Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
fix(generate): account for every planned page and print the actual cost (#2615)
Raghav Chamadiya1374e21bf992
diff --git a/packages/cli/src/repowise/cli/commands/generate_cmd/command.py b/packages/cli/src/repowise/cli/commands/generate_cmd/command.pyindex 1893e9d75..07a94a656 100644--- a/packages/cli/src/repowise/cli/commands/generate_cmd/command.py+++ b/packages/cli/src/repowise/cli/commands/generate_cmd/command.py@@ -301,21 +301,81 @@ def generate_command(_write_state(repo_path, state, provider, outcome)- elapsed = time.monotonic() - start- tail = (- f", {outcome.remaining_template_pages} still unwritten"- if outcome.remaining_template_pages- else " — every page is now written"- )- stale_note = f", {outcome.marked_stale} marked stale" if outcome.marked_stale else ""- console.print(- f"[bold green]Generated {len(outcome.generated_pages)} pages[/bold green] "- f"in {elapsed:.1f}s{stale_note}{tail}."- )+ _report_outcome(outcome, time.monotonic() - start)if embedder_upgraded:_reembed_after_upgrade(repo_path, embedder_name)+def _account_for_plan(+ planned_ids: set[str], generated_pages: list[Any], swept_ids: list[str]+) -> dict[str, int]:+ """Sort every planned page into exactly one outcome bucket."""+ from repowise.core.generation.models import STUB_FALLBACK_ERROR++ counts = {"written": 0, "unchanged": 0, "failed": 0}+ produced: set[str] = set()+ for page in generated_pages:+ produced.add(page.page_id)+ meta = page.metadata or {}+ if STUB_FALLBACK_ERROR in meta:+ counts["failed"] += 1+ elif meta.get("reused_from_prior_run"):+ counts["unchanged"] += 1+ else:+ counts["written"] += 1+ missing = planned_ids - produced+ counts["retired"] = len(missing & set(swept_ids))+ counts["not_produced"] = len(missing) - counts["retired"]+ return counts+++def _report_outcome(outcome: Any, elapsed: float) -> None:+ """Print where every planned page went, the actual cost, and what is left."""+ planned = outcome.plan.generate_ids+ c = _account_for_plan(planned, outcome.generated_pages, outcome.swept_page_ids)+ done = c["written"] + c["unchanged"]+ unchanged = f" ({c['unchanged']} unchanged, no model call)" if c["unchanged"] else ""+ stale_note = f", {outcome.marked_stale} dependents marked stale" if outcome.marked_stale else ""+ console.print(+ f"[bold green]Generated {done} of {len(planned)} planned pages[/bold green]"+ f"{unchanged} in {elapsed:.1f}s{stale_note}."+ )+ rest = [+ f"{c['retired']} retired (merged into pages this run wrote)" if c["retired"] else "",+ f"{c['not_produced']} not produced (the code no longer yields them)"+ if c["not_produced"]+ else "",+ f"{c['failed']} failed (kept as a stub)" if c["failed"] else "",+ ]+ rest = [r for r in rest if r]+ if rest:+ console.print(" Not generated: " + ", ".join(rest) + ".")+ console.print(f"Cost: [bold]${outcome.cost_usd:.3f}[/bold] ({outcome.tokens:,} tokens).")++ if outcome.remaining_template_pages:+ console.print(+ f"[yellow]{outcome.remaining_template_pages} page(s) still unwritten.[/yellow] "+ "Run [cyan]repowise generate --unwritten[/cyan] to write them."+ )+ else:+ console.print("Every concept page is now written.")+ # A planned page the code no longer yields stays stale however often it is+ # retried, so only the rest are pointed at `generate --stale`.+ stuck = outcome.stale_page_ids & (planned - {p.page_id for p in outcome.generated_pages})+ stuck -= set(outcome.swept_page_ids)+ retryable = len(outcome.stale_page_ids) - len(stuck)+ if retryable:+ console.print(+ f"[yellow]{retryable} page(s) still stale.[/yellow] "+ "Run [cyan]repowise generate --stale[/cyan] to regenerate them."+ )+ if stuck:+ console.print(+ f"[dim]{len(stuck)} stale page(s) were not produced this run; "+ "regenerating will not refresh them.[/dim]"+ )++def _reembed_after_upgrade(repo_path: Path, embedder_name: str) -> None:"""Re-embed the whole wiki after the embedder was upgraded off the mock.diff --git a/packages/cli/src/repowise/cli/commands/generate_cmd/engine.py b/packages/cli/src/repowise/cli/commands/generate_cmd/engine.pyindex 6433e808b..fb60ac4e3 100644--- a/packages/cli/src/repowise/cli/commands/generate_cmd/engine.py+++ b/packages/cli/src/repowise/cli/commands/generate_cmd/engine.py@@ -9,7 +9,7 @@ in core so the OSS server and hosted share it.from __future__ import annotations-from dataclasses import dataclass, replace+from dataclasses import dataclass, field, replacefrom pathlib import Pathfrom typing import Any@@ -49,6 +49,11 @@ class GenerateOutcome:marked_stale: intremaining_template_pages: intplan: ScopePlan+ swept_page_ids: list[str] = field(default_factory=list)+ cost_usd: float = 0.0+ tokens: int = 0+ #: Model-written pages still stale after the run.+ stale_page_ids: set[str] = field(default_factory=set)async def run_scoped_generation(@@ -220,20 +225,24 @@ async def run_scoped_generation(concurrency=config.max_concurrency,)- total_pages, remaining_templates = await _page_stats(sf, repo_id)+ total_pages, remaining_templates, stale_ids = await _page_stats(sf, repo_id)return GenerateOutcome(generated_pages=result.generated_pages,total_pages=total_pages,marked_stale=result.marked_stale,remaining_template_pages=remaining_templates,plan=plan,+ swept_page_ids=result.swept_page_ids,+ cost_usd=cost_tracker.session_cost,+ tokens=cost_tracker.session_tokens,+ stale_page_ids=stale_ids,)finally:await engine.dispose()-async def _page_stats(sf: Any, repo_id: str) -> tuple[int, int]:- """Return ``(total_pages, remaining_stub_pages)`` from the DB.+async def _page_stats(sf: Any, repo_id: str) -> tuple[int, int, set[str]]:+ """Return ``(total_pages, remaining_stub_pages, stale_model_page_ids)``.A "stub" is a page a model was meant to write but has not yet: amodel-written page type still stamped ``provider_name='template'``.@@ -271,7 +280,18 @@ async def _page_stats(sf: Any, repo_id: str) -> tuple[int, int]:)).scalar_one())- return total, stubs+ stale_ids = set(+ (+ await session.execute(+ sa_select(Page.id).where(+ Page.repository_id == repo_id,+ Page.freshness_status == "stale",+ Page.page_type.in_(list(_MODEL_WRITTEN_PAGE_TYPES)),+ )+ )+ ).scalars()+ )+ return total, stubs, stale_idsdef _report_plan(plan: ScopePlan, cascade_mode: CascadeMode) -> None:diff --git a/tests/unit/cli/test_generate_outcome_report.py b/tests/unit/cli/test_generate_outcome_report.pynew file mode 100644index 000000000..3b43036f5--- /dev/null+++ b/tests/unit/cli/test_generate_outcome_report.py@@ -0,0 +1,90 @@+"""The generate summary accounts for every planned page and prints the cost."""++from __future__ import annotations++from types import SimpleNamespace+from unittest.mock import patch++from rich.console import Console++from repowise.cli.commands.generate_cmd import command+from repowise.cli.commands.generate_cmd.engine import GenerateOutcome+from repowise.core.generation.models import STUB_FALLBACK_ERROR+++def _page(pid: str, **meta: object) -> SimpleNamespace:+ return SimpleNamespace(page_id=pid, metadata=dict(meta))+++def _render(outcome: GenerateOutcome) -> str:+ rec = Console(record=True, width=300)+ with patch.object(command, "console", rec):+ command._report_outcome(outcome, 12.0)+ return rec.export_text()+++def _outcome(**kw: object) -> GenerateOutcome:+ planned = {f"module_page:m{i}" for i in range(10)}+ base = dict(+ generated_pages=[+ _page("module_page:m0"),+ _page("module_page:m1"),+ _page("module_page:m2", reused_from_prior_run=True),+ _page("module_page:m3", **{STUB_FALLBACK_ERROR: "boom"}),+ ],+ total_pages=40,+ marked_stale=0,+ remaining_template_pages=1,+ plan=SimpleNamespace(generate_ids=planned),+ swept_page_ids=["module_page:m4", "module_page:m5", "module_page:m6", "module_page:gone"],+ cost_usd=0.4321,+ tokens=12345,+ stale_page_ids={"module_page:m7", "module_page:other"},+ )+ base.update(kw)+ return GenerateOutcome(**base) # type: ignore[arg-type]+++def test_account_for_plan_puts_every_planned_page_in_one_bucket() -> None:+ o = _outcome()+ counts = command._account_for_plan(o.plan.generate_ids, o.generated_pages, o.swept_page_ids)+ assert counts == {+ "written": 2,+ "unchanged": 1,+ "failed": 1,+ "retired": 3,+ "not_produced": 3,+ }+ assert sum(counts.values()) == len(o.plan.generate_ids)+++def test_report_names_each_bucket_the_cost_and_next_steps() -> None:+ out = _render(_outcome())+ assert "Generated 3 of 10 planned pages (1 unchanged, no model call) in 12.0s." in out+ assert (+ "Not generated: 3 retired (merged into pages this run wrote), "+ "3 not produced (the code no longer yields them), 1 failed (kept as a stub)."+ ) in out+ assert "Cost: $0.432 (12,345 tokens)." in out+ assert "1 page(s) still unwritten. Run repowise generate --unwritten" in out+ # m7 was planned and not produced, so only the other stale page is retryable.+ assert "1 page(s) still stale. Run repowise generate --stale" in out+ assert "1 stale page(s) were not produced this run" in out+++def test_clean_run_prints_no_leftover_lines() -> None:+ out = _render(+ _outcome(+ generated_pages=[_page(f"module_page:m{i}") for i in range(10)],+ swept_page_ids=[],+ remaining_template_pages=0,+ stale_page_ids=set(),+ cost_usd=0.0,+ tokens=0,+ )+ )+ assert "Generated 10 of 10 planned pages in 12.0s." in out+ assert "Not generated" not in out+ assert "Cost: $0.000 (0 tokens)." in out+ assert "Every concept page is now written." in out+ assert "stale" not in out