alysis-code 0.13.0__py3-none-any.whl

alysis_code/cli_impl/commands/cli_surface.py

@@ -0,0 +1,77 @@
+# ruff: noqa: F401,F403,F405,I001
+from __future__ import annotations
+
+from . import cli_common as _cli_common
+from . import chat_state as _chat_state
+from . import startup as _startup
+from . import chat_terminal as _chat_terminal
+from . import welcome as _welcome
+from . import chat_resume_helpers as _chat_resume_helpers
+from . import chat_status as _chat_status
+from . import forge_helpers as _forge_helpers
+from . import execution_helpers as _execution_helpers
+from . import prompt_helpers as _prompt_helpers
+from . import update as _update
+
+from .cli_common import *
+from .chat_state import *
+from .startup import *
+from .chat_terminal import *
+from .welcome import *
+from .chat_resume_helpers import *
+from .chat_status import *
+from .forge_helpers import *
+from .execution_helpers import *
+from .prompt_helpers import *
+from .update import *
+
+_CLI_SURFACE_MODULES = (
+    _cli_common,
+    _chat_state,
+    _startup,
+    _chat_terminal,
+    _welcome,
+    _chat_resume_helpers,
+    _chat_status,
+    _forge_helpers,
+    _execution_helpers,
+    _prompt_helpers,
+    _update,
+)
+
+_CLI_SURFACE_INTERNAL_NAMES = {
+    "_CLI_SURFACE_INTERNAL_NAMES",
+    "_CLI_SURFACE_MODULES",
+    "_chat_resume_helpers",
+    "_chat_state",
+    "_chat_status",
+    "_chat_terminal",
+    "_cli_common",
+    "_execution_helpers",
+    "_forge_helpers",
+    "_prompt_helpers",
+    "_startup",
+    "_sync_module_globals",
+    "_update",
+    "_welcome",
+}
+
+
+def _sync_module_globals() -> None:
+    surface_globals = globals()
+    for module in _CLI_SURFACE_MODULES:
+        module_globals = module.__dict__
+        for name, value in surface_globals.items():
+            if name.startswith("__") or name in _CLI_SURFACE_INTERNAL_NAMES:
+                continue
+            module_globals[name] = value
+
+
+_sync_module_globals()
+
+__all__ = [
+    name
+    for name in globals()
+    if (not name.startswith("__") or name == "__version__")
+    and name not in _CLI_SURFACE_INTERNAL_NAMES
+]

