fable-engine 1.3.1__py3-none-any.whl

fable_v2/coder_fleet/diagnostics.py

@@ -0,0 +1,293 @@
+"""Diagnostics Engine for AST-based Static Analysis and Automated Quick-Fixes.
+
+Pure-Python implementation with zero external C-dependencies.
+"""
+from __future__ import annotations
+
+import ast
+import builtins
+import re
+from typing import Any
+
+# Standard known library symbols for automated quick-fixes
+KNOWN_IMPORTS: dict[str, str] = {
+    "os": "import os",
+    "sys": "import sys",
+    "re": "import re",
+    "json": "import json",
+    "math": "import math",
+    "time": "import time",
+    "datetime": "import datetime",
+    "Path": "from pathlib import Path",
+    "List": "from typing import List",
+    "Dict": "from typing import Dict",
+    "Set": "from typing import Set",
+    "Tuple": "from typing import Tuple",
+    "Optional": "from typing import Optional",
+    "Union": "from typing import Union",
+    "Any": "from typing import Any",
+    "Callable": "from typing import Callable",
+    "Iterable": "from typing import Iterable",
+    "Mapping": "from typing import Mapping",
+    "Sequence": "from typing import Sequence",
+    "defaultdict": "from collections import defaultdict",
+    "Counter": "from collections import Counter",
+    "deque": "from collections import deque",
+    "uuid": "import uuid",
+    "hashlib": "import hashlib",
+    "subprocess": "import subprocess",
+}
+
+
+class DiagnosticsEngine:
+    """Engine for syntax validation, AST semantic diagnostics, and automated quick fixes."""
+
+    def __init__(self) -> None:
+        self._builtins: set[str] = set(dir(builtins)) | {
+            "__name__",
+            "__doc__",
+            "__file__",
+            "__package__",
+            "__annotations__",
+            "__builtins__",
+            "__spec__",
+            "__loader__",
+            "self",
+            "cls",
+        }
+
+    def run_diagnostics(self, source_code: str, language: str = "python") -> list[dict[str, Any]]:
+        """Run AST-based syntax and semantic checks.
+
+        Returns list of {line, col, code, message, severity, symbol}.
+        """
+        if language.lower() != "python":
+            return [
+                {
+                    "line": 1,
+                    "col": 0,
+                    "code": "UNSUPPORTED_LANGUAGE",
+                    "message": f"Language '{language}' diagnostics not supported (Python only)",
+                    "severity": "warning",
+                }
+            ]
+
+        diagnostics: list[dict[str, Any]] = []
+
+        try:
+            tree = ast.parse(source_code)
+        except SyntaxError as exc:
+            return [
+                {
+                    "line": exc.lineno or 1,
+                    "col": exc.offset or 0,
+                    "code": "E999",
+                    "message": f"SyntaxError: {exc.msg}",
+                    "severity": "error",
+                    "symbol": None,
+                }
+            ]
+
+        # 1. Collect imports, defined symbols, loaded symbols, and special nodes
+        imported_symbols: dict[str, tuple[int, int, ast.AST, str]] = {}  # name -> (line, col, node, import_stmt)
+        defined_symbols: set[str] = set(self._builtins)
+        loaded_symbols: list[tuple[str, int, int]] = []
+
+        class ScopeCollector(ast.NodeVisitor):
+            def __init__(self) -> None:
+                self.bare_excepts: list[tuple[int, int]] = []
+                self.duplicate_keys: list[tuple[int, int, str]] = []
+
+            def visit_Import(self, node: ast.Import) -> None:
+                for alias in node.names:
+                    name = alias.asname or alias.name.split(".")[0]
+                    imported_symbols[name] = (node.lineno, node.col_offset, node, "import")
+                    defined_symbols.add(name)
+                self.generic_visit(node)
+
+            def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+                for alias in node.names:
+                    name = alias.asname or alias.name
+                    imported_symbols[name] = (node.lineno, node.col_offset, node, "from")
+                    defined_symbols.add(name)
+                self.generic_visit(node)
+
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+                defined_symbols.add(node.name)
+                for arg in node.args.args + node.args.kwonlyargs:
+                    defined_symbols.add(arg.arg)
+                if node.args.vararg:
+                    defined_symbols.add(node.args.vararg.arg)
+                if node.args.kwarg:
+                    defined_symbols.add(node.args.kwarg.arg)
+                self.generic_visit(node)
+
+            def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+                defined_symbols.add(node.name)
+                for arg in node.args.args + node.args.kwonlyargs:
+                    defined_symbols.add(arg.arg)
+                if node.args.vararg:
+                    defined_symbols.add(node.args.vararg.arg)
+                if node.args.kwarg:
+                    defined_symbols.add(node.args.kwarg.arg)
+                self.generic_visit(node)
+
+            def visit_ClassDef(self, node: ast.ClassDef) -> None:
+                defined_symbols.add(node.name)
+                self.generic_visit(node)
+
+            def visit_Name(self, node: ast.Name) -> None:
+                if isinstance(node.ctx, (ast.Store, ast.Del)):
+                    defined_symbols.add(node.id)
+                elif isinstance(node.ctx, ast.Load):
+                    loaded_symbols.append((node.id, node.lineno, node.col_offset))
+                self.generic_visit(node)
+
+            def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+                if node.type is None:
+                    self.bare_excepts.append((node.lineno, node.col_offset))
+                if node.name:
+                    defined_symbols.add(node.name)
+                self.generic_visit(node)
+
+            def visit_comprehension(self, node: ast.comprehension) -> None:
+                if isinstance(node.target, ast.Name):
+                    defined_symbols.add(node.target.id)
+                elif isinstance(node.target, (ast.Tuple, ast.List)):
+                    for elt in node.target.elts:
+                        if isinstance(elt, ast.Name):
+                            defined_symbols.add(elt.id)
+                self.generic_visit(node)
+
+            def visit_Dict(self, node: ast.Dict) -> None:
+                seen_keys: set[Any] = set()
+                for k in node.keys:
+                    if isinstance(k, ast.Constant):
+                        if k.value in seen_keys:
+                            self.duplicate_keys.append((k.lineno, k.col_offset, repr(k.value)))
+                        else:
+                            seen_keys.add(k.value)
+                self.generic_visit(node)
+
+        collector = ScopeCollector()
+        collector.visit(tree)
+
+        # 2. Check for unused imports (W0611)
+        loaded_names = {name for name, _, _ in loaded_symbols}
+        for name, (line, col, _node, _stmt_type) in imported_symbols.items():
+            if name not in loaded_names:
+                diagnostics.append({
+                    "line": line,
+                    "col": col,
+                    "code": "W0611",
+                    "message": f"Unused import '{name}'",
+                    "severity": "warning",
+                    "symbol": name,
+                })
+
+        # 3. Check for undefined names (E0602)
+        reported_undefined: set[str] = set()
+        for name, line, col in loaded_symbols:
+            if name not in defined_symbols and name not in reported_undefined:
+                reported_undefined.add(name)
+                diagnostics.append({
+                    "line": line,
+                    "col": col,
+                    "code": "E0602",
+                    "message": f"Undefined name '{name}'",
+                    "severity": "error",
+                    "symbol": name,
+                })
+
+        # 4. Check bare excepts (W0702)
+        for line, col in collector.bare_excepts:
+            diagnostics.append({
+                "line": line,
+                "col": col,
+                "code": "W0702",
+                "message": "Bare 'except:' used without specifying exception type",
+                "severity": "warning",
+                "symbol": None,
+            })
+
+        # 5. Check duplicate dictionary keys (W0109)
+        for line, col, key_repr in collector.duplicate_keys:
+            diagnostics.append({
+                "line": line,
+                "col": col,
+                "code": "W0109",
+                "message": f"Duplicate key {key_repr} in dictionary literal",
+                "severity": "warning",
+                "symbol": key_repr,
+            })
+
+        # Sort diagnostics by line number
+        diagnostics.sort(key=lambda d: (d.get("line", 0), d.get("col", 0)))
+        return diagnostics
+
+    def apply_quick_fix(self, diagnostic: dict[str, Any], source_code: str) -> str:
+        """Apply an automated fix for a diagnostic issue."""
+        code = diagnostic.get("code")
+        symbol = diagnostic.get("symbol")
+        line_num = diagnostic.get("line", 1)
+        lines = source_code.splitlines(keepends=True)
+
+        if code == "W0611" and symbol:
+            # Unused import removal
+            if 1 <= line_num <= len(lines):
+                target_line = lines[line_num - 1]
+                # If the line only imports this symbol, remove the line
+                # Example: "import os\n" or "from math import sqrt\n"
+                clean = target_line.strip()
+                if clean in (f"import {symbol}", f"import {symbol} as {symbol}"):
+                    lines.pop(line_num - 1)
+                    return "".join(lines)
+                from_match = re.match(r"^from\s+[\w\.]+\s+import\s+(.+)$", clean)
+                if from_match:
+                    imported_items = [i.strip() for i in from_match.group(1).split(",") if i.strip()]
+                    remaining = [i for i in imported_items if i != symbol and not i.endswith(f" as {symbol}")]
+                    if not remaining:
+                        lines.pop(line_num - 1)
+                    else:
+                        module_part = clean.split("import")[0]
+                        indent = len(target_line) - len(target_line.lstrip())
+                        new_line = " " * indent + module_part + "import " + ", ".join(remaining) + "\n"
+                        lines[line_num - 1] = new_line
+                    return "".join(lines)
+                # Fallback: remove full line if symbol is found in it
+                if symbol in clean:
+                    lines.pop(line_num - 1)
+                    return "".join(lines)
+
+        elif code == "E0602" and symbol:
+            # Undefined name: auto-insert import if recognized
+            fix_stmt = KNOWN_IMPORTS.get(symbol)
+            if fix_stmt:
+                # Find best insertion point (after module docstring and future imports)
+                insert_idx = 0
+                for idx, line in enumerate(lines):
+                    s = line.strip()
+                    if s.startswith('"""') or s.startswith("'''"):
+                        # docstring handling
+                        continue
+                    if s.startswith("from __future__"):
+                        insert_idx = idx + 1
+                    elif s.startswith("import ") or s.startswith("from "):
+                        insert_idx = idx
+                        break
+                    elif s and not s.startswith("#"):
+                        insert_idx = idx
+                        break
+
+                lines.insert(insert_idx, fix_stmt + "\n")
+                return "".join(lines)
+
+        elif code == "W0702":
+            # Bare except fix
+            if 1 <= line_num <= len(lines):
+                target_line = lines[line_num - 1]
+                if "except:" in target_line:
+                    lines[line_num - 1] = target_line.replace("except:", "except Exception:", 1)
+                    return "".join(lines)
+
+        return source_code

