core-runtime 0.1.1__py3-none-any.whl

body/quality/coverage_analyzer.py

@@ -0,0 +1,177 @@
+# src/body/quality/coverage_analyzer.py
+
+"""
+Analyzes codebase coverage and module structure.
+
+Provides coverage measurement and module complexity analysis
+to support intelligent test prioritization.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+# REFACTORED: Removed direct settings import
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+_CFG = load_operational_config().coverage
+
+
+# ID: 2b075104-ab91-4ea3-931b-a9be87d56799
+class CoverageAnalyzer:
+    """
+    Analyzes test coverage and module structure for prioritization.
+    """
+
+    def __init__(self, repo_path: Path) -> None:
+        self.repo_path = repo_path
+
+    # ID: 168e0d67-a382-48a5-9dd5-79eeb9656cfa
+    def get_module_coverage(self) -> dict[str, float]:
+        """
+        Gets current coverage percentage for each module.
+
+        Returns:
+            Dict mapping file paths to coverage percentages
+        """
+        try:
+            subprocess.run(
+                ["poetry", "run", "pytest", "--cov=src", "--cov-report=json", "-q"],
+                cwd=self.repo_path,
+                capture_output=True,
+                timeout=_CFG.collect_timeout_sec,
+            )
+            coverage_json = self.repo_path / "coverage.json"
+            if coverage_json.exists():
+                data = json.loads(coverage_json.read_text())
+                module_coverage = {}
+                for file_path, file_data in data.get("files", {}).items():
+                    summary = file_data.get("summary", {})
+                    percent = summary.get("percent_covered", 0)
+                    module_coverage[file_path] = round(percent, 2)
+                return module_coverage
+        except Exception as e:
+            logger.debug("Could not get module coverage: %s", e)
+        return {}
+
+    # ID: 12e50464-4e37-48a6-a738-5def4ee46de1
+    def analyze_codebase(self) -> dict[str, Any]:
+        """
+        Analyzes codebase structure to identify testing priorities.
+
+        Returns:
+            Dict with module metadata (imports, complexity, etc.)
+        """
+        module_info = {}
+        src_dir = self.repo_path / "src"
+        for py_file in src_dir.rglob("*.py"):
+            if py_file.name == "__init__.py":
+                continue
+            try:
+                code = py_file.read_text()
+                tree = ast.parse(code)
+                imports = sum(
+                    1
+                    for node in ast.walk(tree)
+                    if isinstance(node, (ast.Import, ast.ImportFrom))
+                )
+                classes = sum(
+                    1 for node in ast.walk(tree) if isinstance(node, ast.ClassDef)
+                )
+                functions = sum(
+                    1 for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
+                )
+                loc = len(
+                    [
+                        line
+                        for line in code.splitlines()
+                        if line.strip() and (not line.strip().startswith("#"))
+                    ]
+                )
+                rel_path = str(py_file.relative_to(self.repo_path))
+                module_info[rel_path] = {
+                    "imports": imports,
+                    "classes": classes,
+                    "functions": functions,
+                    "loc": loc,
+                    "complexity_score": imports + classes + functions,
+                }
+            except Exception as e:
+                logger.debug("Could not analyze {py_file}: %s", e)
+        return module_info
+
+    # ID: 09b41c82-55e9-494b-8387-bd92eeff3509
+    def measure_coverage(self) -> dict[str, Any] | None:
+        """
+        Runs pytest with coverage and returns parsed results.
+
+        Returns:
+            Dict with coverage metrics or None if measurement fails
+        """
+        try:
+            result = subprocess.run(
+                [
+                    "poetry",
+                    "run",
+                    "pytest",
+                    "--cov=src",
+                    "--cov-report=json",
+                    "--cov-report=term",
+                    "-q",
+                ],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                timeout=_CFG.full_run_timeout_sec,
+            )
+            coverage_json = self.repo_path / "coverage.json"
+            if coverage_json.exists():
+                data = json.loads(coverage_json.read_text())
+                totals = data.get("totals", {})
+                return {
+                    "overall_percent": totals.get("percent_covered", 0),
+                    "lines_covered": totals.get("covered_lines", 0),
+                    "lines_total": totals.get("num_statements", 0),
+                    "files": data.get("files", {}),
+                    "timestamp": data.get("meta", {}).get("timestamp"),
+                }
+            return self._parse_term_output(result.stdout)
+        except subprocess.TimeoutExpired:
+            logger.error("Coverage measurement timed out after 5 minutes")
+            return None
+        except Exception as e:
+            logger.error("Failed to measure coverage: %s", e, exc_info=True)
+            return None
+
+    def _parse_term_output(self, output: str) -> dict[str, Any] | None:
+        """
+        Fallback parser for terminal coverage output.
+
+        Args:
+            output: Terminal output from pytest --cov
+
+        Returns:
+            Dict with coverage metrics or None
+        """
+        try:
+            for line in output.splitlines():
+                if line.startswith("TOTAL"):
+                    parts = line.split()
+                    if len(parts) >= 4:
+                        percent_str = parts[-1].rstrip("%")
+                        return {
+                            "overall_percent": float(percent_str),
+                            "lines_total": int(parts[1]),
+                            "lines_covered": int(parts[1]) - int(parts[2]),
+                        }
+        except Exception as e:
+            logger.debug("Failed to parse coverage output: %s", e)
+        return None

body/repositories/__init__.py

@@ -0,0 +1,4 @@
+# src/body/repositories/__init__.py
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations

body/self_healing/atomic_actions_fixer.py

@@ -0,0 +1,113 @@
+# src/body/self_healing/atomic_actions_fixer.py
+"""
+Source-level fixer for atomic-action pattern violations.
+
+Moved from src/cli/commands/fix/atomic_actions.py under ADR-050 (Body
+must not import from CLI). The CLI module retains a deprecated re-export
+shim for the public entry point; helpers are private to this module.
+
+The fixer operates as a pure source transformation: given a Python
+source string and a list of violations, returns the rewritten source
+with missing @atomic_action decorators and ActionResult return types
+inserted, plus mandatory imports added.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+# ID: 7b1c4661-73dd-4200-98c7-57c56a95f51e
+def fix_file_violations(source: str, violations: list, file_path: Path) -> str:
+    """
+    Fix all violations in a single file and ensure imports exist.
+    """
+    lines = source.splitlines(keepends=True)
+    violations_by_function = {}
+    for v in violations:
+        violations_by_function.setdefault(v.function_name, []).append(v)
+    for function_name, func_violations in violations_by_function.items():
+        for i, line in enumerate(lines):
+            if f"def {function_name}" in line or f"async def {function_name}" in line:
+                lines = _apply_fixes_to_function(
+                    lines, i, function_name, func_violations
+                )
+                break
+    if violations:
+        lines = _ensure_imports(lines)
+    return "".join(lines)
+
+
+def _ensure_imports(lines: list[str]) -> list[str]:
+    """Ensures mandatory atomic action imports exist at the top of the file."""
+    content = "".join(lines)
+    new_imports = []
+    if "from shared.atomic_action import atomic_action" not in content:
+        new_imports.append("from shared.atomic_action import atomic_action\n")
+    if "from shared.action_types import ActionImpact" not in content:
+        if (
+            "from shared.action_types import" in content
+            and "ActionImpact" not in content
+        ):
+            for i, line in enumerate(lines):
+                if "from shared.action_types import" in line:
+                    lines[i] = line.replace("import ", "import ActionImpact, ")
+                    break
+        else:
+            new_imports.append(
+                "from shared.action_types import ActionImpact, ActionResult\n"
+            )
+    if not new_imports:
+        return lines
+    insert_idx = 0
+    for i, line in enumerate(lines):
+        if "from __future__" in line:
+            insert_idx = i + 1
+        elif line.startswith("#"):
+            continue
+        else:
+            break
+    return [*lines[:insert_idx], "\n", *new_imports, *lines[insert_idx:]]
+
+
+def _apply_fixes_to_function(
+    lines: list[str], func_line_idx: int, function_name: str, violations: list
+) -> list[str]:
+    """
+    Apply fixes to a specific function definition.
+    """
+    func_line = lines[func_line_idx]
+    indent = len(func_line) - len(func_line.lstrip())
+    needs_decorator = any(v.rule_id == "action_must_have_decorator" for v in violations)
+    needs_return_type = any(
+        v.rule_id == "action_must_return_result" for v in violations
+    )
+    if needs_decorator:
+        action_id = _infer_action_id(function_name)
+        decorator_lines = [
+            f"{' ' * indent}@atomic_action(\n",
+            f'{" " * (indent + 4)}action_id="{action_id}",\n',
+            f'{" " * (indent + 4)}intent="Atomic action for {function_name}",\n',
+            f"{' ' * (indent + 4)}impact=ActionImpact.WRITE_CODE,\n",
+            f'{" " * (indent + 4)}policies=["atomic_actions"],\n',
+            f"{' ' * indent})\n",
+        ]
+        lines[func_line_idx:func_line_idx] = decorator_lines
+        func_line_idx += len(decorator_lines)
+    if needs_return_type:
+        if " -> " not in lines[func_line_idx] and ":" in lines[func_line_idx]:
+            lines[func_line_idx] = lines[func_line_idx].replace(
+                ":", " -> ActionResult:", 1
+            )
+    return lines
+
+
+def _infer_action_id(function_name: str) -> str:
+    """
+    Infers action_id from function name (category.name).
+    """
+    name = function_name.replace("_internal", "").replace("action_", "")
+    parts = name.split("_")
+    if len(parts) >= 2:
+        return f"{parts[0]}.{parts[1]}"
+    return f"action.{name}"

