core-runtime 0.1.1__py3-none-any.whl

body/services/symbol_query_service.py

@@ -0,0 +1,218 @@
+# src/body/services/symbol_query_service.py
+
+"""
+SymbolQueryService - Body layer service for symbol search and lookup.
+
+Constitutional Compliance:
+- Body layer service: Provides capability without making decisions
+- Mind/Body/Will separation: Encapsulates symbol database access
+- No direct database access in Will: Will queries symbols through this service
+- Dependency injection: Takes AsyncSession, no global imports
+
+Part of Mind-Body-Will architecture:
+- Mind: Database contains Symbol definitions (what exists in codebase)
+- Body: This service provides search/lookup capability
+- Will: Uses this service to find symbols for decision-making (strategy)
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.infrastructure.database.models import Symbol
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+__all__ = ["SymbolQueryService"]
+
+
+# ID: f6789012-3456-7890-abcd-ef1234567890
+class SymbolQueryService:
+    """
+    Body service for symbol search and lookup operations.
+
+    Responsibilities:
+    - Provide search interface for symbols by name, module, qualname
+    - Encapsulate symbol database queries
+    - Return structured symbol data for Will to use in decisions
+
+    Does NOT:
+    - Decide which symbols to use (that's Will)
+    - Modify symbols (that's SymbolDefinitionRepository)
+    - Generate symbols (that's code analysis tools)
+    """
+
+    def __init__(self, session: AsyncSession):
+        """
+        Initialize service with database session.
+
+        Args:
+            session: Active database session for queries
+        """
+        self.session = session
+
+    # ID: 01234567-89ab-cdef-0123-456789abcdef
+    async def search_symbols(
+        self, query: str, limit: int | None = None
+    ) -> list[Symbol]:
+        """
+        Search symbols by name or module using fuzzy matching.
+
+        Args:
+            query: Search term (matched against qualname and module)
+            limit: Optional maximum number of results
+
+        Returns:
+            List of Symbol instances matching the query
+
+        Constitutional Note:
+        This is a read operation. Will uses this to discover available symbols
+        for import generation or code understanding.
+
+        Example:
+            symbols = await symbol_service.search_symbols("FileHandler")
+        """
+        # Clean query for SQL ILIKE
+        clean_query = query.strip()
+
+        stmt = select(Symbol).where(
+            or_(
+                Symbol.qualname.ilike(f"%{clean_query}%"),
+                Symbol.module.ilike(f"%{clean_query}%"),
+            )
+        )
+
+        if limit is not None:
+            stmt = stmt.limit(limit)
+
+        result = await self.session.execute(stmt)
+        symbols = list(result.scalars().all())
+
+        logger.debug("Symbol search for '%s' returned %d results", query, len(symbols))
+        return symbols
+
+    # ID: 12345678-9abc-def0-1234-56789abcdef0
+    async def find_by_name(self, name: str) -> Symbol | None:
+        """
+        Find symbol by exact name match.
+
+        Args:
+            name: Exact symbol name to find
+
+        Returns:
+            Symbol instance if found, None otherwise
+
+        Constitutional Note:
+        Exact lookup for when Will knows precisely which symbol it needs.
+        Returns single result or None (not a list).
+
+        Example:
+            symbol = await symbol_service.find_by_name("FileHandler")
+        """
+        stmt = select(Symbol).where(Symbol.name == name).limit(1)
+
+        result = await self.session.execute(stmt)
+        symbol = result.scalar_one_or_none()
+
+        if symbol:
+            logger.debug("Found symbol: %s in %s", name, symbol.module)
+        else:
+            logger.debug("Symbol not found: %s", name)
+
+        return symbol
+
+    # ID: 23456789-abcd-ef01-2345-6789abcdef01
+    async def find_by_module(self, module: str) -> list[Symbol]:
+        """
+        Find all symbols in a specific module.
+
+        Args:
+            module: Module path (e.g., "shared.infrastructure.database")
+
+        Returns:
+            List of Symbol instances in the module
+
+        Constitutional Note:
+        Module-level queries for when Will needs to understand
+        what's available in a specific module.
+
+        Example:
+            symbols = await symbol_service.find_by_module("src.body.services")
+        """
+        stmt = select(Symbol).where(Symbol.module == module)
+
+        result = await self.session.execute(stmt)
+        symbols = list(result.scalars().all())
+
+        logger.debug("Found %d symbols in module %s", len(symbols), module)
+        return symbols
+
+    # ID: 3456789a-bcde-f012-3456-789abcdef012
+    async def find_by_qualname(self, qualname: str) -> Symbol | None:
+        """
+        Find symbol by fully qualified name.
+
+        Args:
+            qualname: Fully qualified name (e.g., "FileHandler.write_file")
+
+        Returns:
+            Symbol instance if found, None otherwise
+
+        Constitutional Note:
+        Most precise lookup method. Will uses this when it has
+        the complete qualified path to a symbol.
+
+        Example:
+            symbol = await symbol_service.find_by_qualname(
+                "shared.infrastructure.storage.FileHandler.write_file"
+            )
+        """
+        stmt = select(Symbol).where(Symbol.qualname == qualname).limit(1)
+
+        result = await self.session.execute(stmt)
+        symbol = result.scalar_one_or_none()
+
+        if symbol:
+            logger.debug("Found symbol by qualname: %s", qualname)
+        else:
+            logger.debug("Symbol not found by qualname: %s", qualname)
+
+        return symbol
+
+    # ID: 456789ab-cdef-0123-4567-89abcdef0123
+    async def get_symbols_by_file(self, file_path: str) -> list[Symbol]:
+        """
+        Get all symbols defined in a specific file.
+
+        Args:
+            file_path: Repository-relative file path
+
+        Returns:
+            List of Symbol instances defined in the file
+
+        Constitutional Note:
+        File-level queries for when Will needs to understand
+        what's defined in a specific source file.
+
+        Example:
+            symbols = await symbol_service.get_symbols_by_file(
+                "src/body/services/mind_state_service.py"
+            )
+        """
+        stmt = select(Symbol).where(Symbol.file_path == file_path)
+
+        result = await self.session.execute(stmt)
+        symbols = list(result.scalars().all())
+
+        logger.debug("Found %d symbols in file %s", len(symbols), file_path)
+        return symbols
+
+
+# Constitutional Note:
+# This service exists because Will layer MUST NOT import get_session directly.
+# Symbol queries are reads, but they're still infrastructure access.
+# Will depends on Body for capabilities. This service IS that capability.
+# Any Will component needing symbol data should receive SymbolQueryService via DI.

body/services/symbol_service.py

@@ -0,0 +1,94 @@
+# src/body/services/symbol_service.py
+"""
+SymbolService - Data-access layer for core.symbols (capability tagging).
+
+Covers:
+  - CapabilityTaggerWorker._fetch_untagged_symbols
+  - CapabilityTaggerWorker._tag_symbols (UPDATE loop)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 5fa7ca27-3636-48c8-87af-6dba94427689
+class SymbolService:
+    """
+    Body layer service. Exposes named methods for core.symbols operations
+    used by CapabilityTaggerWorker.
+    """
+
+    # ID: 8cd068da-396e-47d9-a241-f4a3c3633a21
+    async def fetch_untagged_symbols(self, batch_size: int) -> list[dict[str, Any]]:
+        """
+        Return up to *batch_size* public, non-deprecated symbols with no
+        capability key assigned, ordered by symbol_path.
+
+        Covers:
+          - CapabilityTaggerWorker._fetch_untagged_symbols
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    SELECT
+                        id, symbol_path, qualname, file_path,
+                        kind, domain, docstring, is_public, calls
+                    FROM core.symbols
+                    WHERE key IS NULL
+                      AND is_public = true
+                      AND state != 'deprecated'
+                      AND file_path IS NOT NULL
+                      AND file_path != ''
+                    ORDER BY symbol_path
+                    LIMIT :batch_size
+                    """
+                ),
+                {"batch_size": batch_size},
+            )
+            return [dict(row) for row in result.mappings().all()]
+
+    # ID: a47395b5-daea-43f4-94eb-515619cc9678
+    async def apply_symbol_keys(self, assignments: list[dict[str, str]]) -> int:
+        """
+        Batch-update capability keys for a list of symbols in a single
+        transaction. Only updates rows where key IS NULL (idempotent).
+
+        *assignments* is a list of dicts with keys ``id`` (UUID str) and
+        ``key`` (dotted capability key string).
+
+        Returns the number of UPDATE statements issued (not affected rows).
+
+        Covers:
+          - CapabilityTaggerWorker._tag_symbols — UPDATE core.symbols loop
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        if not assignments:
+            return 0
+
+        async with ServiceRegistry.session() as session:
+            async with session.begin():
+                for assignment in assignments:
+                    await session.execute(
+                        text(
+                            """
+                            UPDATE core.symbols
+                            SET key = :key, updated_at = NOW()
+                            WHERE id = cast(:id as uuid)
+                              AND key IS NULL
+                            """
+                        ),
+                        {"key": assignment["key"], "id": assignment["id"]},
+                    )
+        return len(assignments)

body/services/validation/__init__.py

@@ -0,0 +1,14 @@
+# src/body/services/validation/__init__.py
+
+"""
+Validation orchestration services.
+Coordinates validation across Mind (governance), Body (tools), and shared utilities.
+"""
+
+from __future__ import annotations
+
+from body.services.validation.python_validator import validate_python_code_async
+from body.services.validation.validation_policies import PolicyValidator
+
+
+__all__ = ["PolicyValidator", "validate_python_code_async"]

body/services/validation/python_validator.py

@@ -0,0 +1,89 @@
+# src/body/services/validation/python_validator.py
+
+"""
+Python code validation pipeline orchestrator.
+
+CONSTITUTIONAL ALIGNMENT:
+- Aligns with 'body_contracts.json' (Headless, no direct Mind engine dependency).
+- Uses local 'PolicyValidator' for semantic safety checks within the Body layer.
+- Enforces 'dry_by_design' by delegating to shared infrastructure for Black/Ruff/Syntax.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import black
+
+from body.services.validation.validation_policies import PolicyValidator
+from shared.infrastructure.validation.black_formatter import format_code_with_black
+from shared.infrastructure.validation.quality import QualityChecker
+from shared.infrastructure.validation.ruff_linter import fix_and_lint_code_with_ruff
+from shared.infrastructure.validation.syntax_checker import check_syntax
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from mind.governance.audit_context import AuditorContext
+
+logger = getLogger(__name__)
+Violation = dict[str, Any]
+
+
+# ID: 9b262a79-1e30-43fb-a9e2-1141058981d5
+async def validate_python_code_async(
+    path_hint: str, code: str, auditor_context: AuditorContext
+) -> tuple[str, list[Violation]]:
+    """
+    Comprehensive validation pipeline for Python code.
+
+    This Body-layer service coordinates deterministic quality checks.
+    Governance-level auditing is deferred to the Mind-layer Auditor.
+    """
+    all_violations: list[Violation] = []
+
+    # 1. FORMATTING (Standard Tooling)
+    try:
+        formatted_code = format_code_with_black(code)
+    except (black.InvalidInput, Exception) as e:
+        all_violations.append(
+            {
+                "rule": "tooling.black_failure",
+                "message": str(e),
+                "line": 0,
+                "severity": "error",
+            }
+        )
+        return code, all_violations
+
+    # 2. LINTING (Standard Tooling)
+    fixed_code, ruff_violations = fix_and_lint_code_with_ruff(
+        formatted_code, auditor_context.paths.repo_root, path_hint
+    )
+    all_violations.extend(ruff_violations)
+
+    # 3. SYNTAX VALIDATION (Deterministic Body Check)
+    syntax_violations = check_syntax(path_hint, fixed_code)
+    all_violations.extend(syntax_violations)
+
+    # Fail fast on syntax errors before performing more expensive checks
+    if any(v["severity"] == "error" for v in syntax_violations):
+        return fixed_code, all_violations
+
+    # 4. LOCAL POLICY VALIDATION (Policy-Aware Body Check)
+    # Uses the local PolicyValidator which is a permitted Body-layer component.
+    safety_policy = auditor_context.policies.get("safety_policy", {})
+    policy_validator = PolicyValidator(safety_policy.get("rules", []))
+    all_violations.extend(policy_validator.check_semantics(fixed_code, path_hint))
+
+    # 5. QUALITY ATTRIBUTES (DRY / FUTURE detection)
+    quality_checker = QualityChecker()
+    all_violations.extend(quality_checker.check_for_todo_comments(fixed_code))
+
+    logger.debug(
+        "Validation completed for %s: %d violation(s) found.",
+        path_hint,
+        len(all_violations),
+    )
+
+    return fixed_code, all_violations

body/services/validation/validation_policies.py

@@ -0,0 +1,121 @@
+# src/body/services/validation/validation_policies.py
+
+"""
+Policy-aware validation logic for enforcing safety and security policies.
+This module is given pre-loaded policies and scans AST nodes for violations.
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+from shared.utils.glob_match import matches_any_glob
+
+
+Violation = dict[str, Any]
+
+
+# ID: dcff1afd-963d-419c-8f66-31978115cfc9
+class PolicyValidator:
+    """Handles policy-aware validation including safety checks and forbidden patterns."""
+
+    def __init__(self, safety_policy_rules: list[dict[str, Any]]):
+        """
+        Initialize the policy validator with pre-loaded safety policy rules.
+        """
+        self.safety_rules = safety_policy_rules
+
+    def _get_full_attribute_name(self, node: ast.Attribute) -> str:
+        """Recursively builds the full name of an attribute call."""
+        parts: list[str] = []  # FIXED
+        current: Any = node  # FIXED: Type set to Any to allow re-assignment
+        while isinstance(current, ast.Attribute):
+            parts.insert(0, current.attr)
+            current = current.value
+        if isinstance(current, ast.Name):
+            parts.insert(0, current.id)
+        return ".".join(parts)
+
+    def _find_dangerous_patterns(
+        self, tree: ast.AST, file_path: str
+    ) -> list[Violation]:
+        """Scans the AST for calls and imports forbidden by safety policies."""
+        violations: list[Violation] = []
+        rules = self.safety_rules
+
+        forbidden_calls = set()
+        forbidden_imports = set()
+
+        for rule in rules:
+            exclude_patterns = [
+                p
+                for p in rule.get("scope", {}).get("exclude", [])
+                if isinstance(p, str)
+            ]
+            is_excluded = matches_any_glob(file_path, exclude_patterns)
+
+            if is_excluded:
+                continue
+
+            if rule.get("id") == "no_dangerous_execution":
+                patterns = {
+                    p.replace("(", "")
+                    for p in rule.get("detection", {}).get("patterns", [])
+                }
+                forbidden_calls.update(patterns)
+            elif rule.get("id") == "no_unsafe_imports":
+                patterns = {
+                    imp.split(" ")[-1]
+                    for imp in rule.get("detection", {}).get("forbidden", [])
+                }
+                forbidden_imports.update(patterns)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                full_call_name = ""
+                if isinstance(node.func, ast.Name):
+                    full_call_name = node.func.id
+                elif isinstance(node.func, ast.Attribute):
+                    full_call_name = self._get_full_attribute_name(node.func)
+
+                if full_call_name in forbidden_calls:
+                    violations.append(
+                        {
+                            "rule": "safety.dangerous_call",
+                            "message": f"Use of forbidden call: '{full_call_name}'",
+                            "line": getattr(node, "lineno", 0),
+                            "severity": "error",
+                        }
+                    )
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    if alias.name.split(".")[0] in forbidden_imports:
+                        violations.append(
+                            {
+                                "rule": "safety.forbidden_import",
+                                "message": f"Import of forbidden module: '{alias.name}'",
+                                "line": getattr(node, "lineno", 0),
+                                "severity": "error",
+                            }
+                        )
+            elif isinstance(node, ast.ImportFrom):
+                if node.module and node.module.split(".")[0] in forbidden_imports:
+                    violations.append(
+                        {
+                            "rule": "safety.forbidden_import",
+                            "message": f"Import from forbidden module: '{node.module}'",
+                            "line": getattr(node, "lineno", 0),
+                            "severity": "error",
+                        }
+                    )
+        return violations
+
+    # ID: d6059c1e-83ab-4c9a-8ebf-e596fa79494d
+    def check_semantics(self, code: str, file_path: str) -> list[Violation]:
+        """Runs all policy-aware semantic checks on a string of Python code."""
+        try:
+            tree = ast.parse(code)
+        except SyntaxError:
+            return []
+        return self._find_dangerous_patterns(tree, file_path)