core-runtime 0.1.1__py3-none-any.whl

body/self_healing/handlers/id_assignment_handler.py

@@ -0,0 +1,201 @@
+# src/body/self_healing/handlers/id_assignment_handler.py
+"""
+ID assignment handler for audit remediation.
+
+Pure-AST, deterministic handler. Inserts # ID: <uuid> comments above public
+functions, methods, and classes that lack one in the file identified by the
+audit finding. No LLM required.
+
+Handler for check_id: linkage.assign_ids
+"""
+
+from __future__ import annotations
+
+import ast
+import time
+import uuid
+from pathlib import Path
+
+from body.self_healing.remediation_models import FixResult
+from shared.ast_utility import find_symbol_id_and_def_line
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.models import AuditFinding
+
+
+logger = getLogger(__name__)
+
+
+def _is_public(node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef) -> bool:
+    """Returns True if the symbol is public — no leading underscore, not a dunder."""
+    is_dunder = node.name.startswith("__") and node.name.endswith("__")
+    return not node.name.startswith("_") and not is_dunder
+
+
+# ID: 3e8f1a2b-c4d5-4e6f-9a7b-8c2d0e1f3a5b
+async def assign_missing_ids_handler(
+    finding: AuditFinding,
+    file_handler: FileHandler,
+    repo_root: Path,
+    write: bool,
+) -> FixResult:
+    """
+    Insert # ID: <uuid> above every public function, method, and class in the
+    file identified by the audit finding that currently lacks one.
+
+    Algorithm:
+        1. Parse the file with ast.parse.
+        2. Walk the AST; for each public FunctionDef, AsyncFunctionDef, or
+           ClassDef, call find_symbol_id_and_def_line to determine whether an
+           ID tag already exists immediately above the def/class keyword
+           (decorator-aware).
+        3. Collect all missing-ID locations, sort descending by line number so
+           that inserting a new line above an early symbol does not shift the
+           line indices of later ones.
+        4. Insert indentation-matched # ID: <uuid4> lines into the line list.
+        5. Write the result via FileHandler (constitutional write gateway).
+
+    Args:
+        finding:      Audit finding from check_id=linkage.assign_ids.
+                      finding.file_path must be relative to repo_root.
+        file_handler: Constitutional write gateway.
+        repo_root:    Repository root for path resolution.
+        write:        If False, performs a dry-run and reports what would change.
+
+    Returns:
+        FixResult with ok=True on success or dry-run.
+        changes_made keys:
+            ids_inserted   — number of IDs written (write mode)
+            would_insert   — number of IDs that would be written (dry-run)
+            symbols        — names of affected symbols
+            already_complete — True when no symbols are missing IDs
+            duration_ms    — elapsed time
+    """
+    start_time = time.time()
+
+    if not finding.file_path:
+        logger.warning("Finding has no file_path, cannot fix: %s", finding.message)
+        return FixResult(
+            ok=False,
+            error_message="No file path in finding",
+            changes_made=None,
+        )
+
+    file_path = repo_root / finding.file_path
+    if not file_path.exists():
+        logger.error("File does not exist: %s", file_path)
+        return FixResult(
+            ok=False,
+            error_message=f"File not found: {finding.file_path}",
+            changes_made=None,
+        )
+
+    try:
+        content = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.error("Failed to read file %s: %s", file_path, e)
+        return FixResult(
+            ok=False,
+            error_message=f"Read failed: {e!s}",
+            changes_made=None,
+        )
+
+    try:
+        tree = ast.parse(content, filename=str(file_path))
+    except SyntaxError as e:
+        logger.error("Syntax error in %s — cannot assign IDs: %s", file_path.name, e)
+        return FixResult(
+            ok=False,
+            error_message=f"Syntax error: {e!s}",
+            changes_made=None,
+        )
+
+    source_lines = content.splitlines()
+
+    # Collect all public symbols that are missing an ID tag.
+    missing: list[dict] = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            if not _is_public(node):
+                continue
+            id_result = find_symbol_id_and_def_line(node, source_lines)
+            if not id_result.has_id:
+                missing.append(
+                    {
+                        "line_number": id_result.definition_line_num,
+                        "name": node.name,
+                    }
+                )
+
+    if not missing:
+        duration_ms = int((time.time() - start_time) * 1000)
+        logger.info("No missing IDs in %s", finding.file_path)
+        return FixResult(
+            ok=True,
+            error_message=None,
+            changes_made={
+                "ids_inserted": 0,
+                "already_complete": True,
+                "duration_ms": duration_ms,
+            },
+        )
+
+    # Sort descending so inserting a line above an earlier symbol does not
+    # shift the line indices of symbols that come later in the file.
+    missing.sort(key=lambda x: x["line_number"], reverse=True)
+
+    if not write:
+        duration_ms = int((time.time() - start_time) * 1000)
+        logger.info(
+            "Dry-run: Would insert %d ID(s) in %s",
+            len(missing),
+            finding.file_path,
+        )
+        return FixResult(
+            ok=True,
+            error_message=None,
+            changes_made={
+                "dry_run": True,
+                "would_insert": len(missing),
+                "symbols": [f["name"] for f in missing],
+                "duration_ms": duration_ms,
+            },
+        )
+
+    lines = source_lines[:]
+    for fix in missing:
+        line_index = fix["line_number"] - 1
+        original_line = lines[line_index]
+        indentation = len(original_line) - len(original_line.lstrip(" "))
+        tag_line = f"{' ' * indentation}# ID: {uuid.uuid4()}"
+        lines.insert(line_index, tag_line)
+
+    new_content = "\n".join(lines) + "\n"
+
+    try:
+        rel_path = str(file_path.relative_to(repo_root))
+        file_handler.write_runtime_text(rel_path, new_content)
+        duration_ms = int((time.time() - start_time) * 1000)
+        logger.info(
+            "Inserted %d ID(s) in %s (%d ms)",
+            len(missing),
+            finding.file_path,
+            duration_ms,
+        )
+        return FixResult(
+            ok=True,
+            error_message=None,
+            changes_made={
+                "ids_inserted": len(missing),
+                "symbols": [f["name"] for f in missing],
+                "duration_ms": duration_ms,
+                "file_path": rel_path,
+            },
+        )
+    except Exception as e:
+        logger.error("Failed to write via FileHandler: %s", e)
+        return FixResult(
+            ok=False,
+            error_message=f"FileHandler write failed: {e!s}",
+            changes_made=None,
+        )

