opencode-arch 1.0.0__py3-none-any.whl

opencode_arch/learning/maintainer.py

@@ -0,0 +1,281 @@
+"""Documentation drift detection and auto-fix.
+
+Checks for discrepancies between code reality and documentation,
+then either flags issues or auto-fixes simple cases.
+"""
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class DriftFlag:
+    """A detected documentation drift issue."""
+    file: str                    # which doc is out of date
+    issue: str                   # what's wrong
+    severity: str                # "blocker", "high", "medium", "low"
+    auto_fixable: bool = False   # can we fix it programmatically?
+    suggested_fix: str = ""      # what to change
+    fixed: bool = False          # was it auto-fixed?
+
+
+def _check_test_count(project_root: Path) -> DriftFlag | None:
+    """Check if README test count matches actual."""
+    readme = project_root / "README.md"
+    if not readme.exists():
+        return None
+    
+    content = readme.read_text(encoding="utf-8")
+    
+    # Find test count claims in README
+    match = re.search(r"(\d+)\s+tests?\s+pass", content, re.IGNORECASE)
+    if not match:
+        return None
+    
+    claimed_count = int(match.group(1))
+    
+    # Run actual test count (collect only, don't execute)
+    try:
+        result = subprocess.run(
+            ["python", "-m", "pytest", "--collect-only", "-q",
+             "--ignore=tests/test_config_loader.py"],
+            capture_output=True, text=True, cwd=str(project_root), timeout=30,
+        )
+        # Parse "X tests collected" or "X items"
+        count_match = re.search(r"(\d+) tests? (?:collected|selected)", result.stdout)
+        if not count_match:
+            # Try alternate format
+            count_match = re.search(r"(\d+) items?", result.stdout)
+        if not count_match:
+            return None
+        
+        actual_count = int(count_match.group(1))
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return None
+    
+    if abs(actual_count - claimed_count) > 5:  # Allow small variance
+        return DriftFlag(
+            file=str(readme.relative_to(project_root)),
+            issue=f"README claims {claimed_count} tests but actual is {actual_count}",
+            severity="medium",
+            auto_fixable=True,
+            suggested_fix=f"Replace '{claimed_count}' with '{actual_count}' in test count",
+        )
+    return None
+
+
+def _check_version_sync(project_root: Path) -> DriftFlag | None:
+    """Check if version in pyproject.toml matches __init__.py."""
+    pyproject = project_root / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    
+    pyproject_content = pyproject.read_text(encoding="utf-8")
+    version_match = re.search(r'version\s*=\s*"([^"]+)"', pyproject_content)
+    if not version_match:
+        return None
+    pyproject_version = version_match.group(1)
+    
+    # Find __init__.py
+    for init_path in project_root.rglob("__init__.py"):
+        rel = str(init_path.relative_to(project_root))
+        if "test" in rel or ".venv" in rel:
+            continue
+        try:
+            init_content = init_path.read_text(encoding="utf-8")
+            init_match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', init_content)
+            if init_match:
+                init_version = init_match.group(1)
+                if init_version != pyproject_version:
+                    rel_path = init_path.relative_to(project_root)
+                    return DriftFlag(
+                        file=str(rel_path),
+                        issue=f"__version__='{init_version}' != pyproject.toml version='{pyproject_version}'",
+                        severity="high",
+                        auto_fixable=True,
+                        suggested_fix=f"Update __version__ to '{pyproject_version}'",
+                    )
+                break  # Found and matches
+        except (UnicodeDecodeError, OSError):
+            continue
+    return None
+
+
+def _check_schema_version(project_root: Path) -> DriftFlag | None:
+    """Check if schema.json version matches CONTEXT.md claims."""
+    schema_path = project_root / "src" / "architecture_model" / "spec" / "schema.json"
+    context_path = project_root / "CONTEXT.md"
+    
+    if not schema_path.exists() or not context_path.exists():
+        return None
+    
+    try:
+        import json
+        schema = json.loads(schema_path.read_text(encoding="utf-8"))
+        schema_id = schema.get("$id", "")
+        # Extract version from $id URL
+        schema_version_match = re.search(r"v?([\d.]+)", schema_id)
+        if not schema_version_match:
+            return None
+        schema_version = schema_version_match.group(1)
+        
+        context_content = context_path.read_text(encoding="utf-8")
+        context_match = re.search(r"[Ss]chema version:?\s*([\d.]+)", context_content)
+        if not context_match:
+            return None
+        context_version = context_match.group(1)
+        
+        if schema_version != context_version:
+            return DriftFlag(
+                file="src/architecture_model/spec/schema.json",
+                issue=f"Schema $id version ({schema_version}) != CONTEXT.md ({context_version})",
+                severity="medium",
+                auto_fixable=False,
+                suggested_fix=f"Align schema $id version to {context_version}",
+            )
+    except (json.JSONDecodeError, OSError):
+        pass
+    return None
+
+
+def _check_python_version(project_root: Path) -> DriftFlag | None:
+    """Check if README Python version matches pyproject.toml requires-python."""
+    readme = project_root / "README.md"
+    pyproject = project_root / "pyproject.toml"
+    
+    if not readme.exists() or not pyproject.exists():
+        return None
+    
+    pyproject_content = pyproject.read_text(encoding="utf-8")
+    req_match = re.search(r'requires-python\s*=\s*"([^"]+)"', pyproject_content)
+    if not req_match:
+        return None
+    
+    # Extract minimum version from requires-python (e.g., ">=3.11" -> "3.11")
+    min_version_match = re.search(r"(\d+\.\d+)", req_match.group(1))
+    if not min_version_match:
+        return None
+    min_version = min_version_match.group(1)
+    
+    readme_content = readme.read_text(encoding="utf-8")
+    readme_match = re.search(r"Python\s+(\d+\.\d+)\+?", readme_content)
+    if not readme_match:
+        return None
+    
+    readme_version = readme_match.group(1)
+    if readme_version != min_version:
+        return DriftFlag(
+            file="README.md",
+            issue=f"README says Python {readme_version}+ but pyproject requires >={min_version}",
+            severity="medium",
+            auto_fixable=True,
+            suggested_fix=f"Replace 'Python {readme_version}+' with 'Python {min_version}+'",
+        )
+    return None
+
+
+def detect_drift(project_root: Path) -> list[DriftFlag]:
+    """Run all drift detection checks on a project.
+    
+    Args:
+        project_root: Path to the project to check.
+    
+    Returns:
+        List of detected drift issues (may be empty if all is well).
+    """
+    checks = [
+        _check_test_count,
+        _check_version_sync,
+        _check_schema_version,
+        _check_python_version,
+    ]
+    
+    flags: list[DriftFlag] = []
+    for check in checks:
+        try:
+            flag = check(project_root)
+            if flag:
+                flags.append(flag)
+        except Exception:
+            pass  # Drift detection is best-effort
+    
+    return flags
+
+
+def auto_fix_drift(flags: list[DriftFlag], project_root: Path) -> list[DriftFlag]:
+    """Auto-fix drift flags that are marked as auto_fixable.
+    
+    Args:
+        flags: List of detected drift flags.
+        project_root: Path to the project root.
+    
+    Returns:
+        List of flags that were successfully fixed.
+    """
+    fixed: list[DriftFlag] = []
+    
+    for flag in flags:
+        if not flag.auto_fixable:
+            continue
+        
+        file_path = project_root / flag.file
+        if not file_path.exists():
+            continue
+        
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            new_content = content
+            
+            if "test count" in flag.issue.lower() or "tests" in flag.issue.lower():
+                # Fix test count
+                match = re.search(r"(\d+)\s+tests?\s+pass", flag.issue)
+                new_match = re.search(r"actual is (\d+)", flag.issue)
+                if match and new_match:
+                    old_count = match.group(1)
+                    new_count = new_match.group(1)
+                    new_content = re.sub(
+                        rf"{old_count}(\s+tests?\s+pass)",
+                        f"{new_count}\\1",
+                        content,
+                    )
+            
+            elif "__version__" in flag.issue:
+                # Fix version mismatch
+                match = re.search(r"to '([^']+)'", flag.suggested_fix)
+                if match:
+                    target_version = match.group(1)
+                    new_content = re.sub(
+                        r'__version__\s*=\s*["\'][^"\']+["\']',
+                        f'__version__ = "{target_version}"',
+                        content,
+                    )
+            
+            elif "Python" in flag.issue:
+                # Fix Python version
+                match = re.search(r"Python ([\d.]+)\+.*Python ([\d.]+)\+", flag.suggested_fix)
+                if match:
+                    old_ver = match.group(1)
+                    new_ver = match.group(2)
+                    new_content = content.replace(f"Python {old_ver}+", f"Python {new_ver}+")
+                else:
+                    # Try alternate parsing from issue text
+                    old_match = re.search(r"says Python ([\d.]+)", flag.issue)
+                    new_match_ver = re.search(r"requires >=([\d.]+)", flag.issue)
+                    if old_match and new_match_ver:
+                        old_ver = old_match.group(1)
+                        new_ver = new_match_ver.group(1)
+                        new_content = content.replace(f"Python {old_ver}+", f"Python {new_ver}+")
+            
+            if new_content != content:
+                file_path.write_text(new_content, encoding="utf-8")
+                flag.fixed = True
+                fixed.append(flag)
+        
+        except (OSError, UnicodeDecodeError):
+            pass
+    
+    return fixed

