novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/prime_factory/runtime.py

@@ -0,0 +1,261 @@
+"""Canonical event-loop entry and explicit suspended-run continuation."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+from novacode_cli import ui_events as ev
+from novacode_cli.prime_factory import DEFAULT_OUTPUT_LIMIT, ROLES
+from novacode_cli.prime_factory.controller import FactoryController, storage_path
+from novacode_cli.prime_factory.runner import SpecialistRunner
+from novacode_cli.prime_factory.store import FactoryError, FactoryStore
+from novacode_cli.prime_factory.workflow import FactoryWorkflow
+from novacode_cli.prime_memory import session_directory
+
+
+def is_factory_request(text: str, session: Any) -> bool:  # noqa: ANN401 - Session proxies.
+    """Only explicit development goals or selected continuations start factory work."""
+    if getattr(session, "prime_enabled", False) is not True:
+        return False
+    normalized = text.strip().lower()
+    if re.match(
+        r"^(?:(?:can you|could you|please)\s+)?"
+        r"(?:update me\b|test results\b|what\b|why\b|how\b|explain\b|"
+        r"describe\b|show\b|summarize\b|status\b)",
+        normalized,
+    ):
+        return False
+    if getattr(session, "prime_factory_resume", None):
+        return True
+    if normalized.startswith("continue") and getattr(session, "prime_pending", None):
+        return True
+    return bool(
+        re.match(
+            r"^(?:(?:please|can you|could you|i want (?:you )?to)\s+)?"
+            r"(?:fix|build|implement|add|create|replace|refactor|remove|update|upgrade|develop|"
+            r"resolve|repair|complete|test|optimize|migrate|finish)\b",
+            normalized,
+        )
+    )
+
+
+def model_routes(profile: Any, session: Any, agent: Any) -> dict[str, Any]:  # noqa: ANN401 - Framework routes.
+    """Inherit the actual bound session model while keeping configured roles exact."""
+    inherited = getattr(agent, "factory_model_route", None) or profile.get_model_config() or {}
+    override = getattr(session, "cli_model_override", None)
+    if isinstance(override, str) and ":" in override:
+        provider, model = override.split(":", 1)
+        inherited = {"provider": provider, "model": model}
+    routes = {role: profile.get_factory_model(role) or inherited for role in ROLES}
+    session_provider = getattr(session, "session_model_provider", None)
+    if any(not route.get("provider") or not route.get("model") for route in routes.values()):
+        message = "Factory requires explicit provider/model routes or a serializable session model"
+        raise FactoryError(message)
+    if (
+        session_provider
+        and session_provider != inherited.get("provider")
+        and any(not profile.get_factory_model(role) for role in ROLES)
+    ):
+        message = "Session model route is unavailable; configure factory role models"
+        raise FactoryError(message)
+    return routes
+
+
+async def prepare_controller(
+    text: str,
+    session: Any,  # noqa: ANN401 - Session proxies.
+    agent: Any,  # noqa: ANN401 - Compiled graph implementations.
+    store: FactoryStore,
+    root: Path,
+    *,
+    requested_thread: str | None = None,
+) -> FactoryController:
+    """Load a durable continuation or persist a new explicitly requested goal."""
+    requested_thread = session.thread_id if requested_thread is None else requested_thread
+    if session.thread_id != requested_thread:
+        message = "Conversation changed during factory startup; no work was dispatched"
+        raise FactoryError(message)
+    identity = getattr(session, "prime_factory_resume", None)
+    if identity:
+        record = await asyncio.to_thread(store.load, identity)
+        saved_root = await asyncio.to_thread(Path(record["root"]).resolve)
+        if saved_root != root:
+            message = "Resume from the factory's original repository workspace"
+            raise FactoryError(message)
+        record.setdefault("origin_thread", record["thread"])
+        record["thread"] = requested_thread
+        controller = FactoryController(store, record, session)
+        await controller.resume()
+        controller.ensure_active()
+        session.prime_factory_resume = None
+        if record["stage"] not in {"requirements", "research", "architecture", "plan_approval"}:
+            record["stage"] = record["phase"] = "plan_approval"
+        controller.save()
+        session.prime_factory = controller
+        return controller
+    existing = getattr(session, "prime_report", None)
+    if (
+        isinstance(existing, dict)
+        and existing.get("factory")
+        and existing.get("status")
+        not in {
+            "published",
+            "cancelled",
+        }
+    ):
+        message = f"Resume or cancel existing factory run {existing['id']} first"
+        raise FactoryError(message)
+    from novacode_cli.config.nova_config import NovaConfig
+
+    profile = await asyncio.to_thread(NovaConfig)
+    routes = await asyncio.to_thread(model_routes, profile, session, agent)
+    output_limit = profile.get("max_tokens") or DEFAULT_OUTPUT_LIMIT
+    if type(output_limit) is not int or output_limit <= 0:
+        message = "Factory model output limit must be a positive integer"
+        raise FactoryError(message)
+    pending = getattr(session, "prime_pending", None)
+    goal = pending.get("goal", text) if isinstance(pending, dict) else text
+    controller = await asyncio.to_thread(
+        FactoryController.create,
+        root,
+        goal,
+        requested_thread,
+        routes,
+        session=session,
+        store=store,
+    )
+    container = profile.get("team_container")
+    controller.record["output_token_limit"] = output_limit
+    controller.save()
+    if container is not None:
+        if not isinstance(container, dict):
+            message = "Configured container profile is invalid"
+            raise FactoryError(message)
+        controller.record["isolation"] = {
+            "workers": "container",
+            "integration_checks": "worktree",
+            "container_profile": {
+                key: container.get(key)
+                for key in (
+                    "image",
+                    "network",
+                    "user",
+                    "memory",
+                    "cpus",
+                    "readonly",
+                )
+            },
+        }
+        controller.save()
+    controller.ensure_active()
+    session.prime_pending = None
+    session.prime_factory = controller
+    return controller
+
+
+async def iterate_factory_events(  # noqa: PLR0912, PLR0915 - Event stream and cancellation cleanup.
+    text: str,
+    session: Any,  # noqa: ANN401 - Session proxies.
+    *,
+    agent: Any = None,  # noqa: ANN401 - Compiled graph implementations.
+) -> AsyncIterator[Any]:
+    """Drive host transitions while keeping approval routing in the originating consumer."""
+    controller = None
+    driver = None
+    store = None
+    originating_thread = session.thread_id
+    try:
+        root = await asyncio.to_thread(lambda: Path(session_directory(session)).resolve())
+        store = await asyncio.to_thread(FactoryStore, storage_path(root))
+        controller = await prepare_controller(
+            text,
+            session,
+            agent,
+            store,
+            root,
+            requested_thread=originating_thread,
+        )
+        if agent is not None:
+            from langchain_core.messages import HumanMessage
+
+            await agent.aupdate_state(
+                {"configurable": {"thread_id": controller.record["thread"]}},
+                {"messages": [HumanMessage(text, id=uuid.uuid4().hex)]},
+            )
+        runner = SpecialistRunner(controller)
+        workflow = await asyncio.to_thread(FactoryWorkflow, controller, runner)
+        driver = asyncio.create_task(
+            workflow.run(), name=f"prime-factory-{controller.record['id']}"
+        )
+        while not driver.done() or not controller.events.empty():
+            try:
+                event = await asyncio.wait_for(controller.events.get(), timeout=0.25)
+            except TimeoutError:
+                continue
+            if session.thread_id != controller.record["thread"]:
+                controller.request_pause()
+                if isinstance(event, ev.InterruptRequest) and not event.future.done():
+                    event.future.set_result({"response": {"approved": False}})
+                continue
+            yield event
+        await driver
+        if session.thread_id != controller.record["thread"]:
+            yield ev.Done(had_response=False)
+            return
+        report = controller.record
+        message = f"Prime factory {report['id']} · {report['status']} · {report['stage']}"
+        if report["blockers"]:
+            message += "\n" + "\n".join(report["blockers"])
+        if report["status"] not in {"published", "cancelled"}:
+            message += f"\nContinue with /prime resume {report['id']}."
+        if agent is not None:
+            from langchain_core.messages import AIMessage
+
+            await agent.aupdate_state(
+                {"configurable": {"thread_id": controller.record["thread"]}},
+                {"messages": [AIMessage(message, id=uuid.uuid4().hex)]},
+            )
+        if session.thread_id != controller.record["thread"]:
+            yield ev.Done(had_response=False)
+            return
+        yield ev.ContextMessage(
+            message,
+            event_type="nova_prime_receipt",
+            record_id=report["id"],
+            data=controller.progress(),
+        )
+        # Headless consumers need a useful continuation in their final result too.
+        yield ev.AssistantMessage(text=message, agent_name="Prime", agent_color="cyan")
+        yield ev.Done(had_response=True)
+    except asyncio.CancelledError:
+        if controller is not None:
+            controller.request_pause()
+        raise
+    except Exception as exc:  # noqa: BLE001 - Frontends receive durable failure state.
+        if controller is not None and not controller._storage_failed:
+            controller.record["blockers"] = [str(exc)]
+            controller.request_pause()
+        if session.thread_id != originating_thread:
+            yield ev.Done(had_response=False)
+            return
+        yield ev.Error(f"Prime factory suspended: {exc}")
+        yield ev.Done(had_response=False)
+    finally:
+        if driver is not None and not driver.done():
+            driver.cancel()
+            await asyncio.gather(driver, return_exceptions=True)
+        if controller is not None:
+            try:
+                await controller.stop_workers()
+            finally:
+                if getattr(session, "prime_factory", None) is controller:
+                    session.prime_factory = None
+        if store is not None:
+            await asyncio.to_thread(store.close)

novacode_cli/prime_factory/state.py

@@ -0,0 +1,201 @@
+"""Validated factory plans and immutable acceptance definitions."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import PurePosixPath, PureWindowsPath
+from typing import Any
+
+from novacode_cli.prime_factory.store import FactoryError
+
+MAX_OWNED_FILES = 128
+MAX_TASKS = 64
+MAX_CHECKS = 32
+MAX_ARGV = 64
+MAX_ASSERTIONS = 8
+
+
+def digest(value: object) -> str:
+    """Hash lossless canonical data for approvals and observed evidence."""
+    return hashlib.sha256(json.dumps(value, sort_keys=True, allow_nan=False).encode()).hexdigest()
+
+
+def bounded_text(value: object, limit: int = 4000) -> str:
+    """Reject truncated or missing worker assertions."""
+    if not isinstance(value, str) or not value.strip() or len(value) > limit:
+        msg = "Expected bounded nonempty text"
+        raise FactoryError(msg)
+    return value
+
+
+def paths(value: object) -> list[str]:
+    """Validate repository-relative ownership, including Windows on Linux hosts."""
+    if not isinstance(value, list) or len(value) > MAX_OWNED_FILES:
+        msg = "Expected at most 128 owned files"
+        raise FactoryError(msg)
+    result = []
+    for item in value:
+        name = bounded_text(item, 500).replace("\\", "/")
+        path = PurePosixPath(name)
+        if (
+            path.is_absolute()
+            or PureWindowsPath(name).drive
+            or ".." in path.parts
+            or any(part in {".git", ".nova", ".env", ".aws", ".codex"} for part in path.parts)
+            or any(char in name for char in "*?[]\x00\n\r")
+        ):
+            msg = "Ownership must name explicit repository files"
+            raise FactoryError(msg)
+        result.append(path.as_posix())
+    if len(result) != len(set(result)):
+        msg = "Duplicate file ownership"
+        raise FactoryError(msg)
+    return result
+
+
+def validate_tasks(value: object) -> list[dict[str, Any]]:
+    """Require an acyclic dependency graph before approving any implementation."""
+    if not isinstance(value, list) or not 1 <= len(value) <= MAX_TASKS:
+        msg = "Plan requires 1-64 tasks"
+        raise FactoryError(msg)
+    tasks: list[dict[str, Any]] = []
+    for raw in value:
+        if not isinstance(raw, dict):
+            msg = "Invalid task"
+            raise FactoryError(msg)
+        key = bounded_text(raw.get("id"), 60)
+        if not key.replace("_", "").replace("-", "").isalnum():
+            msg = "Task IDs must be simple identifiers"
+            raise FactoryError(msg)
+        dependencies = raw.get("depends_on", [])
+        if not isinstance(dependencies, list) or any(not isinstance(d, str) for d in dependencies):
+            msg = "Invalid task dependencies"
+            raise FactoryError(msg)
+        tasks.append(
+            {
+                "id": key,
+                "description": bounded_text(raw.get("description")),
+                "files": paths(raw.get("files")),
+                "depends_on": dependencies,
+                "status": "pending",
+                "attempts": [],
+            }
+        )
+    keys = {task["id"] for task in tasks}
+    if len(keys) != len(tasks):
+        msg = "Duplicate task IDs"
+        raise FactoryError(msg)
+    resolved: set[str] = set()
+    while len(resolved) < len(tasks):
+        ready = {t["id"] for t in tasks if set(t["depends_on"]) <= resolved}
+        if ready <= resolved:
+            msg = "Task dependencies contain a cycle or unknown task"
+            raise FactoryError(msg)
+        resolved |= ready
+    return tasks
+
+
+def check_definition(check: dict[str, Any]) -> dict[str, Any]:
+    """Keep approval and execution signatures on the same acceptance fields."""
+    return {
+        **{key: check[key] for key in ("argv", "criteria", "purpose", "test_first", "security")},
+        **{key: check.get(key, []) for key in ("tasks", "contains", "failure_contains")},
+    }
+
+
+def validate_checks(
+    value: object, criteria: list[str], task_ids: set[str] | list[str] | None = None
+) -> list[dict[str, Any]]:
+    """Assign identity from definitions so renaming cannot reset repair limits."""
+    if not isinstance(value, list) or not 1 <= len(value) <= MAX_CHECKS:
+        msg = "Define 1-32 acceptance checks"
+        raise FactoryError(msg)
+    result: list[dict[str, Any]] = []
+    for raw in value:
+        if not isinstance(raw, dict):
+            msg = "Invalid acceptance definition"
+            raise FactoryError(msg)
+        argv = raw.get("argv")
+        indexes = raw.get("criteria")
+        if not isinstance(argv, list) or not argv or len(argv) > MAX_ARGV:
+            msg = "Checks require command argument arrays"
+            raise FactoryError(msg)
+        argv = [bounded_text(arg, 2000) for arg in argv]
+        if (
+            not isinstance(indexes, list)
+            or not indexes
+            or any(type(i) is not int or not 0 <= i < len(criteria) for i in indexes)
+        ):
+            msg = "Checks must cover existing acceptance criteria"
+            raise FactoryError(msg)
+        owners = raw.get("tasks", sorted(task_ids or []))
+        if (
+            not isinstance(owners, list)
+            or any(not isinstance(owner, str) for owner in owners)
+            or len(owners) != len(set(owners))
+            or (task_ids is not None and (not owners or not set(owners) <= set(task_ids)))
+        ):
+            msg = "Acceptance tasks must identify responsible planned tasks"
+            raise FactoryError(msg)
+        assertions = {}
+        for field in ("contains", "failure_contains"):
+            expected = raw.get(field, [])
+            if not isinstance(expected, list) or len(expected) > MAX_ASSERTIONS:
+                msg = "Acceptance output assertions require at most eight literals"
+                raise FactoryError(msg)
+            assertions[field] = [bounded_text(term, 500) for term in expected]
+        definition = {
+            "argv": argv,
+            "criteria": sorted(set(indexes)),
+            "purpose": bounded_text(raw.get("purpose")),
+            "test_first": raw.get("test_first") is True,
+            "security": raw.get("security") is True,
+            "tasks": sorted(owners),
+            **assertions,
+        }
+        result.append(
+            {
+                **definition,
+                "id": digest(definition),
+                "failures": 0,
+                "status": "pending",
+                "evidence": [],
+            }
+        )
+    if len({c["id"] for c in result}) != len(result):
+        msg = "Duplicate acceptance definitions"
+        raise FactoryError(msg)
+    if {i for c in result for i in c["criteria"]} != set(range(len(criteria))):
+        msg = "Every criterion needs an acceptance check"
+        raise FactoryError(msg)
+    return result
+
+
+def plan_definition(record: dict[str, Any]) -> dict[str, Any]:
+    """Include every approval-relevant field while excluding mutable task/check status."""
+    return {
+        "goal": record["goal"],
+        "criteria": record["criteria"],
+        "tasks": [
+            {k: t[k] for k in ("id", "description", "files", "depends_on")} for t in record["tasks"]
+        ],
+        "checks": [{"id": c["id"], **check_definition(c)} for c in record["checks"]],
+        **{
+            key: record.get(key)
+            for key in (
+                "decisions",
+                "sources",
+                "research_requirements",
+                "research_exemption",
+                "isolation",
+                "routes",
+                "budget",
+                "output_token_limit",
+                "setup",
+                "test_files",
+                "destination",
+                "baseline_selection",
+            )
+        },
+    }

