wenyi-cli 1.4.2__py3-none-any.whl

wenyi_cli/__init__.py

@@ -0,0 +1,9 @@
+"""Wenyi command-line package for local workflows.
+
+``wenyi_cli.cli`` assembles commands that use the shared core and file storage.
+The package exposes the ``wenyi`` console script and a Python module entry point.
+"""
+
+from .main import app, main
+
+__all__ = ["app", "main"]

wenyi_cli/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+main()

wenyi_cli/cli.py

@@ -0,0 +1,45 @@
+"""Construct the command-line application and expose the installed entry point."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from wenyi_core.observability import configure_logging
+
+from .commands.bootstrap import configure_windows_console, initializing_group, register_bootstrap
+from .commands.context import current_context
+from .commands.glossary import register_glossary_commands
+from .commands.inspection import register_inspection_commands
+from .commands.workflows import register_workflows_commands
+from .model_commands import register_model_commands
+
+
+def create_app(*, console: Console | None = None) -> typer.Typer:
+    """Build an independent application with fresh context on every invocation."""
+    configure_windows_console()
+    configure_logging(service="wenyi-cli")
+    console = console or Console()
+    application = typer.Typer(
+        cls=initializing_group(console),
+        add_completion=False,
+        no_args_is_help=True,
+        help="Multilingual translation workflows for long-form fiction.",
+    )
+    register_bootstrap(application)
+    register_model_commands(application, lambda: current_context().load_config(), console)
+    register_workflows_commands(application, current_context)
+    register_inspection_commands(application, current_context)
+    register_glossary_commands(application, current_context)
+    return application
+
+
+app = create_app()
+
+
+def main() -> None:
+    """Start the Typer command-line application."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