body/self_healing/handlers/import_sorting_handler.py

@@ -0,0 +1,181 @@
+# src/body/self_healing/handlers/import_sorting_handler.py
+"""
+Import sorting handler for audit remediation.
+
+This is a SINGLE-FILE fixer that takes one audit finding and fixes
+just that file's import ordering.
+
+Different from the CLI command which fixes the whole codebase,
+this works on individual files as directed by audit findings.
+
+Uses ruff under the hood, but wraps it in the remediation interface.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from body.self_healing.remediation_models import FixResult
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.models import AuditFinding
+
+
+logger = getLogger(__name__)
+
+
+# ID: 97071a65-22bd-4966-b794-7a8801d37fc2
+async def sort_imports_handler(
+    finding: AuditFinding, file_handler: FileHandler, repo_root: Path, write: bool
+) -> FixResult:
+    """
+    Fix import ordering in a single file using ruff.
+
+    This handler:
+    1. Takes the file path from the audit finding
+    2. Runs ruff's import sorter on JUST that file
+    3. If write=True, re-writes the file via FileHandler (constitutional compliance)
+    4. Returns success/failure status
+
+    Args:
+        finding: The audit finding that identified the import problem
+        file_handler: Constitutional write gateway (ensures IntentGuard enforcement)
+        repo_root: Repository root for path resolution
+        write: If False, just check if fix would work (dry-run)
+
+    Returns:
+        FixResult indicating success/failure
+
+    Example:
+        # From audit finding: "Imports not sorted in src/body/cli/admin_cli.py"
+        result = await sort_imports_handler(
+            finding=finding,
+            file_handler=file_handler,
+            repo_root=Path("/opt/dev/CORE"),
+            write=True
+        )
+        # Result: FixResult(ok=True, error_message=None, changes_made={"sorted": True})
+    """
+    start_time = time.time()
+    if not finding.file_path:
+        logger.warning("Finding has no file_path, cannot fix: %s", finding.message)
+        return FixResult(
+            ok=False, error_message="No file path in finding", changes_made=None
+        )
+    file_path = repo_root / finding.file_path
+    if not file_path.exists():
+        logger.error("File does not exist: %s", file_path)
+        return FixResult(
+            ok=False,
+            error_message=f"File not found: {finding.file_path}",
+            changes_made=None,
+        )
+    try:
+        original_content = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.error("Failed to read file %s: %s", file_path, e)
+        return FixResult(
+            ok=False, error_message=f"Read failed: {e!s}", changes_made=None
+        )
+    try:
+        cmd = ["ruff", "check", str(file_path), "--select", "I", "--exit-zero"]
+        if write:
+            cmd.append("--fix")
+        import asyncio
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+        _stdout_bytes, _stderr_bytes = await process.communicate()
+        if write:
+            try:
+                new_content = file_path.read_text(encoding="utf-8")
+            except Exception as e:
+                logger.error("Failed to read modified file %s: %s", file_path, e)
+                return FixResult(
+                    ok=False,
+                    error_message=f"Post-fix read failed: {e!s}",
+                    changes_made=None,
+                )
+            if new_content == original_content:
+                duration_ms = int((time.time() - start_time) * 1000)
+                logger.info(
+                    "No changes needed for %s (already sorted)", finding.file_path
+                )
+                return FixResult(
+                    ok=True,
+                    error_message=None,
+                    changes_made={
+                        "imports_changed": False,
+                        "already_sorted": True,
+                        "duration_ms": duration_ms,
+                    },
+                )
+            try:
+                rel_path = str(file_path.relative_to(repo_root))
+                file_handler.write_source_code(rel_path, new_content)
+                duration_ms = int((time.time() - start_time) * 1000)
+                logger.info(
+                    "Successfully sorted imports in %s (%d ms)",
+                    finding.file_path,
+                    duration_ms,
+                )
+                return FixResult(
+                    ok=True,
+                    error_message=None,
+                    changes_made={
+                        "imports_changed": True,
+                        "duration_ms": duration_ms,
+                        "file_path": rel_path,
+                    },
+                )
+            except Exception as e:
+                logger.error("Failed to write via FileHandler: %s", e)
+                return FixResult(
+                    ok=False,
+                    error_message=f"FileHandler write failed: {e!s}",
+                    changes_made=None,
+                )
+        else:
+            duration_ms = int((time.time() - start_time) * 1000)
+            logger.info("Dry-run: Would sort imports in %s", finding.file_path)
+            return FixResult(
+                ok=True,
+                error_message=None,
+                changes_made={
+                    "dry_run": True,
+                    "would_fix": True,
+                    "duration_ms": duration_ms,
+                },
+            )
+    except Exception as e:
+        logger.error("Ruff execution failed: %s", e)
+        return FixResult(
+            ok=False, error_message=f"Ruff failed: {e!s}", changes_made=None
+        )
+
+
+# ID: 673eec52-3119-407d-b4ef-fbe0fdde22ef
+async def test_handler(repo_root: Path):
+    """
+    Quick test function to verify the handler works.
+    """
+    from shared.models import AuditSeverity
+
+    test_finding = AuditFinding(
+        check_id="style.import_order",
+        severity=AuditSeverity.HIGH,
+        message="Imports not sorted",
+        file_path="src/body/cli/admin_cli.py",
+        line_number=None,
+    )
+    file_handler = FileHandler(str(repo_root))
+    result = await sort_imports_handler(
+        finding=test_finding,
+        file_handler=file_handler,
+        repo_root=repo_root,
+        write=False,
+    )
+    logger.info("Test result: %s", result)
+    return result

body/self_healing/header_service.py

@@ -0,0 +1,308 @@
+# src/body/self_healing/header_service.py
+
+"""
+HeaderService — enforces the constitutional file header law.
+Refactored to use the canonical ActionExecutor Gateway for all mutations.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from body.atomic.executor import ActionExecutor
+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: e1e63d42-0626-40d7-84bc-5d3469a00bc5
+class HeaderService:
+    """Detects and fixes missing or incorrect file path headers in src/**/*.py files."""
+
+    def __init__(self, repo_root: Path) -> None:
+        self.repo_root = repo_root
+
+    def _get_expected_header(self, file_path: Path) -> str:
+        rel_path = file_path.relative_to(self.repo_root).as_posix()
+        return f"# {rel_path}"
+
+    def _get_current_header(self, file_path: Path) -> str | None:
+        try:
+            lines = file_path.read_text(encoding="utf-8").splitlines()
+        except Exception:
+            return None
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            # Check if it's a path comment (starts with # followed by a path)
+            if stripped.startswith("#") and "/" in stripped:
+                return stripped
+            # First non-blank, non-comment line means no header found
+            if not stripped.startswith("#"):
+                return None
+        return None
+
+    # ID: 8d49b70c-95b6-4aea-b392-6b3c30fac7aa
+    def analyze(self, paths: list[str]) -> list[dict[str, Any]]:
+        """Identifies header violations in the provided paths."""
+        issues = []
+        for p in paths:
+            path = Path(p)
+            # Ensure we only target source files within the repo
+            if path.suffix != ".py" or not str(path.resolve()).startswith(
+                str(self.repo_root.resolve() / "src")
+            ):
+                continue
+
+            expected = self._get_expected_header(path)
+            current = self._get_current_header(path)
+
+            if current != expected:
+                issues.append(
+                    {
+                        "file": str(path),
+                        "issue": (
+                            "missing_header" if current is None else "incorrect_header"
+                        ),
+                        "current_header": current,
+                        "expected_header": expected,
+                    }
+                )
+        return issues
+
+    # ID: 900e1f3e-e89c-4ffc-8814-b6cba069509c
+    def analyze_all(self) -> list[dict[str, Any]]:
+        """Scans the entire src directory for header violations."""
+        return self.analyze([str(p) for p in self.repo_root.rglob("src/**/*.py")])
+
+    # ID: fbb21920-5457-4aa2-9ae7-23da72fff8fd
+    async def fix(
+        self, context: CoreContext, paths: list[str], write: bool = False
+    ) -> None:
+        """Fixes headers for specific paths via the Action Gateway."""
+        issues = self.analyze(paths)
+        for issue in issues:
+            await self._apply_fix(
+                context, Path(issue["file"]), issue["expected_header"], write
+            )
+
+    async def _fix_all(self, context: CoreContext, write: bool = False) -> None:
+        """Fixes all header violations in the project via the Action Gateway."""
+        issues = self.analyze_all()
+        for issue in issues:
+            await self._apply_fix(
+                context, Path(issue["file"]), issue["expected_header"], write
+            )
+
+    async def _apply_fix(
+        self, context: CoreContext, file_path: Path, expected_header: str, write: bool
+    ) -> None:
+        """Prepares the new source and dispatches to ActionExecutor."""
+        rel_path = str(file_path.relative_to(self.repo_root))
+        executor = ActionExecutor(context)
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+        except Exception as e:
+            logger.error("Could not read %s for header fix: %s", rel_path, e)
+            return
+
+        lines = content.splitlines(keepends=True)
+        new_lines = []
+        skip_next_blank = False
+
+        for line in lines:
+            stripped = line.strip()
+            # Skip existing header line
+            if stripped.startswith("# src/"):
+                skip_next_blank = True
+                continue
+            # Skip blank line immediately after removed header
+            if skip_next_blank and not stripped:
+                skip_next_blank = False
+                continue
+            skip_next_blank = False
+            new_lines.append(line)
+
+        # Reconstruct with the correct header
+        final_lines = [expected_header + "\n"]
+        if new_lines and new_lines[0].strip():
+            final_lines.append("\n")
+        final_lines.extend(new_lines)
+
+        final_code = "".join(final_lines)
+
+        # CONSTITUTIONAL GATEWAY: Mutation is audited and guarded
+        result = await executor.execute(
+            action_id="file.edit", write=write, file_path=rel_path, code=final_code
+        )
+
+        if result.ok:
+            status = "Fixed" if write else "Proposed (Dry Run)"
+            logger.info("   -> [%s] Header in %s", status, rel_path)
+        else:
+            logger.error("   -> [BLOCKED] %s: %s", rel_path, result.data.get("error"))
+
+
+# ID: 4828affd-f7da-4995-9493-7037211b4144
+async def _run_header_fix_cycle(
+    context: CoreContext, dry_run: bool, all_py_files: list[str]
+) -> dict[str, Any]:
+    """
+    Enforce the src/**/*.py path-header invariant.
+
+    Invariant: line 1 MUST be exactly '# <repo-relative-path>' for each src/**/*.py file.
+    This exists to keep file metadata deterministic and machine-verifiable.
+    """
+    logger.info("🔍 Scanning %d files for header compliance...", len(all_py_files))
+
+    executor = ActionExecutor(context)
+    write_mode = not dry_run
+    files_changed = 0
+    files_created = 0
+    changed_paths: list[str] = []
+
+    def _enforce_line1_path_header(
+        content: str, expected_header: str
+    ) -> tuple[str, bool]:
+        """
+        Return (new_content, did_change) enforcing the path-header invariant:
+        - Empty file            -> insert header
+        - Line 1 == correct     -> no change
+        - Line 1 is a # src/.. -> wrong path, replace line 1
+        - Anything else         -> prepend header, leave file content intact
+        """
+        if content == "":
+            return expected_header + "\n", True
+
+        lines = content.splitlines(keepends=True)
+        first_line_text = lines[0].rstrip("\r\n")
+
+        if first_line_text == expected_header:
+            return content, False
+
+        if first_line_text.startswith("# src/"):
+            # Wrong path header — replace only line 1
+            lines[0] = expected_header + "\n"
+            return "".join(lines), True
+
+        # Not a path header (could be # ID:, docstring, code, anything)
+        # Prepend and leave everything else intact
+        return expected_header + "\n" + content, True
+
+    for i, file_path_str in enumerate(all_py_files, 1):
+        if i % 50 == 0:
+            logger.debug("Header analysis progress: %d/%d", i, len(all_py_files))
+
+        file_path = context.git_service.repo_path / file_path_str
+        try:
+            original_content = file_path.read_text(encoding="utf-8")
+            expected_header = f"# {Path(file_path_str).as_posix()}"
+            corrected_code, changed = _enforce_line1_path_header(
+                original_content, expected_header
+            )
+            if not changed:
+                continue
+
+            result = await executor.execute(
+                action_id="file.edit",
+                write=write_mode,
+                file_path=file_path_str,
+                code=corrected_code,
+            )
+            if result.ok:
+                files_changed += 1
+                changed_paths.append(file_path_str)
+                if original_content == "":
+                    files_created += 1
+            else:
+                logger.warning("   -> [BLOCKED] %s", file_path_str)
+
+        except Exception as e:
+            logger.warning("Could not process %s: %s", file_path_str, e)
+
+    if files_changed == 0:
+        logger.info("✅ All file headers are constitutionally compliant.")
+    else:
+        mode_label = "Fixed" if write_mode else "Proposed fixes for"
+        logger.info(
+            "🏁 Header fix cycle complete. %s %d file(s).", mode_label, files_changed
+        )
+
+        if write_mode:
+            logger.info("🔄 Rebuilding Knowledge Graph to reflect metadata changes...")
+            await executor.execute(action_id="sync.db", write=True)
+            logger.info("✅ Knowledge Graph successfully updated.")
+
+    return {
+        "total_files_scanned": len(all_py_files),
+        "files_changed": files_changed,
+        "files_unchanged": len(all_py_files) - files_changed,
+        "files_created": files_created,
+        "changed_file_paths": changed_paths,
+    }
+
+
+@atomic_action(
+    action_id="fix.headers",
+    intent="Ensure all Python files have constitutionally compliant headers",
+    impact=ActionImpact.WRITE_METADATA,
+    policies=["file_headers"],
+    category="fixers",
+)
+# ID: 936e32e6-18a3-4b7c-a0f2-06cc8ca654f7
+async def fix_headers_internal(
+    context: CoreContext, write: bool = False, **kwargs
+) -> ActionResult:
+    """
+    Core orchestrator for fix.headers — moved from cli/commands/fix/code_style.py
+    under ADR-050. Walks src/, dispatches to _run_header_fix_cycle.
+    """
+    start_time = time.time()
+    repo_root = context.git_service.repo_path
+    try:
+        src_dir = repo_root / "src"
+        all_py_files = [
+            p.relative_to(repo_root).as_posix() for p in src_dir.rglob("*.py")
+        ]
+        summary = await _run_header_fix_cycle(
+            context, dry_run=not write, all_py_files=all_py_files
+        )
+        return ActionResult(
+            action_id="fix.headers",
+            ok=True,
+            data={
+                "total_files_scanned": summary["total_files_scanned"],
+                "files_changed": summary["files_changed"],
+                "files_unchanged": summary["files_unchanged"],
+                "files_created": summary["files_created"],
+                "changed_file_paths": summary["changed_file_paths"],
+                "files_scanned": summary["total_files_scanned"],
+                "violations_found": summary["files_changed"],
+                "fixed_count": summary["files_changed"] if write else 0,
+                "dry_run": not write,
+                "mode": "write" if write else "dry-run",
+            },
+            duration_sec=time.time() - start_time,
+            impact=ActionImpact.WRITE_METADATA if write else ActionImpact.READ_ONLY,
+        )
+    except Exception as e:
+        return ActionResult(
+            action_id="fix.headers",
+            ok=False,
+            data={"error": str(e), "error_type": type(e).__name__},
+            duration_sec=time.time() - start_time,
+            logs=[f"Exception during header fix: {e}"],
+        )