core-runtime 0.1.1__py3-none-any.whl

body/analyzers/prompt_analyzer.py

@@ -0,0 +1,155 @@
+# src/body/analyzers/prompt_analyzer.py
+
+"""
+Prompt Analyzer - PARSE Phase Component.
+Analyzes templates and context to ensure generation tasks are "Ready to Build."
+
+Constitutional Alignment:
+- Phase: PARSE (Template validation and analysis)
+- Authority: CODE (Implementation)
+- Boundary: Requires prompt_root via dependency injection (no settings access)
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any
+
+from body.analyzers.base_analyzer import BaseAnalyzer
+from shared.component_primitive import ComponentResult  # Component, ComponentPhase,
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: ebe63608-68fb-4f79-9151-c3e940d2d8f2
+class PromptAnalyzer(BaseAnalyzer):
+    """
+    Validates that a generation task has all required variables.
+
+    Responsibilities:
+    - Load templates from prompt directory via provided path.
+    - Identify required placeholders in the template.
+    - Verify that the provided context satisfies those placeholders.
+    - Calculate a 'Readiness Score' for the generation task.
+
+    Constitutional Requirement:
+    - MUST receive prompt_root parameter (no settings access)
+    - Body layer components do not access settings directly
+    """
+
+    # ID: 631eec7b-c23d-4d25-8f9f-a191e0239ce9
+    async def execute(
+        self,
+        template_name: str,
+        context_data: dict[str, Any],
+        prompt_root: Path | None = None,
+        **kwargs: Any,
+    ) -> ComponentResult:
+        """
+        Analyze prompt readiness.
+
+        Args:
+            template_name: Stem of the prompt file (e.g., 'fix_line_length')
+            context_data: Dictionary of variables provided for the prompt.
+            prompt_root: Path to prompts directory (required for constitutional compliance)
+
+        Constitutional Compliance:
+        - Requires prompt_root parameter (no settings access)
+        - Returns error if prompt_root not provided (fail fast, dependency injection enforced)
+        """
+        start_time = time.time()
+
+        # Constitutional boundary enforcement: Body requires proper parameters
+        if prompt_root is None:
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={
+                    "error": "PromptAnalyzer requires prompt_root parameter. "
+                    "Body layer components must not access settings directly."
+                },
+                phase=self.phase,
+                confidence=0.0,
+            )
+
+        try:
+            # 1. Load Template via provided prompt_root
+            prompt_path = prompt_root / f"{template_name}.txt"
+            if not prompt_path.exists():
+                return ComponentResult(
+                    component_id=self.component_id,
+                    ok=False,
+                    data={
+                        "error": f"Template not found: {template_name} at {prompt_path}"
+                    },
+                    phase=self.phase,
+                    confidence=0.0,
+                )
+
+            template_text = prompt_path.read_text(encoding="utf-8")
+
+            # 2. Identify placeholders (e.g., {source_code}, {goal})
+            placeholders = set(re.findall(r"\{(\w+)\}", template_text))
+
+            # 3. Cross-reference with provided context
+            provided_keys = set(context_data.keys())
+            missing_keys = placeholders - provided_keys
+
+            # 4. Calculate Readiness
+            # Confidence is 1.0 if all keys present, lower if missing keys.
+            confidence = (
+                1.0
+                if not missing_keys
+                else (
+                    max(0.0, 1.0 - (len(missing_keys) / len(placeholders)))
+                    if placeholders
+                    else 1.0
+                )
+            )
+
+            # 5. Assemble final prompt (if possible)
+            # We still produce the string, but now it's an "Analyzed Result"
+            final_prompt = None
+            if confidence > 0.5:
+                # Fill missing keys with warnings so LLM knows context is thin
+                safe_context = {**context_data}
+                for key in missing_keys:
+                    safe_context[key] = (
+                        f"[WARNING: Context for '{key}' was not found by Analyzer]"
+                    )
+
+                final_prompt = template_text.format(**safe_context)
+
+            duration = time.time() - start_time
+
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=confidence > 0.8,  # Fail if too much context is missing
+                data={
+                    "final_prompt": final_prompt,
+                    "template_used": str(prompt_path),
+                    "required_keys": list(placeholders),
+                    "missing_keys": list(missing_keys),
+                },
+                phase=self.phase,
+                confidence=confidence,
+                metadata={
+                    "readiness": "READY" if not missing_keys else "THIN",
+                    "template_name": template_name,
+                },
+                duration_sec=duration,
+            )
+
+        except Exception as e:
+            logger.error("PromptAnalyzer failed: %s", e)
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={"error": str(e)},
+                phase=self.phase,
+                confidence=0.0,
+            )

body/analyzers/symbol_extractor.py

@@ -0,0 +1,280 @@
+# src/body/analyzers/symbol_extractor.py
+"""Symbol Extractor - Extracts testable symbols from Python files.
+
+Constitutional Alignment:
+- Phase: PARSE (Structural metadata extraction)
+- Authority: CODE (Implementation of structural analysis)
+- SSOT: Aligns symbol keys with core.symbols DB schema (filepath::qualname)
+- Boundary: Requires CoreContext with git_service (no settings fallback)
+
+Purified (V2.3.0)
+- Removed Will-layer DecisionTracer to satisfy architecture.layers.no_body_to_will.
+  Rationale is now returned in metadata.
+"""
+
+from __future__ import annotations
+
+import ast
+import time
+from dataclasses import dataclass
+
+from body.analyzers.base_analyzer import BaseAnalyzer
+from shared.component_primitive import ComponentResult  # Component, ComponentPhase,
+from shared.context import CoreContext
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+_CFG_AZ = load_operational_config().analyzers
+
+
+@dataclass
+# ID: 5d698d5b-f58e-4a4c-8ec4-5e6bf133888e
+class SymbolMetadata:
+    """Structured metadata for a testable symbol.
+
+    Aligned with the Knowledge Graph (SSOT) schema.
+    """
+
+    name: str
+    qualname: str
+    symbol_path: str  # Format: path/to/file.py::QualName
+    type: str  # 'function', 'async_function', 'class'
+    line_number: int
+    docstring: str | None
+    is_public: bool
+    complexity: str  # 'low', 'medium', 'high'
+    parameters: list[str]
+    decorators: list[str]
+
+
+# ID: 2bd8827b-1c5a-44c2-9fc8-78daa71b05b9
+class SymbolExtractor(BaseAnalyzer):
+    """Extracts testable symbols (functions and classes) from Python files.
+
+    Constitutional filters:
+    - Skips private symbols (starting with _)
+    - Skips explicit test files (test_*.py, *_test.py)
+
+    Constitutional requirements:
+    - MUST be initialized with CoreContext containing valid git_service.
+    - Body layer components do not access settings directly.
+    """
+
+    def __init__(self, context: CoreContext | None = None):
+        """Initialize with context for governed path resolution."""
+        self.context = context
+
+    # ID: a98b1814-002c-4deb-aeb9-dadc7039ac60
+    async def execute(
+        self,
+        file_path: str,
+        include_private: bool = False,
+        **kwargs,
+    ) -> ComponentResult:
+        """Analyze a file and extract symbol metadata.
+
+        Constitutional compliance:
+        - Requires valid CoreContext with git_service (no settings fallback)
+        - Returns error if context not provided (fail fast, DI enforced)
+        """
+        start_time = time.time()
+
+        # Constitutional boundary enforcement: Body requires proper context
+        if not self.context or not getattr(self.context, "git_service", None):
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={
+                    "error": (
+                        "SymbolExtractor requires CoreContext with git_service. "
+                        "Body layer components must not access settings directly."
+                    )
+                },
+                phase=self.phase,
+                confidence=0.0,
+            )
+
+        repo_root = self.context.git_service.repo_path
+        abs_path = (repo_root / file_path).resolve()
+
+        if not abs_path.exists():
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={"error": f"File not found: {file_path}"},
+                phase=self.phase,
+                confidence=0.0,
+            )
+
+        # Constitutional Guard: Identify if this is already a test file
+        if abs_path.name.startswith("test_") or abs_path.name.endswith("_test.py"):
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=True,
+                data={"symbols": [], "skipped": True, "reason": "is_test_file"},
+                phase=self.phase,
+                confidence=1.0,
+            )
+
+        try:
+            source_code = abs_path.read_text(encoding="utf-8")
+            tree = ast.parse(source_code)
+
+            extracted_symbols = self._extract_symbols(tree, file_path, include_private)
+
+            public_count = sum(1 for s in extracted_symbols if s.is_public)
+            class_count = sum(1 for s in extracted_symbols if s.type == "class")
+
+            duration = time.time() - start_time
+
+            # CONSTITUTIONAL NOTE: Instead of calling tracer directly, we return
+            # the rationale in metadata for the Will layer to record.
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=True,
+                data={
+                    "symbols": [s.__dict__ for s in extracted_symbols],
+                    "total_count": len(extracted_symbols),
+                    "public_count": public_count,
+                    "class_count": class_count,
+                    "function_count": len(extracted_symbols) - class_count,
+                },
+                phase=self.phase,
+                confidence=1.0,
+                next_suggested="test_strategist",
+                duration_sec=duration,
+                metadata={
+                    "file_path": file_path,
+                    "rationale": (
+                        f"Discovered {len(extracted_symbols)} structural symbols in {file_path}"
+                    ),
+                    "extraction_context": {
+                        "file": file_path,
+                        "total_found": len(extracted_symbols),
+                        "public_api_count": public_count,
+                    },
+                },
+            )
+
+        except SyntaxError as e:
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={"error": f"Syntax error in {file_path}: {e}"},
+                phase=self.phase,
+                confidence=0.0,
+            )
+        except Exception as e:
+            logger.error("SymbolExtractor failure: %s", e, exc_info=True)
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                data={"error": str(e)},
+                phase=self.phase,
+                confidence=0.0,
+            )
+
+    def _extract_symbols(
+        self,
+        tree: ast.AST,
+        rel_path: str,
+        include_private: bool,
+    ) -> list[SymbolMetadata]:
+        symbols: list[SymbolMetadata] = []
+
+        # Walk only top-level to avoid internal closures/nested funcs unless classes
+        for node in tree.body:
+            if isinstance(node, ast.ClassDef):
+                meta = self._build_class_meta(node, rel_path)
+                if include_private or meta.is_public:
+                    symbols.append(meta)
+
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                meta = self._build_function_meta(node, rel_path)
+                if include_private or meta.is_public:
+                    symbols.append(meta)
+
+        return symbols
+
+    def _build_class_meta(self, node: ast.ClassDef, rel_path: str) -> SymbolMetadata:
+        is_public = not node.name.startswith("_")
+        doc = ast.get_docstring(node)
+
+        symbol_path = f"{rel_path}::{node.name}"
+
+        methods = [
+            n
+            for n in node.body
+            if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+        ]
+        complexity = (
+            "high"
+            if len(methods) > _CFG_AZ.class_methods_high_threshold
+            else "medium"
+            if len(methods) > 3
+            else "low"
+        )
+
+        return SymbolMetadata(
+            name=node.name,
+            qualname=node.name,
+            symbol_path=symbol_path,
+            type="class",
+            line_number=node.lineno,
+            docstring=doc,
+            is_public=is_public,
+            complexity=complexity,
+            parameters=[],
+            decorators=[self._get_dec_name(d) for d in node.decorator_list],
+        )
+
+    def _build_function_meta(
+        self,
+        node: ast.FunctionDef | ast.AsyncFunctionDef,
+        rel_path: str,
+    ) -> SymbolMetadata:
+        is_public = not node.name.startswith("_")
+        doc = ast.get_docstring(node)
+
+        symbol_path = f"{rel_path}::{node.name}"
+
+        body_len = len(node.body)
+        complexity = (
+            "high"
+            if body_len > _CFG_AZ.function_body_high_threshold
+            else "medium"
+            if body_len > _CFG_AZ.function_body_low_threshold
+            else "low"
+        )
+
+        func_type = (
+            "async_function" if isinstance(node, ast.AsyncFunctionDef) else "function"
+        )
+
+        return SymbolMetadata(
+            name=node.name,
+            qualname=node.name,
+            symbol_path=symbol_path,
+            type=func_type,
+            line_number=node.lineno,
+            docstring=doc,
+            is_public=is_public,
+            complexity=complexity,
+            parameters=[a.arg for a in node.args.args],
+            decorators=[self._get_dec_name(d) for d in node.decorator_list],
+        )
+
+    def _get_dec_name(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            return node.attr
+        if isinstance(node, ast.Call):
+            return self._get_dec_name(node.func)
+        return "unknown_decorator"
+
+
+SymbolInfo = SymbolMetadata

body/atomic/__init__.py

@@ -0,0 +1,74 @@
+# src/body/atomic/__init__.py
+"""
+Atomic Actions - Constitutional Action System
+"""
+
+from __future__ import annotations
+
+# Side-effect import: registers fix.body_ui in the action registry.
+# Implementation lives in body.self_healing (LLM-driven fixer) but the
+# registration call must execute at body.atomic.* import time so the
+# registry sees the action when fix_routes validates fix_ids.
+import body.self_healing.body_ui_fixer
+
+# Import modules to trigger registration
+from body.atomic import (
+    build_tests_action,
+    check_actions,
+    crate_ops,
+    file_ops,
+    fix_actions,
+    metadata_ops,
+    modularity_fix,
+    proposal_lifecycle_actions,
+    remediate_cognitive_role,
+    sync_actions,
+    test_actions,
+)
+from body.atomic.build_tests_action import action_build_tests
+from body.atomic.check_actions import action_check_imports
+from body.atomic.crate_ops import action_create_crate
+from body.atomic.file_ops import (
+    action_create_file,
+    action_edit_file,
+    action_read_file,
+)
+from body.atomic.fix_actions import (
+    action_fix_headers,
+    action_fix_ids,
+    action_fix_logging,
+)
+
+# Re-export action functions
+from body.atomic.fix_actions import (
+    action_format_code as action_fix_format,
+)
+from body.atomic.metadata_ops import action_tag_metadata
+from body.atomic.modularity_fix import action_fix_modularity
+from body.atomic.registry import action_registry, register_action
+from body.atomic.sync_actions import (
+    action_sync_code_vectors,
+    action_sync_constitutional_vectors,
+    action_sync_database,
+)
+
+
+__all__ = [
+    "action_build_tests",
+    "action_check_imports",
+    "action_create_crate",
+    "action_create_file",
+    "action_edit_file",
+    "action_fix_format",
+    "action_fix_headers",
+    "action_fix_ids",
+    "action_fix_logging",
+    "action_fix_modularity",
+    "action_read_file",
+    "action_registry",
+    "action_sync_code_vectors",
+    "action_sync_constitutional_vectors",
+    "action_sync_database",
+    "action_tag_metadata",
+    "register_action",
+]