opencode-arch 1.0.0__py3-none-any.whl

opencode_arch/context/pipeline_bridge.py

@@ -0,0 +1,201 @@
+"""
+Pipeline Bridge: Connect the Architecture Model to the artifact generation pipeline.
+
+This module provides the interface between:
+- The existing _pipeline_manifest.py (code-grounded reality)
+- The architecture model (structural + semantic truth)
+- The artifact generation pipeline (_pipeline_artifacts.py, _pipeline_templates.py)
+
+It replaces raw manifest slices with model-enriched context for LLM artifact generation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from architecture_model.core.parser import load_model, save_model
+from architecture_model.core.merger import merge_manifest
+from architecture_model.core.slicer import slice_by_fblock, slice_for_artifact
+from architecture_model.core.validator import validate_model
+from architecture_model.core.types import ArchitectureModel
+from opencode_arch.context.formatter import (
+    format_model_context,
+    format_fblock_context,
+    format_artifact_context,
+)
+
+
+# ---------------------------------------------------------------------------
+# Configuration — loaded from .architecture-model.yaml
+# ---------------------------------------------------------------------------
+
+
+def _get_default_paths(project_root: Path) -> tuple[Path, Path, Path]:
+    """Resolve output paths from config."""
+    try:
+        from architecture_model.config.loader import get_config
+
+        config = get_config(project_root)
+        resolved = config.resolved_output()
+        return resolved.model, resolved.manifest, resolved.artifacts
+    except Exception:
+        # Fallback for backward compatibility
+        name = project_root.name
+        return (
+            project_root / f"output/{name}/architecture-model.yaml",
+            project_root / f"output/{name}/reality-manifest.json",
+            project_root / f"output/{name}/artifacts/stage2",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def get_model(
+    project_root: str | Path,
+    force_refresh: bool = False,
+) -> ArchitectureModel:
+    """
+    Load or generate the architecture model for the project.
+
+    If the model YAML exists and isn't stale, loads it.
+    If missing or force_refresh=True, re-extracts from artifacts and merges manifest.
+
+    Args:
+        project_root: Path to project root directory.
+        force_refresh: Force re-extraction even if model exists.
+
+    Returns:
+        Loaded and validated ArchitectureModel.
+    """
+    project_root = Path(project_root)
+    model_path, manifest_path, artifact_dir = _get_default_paths(project_root)
+
+    if model_path.exists() and not force_refresh:
+        return load_model(model_path)
+
+    # Re-extract
+    from opencode_arch.extract.from_artifacts import extract_from_artifacts
+
+    model = extract_from_artifacts(artifact_dir)
+
+    if manifest_path.exists():
+        merge_manifest(model, manifest_path)
+
+    save_model(model, model_path)
+    return model
+
+
+def get_artifact_context(
+    project_root: str | Path,
+    artifact_name: str,
+    max_tokens: int = 3000,
+) -> str:
+    """
+    Get model-based context for artifact generation/regeneration.
+
+    This REPLACES the raw manifest slice with structured architectural context.
+    The returned string is injected into the LLM system prompt alongside the
+    manifest metrics (which are kept for ground-truth file counts).
+
+    Args:
+        project_root: Project root path.
+        artifact_name: Which artifact needs context.
+        max_tokens: Token budget for the context block.
+
+    Returns:
+        Formatted model context string for LLM prompt injection.
+    """
+    model = get_model(project_root)
+    return format_artifact_context(model, artifact_name, max_tokens=max_tokens)
+
+
+def get_fblock_context(
+    project_root: str | Path,
+    f_block: str,
+    max_tokens: int = 2000,
+) -> str:
+    """
+    Get model-based context for a single F-block (for section regeneration).
+
+    Args:
+        project_root: Project root path.
+        f_block: F-block ID (e.g., "F3").
+        max_tokens: Token budget.
+
+    Returns:
+        Formatted F-block context string.
+    """
+    model = get_model(project_root)
+    return format_fblock_context(model, f_block, max_tokens=max_tokens, project_root=Path(project_root))
+
+
+def get_model_summary(project_root: str | Path) -> dict[str, Any]:
+    """
+    Get a summary dict of the model for injection into pipeline metadata.
+
+    Returns dict with entity_count, relationship_count, validation score, etc.
+    """
+    model = get_model(project_root)
+    result = validate_model(model)
+
+    return {
+        "entity_count": model.entity_count,
+        "relationship_count": model.relationship_count,
+        "validation_score": result.score,
+        "entities": {
+            "actors": len(model.entities.actors),
+            "capabilities": len(model.entities.capabilities),
+            "behaviors": len(model.entities.behaviors),
+            "interfaces": len(model.entities.interfaces),
+            "constraints": len(model.entities.constraints),
+            "layers": len(model.entities.layers),
+            "components": len(model.entities.components),
+        },
+        "schema_version": model.meta.schema_version,
+        "manifest_hash": model.meta.manifest_hash,
+    }
+
+
+def enrich_manifest_slice(
+    manifest_slice: str,
+    project_root: str | Path,
+    artifact_name: str,
+    max_model_tokens: int = 2000,
+) -> str:
+    """
+    Enrich an existing manifest slice with architecture model context.
+
+    This is the BACKWARD-COMPATIBLE integration point. The existing pipeline
+    generates manifest slices via _pipeline_manifest.py — this function
+    prepends model context to that slice, giving the LLM both:
+    1. Architectural structure (from model) — WHAT things mean, how they relate
+    2. Code-grounded metrics (from manifest) — WHAT actually exists
+
+    Args:
+        manifest_slice: Raw manifest slice text (from _pipeline_manifest.py).
+        project_root: Project root path.
+        artifact_name: Which artifact this slice is for.
+        max_model_tokens: Token budget for model context portion.
+
+    Returns:
+        Combined context: model context + separator + manifest metrics.
+    """
+    try:
+        model_context = get_artifact_context(
+            project_root, artifact_name, max_tokens=max_model_tokens
+        )
+    except Exception:
+        # If model loading fails, fall back to manifest-only
+        return manifest_slice
+
+    return (
+        f"=== ARCHITECTURE MODEL CONTEXT ===\n"
+        f"{model_context}\n"
+        f"\n"
+        f"=== CODE-GROUNDED MANIFEST (verified metrics) ===\n"
+        f"{manifest_slice}"
+    )

opencode_arch/extract/__init__.py

@@ -0,0 +1,8 @@
+"""
+Extract architecture models from source code or Tier 1 artifacts.
+"""
+
+from .from_code import extract_from_code
+from .from_artifacts import extract_from_artifacts
+
+__all__ = ["extract_from_code", "extract_from_artifacts"]

opencode_arch/extract/constraint_detector.py

@@ -0,0 +1,398 @@
+"""
+Parse project configuration files to derive technical and organizational constraints.
+
+Scans pyproject.toml, Dockerfile, .env templates, CI config, and setup.cfg to
+automatically detect constraints such as Python version requirements, framework
+choices, runtime images, exposed ports, and CI/CD platform.
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from pathlib import Path
+
+from architecture_model.core.types import Constraint, ConstraintType, Status
+
+
+# ---------------------------------------------------------------------------
+# Key frameworks to detect in dependencies
+# ---------------------------------------------------------------------------
+
+_KEY_FRAMEWORKS: set[str] = {
+    "fastapi",
+    "flask",
+    "django",
+    "starlette",
+    "aiohttp",
+    "tornado",
+    "sqlalchemy",
+    "asyncpg",
+    "psycopg2",
+    "pymongo",
+    "redis",
+    "celery",
+}
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def detect_constraints(project_root: Path) -> list[Constraint]:
+    """Scan project configuration files for derivable constraints.
+
+    Args:
+        project_root: Root directory of the project.
+
+    Returns:
+        List of Constraint entities derived from config files.
+    """
+    constraints: list[Constraint] = []
+    tc_counter = 0
+    oc_counter = 0
+
+    # --- pyproject.toml ---
+    tc_counter, oc_counter = _parse_pyproject(
+        project_root, constraints, tc_counter, oc_counter
+    )
+
+    # --- Dockerfile ---
+    tc_counter, oc_counter = _parse_dockerfile(
+        project_root, constraints, tc_counter, oc_counter
+    )
+
+    # --- .env.example / .env.template ---
+    oc_counter = _parse_env_template(project_root, constraints, oc_counter)
+
+    # --- CI/CD config ---
+    oc_counter = _parse_ci_config(project_root, constraints, oc_counter)
+
+    # --- setup.cfg fallback for python_requires ---
+    tc_counter, oc_counter = _parse_setup_cfg(
+        project_root, constraints, tc_counter, oc_counter
+    )
+
+    return constraints
+
+
+# ---------------------------------------------------------------------------
+# pyproject.toml parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_pyproject(
+    project_root: Path,
+    constraints: list[Constraint],
+    tc_counter: int,
+    oc_counter: int,
+) -> tuple[int, int]:
+    """Extract constraints from pyproject.toml."""
+    pyproject_path = project_root / "pyproject.toml"
+    if not pyproject_path.is_file():
+        return tc_counter, oc_counter
+
+    try:
+        data = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError):
+        return tc_counter, oc_counter
+
+    # requires-python
+    requires_python = data.get("project", {}).get("requires-python", "")
+    if requires_python:
+        tc_counter += 1
+        constraints.append(
+            Constraint(
+                id=f"TC-{tc_counter:02d}",
+                name=f"Python {requires_python}",
+                status=Status.ACTIVE,
+                description=f"Project requires Python {requires_python}",
+                type=ConstraintType.TECHNOLOGY,
+                metric="python_version",
+                threshold=requires_python,
+                rationale="Detected from pyproject.toml requires-python",
+            )
+        )
+
+    # dependencies (key frameworks)
+    deps = _collect_dependencies(data)
+    for dep_name in sorted(deps):
+        normalized = _normalize_dep_name(dep_name)
+        if normalized in _KEY_FRAMEWORKS:
+            tc_counter += 1
+            constraints.append(
+                Constraint(
+                    id=f"TC-{tc_counter:02d}",
+                    name=f"Dependency: {normalized}",
+                    status=Status.ACTIVE,
+                    description=f"Project depends on {normalized}",
+                    tags=[normalized],
+                    type=ConstraintType.TECHNOLOGY,
+                    rationale="Detected from pyproject.toml dependencies",
+                )
+            )
+
+    return tc_counter, oc_counter
+
+
+def _collect_dependencies(data: dict) -> list[str]:
+    """Collect dependency names from pyproject.toml data.
+
+    Checks [project.dependencies] and [tool.poetry.dependencies].
+    """
+    deps: list[str] = []
+
+    # PEP 621 style
+    project_deps = data.get("project", {}).get("dependencies", [])
+    for dep in project_deps:
+        # Parse requirement specifier: "fastapi>=0.100" -> "fastapi"
+        name = re.split(r"[>=<!\[;@\s]", dep, maxsplit=1)[0].strip()
+        if name:
+            deps.append(name)
+
+    # Poetry style
+    poetry_deps = (
+        data.get("tool", {}).get("poetry", {}).get("dependencies", {})
+    )
+    if isinstance(poetry_deps, dict):
+        for name in poetry_deps:
+            if name.lower() != "python":
+                deps.append(name)
+
+    return deps
+
+
+def _normalize_dep_name(name: str) -> str:
+    """Normalize a dependency name for comparison (lowercase, hyphens to underscores removed)."""
+    return re.sub(r"[-_.]", "", name.lower())
+
+
+# ---------------------------------------------------------------------------
+# Dockerfile parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_dockerfile(
+    project_root: Path,
+    constraints: list[Constraint],
+    tc_counter: int,
+    oc_counter: int,
+) -> tuple[int, int]:
+    """Extract constraints from Dockerfile."""
+    dockerfile_path = project_root / "Dockerfile"
+    if not dockerfile_path.is_file():
+        return tc_counter, oc_counter
+
+    try:
+        content = dockerfile_path.read_text(encoding="utf-8")
+    except OSError:
+        return tc_counter, oc_counter
+
+    # FROM line (first non-comment FROM)
+    from_match = re.search(
+        r"^\s*FROM\s+(\S+)", content, re.MULTILINE | re.IGNORECASE
+    )
+    if from_match:
+        base_image = from_match.group(1)
+        tc_counter += 1
+        constraints.append(
+            Constraint(
+                id=f"TC-{tc_counter:02d}",
+                name=f"Base image: {base_image}",
+                status=Status.ACTIVE,
+                description=f"Container runtime uses base image {base_image}",
+                type=ConstraintType.TECHNOLOGY,
+                metric="base_image",
+                threshold=base_image,
+                rationale="Detected from Dockerfile FROM directive",
+            )
+        )
+
+    # EXPOSE lines
+    expose_matches = re.findall(
+        r"^\s*EXPOSE\s+(.+)$", content, re.MULTILINE | re.IGNORECASE
+    )
+    ports: list[str] = []
+    for match in expose_matches:
+        # EXPOSE can have multiple ports: "EXPOSE 8000 8080"
+        found = re.findall(r"\d+", match)
+        ports.extend(found)
+
+    if ports:
+        tc_counter += 1
+        port_str = ", ".join(ports)
+        constraints.append(
+            Constraint(
+                id=f"TC-{tc_counter:02d}",
+                name=f"Exposed ports: {port_str}",
+                status=Status.ACTIVE,
+                description=f"Container exposes network port(s): {port_str}",
+                tags=["networking"],
+                type=ConstraintType.TECHNOLOGY,
+                metric="exposed_ports",
+                threshold=port_str,
+                rationale="Detected from Dockerfile EXPOSE directive",
+            )
+        )
+
+    return tc_counter, oc_counter
+
+
+# ---------------------------------------------------------------------------
+# .env template parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_env_template(
+    project_root: Path,
+    constraints: list[Constraint],
+    oc_counter: int,
+) -> int:
+    """Count required env vars from .env.example or .env.template."""
+    env_path: Path | None = None
+    for name in (".env.example", ".env.template"):
+        candidate = project_root / name
+        if candidate.is_file():
+            env_path = candidate
+            break
+
+    if env_path is None:
+        return oc_counter
+
+    try:
+        content = env_path.read_text(encoding="utf-8")
+    except OSError:
+        return oc_counter
+
+    # Count non-empty, non-comment lines that look like KEY=...
+    var_count = 0
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped and not stripped.startswith("#"):
+            if re.match(r"^[A-Za-z_][A-Za-z0-9_]*\s*=", stripped):
+                var_count += 1
+
+    if var_count > 0:
+        oc_counter += 1
+        constraints.append(
+            Constraint(
+                id=f"OC-{oc_counter:02d}",
+                name=f"Environment configuration ({var_count} vars)",
+                status=Status.ACTIVE,
+                description=(
+                    f"Application requires {var_count} environment variable(s) "
+                    f"as defined in {env_path.name}"
+                ),
+                tags=["configuration"],
+                type=ConstraintType.OPERATIONAL,
+                metric="env_var_count",
+                threshold=str(var_count),
+                rationale=f"Detected from {env_path.name}",
+            )
+        )
+
+    return oc_counter
+
+
+# ---------------------------------------------------------------------------
+# CI/CD config parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_ci_config(
+    project_root: Path,
+    constraints: list[Constraint],
+    oc_counter: int,
+) -> int:
+    """Detect CI/CD platform from workflow config files."""
+    # GitHub Actions
+    workflows_dir = project_root / ".github" / "workflows"
+    if workflows_dir.is_dir():
+        yml_files = list(workflows_dir.glob("*.yml")) + list(
+            workflows_dir.glob("*.yaml")
+        )
+        if yml_files:
+            oc_counter += 1
+            constraints.append(
+                Constraint(
+                    id=f"OC-{oc_counter:02d}",
+                    name="CI/CD: GitHub Actions",
+                    status=Status.ACTIVE,
+                    description="Project uses GitHub Actions for CI/CD",
+                    tags=["ci-cd", "github"],
+                    type=ConstraintType.OPERATIONAL,
+                    rationale="Detected from .github/workflows/*.yml",
+                )
+            )
+            return oc_counter
+
+    # GitLab CI
+    gitlab_ci = project_root / ".gitlab-ci.yml"
+    if gitlab_ci.is_file():
+        oc_counter += 1
+        constraints.append(
+            Constraint(
+                id=f"OC-{oc_counter:02d}",
+                name="CI/CD: GitLab CI",
+                status=Status.ACTIVE,
+                description="Project uses GitLab CI/CD",
+                tags=["ci-cd", "gitlab"],
+                type=ConstraintType.OPERATIONAL,
+                rationale="Detected from .gitlab-ci.yml",
+            )
+        )
+
+    return oc_counter
+
+
+# ---------------------------------------------------------------------------
+# setup.cfg fallback
+# ---------------------------------------------------------------------------
+
+
+def _parse_setup_cfg(
+    project_root: Path,
+    constraints: list[Constraint],
+    tc_counter: int,
+    oc_counter: int,
+) -> tuple[int, int]:
+    """Extract python_requires from setup.cfg as fallback.
+
+    Only adds a constraint if no Python version constraint was already found
+    from pyproject.toml.
+    """
+    # Skip if we already have a python version constraint
+    if any(c.metric == "python_version" for c in constraints):
+        return tc_counter, oc_counter
+
+    setup_cfg_path = project_root / "setup.cfg"
+    if not setup_cfg_path.is_file():
+        return tc_counter, oc_counter
+
+    try:
+        content = setup_cfg_path.read_text(encoding="utf-8")
+    except OSError:
+        return tc_counter, oc_counter
+
+    # Look for python_requires under [options]
+    match = re.search(
+        r"^\s*python_requires\s*=\s*(.+)$", content, re.MULTILINE
+    )
+    if match:
+        requires = match.group(1).strip()
+        tc_counter += 1
+        constraints.append(
+            Constraint(
+                id=f"TC-{tc_counter:02d}",
+                name=f"Python {requires}",
+                status=Status.ACTIVE,
+                description=f"Project requires Python {requires}",
+                type=ConstraintType.TECHNOLOGY,
+                metric="python_version",
+                threshold=requires,
+                rationale="Detected from setup.cfg python_requires",
+            )
+        )
+
+    return tc_counter, oc_counter