cortex-loop 0.1.0a1__py3-none-any.whl

cortex/invariants.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Iterable
+
+from .genome import HooksConfig, InvariantsConfig
+from .store import SQLiteStore
+
+
+@dataclass(slots=True)
+class InvariantCaseResult:
+    test_path: str
+    status: str
+    duration_ms: int
+    stdout: str
+    stderr: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "test_path": self.test_path,
+            "status": self.status,
+            "duration_ms": self.duration_ms,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+        }
+
+
+@dataclass(slots=True)
+class InvariantReport:
+    configured_paths: list[str]
+    results: list[InvariantCaseResult] = field(default_factory=list)
+    diagnostics: list[dict[str, Any]] = field(default_factory=list)
+    ok: bool = True
+    had_errors: bool = False
+    recommend_revert: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "configured_paths": self.configured_paths,
+            "results": [r.to_dict() for r in self.results],
+            "diagnostics": self.diagnostics,
+            "ok": self.ok,
+            "had_errors": self.had_errors,
+            "recommend_revert": self.recommend_revert,
+        }
+
+
+class InvariantRunner:
+    def __init__(
+        self,
+        repo_root: Path,
+        store: SQLiteStore,
+        config: InvariantsConfig,
+        hooks_config: HooksConfig,
+        *,
+        trust_profile: str = "trusted",
+    ) -> None:
+        self.repo_root = repo_root.resolve()
+        self.store = store
+        self.config = config
+        self.hooks_config = hooks_config
+        self.trust_profile = trust_profile if trust_profile in {"trusted", "untrusted"} else "untrusted"
+
+    def run(self, session_id: str, extra_pytest_args: Iterable[str] | None = None) -> InvariantReport:
+        report = InvariantReport(configured_paths=list(self.config.suite_paths))
+        args = list(extra_pytest_args or [])
+        if self.trust_profile == "untrusted" and self.config.execution_mode == "host":
+            result = InvariantCaseResult(
+                test_path="__policy__",
+                status="error",
+                duration_ms=0,
+                stdout="",
+                stderr=(
+                    "Host invariant execution is blocked for trust_profile='untrusted'. "
+                    "Set [invariants].execution_mode='container' or [project].trust_profile='trusted'."
+                ),
+            )
+            report.results.append(result)
+            report.diagnostics.append(_invariant_diagnostic(result))
+            report.ok = False
+            report.had_errors = True
+            self.store.record_invariant_result(
+                session_id=session_id,
+                test_path=result.test_path,
+                status=result.status,
+                duration_ms=result.duration_ms,
+                stdout=result.stdout,
+                stderr=result.stderr,
+            )
+            report.recommend_revert = self.hooks_config.recommend_revert_on_invariant_failure
+            return report
+
+        for suite_path in self.config.suite_paths:
+            result = self._run_one(session_id=session_id, suite_path=suite_path, extra_args=args)
+            report.results.append(result)
+            if result.status in {"fail", "error", "missing"}:
+                report.diagnostics.append(_invariant_diagnostic(result))
+            self.store.record_invariant_result(
+                session_id=session_id,
+                test_path=result.test_path,
+                status=result.status,
+                duration_ms=result.duration_ms,
+                stdout=result.stdout,
+                stderr=result.stderr,
+            )
+            if result.status in {"fail", "error", "missing"}:
+                report.ok = False
+            if result.status == "error":
+                report.had_errors = True
+
+        if not report.ok:
+            report.recommend_revert = self.hooks_config.recommend_revert_on_invariant_failure
+        return report
+
+    def promote_session_test(self, session_id: str, source_path: str | Path) -> Path:
+        source = (self.repo_root / source_path).resolve() if not Path(source_path).is_absolute() else Path(source_path)
+        target_dir = self.repo_root / self.config.graduation.target_dir
+        target_dir.mkdir(parents=True, exist_ok=True)
+        target = target_dir / source.name
+        shutil.copy2(source, target)
+        self.store.record_invariant_result(
+            session_id=session_id,
+            test_path=str(target.relative_to(self.repo_root)),
+            status="graduated",
+            duration_ms=0,
+            stdout="",
+            stderr="",
+            graduated_from=str(source),
+        )
+        return target
+
+    def _run_one(self, *, session_id: str, suite_path: str, extra_args: list[str]) -> InvariantCaseResult:
+        path = self.repo_root / suite_path
+        if not path.exists():
+            return InvariantCaseResult(
+                test_path=suite_path,
+                status="missing",
+                duration_ms=0,
+                stdout="",
+                stderr=f"Invariant path not found: {suite_path}",
+            )
+
+        started = time.perf_counter()
+        try:
+            cmd = self._pytest_command(path=path, suite_path=suite_path, extra_args=extra_args, session_id=session_id)
+        except ValueError as exc:
+            return InvariantCaseResult(
+                test_path=suite_path,
+                status="error",
+                duration_ms=int((time.perf_counter() - started) * 1000),
+                stdout="",
+                stderr=str(exc),
+            )
+        env = None
+        if self.config.execution_mode != "container":
+            env = os.environ.copy()
+            env["CORTEX_SESSION_ID"] = str(session_id)
+            env["CORTEX_PROJECT_ROOT"] = str(self.repo_root)
+        try:
+            proc = subprocess.run(
+                cmd,
+                cwd=self.repo_root,
+                env=env,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+        except FileNotFoundError as exc:
+            return InvariantCaseResult(
+                test_path=suite_path,
+                status="error",
+                duration_ms=int((time.perf_counter() - started) * 1000),
+                stdout="",
+                stderr=str(exc),
+            )
+
+        duration_ms = int((time.perf_counter() - started) * 1000)
+        status = "pass" if proc.returncode == 0 else "fail"
+        return InvariantCaseResult(
+            test_path=suite_path,
+            status=status,
+            duration_ms=duration_ms,
+            stdout=proc.stdout.strip(),
+            stderr=proc.stderr.strip(),
+        )
+
+    def _pytest_command(
+        self,
+        *,
+        path: Path,
+        suite_path: str,
+        extra_args: list[str],
+        session_id: str,
+    ) -> list[str]:
+        if self.config.execution_mode != "container":
+            return self._host_pytest_command(path=path, extra_args=extra_args)
+        target = self._container_suite_path(path, suite_path)
+        return [
+            self.config.container_engine,
+            "run",
+            "--rm",
+            "-e",
+            f"CORTEX_SESSION_ID={session_id}",
+            "-e",
+            f"CORTEX_PROJECT_ROOT={self.config.container_workdir}",
+            "-v",
+            f"{self.repo_root}:{self.config.container_workdir}",
+            "-w",
+            self.config.container_workdir,
+            self.config.container_image,
+            "python",
+            "-m",
+            "pytest",
+            target,
+            *extra_args,
+        ]
+
+    def _host_pytest_command(self, *, path: Path, extra_args: list[str]) -> list[str]:
+        configured = str(self.config.pytest_bin).strip() or "pytest"
+        configured_path = Path(configured).expanduser()
+        if configured_path.is_absolute() and configured_path.exists():
+            return [str(configured_path), str(path), *extra_args]
+        if any(sep in configured for sep in ("/", "\\")):
+            repo_relative = (self.repo_root / configured_path).resolve()
+            if repo_relative.exists():
+                return [str(repo_relative), str(path), *extra_args]
+            if configured_path.exists():
+                return [str(configured_path.resolve()), str(path), *extra_args]
+        elif shutil.which(configured):
+            return [configured, str(path), *extra_args]
+        if importlib.util.find_spec("pytest") is not None:
+            return [sys.executable, "-m", "pytest", str(path), *extra_args]
+        raise ValueError(
+            f"Configured pytest_bin '{configured}' is unavailable and fallback 'python -m pytest' is not installed."
+        )
+
+    def _container_suite_path(self, path: Path, suite_path: str) -> str:
+        try:
+            return str(path.resolve().relative_to(self.repo_root))
+        except ValueError as exc:
+            raise ValueError(
+                f"Container invariant path is outside repo root: {path.resolve()} (root: {self.repo_root})"
+            ) from exc
+
+
+def _invariant_diagnostic(result: InvariantCaseResult) -> dict[str, Any]:
+    if result.status == "missing":
+        return {"evidence_found": [result.test_path], "evidence_expected": ["configured invariant test path to exist"], "gap_description": f"Invariant path '{result.test_path}' was missing.", "gap_characterization": "comprehension_gap", "distance_signal": "far"}
+    if result.status == "error":
+        return {"evidence_found": [result.stderr[:200]] if result.stderr else [result.test_path], "evidence_expected": [f"invariant '{result.test_path}' to run successfully"], "gap_description": f"Invariant '{result.test_path}' could not execute cleanly.", "gap_characterization": "execution_gap", "distance_signal": "moderate"}
+    return {"evidence_found": [result.test_path], "evidence_expected": [f"invariant '{result.test_path}' to pass"], "gap_description": f"Invariant '{result.test_path}' failed.", "gap_characterization": "execution_gap", "distance_signal": "close"}

cortex/packs.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+PACK_SCHEMA_VERSION = "cortex_pack_v1"
+
+
+@dataclass(slots=True)
+class PackOverlay:
+    challenge_categories: list[str] = field(default_factory=list)
+    invariant_paths: list[str] = field(default_factory=list)
+    blocked_tools: list[str] = field(default_factory=list)
+    allowed_tools: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+
+def load_pack_overlay(*, root: Path, pack_paths: list[str]) -> PackOverlay:
+    overlay = PackOverlay()
+    for raw_path in pack_paths:
+        declared_path = str(raw_path).strip()
+        if not declared_path:
+            continue
+        manifest_path = (
+            Path(declared_path).expanduser()
+            if Path(declared_path).is_absolute()
+            else (root / declared_path).expanduser()
+        ).resolve()
+        if not manifest_path.exists():
+            overlay.warnings.append(f"Pack manifest not found: {declared_path}")
+            continue
+        try:
+            with manifest_path.open("rb") as fh:
+                payload = tomllib.load(fh)
+        except Exception as exc:  # noqa: BLE001
+            overlay.warnings.append(f"Pack manifest parse error in {manifest_path}: {exc}")
+            continue
+        if not isinstance(payload, dict):
+            overlay.warnings.append(f"Pack manifest must be a TOML table: {manifest_path}")
+            continue
+
+        schema = str(payload.get("schema") or "").strip()
+        if schema != PACK_SCHEMA_VERSION:
+            overlay.warnings.append(
+                f"Unsupported pack schema in {manifest_path}: {schema or 'missing'} "
+                f"(expected {PACK_SCHEMA_VERSION})"
+            )
+            continue
+
+        pack_id = str(payload.get("pack_id") or manifest_path.stem).strip() or manifest_path.stem
+        categories = _as_str_list(payload.get("challenge_categories"))
+        invariants = _as_str_list(payload.get("invariant_paths"))
+        blocked_tools = _as_str_list(payload.get("blocked_tools"))
+        allowed_tools = _as_str_list(payload.get("allowed_tools"))
+        if not (categories or invariants or blocked_tools or allowed_tools):
+            overlay.warnings.append(f"Pack '{pack_id}' declares no challenges/invariants/blocklist entries.")
+            continue
+
+        overlay.challenge_categories.extend(categories)
+        overlay.invariant_paths.extend(
+            _resolve_invariant_paths(
+                repo_root=root,
+                manifest_dir=manifest_path.parent,
+                invariant_paths=invariants,
+            )
+        )
+        overlay.blocked_tools.extend(blocked_tools)
+        overlay.allowed_tools.extend(allowed_tools)
+
+    overlay.challenge_categories = _unique_nonempty(overlay.challenge_categories)
+    overlay.invariant_paths = _unique_nonempty(overlay.invariant_paths)
+    overlay.blocked_tools = _unique_nonempty(overlay.blocked_tools)
+    overlay.allowed_tools = _unique_nonempty(overlay.allowed_tools)
+    overlay.warnings = _unique_nonempty(overlay.warnings)
+    return overlay
+
+
+def _resolve_invariant_paths(
+    *,
+    repo_root: Path,
+    manifest_dir: Path,
+    invariant_paths: list[str],
+) -> list[str]:
+    resolved: list[str] = []
+    for value in invariant_paths:
+        path = Path(value)
+        if path.is_absolute():
+            candidate = path.resolve()
+        else:
+            # Prefer repo-root-relative paths so pack manifests can be dropped into a project
+            # without requiring path rewrites for test suites that already use repo-relative layout.
+            root_candidate = (repo_root / path).resolve()
+            manifest_candidate = (manifest_dir / path).resolve()
+            candidate = root_candidate if (root_candidate.exists() or not manifest_candidate.exists()) else manifest_candidate
+        try:
+            candidate = candidate.relative_to(repo_root)
+        except ValueError:
+            pass
+        resolved.append(candidate.as_posix() if isinstance(candidate, Path) else str(candidate))
+    return resolved
+
+
+def _as_str_list(value: Any) -> list[str]:
+    return [str(v).strip() for v in value] if isinstance(value, list) else []
+
+
+def _unique_nonempty(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for item in values:
+        token = str(item).strip()
+        if not token or token in seen:
+            continue
+        seen.add(token)
+        result.append(token)
+    return result

cortex/repomap.py

@@ -0,0 +1,6 @@
+import sys
+from importlib import import_module
+from types import ModuleType
+
+_IMPL = import_module("cortex_repomap.engine")
+sys.modules[__name__].__class__ = type("_ShimModule", (ModuleType,), {"__getattr__": lambda self, name: getattr(_IMPL, name), "__setattr__": lambda self, name, value: (setattr(_IMPL, name, value), ModuleType.__setattr__(self, name, value))[1]})