wenyi_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Command registration and terminal presentation helpers."""

wenyi_cli/commands/bootstrap.py

@@ -0,0 +1,108 @@
+"""Early configuration creation, platform console setup and root CLI options."""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Sequence
+from importlib.metadata import version as package_version
+from typing import Any
+
+import typer
+from rich.console import Console
+from typer.core import TyperGroup
+from wenyi_core.config import Config
+
+from .context import CommandContext, current_context
+
+
+def configure_windows_console(
+    streams: tuple[object, ...] | None = None,
+    *,
+    is_windows: bool | None = None,
+) -> None:
+    """Enable Unicode output on Windows, including PyInstaller one-file executables."""
+    if is_windows is None:
+        is_windows = os.name == "nt"
+    if not is_windows:
+        return
+    for stream in streams or (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if callable(reconfigure):
+            try:
+                reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                pass
+
+
+def config_path_from_args(args: Sequence[str]) -> str:
+    """Locate the config before Click parses arguments, including help and early exits."""
+    for index, arg in enumerate(args):
+        if arg in {"--config", "-c"}:
+            if index + 1 < len(args):
+                return args[index + 1]
+            break
+        if arg.startswith("--config="):
+            return arg.partition("=")[2]
+        if arg.startswith("-c") and len(arg) > 2:
+            return arg[2:]
+    return "config.yaml"
+
+
+def initializing_group(console: Console) -> type[TyperGroup]:
+    """Bind application presentation while allocating invocation data anew in main."""
+
+    class ConfigInitializingGroup(TyperGroup):
+        """Check the default configuration before Click dispatches or exits early."""
+
+        def main(
+            self,
+            args: Sequence[str] | None = None,
+            *main_args: Any,
+            **main_kwargs: Any,
+        ) -> Any:
+            """Locate and create a missing default config before Click parses the command."""
+            cli_args = list(args) if args is not None else sys.argv[1:]
+            config_path = config_path_from_args(cli_args)
+            main_kwargs["obj"] = CommandContext(
+                config_path, any(arg in {"--help", "-h"} for arg in cli_args), console
+            )
+            Config.create_default_file(config_path)
+            from wenyi_core.llm.limits import RequestStopped
+
+            try:
+                return super().main(*main_args, args=args, **main_kwargs)
+            except RequestStopped as error:
+                typer.echo(f"Stopped: {error}", err=True)
+                raise SystemExit(1) from None
+
+    return ConfigInitializingGroup
+
+
+def register_bootstrap(app: typer.Typer) -> None:
+    def _version_callback(value: bool) -> None:
+        """Print the installed package version derived from Git tags and exit."""
+        if value:
+            current_context().console.print(package_version("wenyi-cli"))
+            raise typer.Exit()
+
+    @app.callback()
+    def _root(
+        ctx: typer.Context,
+        config: str = typer.Option(
+            "config.yaml",
+            "--config",
+            "-c",
+            help="Configuration path; created automatically if missing",
+        ),
+        version: bool = typer.Option(
+            False,
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show the version and exit",
+        ),
+    ):
+        """Record the config path; workflow commands validate credentials after their overrides."""
+        del version
+        current_context().config_path = config

wenyi_cli/commands/context.py

@@ -0,0 +1,50 @@
+"""Configuration and preflight policy scoped to one Click invocation."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import typer
+import yaml
+from rich.console import Console
+from typer.main import get_current_context
+from wenyi_core.config import Config
+
+
+@dataclass
+class CommandContext:
+    config_path: str
+    skip_api_check: bool
+    console: Console
+
+    def load_config(self) -> Config:
+        """Load the configuration selected for this invocation."""
+        try:
+            return Config.load(self.config_path)
+        except (OSError, ValueError, yaml.YAMLError) as error:
+            self.console.print(f"[red]Configuration error: {error}[/]")
+            raise typer.Exit(1) from None
+
+    def validate_api_configuration(self, config: Config, workflow: str) -> None:
+        """Validate only the connections reachable after command-line overrides."""
+        from wenyi_core.llm.factory import build_client
+        from wenyi_core.llm.operations import configured_operations
+
+        if not self.skip_api_check:
+            try:
+                build_client(config).validate_credentials(configured_operations(config, workflow))
+            except (ValueError, RuntimeError) as error:
+                self.console.print(f"[red]Error: {error}[/]")
+                raise typer.Exit(1) from None
+
+
+ContextAccessor = Callable[[], CommandContext]
+
+
+def current_context() -> CommandContext:
+    """Return the root invocation data, including during eager option callbacks."""
+    context = get_current_context().find_root().obj
+    if not isinstance(context, CommandContext):
+        raise RuntimeError("The CLI invocation has no CommandContext")
+    return context

wenyi_cli/commands/glossary.py

