infospace-bench/src/infospace_bench/cli.py

from __future__ import annotations

import argparse
from collections import Counter
import json
import sys
from pathlib import Path

from .checks import run_collection_checks
from .engine import engine_capability_contract, plan_asset_sync, sync_assets
from .errors import InfospaceError
from .evaluation_io import read_entity_evaluations
from .history import (
    build_viability_report,
    find_snapshot,
    get_history,
    metric_trend,
    read_metrics_file,
    record_check_results,
)
from .inspection import export_mermaid, relationship_summary
from .lifecycle import add_artifact, create_infospace, load_infospace
from .markdown_adapter import validate_infospace_artifacts
from .semantics import list_entities, list_relations
from .workflow import (
    FixtureAssistedGenerationAdapter,
    load_workflows,
    plan_workflow,
    run_workflow,
)


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="infospace-bench")
    sub = parser.add_subparsers(dest="command", required=True)

    create = sub.add_parser("create", help="Create an infospace")
    create.add_argument("workspace")
    create.add_argument("slug")
    create.add_argument("--name", required=True)
    create.add_argument("--topic-domain", default="")

    inspect = sub.add_parser("inspect", help="Inspect an infospace")
    inspect.add_argument("root")

    status = sub.add_parser("status", help="Summarize replacement readiness state")
    status.add_argument("root")

    add = sub.add_parser("add-artifact", help="Add an artifact to an infospace")
    add.add_argument("root")
    add.add_argument("source")
    add.add_argument("--kind", required=True)
    add.add_argument("--title", default="")

    export = sub.add_parser("export", help="Print the infospace representation")
    export.add_argument("root")

    validate = sub.add_parser("validate", help="Validate infospace artifacts")
    validate.add_argument("root")

    entities = sub.add_parser("entities", help="List parsed entity artifacts")
    entities.add_argument("root")

    relations = sub.add_parser("relations", help="List parsed relation artifacts")
    relations.add_argument("root")

    history = sub.add_parser("history", help="List evaluation snapshot history")
    history.add_argument("root")
    history.add_argument("--metric", default="")

    history_diff = sub.add_parser(
        "history-diff",
        help="Diff two evaluation snapshots by snapshot ID or date",
    )
    history_diff.add_argument("root")
    history_diff.add_argument("before")
    history_diff.add_argument("after")

    metrics = sub.add_parser(
        "metrics",
        help="Run collection checks and persist metrics/history",
    )
    metrics.add_argument("root")

    check = sub.add_parser(
        "check",
        help="Run collection checks and persist metrics/history",
    )
    check.add_argument("root")

    viability = sub.add_parser("viability", help="Evaluate configured thresholds")
    viability.add_argument("root")

    graph = sub.add_parser("graph", help="Export the artifact relationship graph")
    graph.add_argument("root")
    graph.add_argument("--format", choices=["json", "mermaid"], default="json")

    workflow = sub.add_parser("workflow", help="Inspect, plan, and run workflows")
    workflow_sub = workflow.add_subparsers(dest="workflow_command", required=True)

    workflow_inspect = workflow_sub.add_parser(
        "inspect",
        help="Inspect workflow declarations",
    )
    workflow_inspect.add_argument("root")

    workflow_plan = workflow_sub.add_parser(
        "plan",
        help="Plan a workflow without writing outputs",
    )
    workflow_plan.add_argument("root")
    workflow_plan.add_argument("workflow_id")

    workflow_run = workflow_sub.add_parser(
        "run",
        help="Run a deterministic workflow",
    )
    workflow_run.add_argument("root")
    workflow_run.add_argument("workflow_id")
    workflow_run.add_argument(
        "--fixture-responses",
        default="",
        help="Run assisted stages with deterministic fixture responses",
    )

    engine = sub.add_parser("engine", help="Inspect and sync engine boundary state")
    engine_sub = engine.add_subparsers(dest="engine_command", required=True)

    engine_inspect = engine_sub.add_parser(
        "inspect",
        help="Inspect the optional engine capability contract",
    )
    engine_inspect.add_argument("root")

    engine_plan = engine_sub.add_parser(
        "plan-sync",
        help="Plan artifact-to-asset sync without mutation",
    )
    engine_plan.add_argument("root")

    engine_sync = engine_sub.add_parser(
        "sync",
        help="Dry-run artifact-to-asset sync unless --apply is passed",
    )
    engine_sync.add_argument("root")
    engine_sync.add_argument("--apply", action="store_true")

    return parser


