core-runtime 0.1.1__py3-none-any.whl

body/introspection/sync/scanner.py

@@ -0,0 +1,56 @@
+# src/body/introspection/sync/scanner.py
+
+"""Refactored logic for src/features/introspection/sync/scanner.py."""
+
+from __future__ import annotations
+
+import ast
+import logging
+from pathlib import Path
+from typing import Any
+
+# REFACTORED: Removed direct settings import
+from shared.utils.domain_mapper import map_module_to_domain
+
+from .visitor import SymbolVisitor
+
+
+logger = logging.getLogger(__name__)
+
+
+# ID: 73de4c04-495b-4ecb-bf94-04e06acdbf2d
+class SymbolScanner:
+    """Scans the codebase to extract symbol information."""
+
+    def __init__(self, repo_root: Path) -> None:
+        self.repo_root = repo_root
+
+    # ID: 3659a617-162e-41e5-979d-af439c230b17
+    def scan(self) -> list[dict[str, Any]]:
+        src_dir = self.repo_root / "src"
+        all_symbols: list[dict[str, Any]] = []
+
+        if not src_dir.exists():
+            logger.warning("Source directory not found: %s", src_dir)
+            return []
+
+        for file_path in src_dir.rglob("*.py"):
+            try:
+                content = file_path.read_text(encoding="utf-8")
+                tree = ast.parse(content, filename=str(file_path))
+                rel_path_str = str(file_path.relative_to(self.repo_root))
+
+                module_path = rel_path_str.replace(".py", "").replace("/", ".")
+                domain = map_module_to_domain(module_path)
+
+                visitor = SymbolVisitor(rel_path_str)
+                visitor.visit(tree)
+
+                for sym in visitor.symbols:
+                    sym["domain"] = domain
+                    all_symbols.append(sym)
+            except Exception as exc:
+                logger.error("Error scanning %s: %s", file_path, exc)
+
+        unique_symbols = {s["symbol_path"]: s for s in all_symbols}
+        return list(unique_symbols.values())

body/introspection/sync/visitor.py