alysis_code/cli_impl/commands/config.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import typer
+
+from ...branding import env_get
+from ...config import (
+    ConfigError,
+    clear_persisted_api_key,
+    config_path,
+    credentials_path,
+    ensure_subscription_menu_managed_key,
+    load_config,
+    resolve_api_key,
+    save_config,
+    save_persisted_api_key,
+    set_config_value,
+)
+from . import _patchable
+from ._shared import _console
+
+config_app = typer.Typer(add_completion=False, help="Configuration commands.")
+
+
+@config_app.command("show")
+def config_show() -> None:
+    console = _console()
+    cfg = _patchable("load_config", load_config)()
+    data = cfg.model_dump()
+    data["config_path"] = os.fspath(config_path())
+    api_key = _patchable("resolve_api_key", resolve_api_key)()
+    data["api_key_set"] = bool(api_key.key)
+    data["api_key_source"] = "stored" if api_key.source == "stored:legacy" else api_key.source
+    data["credentials_path"] = os.fspath(credentials_path())
+    data["active_profile"] = str((cfg.extra_fields or {}).get("active_profile") or "")
+    role_models = (cfg.extra_fields or {}).get("role_models")
+    forge_role_models = (cfg.extra_fields or {}).get("forge_role_models")
+    data["role_models"] = dict(role_models) if isinstance(role_models, dict) else {}
+    data["forge_role_models"] = (
+        dict(forge_role_models) if isinstance(forge_role_models, dict) else {}
+    )
+    console.print_json(json.dumps(data))
+
+
+@config_app.command("menu")
+def config_menu_cmd() -> None:
+    """Open the inline configuration menu."""
+    from ..config_menu import run_config_menu
+
+    result = run_config_menu()
+    if result.saved:
+        n = len(result.changes) + (1 if result.api_key_changed else 0)
+        typer.echo(f"Saved {n} change(s).")
+        return
+    typer.echo("Cancelled — no changes saved.")
+
+
+@config_app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Key to set."),
+    value: str = typer.Argument(..., help="Value to set."),
+) -> None:
+    console = _console()
+    cfg = _patchable("load_config", load_config)()
+    try:
+        ensure_subscription_menu_managed_key(cfg, key)
+        cfg = set_config_value(cfg, key, value)
+        save_config(cfg)
+    except ConfigError as e:
+        console.print(f"[red]Config error:[/red] {e}")
+        raise typer.Exit(code=2) from e
+    console.print(f"Saved {key} in {config_path()}")
+
+
+@config_app.command("set-api-key")
+def config_set_api_key(
+    env_var: str | None = typer.Option(
+        None,
+        "--env-var",
+        help="Copy the API key from this environment variable.",
+    ),
+    stdin: bool = typer.Option(
+        False,
+        "--stdin",
+        help="Read the API key from standard input.",
+    ),
+) -> None:
+    console = _console()
+    if env_var and stdin:
+        console.print("[red]Config error:[/red] Use either --env-var or --stdin, not both.")
+        raise typer.Exit(code=2)
+
+    if env_var:
+        env_name = env_var.strip()
+        if not env_name:
+            console.print("[red]Config error:[/red] --env-var must be non-empty.")
+            raise typer.Exit(code=2)
+        key = str(env_get(env_name) or "").strip()
+        if not key:
+            console.print(f"[red]Config error:[/red] Environment variable {env_name} is not set.")
+            raise typer.Exit(code=2)
+    elif stdin:
+        key = sys.stdin.read().strip()
+        if not key:
+            console.print("[red]Config error:[/red] API key is empty.")
+            raise typer.Exit(code=2)
+    else:
+        key = typer.prompt("API key", hide_input=True).strip()
+        if not key:
+            console.print("[red]Config error:[/red] API key is empty.")
+            raise typer.Exit(code=2)
+
+    try:
+        save_persisted_api_key(key)
+    except ConfigError as e:
+        console.print(f"[red]Config error:[/red] {e}")
+        raise typer.Exit(code=2) from e
+    console.print(f"Saved API key in {credentials_path()}")
+
+
+@config_app.command("clear-api-key")
+def config_clear_api_key() -> None:
+    console = _console()
+    removed = clear_persisted_api_key()
+    if removed:
+        console.print(f"Removed persisted API key from {credentials_path()}")
+        return
+    console.print(f"No persisted API key found at {credentials_path()}")

alysis_code/cli_impl/commands/conventions.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from ...skills import load_repo_conventions, render_repo_conventions_context
+from ._shared import _console, _resolve_tool_workspace_root, _Table
+
+conventions_app = typer.Typer(
+    add_completion=False,
+    help="Repo conventions diagnostics for AGENTS.md / CLAUDE.md / CONVENTIONS.md.",
+)
+
+
+@conventions_app.command("list")
+def conventions_list(
+    path: Path = typer.Option(Path("."), "--path", help="Workspace, repository, or file path."),
+) -> None:
+    console = _console()
+    focus_path = path.expanduser().resolve()
+    workspace_root = _resolve_tool_workspace_root(
+        path=focus_path if focus_path.is_dir() else focus_path.parent
+    )
+    documents = load_repo_conventions(
+        focus_path=focus_path,
+        workspace_root=workspace_root,
+    )
+    console.print(f"[dim]Workspace root:[/dim] {workspace_root.as_posix()}")
+    console.print(f"[dim]Focus path:[/dim] {focus_path.as_posix()}")
+    if not documents:
+        console.print("No repo conventions found.")
+        return
+
+    table = _Table(title="Repo Conventions")
+    table.add_column("priority")
+    table.add_column("name")
+    table.add_column("trust")
+    table.add_column("chars")
+    table.add_column("path")
+    for priority, document in enumerate(documents, start=1):
+        try:
+            display_path = document.path.relative_to(workspace_root).as_posix()
+        except ValueError:
+            display_path = document.path.as_posix()
+        table.add_row(
+            str(priority),
+            document.name,
+            document.trust_level,
+            str(len(document.content)),
+            display_path,
+        )
+    console.print(table)
+    console.print("[dim]Priority order is highest precedence first within repo conventions.[/dim]")
+
+
+@conventions_app.command("render")
+def conventions_render(
+    path: Path = typer.Option(Path("."), "--path", help="Workspace, repository, or file path."),
+    max_chars: int = typer.Option(
+        4000,
+        "--max-chars",
+        min=256,
+        help="Maximum rendered repo-conventions context size.",
+    ),
+) -> None:
+    console = _console()
+    focus_path = path.expanduser().resolve()
+    workspace_root = _resolve_tool_workspace_root(
+        path=focus_path if focus_path.is_dir() else focus_path.parent
+    )
+    documents = load_repo_conventions(
+        focus_path=focus_path,
+        workspace_root=workspace_root,
+    )
+    rendered = render_repo_conventions_context(
+        documents=documents,
+        max_chars=max_chars,
+    )
+    console.print(f"[dim]Workspace root:[/dim] {workspace_root.as_posix()}")
+    console.print(f"[dim]Focus path:[/dim] {focus_path.as_posix()}")
+    if rendered is None:
+        console.print("No repo conventions found.")
+        return
+    console.print(rendered, end="")