novacode_cli/prime_factory/store.py

@@ -0,0 +1,128 @@
+"""Atomic factory snapshots with optimistic writer fencing."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from threading import RLock
+from typing import TYPE_CHECKING, Any
+
+from novacode_cli.prime_factory import DEFAULT_OUTPUT_LIMIT, VERSION
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class FactoryError(ValueError):
+    """A factory invariant requires intervention before work can continue."""
+
+
+def listing(record: dict[str, Any]) -> dict[str, Any]:
+    """Project bounded display metadata separately from execution and publication artifacts."""
+    result = {
+        key: record[key]
+        for key in (
+            "id",
+            "version",
+            "factory",
+            "thread",
+            "root",
+            "goal",
+            "stage",
+            "phase",
+            "status",
+        )
+        if key in record
+    }
+    result["summary_only"] = True
+    result["checks"] = [
+        {"id": check["id"], "status": check["status"], "purpose": check.get("purpose", "")[:300]}
+        for check in record.get("checks", [])
+    ]
+    return result
+
+
+class FactoryStore:
+    """Commit complete snapshots before dispatching side effects."""
+
+    def __init__(self, path: Path) -> None:
+        """Open repository-local storage; failures propagate to the caller."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self.lock = RLock()
+        self.db = sqlite3.connect(path, timeout=5, check_same_thread=False)
+        self.db.execute("PRAGMA journal_mode=WAL")
+        self.db.execute("PRAGMA synchronous=FULL")
+        self.db.execute(
+            "CREATE TABLE IF NOT EXISTS runs (id TEXT PRIMARY KEY, revision INTEGER, body TEXT)"
+        )
+        columns = {row[1] for row in self.db.execute("PRAGMA table_info(runs)")}
+        if "summary" not in columns:
+            self.db.execute("ALTER TABLE runs ADD COLUMN summary TEXT")
+        self.db.commit()
+
+    def save(self, record: dict[str, Any]) -> None:
+        """Reject stale controllers rather than allowing two schedulers to dispatch."""
+        with self.lock:
+            revision = record.get("store_revision", 0)
+            snapshot = {**record, "store_revision": revision + 1}
+            encoded = json.dumps(snapshot, allow_nan=False, sort_keys=True)
+            from novacode_cli.security.prompt_injection import _credential_values
+
+            if any(json.dumps(secret)[1:-1] in encoded for secret in _credential_values()):
+                message = "Factory records cannot contain credentials; use environment references"
+                raise FactoryError(message)
+            summary = json.dumps(listing(snapshot), allow_nan=False)
+            with self.db:
+                if revision == 0:
+                    self.db.execute(
+                        "INSERT INTO runs (id, revision, body, summary) VALUES (?, ?, ?, ?)",
+                        (record["id"], 1, encoded, summary),
+                    )
+                else:
+                    cursor = self.db.execute(
+                        "UPDATE runs SET revision=?, body=?, summary=? WHERE id=? AND revision=?",
+                        (revision + 1, encoded, summary, record["id"], revision),
+                    )
+                    if cursor.rowcount != 1:
+                        msg = "Factory ownership changed; reload before continuing"
+                        raise FactoryError(msg)
+            record["store_revision"] = revision + 1
+
+    def load(self, identity: str) -> dict[str, Any]:
+        """Read only this repository's versioned factory records."""
+        with self.lock:
+            row = self.db.execute("SELECT body FROM runs WHERE id=?", (identity,)).fetchone()
+        if row is None:
+            msg = "Factory run not found in this repository"
+            raise FactoryError(msg)
+        record = json.loads(row[0])
+        if record.get("version") != VERSION or record.get("factory") is not True:
+            msg = "Unsupported factory record version"
+            raise FactoryError(msg)
+        record.setdefault("output_token_limit", DEFAULT_OUTPUT_LIMIT)
+        return record
+
+    def records(self) -> list[dict[str, Any]]:
+        """Return bounded recent summaries without loading command output."""
+        with self.lock:
+            rows = self.db.execute(
+                "SELECT id, summary FROM runs ORDER BY rowid DESC LIMIT 50"
+            ).fetchall()
+            result = []
+            for identity, stored_summary in rows:
+                summary = stored_summary
+                if summary is None:
+                    # Upgrade one old record at a time, never materialize fifty full histories.
+                    record = self.load(identity)
+                    summary = json.dumps(listing(record))
+                    with self.db:
+                        self.db.execute(
+                            "UPDATE runs SET summary=? WHERE id=? AND revision=?",
+                            (summary, identity, record["store_revision"]),
+                        )
+                result.append(json.loads(summary))
+            return result
+
+    def close(self) -> None:
+        """Release the database after all owned workers have stopped."""
+        self.db.close()