rein-aharness/rein_aharness/cli.py

"""CLI: validate instance manifests and execute exactly one task."""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

from rein_aharness.manifest import (
    ManifestError,
    load_manifest_for_repo,
    manifest_path,
    validate_manifest,
)
from rein_aharness.profiles import list_profiles
from rein_aharness.runner import run_task
from rein_aharness.taskspec import TaskSpec, TaskSpecError


def _cmd_validate(args: argparse.Namespace) -> int:
    target = Path(args.target).expanduser().resolve()
    path = manifest_path(target)
    if not path.is_file():
        print(f"error: no instance manifest at {path}", file=sys.stderr)
        return 2
    try:
        manifest = load_manifest_for_repo(target)
    except ManifestError as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 2

    errors = validate_manifest(
        manifest, require_harness_fields=bool(args.strict)
    )
    if errors:
        print(f"invalid: {path}", file=sys.stderr)
        for err in errors:
            print(f"  - {err}", file=sys.stderr)
        return 1

    enabled = manifest.enabled_agents()
    print(f"ok: {path}")
    print(f"  version: {manifest.version}")
    if manifest.timezone:
        print(f"  timezone: {manifest.timezone}")
    if manifest.harness is not None:
        print(f"  harness major: {manifest.harness}")
    print(f"  agents: {len(manifest.agents)} ({len(enabled)} enabled)")
    for agent in manifest.agents:
        flags = []
        if not agent.enabled:
            flags.append("disabled")
        if agent.tool_profile:
            flags.append(f"profile={agent.tool_profile}")
        if agent.lane:
            flags.append(f"lane={agent.lane}")
        if agent.budget is not None:
            flags.append(f"budget={agent.budget}")
        suffix = f" [{', '.join(flags)}]" if flags else ""
        print(f"    - {agent.name}: {agent.cadence}{suffix}")
    return 0


def _cmd_profiles(_args: argparse.Namespace) -> int:
    for profile in list_profiles():
        print(f"{profile.name}\tlane={profile.lane}\t{profile.description}")
    return 0


def _cmd_poll(args: argparse.Namespace) -> int:
    source = getattr(args, "source", "issue-core") or "issue-core"
    if source in {"ops-run", "ops_run", "ops"}:
        from rein_aharness.claim_loop import process_one, poll_peek
        from rein_aharness.ops_run_client import OpsRunError

        try:
            if args.no_claim:
                rows = poll_peek()
                print(
                    json.dumps(
                        {"source": "ops-run", "queue": "empty" if not rows else "open", "items": rows},
                        indent=2,
                    )
                )
                return 0
            result = process_one(
                dry_run=bool(getattr(args, "dry_run", False)),
                report_to_hub=False if getattr(args, "no_hub", False) else True,
            )
        except OpsRunError as exc:
            print(f"ops-run error: {exc}", file=sys.stderr)
            return 2
        print(
            json.dumps(
                {
                    "source": "ops-run",
                    "claimed": result.claimed,
                    "empty": result.empty,
                    "run_id": result.run_id,
                    "approach": result.approach,
                    "ok": result.ok,
                    "ops_state": result.ops_state,
                    "reason": result.reason,
                    "detail": result.detail,
                },
                indent=2,
            )
        )
        if result.empty:
            return 0
        return 0 if result.ok else 1

    from rein_aharness.intake import IntakeError, IssueCoreClient, poll_next

    try:
        client = IssueCoreClient()
        result = poll_next(client, claim=not args.no_claim)
    except IntakeError as exc:
        print(f"intake error: {exc}", file=sys.stderr)
        return 2
    if result is None:
        print(json.dumps({"source": "issue-core", "queue": "empty"}, indent=2))
        return 0
    issue, spec = result
    print(
        json.dumps(
            {
                "source": "issue-core",
                "issue_id": issue.issue_id,
                "state": issue.state,
                "title": issue.title,
                "agent": spec.agent,
                "target_repo": str(spec.target_repo),
                "completion_event_type": spec.completion_event_type,
                "labels": spec.labels,
                "claimed": not args.no_claim,
            },
            indent=2,
        )
    )
    return 0


