opencode-arch 1.0.0__py3-none-any.whl

opencode_arch/mcp/tools/extract.py

@@ -0,0 +1,107 @@
+"""architect_extract MCP tool — validate and store an architecture extraction."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+async def store_extraction(
+    repo_path: str,
+    model_yaml: str,
+    context_tokens: int = 0,
+) -> dict[str, Any]:
+    """Validate and store an architecture model extraction.
+
+    Called AFTER the agent has produced a YAML architecture model.
+    Validates the model, writes it to .architecture-model.yaml,
+    and records telemetry.
+
+    Args:
+        repo_path: Path to the repository root (where to save the model).
+        model_yaml: The YAML architecture model produced by the agent.
+        context_tokens: How many tokens of context the agent used (for telemetry).
+
+    Returns:
+        Dict with: stored (bool), score (int), issues (list), telemetry_recorded (bool).
+    """
+    path = Path(repo_path)
+
+    try:
+        # Parse the YAML
+        raw = yaml.safe_load(model_yaml)
+        if not isinstance(raw, dict):
+            return {"stored": False, "error": "YAML did not parse to a dict", "score": 0}
+
+        # Validate using architecture_model
+        from architecture_model.core.parser import _parse_raw
+        from architecture_model.core.validator import validate_model
+
+        model = _parse_raw(raw)
+        validation = validate_model(model)
+
+        score = validation.score
+        issues = [str(issue) for issue in validation.issues]
+
+        # Write to repo
+        output_path = path / ".architecture-model.yaml"
+        output_path.write_text(model_yaml)
+
+        # Record telemetry
+        telemetry_recorded = False
+        try:
+            from opencode_arch.telemetry.store import TelemetryStore
+            store = TelemetryStore()
+            store.record(
+                tool="architect_extract",
+                repo=str(path.name),
+                context_tokens=context_tokens,
+                output_quality=score,
+                iterations=1,
+            )
+            telemetry_recorded = True
+        except Exception:
+            pass  # Telemetry failure shouldn't block the tool
+
+        try:
+            from opencode_arch.telemetry.collector import drain_and_store
+            drain_and_store(tool="architect_extract", repo=path.name)
+        except Exception:
+            pass
+
+        # After the model is stored successfully, persist full project snapshot
+        try:
+            from architecture_model.manifest.generator import generate_manifest
+            from architecture_model.persistence.store import save_project
+
+            manifest = generate_manifest(Path(repo_path))
+
+            # Try to compute representativeness
+            rep = None
+            try:
+                from architecture_model.core.representativeness import compute_representativeness
+                rep = compute_representativeness(model, manifest)
+            except Exception:
+                pass
+
+            save_project(
+                Path(repo_path), model, manifest,
+                representativeness=rep,
+                telemetry={"context_tokens": context_tokens} if context_tokens else None,
+            )
+        except Exception:
+            pass  # Persistence failures should never block tool operation
+
+        return {
+            "stored": True,
+            "score": score,
+            "issues": issues,
+            "path": str(output_path),
+            "telemetry_recorded": telemetry_recorded,
+        }
+
+    except yaml.YAMLError as e:
+        return {"stored": False, "error": f"Invalid YAML: {e}", "score": 0}
+    except Exception as e:
+        return {"stored": False, "error": f"Validation failed: {e}", "score": 0}

opencode_arch/mcp/tools/feedback.py

@@ -0,0 +1,65 @@
+"""Record user feedback for model improvement and training."""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+async def record_feedback(
+    repo_path: str,
+    feedback_type: str,
+    content: str,
+    context: dict | None = None,
+    rating: int | None = None,
+    correction: dict | None = None,
+) -> dict[str, Any]:
+    """Record user feedback to .architecture/feedback.jsonl.
+    
+    Args:
+        repo_path: Repository root path
+        feedback_type: "correction" | "rating" | "tool_feedback" | "training"
+        content: The feedback content (human-readable)
+        context: Optional context dict (tool name, prompt, response, etc.)
+        rating: Optional 1-5 quality rating
+        correction: Optional structured correction {entity_id, field, old, new}
+    
+    Returns:
+        {recorded, feedback_id, total_feedback}
+    """
+    repo = Path(repo_path)
+    arch_dir = repo / ".architecture"
+    arch_dir.mkdir(parents=True, exist_ok=True)
+    feedback_path = arch_dir / "feedback.jsonl"
+    
+    # Count existing entries to generate ID
+    existing_count = 0
+    if feedback_path.exists():
+        existing_count = sum(1 for line in feedback_path.read_text().splitlines() if line.strip())
+    
+    feedback_id = f"FB-{existing_count + 1}"
+    
+    # Build entry
+    entry: dict[str, Any] = {
+        "id": feedback_id,
+        "type": feedback_type,
+        "ts": datetime.now(timezone.utc).isoformat(),
+        "content": content,
+    }
+    if context:
+        entry["context"] = context
+    if rating is not None:
+        entry["rating"] = rating
+    if correction:
+        entry["correction"] = correction
+    
+    # Append to JSONL
+    with feedback_path.open("a") as f:
+        f.write(json.dumps(entry, default=str) + "\n")
+    
+    return {
+        "recorded": True,
+        "feedback_id": feedback_id,
+        "total_feedback": existing_count + 1,
+    }

opencode_arch/mcp/tools/generate.py

@@ -0,0 +1,104 @@
+# src/opencode_arch/mcp/tools/generate.py
+"""architect_generate MCP tool — run tests on generated code."""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+async def run_tests_on_generated_code(
+    repo_path: str,
+    test_command: str | None = None,
+) -> dict[str, Any]:
+    """Run the repository's test suite against generated code.
+
+    This is the quality gate for code generation. The agent generates code,
+    then calls this tool to verify it passes the original tests.
+
+    Args:
+        repo_path: Path to the repository with generated code + tests.
+        test_command: Custom test command. Defaults to pytest.
+
+    Returns:
+        Dict with: passed (bool), pass_rate (float), total_tests (int),
+        passed_tests (int), failures (list of failure descriptions).
+    """
+    path = Path(repo_path)
+    if not path.exists():
+        return {"error": f"Path does not exist: {repo_path}"}
+
+    try:
+        if test_command:
+            cmd = test_command.split()
+        else:
+            cmd = [sys.executable, "-m", "pytest", str(path), "-v", "--tb=short", "-q"]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=120,
+            cwd=str(path),
+        )
+
+        # Parse pytest output
+        output = result.stdout + result.stderr
+        parsed = _parse_pytest_output(output, result.returncode)
+
+        try:
+            from opencode_arch.telemetry.collector import drain_and_store
+            drain_and_store(tool="architect_generate", repo=path.name)
+        except Exception:
+            pass
+
+        return parsed
+
+    except subprocess.TimeoutExpired:
+        return {"error": "Test execution timed out (120s)", "passed": False, "pass_rate": 0.0, "total_tests": 0}
+    except Exception as e:
+        return {"error": f"Test execution failed: {e}", "passed": False, "pass_rate": 0.0, "total_tests": 0}
+
+
+def _parse_pytest_output(output: str, returncode: int) -> dict[str, Any]:
+    """Parse pytest output to extract pass/fail counts."""
+    total = 0
+    passed_count = 0
+    failures: list[str] = []
+
+    for line in output.split("\n"):
+        # Look for summary line: "5 passed, 2 failed in 0.5s"
+        if "passed" in line or "failed" in line or "error" in line:
+            parts = line.strip().split()
+            for i, part in enumerate(parts):
+                if part == "passed" and i > 0:
+                    try:
+                        passed_count = int(parts[i - 1])
+                    except ValueError:
+                        pass
+                elif part == "failed" and i > 0:
+                    try:
+                        total += int(parts[i - 1])
+                    except ValueError:
+                        pass
+
+        # Capture FAILED test names
+        if line.startswith("FAILED"):
+            failures.append(line.strip())
+
+    total += passed_count
+
+    if total == 0 and "no tests ran" in output.lower():
+        return {"passed": True, "pass_rate": 0.0, "total_tests": 0, "passed_tests": 0, "failures": []}
+
+    pass_rate = passed_count / total if total > 0 else 0.0
+
+    return {
+        "passed": returncode == 0,
+        "pass_rate": pass_rate,
+        "total_tests": total,
+        "passed_tests": passed_count,
+        "failures": failures,
+    }

opencode_arch/mcp/tools/group.py

@@ -0,0 +1,62 @@
+"""architect_group MCP tool — group repository modules into logical components."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+async def group_repository(repo_path: str, target_groups: int = 0) -> dict[str, Any]:
+    """Group repository modules into logical architecture components.
+
+    Uses multi-signal affinity (subdirectory, name-prefix, imports) to
+    cluster source files into coherent component groups. This provides
+    suggested component boundaries for architecture extraction.
+
+    Args:
+        repo_path: Absolute path to the repository root.
+        target_groups: Desired number of groups. 0 = auto-calculate.
+
+    Returns:
+        Dict with keys: groups, total_modules, total_groups, filtered_trivial.
+        Each group has: name, files, file_count, locked.
+        Returns {"error": "..."} on failure.
+    """
+    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.manifest.grouping import group_modules
+
+        manifest = generate_manifest(path)
+        target = target_groups if target_groups > 0 else None
+        groups = group_modules(
+            manifest.modules,
+            manifest.interfaces,
+            target_groups=target,
+        )
+
+        result_groups = []
+        for g in groups:
+            result_groups.append({
+                "name": g.name,
+                "files": g.modules,
+                "file_count": len(g.modules),
+                "primary_file": g.primary_file,
+            })
+
+        try:
+            from opencode_arch.telemetry.collector import drain_and_store
+            drain_and_store(tool="architect_group", repo=path.name)
+        except Exception:
+            pass
+
+        return {
+            "groups": result_groups,
+            "total_modules": len(manifest.modules),
+            "total_groups": len(groups),
+        }
+
+    except Exception as e:
+        return {"error": f"Grouping failed: {e}"}

