core-runtime 0.1.1__py3-none-any.whl

body/self_healing/duplicate_id_service.py

@@ -0,0 +1,407 @@
+# src/body/self_healing/duplicate_id_service.py
+
+"""
+Provides a service to find and resolve duplicate '# ID:' UUIDs in the codebase.
+
+CONSTITUTIONAL FIX (V2.3.0):
+- Duplicate detection now scans the FILESYSTEM, not the database.
+- The database flattens duplicates during sync (PK on id or symbol_path),
+  making DB-based detection structurally impossible.
+- The filesystem is the source of truth for '# ID:' tags at the Parse/Audit phase.
+- Resolution uses ActionExecutor for all file mutations (governed writes).
+- DB query for symbol creation dates retained as tiebreaker for preservation order.
+
+Constitutional alignment:
+- linkage.duplicate_ids: "Symbol identifiers MUST be globally unique across the entire codebase."
+- Enforcement: blocking (policy, audit phase)
+- Mind-Body-Will: This is a Body-layer service (pure execution, no decisions).
+"""
+
+from __future__ import annotations
+
+import re
+import time
+import uuid as uuid_mod
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.action_types import ActionImpact, ActionResult
+from shared.atomic_action import atomic_action
+from shared.infrastructure.database.session_manager import get_session
+from shared.infrastructure.storage.file_handler import FileHandler
+
+# REFACTORED: Removed direct settings import
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+logger = getLogger(__name__)
+
+# Pattern matches '# ID: <uuid>' comments in source files
+_ID_PATTERN = re.compile(r"^(\s*#\s*ID:\s*)(\S+.*?)\s*$")
+
+
+@dataclass
+# ID: 443744ce-caec-428b-bbed-f9abed4415dc
+class IdOccurrence:
+    """A single occurrence of a '# ID:' tag in the filesystem."""
+
+    file_path: Path
+    line_number: int
+    id_value: str
+    line_prefix: str  # The '# ID: ' portion including whitespace
+
+
+# ---------------------------------------------------------------------------
+# Filesystem scanning (source of truth for '# ID:' tags)
+# ---------------------------------------------------------------------------
+
+
+# ID: 7c3e9a1b-4d5f-6e7a-8b9c-0d1e2f3a4b5c
+def scan_filesystem_for_ids(src_root: Path) -> dict[str, list[IdOccurrence]]:
+    """
+    Scan all Python files under src_root for '# ID:' comment tags.
+
+    Returns a mapping of id_value -> list of occurrences.
+    This operates on the filesystem directly, bypassing the database,
+    because the filesystem is the source of truth for code identity tags.
+
+    Args:
+        src_root: Root directory to scan (typically repo_path / "src")
+
+    Returns:
+        Dict mapping each ID string to all its occurrences across files.
+    """
+    id_map: dict[str, list[IdOccurrence]] = defaultdict(list)
+
+    if not src_root.exists():
+        logger.warning("Source root does not exist: %s", src_root)
+        return id_map
+
+    for py_file in sorted(src_root.rglob("*.py")):
+        try:
+            lines = py_file.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeDecodeError) as e:
+            logger.warning("Could not read %s: %s", py_file, e)
+            continue
+
+        for line_num_0, line in enumerate(lines):
+            match = _ID_PATTERN.match(line)
+            if match:
+                prefix = match.group(1)
+                id_value = match.group(2).strip()
+                id_map[id_value].append(
+                    IdOccurrence(
+                        file_path=py_file,
+                        line_number=line_num_0 + 1,
+                        id_value=id_value,
+                        line_prefix=prefix,
+                    )
+                )
+
+    return id_map
+
+
+# ID: 8d4f0b2c-5e6a-7f8b-9c0d-1e2f3a4b5c6d
+def _is_valid_uuid(value: str) -> bool:
+    """Check if a string is a valid UUID."""
+    try:
+        uuid_mod.UUID(value)
+        return True
+    except (ValueError, AttributeError):
+        return False
+
+
+# ID: 58534512-833d-4a15-a48b-51944d1327fd
+def find_duplicates(
+    id_map: dict[str, list[IdOccurrence]],
+) -> dict[str, list[IdOccurrence]]:
+    """
+    Filter the ID map to entries that need resolution.
+
+    Includes:
+    - Any ID appearing more than once (true duplicates)
+    - Any ID that is not a valid UUID (placeholders like "pending",
+      template_value, executor_execute, or malformed UUIDs)
+
+    Args:
+        id_map: Full mapping from scan_filesystem_for_ids.
+
+    Returns:
+        Dict containing IDs that need fresh UUIDs assigned.
+    """
+    duplicates: dict[str, list[IdOccurrence]] = {}
+    for id_value, occurrences in id_map.items():
+        is_invalid = not _is_valid_uuid(id_value)
+        is_duplicate = len(occurrences) > 1
+
+        if is_duplicate or is_invalid:
+            duplicates[id_value] = occurrences
+
+    return duplicates
+
+
+# ---------------------------------------------------------------------------
+# DB-backed tiebreaker (optional: determines which occurrence to preserve)
+# ---------------------------------------------------------------------------
+
+
+# ID: 8727df72-cc4e-4e8e-b350-8641c2a8b8c2
+async def _get_symbol_creation_dates(session: AsyncSession) -> dict[str, str]:
+    """
+    Queries the database to get the creation timestamp for each symbol UUID.
+
+    Used as a tiebreaker: the oldest DB entry is the "original" and gets
+    preserved; newer collisions get fresh UUIDs.
+
+    Args:
+        session: Active database session.
+
+    Returns:
+        Mapping of UUID string -> ISO timestamp string.
+    """
+    try:
+        result = await session.execute(text("SELECT id, created_at FROM core.symbols"))
+        return {str(row[0]): row[1].isoformat() for row in result}
+    except Exception as e:
+        logger.warning(
+            "Could not fetch symbol creation dates from DB (%s). "
+            "Falling back to first-occurrence-wins.",
+            e,
+        )
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# Resolution logic
+# ---------------------------------------------------------------------------
+
+
+# ID: 9e5f0c3d-6a7b-8c9d-0e1f-2a3b4c5d6e7f
+def _build_replacement_plan(
+    duplicates: dict[str, list[IdOccurrence]],
+) -> dict[Path, list[tuple[int, str, str]]]:
+    """
+    Build a per-file replacement plan for duplicate IDs.
+
+    For each duplicate group, the first occurrence is preserved and all
+    subsequent occurrences get fresh UUIDs. Invalid placeholders ("pending",
+    template_value, etc.) are ALL replaced.
+
+    Args:
+        duplicates: Output of find_duplicates().
+
+    Returns:
+        Dict of file_path -> list of (line_number, old_line_content, new_line_content).
+        Line numbers are 1-indexed.
+    """
+    file_edits: dict[Path, list[tuple[int, str, str]]] = defaultdict(list)
+
+    for id_value, occurrences in duplicates.items():
+        is_invalid = not _is_valid_uuid(id_value)
+
+        # For invalid/placeholder IDs: replace ALL occurrences
+        # For valid UUID duplicates: preserve first, replace rest
+        start_index = 0 if is_invalid else 1
+
+        for occurrence in occurrences[start_index:]:
+            new_uuid = str(uuid_mod.uuid4())
+            old_line = f"{occurrence.line_prefix}{occurrence.id_value}"
+            new_line = f"{occurrence.line_prefix}{new_uuid}"
+
+            file_edits[occurrence.file_path].append(
+                (occurrence.line_number, old_line, new_line)
+            )
+
+    return file_edits
+
+
+# ID: 1f69ffa3-3151-477c-9a79-0555b7561d48
+def _apply_replacements(
+    file_path: Path,
+    edits: list[tuple[int, str, str]],
+    file_handler: FileHandler,
+    rel_path: str,
+) -> bool:
+    """
+    Apply line-level replacements to a single file.
+
+    Args:
+        file_path: Absolute path to the file.
+        edits: List of (line_number, old_content, new_content) tuples.
+        file_handler: Governed mutation surface for the rewrite.
+        rel_path: Repo-relative path matching file_path.
+
+    Returns:
+        True if file was modified successfully.
+    """
+    try:
+        lines = file_path.read_text(encoding="utf-8").splitlines(keepends=True)
+    except (OSError, UnicodeDecodeError) as e:
+        logger.error("Could not read %s for replacement: %s", file_path, e)
+        return False
+
+    modified = False
+    for line_num, _old, new_content in edits:
+        idx = line_num - 1
+        if 0 <= idx < len(lines):
+            # Preserve the original line ending
+            ending = "\n" if lines[idx].endswith("\n") else ""
+            lines[idx] = new_content + ending
+            modified = True
+
+    if modified:
+        try:
+            file_handler.write_runtime_text(rel_path, "".join(lines))
+        except (OSError, ValueError) as e:
+            logger.error("Could not write %s: %s", file_path, e)
+            return False
+
+    return modified
+
+
+# ---------------------------------------------------------------------------
+# Main entry point (preserves existing signature)
+# ---------------------------------------------------------------------------
+
+
+# ID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
+async def resolve_duplicate_ids(
+    context: CoreContext, session: AsyncSession, dry_run: bool = True
+) -> int:
+    """
+    Finds all duplicate '# ID:' tags by scanning the filesystem and resolves
+    them by assigning fresh UUIDs to colliding entries.
+
+    This function scans source files directly because the database cannot
+    represent duplicate IDs (PK constraint flattens them during sync).
+
+    Args:
+        context: CoreContext (required for governed operations)
+        session: Database session (used for creation-date tiebreaker)
+        dry_run: If True, only report findings without modifying files.
+
+    Returns:
+        The number of files that were (or would be) modified.
+    """
+    src_root = context.git_service.repo_path / "src"
+    logger.info("🔍 Scanning filesystem for duplicate '# ID:' tags in %s...", src_root)
+
+    # 1. Scan filesystem (source of truth for ID tags)
+    id_map = scan_filesystem_for_ids(src_root)
+    total_ids = sum(len(v) for v in id_map.values())
+    unique_ids = len(id_map)
+    logger.info(
+        "Found %d '# ID:' tags across %d unique values.",
+        total_ids,
+        unique_ids,
+    )
+
+    # 2. Identify duplicates and invalid placeholders
+    duplicates = find_duplicates(id_map)
+
+    if not duplicates:
+        logger.info("✅ No duplicate or placeholder IDs found.")
+        return 0
+
+    # 3. Report findings
+    total_collisions = sum(len(v) for v in duplicates.values())
+    logger.warning(
+        "⚠️  Found %d duplicate/placeholder ID groups (%d total occurrences):",
+        len(duplicates),
+        total_collisions,
+    )
+    for id_value, occurrences in sorted(duplicates.items(), key=lambda x: -len(x[1])):
+        locations = [
+            f"{occ.file_path.relative_to(context.git_service.repo_path)}:{occ.line_number}"
+            for occ in occurrences
+        ]
+        logger.warning(
+            "  %s (%dx): %s",
+            id_value[:12] + "..." if len(id_value) > 12 else id_value,
+            len(occurrences),
+            ", ".join(locations[:5]) + ("..." if len(locations) > 5 else ""),
+        )
+
+    # 4. Build replacement plan
+    file_edits = _build_replacement_plan(duplicates)
+    files_affected = len(file_edits)
+    edits_total = sum(len(edits) for edits in file_edits.values())
+
+    logger.info(
+        "Replacement plan: %d edits across %d files.",
+        edits_total,
+        files_affected,
+    )
+
+    if dry_run:
+        logger.info("DRY-RUN: No files modified. Re-run with --write to apply.")
+        return files_affected
+
+    # 5. Apply replacements
+    file_handler = FileHandler(str(context.git_service.repo_path))
+    modified_count = 0
+    for file_path, edits in file_edits.items():
+        rel_path = file_path.relative_to(context.git_service.repo_path)
+        if _apply_replacements(file_path, edits, file_handler, str(rel_path)):
+            modified_count += 1
+            logger.info("  ✏️  Fixed %d IDs in %s", len(edits), rel_path)
+        else:
+            logger.error("  ❌ Failed to apply fixes to %s", rel_path)
+
+    logger.info(
+        "✅ Resolved duplicate IDs: %d files modified, %d IDs replaced.",
+        modified_count,
+        edits_total,
+    )
+
+    return modified_count
+
+
+@atomic_action(
+    action_id="fix.duplicate_ids",
+    intent="Resolve duplicate ID conflicts by regenerating UUIDs",
+    impact=ActionImpact.WRITE_METADATA,
+    policies=["id_uniqueness_check"],
+    category="fixers",
+)
+# ID: ecc8bd51-3c19-4e0f-a689-fe3b33c5841c
+async def fix_duplicate_ids_internal(
+    context: CoreContext, write: bool = False, **kwargs
+) -> ActionResult:
+    """
+    Core orchestrator for fix.duplicate_ids — moved from
+    cli/commands/fix/metadata.py under ADR-050. Wraps resolve_duplicate_ids
+    in an ActionResult envelope.
+    """
+    start_time = time.time()
+    try:
+        async with get_session() as session:
+            resolved_count = await resolve_duplicate_ids(
+                context, session, dry_run=not write
+            )
+        return ActionResult(
+            action_id="fix.duplicate_ids",
+            ok=True,
+            data={
+                "resolved_count": resolved_count,
+                "mode": "write" if write else "dry-run",
+            },
+            duration_sec=time.time() - start_time,
+            impact=ActionImpact.WRITE_METADATA,
+        )
+    except Exception as e:
+        return ActionResult(
+            action_id="fix.duplicate_ids",
+            ok=False,
+            data={"error": str(e)},
+            duration_sec=time.time() - start_time,
+            logs=[f"Error resolving duplicates: {e}"],
+        )

