devflow-engine 1.0.0__py3-none-any.whl

devflow_engine/implementation/green_gate.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from .test_runtime import (
+    infer_test_runtime_contract,
+    runtime_contract_cwd,
+    runtime_contract_env,
+)
+
+
+@dataclass(frozen=True)
+class GateResult:
+    ok: bool
+    stdout: str
+    stderr: str
+    returncode: int
+
+
+def _resolve_devflow_cmd(repo_root: Path) -> list[str]:
+    found = shutil.which("devflow")
+    if found:
+        return [found]
+    candidates = [
+        repo_root / ".venv" / "bin" / "devflow",
+        Path(sys.executable).parent / "devflow",
+        Path(__file__).resolve().parents[3] / ".venv" / "bin" / "devflow",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return [str(candidate)]
+    return ["devflow"]
+
+
+def run_cmd(repo_root: Path, cmd: list[str], *, cwd: Path | None = None, env: dict[str, str] | None = None) -> GateResult:
+    if cmd and cmd[0] == "devflow":
+        cmd = [*_resolve_devflow_cmd(repo_root), *cmd[1:]]
+    p = subprocess.run(
+        cmd,
+        cwd=str(cwd or repo_root),
+        text=True,
+        capture_output=True,
+        env=env,
+    )
+    return GateResult(
+        ok=p.returncode == 0,
+        stdout=p.stdout,
+        stderr=p.stderr,
+        returncode=p.returncode,
+    )
+
+
+def _run_runtime_contract_setup(repo_root: Path, runtime_contract: dict[str, object]) -> GateResult | None:
+    setup_cmd = runtime_contract.get("setup_cmd")
+    if not isinstance(setup_cmd, list) or not setup_cmd:
+        return None
+    return run_cmd(
+        repo_root,
+        [str(item) for item in setup_cmd],
+        cwd=runtime_contract_cwd(repo_root=repo_root, runtime_contract=runtime_contract),
+        env=runtime_contract_env(runtime_contract),
+    )
+
+
+def run_green_gate(repo_root: Path, runtime_contract: dict[str, object] | None = None) -> dict[str, GateResult]:
+    """Run 'green' definition: registry + package policy + tests + typecheck + lint."""
+
+    results: dict[str, GateResult] = {}
+    python_cmd = sys.executable or "python3"
+    runtime_contract = runtime_contract or infer_test_runtime_contract(repo_root)
+
+    # If a repo-local registry exists, it is part of the definition of green.
+    if (repo_root / ".devflow" / "registry.sqlite").exists():
+        results["registry"] = run_cmd(repo_root, ["devflow", "registry", "validate"])
+        results["package_policy"] = run_cmd(repo_root, ["devflow", "registry", "gate-packages"])
+
+    setup_result = _run_runtime_contract_setup(repo_root, runtime_contract)
+    if setup_result is not None and not setup_result.ok:
+        results["tests"] = setup_result
+    else:
+        results["tests"] = run_cmd(
+            repo_root,
+            [str(item) for item in (runtime_contract.get("run_cmd") or [python_cmd, "-m", "pytest"])],
+            cwd=runtime_contract_cwd(repo_root=repo_root, runtime_contract=runtime_contract),
+            env=runtime_contract_env(runtime_contract),
+        )
+    results["typecheck"] = run_cmd(repo_root, [python_cmd, "-m", "mypy", "."])
+    results["lint"] = run_cmd(repo_root, [python_cmd, "-m", "ruff", "check", "."])
+    return results

devflow_engine/implementation/prompts.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from importlib.resources import files
+from pathlib import Path
+from typing import Any
+
+_REPO_ROOT = Path(__file__).resolve().parents[3]
+_PROMPTS_ROOT = _REPO_ROOT / "prompts" / "implementation"
+
+_STAGE_PROMPT_LAYOUT: dict[str, tuple[str, str]] = {
+    "green": ("green", "green"),
+}
+
+_NODE_CONFIG_LAYOUT: dict[str, tuple[str, str]] = {
+    "green": ("green", "node_config"),
+}
+
+_REVIEW_PROMPT_LAYOUT: dict[str, tuple[str, str]] = {
+    "green_outcome_review": ("green_review", "outcome_review"),
+    "green_prior_run_review": ("green_review", "prior_run_review"),
+}
+
+
+def implementation_prompt_path(*, node: str, agent_name: str) -> Path:
+    source_path = _PROMPTS_ROOT / node / agent_name / "prompt.md"
+    if source_path.exists():
+        return source_path
+    return Path(str(_packaged_implementation_prompts_root().joinpath(node, agent_name, "prompt.md")))
+
+
+def _packaged_implementation_prompts_root() -> Any:
+    return files("devflow_engine").joinpath("prompts", "implementation")
+
+
+def _prompt_text(path: Path) -> str:
+    if path.exists():
+        return path.read_text(encoding="utf-8").strip()
+    package_path = _packaged_implementation_prompts_root().joinpath(*path.parts[-3:])
+    return package_path.read_text(encoding="utf-8").strip()
+
+
+def implementation_stage_prompt_path(stage_name: str) -> Path:
+    try:
+        node, agent_name = _STAGE_PROMPT_LAYOUT[stage_name]
+    except KeyError as exc:
+        raise KeyError(f"Unknown implementation stage prompt mapping: {stage_name}") from exc
+    return implementation_prompt_path(node=node, agent_name=agent_name)
+
+
+def implementation_node_prompt_path(node: str) -> Path:
+    try:
+        mapped_node, agent_name = _NODE_CONFIG_LAYOUT[node]
+    except KeyError as exc:
+        raise KeyError(f"Unknown implementation node prompt mapping: {node}") from exc
+    return implementation_prompt_path(node=mapped_node, agent_name=agent_name)
+
+
+def load_implementation_prompt_markdown(*, node: str, agent_name: str) -> str:
+    return _prompt_text(implementation_prompt_path(node=node, agent_name=agent_name))
+
+
+def load_implementation_stage_prompt_markdown(stage_name: str) -> str:
+    return _prompt_text(implementation_stage_prompt_path(stage_name))
+
+
+def load_implementation_node_instruction(node: str) -> str:
+    return _parse_prompt_markdown(_prompt_text(implementation_node_prompt_path(node)))[0]
+
+
+def implementation_review_prompt_path(review_name: str) -> Path:
+    try:
+        node, agent_name = _REVIEW_PROMPT_LAYOUT[review_name]
+    except KeyError as exc:
+        raise KeyError(f"Unknown implementation review prompt mapping: {review_name}") from exc
+    return implementation_prompt_path(node=node, agent_name=agent_name)
+
+
+def load_implementation_stage_instruction(stage_name: str) -> str:
+    return _parse_prompt_markdown(_prompt_text(implementation_stage_prompt_path(stage_name)))[0]
+
+
+def load_implementation_stage_guidance(stage_name: str) -> list[str]:
+    return _parse_prompt_markdown(_prompt_text(implementation_stage_prompt_path(stage_name)))[1]
+
+
+def load_implementation_review_instruction(review_name: str) -> str:
+    return _parse_prompt_markdown(_prompt_text(implementation_review_prompt_path(review_name)))[0]
+
+
+def load_implementation_review_guidance(review_name: str) -> list[str]:
+    return _parse_prompt_markdown(_prompt_text(implementation_review_prompt_path(review_name)))[1]
+
+
+def _parse_prompt_markdown(markdown: str) -> tuple[str, list[str]]:
+    instruction = ""
+    guidance: list[str] = []
+    for raw_line in markdown.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("- "):
+            guidance.append(line[2:].strip())
+            continue
+        if not instruction:
+            instruction = line
+    if not instruction:
+        raise ValueError("Implementation prompt markdown is missing an instruction line.")
+    return instruction, guidance