core-runtime 0.1.1__py3-none-any.whl

body/self_healing/test_target_analyzer.py

@@ -0,0 +1,118 @@
+# src/body/self_healing/test_target_analyzer.py
+"""
+Analyzes Python source files to identify and classify functions as test targets.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from radon.visitors import ComplexityVisitor
+
+
+Classification = Literal["SIMPLE", "COMPLEX"]
+
+
+@dataclass
+# ID: 4be9923d-aa4d-4fc6-83ff-1bc1c1918f09
+class TestTarget:
+    """Represents a potential function to be tested."""
+
+    __test__ = False
+
+    name: str
+    complexity: int
+    classification: Classification
+    reason: str
+
+
+# ID: e1e93bfa-852d-4673-85e3-ffc827419c8c
+class TestTargetAnalyzer:
+    """Analyzes a Python file and classifies its functions for testability."""
+
+    __test__ = False
+
+    def __init__(self, complexity_threshold: int = 5):
+        self.complexity_threshold = complexity_threshold
+        self.complex_arg_types = {"CoreContext", "AsyncSession"}
+        self.io_imports = {"httpx", "sqlalchemy", "get_session"}
+
+    # ID: f268fe3a-a735-46bc-8438-b0197dcbca8f
+    def analyze_file(self, file_path: Path) -> list[TestTarget]:
+        """
+        Analyzes a single Python file and returns a list of classified test targets.
+        """
+        try:
+            content = file_path.read_text("utf-8")
+            tree = ast.parse(content)
+            complexity_visitor = ComplexityVisitor.from_code(content)
+        except Exception:
+            return []
+
+        imports = self._get_imports(tree)
+        targets = []
+
+        for func in complexity_visitor.functions:
+            is_public = not func.name.startswith("_")
+            if not is_public:
+                continue
+
+            node = self._find_func_node(tree, func.name)
+            if not node:
+                continue
+
+            classification, reason = self._classify_function(func, node, imports)
+            targets.append(
+                TestTarget(
+                    name=func.name,
+                    complexity=func.complexity,
+                    classification=classification,
+                    reason=reason,
+                )
+            )
+
+        return sorted(targets, key=lambda t: t.complexity)
+
+    def _get_imports(self, tree: ast.AST) -> set[str]:
+        """Extracts top-level import names from an AST."""
+        imports = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.add(alias.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom) and node.module:
+                imports.add(node.module.split(".")[0])
+        return imports
+
+    def _find_func_node(
+        self, tree: ast.AST, func_name: str
+    ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+        """Finds the AST node for a function by name."""
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if node.name == func_name:
+                    return node
+        return None
+
+    def _classify_function(
+        self,
+        func_metrics,
+        node: ast.FunctionDef | ast.AsyncFunctionDef,
+        file_imports: set[str],
+    ) -> tuple[Classification, str]:
+        """Applies heuristics to classify a function as SIMPLE or COMPLEX."""
+        if func_metrics.complexity > self.complexity_threshold:
+            return "COMPLEX", f"High complexity ({func_metrics.complexity})"
+
+        for arg in node.args.args:
+            if arg.annotation and isinstance(arg.annotation, ast.Name):
+                if arg.annotation.id in self.complex_arg_types:
+                    return "COMPLEX", f"Depends on complex type '{arg.annotation.id}'"
+
+        if self.io_imports.intersection(file_imports):
+            return "COMPLEX", "File involves I/O operations"
+
+        return "SIMPLE", "Low complexity, no complex dependencies"

body/self_healing/vulture_healer.py

@@ -0,0 +1,161 @@
+# src/body/self_healing/vulture_healer.py
+"""Surgical cleanup of Vulture dead-code findings.
+
+Uses local LLM intelligence to safely remove unused variables and functions
+identified by the Vulture static analyser.
+
+Relocated from src/will/self_healing/vulture_healer.py under ADR-055 D6
+Stage B reopen #6: this module has no will/* dependencies (only
+body/services/file_service + shared.*), so its previous will/ placement
+was a layer misfit. Registration as fix.vulture_heal in
+body/atomic/fix_actions.py expects this module to live under body/.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from body.services.file_service import FileService
+from shared.ai.prompt_model import PromptModel
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+from shared.utils.parsing import extract_python_code_from_response
+
+
+logger = getLogger(__name__)
+
+
+# ID: 515a5f31-deb3-41bc-9736-4e29e1989a0f
+async def heal_dead_code(
+    context,
+    file_handler: FileService,
+    repo_root: Path,
+    write: bool = False,
+) -> None:
+    """Surgical cleanup of Vulture findings using local intelligence.
+
+    Args:
+        context: CoreContext providing cognitive_service.
+        file_handler: Governed file mutation surface.
+        repo_root: Repository root path.
+        write: If False, dry-run only. If True, applies deletions.
+    """
+    path_resolver = PathResolver(repo_root)
+
+    # Canonical path via PathResolver — never hardcoded.
+    evidence_path = path_resolver.audit_findings_path
+
+    if not evidence_path.exists():
+        logger.error(
+            "No audit evidence found at %s. Run 'core-admin check audit' first.",
+            evidence_path,
+        )
+        return
+
+    try:
+        findings = json.loads(evidence_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        logger.error("Failed to read audit findings from %s: %s", evidence_path, e)
+        return
+
+    dead_code_targets = [
+        f for f in findings if f.get("check_id") == "workflow.dead_code_check"
+    ]
+
+    if not dead_code_targets:
+        logger.info("No dead code findings in the ledger.")
+        return
+
+    # Ensure artifact directory exists via governed channel.
+    artifact_rel = "work/artifacts/healer"
+    file_handler.ensure_dir(artifact_rel)
+
+    logger.info(
+        "Found %d dead code targets — beginning surgical cleanup (write=%s)",
+        len(dead_code_targets),
+        write,
+    )
+
+    cognitive_service = getattr(context, "cognitive_service", None)
+    if cognitive_service is None:
+        logger.error(
+            "cognitive_service unavailable on CoreContext — cannot perform LLM-assisted healing."
+        )
+        return
+
+    healed = 0
+    skipped = 0
+    errors = 0
+
+    for finding in dead_code_targets:
+        file_path_str = finding.get("file_path")
+        line_number = finding.get("line_number")
+        message = finding.get("message", "")
+
+        if not file_path_str or not file_path_str.endswith(".py"):
+            skipped += 1
+            continue
+
+        abs_path = repo_root / file_path_str
+        if not abs_path.exists():
+            logger.warning("Dead code target not found: %s — skipping", abs_path)
+            skipped += 1
+            continue
+
+        try:
+            source = abs_path.read_text(encoding="utf-8")
+        except OSError as e:
+            logger.error("Could not read %s: %s", abs_path, e)
+            errors += 1
+            continue
+
+        prompt_model = PromptModel(cognitive_service=cognitive_service)
+        prompt = (
+            f"You are a precise Python refactoring tool.\n\n"
+            f"The following finding was reported by Vulture (dead code detector):\n"
+            f"  File: {file_path_str}\n"
+            f"  Line: {line_number}\n"
+            f"  Finding: {message}\n\n"
+            f"Remove the dead code item identified above from the source file below. "
+            f"Do not modify any other code. "
+            f"Return only the complete updated Python file, no explanation.\n\n"
+            f"```python\n{source}\n```"
+        )
+
+        try:
+            response = await prompt_model.complete(prompt)
+            updated_code = extract_python_code_from_response(response)
+        except Exception as e:
+            logger.error("LLM healing failed for %s: %s", file_path_str, e)
+            errors += 1
+            continue
+
+        if not updated_code or updated_code.strip() == source.strip():
+            logger.info("No change produced for %s — skipping", file_path_str)
+            skipped += 1
+            continue
+
+        if write:
+            try:
+                file_handler.write_runtime_text(file_path_str, updated_code)
+                logger.info("Healed: %s (line %s)", file_path_str, line_number)
+                healed += 1
+            except Exception as e:
+                logger.error("FileHandler write failed for %s: %s", file_path_str, e)
+                errors += 1
+        else:
+            logger.info(
+                "[DRY RUN] Would remove dead code in %s (line %s)",
+                file_path_str,
+                line_number,
+            )
+            healed += 1
+
+    logger.info(
+        "Vulture healer complete — healed=%d, skipped=%d, errors=%d (write=%s)",
+        healed,
+        skipped,
+        errors,
+        write,
+    )

body/services/__init__.py

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

body/services/artifact_service.py

@@ -0,0 +1,155 @@
+# src/body/services/artifact_service.py
+"""
+ArtifactService - Data-access layer for core.repo_artifacts (embedding lifecycle).
+
+Covers:
+  - RepoEmbedderWorker.run — fetch unembedded, mark empty, update chunk count
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: beea8b47-3e24-45cf-af38-f2624f65d3b5
+class ArtifactService:
+    """
+    Body layer service. Exposes named methods for core.repo_artifacts
+    operations used by RepoEmbedderWorker.
+    """
+
+    # ID: 5b5d1e10-9ee1-45da-971d-8c5663c445ff
+    async def fetch_unembedded_artifacts(self, batch_size: int) -> list[dict[str, Any]]:
+        """
+        Return up to *batch_size* artifacts that have not yet been embedded
+        (chunk_count = 0), ordered by most recently crawled first.
+        Excludes permanently-skipped artifacts (chunk_count = -1).
+
+        Returns list of dicts with keys: id, file_path, artifact_type,
+        qdrant_collection.
+
+        Covers:
+          - RepoEmbedderWorker.run — SELECT from core.repo_artifacts WHERE chunk_count = 0
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    SELECT id, file_path, artifact_type, qdrant_collection
+                    FROM core.repo_artifacts
+                    WHERE chunk_count = 0
+                      AND chunk_count != -1
+                    ORDER BY last_crawled_at DESC
+                    LIMIT :batch_size
+                    """
+                ),
+                {"batch_size": batch_size},
+            )
+            return [
+                {
+                    "id": str(row[0]),
+                    "file_path": row[1],
+                    "artifact_type": row[2],
+                    "qdrant_collection": row[3],
+                }
+                for row in result.fetchall()
+            ]
+
+    # ID: 5ca77ba6-4b34-46f3-a65b-29e0a29850ee
+    async def mark_artifact_empty(self, artifact_id: str) -> None:
+        """
+        Set chunk_count = -1 to permanently skip an empty artifact.
+
+        Covers:
+          - RepoEmbedderWorker.run — UPDATE chunk_count = -1 (empty file branch)
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            await session.execute(
+                text(
+                    "UPDATE core.repo_artifacts SET chunk_count = -1 "
+                    "WHERE id = cast(:artifact_id as uuid)"
+                ),
+                {"artifact_id": artifact_id},
+            )
+            await session.commit()
+
+    # ID: 8ed59fa4-8696-4b39-848d-582949d7248b
+    async def update_artifact_chunk_count(
+        self, artifact_id: str, chunk_count: int
+    ) -> None:
+        """
+        Record the number of semantic chunks produced for an artifact
+        after a successful embedding pass.
+
+        Covers:
+          - RepoEmbedderWorker.run — UPDATE core.repo_artifacts SET chunk_count = :chunk_count
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            await session.execute(
+                text(
+                    """
+                    UPDATE core.repo_artifacts
+                    SET chunk_count = :chunk_count
+                    WHERE id = cast(:artifact_id as uuid)
+                    """
+                ),
+                {"chunk_count": chunk_count, "artifact_id": artifact_id},
+            )
+            await session.commit()
+
+    # ID: c3d4e5f6-a7b8-9012-cdef-012345678901
+    async def count_pending_artifacts(self) -> int:
+        """
+        Count repo_artifacts with chunk_count = 0 (unembedded, not permanently skipped).
+
+        Covers:
+          - sync_actions.action_sync_code_vectors — per-pass pending check
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    "SELECT COUNT(*) FROM core.repo_artifacts "
+                    "WHERE chunk_count = 0 AND chunk_count != -1"
+                )
+            )
+            return result.scalar() or 0
+
+    # ID: 1a8d7e2b-5c91-4f3a-9d6b-8e4c0a72f513
+    async def reset_pending_chunk_counts(self) -> int:
+        """
+        Reset chunk_count to 0 on every artifact that has been embedded
+        (chunk_count > 0), forcing the next embed pass to treat them as
+        pending. Permanently-skipped artifacts (chunk_count = -1) are left
+        alone — they were determined empty and should not be re-queued.
+
+        Returns the number of rows reset.
+
+        Covers:
+          - sync.vectors_code force=True — pre-loop reset before re-embed.
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    "UPDATE core.repo_artifacts SET chunk_count = 0 "
+                    "WHERE chunk_count > 0"
+                )
+            )
+            await session.commit()
+            return result.rowcount or 0

body/services/blackboard_service/__init__.py

@@ -0,0 +1,22 @@
+# src/body/services/blackboard_service/__init__.py
+# blackboard_service/__init__.py
+"""
+Package split from blackboard_service.py.
+"""
+
+from __future__ import annotations
+
+from .blackboard_claim_service import BlackboardClaimService
+from .blackboard_proposal_service import BlackboardProposalService
+from .blackboard_query_service import BlackboardQueryService
+from .blackboard_service import BlackboardService
+
+
+# ID: 88382dd0-e47a-4538-88b7-40c050a649f8
+class BlackboardService(
+    BlackboardService,
+    BlackboardProposalService,
+    BlackboardQueryService,
+    BlackboardClaimService,
+):
+    pass

body/services/blackboard_service/blackboard_claim_service.py

@@ -0,0 +1,216 @@
+# src/body/services/blackboard_service/blackboard_claim_service.py
+"""Atomic claiming methods — FOR UPDATE SKIP LOCKED, return claimed rows."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from typing import Any
+
+from sqlalchemy import text
+
+
+# ID: 9f135870-8e69-4c6b-a733-3c24cb8be8dc
+class BlackboardClaimService:
+    # ID: 39ffce8c-7f06-40c0-b8e6-16183b788a56
+    async def claim_open_findings(
+        self, subject_prefix: str, limit: int
+    ) -> list[dict[str, Any]]:
+        """
+        Atomically claim up to *limit* open findings whose subject matches
+        *subject_prefix*.  Uses FOR UPDATE SKIP LOCKED to prevent
+        double-claiming across concurrent worker instances.
+
+        Returns list of dicts with keys: id, subject, payload.
+
+        Covers:
+          - PromptExtractorWorker._claim_open_findings
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            async with session.begin():
+                result = await session.execute(
+                    text(
+                        """
+                        UPDATE core.blackboard_entries
+                        SET status = 'claimed',
+                            claimed_at = now(),
+                            updated_at = now()
+                        WHERE id IN (
+                            SELECT id FROM core.blackboard_entries
+                            WHERE entry_type = 'finding'
+                              AND subject LIKE :prefix
+                              AND status = 'open'
+                            ORDER BY created_at ASC
+                            LIMIT :limit
+                            FOR UPDATE SKIP LOCKED
+                        )
+                        RETURNING id, subject, payload
+                        """
+                    ),
+                    {"prefix": subject_prefix, "limit": limit},
+                )
+                rows = result.fetchall()
+
+        findings = []
+        for row in rows:
+            raw_payload = row[2]
+            payload = (
+                raw_payload
+                if isinstance(raw_payload, dict)
+                else json.loads(raw_payload)
+            )
+            findings.append(
+                {
+                    "id": str(row[0]),
+                    "subject": row[1],
+                    "payload": payload,
+                }
+            )
+        return findings
+
+    # ID: f3a8d1c2-7e45-4b09-a3f6-9d2c0e5b1a87
+    async def claim_violation_findings(
+        self, prefix: str, limit: int, claimed_by: uuid.UUID | None = None
+    ) -> list[dict[str, Any]]:
+        """
+        Atomically claim up to *limit* open findings whose subject matches
+        *prefix*, ordered by severity (critical first) then creation time.
+        Uses FOR UPDATE SKIP LOCKED to prevent double-claiming across
+        concurrent worker instances.
+
+        Returns list of dicts with keys: id, subject, payload.
+
+        Covers:
+          - ViolationRemediator._claim_open_findings
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            async with session.begin():
+                result = await session.execute(
+                    text(
+                        """
+                        UPDATE core.blackboard_entries
+                        SET status = 'claimed',
+                            claimed_by = :claimed_by,
+                            claimed_at = now(),
+                            updated_at = now()
+                        WHERE id IN (
+                            SELECT id FROM core.blackboard_entries
+                            WHERE entry_type = 'finding'
+                              AND subject LIKE :prefix
+                              AND status = 'open'
+                            ORDER BY
+                                CASE (payload->>'severity')
+                                    WHEN 'critical' THEN 1
+                                    WHEN 'error'    THEN 2
+                                    WHEN 'warning'  THEN 3
+                                    WHEN 'info'     THEN 4
+                                    ELSE 5
+                                END ASC,
+                                created_at ASC
+                            LIMIT :limit
+                            FOR UPDATE SKIP LOCKED
+                        )
+                        RETURNING id, subject, payload
+                        """
+                    ),
+                    {
+                        "prefix": prefix,
+                        "limit": limit,
+                        "claimed_by": str(claimed_by) if claimed_by else None,
+                    },
+                )
+                rows = result.fetchall()
+
+        findings = []
+        for row in rows:
+            raw_payload = row[2]
+            payload = (
+                raw_payload
+                if isinstance(raw_payload, dict)
+                else json.loads(raw_payload)
+            )
+            findings.append(
+                {
+                    "id": str(row[0]),
+                    "subject": row[1],
+                    "payload": payload,
+                }
+            )
+        return findings
+
+    # ID: 8b1e6f3a-d42c-4e7a-9f05-b3c8a71d2e94
+    async def claim_unmapped_violation_findings(
+        self,
+        mapped_rule_ids: set[str],
+        limit: int,
+        claimed_by: uuid.UUID,
+    ) -> list[dict[str, Any]]:
+        """
+        Atomically claim open audit.violation findings whose rule is NOT
+        in the mapped_rule_ids set. Used by ViolationExecutorWorker (Will)
+        to claim findings that RemediatorWorker left unclaimed.
+
+        Returns a list of dicts: {id, subject, payload}.
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        if mapped_rule_ids:
+            rule_filter = "AND payload->>'rule' != ALL(:mapped_rules)"
+            params: dict[str, Any] = {
+                "limit": limit,
+                "claimed_by": str(claimed_by),
+                "mapped_rules": list(mapped_rule_ids),
+            }
+        else:
+            rule_filter = ""
+            params = {
+                "limit": limit,
+                "claimed_by": str(claimed_by),
+            }
+
+        sql = f"""
+            WITH to_claim AS (
+                SELECT id
+                FROM core.blackboard_entries
+                WHERE entry_type = 'finding'
+                  AND subject LIKE 'audit.violation::%%'
+                  AND status = 'open'
+                  {rule_filter}
+                ORDER BY created_at ASC
+                LIMIT :limit
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE core.blackboard_entries
+            SET status = 'claimed',
+                claimed_by = cast(:claimed_by as uuid),
+                claimed_at = now(),
+                updated_at = now()
+            WHERE id IN (SELECT id FROM to_claim)
+            RETURNING id, subject, payload
+        """
+
+        async with ServiceRegistry.session() as session:
+            async with session.begin():
+                result = await session.execute(text(sql), params)
+                rows = result.fetchall()
+
+        findings = []
+        for row in rows:
+            raw_payload = row[2]
+            payload = (
+                raw_payload
+                if isinstance(raw_payload, dict)
+                else json.loads(raw_payload)
+            )
+            findings.append(
+                {
+                    "id": str(row[0]),
+                    "subject": row[1],
+                    "payload": payload,
+                }
+            )
+        return findings