@@ -0,0 +1,104 @@
+"""Register glossary commands with an invocation context accessor."""
+
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+
+from .context import ContextAccessor
+from .validation import (
+    runstore_for_cli,
+)
+
+
+def register_glossary_commands(app: typer.Typer, context: ContextAccessor) -> None:
+    glossary_app = typer.Typer(
+        add_completion=False,
+        no_args_is_help=True,
+        help="Inspect glossary entries, check conflicts and resolve translations.",
+    )
+    app.add_typer(glossary_app, name="glossary", rich_help_panel="Glossary")
+
+    @glossary_app.command("list")
+    def glossary_list(
+        input: str = typer.Argument(..., help="Source file with existing translation state"),
+    ) -> None:
+        """List established glossary translations and their status."""
+        console = context().console
+        from wenyi_core.glossary.store import GlossaryStore
+
+        config = context().load_config()
+        store = runstore_for_cli(config, input, console=console)
+        if not store.exists():
+            console.print("[yellow]No progress found. Run prepare or translate first.[/]")
+            raise typer.Exit(1)
+        g = GlossaryStore(store.glossary_path)
+        try:
+            table = Table("Source", "Translation", "Type", "Status")
+            # all_terms() preserves insertion order for prompt prefix caching.
+            # Sort only this display by type/source; preserve the shared data order.
+            for term in sorted(g.all_terms(), key=lambda t: (t.type, t.source)):
+                table.add_row(
+                    term.source,
+                    term.target,
+                    f"{term.type}{'/' + term.gender if term.gender else ''}",
+                    term.status,
+                )
+            console.print(table)
+        finally:
+            g.close()
+
+    @glossary_app.command("conflicts")
+    def glossary_conflicts(
+        input: str = typer.Argument(..., help="Source file with existing translation state"),
+    ) -> None:
+        """List unresolved translation conflicts discovered during extraction."""
+        console = context().console
+        from wenyi_core.glossary.store import GlossaryStore
+
+        config = context().load_config()
+        store = runstore_for_cli(config, input, console=console)
+        if not store.exists():
+            console.print("[yellow]No progress found. Run translate or prepare first.[/]")
+            raise typer.Exit(1)
+        glossary = GlossaryStore(store.glossary_path)
+        try:
+            conflicts = glossary.open_conflicts()
+            if not conflicts:
+                console.print("No unresolved glossary conflicts.")
+                return
+            for conflict in conflicts:
+                console.print(
+                    f"  {conflict['source']}: existing “{conflict['existing_target']}” vs "
+                    f"proposed “{conflict['proposed_target']}”"
+                    f"(chapter {conflict['chapter']})"
+                )
+        finally:
+            glossary.close()
+
+    @glossary_app.command("resolve")
+    def glossary_resolve(
+        input: str = typer.Argument(..., help="Source file with existing translation state"),
+        source: str = typer.Argument(..., help="Source term to resolve"),
+        target: str = typer.Argument(
+            ..., help="Target translation to use consistently from now on"
+        ),
+    ) -> None:
+        """Resolve an existing term to a chosen translation and close its conflicts."""
+        console = context().console
+        from wenyi_core.glossary import resolver
+        from wenyi_core.glossary.store import GlossaryStore
+
+        config = context().load_config()
+        store = runstore_for_cli(config, input, console=console)
+        if not store.exists():
+            console.print("[yellow]No progress found. Run translate or prepare first.[/]")
+            raise typer.Exit(1)
+        glossary = GlossaryStore(store.glossary_path)
+        try:
+            if not resolver.resolve(glossary, source, target):
+                console.print(f"[red]Term does not exist: {source}[/]")
+                raise typer.Exit(1)
+            console.print(f"Resolved {source} → {target}")
+        finally:
+            glossary.close()

wenyi_cli/commands/inspection.py

