devflow-engine 1.0.0__py3-none-any.whl

devflow_engine/integration/prompts.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import re
+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" / "integration"
+
+_STAGE_PROMPT_LAYOUT: dict[str, tuple[str, str]] = {
+    "resolve_side_effects": ("resolve", "resolve_side_effects"),
+    "resolve_implicated_users": ("resolve", "resolve_implicated_users"),
+    "write_workflows": ("write_workflows", "write_workflows"),
+    "build_idea_acceptance_coverage": ("validate", "build_idea_acceptance_coverage"),
+    "validate_enrich_gate": ("validate", "validate_enrich_gate"),
+    "validate_repair": ("validate", "validate_repair"),
+    "red": ("red", "red"),
+    "red_repair": ("red", "red_repair"),
+    "red_review": ("red_review", "red_review"),
+    "green": ("green", "green"),
+    "green_enrich": ("green_enrich", "green_enrich"),
+}
+
+_NODE_CONFIG_LAYOUT: dict[str, tuple[str, str]] = {
+    "resolve": ("resolve", "node_config"),
+    "write_workflows": ("write_workflows", "node_config"),
+    "validate": ("validate", "node_config"),
+    "red": ("red", "node_config"),
+    "red_review": ("red_review", "node_config"),
+    "green": ("green", "node_config"),
+    "green_enrich": ("green_enrich", "node_config"),
+}
+
+
+def integration_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_integration_prompts_root().joinpath(node, agent_name, "prompt.md")))
+
+
+def _packaged_integration_prompts_root() -> Any:
+    return files("devflow_engine").joinpath("prompts", "integration")
+
+
+def _prompt_text(path: Path) -> str:
+    if path.exists():
+        return path.read_text(encoding="utf-8").strip()
+    package_path = _packaged_integration_prompts_root().joinpath(*path.parts[-3:])
+    return package_path.read_text(encoding="utf-8").strip()
+
+
+def integration_stage_prompt_path(stage_name: str) -> Path:
+    normalized_stage_name = _normalize_stage_name(stage_name)
+    try:
+        node, agent_name = _STAGE_PROMPT_LAYOUT[normalized_stage_name]
+    except KeyError as exc:
+        raise KeyError(f"Unknown integration stage prompt mapping: {stage_name}") from exc
+    return integration_prompt_path(node=node, agent_name=agent_name)
+
+
+def integration_node_prompt_path(node: str) -> Path:
+    try:
+        mapped_node, agent_name = _NODE_CONFIG_LAYOUT[node]
+    except KeyError as exc:
+        raise KeyError(f"Unknown integration node prompt mapping: {node}") from exc
+    return integration_prompt_path(node=mapped_node, agent_name=agent_name)
+
+
+def load_integration_prompt_markdown(*, node: str, agent_name: str) -> str:
+    return _prompt_text(integration_prompt_path(node=node, agent_name=agent_name))
+
+
+def load_integration_stage_prompt_markdown(stage_name: str) -> str:
+    return _prompt_text(integration_stage_prompt_path(stage_name))
+
+
+def load_integration_node_instruction(node: str) -> str:
+    return _parse_prompt_markdown(_prompt_text(integration_node_prompt_path(node)))[0]
+
+
+def load_integration_stage_guidance(stage_name: str) -> list[str]:
+    return _parse_prompt_markdown(_prompt_text(integration_stage_prompt_path(stage_name)))[1]
+
+
+def load_integration_code_repair_guidance(*, red_mode: bool) -> list[str]:
+    node = "red" if red_mode else "validate"
+    return _parse_prompt_markdown(
+        _prompt_text(integration_prompt_path(node=node, agent_name="code_repair"))
+    )[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("Integration prompt markdown is missing an instruction line.")
+    return instruction, guidance
+
+
+def _normalize_stage_name(stage_name: str) -> str:
+    if re.fullmatch(r"red_repair_iter\d+", stage_name):
+        return "red_repair"
+    return stage_name

devflow_engine/integration/supabase_schema.sql

@@ -0,0 +1,31 @@
+CREATE TABLE IF NOT EXISTS devflow_idea_integrations (
+  idea_id         TEXT PRIMARY KEY,
+  project_id      TEXT NOT NULL,
+  run_id          TEXT,
+  pipeline_dir    TEXT,
+  status          TEXT NOT NULL DEFAULT 'running',
+  exit_code       INT,
+  iterations_used INT,
+  workflow_count  INT,
+  side_effect_count INT,
+  side_effects    JSONB,
+  implicated_users JSONB,
+  workflow_inventory JSONB,
+  validation_report  JSONB,
+  red_package     JSONB,
+  red_review      JSONB,
+  green_package   JSONB,
+  green_enrich    JSONB,
+  commit_package  JSONB,
+  failure_message TEXT,
+  updated_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+  created_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_devflow_idea_integrations_project_status
+  ON devflow_idea_integrations(project_id, status, updated_at DESC);
+
+ALTER TABLE devflow_idea_integrations
+  ADD COLUMN IF NOT EXISTS repair_cycles INT DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS repair_patches_count INT DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS repair_summary TEXT;

devflow_engine/integration/supabase_sync.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+from urllib.request import Request, urlopen
+
+from ..devflow_state import _is_uuid_like
+from ..project_registration.dag import _infer_owner_repo, _lookup_supabase_project_uuid
+from ..project_registry import find_project_for_repo_root, resolve_project_entry
+
+logger = logging.getLogger(__name__)
+
+
+def _keychain_get(service: str, account: str) -> str | None:
+    try:
+        proc = subprocess.run(
+            ["security", "find-generic-password", "-s", service, "-a", account, "-w"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=10,
+        )
+    except Exception:
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout.strip() or None
+
+
+def resolve_supabase_rest_config() -> tuple[str, str] | None:
+    if os.environ.get("PYTEST_CURRENT_TEST"):
+        return None
+    url = (
+        os.environ.get("DEVFLOW_SUPABASE_URL")
+        or os.environ.get("SUPABASE_URL")
+        or _keychain_get("Supabase URL", "Clarity")
+    )
+    key = (
+        os.environ.get("DEVFLOW_SUPABASE_SERVICE_KEY")
+        or os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
+        or os.environ.get("SUPABASE_SERVICE_KEY")
+        or _keychain_get("Supabase Service Key", "Clarity")
+    )
+    if not url or not key:
+        return None
+    return url.rstrip("/"), key
+
+
+def postgrest_request(
+    *,
+    method: str,
+    url: str,
+    key: str,
+    body: Any | None = None,
+    prefer: str | None = None,
+) -> Any:
+    payload = None if body is None else json.dumps(body).encode("utf-8")
+    req = Request(url, data=payload, method=method)
+    req.add_header("apikey", key)
+    req.add_header("Authorization", f"Bearer {key}")
+    if body is not None:
+        req.add_header("Content-Type", "application/json")
+    if prefer:
+        req.add_header("Prefer", prefer)
+    with urlopen(req, timeout=30) as resp:
+        raw = resp.read().decode("utf-8")
+        return json.loads(raw) if raw else None
+
+
+def resolve_authoritative_project_id(
+    *,
+    project_id: str,
+    repo_root: Path | None,
+    url: str,
+    key: str,
+    log_prefix: str,
+    idea_id: str,
+    run_id: str,
+) -> str | None:
+    resolved_project_id = str(project_id or "").strip()
+    if not resolved_project_id or resolved_project_id.startswith("unregistered:"):
+        return None
+    if _is_uuid_like(resolved_project_id):
+        return resolved_project_id
+    if repo_root is None:
+        project_entry = resolve_project_entry(resolved_project_id)
+        repo_root_value = str((project_entry or {}).get("repo_root") or "").strip()
+        if repo_root_value:
+            repo_root = Path(repo_root_value).expanduser()
+    if repo_root is None:
+        logger.warning(
+            "%s: skipping sync for idea_id=%s run_id=%s because local project_id=%s is not canonical and repo_root is unavailable",
+            log_prefix,
+            idea_id,
+            run_id,
+            project_id,
+        )
+        return None
+    project_entry = find_project_for_repo_root(repo_root)
+    remote_url = str((project_entry or {}).get("remote_url") or "").strip() or None
+    project_name = str((project_entry or {}).get("name") or "").strip() or None
+    owner, repo = _infer_owner_repo(remote_url, repo_root, project_name)
+    try:
+        resolved_project_id = _lookup_supabase_project_uuid(
+            url=url,
+            key=key,
+            repo_root=repo_root,
+            remote_url=remote_url,
+            owner=owner,
+            repo=repo,
+        ) or ""
+    except Exception as exc:
+        logger.warning(
+            "%s: skipping sync for idea_id=%s run_id=%s because canonical project UUID lookup failed for local project_id=%s: %s",
+            log_prefix,
+            idea_id,
+            run_id,
+            project_id,
+            exc,
+        )
+        return None
+    if not _is_uuid_like(resolved_project_id):
+        logger.warning(
+            "%s: skipping sync for idea_id=%s run_id=%s because canonical project UUID could not be resolved from local project_id=%s",
+            log_prefix,
+            idea_id,
+            run_id,
+            project_id,
+        )
+        return None
+    return resolved_project_id
+
+
+def upsert_idea_integration_row(
+    *,
+    idea_id: str,
+    project_id: str,
+    run_id: str,
+    repo_root: Path | None = None,
+    row: dict[str, Any],
+    log_prefix: str = "integration-supabase-sync",
+) -> None:
+    config = resolve_supabase_rest_config()
+    if config is None:
+        return
+    url, key = config
+    resolved_project_id = resolve_authoritative_project_id(
+        project_id=project_id,
+        repo_root=repo_root,
+        url=url,
+        key=key,
+        log_prefix=log_prefix,
+        idea_id=idea_id,
+        run_id=run_id,
+    )
+    if not resolved_project_id:
+        return
+    payload = dict(row)
+    payload["idea_id"] = idea_id
+    payload["project_id"] = resolved_project_id
+    payload["run_id"] = run_id
+    payload.setdefault("updated_at", datetime.now(UTC).isoformat())
+    try:
+        postgrest_request(
+            method="POST",
+            url=f"{url}/rest/v1/devflow_idea_integrations?on_conflict=idea_id",
+            key=key,
+            body=[payload],
+            prefer="resolution=merge-duplicates",
+        )
+    except Exception:
+        pass

devflow_engine/llm/__init__.py

@@ -0,0 +1 @@
+"""LLM execution adapters (CLI one-shot for now)."""

devflow_engine/llm/cli_one_shot.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..api_keys import bootstrap_provider_api_keys
+
+
+@dataclass(frozen=True)
+class OneShotResult:
+    ok: bool
+    stdout: str
+    stderr: str
+    returncode: int
+
+
+def _normalize_timeout_output(value: str | bytes | None) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bytes):
+        return value.decode("utf-8", errors="replace")
+    return value
+
+
+def _split_base(cmd: str) -> list[str]:
+    parts = shlex.split(cmd)
+    return [p for p in parts if p]
+
+
+def run_one_shot(
+    *,
+    base_cmd: str,
+    delivery: str,
+    prompt: str,
+    cwd: Path,
+    timeout_seconds: int | None = None,
+    provider: str | None = None,
+) -> OneShotResult:
+    """Run a one-shot prompt via an external CLI.
+
+    delivery:
+      - argument: append prompt as a final argv element
+      - stdin: pass prompt via stdin
+
+    This is intentionally simple; streaming/resume can be added later.
+    """
+
+    argv = _split_base(base_cmd)
+    if not argv:
+        raise RuntimeError("llm cli base command is empty")
+
+    child_env = os.environ.copy()
+    if provider:
+        bootstrap_provider_api_keys(env=child_env)
+
+    if delivery == "argument":
+        argv = argv + [prompt]
+        try:
+            p = subprocess.run(argv, cwd=str(cwd), text=True, capture_output=True, timeout=timeout_seconds, env=child_env)
+        except subprocess.TimeoutExpired as exc:
+            return OneShotResult(
+                ok=False,
+                stdout=_normalize_timeout_output(exc.stdout),
+                stderr=_normalize_timeout_output(exc.stderr) + f"\nTIMEOUT after {timeout_seconds}s",
+                returncode=124,
+            )
+        return OneShotResult(ok=p.returncode == 0, stdout=p.stdout, stderr=p.stderr, returncode=p.returncode)
+
+    if delivery == "stdin":
+        try:
+            p = subprocess.run(argv, cwd=str(cwd), text=True, input=prompt, capture_output=True, timeout=timeout_seconds, env=child_env)
+        except subprocess.TimeoutExpired as exc:
+            return OneShotResult(
+                ok=False,
+                stdout=_normalize_timeout_output(exc.stdout),
+                stderr=_normalize_timeout_output(exc.stderr) + f"\nTIMEOUT after {timeout_seconds}s",
+                returncode=124,
+            )
+        return OneShotResult(ok=p.returncode == 0, stdout=p.stdout, stderr=p.stderr, returncode=p.returncode)
+
+    raise RuntimeError(f"unsupported delivery: {delivery}")