core-runtime 0.1.1__py3-none-any.whl

body/autonomy/audit_analyzer.py

@@ -0,0 +1,343 @@
+# src/body/autonomy/audit_analyzer.py
+"""
+Audit Analyzer - Identifies auto-fixable violations from audit findings.
+
+Bridges audit detection and autonomous remediation by reading the
+constitutional remediation map from .intent/ and matching audit findings
+against it.
+
+Constitutional alignment:
+- Remediation mappings live in .intent/enforcement/mappings/remediation/
+- No action mappings are hardcoded in this file
+- Adding/removing a mapping is a constitutional act (.intent/ edit only)
+- No mutations - pure analysis only
+
+V2.7 FIX:
+- Removed hardcoded REMEDIATION_MAP_PATH constant.
+- Removed hardcoded MIN_CONFIDENCE constant.
+- Both are now loaded via PathResolver from:
+    .intent/enforcement/config/governance_paths.yaml
+- AuditAnalyzer.findings_path now uses PathResolver.audit_findings_path.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+
+
+logger = getLogger(__name__)
+
+# Fallback used only when governance_paths.yaml cannot be loaded.
+# This constant must NOT be used in logic — it is a last-resort default only.
+_FALLBACK_MIN_CONFIDENCE: float = 0.80
+
+
+# ID: e1f2a3b4-c5d6-7890-efab-cd0000000001
+def _load_governance_config(path_resolver: PathResolver) -> dict[str, Any]:
+    """
+    Load governance paths & thresholds from .intent/enforcement/config/governance_paths.yaml.
+
+    Returns empty dict on failure so callers can apply fallbacks gracefully.
+    """
+    config_path = path_resolver.governance_config_path
+    if not config_path.exists():
+        logger.warning(
+            "Governance config not found at %s — using fallback defaults. "
+            "Create .intent/enforcement/config/governance_paths.yaml to configure.",
+            config_path,
+        )
+        return {}
+    try:
+        raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        return raw if isinstance(raw, dict) else {}
+    except Exception as e:
+        logger.error("Failed to load governance config from %s: %s", config_path, e)
+        return {}
+
+
+# ID: dc64f3c1-b122-4032-ac7c-acf00f43f6d6
+def _load_remediation_map(path_resolver: PathResolver) -> dict[str, dict[str, Any]]:
+    """
+    Load the remediation map via PathResolver.
+
+    Path is resolved from PathResolver.remediation_map_path — never hardcoded.
+    Each entry must declare exactly one of 'action' (AtomicAction id) or
+    'flow' (Flow id). The validated dict carries both 'ref_id' and 'ref_kind'
+    so callers can construct the appropriate ProposalAction without
+    re-discriminating.
+    Returns a dict of
+      {check_id: {action, flow, ref_id, ref_kind, confidence, risk, description, status}}.
+    Fails gracefully — returns empty dict if file missing or malformed.
+    """
+    map_path = path_resolver.remediation_map_path
+
+    if not map_path.exists():
+        logger.warning(
+            "Remediation map not found: %s — no autonomous proposals will be generated. "
+            "Populate .intent/enforcement/mappings/remediation/auto_remediation.yaml to enable.",
+            map_path,
+        )
+        return {}
+
+    try:
+        raw = yaml.safe_load(map_path.read_text(encoding="utf-8"))
+    except Exception as e:
+        logger.error("Failed to load remediation map from %s: %s", map_path, e)
+        return {}
+
+    mappings = raw.get("mappings", {})
+    if not isinstance(mappings, dict):
+        logger.error(
+            "Remediation map has unexpected format (expected dict under 'mappings')"
+        )
+        return {}
+
+    validated: dict[str, dict[str, Any]] = {}
+    for check_id, entry in mappings.items():
+        if not isinstance(entry, dict):
+            logger.warning(
+                "Remediation map: skipping malformed entry for '%s'", check_id
+            )
+            continue
+
+        has_action = entry.get("action") is not None
+        has_flow = entry.get("flow") is not None
+        if has_action and has_flow:
+            logger.warning(
+                "Remediation map: entry '%s' declares both 'action' and 'flow' — "
+                "skipped (must declare exactly one)",
+                check_id,
+            )
+            continue
+        if not has_action and not has_flow:
+            logger.warning(
+                "Remediation map: entry '%s' missing both 'action' and 'flow' — "
+                "skipped (must declare exactly one)",
+                check_id,
+            )
+            continue
+        # Skip PENDING entries explicitly (status field in auto_remediation.yaml)
+        if entry.get("status") == "PENDING":
+            logger.debug("Remediation map: skipping PENDING entry '%s'", check_id)
+            continue
+
+        ref_id = entry["action"] if has_action else entry["flow"]
+        ref_kind = "action" if has_action else "flow"
+
+        validated[check_id] = {
+            "action": entry.get("action"),
+            "flow": entry.get("flow"),
+            "ref_id": ref_id,
+            "ref_kind": ref_kind,
+            "confidence": float(entry.get("confidence", 0.0)),
+            "risk": entry.get("risk", "medium"),
+            "description": entry.get("description", ""),
+            "status": entry.get("status", "ACTIVE"),
+        }
+
+    logger.debug(
+        "Remediation map loaded: %d active mappings from %s", len(validated), map_path
+    )
+    return validated
+
+
+# ID: b2c3d4e5-f6a7-8901-bcde-f12345678901
+class AuditAnalyzer:
+    """
+    Analyzes audit findings to identify auto-fixable violations.
+
+    Autonomous loop: audit findings -> fixable list -> proposals -> execution.
+
+    The mapping from check_id to action is loaded from:
+      .intent/enforcement/mappings/remediation/auto_remediation.yaml
+
+    The min_confidence threshold is loaded from:
+      .intent/enforcement/config/governance_paths.yaml
+
+    No paths or thresholds are hardcoded in this file.
+    Adding a new remediable rule = editing .intent/ only.
+    """
+
+    def __init__(self, repo_root: Path) -> None:
+        """
+        Initialize analyzer.
+
+        Args:
+            repo_root: Repository root path. Used to construct PathResolver.
+                       Kept as a Path argument for backward compatibility with
+                       all existing callers.
+        """
+        self._path_resolver = PathResolver(repo_root)
+
+        # Derive findings path from PathResolver — never hardcoded.
+        self.findings_path = self._path_resolver.audit_findings_path
+
+        # Load min_confidence from constitutional governance config.
+        gov_config = _load_governance_config(self._path_resolver)
+        self._min_confidence: float = float(
+            gov_config.get("remediation", {}).get(
+                "min_confidence", _FALLBACK_MIN_CONFIDENCE
+            )
+        )
+        logger.debug(
+            "AuditAnalyzer: min_confidence=%.2f (source: %s)",
+            self._min_confidence,
+            "governance_paths.yaml" if gov_config else "fallback default",
+        )
+
+        self._remediation_map: dict[str, dict[str, Any]] | None = None
+
+    def _get_remediation_map(self) -> dict[str, dict[str, Any]]:
+        """Lazy-load the remediation map (cached per instance)."""
+        if self._remediation_map is None:
+            self._remediation_map = _load_remediation_map(self._path_resolver)
+        return self._remediation_map
+
+    # ID: c3d4e5f6-a7b8-9012-cdef-123456789012
+    def analyze_findings(self, findings_path: Path | None = None) -> dict[str, Any]:
+        """
+        Analyze audit findings to identify auto-fixable violations.
+
+        Loads the remediation map from .intent/, reads audit findings,
+        matches each finding's check_id against the map, and groups
+        fixable findings by action. Only entries with confidence >=
+        min_confidence (from governance_paths.yaml) are included.
+
+        Args:
+            findings_path: Override path to audit findings JSON.
+
+        Returns:
+            Dict with keys: status, total_findings, auto_fixable_count,
+            fixable_by_action, not_fixable, summary_by_action.
+        """
+        remediation_map = self._get_remediation_map()
+
+        if not remediation_map:
+            return {
+                "status": "no_remediation_map",
+                "message": (
+                    "No remediation mappings found. "
+                    "Populate .intent/enforcement/mappings/remediation/auto_remediation.yaml."
+                ),
+                "auto_fixable_count": 0,
+                "fixable_by_action": {},
+                "summary_by_action": [],
+            }
+
+        path = findings_path or self.findings_path
+
+        if not path.exists():
+            logger.warning("Audit findings not found: %s", path)
+            return {
+                "status": "no_findings",
+                "message": f"No audit findings found at {path}",
+                "auto_fixable_count": 0,
+                "fixable_by_action": {},
+                "summary_by_action": [],
+            }
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                findings = json.load(f)
+        except json.JSONDecodeError as e:
+            logger.error("Failed to parse audit findings: %s", e)
+            return {
+                "status": "parse_error",
+                "message": f"Failed to parse JSON: {e}",
+                "auto_fixable_count": 0,
+                "fixable_by_action": {},
+                "summary_by_action": [],
+            }
+
+        if not isinstance(findings, list):
+            logger.error(
+                "Unexpected findings format: expected list, got %s",
+                type(findings),
+            )
+            return {
+                "status": "format_error",
+                "message": "Audit findings not in expected format",
+                "auto_fixable_count": 0,
+                "fixable_by_action": {},
+                "summary_by_action": [],
+            }
+
+        logger.info(
+            "Analyzing %d audit findings against %d remediation mappings "
+            "(min_confidence=%.2f)",
+            len(findings),
+            len(remediation_map),
+            self._min_confidence,
+        )
+
+        fixable_by_action: dict[str, list[dict[str, Any]]] = {}
+        not_fixable: list[dict[str, Any]] = []
+
+        for finding in findings:
+            check_id = finding.get("check_id", "") or finding.get("rule_id", "")
+            if not check_id:
+                continue
+
+            entry = remediation_map.get(check_id)
+
+            if entry and entry["confidence"] >= self._min_confidence:
+                action = entry["action"]
+                fixable_by_action.setdefault(action, [])
+                fixable_by_action[action].append(
+                    {
+                        **finding,
+                        "fix_action": action,
+                        "fix_confidence": entry["confidence"],
+                        "fix_risk": entry["risk"],
+                        "fix_description": entry["description"],
+                    }
+                )
+            else:
+                not_fixable.append(finding)
+
+        total_fixable = sum(len(v) for v in fixable_by_action.values())
+
+        logger.info(
+            "Analysis complete: %d auto-fixable (%.1f%%), %d not auto-fixable",
+            total_fixable,
+            (total_fixable / len(findings) * 100) if findings else 0,
+            len(not_fixable),
+        )
+
+        return {
+            "status": "success",
+            "total_findings": len(findings),
+            "auto_fixable_count": total_fixable,
+            "not_fixable_count": len(not_fixable),
+            "fixable_by_action": fixable_by_action,
+            "not_fixable": not_fixable[:20],
+            "summary_by_action": self._summarize_by_action(fixable_by_action),
+        }
+
+    # ID: e5f6a7b8-c9d0-1234-ef12-345678901234
+    def _summarize_by_action(
+        self, fixable_by_action: dict[str, list[dict[str, Any]]]
+    ) -> list[dict[str, Any]]:
+        """Summarise fixable findings grouped by action."""
+        return [
+            {
+                "action": action,
+                "count": len(findings),
+                "files": list({f.get("file_path", "unknown") for f in findings})[:10],
+                "avg_confidence": (
+                    sum(f["fix_confidence"] for f in findings) / len(findings)
+                    if findings
+                    else 0.0
+                ),
+            }
+            for action, findings in sorted(
+                fixable_by_action.items(), key=lambda kv: len(kv[1]), reverse=True
+            )
+        ]

body/autonomy/micro_proposal_executor.py

@@ -0,0 +1,316 @@
+# src/body/autonomy/micro_proposal_executor.py
+
+"""
+Service for validating and applying micro-proposals to enable safe, autonomous
+changes to the CORE codebase, adhering to the micro_proposal_policy and
+enforcing safe_by_default and reason_with_purpose principles.
+
+Architectural rule:
+- No direct filesystem mutations (write_text/unlink/mkdir/etc.) in this service.
+- All mutations must go through FileHandler (IntentGuard enforced).
+
+CONSTITUTIONAL COMPLIANCE:
+- Searches for micro_proposal_policy in new .intent/ structure
+- Uses FileHandler for all mutations (IntentGuard enforced)
+- No direct .intent/ filesystem access
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.models import CheckResult
+from shared.path_utils import get_repo_root
+from shared.processors.yaml_processor import strict_yaml_processor
+from shared.utils.glob_match import matches_any_glob
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: 5a5fabd4-5e30-48c6-ad4d-5702abbb22e8
+class MicroProposal:
+    """Internal data structure for a micro-proposal with target file, action, and content."""
+
+    file_path: str
+    action: str
+    content: str
+    validation_report_id: str | None = None
+    intent_bundle_id: str | None = None  # Added for constitutional audit traceability
+
+
+# ID: 91fbe5a7-9add-46b5-9443-c9759e49fa28
+class MicroProposalExecutor:
+    """
+    Validates and applies micro-proposals for safe, autonomous changes as defined
+    by micro_proposal_policy, ensuring compliance with safe_by_default and
+    reason_with_purpose principles.
+    """
+
+    def __init__(self, repo_root: Path | None = None) -> None:
+        """
+        Initialize the executor with the repository root and load the policy.
+
+        Args:
+            repo_root: Path to the repository root, defaults to detected root.
+        """
+        self.repo_root = (repo_root or get_repo_root()).resolve()
+
+        # FIXED: Search for policy in new .intent/ structure
+        # Try multiple possible locations
+        possible_paths = [
+            self.repo_root / ".intent/phases/micro_proposal_policy.yaml",
+            self.repo_root / ".intent/workflows/micro_proposal_policy.yaml",
+            self.repo_root / ".intent/rules/will/micro_proposal_policy.json",
+            self.repo_root
+            / ".intent/rules/will/autonomy.json",  # May be embedded in autonomy rules
+        ]
+
+        self.policy_path = None
+        for path in possible_paths:
+            if path.exists():
+                self.policy_path = path
+                logger.debug("Found micro_proposal_policy at: %s", path)
+                break
+
+        if not self.policy_path:
+            logger.warning(
+                "micro_proposal_policy not found in any expected location, using empty policy"
+            )
+            self.policy = {"policy_id": "micro_proposal_policy", "rules": []}
+        else:
+            self.policy = self._load_policy()
+
+        # Mutation surface (IntentGuard enforced inside)
+        self.fs = FileHandler(str(self.repo_root))
+
+        logger.debug("MicroProposalExecutor initialized (repo_root=%s)", self.repo_root)
+
+    def _load_policy(self) -> dict:
+        """
+        Load and validate the micro_proposal_policy.
+
+        Returns:
+            Dict: The parsed policy content.
+
+        Raises:
+            ValueError: If the policy file is missing or invalid.
+        """
+        if not self.policy_path:
+            return {"policy_id": "micro_proposal_policy", "rules": []}
+
+        try:
+            policy = strict_yaml_processor.load_strict(self.policy_path)
+            if not policy:
+                raise ValueError("Micro-proposal policy is empty or invalid")
+            return policy
+        except ValueError as e:
+            logger.error("Failed to load micro-proposal policy: %s", e)
+            raise
+
+    def _check_safe_actions(self, action: str) -> CheckResult:
+        """
+        Verify if the action is in the allowed_actions list.
+        """
+        safe_actions_rule = next(
+            (
+                rule
+                for rule in self.policy.get("rules", [])
+                if rule.get("id") == "safe_actions"
+            ),
+            None,
+        )
+        allowed = (safe_actions_rule or {}).get("allowed_actions", []) or []
+        if action not in allowed:
+            return CheckResult(
+                policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+                rule_id="safe_actions",
+                severity="error",
+                message=f"Action '{action}' is not in allowed actions",
+                path=None,
+            )
+        return CheckResult(
+            policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+            rule_id="safe_actions",
+            severity="pass",
+            message=f"Action '{action}' is allowed",
+            path=None,
+        )
+
+    def _check_safe_paths(self, file_path: str) -> CheckResult:
+        """
+        Verify if the file_path matches allowed patterns and does not match forbidden patterns.
+        """
+        # This module historically validated paths via policy rules, but the repo also
+        # enforces a second gate at mutation-time (IntentGuard inside FileHandler).
+        safe_paths_rule = next(
+            (
+                rule
+                for rule in self.policy.get("rules", [])
+                if rule.get("id") == "safe_paths"
+            ),
+            None,
+        )
+        allowed_patterns = (safe_paths_rule or {}).get("allowed_paths", []) or []
+        forbidden_patterns = (safe_paths_rule or {}).get("forbidden_paths", []) or []
+
+        # Normalize to repo-relative for evaluation
+        rel = self._normalize_to_repo_rel(file_path)
+
+        # Glob matching uses gitignore semantics via shared helper (ADR-012)
+        if forbidden_patterns and matches_any_glob(rel, forbidden_patterns):
+            return CheckResult(
+                policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+                rule_id="safe_paths",
+                severity="error",
+                message=f"File path '{rel}' matches a forbidden pattern",
+                path=rel,
+            )
+        if allowed_patterns and not matches_any_glob(rel, allowed_patterns):
+            return CheckResult(
+                policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+                rule_id="safe_paths",
+                severity="error",
+                message=f"File path '{rel}' does not match any allowed pattern",
+                path=rel,
+            )
+        return CheckResult(
+            policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+            rule_id="safe_paths",
+            severity="pass",
+            message=f"File path '{rel}' is allowed",
+            path=rel,
+        )
+
+    def _check_validation_report(self, report_id: str | None) -> CheckResult:
+        """
+        Verify if a validation report ID is provided and valid (placeholder).
+        """
+        if not report_id:
+            return CheckResult(
+                policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+                rule_id="require_validation",
+                severity="error",
+                message="No validation report ID provided",
+                path=None,
+            )
+        return CheckResult(
+            policy_id=self.policy.get("policy_id", "micro_proposal_policy"),
+            rule_id="require_validation",
+            severity="pass",
+            message=f"Validation report '{report_id}' accepted (placeholder)",
+            path=None,
+        )
+
+    # ID: 8e521e21-2ee8-4890-8e1a-be92893f4d61
+    def validate_proposal(self, proposal: MicroProposal) -> list[CheckResult]:
+        """
+        Validate a micro-proposal against safe_actions, safe_paths, and
+        require_validation rules from micro_proposal_policy.
+        """
+        results: list[CheckResult] = []
+        logger.debug(
+            "Validating micro-proposal for action '%s' on '%s'",
+            proposal.action,
+            proposal.file_path,
+        )
+        results.append(self._check_safe_actions(proposal.action))
+        results.append(self._check_safe_paths(proposal.file_path))
+        results.append(self._check_validation_report(proposal.validation_report_id))
+
+        errors = [r for r in results if r.severity == "error"]
+        if errors:
+            logger.error(
+                "Micro-proposal validation failed: %s",
+                [(r.rule_id, r.message) for r in errors],
+            )
+        else:
+            logger.info("Micro-proposal passed all validation checks")
+        return results
+
+    def _normalize_to_repo_rel(self, file_path: str) -> str:
+        """
+        Convert file_path into a repo-relative path (string), rejecting escapes.
+        Supports:
+        - repo-relative paths like 'src/x.py'
+        - absolute paths under repo_root like '/opt/dev/CORE/src/x.py'
+        """
+        raw = str(file_path).strip()
+
+        # Treat empty as invalid early (prevents writing to repo root by mistake)
+        if not raw:
+            raise ValueError("Proposal file_path is empty")
+
+        p = Path(raw)
+
+        if p.is_absolute():
+            try:
+                rel = p.resolve().relative_to(self.repo_root)
+            except ValueError as e:
+                raise ValueError(f"Absolute path is outside repo_root: {p}") from e
+            return str(rel).lstrip("./")
+
+        # Relative: normalize and ensure it stays within repo_root when resolved
+        candidate = (self.repo_root / p).resolve()
+        try:
+            rel = candidate.relative_to(self.repo_root)
+        except ValueError as e:
+            raise ValueError(f"Relative path escapes repo_root: {raw}") from e
+
+        return str(rel).lstrip("./")
+
+    # ID: d9dcf58e-224a-4971-bab0-750913c3c3e8
+    async def apply_proposal(self, proposal: MicroProposal) -> bool:
+        """
+        Apply a validated micro-proposal by executing the specified action.
+
+        Policy:
+        - Validation first
+        - Log intent_bundle_id
+        - Write only via FileHandler (IntentGuard enforced)
+        """
+        validation_results = self.validate_proposal(proposal)
+        if any(result.severity == "error" for result in validation_results):
+            logger.error("Cannot apply proposal due to validation errors")
+            return False
+
+        # Constitutional requirement: Generate and log IntentBundle ID before write operations
+        if not proposal.intent_bundle_id:
+            proposal.intent_bundle_id = str(uuid.uuid4())
+
+        logger.info(
+            "Applying micro-proposal with intent_bundle_id: %s",
+            proposal.intent_bundle_id,
+        )
+
+        try:
+            rel_target = self._normalize_to_repo_rel(proposal.file_path)
+
+            if proposal.action in {
+                "autonomy.self_healing.format_code",
+                "autonomy.self_healing.fix_docstrings",
+                "autonomy.self_healing.fix_headers",
+            }:
+                logger.info(
+                    "Writing changes for intent_bundle_id: %s to %s",
+                    proposal.intent_bundle_id,
+                    rel_target,
+                )
+
+                # IMPORTANT: mutation via governed surface (IntentGuard blocks .intent/**)
+                self.fs.write_runtime_text(rel_target, proposal.content)
+
+                logger.info("Applied %s to %s", proposal.action, rel_target)
+                return True
+
+            logger.error("Unsupported action: %s", proposal.action)
+            return False
+
+        except Exception as e:
+            logger.error("Failed to apply micro-proposal: %s", e)
+            return False