body/self_healing/body_ui_fixer.py

@@ -0,0 +1,193 @@
+# src/body/self_healing/body_ui_fixer.py
+
+"""Headless fixer for Body-layer contract violations.
+
+Relocated from src/cli/logic/body_contracts_fixer.py under ADR-055 D6:
+an @atomic_action belongs in body/, not cli/logic/. Also wired into
+the action registry via @register_action so it can be dispatched
+through POST /v1/fix/run/fix.body_ui (the previous module had the
+@atomic_action decoration but no registration, so executor dispatch
+returned 422 unknown_fix_id).
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from body.atomic.registry import ActionCategory, register_action
+from body.governance.body_contracts_service import check_body_contracts
+from shared.action_types import ActionImpact, ActionResult
+from shared.ai.prompt_model import PromptModel
+from shared.atomic_action import atomic_action
+from shared.logger import getLogger
+from shared.utils.parallel_processor import ThrottledParallelProcessor
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+    from shared.infrastructure.storage.file_handler import FileHandler
+
+logger = getLogger(__name__)
+
+
+async def _process_single_file(
+    item: tuple[Path, list[dict[str, Any]]],
+    agent: Any,
+    write: bool,
+    file_handler: FileHandler,
+) -> dict[str, Any]:
+    """
+    Worker function to process a single file.
+    """
+    path, vlist = item
+    logger.info("Processing %s...", path.name)
+    try:
+        original_source = path.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning("Body UI fixer: cannot read %s: %s", path, e)
+        return {
+            "path": str(path),
+            "had_violations": True,
+            "modified": False,
+            "error": f"read_error: {e}",
+        }
+
+    summary_lines = sorted(
+        {f"- {v['rule_id']} @ line {v.get('line')}: {v['message']}" for v in vlist}
+    )
+    violation_summary = "\n".join(summary_lines)
+
+    try:
+        model = PromptModel.load("body_contracts_fixer")
+        raw_response = await model.invoke(
+            context={
+                "file_path": str(path),
+                "violation_summary": violation_summary,
+                "original_source": original_source,
+            },
+            client=agent,
+            user_id="fix_body_ui",
+        )
+    except Exception as e:
+        logger.warning("Body UI fixer: LLM request failed for %s: %s", path, e)
+        return {
+            "path": str(path),
+            "had_violations": True,
+            "modified": False,
+            "error": f"llm_error: {e}",
+        }
+
+    new_source = raw_response.strip()
+    if new_source.startswith("```"):
+        lines = new_source.splitlines()
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].startswith("```"):
+            lines = lines[:-1]
+        new_source = "\n".join(lines).strip()
+
+    if new_source == original_source:
+        return {
+            "path": str(path),
+            "had_violations": True,
+            "modified": False,
+            "info": "LLM returned identical content.",
+        }
+
+    if write:
+        try:
+            rel_path = str(path.relative_to(file_handler.repo_path))
+            file_handler.write_runtime_text(rel_path, new_source)
+            logger.info("Body UI fixer: updated file %s", path)
+        except Exception as e:
+            logger.warning("Body UI fixer: failed to write %s: %s", path, e)
+            return {
+                "path": str(path),
+                "had_violations": True,
+                "modified": False,
+                "error": f"write_error: {e}",
+            }
+    return {"path": str(path), "had_violations": True, "modified": write}
+
+
+@register_action(
+    action_id="fix.body_ui",
+    description="Autonomously fix Body-layer UI/env contract violations using LLM",
+    category=ActionCategory.FIX,
+    policies=["body_contracts", "agent_governance"],
+    remediates=[
+        "no_ui_imports_in_body",
+        "no_print_or_input_in_body",
+        "write_defaults_false",
+        "no_envvar_access_in_body",
+    ],
+)
+@atomic_action(
+    action_id="fix.body_ui",
+    intent="Autonomously fix Body UI violations using LLM",
+    impact=ActionImpact.WRITE_CODE,
+    policies=["body_contracts", "agent_governance"],
+    category="fixers",
+)
+# ID: 2b467a78-e140-4431-9166-1f485a8fe619
+async def fix_body_ui_violations(
+    core_context: CoreContext,
+    write: bool = False,
+    repo_root: Path | None = None,
+    limit: int | None = None,
+    **kwargs,
+) -> ActionResult:
+    """
+    Use an LLM (via CoreContext) to automatically fix Body UI/env violations.
+    """
+    start_time = time.time()
+    if repo_root is None:
+        repo_root = core_context.git_service.repo_path
+
+    check_result = await check_body_contracts(repo_root=repo_root)
+    violations_raw: list[dict[str, Any]] = check_result.data.get("violations", [])
+
+    if not violations_raw:
+        return ActionResult(
+            action_id="fix.body_ui",
+            ok=True,
+            data={"files_processed": 0},
+            duration_sec=time.time() - start_time,
+        )
+
+    by_file: dict[Path, list[dict[str, Any]]] = {}
+    for v in violations_raw:
+        path = Path(v["file"])
+        by_file.setdefault(path, []).append(v)
+
+    items = list(by_file.items())
+    if limit:
+        items = items[:limit]
+
+    cognitive = core_context.cognitive_service
+    model = PromptModel.load("body_contracts_fixer")
+    agent = await cognitive.aget_client_for_role(model.manifest.role)
+    processor = ThrottledParallelProcessor(description="Fixing Body UI violations...")
+
+    # ID: dbf3bacb-1562-48e3-acfa-9127c985737b
+    async def worker(item):
+        return await _process_single_file(item, agent, write, core_context.file_handler)
+
+    per_file_results = await processor.run_async(items, worker)
+    files_modified = sum(1 for res in per_file_results if res.get("modified"))
+
+    return ActionResult(
+        action_id="fix.body_ui",
+        ok=True,
+        data={
+            "files_found": len(by_file),
+            "files_processed": len(per_file_results),
+            "files_modified": files_modified,
+            "dry_run": not write,
+            "per_file": per_file_results,
+        },
+        duration_sec=time.time() - start_time,
+        impact=ActionImpact.WRITE_CODE if write else ActionImpact.READ_ONLY,
+    )

body/self_healing/capability_parser.py

@@ -0,0 +1,65 @@
+# src/body/self_healing/capability_parser.py
+
+"""
+Capability Parser - Extract Capability Tags from Code
+
+CONSTITUTIONAL ALIGNMENT:
+- Single Responsibility: Parse capability tags
+- Stateless utility
+- No side effects
+
+Extracted from complexity_service.py to separate parsing concerns.
+"""
+
+from __future__ import annotations
+
+import re
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 1a2b3c4d-5e6f-7890-abcd-ef1234567890
+class CapabilityParser:
+    """
+    Parses capability tags from code.
+
+    Capabilities are declared with # CAPABILITY: tag_name
+    """
+
+    @staticmethod
+    # ID: 6188e431-7097-4e73-a523-2edfed57231c
+    def extract_capabilities(code: str) -> list[str]:
+        """
+        Extract # CAPABILITY tags from code.
+
+        Args:
+            code: Source code to parse
+
+        Returns:
+            List of capability tag names
+
+        Example:
+            # CAPABILITY: file_operations
+            # CAPABILITY: database_access
+            -> ["file_operations", "database_access"]
+        """
+        return re.findall(r"#\s*CAPABILITY:\s*(\S+)", code)
+
+    @staticmethod
+    # ID: ac4ff8e2-924e-4d81-a744-55c6ce91b08e
+    def has_capability(code: str, capability: str) -> bool:
+        """
+        Check if code declares a specific capability.
+
+        Args:
+            code: Source code to check
+            capability: Capability name to search for
+
+        Returns:
+            True if capability is declared
+        """
+        capabilities = CapabilityParser.extract_capabilities(code)
+        return capability in capabilities

body/self_healing/code_style_service.py

@@ -0,0 +1,51 @@
+# src/body/self_healing/code_style_service.py
+
+"""
+Provides the service logic for formatting code according to constitutional style rules.
+
+CONSTITUTIONAL FIX: Added 'write' parameter support to respect Dry Run intent.
+Ensures that external tools (ruff format/ruff check) do not mutate the disk unless authorized.
+"""
+
+from __future__ import annotations
+
+from shared.utils.subprocess_utils import run_poetry_command
+
+
+# ID: 1655ba02-a26e-4f8b-847a-8e4d16acfea0
+def format_code(path: str | None = None, write: bool = True) -> None:
+    """
+    Format code using ruff format and ruff check.
+
+    Args:
+        path: Optional specific target. Defaults to src and tests.
+        write: If False, runs in check-only mode (Dry Run).
+    """
+    if path is None:
+        targets = ["src", "tests"]
+    else:
+        targets = [path]
+
+    # --- Ruff Format Configuration ---
+    ruff_format_cmd = ["ruff", "format"]
+    if not write:
+        ruff_format_cmd.append("--check")
+    ruff_format_cmd.extend(targets)
+
+    # --- Ruff Check (Linter) Configuration ---
+    ruff_cmd = ["ruff", "check"]
+    if write:
+        ruff_cmd.extend(["--fix", "--unsafe-fixes"])
+    else:
+        # In dry-run, we just want to see what would happen
+        pass
+    ruff_cmd.extend(targets)
+
+    # Execute
+    run_poetry_command(
+        f"✨ Ruff Format ({'Write' if write else 'Check'}): {' '.join(targets)}",
+        ruff_format_cmd,
+    )
+    run_poetry_command(
+        f"✨ Ruff Check ({'Fix' if write else 'Check'}): {' '.join(targets)}", ruff_cmd
+    )

body/self_healing/complexity_filter.py

@@ -0,0 +1,70 @@
+# src/body/self_healing/complexity_filter.py
+
+"""
+Provides a simple, stateless filter to determine if a file's complexity
+is within an acceptable threshold for autonomous test generation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from radon.visitors import ComplexityVisitor
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+COMPLEXITY_THRESHOLDS = {"SIMPLE": 5, "MODERATE": 15, "COMPLEX": 50}
+
+
+# ID: c020e1c4-89a7-4933-a859-920ffea4244e
+class ComplexityFilter:
+    """
+    Determines if a file should be attempted for remediation based on complexity.
+    """
+
+    def __init__(self, max_complexity: str = "MODERATE"):
+        """
+        Args:
+            max_complexity: The maximum complexity level to allow (SIMPLE, MODERATE, COMPLEX).
+        """
+        self.threshold = COMPLEXITY_THRESHOLDS.get(max_complexity.upper(), 15)
+
+    # ID: cc7541ee-4499-4483-a8b8-c6256e69573a
+    def should_attempt(self, file_path: Path) -> dict[str, Any]:
+        """
+        Analyzes a file and decides if it's simple enough to attempt.
+
+        Returns:
+            A dictionary with 'should_attempt', 'reason', and 'complexity'.
+        """
+        try:
+            source_code = file_path.read_text("utf-8")
+            visitor = ComplexityVisitor.from_code(source_code)
+            if visitor.complexity > self.threshold * 2:
+                return {
+                    "should_attempt": False,
+                    "reason": "Module complexity too high",
+                    "complexity": visitor.complexity,
+                }
+            for func in visitor.functions:
+                if func.complexity > self.threshold:
+                    return {
+                        "should_attempt": False,
+                        "reason": f"Function '{func.name}' is too complex ({func.complexity})",
+                        "complexity": func.complexity,
+                    }
+            return {
+                "should_attempt": True,
+                "reason": "Complexity is within threshold",
+                "complexity": visitor.complexity,
+            }
+        except Exception as e:
+            logger.warning("Could not analyze complexity for {file_path}: %s", e)
+            return {
+                "should_attempt": False,
+                "reason": "Failed to analyze complexity",
+                "complexity": -1,
+            }