opencode_arch/learning/patterns.py

@@ -0,0 +1,51 @@
+"""Failure pattern definitions and taxonomy."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class PatternType(str, Enum):
+    """Known failure pattern types."""
+    CROSS_DEP = "cross_dep"           # ImportError/NameError from another module
+    MISSING_IMPL = "missing_impl"     # AttributeError on generated code
+    WRONG_CONSTANT = "wrong_constant" # AssertionError with literal mismatch
+    API_MISMATCH = "api_mismatch"     # TypeError wrong arg count/types
+    COMPLEX_BEHAVIOR = "complex_behavior"  # Multiple sequential failures
+    TEST_INFRA = "test_infra"         # ModuleNotFoundError for test helpers
+    UNKNOWN = "unknown"               # Unclassified
+
+
+class Strategy(str, Enum):
+    """Adaptation strategies to apply for each pattern."""
+    EXPAND_DEP_CONTEXT = "expand_dep_context"       # Include full dep API + body_hints
+    INCLUDE_SOURCE_EXCERPT = "include_source_excerpt"  # Escape hatch: include source
+    PRIORITIZE_CONSTANTS = "prioritize_constants"    # Move constants to top, increase budget
+    FIX_SIGNATURES = "fix_signatures"               # Include exact param lists
+    INCREASE_CONTRACT_CAP = "increase_contract_cap"  # Raise from 50 to 100+
+    COPY_TEST_INFRA = "copy_test_infra"             # Additional test helper copying
+    NO_ACTION = "no_action"                         # Pattern recognized but no fix available
+
+
+@dataclass
+class FailureClassification:
+    """A classified test failure with dual-level signals."""
+    pattern: PatternType
+    confidence: float                    # 0.0-1.0
+    raw_signal: str                      # regex match from pytest output
+    structured_signal: dict = field(default_factory=dict)  # parsed details
+    suggested_strategy: Strategy = Strategy.NO_ACTION
+    affected_symbols: list[str] = field(default_factory=list)  # symbols/modules involved
+    source_module: str = ""              # which module the failure relates to
+
+
+# Pattern → Strategy mapping (default strategies)
+PATTERN_STRATEGIES: dict[PatternType, Strategy] = {
+    PatternType.CROSS_DEP: Strategy.EXPAND_DEP_CONTEXT,
+    PatternType.MISSING_IMPL: Strategy.INCLUDE_SOURCE_EXCERPT,
+    PatternType.WRONG_CONSTANT: Strategy.PRIORITIZE_CONSTANTS,
+    PatternType.API_MISMATCH: Strategy.FIX_SIGNATURES,
+    PatternType.COMPLEX_BEHAVIOR: Strategy.INCREASE_CONTRACT_CAP,
+    PatternType.TEST_INFRA: Strategy.COPY_TEST_INFRA,
+    PatternType.UNKNOWN: Strategy.NO_ACTION,
+}

opencode_arch/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP server for architecture tools."""