opencode_arch/mcp/tools/ingest.py

@@ -0,0 +1,101 @@
+"""architect_ingest tool — accept a SourceGraph JSON for any language.
+
+Allows agents or external tools to submit dependency/export data for
+non-Python repos. Stores the graph and runs grouping + interface extraction.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+async def ingest_source_graph(
+    repo_path: str,
+    source_graph_json: str,
+) -> dict:
+    """Ingest a SourceGraph JSON and generate architecture components.
+
+    Args:
+        repo_path: Absolute path to the repository.
+        source_graph_json: JSON string with SourceGraph data.
+
+    Returns:
+        Dict with components, interfaces, and group info.
+    """
+    try:
+        from architecture_model.manifest.protocol import SourceGraph
+        from architecture_model.manifest.grouping import group_source_graph, auto_fblocks
+        from architecture_model.core.types import (
+            ArchitectureModel, Component, Entities, ModelMeta,
+        )
+        from architecture_model.orchestration.auto_enrich import extract_component_interfaces
+        from architecture_model.core.parser import save_model
+
+        project_root = Path(repo_path)
+
+        # Parse the source graph
+        data = json.loads(source_graph_json)
+        graph = SourceGraph.from_json(data)
+        graph.root = repo_path
+
+        # Group into components
+        groups = group_source_graph(graph)
+        if not groups:
+            return {"error": "No non-trivial source units found", "units": len(graph.units)}
+
+        # Create components from groups
+        components: list[Component] = []
+        for idx, group in enumerate(groups, 1):
+            components.append(Component(
+                id=f"COMP-{idx}",
+                name=group.name,
+                status="ACTIVE",
+                files=group.modules,
+            ))
+
+        # Build model
+        model = ArchitectureModel(
+            meta=ModelMeta(project=project_root.name, schema_version="1.3"),
+            entities=Entities(components=components),
+            relationships=[],
+        )
+
+        # Extract interface contracts
+        n_ifaces = extract_component_interfaces(model, graph)
+
+        # Enrich components from SourceGraph (signatures, symbols, contracts, patterns)
+        from architecture_model.orchestration.auto_enrich import enrich_from_source_graph
+        enrich_from_source_graph(model, graph)
+
+        # Generate F-block config
+        fblock_config = auto_fblocks(groups, threshold=3)
+
+        # Save the model
+        model_path = project_root / ".architecture-model-extracted.yaml"
+        save_model(model, model_path)
+
+        # Also save the source graph for later use
+        graph_path = project_root / ".architecture-models" / "source-graph.json"
+        graph_path.parent.mkdir(parents=True, exist_ok=True)
+        graph_path.write_text(json.dumps(graph.to_json(), indent=2))
+
+        return {
+            "stored": True,
+            "model_path": str(model_path),
+            "graph_path": str(graph_path),
+            "components": len(components),
+            "interfaces": n_ifaces,
+            "fblocks": len(fblock_config),
+            "units": len(graph.units),
+            "edges": len(graph.edges),
+            "language": graph.language,
+            "groups": [
+                {"name": g.name, "files": g.modules, "file_count": len(g.modules)}
+                for g in groups
+            ],
+        }
+
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON: {e}"}
+    except Exception as e:
+        return {"error": str(e)}

opencode_arch/mcp/tools/require.py

@@ -0,0 +1,77 @@
+"""Capture functional requirements against architecture components."""
+from __future__ import annotations
+
+import yaml
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+async def capture_requirement(
+    repo_path: str,
+    requirement: str,
+    component_id: str | None = None,
+    priority: str = "must",
+    context: str = "",
+) -> dict[str, Any]:
+    """Store a functional requirement linked to a component.
+    
+    Args:
+        repo_path: Repository root path
+        requirement: The requirement text
+        component_id: Component ID (e.g., "COMP-3"). If None, stored as unlinked.
+        priority: must | should | could (MoSCoW)
+        context: Additional context from conversation
+    
+    Returns:
+        {stored, requirement_id, component, total_requirements}
+    """
+    repo = Path(repo_path)
+    arch_dir = repo / ".architecture"
+    arch_dir.mkdir(parents=True, exist_ok=True)
+    req_path = arch_dir / "requirements.yaml"
+    
+    # Load existing
+    if req_path.exists():
+        data = yaml.safe_load(req_path.read_text()) or {}
+    else:
+        data = {}
+    
+    reqs = data.get("requirements", [])
+    
+    # Generate next ID
+    existing_ids = [r.get("id", "") for r in reqs]
+    max_num = 0
+    for rid in existing_ids:
+        if rid.startswith("REQ-"):
+            try:
+                max_num = max(max_num, int(rid[4:]))
+            except ValueError:
+                pass
+    next_id = f"REQ-{max_num + 1}"
+    
+    # Build requirement entry
+    entry = {
+        "id": next_id,
+        "text": requirement,
+        "priority": priority,
+        "status": "proposed",
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }
+    if component_id:
+        entry["component"] = component_id
+    if context:
+        entry["context"] = context
+    
+    reqs.append(entry)
+    data["requirements"] = reqs
+    
+    # Write back
+    req_path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False))
+    
+    return {
+        "stored": True,
+        "requirement_id": next_id,
+        "component": component_id or "unlinked",
+        "total_requirements": len(reqs),
+    }

opencode_arch/mcp/tools/scan.py

@@ -0,0 +1,53 @@
+"""architect_scan MCP tool — generate reality manifest via AST scanning."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+async def scan_repository(repo_path: str) -> dict[str, Any]:
+    """Scan a repository and generate its reality manifest.
+
+    Performs AST analysis on all source files to produce a ground-truth
+    inventory of modules, functions, classes, imports, and metrics.
+
+    Args:
+        repo_path: Absolute path to the repository root.
+
+    Returns:
+        Manifest dict with keys: generated_at, project_root, metrics,
+        functional_blocks, modules, interfaces.
+        Returns {"error": "..."} on failure.
+    """
+    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
+        manifest = generate_manifest(path)
+
+        # Include suggested component groupings
+        suggested = None
+        try:
+            from architecture_model.manifest.grouping import group_modules
+            groups = group_modules(manifest.modules, manifest.interfaces)
+            suggested = [
+                {"name": g.name, "files": g.modules, "file_count": len(g.modules)}
+                for g in groups
+            ]
+        except Exception:
+            pass
+
+        try:
+            from opencode_arch.telemetry.collector import drain_and_store
+            drain_and_store(tool="architect_scan", repo=path.name)
+        except Exception:
+            pass
+
+        result = manifest
+        if suggested and isinstance(result, dict):
+            result["suggested_components"] = suggested
+        return result
+    except Exception as e:
+        return {"error": f"Scan failed: {e}"}