core-runtime 0.1.1__py3-none-any.whl

body/services/crate_creation_service.py

@@ -0,0 +1,217 @@
+# src/body/services/crate_creation_service.py
+
+"""
+Service for creating Intent Crates from generated code.
+
+Packages code, tests, and metadata into constitutionally-compliant crates
+that can be processed by CrateProcessingService with canary validation.
+
+UNIX-Compliant Methodology:
+- This is a "Body" component: it executes the packaging but makes no decisions.
+- It is the "Staging Area" between the SpecificationAgent and ExecutionAgent.
+
+Policy Alignment:
+- Headless: Uses standard logging only.
+- Safe-by-Default: Validates all paths before touching the disk.
+- Governed: All mutations route through FileHandler (IntentGuard enforced).
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+from shared.action_types import ActionImpact, ActionResult
+from shared.atomic_action import atomic_action
+
+# REFACTORED: Removed direct settings import
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+logger = getLogger(__name__)
+
+
+# ID: 8051b110-89d6-44f9-b787-21a3d58519b5
+class CrateCreationService:
+    """
+    Creates Intent Crates from generated code.
+    Acts as the bridge between Engineering (Will) and Construction (Body).
+    """
+
+    def __init__(self, core_context: CoreContext) -> None:
+        """
+        Initialize service with the system context.
+
+        Args:
+            core_context: The central container for system services.
+        """
+        self.context = core_context
+
+        # REFACTOR: Access repo_path via context -> git_service
+        self.repo_path = core_context.git_service.repo_path
+
+        # REFACTOR: Construct canonical inbox path manually (var/workflows/crates/inbox)
+        # This avoids depending on 'context.settings.paths'
+        self.inbox_path = self.repo_path / "var" / "workflows" / "crates" / "inbox"
+
+        self.fs = core_context.file_handler
+
+    @atomic_action(
+        action_id="crate.create",
+        intent="Package generated code into an Intent Crate for canary validation",
+        impact=ActionImpact.WRITE_DATA,
+        policies=["body_contracts", "intent_crate_schema"],
+        category="orchestration",
+    )
+    # ID: dc96d08d-72ec-407e-b087-349423ed66ef
+    async def create_intent_crate(
+        self,
+        intent: str,
+        payload_files: dict[str, str],
+        crate_type: str = "STANDARD",
+        metadata: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> ActionResult:
+        """
+        The core logic to build a Crate. Returns an ActionResult for the Orchestrator.
+        """
+        start_time = time.time()
+        crate_id = self._generate_crate_id()
+        crate_path = self.inbox_path / crate_id
+
+        # Convert to repo-relative path for FileHandler
+        crate_rel = self._to_repo_rel(crate_path)
+
+        try:
+            # 1. Path Safety Check (Constitutional Guard)
+            path_errors = self.validate_payload_paths(payload_files)
+            if path_errors:
+                return ActionResult(
+                    action_id="crate.create",
+                    ok=False,
+                    data={
+                        "error": "Forbidden paths in payload",
+                        "details": path_errors,
+                    },
+                    duration_sec=time.time() - start_time,
+                )
+
+            # 2. Create directory (Governed Mutation)
+            self.fs.ensure_dir(crate_rel)
+
+            # 3. Create Manifest
+            # REFACTOR: Use standard datetime formatting instead of settings helper
+            timestamp = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+            manifest = {
+                "crate_id": crate_id,
+                "author": "CoderAgent",
+                "intent": intent,
+                "type": "CODE_MODIFICATION" if crate_type == "STANDARD" else crate_type,
+                "created_at": timestamp,
+                "metadata": metadata or {},
+                "payload_files": list(payload_files.keys()),
+            }
+
+            # 4. Write Manifest & Payload (IntentGuard Enforced)
+            self.fs.write_runtime_text(
+                f"{crate_rel}/manifest.yaml", yaml.dump(manifest, sort_keys=False)
+            )
+
+            for rel_path, content in payload_files.items():
+                # Ensure we don't allow traversal or absolute paths
+                safe_file_rel = f"{crate_rel}/{rel_path.lstrip('/')}"
+                self.fs.write_runtime_text(safe_file_rel, content)
+
+            logger.info("Successfully created Crate: %s", crate_id)
+
+            return ActionResult(
+                action_id="crate.create",
+                ok=True,
+                data={
+                    "crate_id": crate_id,
+                    "path": crate_rel,
+                    "file_count": len(payload_files),
+                },
+                duration_sec=time.time() - start_time,
+                impact=ActionImpact.WRITE_DATA,
+            )
+
+        except Exception as e:
+            logger.error("Crate creation failed: %s", e, exc_info=True)
+            # Cleanup on failure via governed surface
+            self.fs.remove_tree(crate_rel)
+
+            return ActionResult(
+                action_id="crate.create",
+                ok=False,
+                data={"error": str(e)},
+                duration_sec=time.time() - start_time,
+            )
+
+    def _generate_crate_id(self) -> str:
+        """Generate a deterministic, stable ID for the transaction."""
+        return f"fix_{uuid.uuid4().hex[:8]}"
+
+    # ID: 356375c5-8d95-441f-90ec-967f38794f35
+    def validate_payload_paths(self, payload_files: dict[str, str]) -> list[str]:
+        """
+        Enforce Constitutional path boundaries.
+        CORE must never write to .intent/** or keys/**.
+        """
+        errors: list[str] = []
+        forbidden_roots = [".intent", "var/keys", "var/cache"]
+
+        for path_str in payload_files.keys():
+            p = Path(path_str)
+            if p.is_absolute():
+                errors.append(f"Absolute path forbidden: {path_str}")
+                continue
+
+            normalized = p.as_posix()
+            if any(normalized.startswith(root) for root in forbidden_roots):
+                errors.append(f"Constitutional boundary violation: {path_str}")
+
+            if ".." in normalized:
+                errors.append(f"Path traversal detected: {path_str}")
+
+        return errors
+
+    def _to_repo_rel(self, p: Path) -> str:
+        """Internal helper to ensure paths are compatible with FileHandler."""
+        try:
+            return str(p.relative_to(self.repo_path))
+        except ValueError:
+            # If it's already relative, just return it
+            return str(p)
+
+
+@atomic_action(
+    action_id="crate.create_from_spec",
+    intent="Atomic action for create_crate_from_spec",
+    impact=ActionImpact.WRITE_CODE,
+    policies=["atomic_actions"],
+)
+# ID: d7ec3f85-f7ba-4b08-8389-bd76082f9606
+async def create_crate_from_spec(
+    context: CoreContext,
+    intent: str,
+    files_generated: dict[str, str],
+    metadata: dict[str, Any] | None = None,
+    **kwargs,
+) -> ActionResult:
+    """
+    Convenience wrapper for SpecificationAgent.
+    """
+    service = CrateCreationService(context)
+    return await service.create_intent_crate(
+        intent=intent, payload_files=files_generated, metadata=metadata
+    )

body/services/crate_processing_service.py

@@ -0,0 +1,279 @@
+# src/body/services/crate_processing_service.py
+
+"""
+CrateProcessingService - The Constitutional Judge
+
+Orchestrates the lifecycle of an Intent Crate: validation, canary testing,
+and final reporting. This service ensures that proposed changes are
+proven safe in a sandbox before being accepted into the Body.
+
+A3 Methodology:
+- Supports surgical validation by Crate ID for iterative retry loops.
+- Enforces Canary thresholds defined in operations.json.
+- Headless execution for background automation.
+"""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+import yaml
+
+from body.crate_processing.canary_executor import CanaryExecutor, CanaryResult
+from body.introspection.knowledge_graph_service import KnowledgeGraphBuilder
+from mind.governance.audit_context import AuditorContext
+from mind.governance.auditor import ConstitutionalAuditor
+from shared.action_logger import action_logger
+from shared.context import CoreContext
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.models import AuditFinding, AuditSeverity
+from shared.path_resolver import PathResolver
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: 96730f37-f39b-4241-9409-8c4664520beb
+class Crate:
+    """A simple data class representing a validated Intent Crate."""
+
+    path: Path
+    manifest: dict[str, Any]
+
+
+# ID: 26ed379a-875e-4df0-9596-f053baadca66
+class CrateProcessingService:
+    """
+    Validates and processes Intent Crates via Canary sandboxing.
+    """
+
+    def __init__(self, core_context: CoreContext):
+        """Initializes service using PathResolver (SSOT)."""
+        self.core_context = core_context
+        self.repo_root = core_context.git_service.repo_path.resolve()
+        self._fh = core_context.file_handler or FileHandler(str(self.repo_root))
+        self._paths = PathResolver.from_repo(
+            repo_root=self.repo_root, intent_root=self.repo_root / ".intent"
+        )
+
+        # Use canonical paths from PathResolver
+        self.inbox_path = self._paths.workflows_dir / "crates" / "inbox"
+        self.processing_path = self._paths.workflows_dir / "crates" / "processing"
+        self.accepted_path = self._paths.workflows_dir / "crates" / "accepted"
+        self.rejected_path = self._paths.workflows_dir / "crates" / "rejected"
+
+        # Initialize Logic components
+        try:
+            from shared.infrastructure.intent.intent_repository import (
+                get_intent_repository,
+            )
+
+            intent_repo = get_intent_repository()
+            ops_policy = intent_repo.load_policy("policies/operations")
+            self.canary_config = ops_policy.get("canary", {"enabled": True})
+        except Exception:
+            self.canary_config = {"enabled": True}
+
+        self.canary_executor = CanaryExecutor(self.canary_config)
+
+        try:
+            from shared.infrastructure.intent.intent_repository import (
+                get_intent_repository,
+            )
+
+            intent_repo = get_intent_repository()
+            self.crate_schema = intent_repo.load_document(
+                self._paths.intent_root
+                / "schemas"
+                / "constitutional"
+                / "intent_crate.schema.json"
+            )
+        except Exception:
+            # Fallback to minimal schema
+            self.crate_schema = {"type": "object"}
+
+    # ID: 154f8a2c-9a4d-4cb0-8172-3334d7bd05b8
+    async def validate_crate_by_id(
+        self, crate_id: str
+    ) -> tuple[bool, list[AuditFinding]]:
+        """
+        Surgical validation for a specific crate.
+        Used by the Orchestrator to drive the A3 retry loop.
+        """
+        crate_path = self.inbox_path / crate_id
+        if not crate_path.exists():
+            logger.error("Crate %s not found in inbox.", crate_id)
+            return False, [
+                AuditFinding(
+                    check_id="infra.crate_missing",
+                    severity=AuditSeverity.BLOCK,
+                    message=f"Crate {crate_id} missing from inbox",
+                    file_path="none",
+                )
+            ]
+
+        try:
+            # 1. Load and validate manifest structure
+            manifest_path = crate_path / "manifest.yaml"
+            manifest = yaml.safe_load(manifest_path.read_text(encoding="utf-8"))
+            jsonschema.validate(instance=manifest, schema=self.crate_schema)
+
+            crate_obj = Crate(path=crate_path, manifest=manifest)
+
+            # 2. Run the Sandbox Trial
+            return await self._run_canary_validation(crate_obj)
+
+        except Exception as e:
+            logger.error("Crate %s failed structural validation: %s", crate_id, e)
+            return False, [
+                AuditFinding(
+                    check_id="infra.crate_invalid",
+                    severity=AuditSeverity.BLOCK,
+                    message=str(e),
+                    file_path="manifest.yaml",
+                )
+            ]
+
+    async def _run_canary_validation(
+        self, crate: Crate
+    ) -> tuple[bool, list[AuditFinding]]:
+        """
+        Creates a temporary environment, applies crate changes, and runs a full audit.
+        """
+        # Create canary sandbox in work/ directory (within REPO_PATH)
+        canary_id = f"sandbox_{crate.manifest.get('crate_id')}"
+        canary_repo_path = self.repo_root / "work" / "canary" / canary_id
+
+        try:
+            # Clean any previous sandbox with same ID
+            if canary_repo_path.exists():
+                shutil.rmtree(canary_repo_path, ignore_errors=True)
+
+            canary_repo_path.mkdir(parents=True, exist_ok=True)
+
+            logger.info("Created Canary Sandbox at %s", canary_repo_path)
+
+            # A) Snapshot the system (exclude runtime noise)
+            exclude_dirs = {"var", ".git", "__pycache__", ".venv", "work", "reports"}
+
+            for item in self.repo_root.iterdir():
+                if item.name in exclude_dirs:
+                    continue
+
+                dst = canary_repo_path / item.name
+                try:
+                    if item.is_dir():
+                        shutil.copytree(
+                            item, dst, symlinks=False, ignore_dangling_symlinks=True
+                        )
+                    else:
+                        shutil.copy2(item, dst)
+                except Exception as e:
+                    logger.warning("Failed to copy %s: %s", item.name, e)
+
+            # B) Apply the "Blueprint" (Payload)
+            payload_files = crate.manifest.get("payload_files", [])
+            for rel_file in payload_files:
+                src = crate.path / rel_file
+                dst = canary_repo_path / rel_file
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                dst.write_text(src.read_text(encoding="utf-8"), encoding="utf-8")
+
+            # C) The Trial: Canary is under repo_root, so path-relative tooling works
+
+            # Build knowledge graph in sandbox
+            kg_builder = KnowledgeGraphBuilder(canary_repo_path)
+            kg_builder.build()
+
+            # Create auditor context - canary is within repo_root
+            auditor_ctx = AuditorContext(canary_repo_path)
+            auditor = ConstitutionalAuditor(auditor_ctx)
+
+            # Run audit
+            audit_result = await auditor.run_full_audit_async()
+            raw_findings = (
+                audit_result.get("findings", [])
+                if isinstance(audit_result, dict)
+                else audit_result
+            )
+            all_findings = [
+                AuditFinding(**f) if isinstance(f, dict) else f for f in raw_findings
+            ]
+
+            # D) The Verdict
+            metrics = self.canary_executor.derive_metrics_from_audit(all_findings)
+            canary_result: CanaryResult = self.canary_executor.enforce(metrics)
+
+            if canary_result.passed:
+                logger.info(
+                    "✅ Canary Trial PASSED for %s", crate.manifest.get("crate_id")
+                )
+                return True, []
+
+            logger.warning(
+                "❌ Canary Trial FAILED for %s", crate.manifest.get("crate_id")
+            )
+            return False, all_findings
+
+        except Exception as e:
+            logger.error("Canary trial crashed: %s", e, exc_info=True)
+            return False, [
+                AuditFinding(
+                    check_id="infra.canary_crash",
+                    severity=AuditSeverity.BLOCK,
+                    message=f"Canary trial infrastructure error: {e}",
+                    file_path="canary_sandbox",
+                )
+            ]
+        finally:
+            # Clean up sandbox
+            if canary_repo_path.exists():
+                shutil.rmtree(canary_repo_path, ignore_errors=True)
+
+    # ID: 729b80a5-bc1b-484d-aa22-d27356481cbc
+    async def apply_and_finalize_crate(self, crate_id: str):
+        """
+        Final execution: Applies crate to the real 'Body' and moves it to accepted.
+        """
+        crate_path = self.inbox_path / crate_id
+        manifest_path = crate_path / "manifest.yaml"
+        manifest = yaml.safe_load(manifest_path.read_text(encoding="utf-8"))
+
+        logger.info("Applying accepted crate '%s' to production code...", crate_id)
+
+        for rel_file in manifest.get("payload_files", []):
+            source = crate_path / rel_file
+            # Governed write to live system
+            self._fh.write_runtime_text(rel_file, source.read_text(encoding="utf-8"))
+
+        # Move to accepted
+        final_path = self.accepted_path / crate_id
+        self._fh.copy_tree(self._to_repo_rel(crate_path), self._to_repo_rel(final_path))
+        self._fh.remove_tree(self._to_repo_rel(crate_path))
+
+        self._write_result_manifest(final_path, "accepted", "Canary trial passed.")
+        action_logger.log_event("crate.accepted", {"crate_id": crate_id})
+
+    def _write_result_manifest(self, crate_path: Path, status: str, details: Any):
+        """Writes result.yaml into the crate directory."""
+        result_content = {
+            "status": status,
+            "processed_at_utc": datetime.now(UTC).isoformat(),
+            "details": details,
+        }
+        result_rel = f"{self._to_repo_rel(crate_path)}/result.yaml"
+        self._fh.write_runtime_text(result_rel, yaml.dump(result_content, indent=2))
+
+    def _to_repo_rel(self, p: Path) -> str:
+        """Helper to ensure paths are FileHandler compatible."""
+        try:
+            return str(p.relative_to(self.repo_root))
+        except ValueError:
+            return str(p)

body/services/crawl_service/__init__.py

@@ -0,0 +1,10 @@
+# src/body/services/crawl_service/__init__.py
+# crawl_service/__init__.py
+"""
+Package split from crawl_service.py.
+"""
+
+from __future__ import annotations
+
+from .main_module import CrawlService, logger
+from .symbol_processing import _CallGraphExtractor, _detect_layer, _sha256