def _cmd_claim_loop(args: argparse.Namespace) -> int:
    import logging

    from rein_aharness.claim_loop import run_claim_loop

    logging.basicConfig(
        level=logging.DEBUG if args.verbose else logging.INFO,
        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    )
    return run_claim_loop(
        once=bool(args.once),
        interval_seconds=args.interval,
        report_to_hub=not args.no_hub,
        commit=not args.no_commit,
        dry_run=bool(args.dry_run),
        max_iterations=args.max_iterations,
    )


def _cmd_run(args: argparse.Namespace) -> int:
    from rein_aharness.intake import IntakeError, IssueCoreClient, poll_next

    issue_id: str | None = None
    client: IssueCoreClient | None = None

    if getattr(args, "from_ops_run", False):
        from rein_aharness.claim_loop import process_one
        from rein_aharness.ops_run_client import OpsRunError

        try:
            result = process_one(
                report_to_hub=not args.no_hub,
                commit=not getattr(args, "no_commit", False),
            )
        except OpsRunError as exc:
            print(f"ops-run error: {exc}", file=sys.stderr)
            return 2
        print(
            json.dumps(
                {
                    "source": "ops-run",
                    "ok": bool(result.ok) if result.claimed else True,
                    "empty": result.empty,
                    "run_id": result.run_id,
                    "approach": result.approach,
                    "ops_state": result.ops_state,
                    "reason": result.reason,
                    "detail": result.detail,
                },
                indent=2,
            )
        )
        if result.empty:
            return 0
        return 0 if result.ok else 1

    if args.from_issue_core:
        try:
            client = IssueCoreClient()
            polled = poll_next(client, claim=True)
        except IntakeError as exc:
            print(f"intake error: {exc}", file=sys.stderr)
            return 2
        if polled is None:
            print(json.dumps({"ok": True, "source": "issue-core", "queue": "empty"}, indent=2))
            return 0
        issue, spec = polled
        issue_id = issue.issue_id
    else:
        if not args.task_file:
            print(
                "error: provide --task-file, --from-ops-run, or --from-issue-core",
                file=sys.stderr,
            )
            return 2
        try:
            spec = TaskSpec.from_file(args.task_file)
        except (TaskSpecError, OSError, json.JSONDecodeError) as exc:
            print(f"invalid task spec: {exc}", file=sys.stderr)
            return 2

    def _print_event(event: dict) -> None:
        # Tagged + single-line so a consumer reading stdout line-by-line
        # (e.g. glas-harness's ReinAharness) can tell an event line apart
        # from the pretty-printed final result block below.
        print(json.dumps({"stream_event": event}), flush=True)

    result = run_task(
        spec,
        report_to_hub=not args.no_hub,
        write_metrics=not args.no_metrics,
        emit_tool_events=args.stream_tool_events,
        on_tool_event=_print_event if args.stream_tool_events else None,
        model=args.model,
        tool_profile_override=args.tool_profile,
        budget_tokens_override=args.budget_tokens,
    )

    closed = False
    close_error = ""
    if client is not None and issue_id:
        try:
            if result.ok:
                client.close(issue_id)
                closed = True
            else:
                client.reopen(issue_id)
        except IntakeError as exc:
            close_error = str(exc)

    print(
        json.dumps(
            {
                "ok": result.ok,
                "source": "issue-core" if issue_id else "task-file",
                "committed": result.committed,
                "head_after": result.head_after,
                "persona_source": result.persona_source,
                "tool_profile": result.tool_profile,
                "budget_tokens": result.budget_tokens,
                "tokens_spent": result.tokens_spent,
                "execution_time_s": round(result.execution_time_s, 3),
                "reason": result.reason,
                "model": result.model,
                "issue_id": issue_id,
                "issue_closed": closed,
                "issue_close_error": close_error,
            },
            indent=2,
        )
    )
    return 0 if result.ok else 1


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(prog="rein-aharness")
    sub = parser.add_subparsers(dest="command", required=True)

    run = sub.add_parser(
        "run",
        help="Execute one task: ops_run (primary), issue-core (legacy), or task file",
    )
    run_src = run.add_mutually_exclusive_group(required=True)
    run_src.add_argument("--task-file", help="Local JSON task-spec (dev path)")
    run_src.add_argument(
        "--from-ops-run",
        action="store_true",
        help="Claim one activity-core ops_run, select approach, execute, complete/fail",
    )
    run_src.add_argument(
        "--from-issue-core",
        action="store_true",
        help="Legacy: poll issue-core for one open harness-labeled task, claim, run, close",
    )
    run.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    run.add_argument(
        "--no-commit",
        action="store_true",
        help="With --from-ops-run: approaches that support it skip git commit",
    )
    run.add_argument(
        "--no-metrics",
        action="store_true",
        help="Skip writing .kaizen/metrics in the target repo",
    )
    run.add_argument(
        "--stream-tool-events",
        action="store_true",
        help=(
            "Run claude with --output-format stream-json --include-hook-events "
            "and print each tool_use/tool_result/hook event as its own JSON "
            "line while running (real-time audit, not external tool dispatch "
            "-- HARNESS-WP-0002-T03)"
        ),
    )
    run.add_argument(
        "--model",
        default=None,
        help="Explicit Claude Code model identifier supplied by the execution profile",
    )
    run.add_argument(
        "--tool-profile",
        default=None,
        help="Override the instance tool profile for this explicitly governed run",
    )
    run.add_argument(
        "--budget-tokens",
        type=int,
        default=None,
        help="Override the instance token budget for this explicitly governed run",
    )

    scan = sub.add_parser(
        "mail-scan", help="Deterministic company-mailbox scan (no LLM session)"
    )
    scan.add_argument("--target-repo", required=True)
    scan.add_argument("--config", default="integrations/mailbox-binky-company.yml")
    scan.add_argument("--out", default="mailmeta/reports")
    scan.add_argument("--no-hub", action="store_true", help="Skip hub reporting")

    triage = sub.add_parser(
        "mail-triage",
        help="Triage newest mail CSV via llm-connect (JSON + deterministic apply; no Claude)",
    )
    triage.add_argument("--target-repo", required=True)
    triage.add_argument("--reports-dir", default="mailmeta/reports")
    triage.add_argument("--mail-log", default="mailmeta/mail-log.md")
    triage.add_argument(
        "--max-rows",
        type=int,
        default=None,
        help="Max CSV rows to send to the model (default env MAIL_TRIAGE_MAX_ROWS or 40)",
    )
    triage.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    triage.add_argument(
        "--no-commit",
        action="store_true",
        help="Apply log updates but do not git commit",
    )

    brief = sub.add_parser(
        "brief-daily",
        help="Write daily brief via llm-connect (JSON + markdown apply; no Claude)",
    )
    brief.add_argument("--target-repo", required=True)
    brief.add_argument(
        "--date",
        default=None,
        help="Brief date YYYY-MM-DD (default: today Europe/Berlin)",
    )
    brief.add_argument(
        "--force",
        action="store_true",
        help="Overwrite if today's brief already exists",
    )
    brief.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    brief.add_argument(
        "--no-commit",
        action="store_true",
        help="Write brief file but do not git commit",
    )

    weekly = sub.add_parser(
        "brief-weekly",
        help="Write weekly founder-review prep via llm-connect (no coding agent)",
    )
    weekly.add_argument("--target-repo", required=True)
    weekly.add_argument(
        "--date",
        default=None,
        help="Review date YYYY-MM-DD (default: today Europe/Berlin)",
    )
    weekly.add_argument(
        "--force",
        action="store_true",
        help="Overwrite if today's weekly review already exists",
    )
    weekly.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    weekly.add_argument(
        "--no-commit",
        action="store_true",
        help="Write review file but do not git commit",
    )

    fi_brief = sub.add_parser(
        "fi-research-brief",
        help=(
            "Freedom Intelligence research brief via llm-connect "
            "(activity-core consumer; posts fi_daily_brief)"
        ),
    )
    fi_brief.add_argument(
        "--target-repo",
        required=True,
        help="freedom-intelligence checkout path",
    )
    fi_brief.add_argument(
        "--date",
        default=None,
        help="Brief date YYYY-MM-DD (default: today Europe/Berlin)",
    )
    fi_brief.add_argument(
        "--force",
        action="store_true",
        help="Overwrite if today's brief already exists",
    )
    fi_brief.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    fi_brief.add_argument(
        "--no-commit",
        action="store_true",
        help="Write brief file but do not git commit",
    )

    validate = sub.add_parser(
        "validate",
        help="Validate instance manifest (.kaizen/schedule.yml + harness fields)",
    )
    validate.add_argument(
        "--target",
        default=".",
        help="Consuming repo root (default: cwd)",
    )
    validate.add_argument(
        "--strict",
        action="store_true",
        help="Require lane, tool_profile, and harness pin on every enabled agent",
    )

    sub.add_parser("profiles", help="List named tool profiles")

    smoke = sub.add_parser(
        "smoke",
        help="Deterministic Railiance smoke: commit SMOKE.md, optional push, hub event",
    )
    smoke.add_argument(
        "--target-repo",
        help="Existing git checkout (default: clone executor-sandbox under --work-dir)",
    )
    smoke.add_argument(
        "--work-dir",
        default="~/work/executor-sandbox",
        help="Clone destination when --target-repo is omitted",
    )
    smoke.add_argument(
        "--remote",
        default="ssh://git@forgejo-agent-harness/coulomb/executor-sandbox.git",
        help="Git remote for sandbox clone",
    )
    smoke.add_argument("--no-hub", action="store_true", help="Skip hub reporting")
    smoke.add_argument("--no-push", action="store_true", help="Skip git push after commit")

    poll = sub.add_parser(
        "poll",
        help="Peek/claim next task (default source=ops-run; issue-core is legacy)",
    )
    poll.add_argument(
        "--source",
        choices=["ops-run", "issue-core"],
        default="ops-run",
        help="ops-run = activity-core claim queue (primary); issue-core = legacy tickets",
    )
    poll.add_argument(
        "--no-claim",
        action="store_true",
        help="List/map only; do not claim",
    )
    poll.add_argument(
        "--dry-run",
        action="store_true",
        help="With ops-run: claim then fail+reopen without executing",
    )
    poll.add_argument("--no-hub", action="store_true", help="Skip hub on execute")

    claim_loop = sub.add_parser(
        "claim-loop",
        help="Continuously claim ops_runs, select approach, execute, complete/fail",
    )
    claim_loop.add_argument(
        "--once",
        action="store_true",
        help="Process at most one claim cycle then exit",
    )
    claim_loop.add_argument(
        "--interval",
        type=float,
        default=None,
        help="Seconds between empty-queue polls (default env AGENT_HARNESS_CLAIM_INTERVAL or 30)",
    )
    claim_loop.add_argument(
        "--max-iterations",
        type=int,
        default=None,
        help="Stop after N cycles (tests / bounded runs)",
    )
    claim_loop.add_argument("--dry-run", action="store_true")
    claim_loop.add_argument("--no-hub", action="store_true")
    claim_loop.add_argument("--no-commit", action="store_true")
    claim_loop.add_argument("-v", "--verbose", action="store_true")

    args = parser.parse_args(argv)

    if args.command == "validate":
        return _cmd_validate(args)

    if args.command == "profiles":
        return _cmd_profiles(args)

    if args.command == "poll":
        return _cmd_poll(args)

    if args.command == "claim-loop":
        return _cmd_claim_loop(args)

    if args.command == "run":
        return _cmd_run(args)

    if args.command == "smoke":
        from rein_aharness.smoke import ensure_sandbox_clone, run_smoke

        if args.target_repo:
            repo = Path(args.target_repo).expanduser().resolve()
        else:
            try:
                repo = ensure_sandbox_clone(
                    Path(args.work_dir).expanduser(),
                    remote=args.remote,
                )
            except Exception as exc:
                print(f"smoke clone failed: {exc}", file=sys.stderr)
                return 2
        try:
            smoke_result = run_smoke(
                repo,
                report_to_hub=not args.no_hub,
                push=not args.no_push,
            )
        except Exception as exc:
            print(f"smoke failed: {exc}", file=sys.stderr)
            return 1
        print(
            json.dumps(
                {
                    "ok": smoke_result.run.ok and (
                        smoke_result.pushed or args.no_push
                    ),
                    "committed": smoke_result.run.committed,
                    "pushed": smoke_result.pushed,
                    "head_after": smoke_result.run.head_after,
                    "tool_profile": smoke_result.run.tool_profile,
                    "reason": smoke_result.run.reason,
                    "push_reason": smoke_result.push_reason,
                    "target_repo": str(repo),
                },
                indent=2,
            )
        )
        ok = smoke_result.run.ok and (smoke_result.pushed or args.no_push)
        return 0 if ok else 1

    if args.command == "mail-triage":
        from rein_aharness.mail_triage import run_mail_triage

        triage_result = run_mail_triage(
            target_repo=Path(args.target_repo).expanduser(),
            reports_dir=args.reports_dir,
            mail_log_rel=args.mail_log,
            max_rows=args.max_rows,
            report_to_hub=not args.no_hub,
            commit=not args.no_commit,
        )
        print(
            json.dumps(
                {
                    "ok": triage_result.ok,
                    "report": triage_result.report,
                    "entries_applied": triage_result.entries_applied,
                    "committed": triage_result.committed,
                    "head_after": triage_result.head_after,
                    "reason": triage_result.reason,
                    "model_meta": triage_result.model_meta,
                },
                indent=2,
            )
        )
        return 0 if triage_result.ok else 1

    if args.command == "brief-daily":
        from datetime import date as date_cls

        from rein_aharness.brief_daily import run_brief_daily

        day = None
        if args.date:
            day = date_cls.fromisoformat(args.date)
        brief_result = run_brief_daily(
            target_repo=Path(args.target_repo).expanduser(),
            day=day,
            force=bool(args.force),
            report_to_hub=not args.no_hub,
            commit=not args.no_commit,
        )
        print(
            json.dumps(
                {
                    "ok": brief_result.ok,
                    "date": brief_result.date,
                    "path": brief_result.path,
                    "wrote": brief_result.wrote,
                    "committed": brief_result.committed,
                    "skipped_existing": brief_result.skipped_existing,
                    "head_after": brief_result.head_after,
                    "reason": brief_result.reason,
                    "model_meta": brief_result.model_meta,
                },
                indent=2,
            )
        )
        return 0 if brief_result.ok else 1

    if args.command == "brief-weekly":
        from datetime import date as date_cls

        from rein_aharness.brief_weekly import run_brief_weekly

        day = date_cls.fromisoformat(args.date) if args.date else None
        result = run_brief_weekly(
            target_repo=Path(args.target_repo).expanduser(),
            day=day,
            force=bool(args.force),
            report_to_hub=not args.no_hub,
            commit=not args.no_commit,
        )
        print(
            json.dumps(
                {
                    "ok": result.ok,
                    "date": result.date,
                    "path": result.path,
                    "wrote": result.wrote,
                    "committed": result.committed,
                    "skipped_existing": result.skipped_existing,
                    "milestone_moved": result.milestone_moved,
                    "risk005_state": result.risk005_state,
                    "head_after": result.head_after,
                    "reason": result.reason,
                    "model_meta": result.model_meta,
                },
                indent=2,
            )
        )
        return 0 if result.ok else 1

    if args.command == "fi-research-brief":
        from datetime import date as date_cls

        from rein_aharness.fi_research_brief import run_fi_research_brief

        day = None
        if args.date:
            day = date_cls.fromisoformat(args.date)
        fi_result = run_fi_research_brief(
            target_repo=Path(args.target_repo).expanduser(),
            day=day,
            force=bool(args.force),
            report_to_hub=not args.no_hub,
            commit=not args.no_commit,
        )
        print(
            json.dumps(
                {
                    "ok": fi_result.ok,
                    "date": fi_result.date,
                    "path": fi_result.path,
                    "wrote": fi_result.wrote,
                    "committed": fi_result.committed,
                    "skipped_existing": fi_result.skipped_existing,
                    "collection_candidates": fi_result.collection_candidates,
                    "head_after": fi_result.head_after,
                    "reason": fi_result.reason,
                    "model_meta": fi_result.model_meta,
                },
                indent=2,
            )
        )
        return 0 if fi_result.ok else 1

    if args.command == "mail-scan":
        from rein_aharness.mailscan import run_mail_scan

        result = run_mail_scan(
            target_repo=Path(args.target_repo).expanduser(),
            config=args.config,
            out_dir=args.out,
            report_to_hub=not args.no_hub,
        )
        print(
            json.dumps(
                {
                    "ok": result.ok,
                    "report": result.report_path,
                    "new_messages": result.new_messages,
                    "auth_lane": result.auth_lane,
                    "reason": result.reason,
                },
                indent=2,
            )
        )
        return 0 if result.ok else 1

    print(f"unknown command: {args.command}", file=sys.stderr)
    return 2


if __name__ == "__main__":
    raise SystemExit(main())