opencode_arch/mcp/__main__.py

@@ -0,0 +1,8 @@
+"""Allow running as: python -m opencode_arch.mcp"""
+from opencode_arch.mcp.server import mcp
+
+if mcp is not None:
+    mcp.run()
+else:
+    print("Error: mcp package not installed. Install with: pip install 'opencode-arch[mcp]'")
+    raise SystemExit(1)

opencode_arch/mcp/server.py

@@ -0,0 +1,183 @@
+# src/opencode_arch/mcp/server.py
+"""FastMCP server entry point for opencode-arch.
+
+Run with: python -m opencode_arch.mcp.server
+"""
+from __future__ import annotations
+
+try:
+    from mcp.server.fastmcp import FastMCP
+
+    mcp = FastMCP(
+        "opencode-arch",
+        instructions="Architecture context compression, validation, and code quality tools",
+    )
+
+    from opencode_arch.mcp.tools.scan import scan_repository
+    from opencode_arch.mcp.tools.slice import slice_context
+    from opencode_arch.mcp.tools.validate import validate_architecture
+    from opencode_arch.mcp.tools.extract import store_extraction
+    from opencode_arch.mcp.tools.generate import run_tests_on_generated_code
+    from opencode_arch.mcp.tools.group import group_repository
+    from opencode_arch.mcp.tools.check import check_representativeness
+    from opencode_arch.mcp.tools.require import capture_requirement
+    from opencode_arch.mcp.tools.feedback import record_feedback
+    from opencode_arch.mcp.tools.ingest import ingest_source_graph
+
+    @mcp.tool()
+    async def architect_scan(repo_path: str) -> dict:
+        """Scan a repository to generate its reality manifest (AST analysis).
+
+        Returns a manifest with: modules, functions, classes, imports, metrics.
+        Use this as raw material before slicing context.
+        """
+        return await scan_repository(repo_path=repo_path)
+
+    @mcp.tool()
+    async def architect_slice(repo_path: str, focus: str = "all", budget: int = 4000, detail: str = "standard") -> str:
+        """Generate an optimized context slice from a repository.
+
+        Compresses the full repository into a dense context string within the
+        token budget. This is the core token-arbitrage function.
+
+        Args:
+            repo_path: Absolute path to the repository.
+            focus: "all", an F-block ID ("F1"), layer name, or artifact name ("icd").
+            budget: Maximum token budget (default 4000).
+            detail: "minimal", "standard", or "full".
+        """
+        return await slice_context(repo_path=repo_path, focus=focus, budget=budget, detail=detail)
+
+    @mcp.tool()
+    async def architect_validate(model_yaml: str) -> dict:
+        """Validate an architecture model for structural correctness.
+
+        Checks: ID uniqueness, referential integrity, orphan detection,
+        capability realization, meta completeness. Returns score 0-100.
+        """
+        return await validate_architecture(model_yaml=model_yaml)
+
+    @mcp.tool()
+    async def architect_extract(repo_path: str, model_yaml: str, context_tokens: int = 0) -> dict:
+        """Store a validated architecture extraction.
+
+        Call AFTER the agent produces a YAML model. Validates, writes to
+        .architecture-model.yaml, and records telemetry.
+        """
+        return await store_extraction(repo_path=repo_path, model_yaml=model_yaml, context_tokens=context_tokens)
+
+    @mcp.tool()
+    async def architect_generate(repo_path: str, test_command: str = "") -> dict:
+        """Run tests on generated code to verify quality.
+
+        Executes the repository's test suite against generated code.
+        Returns pass rate, failures, and total test count.
+        """
+        return await run_tests_on_generated_code(repo_path=repo_path, test_command=test_command or None)
+
+    @mcp.tool()
+    async def architect_group(repo_path: str, target_groups: int = 0) -> dict:
+        """Group repository modules into logical architecture components.
+
+        Uses multi-signal affinity (subdirectory, name-prefix, imports) to
+        suggest component boundaries. Call after scan, before extraction.
+
+        Args:
+            repo_path: Absolute path to the repository.
+            target_groups: Desired number of groups (0 = auto-calculate).
+        """
+        return await group_repository(repo_path=repo_path, target_groups=target_groups)
+
+    @mcp.tool()
+    async def architect_check(repo_path: str, model_yaml: str) -> dict:
+        """Verify model representativeness against code reality.
+
+        Computes three sub-scores comparing model against AST-derived ground truth.
+        Target: 100% on all three. Returns file_coverage, relationship_accuracy,
+        boundary_coherence, and overall (0-100).
+        """
+        return await check_representativeness(repo_path=repo_path, model_yaml=model_yaml)
+
+    @mcp.tool()
+    async def architect_require(
+        repo_path: str,
+        requirement: str,
+        component_id: str = "",
+        priority: str = "must",
+        context: str = "",
+    ) -> dict:
+        """Capture a functional requirement linked to an architecture component.
+
+        Stores requirements in .architecture/requirements.yaml with MoSCoW priority.
+
+        Args:
+            repo_path: Absolute path to the repository.
+            requirement: The requirement text.
+            component_id: Component ID (e.g., "COMP-3"). Empty string = unlinked.
+            priority: must | should | could (MoSCoW).
+            context: Additional context from conversation.
+        """
+        return await capture_requirement(
+            repo_path=repo_path,
+            requirement=requirement,
+            component_id=component_id or None,
+            priority=priority,
+            context=context,
+        )
+
+    @mcp.tool()
+    async def architect_feedback(
+        repo_path: str,
+        feedback_type: str,
+        content: str,
+        context: dict | None = None,
+        rating: int | None = None,
+        correction: dict | None = None,
+    ) -> dict:
+        """Record user feedback for model improvement and training.
+
+        Appends feedback to .architecture/feedback.jsonl for future training use.
+
+        Args:
+            repo_path: Absolute path to the repository.
+            feedback_type: "correction" | "rating" | "tool_feedback" | "training".
+            content: The feedback content (human-readable).
+            context: Optional context dict.
+            rating: Optional 1-5 quality rating.
+            correction: Optional structured correction {entity_id, field, old, new}.
+        """
+        return await record_feedback(
+            repo_path=repo_path,
+            feedback_type=feedback_type,
+            content=content,
+            context=context,
+            rating=rating,
+            correction=correction,
+        )
+
+    @mcp.tool()
+    async def architect_ingest(repo_path: str, source_graph_json: str) -> dict:
+        """Ingest a SourceGraph JSON for any language repository.
+
+        Accepts dependency and export data (from external tools or agent analysis),
+        groups modules into components, extracts interface contracts, and stores
+        the architecture model.
+
+        Args:
+            repo_path: Absolute path to the repository.
+            source_graph_json: JSON string with SourceGraph data. Format:
+                {"language": "typescript", "units": [{"file": "...", "exports": [...]}], "edges": [...]}
+        """
+        return await ingest_source_graph(repo_path=repo_path, source_graph_json=source_graph_json)
+
+except ImportError:
+    # mcp package not available - tools still work as standalone async functions
+    mcp = None
+
+
+if __name__ == "__main__":
+    if mcp is not None:
+        mcp.run()
+    else:
+        print("Error: mcp package not installed. Install with: pip install 'opencode-arch[mcp]'")
+        raise SystemExit(1)

