wenyi-cli 1.4.2__py3-none-any.whl

wenyi_cli/commands/presentation.py

@@ -0,0 +1,139 @@
+"""Display workflow summaries from supplied data without accessing run state."""
+
+from typing import Any
+
+from rich.console import Console
+from wenyi_core.timing import format_duration
+
+
+def print_timing(console: Console, timing: dict[str, Any] | None) -> None:
+    """Show the last invocation and accumulated execution time, including failed runs."""
+    if timing is None:
+        return
+    last = timing["runs"][-1]
+    count = len(timing["runs"])
+    console.print(
+        f"Time: last run {format_duration(last['elapsed_seconds'])} ({last['status']}), "
+        f"cumulative {format_duration(timing['total_seconds'])} across {count} "
+        f"{'run' if count == 1 else 'runs'}.",
+        highlight=False,
+    )
+
+
+def _cache_description(slot: dict[str, Any]) -> str:
+    """Describe cache coverage without reinterpreting legacy misses as ordinary input."""
+    hit = slot.get("cache_hit_tokens", 0)
+    prompt = slot.get("prompt_tokens", 0)
+    known_read = hit or slot.get("cache_hit_reported_calls")
+    rate = f"{hit / prompt:.1%}" if prompt and known_read else "unknown"
+    write = slot.get("cache_write_tokens", 0)
+    ordinary = slot.get("uncached_tokens", 0)
+    unknown = slot.get("cache_unknown_tokens", max(0, prompt - hit - write - ordinary))
+
+    def counter(field: str, presence: str) -> str:
+        value = slot.get(field, 0)
+        return f"{value:,}" if value or slot.get(presence) else "unknown"
+
+    description = (
+        f"cache read / all input {rate}"
+        f" (read {f'{hit:,}' if known_read else 'unknown'}"
+        f" / write {counter('cache_write_tokens', 'cache_write_reported_calls')}"
+        f" / ordinary {counter('uncached_tokens', 'uncached_reported_calls')}"
+        f" / unknown {unknown:,} tok)"
+    )
+    if slot.get("cache_write_5m_reported_calls") or slot.get("cache_write_1h_reported_calls"):
+        description += (
+            f" [write TTL: 5m {counter('cache_write_5m_tokens', 'cache_write_5m_reported_calls')}"
+            f" / 1h {counter('cache_write_1h_tokens', 'cache_write_1h_reported_calls')} tok]"
+        )
+    return description
+
+
+def print_usage(console: Console, usage: dict[str, Any] | None) -> None:
+    """Print cumulative usage with an all-input denominator and unknown coverage."""
+    usage = usage or {}
+    totals = usage.get("totals") or {}
+    if not totals.get("total_tokens"):
+        return
+    console.print(
+        f"Usage (book total): {totals['total_tokens']:,} tok"
+        f" (prompt {totals['prompt_tokens']:,} / completion {totals['completion_tokens']:,}), "
+        f"{_cache_description(totals)}",
+        markup=False,
+    )
+    for tier, v in sorted(usage.get("by_tier", {}).items()):
+        console.print(
+            f"  · {tier}: {v['total_tokens']:,} tok, {v['calls']} calls, {_cache_description(v)}",
+            markup=False,
+        )
+    for stage, v in sorted(
+        (usage.get("by_stage") or {}).items(),
+        key=lambda item: -item[1]["total_tokens"],
+    ):
+        console.print(
+            f"  · Stage {stage}: {v['total_tokens']:,} tok"
+            f" (prompt {v['prompt_tokens']:,} / completion {v['completion_tokens']:,}), "
+            f"{v['calls']} calls, {_cache_description(v)}",
+            markup=False,
+        )
+
+    for identity, value in sorted((usage.get("by_model") or {}).items()):
+        label = (usage.get("labels") or {}).get(identity, identity)
+        console.print(f"  · Model {label}: {value['total_tokens']:,} tok, {value['calls']} calls")
+
+
+def print_review_summary(console: Console, review_result: dict[str, Any], run_dir: str) -> None:
+    """Show standalone Review completion and publication results."""
+    summary = review_result["summary"]
+    console.print(
+        f"[bold green]Whole-book agent review complete[/]: {review_result['termination']}, "
+        f"Remaining issues: {summary['issue_count']}, "
+        f"suggested changes: {summary['change_count']}."
+    )
+    autofix_result = review_result.get("autofix") or {}
+    if autofix_result.get("enabled"):
+        console.print(
+            f"Autofix: published {autofix_result.get('applied_segment_count', 0)} paragraphs, "
+            f"failed issues: {autofix_result.get('failed_issue_count', 0)}."
+        )
+    else:
+        console.print(
+            "Review produced recommendations only; formal chapter translations are unchanged."
+        )
+    console.print(f"Review directory: {run_dir}")
+
+
+def print_review_details(
+    console: Console, review_result: dict[str, Any] | None, run_dir: str
+) -> None:
+    """Show review details after the full translation workflow."""
+    review_result = review_result or {}
+    review_summary = review_result.get("summary") or {}
+    console.print(
+        f"Review result: {review_result.get('termination', 'unknown')}, "
+        f"issues: {review_summary.get('issue_count', 0)}, "
+        f"suggested changes: {review_summary.get('change_count', 0)}."
+    )
+    console.print(f"Review directory: {run_dir}")
+
+
+def print_preparation_summary(
+    console: Console, *, chapter_count: int, digest_count: int, has_synopsis: bool, run_dir: str
+) -> None:
+    """Show saved preparation coverage and the next workflow command."""
+    console.print(
+        f"[bold green]Preparation complete[/]: Parsed {chapter_count} chapters, "
+        f"prescanned {digest_count}/{chapter_count} chapters, "
+        f"Whole-book synopsis{' generated' if has_synopsis else ' unavailable'}."
+    )
+    console.print(f"State directory: [bold]{run_dir}[/]")
+    console.print("Run translate with the same source file to continue the full translation.")
+
+
+def print_translation_summary(
+    console: Console, *, chapters_done: int, chapters_total: int, terms: int
+) -> None:
+    """Show complete book chapter and terminology counts."""
+    console.print(
+        f"[bold green]Complete[/]: {chapters_done}/{chapters_total} chapters, terms: {terms}."
+    )