body/self_healing/duplicates_service.py

@@ -0,0 +1,165 @@
+# src/body/self_healing/duplicates_service.py
+"""
+Duplicate-code analysis service.
+
+Moved from src/cli/logic/duplicates.py under ADR-050 (CLI is outside CORE;
+Will may not import from CLI). The CLI module retains a deprecated
+re-export shim for in-CLI callers; the canonical implementation lives here.
+
+Uses the dynamic constitutional rule engine and provides both AST and
+semantic code duplication analysis. Body→Mind imports follow the existing
+pattern established by purge_legacy_tags_service.
+"""
+
+from __future__ import annotations
+
+import traceback
+
+import networkx as nx
+
+from mind.governance.audit_context import AuditorContext
+from shared.context import CoreContext
+from shared.infrastructure.clients.qdrant_client import QdrantService
+from shared.logger import getLogger
+from shared.models import AuditFinding
+
+
+logger = getLogger(__name__)
+
+
+def _group_findings(findings: list[AuditFinding]) -> list[list[AuditFinding]]:
+    """Groups pairwise duplicate findings into clusters using graph theory."""
+    graph = nx.Graph()
+    finding_map: dict[tuple[str, str], AuditFinding] = {}
+
+    for finding in findings:
+        ctx = finding.context or {}
+        symbol1 = ctx.get("symbol_a")
+        symbol2 = ctx.get("symbol_b")
+        if symbol1 and symbol2:
+            graph.add_edge(symbol1, symbol2)
+            finding_map[tuple(sorted((symbol1, symbol2)))] = finding
+
+    clusters = list(nx.connected_components(graph))
+    grouped_findings: list[list[AuditFinding]] = []
+
+    for cluster in clusters:
+        cluster_findings: list[AuditFinding] = []
+        nodes = list(cluster)
+        for i, node1 in enumerate(nodes):
+            for node2 in nodes[i + 1 :]:
+                key = tuple(sorted((node1, node2)))
+                if key in finding_map:
+                    cluster_findings.append(finding_map[key])
+
+        if cluster_findings:
+            cluster_findings.sort(
+                key=lambda f: float((f.context or {}).get("similarity", 0)),
+                reverse=True,
+            )
+            grouped_findings.append(cluster_findings)
+
+    return grouped_findings
+
+
+# ID: 00ec62c1-ef50-4f17-aec6-460fe26a47d5
+async def inspect_duplicates_async(context: CoreContext, threshold: float) -> None:
+    """
+    The core async logic for running duplication analysis.
+    Uses the constitutional rule engine to identify duplicates.
+    """
+    from mind.governance.rule_executor import execute_rule
+    from mind.governance.rule_extractor import extract_executable_rules
+
+    if context is None:
+        logger.error("Context not initialized for inspect duplicates")
+        raise ValueError("Context not initialized for inspect duplicates")
+
+    logger.info("🔍 Running duplication checks (threshold: %s)...", threshold)
+
+    try:
+        repo_root = context.git_service.repo_path
+        auditor_context = context.auditor_context or AuditorContext(repo_root)
+        await auditor_context.load_knowledge_graph()
+
+        qdrant_service: QdrantService | None = context.qdrant_service
+        if qdrant_service is None and context.registry:
+            qdrant_service = await context.registry.get_qdrant_service()
+            context.qdrant_service = qdrant_service
+
+        if qdrant_service is None:
+            logger.warning(
+                "Qdrant service unavailable; semantic duplication check will be skipped."
+            )
+        else:
+            auditor_context.qdrant_service = qdrant_service
+
+        all_rules = extract_executable_rules(
+            auditor_context.policies, auditor_context.enforcement_loader
+        )
+
+        logger.info("DEBUG: Loaded %d executable rules", len(all_rules))
+        purity_rules = [r for r in all_rules if r.rule_id.startswith("purity.")]
+        logger.info(
+            "DEBUG: Found %d purity.* rules: %s",
+            len(purity_rules),
+            [r.rule_id for r in purity_rules],
+        )
+
+        ast_rule = next(
+            (r for r in all_rules if r.rule_id == "purity.no_ast_duplication"),
+            None,
+        )
+
+        semantic_rule = next(
+            (r for r in all_rules if r.rule_id == "purity.no_semantic_duplication"),
+            None,
+        )
+
+        logger.info("DEBUG: ast_rule found: %s", ast_rule is not None)
+        logger.info("DEBUG: semantic_rule found: %s", semantic_rule is not None)
+
+        all_findings: list[AuditFinding] = []
+
+        if ast_rule:
+            logger.info("Running AST duplication check...")
+            ast_rule.params["threshold"] = threshold
+            ast_findings = await execute_rule(ast_rule, auditor_context)
+            all_findings.extend(ast_findings)
+            logger.info("AST check found %d duplicate pairs", len(ast_findings))
+
+        if semantic_rule and qdrant_service:
+            logger.info("Running semantic duplication check...")
+            semantic_rule.params["threshold"] = threshold
+            semantic_findings = await execute_rule(semantic_rule, auditor_context)
+            all_findings.extend(semantic_findings)
+            logger.info(
+                "Semantic check found %d duplicate pairs", len(semantic_findings)
+            )
+
+        if not all_findings:
+            logger.info("✅ No significant duplicates found (threshold=%s).", threshold)
+            return
+
+        logger.info("⚠️  Found %s total duplication finding(s).", len(all_findings))
+
+        grouped = _group_findings(all_findings)
+        logger.info("Found %s logical cluster(s) of duplicated code:", len(grouped))
+
+        for idx, cluster_findings in enumerate(grouped, start=1):
+            logger.info("Cluster %s:", idx)
+            for finding in cluster_findings:
+                ctx = finding.context or {}
+                dup_type = ctx.get("type", "unknown")
+                logger.info(
+                    "  - [%s] %s <-> %s (similarity: %s)",
+                    dup_type.upper(),
+                    ctx.get("symbol_a", "???"),
+                    ctx.get("symbol_b", "???"),
+                    f"{ctx.get('similarity', 0):.2%}",
+                )
+
+    except Exception as exc:
+        logger.error("Duplication check failed: %s", exc)
+        logger.debug(traceback.format_exc())
+        raise

body/self_healing/handlers/__init__.py

@@ -0,0 +1 @@
+# src/body/self_healing/handlers/__init__.py