norn-cli 0.7.1__py3-none-any.whl

norf_harness/__init__.py

@@ -0,0 +1,6 @@
+"""Norn package implementation."""
+
+from .config import HarnessConfig, load_config
+
+__all__ = ["HarnessConfig", "load_config"]
+__version__ = "0.7.1"

norf_harness/cli.py

@@ -0,0 +1,303 @@
+"""Command-line interface for Norn."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import shutil
+import sys
+from pathlib import Path
+
+import yaml
+
+from . import __version__
+from .config import ConfigError, default_config_path, load_config, project_config_path
+from .doctor import checks_as_dict, doctor_exit_code, run_doctor
+from .models import ExitCode, RunMode, RunStatus, StopReason
+from .pipeline import execute_pipeline
+from .providers import default_registry
+from .reporting import read_report, write_reports
+from .run_store import RunStore, RunStoreError
+from .skill_install import SkillInstallError, install_skills
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="norn")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init", help="create project harness configuration")
+    _project_option(init_parser)
+    init_parser.add_argument("--force", action="store_true")
+
+    skill_parser = subparsers.add_parser(
+        "install-skill", help="install the bundled Codex and/or Claude skill"
+    )
+    _project_option(skill_parser)
+    skill_parser.add_argument("--target", choices=("codex", "claude", "all"), default="all")
+    skill_parser.add_argument("--scope", choices=("project", "user"), default="project")
+    skill_parser.add_argument("--force", action="store_true")
+
+    doctor_parser = subparsers.add_parser("doctor", help="check local harness prerequisites")
+    _common_options(doctor_parser)
+    doctor_parser.add_argument("--json", action="store_true", dest="json_output")
+
+    validate_parser = subparsers.add_parser("validate-config", help="validate merged config")
+    _common_options(validate_parser)
+    validate_parser.add_argument("--json", action="store_true", dest="json_output")
+
+    providers_parser = subparsers.add_parser(
+        "providers", help="show provider profiles without invoking models"
+    )
+    _common_options(providers_parser)
+    providers_parser.add_argument("--json", action="store_true", dest="json_output")
+
+    for name in ("plan", "run"):
+        execution = subparsers.add_parser(name, help=f"start a {name} lifecycle")
+        execution.add_argument("request")
+        _common_options(execution)
+        _limit_options(execution)
+
+    for name in ("status", "recover", "report"):
+        command = subparsers.add_parser(name)
+        command.add_argument("run_id")
+        _common_options(command)
+        if name in {"status", "report"}:
+            command.add_argument("--json", action="store_true", dest="json_output")
+        if name == "report":
+            command.add_argument("--escalation", action="store_true")
+
+    return parser
+
+
+def _project_option(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--project", type=Path, default=Path.cwd())
+
+
+def _common_options(parser: argparse.ArgumentParser) -> None:
+    _project_option(parser)
+    parser.add_argument("--config", type=Path)
+
+
+def _limit_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--max-rounds", type=int)
+    parser.add_argument("--max-total-rounds", type=int)
+    parser.add_argument("--max-planner-retries", type=int)
+    parser.add_argument("--max-final-replans", type=int)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "init":
+            return _init(args)
+        if args.command == "install-skill":
+            return _install_skill(args)
+        config = load_config(
+            args.project,
+            config_path=args.config,
+            overrides=_overrides(args),
+        )
+        if args.command == "doctor":
+            return _doctor(config, args.json_output)
+        if args.command == "validate-config":
+            return _validate(config, args.json_output)
+        if args.command == "providers":
+            return _providers(config, args.json_output)
+        if args.command in {"plan", "run"}:
+            return _execution(config, args.request, RunMode(args.command))
+        if args.command == "status":
+            return _status(config, args.run_id, args.json_output)
+        if args.command == "recover":
+            return _recover(config, args.run_id)
+        if args.command == "report":
+            return _report(config, args.run_id, args.escalation, args.json_output)
+    except ConfigError as exc:
+        print(f"CONFIG ERROR: {exc}", file=sys.stderr)
+        return int(ExitCode.CONFIG_ERROR)
+    except SkillInstallError as exc:
+        print(f"SKILL ERROR: {exc}", file=sys.stderr)
+        return int(ExitCode.CONFIG_ERROR)
+    except (RunStoreError, FileNotFoundError) as exc:
+        print(f"RUN ERROR: {exc}", file=sys.stderr)
+        return int(ExitCode.UNEXPECTED_FAILURE)
+    return int(ExitCode.UNEXPECTED_FAILURE)
+
+
+def _init(args: argparse.Namespace) -> int:
+    root = args.project.expanduser().resolve()
+    target = project_config_path(root)
+    if target.exists() and not args.force:
+        print(f"Config already exists: {target}", file=sys.stderr)
+        return int(ExitCode.CONFIG_ERROR)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    defaults = yaml.safe_load(default_config_path().read_text(encoding="utf-8"))
+    defaults["paths"]["runs_dir"] = ".norf/runs"
+    target.write_text(
+        yaml.safe_dump(defaults, sort_keys=False, allow_unicode=True), encoding="utf-8"
+    )
+    _ensure_gitignore(root)
+    print(f"Created {target}")
+    return int(ExitCode.SUCCESS)
+
+
+def _install_skill(args: argparse.Namespace) -> int:
+    installed = install_skills(
+        args.project,
+        target=args.target,
+        scope=args.scope,
+        force=args.force,
+    )
+    for item in installed:
+        print(f"Installed {item.target} skill: {item.path}")
+    return int(ExitCode.SUCCESS)
+
+
+def _ensure_gitignore(root: Path) -> None:
+    path = root / ".gitignore"
+    markers = (".norf/runs/", ".norf/worktrees/", ".norf/e2e-evidence/")
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    current = set(existing.splitlines())
+    missing = [marker for marker in markers if marker not in current]
+    if missing:
+        prefix = existing
+        if prefix and not prefix.endswith("\n"):
+            prefix += "\n"
+        path.write_text(prefix + "\n".join(missing) + "\n", encoding="utf-8")
+
+
+def _doctor(config, json_output: bool) -> int:
+    checks = run_doctor(config)
+    if json_output:
+        print(json.dumps(checks_as_dict(checks), ensure_ascii=False, indent=2))
+    else:
+        for check in checks:
+            print(f"[{check.status:<4}] {check.name}: {check.detail}")
+    return doctor_exit_code(checks)
+
+
+def _validate(config, json_output: bool) -> int:
+    if json_output:
+        print(json.dumps(config.to_dict(), ensure_ascii=False, indent=2))
+    else:
+        print("Config valid")
+        print(f"Project: {config.project_root}")
+        print(f"Runs: {config.runs_dir}")
+        print("Sources:")
+        for source in config.sources:
+            print(f"  - {source}")
+    return int(ExitCode.SUCCESS)
+
+
+def _providers(config, json_output: bool) -> int:
+    registered = default_registry()
+    rows: list[dict[str, object]] = []
+    failed = False
+    for profile_name, profile in config.profiles.items():
+        for index, candidate in enumerate(profile.candidates):
+            provider = config.providers[candidate.provider]
+            command = shutil.which(provider.command)
+            adapter_registered = provider.adapter in registered
+            available = command is not None and adapter_registered
+            failed = failed or (index == 0 and not available and len(profile.candidates) == 1)
+            rows.append(
+                {
+                    "profile": profile_name,
+                    "priority": index + 1,
+                    "provider": provider.name,
+                    "adapter": provider.adapter,
+                    "model": candidate.model,
+                    "model_id": candidate.resolved_model,
+                    "effort": candidate.effort,
+                    "command": command or provider.command,
+                    "available": available,
+                }
+            )
+    if json_output:
+        print(json.dumps(rows, ensure_ascii=False, indent=2))
+    else:
+        for row in rows:
+            marker = "PASS" if row["available"] else "WARN"
+            print(
+                f"[{marker}] {row['profile']}#{row['priority']} "
+                f"{row['provider']}/{row['model']}->{row['model_id']}/{row['effort']} "
+                f"adapter={row['adapter']}"
+            )
+    return 1 if failed else 0
+
+
+def _execution(config, request: str, mode: RunMode) -> int:
+    outcome = asyncio.run(execute_pipeline(config, request, mode))
+    manifest = outcome.manifest
+    if manifest.exit_code == 0:
+        print(f"Harness succeeded: {outcome.paths.final_report}")
+    else:
+        print(f"Harness stopped: {manifest.stop_reason}", file=sys.stderr)
+        print(f"Exit code: {manifest.exit_code}", file=sys.stderr)
+        print(f"Escalation report: {outcome.paths.escalation_report}", file=sys.stderr)
+    print(f"Run ID: {manifest.run_id}", file=sys.stderr)
+    return outcome.exit_code
+
+
+def _status(config, run_id: str, json_output: bool) -> int:
+    manifest = RunStore(config).load_manifest(run_id)
+    if json_output:
+        print(json.dumps(manifest.to_dict(), ensure_ascii=False, indent=2))
+    else:
+        print(f"Run: {manifest.run_id}")
+        print(f"Status: {manifest.status}")
+        print(f"Phase: {manifest.phase}")
+        print(f"Exit code: {manifest.exit_code}")
+        print(f"Stop reason: {manifest.stop_reason or ''}")
+    return int(manifest.exit_code or 0)
+
+
+def _recover(config, run_id: str) -> int:
+    store = RunStore(config)
+    manifest = store.load_manifest(run_id)
+    if manifest.status in {RunStatus.CREATED, RunStatus.RUNNING}:
+        store.escalate(
+            manifest,
+            reason=StopReason.UNEXPECTED_FAILURE,
+            exit_code=ExitCode.UNEXPECTED_FAILURE,
+            detail="前回プロセスが完了記録を残さず停止しました。イベントから判断文書を再構築しました。",
+            decisions=["直近イベントとworktreeを確認し、再実行または手動継続を判断する"],
+        )
+    paths = write_reports(store, manifest)
+    target = (
+        paths.escalation_report if manifest.status != RunStatus.SUCCEEDED else paths.final_report
+    )
+    print(f"Recovered report: {target}")
+    return int(manifest.exit_code or 0)
+
+
+def _report(config, run_id: str, escalation: bool, json_output: bool) -> int:
+    store = RunStore(config)
+    manifest = store.load_manifest(run_id)
+    paths = write_reports(store, manifest)
+    if json_output:
+        path = paths.escalation_json if escalation else paths.manifest
+    else:
+        path = paths.escalation_report if escalation else paths.final_report
+    print(read_report(path), end="")
+    return int(manifest.exit_code or 0)
+
+
+def _overrides(args: argparse.Namespace) -> dict[str, int]:
+    mapping = {
+        "max_rounds": "limits.implementation.max_rounds",
+        "max_total_rounds": "limits.pipeline.max_total_rounds",
+        "max_planner_retries": "limits.planning.max_retries",
+        "max_final_replans": "limits.final_gate.max_replans",
+    }
+    result: dict[str, int] = {}
+    for attribute, dotted in mapping.items():
+        value = getattr(args, attribute, None)
+        if value is not None:
+            result[dotted] = value
+    return result
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())