fable_v2/coder_fleet/fleet_dispatcher.py

@@ -0,0 +1,214 @@
+"""Coder Fleet Dispatcher for Unified Routing to All 10 Coder Subagent Engines.
+
+Provides centralized dispatch(action, params) mapping with error containment,
+telemetry, and action discovery.
+"""
+from __future__ import annotations
+
+import inspect
+from typing import Any, Callable
+
+from ..cortical import HebbianPlasticityEngine
+from .ast_tools import TreeSitterCodemodEngine
+from .compute import ComputeOrchestratorEngine
+from .design_engine import DesignEngine
+from .diagnostics import DiagnosticsEngine
+from .mock_auditor import MockAuditorEngine
+from .mutation import MutationVerifierEngine
+from .property_oracle import PropertyOracleEngine
+from .receipt_attestor import ReceiptAttestorEngine
+from .red_team_swarm import RedTeamSwarm
+from .test_harness import TestHarnessEngine
+from .vector_engine import FableVectorCompiler, VLayoutSolver, VNode
+from .visual import VisualGroundingEngine
+from .workspace import AtomicWorkspaceEngine
+
+
+class CoderFleetDispatcher:
+    """Unified dispatcher for the 10-Tool Coder Subagent MCP Fleet, Cortical Engine, and Design Engine."""
+
+    def __init__(
+        self,
+        visual: VisualGroundingEngine | None = None,
+        diagnostics: DiagnosticsEngine | None = None,
+        ast_tools: TreeSitterCodemodEngine | None = None,
+        workspace: AtomicWorkspaceEngine | None = None,
+        test_harness: TestHarnessEngine | None = None,
+        mutation: MutationVerifierEngine | None = None,
+        mock_auditor: MockAuditorEngine | None = None,
+        property_oracle: PropertyOracleEngine | None = None,
+        receipt_attestor: ReceiptAttestorEngine | None = None,
+        compute: ComputeOrchestratorEngine | None = None,
+        red_team_swarm: RedTeamSwarm | None = None,
+        plasticity_engine: HebbianPlasticityEngine | None = None,
+        vector_compiler: FableVectorCompiler | None = None,
+        layout_solver: VLayoutSolver | None = None,
+        design_engine: DesignEngine | None = None,
+    ) -> None:
+        self.visual = visual or VisualGroundingEngine()
+        self.diagnostics = diagnostics or DiagnosticsEngine()
+        self.ast_tools = ast_tools or TreeSitterCodemodEngine()
+        self.workspace = workspace or AtomicWorkspaceEngine()
+        self.test_harness = test_harness or TestHarnessEngine()
+        self.mutation = mutation or MutationVerifierEngine(test_harness=self.test_harness)
+        self.mock_auditor = mock_auditor or MockAuditorEngine()
+        self.property_oracle = property_oracle or PropertyOracleEngine(test_harness=self.test_harness)
+        self.receipt_attestor = receipt_attestor or ReceiptAttestorEngine()
+        self.compute = compute or ComputeOrchestratorEngine()
+        self.plasticity_engine = plasticity_engine or HebbianPlasticityEngine()
+        self.vector_compiler = vector_compiler or FableVectorCompiler()
+        self.layout_solver = layout_solver or VLayoutSolver()
+        self.design_engine = design_engine or DesignEngine()
+        self.red_team_swarm = red_team_swarm or RedTeamSwarm(
+            test_harness=self.test_harness,
+            mock_auditor=self.mock_auditor,
+            property_oracle=self.property_oracle,
+            plasticity_engine=self.plasticity_engine,
+        )
+
+        self._actions: dict[str, Callable[..., Any]] = {
+            # 1. Visual Grounding Engine
+            "render_vector": self.visual.render_vector,
+            "perceptual_diff": self.visual.perceptual_diff,
+            "extract_palette_and_boxes": self.visual.extract_palette_and_boxes,
+            # 2. Diagnostics Engine
+            "run_diagnostics": self.diagnostics.run_diagnostics,
+            "apply_quick_fix": self.diagnostics.apply_quick_fix,
+            # 3. TreeSitter / AST Codemod Engine
+            "query_ast": self.ast_tools.query_ast,
+            "rename_symbol": self.ast_tools.rename_symbol,
+            "verify_syntax": self.ast_tools.verify_syntax,
+            # 4. Atomic Workspace Engine
+            "create_checkpoint": self.workspace.create_checkpoint,
+            "inspect_patch": self.workspace.inspect_patch,
+            "rollback": self.workspace.rollback,
+            "commit_milestone": self.workspace.commit_milestone,
+            # 5. Test Harness Engine
+            "run_scratch_test": self.test_harness.run_scratch_test,
+            "concurrency_fuzz": self.test_harness.concurrency_fuzz,
+            "profile_memory_and_cpu": self.test_harness.profile_memory_and_cpu,
+            # 6. Mutation Verifier Engine
+            "inject_mutants": self.mutation.inject_mutants,
+            "audit_test_strength": self.mutation.audit_test_strength,
+            # 7. Mock Auditor Engine
+            "audit_assertions": self.mock_auditor.audit_assertions,
+            "detect_mock_leakage": self.mock_auditor.detect_mock_leakage,
+            "enforce_negative_paths": self.mock_auditor.enforce_negative_paths,
+            # 8. Property Oracle Engine
+            "generate_property_matrix": self.property_oracle.generate_property_matrix,
+            "verify_algebraic_invariants": self.property_oracle.verify_algebraic_invariants,
+            # 9. Receipt Attestor Engine
+            "attest_execution": self.receipt_attestor.attest_execution,
+            "verify_receipt": self.receipt_attestor.verify_receipt,
+            # 10. Compute Orchestrator Engine
+            "calculate_thinking_budget": self.compute.calculate_thinking_budget,
+            "mcts_explore": self.compute.mcts_explore,
+            "best_of_n_consensus": self.compute.best_of_n_consensus,
+            # 11. Red Team Swarm Engine (Modular Fable Part 1: Adversarial Code Review)
+            "red_team_generate_scenarios": self.red_team_swarm.generate_break_scenarios,
+            "red_team_execute_attack": self.red_team_swarm.execute_swarm_attack,
+            "red_team_document_breakage": self.red_team_swarm.document_breakage,
+            "red_team_verify_remediation": self.red_team_swarm.verify_remediation,
+            "red_team_full_review_cycle": self.red_team_swarm.run_full_review_cycle,
+            "red_team_code_review": self.red_team_swarm.run_full_review_cycle,
+            "record_breakage_report": self.red_team_swarm.document_breakage,
+            "verify_red_team_remediation": self.red_team_swarm.verify_remediation,
+            # 12. Cortical Plasticity Engine (Modular Fable Part 2: Hebbian Learning & Domain Lobes)
+            "cortical_define_lobe": self.plasticity_engine.define_cortical_lobe,
+            "cortical_list_lobes": self.plasticity_engine.list_cortical_lobes,
+            "cortical_activate_lobe": self.plasticity_engine.activate_lobe,
+            "cortical_consolidate_task": self.plasticity_engine.consolidate_task,
+            "cortical_recall_context": self.plasticity_engine.recall_cortical_context,
+            "cortical_inspect_matrix": self.plasticity_engine.get_synaptic_matrix,
+            "evolve_cortex": self.plasticity_engine.consolidate_task,
+            # 13. Fable-Vector Neuro-Symbolic Vector Engine
+            "compile_vector": self.compile_vector,
+            "solve_layout": self.solve_layout,
+            # 14. Anti-Slop Frontend & Design Taste Engine
+            "audit_anti_slop": self.design_engine.audit_anti_slop,
+            "infer_design_brief": self.design_engine.infer_design_brief,
+            "generate_design_tokens": self.design_engine.generate_design_tokens,
+            "generate_awwwards_scaffold": self.design_engine.generate_awwwards_scaffold,
+            "validate_preflight_design": self.design_engine.validate_preflight_design,
+            "list_design_archetypes": self.design_engine.list_design_archetypes,
+        }
+
+    def list_actions(self) -> list[str]:
+        """Return list of all registered action names."""
+        return sorted(self._actions.keys())
+
+    def dispatch(self, action: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Dispatch an action with parameter dictionary to the corresponding fleet engine."""
+        if action not in self._actions:
+            return {
+                "success": False,
+                "action": action,
+                "error": f"Unknown fleet action '{action}'. Available actions: {', '.join(self.list_actions())}",
+            }
+
+        target_fn = self._actions[action]
+        kwargs = dict(params or {})
+
+        try:
+            sig = inspect.signature(target_fn)
+            # Filter kwargs to only accepted parameters if not accepting **kwargs
+            has_var_keyword = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
+            if not has_var_keyword:
+                valid_params = set(sig.parameters.keys())
+                filtered_kwargs = {k: v for k, v in kwargs.items() if k in valid_params}
+            else:
+                filtered_kwargs = kwargs
+
+            result = target_fn(**filtered_kwargs)
+            return {
+                "success": True,
+                "action": action,
+                "result": result,
+            }
+        except TypeError as type_err:
+            return {
+                "success": False,
+                "action": action,
+                "error": f"Invalid arguments for action '{action}': {type_err}",
+            }
+        except Exception as exc:
+            return {
+                "success": False,
+                "action": action,
+                "error": f"Execution error in action '{action}': {exc}",
+            }
+
+    def compile_vector(
+        self,
+        node: VNode | dict[str, Any] | None = None,
+        tree: VNode | dict[str, Any] | None = None,
+        root: VNode | dict[str, Any] | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Compile a VNode tree or dictionary definition into production SVG."""
+        target = node if node is not None else (tree if tree is not None else root)
+        if target is None:
+            raise ValueError("No node, tree, or root provided to compile_vector")
+        svg_code = self.vector_compiler.compile(target, options=options)
+        return {
+            "svg": svg_code,
+            "valid": True,
+        }
+
+    def solve_layout(
+        self,
+        root: VNode | dict[str, Any] | None = None,
+        node: VNode | dict[str, Any] | None = None,
+        tree: VNode | dict[str, Any] | None = None,
+        viewport_width: float = 1920.0,
+        viewport_height: float = 1080.0,
+    ) -> dict[str, Any]:
+        """Solve layout constraints and return computed coordinates and bounding boxes."""
+        target = root if root is not None else (node if node is not None else tree)
+        if target is None:
+            raise ValueError("No root, node, or tree provided to solve_layout")
+        return self.layout_solver.solve_layout(
+            target,
+            viewport_width=viewport_width,
+            viewport_height=viewport_height,
+        )