wenyi_cli/commands/progress.py

@@ -0,0 +1,92 @@
+"""Render workflow stages without resetting the overall invocation clock."""
+
+from rich.cells import cell_len, set_cell_size
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    ProgressColumn,
+    SpinnerColumn,
+    Task,
+    TextColumn,
+    TimeElapsedColumn,
+)
+from rich.table import Column
+from rich.text import Text
+from wenyi_core.timing import format_duration
+
+_PROGRESS_DESCRIPTION_WIDTH = 28
+
+
+def _short_progress_description(label: str) -> str:
+    """Truncate long titles by terminal cell width and keep an ellipsis when clipped."""
+    if cell_len(label) <= _PROGRESS_DESCRIPTION_WIDTH:
+        return label
+    prefix = set_cell_size(label, _PROGRESS_DESCRIPTION_WIDTH - 1).rstrip()
+    return f"{prefix}…"
+
+
+class WorkflowElapsedColumn(TimeElapsedColumn):
+    """Keep elapsed time advancing across stages, including completed-stage waits."""
+
+    def render(self, task: Task) -> Text:
+        started = task.fields.get("workflow_started", task.start_time)
+        elapsed = 0.0 if started is None else task.get_time() - started
+        return Text(format_duration(elapsed), style="progress.elapsed")
+
+
+def progress_columns() -> tuple[ProgressColumn, ...]:
+    """Build Rich columns that keep long stage names from hiding the bar."""
+    description_column = Column(
+        max_width=_PROGRESS_DESCRIPTION_WIDTH,
+        no_wrap=True,
+        overflow="ellipsis",
+    )
+    return (
+        SpinnerColumn(),
+        TextColumn(
+            "[progress.description]{task.description}",
+            table_column=description_column,
+        ),
+        BarColumn(),
+        MofNCompleteColumn(),
+        WorkflowElapsedColumn(),
+    )
+
+
+class RichProgressBridge:
+    """Map pipeline stage progress onto one Rich task."""
+
+    def __init__(self, progress: Progress, initial_description: str) -> None:
+        self.progress = progress
+        self._started = progress.get_time()
+        self.task = progress.add_task(
+            _short_progress_description(initial_description),
+            total=None,
+            workflow_started=self._started,
+        )
+        self._stage: tuple[str, int | None] = (initial_description, None)
+
+    def __call__(self, done: int, total: int, label: str) -> None:
+        """Refresh the current stage and counts without accumulating progress bars."""
+        stage = (label, total if total > 0 else None)
+        short = _short_progress_description(label)
+        if total > 0:
+            if stage != self._stage:
+                # A completed Rich task retains its finished time until reset.
+                self.progress.reset(self.task, total=total, completed=done, description=short)
+            self._stage = stage
+            self.progress.update(
+                self.task,
+                completed=done,
+                total=total,
+                description=short,
+            )
+            return
+        if stage == self._stage:
+            return
+        # Rich update(total=None) leaves the total unchanged. Recreate the task
+        # to restore indeterminate progress and clear the previous stage’s counts.
+        self.progress.remove_task(self.task)
+        self.task = self.progress.add_task(short, total=None, workflow_started=self._started)
+        self._stage = stage

