Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

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.py
index 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.py
index 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, replace
from pathlib import Path
from typing import Any
@@ -49,6 +49,11 @@ class GenerateOutcome:
marked_stale: int
remaining_template_pages: int
plan: 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: a
model-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_ids
def _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.py
new file mode 100644
index 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