core-runtime 0.1.1__py3-none-any.whl

body/services/crawl_service/symbol_processing.py

@@ -0,0 +1,279 @@
+# src/body/services/crawl_service/symbol_processing.py
+# symbol_processing.py
+"""handles symbol extraction and layer detection"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import uuid
+from pathlib import Path
+from typing import Any
+
+
+_LAYER_MAP: dict[str, str] = {
+    "src/mind": "mind",
+    "src/body": "body",
+    "src/will": "will",
+    "src/shared": "shared",
+}
+
+
+class _CallGraphExtractor(ast.NodeVisitor):
+    """
+    Extracts directed call graph edges from a Python AST.
+    Produces edge dicts ready for insertion into core.symbol_calls.
+
+    symbol_path format matches DB: src/path/to/file.py::ClassName.method_name
+
+    Resolution cascade (applied in order until a match is found):
+      1. Direct key match against symbol_index
+      2. Qualname match: symbol_index key suffix after '::'
+      3. self./cls. stripping + current-class qualification
+      4. Module dotted path → file path conversion
+         (e.g. 'will.workers.foo.Bar' → 'src/will/workers/foo.py::Bar')
+      5. Short name unique match (only when exactly one symbol has that short name)
+    """
+
+    def __init__(
+        self,
+        rel_path: str,
+        layer: str,
+        symbol_index: dict[str, str],
+        crawl_run_id: uuid.UUID,
+    ) -> None:
+        self._rel_path = rel_path
+        self._layer = layer
+        self._symbol_index = symbol_index
+        self._crawl_run_id = str(crawl_run_id)
+        self._edges: list[dict[str, Any]] = []
+        self._current_caller_id: str | None = None
+        self._current_class: str | None = None
+
+        self._qualname_index: dict[str, str] = {}
+        _shortname_bucket: dict[str, list[str]] = {}
+
+        for symbol_path, symbol_id in symbol_index.items():
+            if "::" not in symbol_path:
+                continue
+            qualname = symbol_path.split("::", 1)[1]
+            self._qualname_index[qualname] = symbol_id
+            short = qualname.split(".")[-1]
+            _shortname_bucket.setdefault(short, []).append(symbol_id)
+
+        self._shortname_index: dict[str, str] = {
+            k: v[0] for k, v in _shortname_bucket.items() if len(v) == 1
+        }
+
+    # ID: 6b2f1fc9-9666-44db-a3e1-407dc81e2a39
+    def extract(self, tree: ast.AST) -> list[dict[str, Any]]:
+        self.visit(tree)
+        return self._edges
+
+    # ID: 02eaa803-3c00-4aa3-b2e5-dbaced1a91a2
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        if self._current_class:
+            qualname = f"{self._current_class}.{node.name}"
+        else:
+            qualname = node.name
+        symbol_path = f"{self._rel_path}::{qualname}"
+        self._current_caller_id = self._symbol_index.get(symbol_path)
+        self.generic_visit(node)
+        self._current_caller_id = None
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    # ID: 216190a2-ca25-4659-9cac-7659d3fefef4
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        prev_class = self._current_class
+        self._current_class = node.name
+        symbol_path = f"{self._rel_path}::{node.name}"
+        caller_id = self._symbol_index.get(symbol_path)
+        for base in node.bases:
+            callee_raw = ast.unparse(base)
+            self._add_edge(
+                callee_raw=callee_raw,
+                edge_kind="inheritance",
+                line_number=node.lineno,
+                caller_id=caller_id,
+            )
+        self.generic_visit(node)
+        self._current_class = prev_class
+
+    # ID: 09f061e2-059f-4fce-8232-1c10ff4df527
+    def visit_Call(self, node: ast.Call) -> None:
+        if self._current_caller_id is None:
+            self.generic_visit(node)
+            return
+        callee_raw = ast.unparse(node.func)
+        self._add_edge(
+            callee_raw=callee_raw,
+            edge_kind="direct_call",
+            line_number=node.lineno,
+        )
+        self.generic_visit(node)
+
+    # ID: b15b99d6-420f-49b9-8cbf-c5a83f8f6700
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            self._add_edge(
+                callee_raw=alias.name,
+                edge_kind="import",
+                line_number=node.lineno,
+            )
+
+    # ID: 855c7b0d-8fe4-4fd5-a7f9-c694ff9adce3
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        module = node.module or ""
+        for alias in node.names:
+            callee_raw = f"{module}.{alias.name}" if module else alias.name
+            self._add_edge(
+                callee_raw=callee_raw,
+                edge_kind="import",
+                line_number=node.lineno,
+            )
+
+    def _resolve_callee_id(self, callee_raw: str) -> str | None:
+        """Multi-strategy callee resolution cascade."""
+        hit = self._symbol_index.get(callee_raw)
+        if hit:
+            return hit
+
+        hit = self._qualname_index.get(callee_raw)
+        if hit:
+            return hit
+
+        if self._current_class and callee_raw.startswith(("self.", "cls.")):
+            stripped = callee_raw.split(".", 1)[1]
+            qualified = f"{self._current_class}.{stripped}"
+            hit = self._qualname_index.get(qualified)
+            if hit:
+                return hit
+            hit = self._qualname_index.get(stripped)
+            if hit:
+                return hit
+
+        if "." in callee_raw:
+            parts = callee_raw.split(".")
+            for split in range(len(parts) - 1, 0, -1):
+                module_path = "src/" + "/".join(parts[:split]) + ".py"
+                qualname = ".".join(parts[split:])
+                candidate = f"{module_path}::{qualname}"
+                hit = self._symbol_index.get(candidate)
+                if hit:
+                    return hit
+                candidate_no_src = "/".join(parts[:split]) + ".py::" + qualname
+                hit = self._symbol_index.get(candidate_no_src)
+                if hit:
+                    return hit
+
+        short = callee_raw.split(".")[-1]
+        hit = self._shortname_index.get(short)
+        if hit:
+            return hit
+
+        return None
+
+    def _add_edge(
+        self,
+        callee_raw: str,
+        edge_kind: str,
+        line_number: int | None,
+        caller_id: str | None = None,
+    ) -> None:
+        resolved_caller_id = caller_id or self._current_caller_id
+        if resolved_caller_id is None:
+            return
+
+        callee_id = self._resolve_callee_id(callee_raw)
+        caller_layer = self._layer
+        callee_layer = _detect_layer_from_symbol(callee_raw)
+        is_cross_layer = (
+            caller_layer != callee_layer
+            and callee_layer != "unknown"
+            and caller_layer != "unknown"
+        )
+        is_external = not callee_raw.startswith(
+            ("src.", "will.", "body.", "mind.", "shared.")
+        )
+
+        self._edges.append(
+            {
+                "caller_id": resolved_caller_id,
+                "callee_id": callee_id,
+                "callee_raw": callee_raw[:500],
+                "edge_kind": edge_kind,
+                "file_path": self._rel_path,
+                "line_number": line_number,
+                "is_cross_layer": is_cross_layer,
+                "is_external": is_external,
+                "crawl_run_id": self._crawl_run_id,
+            }
+        )
+
+
+def _detect_layer(rel_path: str) -> str:
+    """Detect architectural layer from repo-relative file path."""
+    for prefix, layer in _LAYER_MAP.items():
+        if rel_path.startswith(prefix):
+            return layer
+    return "unknown"
+
+
+def _detect_layer_from_symbol(symbol: str) -> str:
+    """Detect layer from a dotted symbol/module name."""
+    for prefix, layer in {
+        "mind.": "mind",
+        "body.": "body",
+        "will.": "will",
+        "shared.": "shared",
+    }.items():
+        if symbol.startswith(prefix):
+            return layer
+    return "unknown"
+
+
+def _find_symbol_references(
+    content: str,
+    symbol_index: dict[str, str],
+    rel_path: str,
+    artifact_type: str,
+) -> list[dict[str, Any]]:
+    """
+    Scan file text for mentions of known symbol qualnames.
+    Returns link dicts ready for core.artifact_symbol_links insertion.
+    """
+    link_kind_map = {
+        "doc": "documents",
+        "test": "tests",
+        "intent": "governs",
+        "infra": "configures",
+        "prompt": "references",
+        "report": "references",
+    }
+    link_kind = link_kind_map.get(artifact_type, "references")
+    links: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    for symbol_path, symbol_id in symbol_index.items():
+        qualname = symbol_path.split(":")[-1] if ":" in symbol_path else symbol_path
+        if len(qualname) < 4:
+            continue
+        if qualname in content and symbol_id not in seen:
+            seen.add(symbol_id)
+            links.append(
+                {
+                    "symbol_id": symbol_id,
+                    "link_kind": link_kind,
+                    "confidence": 0.8,
+                    "source": "name_match",
+                }
+            )
+    return links
+
+
+def _sha256(path: Path) -> str:
+    """Compute SHA256 hex digest of a file."""
+    h = hashlib.sha256()
+    h.update(path.read_bytes())
+    return h.hexdigest()

body/services/database_service.py

@@ -0,0 +1,242 @@
+# src/body/services/database_service.py
+"""
+Database Service - Body Layer
+
+CONSTITUTIONAL FIX: Infrastructure wrapper for database access
+
+This service provides database operations for Will layer.
+Will layer must NEVER import get_session or AsyncSession directly.
+All database access goes through this Body service.
+
+Constitutional Compliance:
+- Body layer: Wraps infrastructure primitives
+- Provides high-level operations for Will
+- Manages session lifecycle internally
+- Will receives this service, never creates sessions
+
+Architecture:
+- Mind: Defines what data exists (.intent/ schemas)
+- Body: Executes database operations (this file)
+- Will: Orchestrates using Body services (never touches infrastructure)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import select
+
+from shared.infrastructure.database.models import CognitiveRole, LlmResource
+from shared.infrastructure.database.session_manager import get_session
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 78cbd4a9-32a2-49cd-84dd-4f401daa8df3
+class DatabaseService:
+    """
+    Body layer service for database operations.
+
+    CONSTITUTIONAL ROLE:
+    - Body layer: Infrastructure wrapper
+    - Provides database operations without exposing sessions
+    - Will layer uses this service, never imports get_session
+    - Manages session lifecycle internally
+
+    This service encapsulates all database infrastructure.
+    Will layer receives instances of this service and calls methods.
+    """
+
+    def __init__(self):
+        """
+        Initialize database service.
+
+        Note: Does NOT take a session in constructor.
+        Sessions are created per-operation to avoid lifecycle issues.
+        """
+        logger.debug("DatabaseService initialized")
+
+    # ID: 872b8a2c-50ff-493a-b6ba-be62215f4c63
+    async def query_roles(self) -> list[CognitiveRole]:
+        """
+        Query all cognitive roles from database.
+
+        Body layer execution:
+        - Creates session internally
+        - Executes query
+        - Closes session
+        - Returns results to Will
+
+        Returns:
+            List of CognitiveRole objects
+        """
+        async with get_session() as session:
+            result = await session.execute(select(CognitiveRole))
+            roles = result.scalars().all()
+            logger.debug("Queried %d cognitive roles", len(roles))
+            return list(roles)
+
+    # ID: 8b644d68-426f-4bfa-a866-5bdbbe8ee7fe
+    async def query_resources(self) -> list[LlmResource]:
+        """
+        Query all LLM resources from database.
+
+        Body layer execution:
+        - Creates session internally
+        - Executes query
+        - Closes session
+        - Returns results to Will
+
+        Returns:
+            List of LlmResource objects
+        """
+        async with get_session() as session:
+            result = await session.execute(select(LlmResource))
+            resources = result.scalars().all()
+            logger.debug("Queried %d LLM resources", len(resources))
+            return list(resources)
+
+    # ID: 1e312dd0-ddf2-482f-95db-959654191557
+    async def query_role_by_id(self, role_id: UUID) -> CognitiveRole | None:
+        """
+        Query a specific cognitive role by ID.
+
+        Body layer execution:
+        - Creates session internally
+        - Executes query
+        - Closes session
+        - Returns result to Will
+
+        Args:
+            role_id: UUID of the role to query
+
+        Returns:
+            CognitiveRole if found, None otherwise
+        """
+        async with get_session() as session:
+            result = await session.execute(
+                select(CognitiveRole).where(CognitiveRole.id == role_id)
+            )
+            role = result.scalar_one_or_none()
+
+            if role:
+                # FIX: CognitiveRole.role is the attribute name, not role_name
+                logger.debug("Found role: %s", role.role)
+            else:
+                logger.debug("Role not found: %s", role_id)
+
+            return role
+
+    # ID: 69abb440-9af8-4107-bcee-264cec877251
+    async def query_resource_by_id(self, resource_id: UUID) -> LlmResource | None:
+        """
+        Query a specific LLM resource by ID.
+
+        Body layer execution:
+        - Creates session internally
+        - Executes query
+        - Closes session
+        - Returns result to Will
+
+        Args:
+            resource_id: UUID of the resource to query
+
+        Returns:
+            LlmResource if found, None otherwise
+        """
+        async with get_session() as session:
+            result = await session.execute(
+                select(LlmResource).where(LlmResource.id == resource_id)
+            )
+            resource = result.scalar_one_or_none()
+
+            if resource:
+                # FIX: LlmResource.name is the attribute name, not resource_name
+                logger.debug("Found resource: %s", resource.name)
+            else:
+                logger.debug("Resource not found: %s", resource_id)
+
+            return resource
+
+    # ID: f6a7b8c9-d0e1-2f3a-4b5c-6d7e8f9a0b1c
+    async def execute_query(
+        self, query: str, params: dict[str, Any] | None = None
+    ) -> list[dict[str, Any]]:
+        """
+        Execute a raw SQL query with parameters.
+
+        Body layer execution:
+        - Creates session internally
+        - Executes parameterized query
+        - Closes session
+        - Returns results to Will
+
+        Args:
+            query: SQL query string
+            params: Optional parameters for the query
+
+        Returns:
+            List of result dictionaries
+
+        Warning:
+            Use this sparingly. Prefer typed methods above.
+        """
+        from sqlalchemy import text
+
+        async with get_session() as session:
+            stmt = text(query)
+            result = await session.execute(stmt, params or {})
+            rows = [dict(row._mapping) for row in result]
+            logger.debug("Executed raw query, returned %d rows", len(rows))
+            return rows
+
+    # ID: a7b8c9d0-e1f2-3a4b-5c6d-7e8f9a0b1c2d
+    async def with_session(self, operation):
+        """
+        Execute an operation with a managed session.
+
+        Body layer execution:
+        - Creates session
+        - Passes to operation callback
+        - Ensures session is closed
+        - Returns operation result
+
+        This is for complex operations that need session control.
+
+        Args:
+            operation: Async callable that takes (session) and returns result
+
+        Returns:
+            Result from operation
+
+        Example:
+            # ID: 61799ec8-5cf5-442e-825b-c65e57220137
+            async def complex_query(session):
+                # Do complex multi-step operation
+                return result
+
+            result = await db_service.with_session(complex_query)
+        """
+        async with get_session() as session:
+            return await operation(session)
+
+
+# ID: 0cf303d2-3131-4d15-9b42-83d3de3c3579
+def get_database_service() -> DatabaseService:
+    """
+    Factory function for database service.
+
+    Returns:
+        DatabaseService instance
+
+    Usage:
+        # Body layer: Create service
+        db_service = get_database_service()
+
+        # Will layer: Use service
+        roles = await db_service.query_roles()
+    """
+    return DatabaseService()

body/services/doc_service.py

@@ -0,0 +1,57 @@
+# src/body/services/doc_service.py
+"""
+DocService - Data-access layer for core.symbols (documentation).
+
+Covers:
+  - DocWorker._fetch_undocumented_symbols
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 775dc52c-2cbf-4a87-929e-ea677f872685
+class DocService:
+    """
+    Body layer service. Exposes named methods for core.symbols
+    queries used by DocWorker.
+    """
+
+    # ID: d68e8d4c-7382-4530-a715-3aa852b9eac8
+    async def fetch_undocumented_symbols(self) -> list[dict[str, Any]]:
+        """
+        Return public symbols with missing or empty intent,
+        ordered by module and qualname.
+
+        Covers:
+          - DocWorker._fetch_undocumented_symbols
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    select
+                        symbol_path,
+                        module,
+                        qualname,
+                        kind,
+                        file_path
+                    from core.symbols
+                    where
+                        is_public = true
+                        and (intent is null or trim(intent) = '')
+                    order by module, qualname
+                    """
+                )
+            )
+            return [dict(row._mapping) for row in result]