wenyi_cli/commands/run_report.py

@@ -0,0 +1,103 @@
+"""Aggregate one run's timing, usage and failure events into a single report."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from wenyi_core.timing import load_timing
+
+
+def _read_events(path: str) -> list[dict[str, Any]]:
+    """Read the append-only log, skipping a torn final line.
+
+    Records are appended with ``ensure_ascii=False``, so an interrupted write can tear a
+    multi-byte character in half; strict text-mode decoding would then raise before any
+    record is read (audit Z-2/H-2). Read bytes and drop undecodable lines instead.
+    """
+    if not os.path.isfile(path):
+        return []
+    events: list[dict[str, Any]] = []
+    with open(path, "rb") as handle:
+        raw = handle.read()
+    for line in raw.split(b"\n"):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            text = line.decode("utf-8")
+        except UnicodeDecodeError:
+            # Torn multi-byte append: the earlier records are still valid.
+            continue
+        try:
+            events.append(json.loads(text))
+        except json.JSONDecodeError:
+            continue
+    return events
+
+
+def _usage_totals(usage: dict[str, Any] | None) -> dict[str, Any]:
+    """Return the ledger totals; the ledger already sums them by tier."""
+    if not usage or not isinstance(usage, dict):
+        return {}
+    totals = usage.get("totals")
+    return dict(totals) if isinstance(totals, dict) else {}
+
+
+def _crashed_step_events(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Return ``run_steps_started`` events whose steps never finished.
+
+    CLI/Core pipelines never emit the backend runner's ``pipeline_error`` events; on the
+    CLI a failed run is a step that started but has no matching ``run_steps_finished``
+    (audit Z-2/H-1). Resume invocations restart the step list, so finished steps from
+    any invocation count as done.
+    """
+    finished_steps: set[str] = set()
+    started_events: list[dict[str, Any]] = []
+    for event in events:
+        name = event.get("event")
+        steps = event.get("steps")
+        if not isinstance(steps, list):
+            continue
+        if name == "run_steps_started":
+            started_events.append(event)
+        elif name == "run_steps_finished":
+            finished_steps.update(step for step in steps if isinstance(step, str))
+    return [
+        event
+        for event in started_events
+        if not {step for step in event.get("steps") or [] if isinstance(step, str)}
+        <= finished_steps
+    ]
+
+
+def build_report(store) -> dict[str, Any]:
+    """Collect what a failed or slow run would need to explain itself."""
+    events = _read_events(store.event_log_path)
+    failures = [event for event in events if event.get("event") == "pipeline_error"]
+    failures.extend(_crashed_step_events(events))
+    retries = [event for event in events if str(event.get("event", "")).startswith("llm_retry")]
+    exhausted = [event for event in events if event.get("event") == "llm_retry_exhausted"]
+    paused = [event for event in events if event.get("event") == "task_paused"]
+    timing = load_timing(store.run_dir)
+    usage = store.load_usage()
+
+    last_failure = exhausted[-1] if exhausted else (failures[-1] if failures else None)
+    return {
+        "run_dir": store.run_dir,
+        "events": len(events),
+        "failures": len(failures),
+        "retries": len(retries),
+        "pauses": len(paused),
+        "last_failure": {
+            "error_type": last_failure.get("error_type"),
+            "error": last_failure.get("error"),
+            "run_id": last_failure.get("run_id"),
+            "traceback": last_failure.get("traceback"),
+        }
+        if last_failure
+        else None,
+        "timing": timing,
+        "usage": _usage_totals(usage),
+    }