alysis_code/cli_impl/commands/execution_helpers.py

@@ -0,0 +1,350 @@
+# ruff: noqa: F401,F403,F405,I001
+# Legacy split module: dependencies are synced by cli_surface.py.
+from __future__ import annotations
+
+from ...task_dependencies import infer_ordered_predecessor_dependency
+from .cli_common import *
+
+
+def _snapshot_workspace_tree(root: Path) -> dict[str, str]:
+    return _shared_snapshot_workspace_tree(root)
+
+
+def _capture_task_local_workspace_baseline(
+    root: Path,
+    *,
+    before_commit: str | None,
+) -> Any:
+    return _shared_capture_task_local_workspace_baseline(
+        root,
+        before_commit=before_commit,
+    )
+
+
+def _cleanup_task_local_workspace_baseline(baseline: Any) -> None:
+    _shared_cleanup_task_local_workspace_baseline(baseline)
+
+
+def _git_diff_text(root: Path) -> str | None:
+    if shutil.which("git") is None:
+        return None
+    proc = subprocess.run(
+        ["git", "-C", os.fspath(root), "diff"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        return None
+    return proc.stdout
+
+
+def _git_changed_files(root: Path) -> list[str]:
+    return _shared_git_changed_files(root)
+
+
+def _build_execution_reporting_diff(root: Path) -> Any:
+    return _shared_build_execution_reporting_diff(root)
+
+
+def _build_execution_reporting_diff_with_commit_range(
+    root: Path,
+    *,
+    before_commit: str | None,
+    after_commit: str | None,
+) -> Any:
+    return _shared_build_execution_reporting_diff_with_commit_range(
+        root,
+        before_commit=before_commit,
+        after_commit=after_commit,
+    )
+
+
+def _build_workspace_snapshot_reporting_diff(
+    root: Path,
+    *,
+    before_snapshot: dict[str, str],
+    after_snapshot: dict[str, str],
+) -> Any:
+    return _shared_build_workspace_snapshot_reporting_diff(
+        root,
+        before_snapshot=before_snapshot,
+        after_snapshot=after_snapshot,
+    )
+
+
+def _build_task_local_workspace_reporting_diff(
+    root: Path,
+    *,
+    baseline: Any,
+    after_commit: str | None,
+) -> Any:
+    return _shared_build_task_local_workspace_reporting_diff(
+        root,
+        baseline=baseline,
+        after_commit=after_commit,
+    )
+
+
+def _snapshot_session_logs(cfg: AppConfig) -> set[Path]:
+    return _shared_snapshot_session_logs(cfg)
+
+
+def _execution_private_sessions_dir(
+    *,
+    cfg: AppConfig,
+    run_id: str,
+    task_id: str,
+    workspace_root: Path,
+) -> Path:
+    return _shared_execution_private_sessions_dir(
+        cfg=cfg,
+        run_id=run_id,
+        task_id=task_id,
+        workspace_root=workspace_root,
+    )
+
+
+def _cleanup_execution_private_sessions_dir(path: Path) -> None:
+    _shared_cleanup_execution_private_sessions_dir(path)
+
+
+def _write_exec_log_artifacts(
+    *,
+    paths: Any,
+    task_id: str,
+    cfg: AppConfig,
+    no_log: bool,
+    before_logs: set[Path] | None,
+    sessions_dir: Path | None = None,
+    expected_session_id: str | None = None,
+) -> Any:
+    return _shared_write_exec_log_artifacts(
+        paths=paths,
+        task_id=task_id,
+        cfg=cfg,
+        no_log=no_log,
+        before_logs=before_logs,
+        sessions_dir=sessions_dir,
+        expected_session_id=expected_session_id,
+    )
+
+
+def _write_execution_context_artifact(
+    *,
+    paths: Any,
+    task_id: str,
+    context_text: str,
+) -> Path:
+    return _shared_write_execution_context_artifact(
+        run_paths=paths,
+        task_id=task_id,
+        context_text=context_text,
+    )
+
+
+def _write_execution_budget_artifact(
+    *,
+    paths: Any,
+    task_id: str,
+    payload: dict[str, Any],
+) -> Path:
+    return _shared_write_execution_budget_artifact(
+        run_paths=paths,
+        task_id=task_id,
+        payload=payload,
+    )
+
+
+def _resolve_managed_task_step_budget(
+    *,
+    cfg: AppConfig,
+    plan: dict[str, Any],
+    task: dict[str, Any],
+    kind: str = "managed_task",
+    mode: str | None = None,
+    verification_enabled: bool,
+    max_steps_override: int | None = None,
+    attempt_count: int | None = None,
+    image_count: int = 0,
+    conflict_file_count: int = 0,
+):
+    return _shared_resolve_managed_task_step_budget(
+        cfg=cfg,
+        plan=plan,
+        task=task,
+        kind=kind,
+        mode=mode,
+        verification_enabled=verification_enabled,
+        max_steps_override=max_steps_override,
+        attempt_count=attempt_count,
+        image_count=image_count,
+        conflict_file_count=conflict_file_count,
+    )
+
+
+def _prepare_task_execution_knowledge(
+    *,
+    run_paths: RunPaths,
+    task: dict[str, Any],
+    selection_label: str,
+    extra_paths: list[str] | None = None,
+    limit: int = 4,
+) -> Any:
+    return _shared_prepare_task_execution_knowledge(
+        run_paths=run_paths,
+        task=task,
+        selection_label=selection_label,
+        extra_paths=extra_paths,
+        limit=limit,
+    )
+
+
+def _mirror_selected_knowledge_into_worktree(
+    *,
+    materialized: Any,
+    run_paths: RunPaths,
+    worktree_repo_path: Path,
+) -> None:
+    _shared_mirror_selected_knowledge_into_worktree(
+        materialized=materialized,
+        run_paths=run_paths,
+        worktree_repo_path=worktree_repo_path,
+    )
+
+
+def _task_dependency_blockers(plan: dict[str, Any], task: dict[str, Any]) -> list[str]:
+    blockers: list[str] = []
+    deps = task.get("dependencies") or []
+    for dep_id in deps:
+        dep_task = find_task(plan, str(dep_id))
+        if dep_task is None:
+            blockers.append(f"{dep_id} (missing)")
+            continue
+        dep_status = str(dep_task.get("status") or "")
+        if dep_status != "done":
+            blockers.append(f"{dep_id} ({dep_status or 'unknown'})")
+    tasks = [item for item in plan.get("tasks") or [] if isinstance(item, dict)]
+    inferred = infer_ordered_predecessor_dependency(tasks=tasks, task=task)
+    if inferred is not None and inferred.depends_on not in {str(dep).strip() for dep in deps}:
+        dep_task = find_task(plan, inferred.depends_on)
+        if dep_task is None:
+            blockers.append(f"{inferred.depends_on} (missing, inferred)")
+        else:
+            dep_status = str(dep_task.get("status") or "")
+            if dep_status != "done":
+                blockers.append(f"{inferred.depends_on} ({dep_status or 'unknown'}, inferred)")
+    return blockers
+
+
+def _safe_task_file_component(task_id: str) -> str:
+    return _shared_safe_task_file_component(task_id)
+
+
+def _normalize_scope_mode(scope: str) -> str:
+    value = scope.strip().lower()
+    if value not in _SCOPE_MODES:
+        raise ForgeError("Invalid --scope. Use one of: off, warn, strict.")
+    return value
+
+
+def _normalize_verify_mode(value: str) -> str:
+    try:
+        return normalize_verify_mode(value)
+    except VerifyError as e:
+        raise ForgeError(str(e)) from e
+
+
+def _remote_report_lines(record: dict[str, Any] | None) -> list[str]:
+    if not record:
+        return []
+    lines: list[str] = [
+        f"remote={record.get('remote') or '-'} provider={record.get('provider') or 'unknown'}",
+        (
+            f"pushed_branch={record.get('pushed_branch')} "
+            f"pushed_base={record.get('pushed_base')} "
+            f"created_pr={record.get('created_pr')}"
+        ),
+    ]
+    pr_url = str(record.get("pr_url") or "").strip()
+    if pr_url:
+        lines.append(f"pr_url={pr_url}")
+    pr_id = str(record.get("pr_number_or_iid") or "").strip()
+    if pr_id:
+        lines.append(f"pr_number_or_iid={pr_id}")
+
+    branch_push_output = str(record.get("branch_push_output") or "").strip()
+    if branch_push_output:
+        lines.append(f"branch_push_output={truncate_output(branch_push_output, max_chars=300)}")
+    base_push_output = str(record.get("base_push_output") or "").strip()
+    if base_push_output:
+        lines.append(f"base_push_output={truncate_output(base_push_output, max_chars=300)}")
+    pr_output = str(record.get("pr_output") or "").strip()
+    if pr_output:
+        lines.append(f"pr_output={truncate_output(pr_output, max_chars=300)}")
+
+    raw_errors = record.get("errors")
+    if isinstance(raw_errors, list):
+        for err in raw_errors:
+            msg = str(err).strip()
+            if msg:
+                lines.append(f"error={truncate_output(msg, max_chars=300)}")
+    return lines
+
+
+def _print_usage_summary_from_logs(
+    *,
+    console: Console,
+    title: str,
+    log_paths: list[Path],
+) -> None:
+    summary = aggregate_usage_from_session_logs(log_paths)
+    rows = summary.by_model_rows()
+    if not rows:
+        return
+    table = _Table(title=title)
+    table.add_column("model")
+    table.add_column("prompt_tokens", justify="right")
+    table.add_column("completion_tokens", justify="right")
+    table.add_column("total_tokens", justify="right")
+    table.add_column("cost_usd", justify="right")
+    table.add_column("unknown_pricing", justify="right")
+    table.add_column("usage_source(api/est)", justify="right")
+    for row in rows:
+        unknown_count = int(row.get("unknown_cost_count") or 0)
+        cost_display = _format_cost_with_unknown(
+            known_cost=_known_cost_value(row),
+            unknown_calls=unknown_count,
+            style="table",
+        )
+        table.add_row(
+            str(row.get("model") or "-"),
+            str(int(row.get("prompt_tokens") or 0)),
+            str(int(row.get("completion_tokens") or 0)),
+            str(int(row.get("total_tokens") or 0)),
+            cost_display,
+            str(unknown_count),
+            (f"{int(row.get('api_usage_calls') or 0)}/{int(row.get('estimate_usage_calls') or 0)}"),
+        )
+    totals = summary.totals()
+    total_cost = _format_cost_with_unknown(
+        known_cost=_known_cost_value(totals),
+        unknown_calls=int(totals.get("unknown_cost_calls") or 0),
+        style="table",
+    )
+    table.add_row(
+        "TOTAL",
+        str(int(totals.get("prompt_tokens") or 0)),
+        str(int(totals.get("completion_tokens") or 0)),
+        str(int(totals.get("total_tokens") or 0)),
+        total_cost,
+        str(int(totals.get("unknown_cost_calls") or 0)),
+        (
+            f"{int(totals.get('api_usage_calls') or 0)}/"
+            f"{int(totals.get('estimate_usage_calls') or 0)}"
+        ),
+    )
+    console.print(table)
+
+
+__all__ = [name for name in globals() if (not name.startswith("__") or name == "__version__")]