@@ -0,0 +1,179 @@
+"""Register inspection commands with an invocation context accessor."""
+
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+from wenyi_core.timing import load_timing
+
+from wenyi_cli.commands import presentation
+
+from .context import ContextAccessor
+from .run_report import build_report
+from .validation import (
+    require_input_file,
+    resolve_output_format,
+    runstore_for_cli,
+)
+
+
+def register_inspection_commands(app: typer.Typer, context: ContextAccessor) -> None:
+    @app.command(rich_help_panel="State and output")
+    def language_policy(
+        source: str | None = typer.Option(
+            None, "--source", help="Resolved source language for preview"
+        ),
+        fmt: str | None = typer.Option(None, "--format", help="Actual export format"),
+        backend: str = typer.Option("native", "--backend", help="native / babeldoc"),
+    ) -> None:
+        """Preview built-in language operations and phase fingerprints without model calls."""
+        from wenyi_core.i18n.languages import require_language
+
+        try:
+            config = context().load_config()
+            if source is not None:
+                config.source_lang = require_language(source, allow_auto=True)
+            preview = config.language_policy_preview(
+                format=fmt or "epub",
+                backend=backend,
+            )
+        except ValueError as error:
+            context().console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+        context().console.print_json(data=preview)
+
+    @app.command(rich_help_panel="State and output")
+    def languages() -> None:
+        """List built-in translation languages (experimental) without calling a model."""
+        console = context().console
+        from wenyi_core.i18n.languages import profile, supported_languages
+        from wenyi_core.i18n.prompts import render
+
+        table = Table("Code", "Language")
+        for code in supported_languages():
+            entry = profile(code)
+            render("translator_system", src="auto", tgt=code)
+            table.add_row(code, entry["english_name"])
+        console.print(table)
+        console.print("Set language.source and language.target; source also accepts auto.")
+
+    @app.command(rich_help_panel="State and output")
+    def status(
+        input: str = typer.Argument(..., help="Source file with existing translation state"),
+    ) -> None:
+        """Show chapter progress and glossary statistics."""
+        console = context().console
+        from wenyi_core.glossary.store import GlossaryStore
+
+        config = context().load_config()
+        store = runstore_for_cli(config, input, console=console)
+        if not store.exists():
+            console.print("[yellow]No progress found. Run prepare or translate first.[/]")
+            raise typer.Exit(1)
+        m = store.load_manifest()
+        console.print(f"“{m['title']}”({m['fmt']})  {m['source_lang']}→{m['target_lang']}")
+        table = Table("", "#", "Chapter", "Translation")
+        for c in m["chapters"]:
+            mark = "✓" if c["status"] == "done" else "·"
+            table.add_row(
+                mark,
+                str(c["index"]),
+                c["title"],
+                c["status"],
+            )
+        console.print(table)
+        g = GlossaryStore(store.glossary_path)
+        console.print("Glossary: ", g.stats())
+        g.close()
+        presentation.print_timing(console, load_timing(store.run_dir))
+
+    @app.command(rich_help_panel="State and output")
+    def inspect_run(
+        input: str = typer.Argument(..., help="Source file with existing translation state"),
+        verbose: bool = typer.Option(False, "--verbose", help="Include the last failure traceback"),
+    ) -> None:
+        """Summarize one run: failures, retries, timing and token usage, read-only."""
+        console = context().console
+        config = context().load_config()
+        store = runstore_for_cli(config, input, console=console)
+        if not store.exists():
+            console.print("[yellow]No progress found. Run prepare or translate first.[/]")
+            raise typer.Exit(1)
+
+        report = build_report(store)
+        console.print(f"Run: [bold]{report['run_dir']}[/]")
+        console.print(
+            f"  Events {report['events']}  Failures {report['failures']}  "
+            f"Retries {report['retries']}  Pauses {report['pauses']}"
+        )
+        failure = report["last_failure"]
+        if failure:
+            # The type is what makes a failure diagnosable; the text alone is not.
+            console.print(
+                f"  Last failure: [red]{failure['error_type'] or 'unknown'}[/] {failure['error'] or ''}"
+            )
+            if verbose and failure.get("traceback"):
+                console.print(failure["traceback"])
+        else:
+            console.print("  Last failure: none")
+
+        usage = report["usage"]
+        if usage:
+            console.print(
+                "  Tokens: "
+                f"in {usage.get('prompt_tokens', 0)}  out {usage.get('completion_tokens', 0)}  "
+                f"cache read {usage.get('cache_hit_tokens', 0)}"
+            )
+        presentation.print_timing(console, report["timing"])
+
+    @app.command(rich_help_panel="State and output")
+    def assemble(
+        input: str = typer.Argument(..., help="Source file with a complete or partial translation"),
+        out: str | None = typer.Option(
+            None,
+            "--out",
+            help="Monolingual output path; defaults to the output directory beside the source",
+        ),
+        fmt: str | None = typer.Option(
+            None,
+            "--format",
+            help="Output format: epub / txt / html / markdown / docx / pdf (BabelDOC only); default: pdf for BabelDOC PDF state, docx for .docx input, epub otherwise",
+        ),
+        mono: bool | None = typer.Option(
+            None,
+            "--mono/--no-mono",
+            help="Override output.mono to enable or disable monolingual output",
+        ),
+        bilingual: bool | None = typer.Option(
+            None,
+            "--bilingual/--no-bilingual",
+            help="Override output.bilingual to enable or disable bilingual output",
+        ),
+    ):
+        """Export translations from existing state without calling a model."""
+        from wenyi_core.models.errors import IngestError
+
+        console = context().console
+        from wenyi_core.llm.providers.fake import FakeClient
+        from wenyi_core.pipeline.orchestrator import Orchestrator
+
+        config = context().load_config()
+        require_input_file(input, console=console)
+        fmt = resolve_output_format(input, fmt, console=console)
+        if mono is not None:
+            config.output.mono = mono
+        if bilingual is not None:
+            config.output.bilingual = bilingual
+        try:
+            result = Orchestrator(config, client=FakeClient()).run_assemble(
+                input,
+                out_format=fmt,
+                out_path=out,
+            )
+        except (IngestError, OSError, ValueError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+        paths = result["outputs"]
+        presentation.print_timing(console, load_timing(result["store"].run_dir))
+        for path in paths:
+            console.print(f"Translation written: [bold]{path}[/]")

wenyi_cli/commands/machine_output.py

@@ -0,0 +1,102 @@
+"""Atomic, versioned CLI receipts for external process supervisors."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from uuid import uuid4
+
+from wenyi_core.atomicio import publish_bytes
+
+
+def file_digest(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+class MachineOutput:
+    """Publish progress and receipts without exposing configuration or model responses."""
+
+    def __init__(
+        self,
+        progress_path: str | None,
+        result_path: str | None,
+        *,
+        source: str,
+        config: str,
+        output: str | None,
+    ) -> None:
+        self.progress_path = Path(progress_path).resolve() if progress_path else None
+        self.result_path = Path(result_path).resolve() if result_path else None
+        self.source = Path(source).resolve()
+        self.run_id = uuid4().hex
+        self.completed = False
+        paths = [path for path in (self.progress_path, self.result_path) if path is not None]
+        protected = {self.source, Path(config).resolve()}
+        if output:
+            protected.add(Path(output).resolve())
+        if len(set(paths)) != len(paths) or protected.intersection(paths):
+            raise ValueError("Machine output paths must be distinct from source, config and output")
+
+    @property
+    def enabled(self) -> bool:
+        return self.progress_path is not None or self.result_path is not None
+
+    def _write(self, path: Path | None, **data) -> None:
+        if path is None:
+            return
+        payload = {
+            "protocol_version": 1,
+            "run_id": self.run_id,
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+            **data,
+        }
+        publish_bytes(path, json.dumps(payload, ensure_ascii=False).encode("utf-8"))
+
+    def start(self) -> None:
+        # Replace an old receipt before preflight so it cannot masquerade as this run.
+        self._write(self.result_path, status="running", outputs=[])
+        self(0, 0, "Starting Wenyi")
+
+    def __call__(self, done: int, total: int, label: str) -> None:
+        self._write(
+            self.progress_path,
+            status="running",
+            done=done,
+            total=total if total > 0 else None,
+            label=label,
+        )
+
+    def success(self, paths: list[str], state_dir: str) -> None:
+        if not self.enabled:
+            self.completed = True
+            return
+        outputs = []
+        for name in paths:
+            path = Path(name).resolve()
+            outputs.append(
+                {"path": str(path), "size": path.stat().st_size, "sha256": file_digest(path)}
+            )
+        self._write(
+            self.result_path,
+            status="success",
+            source_sha256=file_digest(self.source),
+            state_dir=str(Path(state_dir).resolve()),
+            outputs=outputs,
+        )
+        self._write(self.progress_path, status="success", done=1, total=1, label="Completed")
+        self.completed = True
+
+    def failed(self) -> None:
+        self._write(
+            self.result_path,
+            status="failed",
+            outputs=[],
+            error={"code": "translation_failed", "message": "See the Wenyi log for details."},
+        )
+        self._write(self.progress_path, status="failed", done=0, total=None, label="Stopped")