wenyi_cli/commands/validation.py

@@ -0,0 +1,97 @@
+"""Shared input, backend, format and existing-state validation for CLI commands."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+import typer
+from rich.console import Console
+from wenyi_core.i18n.languages import validate_run_languages
+
+if TYPE_CHECKING:
+    from wenyi_core.config import Config
+    from wenyi_core.storage.run_store import RunStore
+
+
+def load_document(*args, **kwargs):
+    """Defer the ingest stack while keeping a patchable module attribute.
+
+    Callers and tests have always reached this name through the module, so the
+    import stays behind the call rather than moving out of the namespace.
+    """
+    from wenyi_core.ingest.segmenter import load_document as parse
+
+    return parse(*args, **kwargs)
+
+
+def require_input_file(input_path: str, *, console: Console | None = None) -> None:
+    """Require an input file, otherwise report the error and exit with status 1."""
+    console = console or Console()
+    if not os.path.isfile(input_path):
+        console.print(f"[red]Input file does not exist: {input_path}[/]")
+        raise typer.Exit(1)
+
+
+def validate_output_format(fmt: str, *, console: Console | None = None) -> str:
+    """Normalize and validate the requested output format."""
+    console = console or Console()
+    normalized = fmt.strip().lower()
+    allowed = {"epub", "txt", "html", "markdown", "pdf", "docx"}
+    if normalized not in allowed:
+        console.print(
+            f"[red]Unsupported output format: {fmt} (choose epub / txt / html / markdown / pdf / docx)[/]"
+        )
+        raise typer.Exit(2)
+    return normalized
+
+
+def resolve_output_format(
+    input_path: str, fmt: str | None, *, console: Console | None = None
+) -> str | None:
+    """Defer PDF defaults to saved backend metadata; keep DOCX and EPUB defaults."""
+    console = console or Console()
+    if fmt is not None and str(fmt).strip():
+        return validate_output_format(str(fmt), console=console)
+    if os.path.splitext(input_path)[1].lower() == ".pdf":
+        return None
+    if os.path.splitext(input_path)[1].lower() == ".docx":
+        return "docx"
+    return "epub"
+
+
+def runstore_for(config: Config, input_path: str, *, console: Console | None = None) -> RunStore:
+    """Resolve the title and locate existing state without creating a directory."""
+    # Deferred: reading a title pulls the ingest stack (bs4/lxml) in; --help
+    # must not pay for that.
+    from wenyi_core.storage.run_store import RunStore, translation_run_dir
+
+    console = console or Console()
+    require_input_file(input_path, console=console)
+    if os.path.splitext(input_path)[1].lower() == ".pdf":
+        title = os.path.splitext(os.path.basename(input_path))[0]
+        run_dir = translation_run_dir(config.state_dir, title, config.target_lang)
+        store = RunStore(run_dir, create=False)
+    else:
+        doc = load_document(input_path, config.source_lang, config.target_lang)
+        run_dir = translation_run_dir(config.state_dir, doc.title, config.target_lang)
+        store = RunStore(run_dir, create=False)
+    if store.exists():
+        with store.lock():
+            validate_run_languages(store.load_manifest(), config.source_lang, config.target_lang)
+            store.ensure_source_identity(input_path)
+    return store
+
+
+def runstore_for_cli(
+    config: Config, input_path: str, *, console: Console | None = None
+) -> RunStore:
+    # Deferred with the ingest stack; the base error class drags it in.
+    from wenyi_core.models.errors import IngestError
+
+    console = console or Console()
+    try:
+        return runstore_for(config, input_path, console=console)
+    except (IngestError, OSError, ValueError) as error:
+        console.print(f"[red]Error: {error}[/]")
+        raise typer.Exit(1) from None