@@ -0,0 +1,83 @@
+# src/body/introspection/sync/visitor.py
+
+"""Refactored logic for src/features/introspection/sync/visitor.py."""
+
+from __future__ import annotations
+
+import ast
+import json
+import uuid
+from typing import Any
+
+from shared.ast_utility import FunctionCallVisitor, calculate_structural_hash
+
+
+# ID: d766fc43-dea6-4156-8fe9-f9577416ad31
+class SymbolVisitor(ast.NodeVisitor):
+    """
+    An AST visitor that discovers top-level public symbols, their immediate methods,
+    and the symbols they call.
+    """
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = file_path
+        self.symbols: list[dict[str, Any]] = []
+        self.class_stack: list[str] = []
+
+    # ID: e7f6fab3-cf81-46ff-b2d1-21d7b6f311c6
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        if not self.class_stack:
+            self._process_symbol(node)
+            self.class_stack.append(node.name)
+            self.generic_visit(node)
+            self.class_stack.pop()
+
+    # ID: 056a919f-fe43-4bab-9398-48c93c971545
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        if len(self.class_stack) <= 1:
+            self._process_symbol(node)
+
+    # ID: aae1a414-338b-4a62-bb93-5a5a6b22a1fa
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        if len(self.class_stack) <= 1:
+            self._process_symbol(node)
+
+    def _process_symbol(
+        self, node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> None:
+        is_public = not node.name.startswith("_")
+        is_dunder = node.name.startswith("__") and node.name.endswith("__")
+        if not (is_public and not is_dunder):
+            return
+
+        path_components = [*self.class_stack, node.name]
+        symbol_path = f"{self.file_path}::{'.'.join(path_components)}"
+        qualname = ".".join(path_components)
+
+        module_name = (
+            self.file_path.replace("src/", "").replace(".py", "").replace("/", ".")
+        )
+        kind_map = {
+            "ClassDef": "class",
+            "FunctionDef": "method" if self.class_stack else "function",
+            "AsyncFunctionDef": "method" if self.class_stack else "function",
+        }
+
+        call_visitor = FunctionCallVisitor()
+        call_visitor.visit(node)
+        calls = sorted(list(call_visitor.calls))
+
+        self.symbols.append(
+            {
+                "id": uuid.uuid5(uuid.NAMESPACE_DNS, symbol_path),
+                "symbol_path": symbol_path,
+                "module": module_name,
+                "qualname": qualname,
+                "kind": kind_map.get(type(node).__name__, "function"),
+                "ast_signature": "pending",
+                "fingerprint": calculate_structural_hash(node),
+                "state": "discovered",
+                "is_public": True,
+                "calls": json.dumps(calls),
+            }
+        )

body/introspection/sync_service.py

@@ -0,0 +1,62 @@
+# src/body/introspection/sync_service.py
+
+"""
+Symbol Synchronization Service
+Orchestrates Mind/Body alignment via modularized components.
+"""
+
+from __future__ import annotations
+
+import time
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.action_types import ActionImpact, ActionResult
+from shared.atomic_action import atomic_action
+from shared.logger import getLogger
+
+from .sync.engine import run_db_merge
+from .sync.scanner import SymbolScanner
+
+
+logger = getLogger(__name__)
+
+
+@atomic_action(
+    action_id="sync.knowledge_graph",
+    intent="Synchronize filesystem symbols to the persistent database Knowledge Graph",
+    impact=ActionImpact.WRITE_DATA,
+    policies=["knowledge.database_ssot", "db.write_via_governed_cli"],
+    category="introspection",
+)
+# ID: 3d99a5e7-06f8-4cfa-aba8-41a6e0655987
+async def run_sync_with_db(session: AsyncSession, **kwargs) -> ActionResult:
+    """Entry point for the database-centric sync logic."""
+    start_time = time.time()
+    logger.info("🚀 Starting symbol sync with database (Mind/Body alignment)")
+
+    # 1. Scan the Body
+    from shared.infrastructure.bootstrap_registry import bootstrap_registry
+
+    scanner = SymbolScanner(repo_root=bootstrap_registry.get_repo_path())
+    code_state = scanner.scan()
+
+    # 2. Update the Mind
+    stats = await run_db_merge(session, code_state)
+    await session.commit()
+
+    logger.info(
+        "✅ Sync complete. Scanned: %d, New: %d, Updated: %d, Delta: %d",
+        stats["scanned"],
+        stats["inserted"],
+        stats["updated"],
+        stats["deleted"],
+    )
+
+    return ActionResult(
+        action_id="sync.knowledge_graph",
+        ok=True,
+        data=stats,
+        duration_sec=time.time() - start_time,
+        impact=ActionImpact.WRITE_DATA,
+    )

body/invokers/__init__.py

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

body/invokers/capability_invoker.py

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

body/maintenance/command_sync_service.py

@@ -0,0 +1,73 @@
+# src/body/maintenance/command_sync_service.py
+
+"""
+Provides a service to introspect the live Typer CLI application and synchronize
+the discovered commands with the `core.cli_commands` database table.
+
+CONSTITUTIONAL HARDENING (v2.4):
+- The audit-time ``audit_cli_registry`` entry point was retired (#483) once
+  ``cli_gate`` became the autonomous enforcement engine for the eight CLI
+  rules; ``self_check_cmd`` now drives those rules through ``cli_gate``
+  directly. This module's responsibility narrows to runtime DB sync.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import delete
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.cli.app_introspection import walk_typer_app
+from shared.infrastructure.database.models import CliCommand
+from shared.logger import getLogger
+from shared.protocols.typer_protocols import (
+    TyperAppLike,
+)
+
+
+logger = getLogger(__name__)
+
+
+async def _sync_commands_to_db(session: AsyncSession, main_app: TyperAppLike):
+    """
+    Introspects the main CLI application and syncs to database.
+    """
+    discovered_commands = walk_typer_app(main_app)
+
+    if not discovered_commands:
+        return
+
+    seen_names: set[str] = set()
+    deduplicated: list[dict[str, Any]] = []
+
+    for cmd in discovered_commands:
+        # DB schema doesn't need audit-only fields, strip them before DB write
+        db_ready_cmd = {
+            k: v
+            for k, v in cmd.items()
+            if k
+            not in {
+                "params_list",
+                "has_callback",
+                "has_explicit_meta",
+                "file_path",
+                "callback",
+            }
+        }
+
+        name = db_ready_cmd["name"]
+        if name not in seen_names:
+            seen_names.add(name)
+            deduplicated.append(db_ready_cmd)
+
+    async with session.begin():
+        await session.execute(delete(CliCommand))
+        if deduplicated:
+            stmt = pg_insert(CliCommand).values(deduplicated)
+            update_dict = {c.name: c for c in stmt.excluded if not c.primary_key}
+            upsert_stmt = stmt.on_conflict_do_update(
+                index_elements=["name"], set_=update_dict
+            )
+            await session.execute(upsert_stmt)

body/maintenance/dotenv_sync_service.py

@@ -0,0 +1,99 @@
+# src/body/maintenance/dotenv_sync_service.py
+
+"""Provides functionality for the dotenv_sync_service module."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from sqlalchemy import func
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.ext.asyncio import AsyncSession
+
+# REFACTORED: Removed direct settings import
+from shared.infrastructure.database.models import RuntimeSetting
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+
+logger = getLogger(__name__)
+
+
+# ID: b4e0cca2-7956-4ee9-80bc-e36aca3bf0f5
+async def run_dotenv_sync(context: CoreContext, session: AsyncSession, dry_run: bool):
+    """
+    Reads variables defined in runtime_requirements.yaml from the environment/.env
+    and upserts them into the core.runtime_settings table.
+
+    Args:
+        session: Database session (injected dependency)
+        dry_run: If True, only report what would be done without executing
+    """
+    logger.info("Synchronizing .env configuration to database...")
+
+    try:
+        runtime_reqs = context.settings.load("mind.config.runtime_requirements")
+        variables_to_sync = runtime_reqs.get("variables", {})
+    except FileNotFoundError as e:
+        logger.error("Cannot find runtime_requirements policy: %s", e)
+        return
+
+    settings_to_upsert: list[dict[str, Any]] = []
+    for key, config in variables_to_sync.items():
+        value = getattr(context.settings, key, None)
+        if value is None:
+            value_str = None
+        elif isinstance(value, bool):
+            value_str = str(value).lower()
+        else:
+            value_str = str(value)
+        is_secret = config.get("source") == "secret" or "_KEY" in key or "_TOKEN" in key
+        settings_to_upsert.append(
+            {
+                "key": key,
+                "value": value_str,
+                "description": config.get("description"),
+                "is_secret": is_secret,
+            }
+        )
+
+    if dry_run:
+        logger.info("-- DRY RUN: The following settings would be synced --")
+        for setting in settings_to_upsert:
+            display_value = (
+                "********"
+                if setting["is_secret"] and setting["value"]
+                else str(setting["value"])
+            )
+            logger.info(
+                "Plan: Key=%s | Value=%s | Secret=%s",
+                setting["key"],
+                display_value,
+                setting["is_secret"],
+            )
+        return
+
+    try:
+        async with session.begin():
+            stmt = pg_insert(RuntimeSetting).values(settings_to_upsert)
+            update_dict = {
+                "value": stmt.excluded.value,
+                "description": stmt.excluded.description,
+                "is_secret": stmt.excluded.is_secret,
+                "last_updated": func.now(),
+            }
+            upsert_stmt = stmt.on_conflict_do_update(
+                index_elements=["key"], set_=update_dict
+            )
+            await session.execute(upsert_stmt)
+
+        logger.info(
+            "Successfully synchronized %d settings to the database.",
+            len(settings_to_upsert),
+        )
+    except Exception as e:
+        logger.error("Database sync failed: %s", e, exc_info=True)
+        raise

body/maintenance/idempotency_harness.py

@@ -0,0 +1,70 @@
+# src/body/maintenance/idempotency_harness.py
+
+"""
+Idempotency Test Harness - Phase 2 Hardening.
+Verifies that system mutations are stable and do not cause 'logic drift' on repeated runs.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from body.atomic.executor import ActionExecutor
+from shared.infrastructure.storage.integrity_service import IntegrityService
+from shared.logger import getLogger
+from shared.models.validation_result import ValidationResult
+
+
+logger = getLogger(__name__)
+
+
+# ID: c5de649e-62b2-49a4-80f2-aedc16b6cdfb
+class IdempotencyHarness:
+    """
+    Orchestrates the 'Run -> Baseline -> Run -> Verify' stability sequence.
+    """
+
+    def __init__(self, core_context: Any):
+        self.context = core_context
+        self.executor = ActionExecutor(core_context)
+        self.integrity = IntegrityService(core_context.git_service.repo_path)
+
+    # ID: f06e3a61-9e9a-4e95-9bcb-3bf71f377646
+    async def verify_action(self, action_id: str, **params: Any) -> ValidationResult:
+        """
+        Tests an atomic action for idempotency.
+
+        Sequence:
+        1. Primary Mutation: Applies the fix/change.
+        2. Snapshot: Records the 'Clean' state.
+        3. Secondary Mutation: Attempts the same change again.
+        4. Drift Check: Ensures the second run produced zero changes.
+        """
+        logger.info("🧪 Testing Idempotency for: %s", action_id)
+        label = f"idempotency_{action_id}_{int(time.time())}"
+
+        # 1. Primary Mutation (Ensure we are in a 'Final' state)
+        logger.debug("   -> Phase 1: Primary Mutation")
+        await self.executor.execute(action_id, write=True, **params)
+
+        # 2. Snapshot (Historical Truth)
+        logger.debug("   -> Phase 2: Creating Baseline")
+        self.integrity.create_baseline(label)
+
+        # 3. Secondary Mutation (The Stability Test)
+        logger.debug("   -> Phase 3: Secondary Mutation")
+        await self.executor.execute(action_id, write=True, **params)
+
+        # 4. Drift Check (Sensation)
+        logger.debug("   -> Phase 4: Verifying zero-drift")
+        result = self.integrity.verify_integrity(label)
+
+        if result.ok:
+            logger.info("✅ Idempotency Proven: %s is stable.", action_id)
+        else:
+            logger.warning(
+                "❌ Idempotency Failure: %s caused drift on repeat.", action_id
+            )
+
+        return result

body/maintenance/maintenance_service.py

@@ -0,0 +1,123 @@
+# src/body/maintenance/maintenance_service.py
+
+"""
+Provides centralized services for repository maintenance tasks.
+UPDATED: Hardened for Indented and Prefix-aware re-wiring (Wave 4).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+    from shared.infrastructure.storage.file_handler import FileHandler
+
+logger = getLogger(__name__)
+
+# THE NEW WORLD MAP
+REWIRE_MAP = {
+    # Brains (Will)
+    "features.autonomy": "will.autonomy",
+    "features.self_healing.audit_remediation_service": "will.self_healing.audit_remediation_service",
+    "features.self_healing.clarity_service": "will.self_healing.clarity_service",
+    "features.self_healing.complexity_service": "will.self_healing.complexity_service",
+    "features.test_generation": "will.test_generation",
+    # Hands (Body)
+    "features.introspection": "body.introspection",
+    "features.maintenance": "body.maintenance",
+    "features.project_lifecycle": "body.project_lifecycle",
+    "features.quality": "body.quality",
+    "features.crate_processing": "body.crate_processing",
+    "features.operations": "body.operations",
+    "features.self_healing": "body.self_healing",
+    # Law (Mind)
+    "features.governance": "mind.governance",
+    # Specific Layer Moves
+    "body.cli": "cli",
+}
+
+
+# ID: 12fcea31-5e2a-46e6-8e8c-9fd529ffc667
+def rewire_imports(
+    context: CoreContext, file_handler: FileHandler, dry_run: bool = True
+) -> int:
+    """
+    Scans and corrects Python imports across the entire src/ directory.
+
+    HARDENED:
+    1. Removed '^' anchor to catch indented/lazy imports.
+    2. Accounts for 'src.' prefix ghosts.
+    3. Prevents self-mutation of the REWIRE_MAP itself.
+    """
+    src_dir = context.git_service.repo_path / "src"
+    all_python_files = list(src_dir.rglob("*.py"))
+    total_changes = 0
+
+    # Pattern matches: [optional space] (from|import) [path]
+    # Removed ^ to catch lazy imports inside functions/TypeChecking blocks
+    import_re = re.compile(r"(\s*(?:from|import)\s+)([a-zA-Z0-9_.]+)")
+
+    sorted_rewire_keys = sorted(REWIRE_MAP.keys(), key=len, reverse=True)
+
+    for file_path in all_python_files:
+        # CONSTITUTIONAL GUARD: Don't let the script rewire its own map definition
+        if file_path.name == "maintenance_service.py":
+            continue
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            lines = content.splitlines()
+            new_lines = []
+            file_changed = False
+
+            for line in lines:
+                match = import_re.search(line)
+                if not match:
+                    new_lines.append(line)
+                    continue
+
+                prefix = match.group(1)  # e.g. "    from "
+                orig_path = match.group(2)  # e.g. "features.introspection"
+
+                modified_path = orig_path
+
+                # Check for each old path in our map
+                for old_key in sorted_rewire_keys:
+                    new_val = REWIRE_MAP[old_key]
+
+                    # Handle standard path
+                    if modified_path.startswith(old_key):
+                        modified_path = modified_path.replace(old_key, new_val, 1)
+                        break
+
+                    # Handle the 'src.' ghost prefix
+                    src_old_key = f"src.{old_key}"
+                    if modified_path.startswith(src_old_key):
+                        # We preserve the 'src.' prefix if the project uses absolute roots
+                        modified_path = modified_path.replace(
+                            src_old_key, f"src.{new_val}", 1
+                        )
+                        break
+
+                if modified_path != orig_path:
+                    # Construct the new line preserving original indentation and keywords
+                    new_line = line.replace(orig_path, modified_path, 1)
+                    new_lines.append(new_line)
+                    file_changed = True
+                    total_changes += 1
+                else:
+                    new_lines.append(line)
+
+            if file_changed and not dry_run:
+                rel_path = str(file_path.relative_to(context.git_service.repo_path))
+                file_handler.write_runtime_text(rel_path, "\n".join(new_lines) + "\n")
+
+        except Exception as e:
+            logger.error("Error processing %s: %s", file_path, e)
+
+    return total_changes