core-runtime 0.1.1__py3-none-any.whl

body/self_healing/prune_private_capabilities.py

@@ -0,0 +1,144 @@
+# src/body/self_healing/prune_private_capabilities.py
+
+"""
+A self-healing tool that scans the codebase and removes # CAPABILITY tags
+from private symbols (those starting with an underscore).
+
+Enforces the 'caps.ignore_private' constitutional policy via governed actions.
+Refactored to use the canonical ActionExecutor Gateway for all mutations.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from body.atomic.executor import ActionExecutor
+
+# REFACTORED: Removed direct settings import
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+logger = getLogger(__name__)
+
+
+# ID: bb384d72-6190-400b-9479-20f53e2e63da
+async def prune_private_capability_tags(
+    context: CoreContext, write: bool = False
+) -> int:
+    """
+    Finds and removes capability tags from private symbols (_ or __) via the Action Gateway.
+
+    Args:
+        context: CoreContext (Required for ActionExecutor and KnowledgeService)
+        write: If True, apply changes; if False, perform dry-run.
+
+    Returns:
+        The total number of tags removed or proposed for removal.
+    """
+    logger.info("🐍 Scanning for misplaced capability tags on private symbols...")
+
+    executor = ActionExecutor(context)
+    knowledge_service = context.knowledge_service
+
+    # Use the DB-backed knowledge graph (SSOT)
+    graph = await knowledge_service.get_graph()
+    symbols = graph.get("symbols", {})
+
+    # Identify private symbols that shouldn't have tags
+    private_symbols_with_tags = [
+        s
+        for s in symbols.values()
+        if s.get("name", "").startswith("_")
+        and s.get("capability") != "unassigned"
+        and s.get("capability") is not None
+    ]
+
+    if not private_symbols_with_tags:
+        logger.info("✅ Compliance perfect: No private symbols have capability tags.")
+        return 0
+
+    logger.info(
+        "Found %d private symbol(s) with illegal capability tags.",
+        len(private_symbols_with_tags),
+    )
+
+    # Group violations by file to minimize gateway transactions
+    files_to_modify: dict[Path, list[int]] = {}
+    tag_pattern = re.compile(r"^\s*#\s*CAPABILITY:\s*\S+\s*$", re.IGNORECASE)
+
+    for symbol in private_symbols_with_tags:
+        file_path_str = symbol.get("file") or symbol.get("file_path")
+        if not file_path_str:
+            continue
+
+        file_path = context.git_service.repo_path / file_path_str
+        line_num = symbol.get("line_number", 0)
+
+        if file_path not in files_to_modify:
+            if file_path.exists():
+                files_to_modify[file_path] = []
+            else:
+                logger.warning(
+                    "File not found for symbol %s: %s",
+                    symbol.get("symbol_path"),
+                    file_path,
+                )
+                continue
+
+        files_to_modify[file_path].append(line_num)
+
+    total_pruned = 0
+    write_mode = write
+
+    # Execute mutations via Gateway
+    for file_path, line_nums in files_to_modify.items():
+        try:
+            rel_path = str(file_path.relative_to(context.git_service.repo_path))
+            lines = file_path.read_text("utf-8").splitlines()
+
+            modified = False
+            # Sort lines descending to prevent index shifts
+            for line_num in sorted(line_nums, reverse=True):
+                # The tag is usually 1 or 2 lines above the symbol definition
+                # We check the immediate vicinity
+                lookback_range = range(max(0, line_num - 3), line_num)
+                for idx in reversed(list(lookback_range)):
+                    if idx < len(lines) and tag_pattern.match(lines[idx]):
+                        logger.debug(
+                            "   -> Found tag for removal in %s at line %d",
+                            rel_path,
+                            idx + 1,
+                        )
+                        lines.pop(idx)
+                        modified = True
+                        total_pruned += 1
+                        break
+
+            if modified:
+                final_code = "\n".join(lines) + "\n"
+
+                # CONSTITUTIONAL GATEWAY: Mutation is audited and guarded
+                result = await executor.execute(
+                    action_id="file.edit",
+                    write=write_mode,
+                    file_path=rel_path,
+                    code=final_code,
+                )
+
+                if result.ok:
+                    status = "Pruned" if write_mode else "Proposed"
+                    logger.info("   -> [%s] %s", status, rel_path)
+                else:
+                    logger.error(
+                        "   -> [BLOCKED] %s: %s", rel_path, result.data.get("error")
+                    )
+
+        except Exception as e:
+            logger.error("Failed to process %s: %s", file_path.name, e)
+
+    return total_pruned

body/self_healing/purge_legacy_tags_service.py

@@ -0,0 +1,146 @@
+# src/body/self_healing/purge_legacy_tags_service.py
+
+"""
+Service logic for purging legacy tags and descriptive pollution from source code.
+Refactored to use the canonical ActionExecutor Gateway for all mutations.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from body.atomic.executor import ActionExecutor
+from mind.governance.audit_context import AuditorContext
+from mind.governance.rule_executor import execute_rule
+from mind.governance.rule_extractor import extract_executable_rules
+
+# REFACTORED: Removed direct settings import
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+logger = getLogger(__name__)
+
+
+# ID: b67cd592-b257-4228-b55e-424245f64205
+async def purge_legacy_tags(context: CoreContext, dry_run: bool = True) -> int:
+    """
+    Finds legacy tags (like # owner: or # Tag:) using constitutional rules
+    and removes them from the source files via the Action Gateway.
+
+    Args:
+        context: CoreContext (Required for ActionExecutor)
+        dry_run: If True, only prints the actions (write=False in Gateway).
+
+    Returns:
+        The total number of lines that were (or would be) removed.
+    """
+    # 1. Initialize Context and Gateway
+    executor = ActionExecutor(context)
+    auditor_context = context.auditor_context or AuditorContext(
+        context.git_service.repo_path
+    )
+    await auditor_context.load_knowledge_graph()
+
+    # 2. Extract rules from the Constitution and find the "Purity" rule
+    # FIX: Added enforcement_loader parameter
+    all_rules = extract_executable_rules(
+        auditor_context.policies, auditor_context.enforcement_loader
+    )
+    target_rule = next(
+        (r for r in all_rules if r.rule_id == "purity.no_descriptive_pollution"), None
+    )
+
+    if not target_rule:
+        logger.warning(
+            "Constitutional rule 'purity.no_descriptive_pollution' not found. Skipping purge."
+        )
+        return 0
+
+    # 3. Execute the rule dynamically to find violations
+    logger.info(
+        "🔍 Scanning for legacy tags via constitutional rule: %s", target_rule.rule_id
+    )
+    all_findings = await execute_rule(target_rule, auditor_context)
+
+    if not all_findings:
+        logger.info("✅ No legacy tags found. Codebase is pure.")
+        return 0
+
+    # 4. Filter findings to only include those in the source directory
+    src_findings = [
+        finding
+        for finding in all_findings
+        if finding.file_path and finding.file_path.startswith("src/")
+    ]
+
+    if not src_findings:
+        logger.info(
+            "Found %s findings in non-code files. No automated action taken on 'src/'.",
+            len(all_findings),
+        )
+        return 0
+
+    logger.info(
+        "Found %s instances of legacy tags in 'src/'. Starting cleanup...",
+        len(src_findings),
+    )
+
+    # 5. Group findings by file to minimize gateway transactions
+    files_to_fix = defaultdict(list)
+    for finding in src_findings:
+        if finding.line_number:
+            files_to_fix[finding.file_path].append(finding.line_number)
+
+    total_lines_removed = 0
+    write_mode = not dry_run
+
+    # 6. Apply fixes via Governed Gateway
+    for file_path_str, line_numbers_to_delete in files_to_fix.items():
+        file_path = context.git_service.repo_path / file_path_str
+
+        # Sort lines in reverse order to avoid index shifting while deleting
+        sorted_line_numbers = sorted(line_numbers_to_delete, reverse=True)
+
+        try:
+            if not file_path.exists():
+                continue
+
+            lines = file_path.read_text("utf-8").splitlines()
+
+            for line_num in sorted_line_numbers:
+                index_to_delete = line_num - 1
+                if 0 <= index_to_delete < len(lines):
+                    del lines[index_to_delete]
+                    total_lines_removed += 1
+
+            final_code = "\n".join(lines) + "\n"
+
+            # CONSTITUTIONAL GATEWAY: Mutation is audited and guarded
+            result = await executor.execute(
+                action_id="file.edit",
+                write=write_mode,
+                file_path=file_path_str,
+                code=final_code,
+            )
+
+            if result.ok:
+                mode_str = "Purged" if write_mode else "Proposed (Dry Run)"
+                logger.info(
+                    "   -> [%s] %s lines from %s",
+                    mode_str,
+                    len(sorted_line_numbers),
+                    file_path_str,
+                )
+            else:
+                logger.error(
+                    "   -> [BLOCKED] %s: %s", file_path_str, result.data.get("error")
+                )
+
+        except Exception as e:
+            logger.error("❌ Error processing %s: %s", file_path_str, e)
+
+    return total_lines_removed