def main(argv: list[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    try:
        if args.command == "create":
            infospace = create_infospace(
                Path(args.workspace),
                args.slug,
                name=args.name,
                topic_domain=args.topic_domain,
            )
            _write_json({"slug": infospace.config.slug, "root": str(infospace.root)})
        elif args.command == "inspect":
            _write_json(load_infospace(Path(args.root)).to_dict())
        elif args.command == "status":
            _write_json(_status_payload(Path(args.root)))
        elif args.command == "add-artifact":
            artifact = add_artifact(
                Path(args.root),
                Path(args.source),
                kind=args.kind,
                title=args.title,
            )
            _write_json({"artifact": artifact.to_dict()})
        elif args.command == "export":
            _write_json(load_infospace(Path(args.root)).to_dict())
        elif args.command == "validate":
            results = validate_infospace_artifacts(Path(args.root))
            valid = all(result.valid for result in results)
            _write_json(
                {
                    "valid": valid,
                    "results": [result.to_dict() for result in results],
                }
            )
            return 0 if valid else 1
        elif args.command == "entities":
            _write_json(
                {
                    "entities": [
                        entity.to_dict() for entity in list_entities(Path(args.root))
                    ]
                }
            )
        elif args.command == "relations":
            _write_json(
                {
                    "relations": [
                        relation.to_dict()
                        for relation in list_relations(Path(args.root))
                    ]
                }
            )
        elif args.command == "history":
            history = get_history(Path(args.root))
            if args.metric:
                _write_json(
                    {
                        "metric": args.metric,
                        "trend": metric_trend(history, args.metric),
                    }
                )
            else:
                _write_json({"history": [item.to_dict() for item in history]})
        elif args.command == "history-diff":
            history = get_history(Path(args.root))
            before = find_snapshot(history, args.before)
            after = find_snapshot(history, args.after)
            if before is None or after is None:
                missing = []
                if before is None:
                    missing.append(args.before)
                if after is None:
                    missing.append(args.after)
                raise InfospaceError(
                    "missing_snapshot",
                    "Could not resolve requested snapshot reference",
                    {"missing_refs": missing},
                )
            _write_json({"diff": before.diff(after).to_dict()})
        elif args.command == "metrics":
            _write_json(_record_checks(Path(args.root)).to_dict())
        elif args.command == "check":
            infospace = load_infospace(Path(args.root))
            report = run_collection_checks(infospace.artifacts)
            result = record_check_results(
                infospace.root,
                report,
                artifact_evaluations=_read_output_evaluations(infospace.root),
            )
            _write_json(
                {
                    **result.to_dict(),
                    "details": report.details,
                }
            )
        elif args.command == "viability":
            _write_json(build_viability_report(Path(args.root)))
        elif args.command == "graph":
            infospace = load_infospace(Path(args.root))
            summary = relationship_summary(infospace.artifacts)
            if args.format == "mermaid":
                print(export_mermaid(summary), end="")
            else:
                _write_json(_relationship_summary_payload(summary))
        elif args.command == "workflow":
            if args.workflow_command == "inspect":
                _write_json(
                    {
                        "workflows": [
                            workflow.to_dict()
                            for workflow in load_workflows(Path(args.root))
                        ]
                    }
                )
            elif args.workflow_command == "plan":
                _write_json(
                    plan_workflow(Path(args.root), args.workflow_id).to_dict()
                )
            elif args.workflow_command == "run":
                adapter = (
                    FixtureAssistedGenerationAdapter.from_file(
                        Path(args.fixture_responses)
                    )
                    if args.fixture_responses
                    else None
                )
                _write_json(
                    run_workflow(
                        Path(args.root),
                        args.workflow_id,
                        assisted_adapter=adapter,
                    ).to_dict()
                )
            else:
                parser.error(f"Unhandled workflow command: {args.workflow_command}")
        elif args.command == "engine":
            if args.engine_command == "inspect":
                _write_json(
                    {
                        "root": str(Path(args.root)),
                        "contract": engine_capability_contract().to_dict(),
                    }
                )
            elif args.engine_command == "plan-sync":
                _write_json(plan_asset_sync(Path(args.root)).to_dict())
            elif args.engine_command == "sync":
                _write_json(
                    sync_assets(Path(args.root), dry_run=not args.apply).to_dict()
                )
            else:
                parser.error(f"Unhandled engine command: {args.engine_command}")
        else:
            parser.error(f"Unhandled command: {args.command}")
    except InfospaceError as exc:
        print(json.dumps(exc.to_dict(), indent=2), file=sys.stderr)
        return 2
    return 0


def _status_payload(root: Path) -> dict:
    infospace = load_infospace(root)
    validation = validate_infospace_artifacts(infospace.root)
    entities = list_entities(infospace.root)
    relations = list_relations(infospace.root)
    history = get_history(infospace.root)
    metrics = read_metrics_file(
        infospace.root / "output" / "metrics" / "metrics.yaml"
    )
    viability = (
        build_viability_report(infospace.root) if infospace.config.viability else None
    )
    graph = relationship_summary(infospace.artifacts)
    return {
        "slug": infospace.config.slug,
        "name": infospace.config.name,
        "topic": infospace.config.topic.to_dict(),
        "artifact_count": len(infospace.artifacts),
        "artifact_kinds": dict(
            sorted(Counter(item.kind for item in infospace.artifacts).items())
        ),
        "entity_count": len(entities),
        "relation_count": len(relations),
        "validation": {
            "checked_artifact_count": len(validation),
            "valid": all(result.valid for result in validation),
        },
        "history": {
            "snapshot_count": len(history),
            "latest_snapshot_id": history[-1].snapshot_id if history else "",
        },
        "metrics": metrics,
        "viability": viability,
        "graph": {
            "node_count": graph.node_count,
            "edge_count": graph.edge_count,
            "relationship_types": graph.relationship_types,
        },
    }


def _record_checks(root: Path):
    infospace = load_infospace(root)
    return record_check_results(
        infospace.root,
        run_collection_checks(infospace.artifacts),
        artifact_evaluations=_read_output_evaluations(infospace.root),
    )


def _read_output_evaluations(root: Path):
    return read_entity_evaluations(root / "output" / "evaluations")


def _relationship_summary_payload(summary) -> dict:
    return {
        "node_count": summary.node_count,
        "edge_count": summary.edge_count,
        "nodes": summary.nodes,
        "edges": [
            {"source": edge.source, "target": edge.target, "type": edge.type}
            for edge in summary.edges
        ],
        "relationship_types": summary.relationship_types,
    }


def _write_json(payload: dict) -> None:
    print(json.dumps(payload, indent=2))