opencode_arch/mcp/tools/__init__.py

@@ -0,0 +1 @@
+"""MCP tool implementations."""

opencode_arch/mcp/tools/check.py

@@ -0,0 +1,159 @@
+"""architect_check MCP tool — verify model representativeness against code reality."""
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+async def check_representativeness(repo_path: str, model_yaml: str) -> dict[str, Any]:
+    """Check how well an architecture model represents the actual codebase.
+
+    Supports three modes:
+    - Hierarchical (config): uses pre-existing fblock_dict from config
+    - Hierarchical (auto): generates F-blocks from module grouping when no config exists
+    - Flat: fallback when neither hierarchical path is available
+
+    Args:
+        repo_path: Absolute path to the repository root.
+        model_yaml: The architecture model YAML to evaluate.
+
+    Returns:
+        Dict with scores, details, and suggested improvements.
+    """
+    path = Path(repo_path)
+    if not path.exists():
+        return {"error": f"Repository path does not exist: {repo_path}"}
+
+    try:
+        from architecture_model.manifest.generator import generate_manifest
+        from architecture_model.core.parser import load_model
+        from architecture_model.core.representativeness import compute_representativeness as _compute
+
+        # Parse the model via temp file
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            f.write(model_yaml)
+            tmp_path = f.name
+
+        try:
+            model = load_model(tmp_path)
+        finally:
+            Path(tmp_path).unlink(missing_ok=True)
+
+        # Try hierarchical mode (config-based)
+        output = _try_hierarchical(path, model)
+        if output is None:
+            # Try auto-F-block hierarchical mode
+            output = _try_auto_hierarchical(path, model)
+        if output is None:
+            # Fall back to flat mode
+            manifest = generate_manifest(path)
+            result = _compute(model, manifest.modules, manifest.interfaces)
+            output = {
+                "mode": "flat",
+                "file_coverage": round(result.file_coverage, 1),
+                "relationship_accuracy": round(result.relationship_accuracy, 1),
+                "boundary_coherence": round(result.boundary_coherence, 1),
+                "overall": round(result.overall, 1),
+                "uncovered_files": result.uncovered_files,
+                "unverified_relationships": result.unverified_relationships,
+                "low_coherence_components": result.low_coherence_components,
+            }
+
+        try:
+            from opencode_arch.telemetry.collector import drain_and_store
+            drain_and_store(tool="architect_check", repo=path.name)
+        except Exception:
+            pass
+
+        return output
+
+    except Exception as e:
+        return {"error": f"Check failed: {e}"}
+
+
+def _try_hierarchical(path: Path, root_model) -> dict[str, Any] | None:
+    """Attempt hierarchical check if recursive manifests are available via config."""
+    try:
+        from architecture_model.manifest.recursive import generate_recursive_manifests
+        from architecture_model.core.representativeness import compute_hierarchical_representativeness
+        from architecture_model.config.loader import get_config
+
+        config = get_config(path)
+        if not config.fblock_dict or len(config.fblock_dict) < 2:
+            return None
+
+        recursive_manifests = generate_recursive_manifests(path)
+        if not recursive_manifests:
+            return None
+
+        result = compute_hierarchical_representativeness(
+            root_model, {}, recursive_manifests
+        )
+
+        return _format_hierarchical_output(result)
+
+    except Exception:
+        return None
+
+
+def _try_auto_hierarchical(path: Path, root_model) -> dict[str, Any] | None:
+    """Attempt hierarchical check using auto-generated F-blocks from module grouping."""
+    try:
+        from architecture_model.manifest.generator import generate_manifest
+        from architecture_model.manifest.grouping import group_modules, auto_fblocks
+        from architecture_model.manifest.recursive import generate_recursive_manifests
+        from architecture_model.core.representativeness import compute_hierarchical_representativeness
+
+        manifest = generate_manifest(path)
+        groups = group_modules(manifest.modules, manifest.interfaces)
+        fblock_config = auto_fblocks(groups)
+
+        if not fblock_config or len(fblock_config) < 2:
+            return None
+
+        recursive_manifests = generate_recursive_manifests(path, fblock_override=fblock_config)
+        if not recursive_manifests:
+            return None
+
+        result = compute_hierarchical_representativeness(
+            root_model, {}, recursive_manifests
+        )
+
+        output = _format_hierarchical_output(result)
+        output["mode"] = "hierarchical_auto"
+        output["fblock_count"] = len(fblock_config)
+        return output
+
+    except Exception:
+        return None
+
+
+def _format_hierarchical_output(result) -> dict[str, Any]:
+    """Format a hierarchical representativeness result into output dict."""
+    output: dict[str, Any] = {
+        "mode": "hierarchical",
+        "root": {
+            "file_coverage": round(result.root.file_coverage, 1),
+            "relationship_accuracy": round(result.root.relationship_accuracy, 1),
+            "boundary_coherence": round(result.root.boundary_coherence, 1),
+            "overall": round(result.root.overall, 1),
+        },
+        "blocks": {},
+        "overall": round(result.overall, 1),
+        "uncovered_files": result.root.uncovered_files,
+        "unverified_relationships": result.root.unverified_relationships,
+        "low_coherence_components": result.root.low_coherence_components,
+    }
+
+    for block_id, block_result in result.blocks.items():
+        output["blocks"][block_id] = {
+            "file_coverage": round(block_result.file_coverage, 1),
+            "relationship_accuracy": round(block_result.relationship_accuracy, 1),
+            "boundary_coherence": round(block_result.boundary_coherence, 1),
+            "overall": round(block_result.overall, 1),
+        }
+
+    return output