opencode-arch 1.0.0__py3-none-any.whl

opencode_arch/cli/export_data.py

@@ -0,0 +1,133 @@
+"""Export training corpus from .architecture/ artifacts.
+
+Collects (model, manifest, metrics) triples from one or more repos
+and writes them as JSONL for LLM training.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+def run_export_data(
+    repos: list[str],
+    output: str = "corpus.jsonl",
+    include_telemetry: bool = False,
+) -> None:
+    """Export .architecture/ artifacts from repos to JSONL.
+
+    Each line is a JSON object with:
+      - repo: repository name
+      - model_yaml: raw YAML content of .architecture-model.yaml
+      - manifest: parsed manifest.json dict
+      - metrics: parsed metrics.json dict
+      - telemetry_records: (optional) list of telemetry DB records
+    """
+    records = []
+
+    for repo_str in repos:
+        repo = Path(repo_str).resolve()
+        if not repo.is_dir():
+            print(f"Warning: {repo} is not a directory, skipping", file=sys.stderr)
+            continue
+
+        model_path = repo / ".architecture-model.yaml"
+        arch_dir = repo / ".architecture"
+
+        if not model_path.exists() and not arch_dir.exists():
+            print(f"Warning: No .architecture-model.yaml or .architecture/ in {repo}, skipping",
+                  file=sys.stderr)
+            continue
+
+        record: dict = {"repo": repo.name}
+
+        # Model YAML (raw text for training)
+        if model_path.exists():
+            record["model_yaml"] = model_path.read_text()
+
+        # Manifest
+        manifest_path = arch_dir / "manifest.json" if arch_dir.exists() else None
+        if manifest_path and manifest_path.exists():
+            record["manifest"] = json.loads(manifest_path.read_text())
+
+        # Metrics
+        metrics_path = arch_dir / "metrics.json" if arch_dir.exists() else None
+        if metrics_path and metrics_path.exists():
+            record["metrics"] = json.loads(metrics_path.read_text())
+
+        # Sub-block artifacts
+        if arch_dir and arch_dir.exists():
+            blocks = {}
+            for block_dir in sorted(arch_dir.iterdir()):
+                if block_dir.is_dir():
+                    block = {}
+                    block_model = block_dir / ".architecture-model.yaml"
+                    if block_model.exists():
+                        block["model_yaml"] = block_model.read_text()
+                    block_manifest = block_dir / "manifest.json"
+                    if block_manifest.exists():
+                        block["manifest"] = json.loads(block_manifest.read_text())
+                    block_metrics = block_dir / "metrics.json"
+                    if block_metrics.exists():
+                        block["metrics"] = json.loads(block_metrics.read_text())
+                     if block:
+                        blocks[block_dir.name] = block
+            if blocks:
+                record["blocks"] = blocks
+
+        # Requirements
+        req_path = arch_dir / "requirements.yaml" if arch_dir.exists() else None
+        if req_path and req_path.exists():
+            try:
+                import yaml
+                req_data = yaml.safe_load(req_path.read_text()) or {}
+                record["requirements"] = req_data.get("requirements", [])
+            except Exception:
+                pass
+
+        # Feedback
+        feedback_path = arch_dir / "feedback.jsonl" if arch_dir.exists() else None
+        if feedback_path and feedback_path.exists():
+            try:
+                feedback_entries = []
+                for line in feedback_path.read_text().splitlines():
+                    if line.strip():
+                        feedback_entries.append(json.loads(line))
+                if feedback_entries:
+                    record["feedback"] = feedback_entries
+            except Exception:
+                pass
+
+        # Telemetry records (from SQLite DB)
+        if include_telemetry:
+            try:
+                from opencode_arch.telemetry.store import TelemetryStore
+                store = TelemetryStore()
+                all_records = store.query(repo=repo.name)
+                if all_records:
+                    record["telemetry_records"] = [
+                        r._asdict() if hasattr(r, '_asdict') else r
+                        for r in all_records
+                    ]
+            except Exception:
+                pass
+
+        records.append(record)
+
+    if not records:
+        print("No data found to export.", file=sys.stderr)
+        sys.exit(1)
+
+    # Write JSONL
+    output_path = Path(output)
+    with output_path.open("w") as f:
+        for record in records:
+            f.write(json.dumps(record, default=str) + "\n")
+
+    print(f"Exported {len(records)} repo(s) to {output_path}")
+    total_size = output_path.stat().st_size
+    if total_size > 1024 * 1024:
+        print(f"  Size: {total_size / 1024 / 1024:.1f} MB")
+    else:
+        print(f"  Size: {total_size / 1024:.1f} KB")

opencode_arch/cli/extract.py

@@ -0,0 +1,93 @@
+"""Extract command - full architecture extraction loop."""
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any
+
+from opencode_arch.runner.base import RunnerBackend
+from opencode_arch.cli.prompts import EXTRACT_PROMPT
+
+
+async def run_extract(
+    repo_path: str,
+    runner: RunnerBackend,
+    budget: int = 4000,
+    focus: str = "all",
+    target_score: int = 80,
+) -> dict[str, Any]:
+    """Run the full extraction loop.
+
+    1. Validates repo exists
+    2. Calls runner with extraction prompt
+    3. Parses YAML from output
+    4. Validates and stores via tool APIs
+    5. Returns metrics
+    """
+    path = Path(repo_path)
+    if not path.exists():
+        return {"success": False, "error": f"Path does not exist: {repo_path}"}
+
+    start_time = time.time()
+
+    prompt = EXTRACT_PROMPT.format(
+        repo_path=str(path.resolve()),
+        focus=focus,
+        budget=budget,
+        target_score=target_score,
+    )
+
+    result = await runner.run(prompt=prompt, repo_path=str(path))
+    elapsed = time.time() - start_time
+
+    if not result.success:
+        return {
+            "success": False,
+            "error": f"Runner failed: {result.output[:500]}",
+            "time_seconds": elapsed,
+        }
+
+    yaml_content = _extract_yaml_from_output(result.output)
+    if not yaml_content:
+        return {
+            "success": False,
+            "error": "No YAML model found in agent output",
+            "time_seconds": elapsed,
+        }
+
+    from opencode_arch.mcp.tools.extract import store_extraction
+    store_result = await store_extraction(
+        repo_path=str(path),
+        model_yaml=yaml_content,
+        context_tokens=budget,
+    )
+
+    return {
+        "success": store_result.get("stored", False),
+        "score": store_result.get("score", 0),
+        "tokens_used": budget,
+        "time_seconds": elapsed,
+        "iterations": 1,
+        "issues": store_result.get("issues", []),
+        "path": store_result.get("path", ""),
+    }
+
+
+def _extract_yaml_from_output(output: str) -> str | None:
+    """Extract YAML content from agent output (between ```yaml fences)."""
+    match = re.search(r"```ya?ml\s*\n(.*?)```", output, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+
+    match = re.search(r"```\s*\n(.*?)```", output, re.DOTALL)
+    if match:
+        content = match.group(1).strip()
+        if "meta:" in content or "entities:" in content:
+            return content
+
+    match = re.search(r"(meta:\s*\n.*?)(?:\n\n|\Z)", output, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+
+    return None

opencode_arch/cli/gap_analyzer.py

@@ -0,0 +1,107 @@
+"""Gap analyzer — maps test failure output to actionable feedback for the next iteration."""
+from __future__ import annotations
+
+import re
+
+
+# Common failure patterns and their interpretations
+_PATTERNS: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"NameError: name '(\w+)' is not defined"),
+     "Missing symbol: {0}"),
+    (re.compile(r"ImportError: cannot import name '(\w+)' from '(\w+)'"),
+     "Missing export: '{0}' not available in module '{1}'"),
+    (re.compile(r"ModuleNotFoundError: No module named '(\S+)'"),
+     "Missing module: {0}"),
+    (re.compile(r"AttributeError: (?:type object |)'(\w+)' (?:object )?has no attribute '(\w+)'"),
+     "Missing attribute '{1}' on '{0}'"),
+    (re.compile(r"AttributeError: module '(\w+)' has no attribute '(\w+)'"),
+     "Missing attribute '{1}' on module '{0}'"),
+    (re.compile(r"AssertionError: (.+?) != (.+)"),
+     "Wrong value: got {0}, expected {1}"),
+    (re.compile(r"AssertionError: (False|0) is not true"),
+     "Assertion failed: expression evaluated to False"),
+    (re.compile(r"TypeError: (\w+)\(\) (?:takes|got|missing) (.+)"),
+     "Signature mismatch for {0}: {1}"),
+    (re.compile(r"TypeError: (\w+)\(\) (.+)"),
+     "Type error in {0}: {1}"),
+    (re.compile(r"KeyError: '(\w+)'"),
+     "Missing key: '{0}'"),
+    (re.compile(r"ValueError: (.+)"),
+     "Value error: {0}"),
+    (re.compile(r"IndentationError: (.+)"),
+     "Syntax issue: indentation error — {0}"),
+    (re.compile(r"SyntaxError: (.+)"),
+     "Syntax error: {0}"),
+]
+
+
+def analyze_gaps(test_output: str, model_context: str = "") -> str:
+    """Parse test failure output and produce enrichment feedback.
+
+    Maps common failure patterns to structured feedback for the next
+    iteration prompt. Returns a formatted string summarizing what needs
+    fixing.
+
+    Args:
+        test_output: Raw pytest output (stdout + stderr).
+        model_context: Optional architecture model context for cross-referencing.
+
+    Returns:
+        Formatted feedback string with identified gaps.
+    """
+    if not test_output.strip():
+        return "No test output to analyze."
+
+    gaps: list[str] = []
+    seen: set[str] = set()
+
+    for line in test_output.splitlines():
+        line_stripped = line.strip()
+        for pattern, template in _PATTERNS:
+            m = pattern.search(line_stripped)
+            if m:
+                msg = template.format(*m.groups())
+                if msg not in seen:
+                    seen.add(msg)
+                    gaps.append(f"- {msg}")
+                break  # One pattern per line
+
+    # Extract FAILED test names for additional context
+    failed_tests = _extract_failed_tests(test_output)
+    if failed_tests:
+        gaps.append("")
+        gaps.append("Failed tests:")
+        for t in failed_tests[:20]:  # Cap at 20
+            gaps.append(f"  - {t}")
+
+    if not gaps:
+        # Generic fallback
+        return _generic_feedback(test_output)
+
+    return "\n".join(gaps)
+
+
+def _extract_failed_tests(output: str) -> list[str]:
+    """Extract FAILED test names from pytest output."""
+    failed: list[str] = []
+    for line in output.splitlines():
+        # pytest FAILED line: "FAILED test_file.py::test_name - ..."
+        if line.startswith("FAILED "):
+            parts = line.split(" - ", 1)
+            name = parts[0].replace("FAILED ", "").strip()
+            failed.append(name)
+        # Short test summary: "FAILED test_x.py::test_y"
+        elif "FAILED" in line and "::" in line:
+            match = re.search(r"FAILED\s+([\w/.]+::\w+)", line)
+            if match:
+                failed.append(match.group(1))
+    return list(dict.fromkeys(failed))  # dedupe preserving order
+
+
+def _generic_feedback(output: str) -> str:
+    """Produce generic feedback when no specific patterns match."""
+    # Look for the short summary line
+    for line in output.splitlines():
+        if "failed" in line.lower() and ("passed" in line.lower() or "error" in line.lower()):
+            return f"Tests failed but no specific error patterns matched.\nSummary: {line.strip()}\nReview the test assertions and ensure all expected values match."
+    return "Tests failed. Review the output and ensure all assertions pass."

opencode_arch/cli/generate.py

@@ -0,0 +1,68 @@
+"""Generate command - test-guided code generation loop."""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from opencode_arch.runner.base import RunnerBackend
+from opencode_arch.cli.prompts import GENERATE_PROMPT
+
+
+async def run_generate(
+    repo_path: str,
+    runner: RunnerBackend,
+    max_iter: int = 3,
+    test_command: str | None = None,
+) -> dict[str, Any]:
+    """Run the test-guided code generation loop."""
+    path = Path(repo_path)
+    if not path.exists():
+        return {"error": f"Path does not exist: {repo_path}", "passed": False}
+
+    start_time = time.time()
+    iterations = 0
+    last_test_result = {}
+
+    from opencode_arch.mcp.tools.generate import run_tests_on_generated_code
+
+    for i in range(max_iter):
+        iterations = i + 1
+
+        prompt = GENERATE_PROMPT.format(repo_path=str(path.resolve()), max_iter=max_iter)
+        if i > 0 and last_test_result.get("failures"):
+            failures_str = "\n".join(last_test_result["failures"][:10])
+            prompt += f"\n\nPrevious failures (iteration {i}):\n{failures_str}\nFix these issues."
+
+        await runner.run(prompt=prompt, repo_path=str(path))
+
+        test_result = await run_tests_on_generated_code(repo_path=str(path), test_command=test_command)
+        last_test_result = test_result
+
+        if test_result.get("passed") or test_result.get("pass_rate", 0) == 1.0:
+            break
+        if test_result.get("total_tests", 0) == 0:
+            break
+
+    elapsed = time.time() - start_time
+
+    try:
+        from opencode_arch.telemetry.store import TelemetryStore
+        store = TelemetryStore()
+        store.record(
+            tool="architect_generate", repo=path.name,
+            context_tokens=0, output_quality=int(last_test_result.get("pass_rate", 0) * 100),
+            iterations=iterations,
+        )
+    except Exception:
+        pass
+
+    return {
+        "passed": last_test_result.get("passed", False),
+        "pass_rate": last_test_result.get("pass_rate", 0.0),
+        "total_tests": last_test_result.get("total_tests", 0),
+        "passed_tests": last_test_result.get("passed_tests", 0),
+        "failures": last_test_result.get("failures", []),
+        "iterations": iterations,
+        "time_seconds": elapsed,
+    }

opencode_arch/cli/launch.py

@@ -0,0 +1,264 @@
+"""Interactive launch — architecture-aware development session.
+
+Pre-flight: scan, slice, persist, update CONTEXT.md, then exec opencode.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Markers for the architecture section in CONTEXT.md
+CONTEXT_START = "<!-- opencode-arch:start -->"
+CONTEXT_END = "<!-- opencode-arch:end -->"
+
+# Minimal opencode.json template
+OPENCODE_JSON_TEMPLATE = {
+    "name": "opencode-arch",
+    "version": "1.0.0",
+    "description": "Architecture-aware development tools",
+    "mcp": {
+        "command": "python",
+        "args": ["-m", "opencode_arch.mcp.server"],
+        "tools": [
+            {"name": "architect_scan", "description": "Scan repository AST to generate manifest"},
+            {"name": "architect_slice", "description": "Get token-compressed architecture context"},
+            {"name": "architect_validate", "description": "Validate architecture model (0-100)"},
+            {"name": "architect_extract", "description": "Store validated architecture model"},
+            {"name": "architect_generate", "description": "Run tests on generated code"},
+            {"name": "architect_group", "description": "Auto-group modules into components"},
+            {"name": "architect_check", "description": "Verify model representativeness"},
+            {"name": "architect_require", "description": "Capture functional requirement"},
+            {"name": "architect_feedback", "description": "Record feedback for training"},
+        ],
+    },
+}
+
+
+def run_launch(repo_path: str | None = None, skip_exec: bool = False) -> dict:
+    """Run pre-flight checks and launch interactive OpenCode session.
+    
+    Args:
+        repo_path: Target repository (default: current directory)
+        skip_exec: If True, do pre-flight only without exec (for testing)
+    
+    Returns:
+        Pre-flight results dict (only if skip_exec=True)
+    """
+    repo = Path(repo_path or ".").resolve()
+    if not repo.is_dir():
+        print(f"Error: {repo} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    start = time.time()
+    results = {"repo": str(repo), "steps": []}
+
+    # Step 1: Scan
+    manifest = None
+    try:
+        from architecture_model.manifest.generator import generate_manifest
+        manifest = generate_manifest(repo)
+        results["modules"] = len(manifest.modules)
+        results["interfaces"] = len(manifest.interfaces)
+        results["steps"].append("scan")
+        _status(f"Scanned {len(manifest.modules)} modules")
+    except Exception as exc:
+        _warn(f"Scan skipped: {exc}")
+
+    # Step 2: Load or bootstrap model
+    model = None
+    model_path = repo / ".architecture-model.yaml"
+    try:
+        if model_path.exists():
+            from architecture_model.core.parser import load_model
+            model = load_model(model_path)
+            _status(f"Model loaded: {len(model.entities.components)} components")
+        elif manifest:
+            from architecture_model.manifest.grouping import create_components_from_manifest
+            from architecture_model.core.types import ArchitectureModel, Entities, ModelMeta
+            from architecture_model.orchestration.auto_enrich import enrich_from_manifest
+            
+            components = create_components_from_manifest(manifest)
+            model = ArchitectureModel(
+                meta=ModelMeta(project=repo.name, schema_version="1.3"),
+                entities=Entities(components=components),
+                relationships=[],
+            )
+            enrich_from_manifest(model, manifest)
+            _status(f"Bootstrapped model: {len(components)} components")
+        results["steps"].append("model")
+    except Exception as exc:
+        _warn(f"Model load/bootstrap skipped: {exc}")
+
+    # Step 3: Slice context
+    context_slice = ""
+    if model and manifest:
+        try:
+            from architecture_model.integrations.llm_context import format_model_context
+            from opencode_arch.mcp.tools.slice import compute_adaptive_budget
+            adaptive_budget = compute_adaptive_budget(len(manifest.modules))
+            context_slice = format_model_context(model, budget=adaptive_budget, detail="standard")
+            results["context_tokens"] = len(context_slice) // 4  # rough estimate
+            results["steps"].append("slice")
+        except Exception:
+            # Fallback: build a compact summary
+            try:
+                comps = model.entities.components
+                lines = [f"## Architecture: {len(comps)} components"]
+                for c in comps[:20]:
+                    files = ", ".join(getattr(c, 'files', [])[:3])
+                    lines.append(f"- **{c.name}** ({c.id}): {files}")
+                context_slice = "\n".join(lines)
+                results["steps"].append("slice_fallback")
+            except Exception:
+                pass
+
+    # Step 4: Compute representativeness
+    rep = None
+    if model and manifest:
+        try:
+            from architecture_model.core.representativeness import compute_representativeness
+            rep = compute_representativeness(model, manifest.modules, manifest.interfaces)
+            results["representativeness"] = rep.overall
+            results["steps"].append("repr")
+            _status(f"Representativeness: {rep.overall:.1f}%")
+        except Exception as exc:
+            _warn(f"Representativeness skipped: {exc}")
+
+    # Step 5: Persist to .architecture/
+    if model and manifest:
+        try:
+            from architecture_model.persistence.store import save_project
+            save_project(repo, model, manifest, representativeness=rep)
+            results["steps"].append("persist")
+        except Exception as exc:
+            _warn(f"Persistence skipped: {exc}")
+
+    # Step 6: Update CONTEXT.md
+    _update_context_md(repo, model, context_slice, rep, manifest)
+    results["steps"].append("context_md")
+
+    # Step 7: Ensure opencode.json
+    _ensure_opencode_json(repo)
+    results["steps"].append("opencode_json")
+
+    elapsed = time.time() - start
+    results["elapsed_s"] = round(elapsed, 2)
+    _status(f"Ready ({elapsed:.1f}s)")
+
+    if skip_exec:
+        return results
+
+    # Step 8: Exec opencode
+    opencode_bin = shutil.which("opencode")
+    if not opencode_bin:
+        print("Error: 'opencode' not found in PATH. Install OpenCode first.", file=sys.stderr)
+        print("  See: https://opencode.ai", file=sys.stderr)
+        sys.exit(1)
+
+    os.chdir(repo)
+    os.execvp(opencode_bin, [opencode_bin])
+
+
+def _update_context_md(
+    repo: Path,
+    model,
+    context_slice: str,
+    rep,
+    manifest,
+) -> None:
+    """Update CONTEXT.md with architecture section between markers."""
+    context_path = repo / "CONTEXT.md"
+    
+    # Build architecture section
+    lines = [CONTEXT_START]
+    lines.append("# Architecture (auto-managed by opencode-arch)")
+    lines.append("")
+    
+    if model:
+        comp_count = len(model.entities.components)
+        rel_count = len(model.relationships) if model.relationships else 0
+        lines.append(f"**Model:** {comp_count} components | {rel_count} relationships")
+    
+    if rep:
+        lines.append(f"**Score:** {rep.overall:.1f}% "
+                     f"(FC={rep.file_coverage:.0f}% RA={rep.relationship_accuracy:.0f}% "
+                     f"BC={rep.boundary_coherence:.0f}% BV={rep.behavioral_coverage:.0f}%)")
+    
+    if manifest:
+        lines.append(f"**Codebase:** {len(manifest.modules)} modules | "
+                     f"{len(manifest.interfaces)} import edges")
+    
+    # Requirements count
+    req_path = repo / ".architecture" / "requirements.yaml"
+    if req_path.exists():
+        try:
+            import yaml
+            reqs = yaml.safe_load(req_path.read_text()) or {}
+            req_list = reqs.get("requirements", [])
+            lines.append(f"**Requirements:** {len(req_list)} tracked")
+        except Exception:
+            pass
+    
+    lines.append("")
+    
+    if context_slice:
+        lines.append("## Component Map")
+        lines.append("")
+        lines.append(context_slice)
+        lines.append("")
+    
+    lines.append("## Development Guidelines")
+    lines.append("")
+    lines.append("- Use `architect_slice` for focused context on specific components")
+    lines.append("- Use `architect_check` after significant changes to verify model accuracy")
+    lines.append("- Use `architect_require` to capture functional requirements from discussion")
+    lines.append("- Use `architect_feedback` to record corrections or rate tool quality")
+    lines.append("- Components are auto-grouped by import affinity — respect boundaries")
+    lines.append(CONTEXT_END)
+    
+    arch_section = "\n".join(lines) + "\n"
+    
+    # Read existing CONTEXT.md
+    if context_path.exists():
+        content = context_path.read_text()
+        # Replace existing section or append
+        if CONTEXT_START in content:
+            # Replace between markers
+            before = content[:content.index(CONTEXT_START)]
+            after_marker = content[content.index(CONTEXT_END) + len(CONTEXT_END):]
+            content = before + arch_section + after_marker
+        else:
+            # Append at end
+            if not content.endswith("\n"):
+                content += "\n"
+            content += "\n" + arch_section
+    else:
+        content = arch_section
+    
+    context_path.write_text(content)
+
+
+def _ensure_opencode_json(repo: Path) -> None:
+    """Ensure opencode.json exists in repo for MCP tool registration."""
+    opencode_json_path = repo / "opencode.json"
+    if not opencode_json_path.exists():
+        opencode_json_path.write_text(
+            json.dumps(OPENCODE_JSON_TEMPLATE, indent=2) + "\n"
+        )
+
+
+def _status(msg: str) -> None:
+    """Print a status line."""
+    print(f"  \u2713 {msg}", file=sys.stderr)
+
+
+def _warn(msg: str) -> None:
+    """Print a warning line."""
+    print(f"  ! {msg}", file=sys.stderr)