body/self_healing/remediation_models.py

@@ -0,0 +1,238 @@
+# src/body/self_healing/remediation_models.py
+"""
+Data models for the Audit Remediation Service.
+
+These are the "boxes" we use to organize information as it flows through
+the remediation process:
+  - What patterns matched
+  - What fixes we tried
+  - What the results were
+
+Think of these as forms you fill out to keep track of what happened.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
+
+from shared.models import AuditFinding
+from shared.models.remediation import AutoFixablePattern
+
+
+# ==============================================================================
+# ENUMS - These are like multiple choice options
+# ==============================================================================
+
+
+# ID: 6d502541-a127-4c4c-9d1b-cb269ef5f527
+class RemediationMode(Enum):
+    """
+    How aggressive should we be when fixing things?
+
+    SAFE_ONLY = Only fix things we're very confident about (>85% sure, low risk)
+    MEDIUM_RISK = Include fixes that are pretty safe (>70% sure, low-medium risk)
+    ALL_DETERMINISTIC = Try all fixes that don't involve AI reasoning
+
+    Start with SAFE_ONLY. Only use others when you trust the system.
+    """
+
+    SAFE_ONLY = "safe_only"
+    MEDIUM_RISK = "medium_risk"
+    ALL_DETERMINISTIC = "all_deterministic"
+
+
+# ==============================================================================
+# MATCH RECORDS - Tracking when a finding matches a fix pattern
+# ==============================================================================
+
+
+@dataclass
+# ID: 5ffc4890-959e-4a45-8bd2-cef113dccede
+class MatchedPattern:
+    """
+    Records when an audit finding matches a pattern we know how to fix.
+
+    Example:
+        Finding: "Imports are not sorted in file X"
+        Pattern: "I know how to sort imports"
+        Result: MatchedPattern connecting them
+
+    This is evidence for later - we can see which patterns matched which problems.
+    """
+
+    finding: AuditFinding  # The problem we found
+    pattern: AutoFixablePattern  # The fix pattern that applies
+    confidence: float  # How confident we are (0.0 to 1.0)
+    risk_level: str  # "low", "medium", or "high"
+
+
+# ==============================================================================
+# FIX EXECUTION RECORDS - What happened when we tried to fix something
+# ==============================================================================
+
+
+@dataclass
+# ID: 7d298182-0eee-430d-a9ff-c6a26d7e6460
+class FixResult:
+    """
+    The outcome of trying to apply ONE fix.
+
+    This is what a fix handler returns to tell us:
+    - Did it work? (ok = True/False)
+    - If not, what went wrong? (error_message)
+    - Any extra details? (changes_made)
+
+    Example:
+        FixResult(
+            ok=True,
+            error_message=None,
+            changes_made={"imports_sorted": 15}
+        )
+    """
+
+    ok: bool  # Did the fix work?
+    error_message: str | None = None  # If not, why not?
+    changes_made: dict[str, Any] | None = None  # Optional details about what changed
+
+
+@dataclass
+# ID: f3ea5a75-ed5d-4f01-8fd7-3a1cc7bce259
+class FixDetail:
+    """
+    Complete record of a single fix attempt - for evidence trail.
+
+    After we try to fix something, we create one of these to remember:
+    - Which file we fixed
+    - Which fix handler we used
+    - Whether it worked
+    - How long it took
+
+    These get saved in the evidence file so we can review what happened.
+    """
+
+    finding_id: str  # Unique identifier for the finding we fixed
+    file_path: str  # Which file we modified
+    action_handler: str  # Which handler function we used (e.g., "sort_imports")
+    status: str  # "success", "failed", or "skipped"
+    error_message: str | None  # If it failed, why?
+    duration_ms: int  # How long it took in milliseconds
+
+
+# ==============================================================================
+# OVERALL RESULTS - The complete story of a remediation session
+# ==============================================================================
+
+
+@dataclass
+# ID: cfc0238c-1276-4fa7-8373-41d969175a9d
+class RemediationResult:
+    """
+    The complete report of one remediation run.
+
+    This is the "big picture" summary that tells you:
+    - How many problems we started with
+    - How many we could fix
+    - How many we actually fixed successfully
+    - Whether things got better
+
+    Gets saved as JSON evidence file for full traceability.
+    """
+
+    # Identity - when did this happen?
+    session_id: str  # Unique ID for this run (UUID)
+    timestamp_utc: str  # When it happened (ISO format)
+
+    # Input stats - what we started with
+    total_findings: int  # Total problems from audit
+    findings_by_severity: dict[str, int]  # How many ERROR, WARNING, INFO
+
+    # Matching results - what we could potentially fix
+    matched_patterns: list[MatchedPattern]  # Problems that matched fix patterns
+    unmatched_findings: list[AuditFinding]  # Problems we don't know how to fix yet
+
+    # Execution results - what we actually did
+    fixes_attempted: int  # How many fixes we tried
+    fixes_succeeded: int  # How many worked
+    fixes_failed: int  # How many didn't work
+
+    # Validation - did we make things better?
+    validation_passed: bool  # True if audit shows improvement
+    findings_before: int  # Violation count before fixes
+    findings_after: int  # Violation count after fixes
+    improvement_delta: int  # How many fewer violations (positive = good)
+
+    # Evidence trail - details for review
+    fix_details: list[FixDetail]  # Complete list of what we tried
+    duration_sec: float  # Total time elapsed
+
+    # File references - where to find related files
+    audit_input_path: str  # Where we read audit findings from
+    remediation_output_path: str  # Where we wrote this result to
+    validation_audit_path: str | None = None  # Where validation audit was saved
+
+
+# ==============================================================================
+# HELPER FUNCTIONS - Making it easier to create these objects
+# ==============================================================================
+
+
+# ID: bcd21dff-5338-4754-baaf-30106517b102
+def create_remediation_result(
+    total_findings: int,
+    findings_by_severity: dict[str, int],
+    matched_patterns: list[MatchedPattern],
+    unmatched_findings: list[AuditFinding],
+    fix_details: list[FixDetail],
+    findings_before: int,
+    findings_after: int,
+    audit_input_path: str,
+    remediation_output_path: str,
+    validation_audit_path: str | None,
+    duration_sec: float,
+) -> RemediationResult:
+    """
+    Helper function to create a RemediationResult with less typing.
+
+    This automatically:
+    - Generates a unique session ID
+    - Sets the current timestamp
+    - Calculates success/failure counts
+    - Determines if validation passed
+
+    You just need to provide the actual data.
+    """
+    import uuid
+
+    session_id = str(uuid.uuid4())
+    timestamp_utc = datetime.now(UTC).isoformat()
+
+    fixes_succeeded = sum(1 for detail in fix_details if detail.status == "success")
+    fixes_failed = sum(1 for detail in fix_details if detail.status == "failed")
+    fixes_attempted = fixes_succeeded + fixes_failed
+
+    improvement_delta = findings_before - findings_after
+    validation_passed = findings_after < findings_before
+
+    return RemediationResult(
+        session_id=session_id,
+        timestamp_utc=timestamp_utc,
+        total_findings=total_findings,
+        findings_by_severity=findings_by_severity,
+        matched_patterns=matched_patterns,
+        unmatched_findings=unmatched_findings,
+        fixes_attempted=fixes_attempted,
+        fixes_succeeded=fixes_succeeded,
+        fixes_failed=fixes_failed,
+        validation_passed=validation_passed,
+        findings_before=findings_before,
+        findings_after=findings_after,
+        improvement_delta=improvement_delta,
+        fix_details=fix_details,
+        duration_sec=duration_sec,
+        audit_input_path=audit_input_path,
+        remediation_output_path=remediation_output_path,
+        validation_audit_path=validation_audit_path,
+    )

body/self_healing/test_context/__init__.py

@@ -0,0 +1,10 @@
+# src/body/self_healing/test_context/__init__.py
+
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations
+
+from .models import ModuleContext
+
+
+__all__ = ["ModuleContext"]

body/self_healing/test_context/detectors.py

@@ -0,0 +1,74 @@
+# src/body/self_healing/test_context/detectors.py
+
+"""Refactored logic for src/features/self_healing/test_context/detectors.py."""
+
+from __future__ import annotations
+
+
+# ID: 2ff96be2-ccfb-4ae2-8529-d5a30e5a919d
+def analyze_dependencies(imports: list[str]) -> list[str]:
+    # PURGED: 'features' removed.
+    return [
+        i
+        for i in imports
+        if any(
+            i.startswith(p) for p in ["core", "mind", "body", "will", "shared", "api"]
+        )
+    ]
+
+
+# ID: 58747330-67ea-4b4a-bf30-8b89816b8e49
+def identify_external_deps(imports: list[str]) -> list[str]:
+    patterns = [
+        "httpx",
+        "requests",
+        "sqlalchemy",
+        "psycopg2",
+        "redis",
+        "boto3",
+        "anthropic",
+        "openai",
+    ]
+    return list({i for i in imports for p in patterns if p in i.lower()})
+
+
+# ID: 034392ba-2992-4514-b294-a479e66c70c9
+def detect_fs_usage(code: str) -> bool:
+    return any(
+        x in code
+        for x in [
+            "Path(",
+            "open(",
+            ".read_text",
+            ".write_text",
+            ".mkdir(",
+            ".exists(",
+            "os.path",
+            "shutil.",
+        ]
+    )
+
+
+# ID: f338824d-8f2a-4a7b-b32f-ea6719278245
+def detect_db_usage(code: str) -> bool:
+    return any(
+        x in code
+        for x in [
+            "get_session",
+            "Session(",
+            "query(",
+            "select(",
+            "insert(",
+            "update(",
+            "delete(",
+            "sessionmaker",
+        ]
+    )
+
+
+# ID: 8f68eb3c-155c-4c49-97e0-27681a52e29e
+def detect_network_usage(code: str) -> bool:
+    return any(
+        x in code
+        for x in ["httpx.", "requests.", "AsyncClient", ".get(", ".post(", "urllib."]
+    )

body/self_healing/test_context/examples.py

@@ -0,0 +1,53 @@
+# src/body/self_healing/test_context/examples.py
+
+"""Refactored logic for src/features/self_healing/test_context/examples.py."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from shared.infrastructure.intent.operational_config import load_operational_config
+
+
+_CFG = load_operational_config().testing
+
+
+# ID: 930e05fb-c828-4995-9bfe-729fde9ff573
+def find_similar_tests(
+    repo_root: Path, module_name: str, classes: list, functions: list
+) -> list:
+    examples = []
+    tests_dir = repo_root / "tests"
+    if not tests_dir.exists():
+        return []
+    for test_file in tests_dir.rglob("test_*.py"):
+        try:
+            content = test_file.read_text(encoding="utf-8")
+            score = sum(
+                2 for c in classes if c["name"].lower() in content.lower()
+            ) + sum(1 for f in functions if f["name"] in content)
+            if score > 0:
+                examples.append(
+                    {
+                        "file": str(test_file.relative_to(repo_root)),
+                        "similarity": score,
+                        "snippet": extract_snippet(content),
+                    }
+                )
+        except Exception:
+            continue
+    return sorted(examples, key=lambda x: x["similarity"], reverse=True)[:3]
+
+
+# ID: 0f835005-0080-4f59-a4db-4b4e2da92c17
+def extract_snippet(content: str, max_lines: int = _CFG.snippet_max_lines) -> str:
+    lines = content.split("\n")
+    for i, line in enumerate(lines):
+        if line.strip().startswith("def test_"):
+            snippet = []
+            for j in range(i, min(i + max_lines, len(lines))):
+                if j > i and lines[j].strip().startswith("def "):
+                    break
+                snippet.append(lines[j])
+            return "\n".join(snippet)
+    return "\n".join(lines[:max_lines])