generic source-to-infospace generator

src/infospace_bench/cli.py

@@ -10,6 +10,12 @@ 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 .generator import (
+    init_generation_infospace,
+    plan_generation,
+    run_generation,
+    status_generation,
+)
 from .history import (
     build_viability_report,
     find_snapshot,
@@ -123,6 +129,72 @@ def build_parser() -> argparse.ArgumentParser:
         help="Run assisted stages with deterministic fixture responses",
     )
 
+    generate = sub.add_parser("generate", help="Generate infospaces from sources")
+    generate_sub = generate.add_subparsers(dest="generate_command", required=True)
+
+    generate_init = generate_sub.add_parser(
+        "init",
+        help="Create a generation infospace from a local source",
+    )
+    generate_init.add_argument("source")
+    generate_init.add_argument("--workspace", default=".")
+    generate_init.add_argument("--slug", required=True)
+    generate_init.add_argument("--name", required=True)
+    generate_init.add_argument("--profile", default="general-knowledge")
+    generate_init.add_argument("--max-chunks", type=int, default=0)
+
+    generate_plan = generate_sub.add_parser(
+        "plan",
+        help="Plan generator work without provider calls",
+    )
+    generate_plan.add_argument("root")
+    generate_plan.add_argument("--stage", default="all")
+
+    generate_run = generate_sub.add_parser(
+        "run",
+        help="Run generator workflows for an infospace",
+    )
+    generate_run.add_argument("root")
+    generate_run.add_argument("--stage", default="all")
+    generate_run.add_argument("--provider", choices=["fixture", "openrouter"], default="fixture")
+    generate_run.add_argument("--model", default="")
+    generate_run.add_argument("--fixture-responses", default="")
+    generate_run.add_argument("--resume", action="store_true")
+    generate_run.add_argument("--force", action="store_true")
+
+    generate_resume = generate_sub.add_parser(
+        "resume",
+        help="Resume generator workflows for an infospace",
+    )
+    generate_resume.add_argument("root")
+    generate_resume.add_argument("--stage", default="all")
+    generate_resume.add_argument("--provider", choices=["fixture", "openrouter"], default="fixture")
+    generate_resume.add_argument("--model", default="")
+    generate_resume.add_argument("--fixture-responses", default="")
+    generate_resume.add_argument("--force", action="store_true")
+
+    generate_status = generate_sub.add_parser(
+        "status",
+        help="Inspect generator status for an infospace",
+    )
+    generate_status.add_argument("root")
+
+    generate_from_source = generate_sub.add_parser(
+        "from-source",
+        help="Initialize and optionally run generation from a local source",
+    )
+    generate_from_source.add_argument("source")
+    generate_from_source.add_argument("--workspace", default=".")
+    generate_from_source.add_argument("--slug", required=True)
+    generate_from_source.add_argument("--name", required=True)
+    generate_from_source.add_argument("--profile", default="general-knowledge")
+    generate_from_source.add_argument("--stage", default="all")
+    generate_from_source.add_argument("--provider", choices=["fixture", "openrouter"], default="fixture")
+    generate_from_source.add_argument("--model", default="")
+    generate_from_source.add_argument("--fixture-responses", default="")
+    generate_from_source.add_argument("--max-chunks", type=int, default=0)
+    generate_from_source.add_argument("--apply", action="store_true")
+
     engine = sub.add_parser("engine", help="Inspect and sync engine boundary state")
     engine_sub = engine.add_subparsers(dest="engine_command", required=True)
 
@@ -284,6 +356,73 @@ def main(argv: list[str] | None = None) -> int:
                 )
             else:
                 parser.error(f"Unhandled workflow command: {args.workflow_command}")
+        elif args.command == "generate":
+            if args.generate_command == "init":
+                infospace = init_generation_infospace(
+                    Path(args.workspace),
+                    Path(args.source),
+                    args.slug,
+                    name=args.name,
+                    profile=args.profile,
+                    max_chunks=_optional_positive(args.max_chunks),
+                )
+                _write_json(
+                    {
+                        "slug": infospace.config.slug,
+                        "root": str(infospace.root),
+                        "status": "initialized",
+                    }
+                )
+            elif args.generate_command == "plan":
+                _write_json(plan_generation(Path(args.root), stage=args.stage))
+            elif args.generate_command == "run":
+                _write_json(
+                    run_generation(
+                        Path(args.root),
+                        stage=args.stage,
+                        provider=args.provider,
+                        model=args.model,
+                        fixture_responses=args.fixture_responses or None,
+                        resume=args.resume,
+                        force=args.force,
+                    ).to_dict()
+                )
+            elif args.generate_command == "resume":
+                _write_json(
+                    run_generation(
+                        Path(args.root),
+                        stage=args.stage,
+                        provider=args.provider,
+                        model=args.model,
+                        fixture_responses=args.fixture_responses or None,
+                        resume=True,
+                        force=args.force,
+                    ).to_dict()
+                )
+            elif args.generate_command == "status":
+                _write_json(status_generation(Path(args.root)))
+            elif args.generate_command == "from-source":
+                infospace = init_generation_infospace(
+                    Path(args.workspace),
+                    Path(args.source),
+                    args.slug,
+                    name=args.name,
+                    profile=args.profile,
+                    max_chunks=_optional_positive(args.max_chunks),
+                )
+                if args.apply:
+                    result = run_generation(
+                        infospace.root,
+                        stage=args.stage,
+                        provider=args.provider,
+                        model=args.model,
+                        fixture_responses=args.fixture_responses or None,
+                    )
+                    _write_json(result.to_dict())
+                else:
+                    _write_json(plan_generation(infospace.root, stage=args.stage))
+            else:
+                parser.error(f"Unhandled generate command: {args.generate_command}")
         elif args.command == "engine":
             if args.engine_command == "inspect":
                 _write_json(
@@ -377,3 +516,7 @@ def _relationship_summary_payload(summary) -> dict:
 
 def _write_json(payload: dict) -> None:
     print(json.dumps(payload, indent=2))
+
+
+def _optional_positive(value: int) -> int | None:
+    return value if value > 0 else None