devflow-engine 1.1.6__tar.gz → 1.1.7__tar.gz

{devflow_engine-1.1.6 → devflow_engine-1.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devflow-engine
-Version: 1.1.6
+Version: 1.1.7
 Summary: DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)
 Author: DevFlow
 License: Proprietary

{devflow_engine-1.1.6 → devflow_engine-1.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devflow-engine"
-version = "1.1.6"
+version = "1.1.7"
 description = "DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)"
 readme = "README.md"
 requires-python = ">=3.11"

{devflow_engine-1.1.6 → devflow_engine-1.1.7}/src/devflow_engine/cli/app.py

@@ -5625,7 +5625,11 @@ def error_solve_runtime(
         # `observation` so BuildObservabilityNode can persist it to
         # error_tasks.observability_json.
         if source_kind == "user_report":
-            return _user_report_observability(ctx, runtime_ctx or {}, repo_root)
+            from ..errors.runtime_observability import build_user_report_observability
+            return build_user_report_observability(
+                repo_root=repo_root,
+                runtime_context=runtime_ctx if isinstance(runtime_ctx, dict) else None,
+            )
 
         if not repro_command:
             return {"observable": False, "reason": "missing_repro_command"}
@@ -5645,117 +5649,6 @@ def error_solve_runtime(
             "runtimeContext": runtime_ctx,
         }
 
-    def _user_report_observability(
-        ctx: dict[str, Any],
-        runtime_ctx: dict[str, Any],
-        repo_root: Path,
-    ) -> dict[str, Any]:
-        """Single invoke_llm call (medium tier) over the bug report + a
-        shallow repo grounding. Returns:
-        - {observable: True, observation: <dict>, details: {...}} on success
-        - {observable: False, reason: <str>, details: {...}} on failure
-        """
-        from ..llm.invoke import LlmInvocationRequest, invoke_llm
-
-        ur = runtime_ctx.get("user_report") if isinstance(runtime_ctx.get("user_report"), dict) else {}
-
-        # Shallow repo grounding — cheap, bounded.
-        excluded = {".git", ".github", ".devflow", ".venv", "venv", "node_modules",
-                    "__pycache__", "dist", "build", "target", ".next", ".cache"}
-        tree: list[str] = []
-        try:
-            for child in sorted(repo_root.iterdir(), key=lambda p: (p.is_file(), p.name.lower())):
-                if child.name in excluded or child.name.startswith("."):
-                    continue
-                tree.append(child.name + ("/" if child.is_dir() else ""))
-                if len(tree) >= 60:
-                    break
-        except OSError:
-            pass
-        repo_knowledge_md: str | None = None
-        rk = repo_root / ".devflow" / "llm" / "repo_knowledge.md"
-        if rk.is_file():
-            try:
-                repo_knowledge_md = rk.read_text(encoding="utf-8", errors="replace")[:6000]
-            except OSError:
-                pass
-
-        prompt_payload = {
-            "task": "user_report_observability",
-            "instruction": (
-                "First-pass observability analysis for a user-reported bug. "
-                "Read the report + repo grounding and emit a SINGLE JSON OBJECT "
-                "with these keys: summary (str), affected_files (list of "
-                "{path, reason}), likely_location (str|null), repro_tests "
-                "(list of {name, file, rationale, language}), open_questions "
-                "(list of str), confidence ('low'|'medium'|'high'). Cite "
-                "workspace-relative paths only. Use open_questions for "
-                "anything unanswerable from the supplied context — do NOT "
-                "guess. 'high' confidence only when you can name the "
-                "function + reproduction steps."
-            ),
-            "error_report": {
-                "title": ur.get("title"),
-                "message": ur.get("message"),
-                "expected_behavior": ur.get("expected_behavior"),
-                "steps_to_reproduce": ur.get("steps_to_reproduce") or [],
-                "report_context": ur.get("report_context") or {},
-            },
-            "repo_context": {
-                "tree_top_level": tree,
-                "repo_knowledge_md": repo_knowledge_md,
-            },
-            "return_format": "json_only",
-        }
-
-        try:
-            result = invoke_llm(
-                LlmInvocationRequest(
-                    purpose="user_report_observability",
-                    repo_root=repo_root,
-                    prompt="",
-                    prompt_payload=prompt_payload,
-                    delivery_model="final_only",
-                    interaction_model="request_response",
-                    response_contract="json_only",
-                    timeout_seconds=90,
-                    strength="medium",
-                )
-            )
-        except Exception as exc:  # noqa: BLE001 — surface as reason
-            return {
-                "observable": False,
-                "reason": f"llm_invoke_raised: {type(exc).__name__}: {exc!s}".splitlines()[0],
-                "details": {"runtimeContext": runtime_ctx},
-            }
-        if not result.ok:
-            return {
-                "observable": False,
-                "reason": f"llm_not_ok: rc={result.returncode} stderr={(result.stderr or '')[:300]}",
-                "details": {"runtimeContext": runtime_ctx},
-            }
-        parsed = result.parsed_json
-        if not isinstance(parsed, dict):
-            return {
-                "observable": False,
-                "reason": f"schema_invalid: response is {type(parsed).__name__}, expected object",
-                "details": {"raw_stdout": (result.stdout or "")[:400]},
-            }
-        required = ("summary", "affected_files", "likely_location", "repro_tests",
-                    "open_questions", "confidence")
-        missing = [k for k in required if k not in parsed]
-        if missing:
-            return {
-                "observable": False,
-                "reason": f"schema_invalid: missing keys {missing}",
-                "details": {"raw_keys": sorted(parsed.keys())},
-            }
-        return {
-            "observable": True,
-            "observation": parsed,
-            "details": {"runtimeContext": runtime_ctx},
-        }
-
     from ..implementation.green_gate import run_green_gate
 
     def _run_shell(cmd: str) -> subprocess.CompletedProcess[str]:

devflow_engine-1.1.7/src/devflow_engine/errors/runtime_observability.py

@@ -0,0 +1,195 @@
+"""Runtime observability bundle builder for the error-solver DAG."""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def build_runtime_observability(
+    *,
+    repo_root: Path,
+    runtime_context: dict[str, Any] | None = None,
+    repro_command: str | None = None,
+    project_id: str | None = None,
+    store: Any = None,
+    error_task_id: str | None = None,
+) -> dict[str, Any]:
+    """Gather observable runtime context for the error-solver DAG.
+
+    Returns a structured evidence bundle that the error-solver DAG passes to
+    its build_observability_fn hook so diagnose/fix nodes have environment
+    context (git status, recent logs, runtime_context payload, etc.).
+    """
+    git_status: str = ""
+    git_log: str = ""
+    try:
+        r = subprocess.run(["git", "status", "--short"], cwd=str(repo_root), capture_output=True, text=True, check=False)
+        git_status = r.stdout.strip()
+    except Exception:
+        pass
+    try:
+        r = subprocess.run(["git", "log", "--oneline", "-10"], cwd=str(repo_root), capture_output=True, text=True, check=False)
+        git_log = r.stdout.strip()
+    except Exception:
+        pass
+
+    return {
+        "artifactVersion": "runtime_evidence_bundle/v1",
+        "observable": True,
+        "repo_root": str(repo_root),
+        "project_id": project_id,
+        "error_task_id": error_task_id,
+        "runtime_context": runtime_context or {},
+        "repro_command": repro_command,
+        "git_status": git_status,
+        "git_log": git_log,
+    }
+
+
+def collect_runtime_evidence_bundle(
+    *,
+    repo_root: Path,
+    runtime_context: dict[str, Any] | None = None,
+    repro_command: str | None = None,
+    project_id: str | None = None,
+    store: Any = None,
+    error_task_id: str | None = None,
+) -> dict[str, Any]:
+    """Compatibility wrapper for the error-solver DAG import path."""
+    return build_runtime_observability(
+        repo_root=repo_root,
+        runtime_context=runtime_context,
+        repro_command=repro_command,
+        project_id=project_id,
+        store=store,
+        error_task_id=error_task_id,
+    )
+
+
+_USER_REPORT_REQUIRED_KEYS = (
+    "summary", "affected_files", "likely_location",
+    "repro_tests", "open_questions", "confidence",
+)
+
+
+def build_user_report_observability(
+    *,
+    repo_root: Path,
+    runtime_context: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """First-pass observability for source_kind='user_report' rows.
+
+    Single invoke_llm call through the canonical tier system
+    (strength='medium' — whatever tier.medium resolves to in
+    ~/.devflow/config.toml). Returns one of:
+    - ``{observable: True, observation: <dict>, details: {...}}`` on
+      success (LLM returned a JSON object with all required keys)
+    - ``{observable: False, reason: <str>, details: {...}}`` on any
+      failure (invoke raised, llm_not_ok, schema_invalid)
+
+    Both worker.py (queue-driven processing) and cli/app.py
+    (`devflow error solve-runtime`) inject this for user_report rows
+    so the same code path handles them regardless of who triggers.
+    """
+    # Local import — keeps this module cheap when only the shell-side
+    # build_runtime_observability is needed (e.g. test envs without LLM
+    # config).
+    from ..llm.invoke import LlmInvocationRequest, invoke_llm
+
+    runtime_ctx = runtime_context or {}
+    ur = runtime_ctx.get("user_report") if isinstance(runtime_ctx.get("user_report"), dict) else {}
+
+    excluded = {".git", ".github", ".devflow", ".venv", "venv", "node_modules",
+                "__pycache__", "dist", "build", "target", ".next", ".cache"}
+    tree: list[str] = []
+    try:
+        for child in sorted(repo_root.iterdir(), key=lambda p: (p.is_file(), p.name.lower())):
+            if child.name in excluded or child.name.startswith("."):
+                continue
+            tree.append(child.name + ("/" if child.is_dir() else ""))
+            if len(tree) >= 60:
+                break
+    except OSError:
+        pass
+    repo_knowledge_md: str | None = None
+    rk = repo_root / ".devflow" / "llm" / "repo_knowledge.md"
+    if rk.is_file():
+        try:
+            repo_knowledge_md = rk.read_text(encoding="utf-8", errors="replace")[:6000]
+        except OSError:
+            pass
+
+    prompt_payload = {
+        "task": "user_report_observability",
+        "instruction": (
+            "First-pass observability analysis for a user-reported bug. "
+            "Read the report + repo grounding and emit a SINGLE JSON OBJECT "
+            "with these keys: summary (str), affected_files (list of "
+            "{path, reason}), likely_location (str|null), repro_tests "
+            "(list of {name, file, rationale, language}), open_questions "
+            "(list of str), confidence ('low'|'medium'|'high'). Cite "
+            "workspace-relative paths only. Use open_questions for "
+            "anything unanswerable from the supplied context — do NOT "
+            "guess. 'high' confidence only when you can name the "
+            "function + reproduction steps."
+        ),
+        "error_report": {
+            "title": ur.get("title"),
+            "message": ur.get("message"),
+            "expected_behavior": ur.get("expected_behavior"),
+            "steps_to_reproduce": ur.get("steps_to_reproduce") or [],
+            "report_context": ur.get("report_context") or {},
+        },
+        "repo_context": {
+            "tree_top_level": tree,
+            "repo_knowledge_md": repo_knowledge_md,
+        },
+        "return_format": "json_only",
+    }
+
+    try:
+        result = invoke_llm(
+            LlmInvocationRequest(
+                purpose="user_report_observability",
+                repo_root=repo_root,
+                prompt="",
+                prompt_payload=prompt_payload,
+                delivery_model="final_only",
+                interaction_model="request_response",
+                response_contract="json_only",
+                timeout_seconds=90,
+                strength="medium",
+            )
+        )
+    except Exception as exc:  # noqa: BLE001 — surface as reason
+        return {
+            "observable": False,
+            "reason": f"llm_invoke_raised: {type(exc).__name__}: {exc!s}".splitlines()[0],
+            "details": {"runtimeContext": runtime_ctx},
+        }
+    if not result.ok:
+        return {
+            "observable": False,
+            "reason": f"llm_not_ok: rc={result.returncode} stderr={(result.stderr or '')[:300]}",
+            "details": {"runtimeContext": runtime_ctx},
+        }
+    parsed = result.parsed_json
+    if not isinstance(parsed, dict):
+        return {
+            "observable": False,
+            "reason": f"schema_invalid: response is {type(parsed).__name__}, expected object",
+            "details": {"raw_stdout": (result.stdout or "")[:400]},
+        }
+    missing = [k for k in _USER_REPORT_REQUIRED_KEYS if k not in parsed]
+    if missing:
+        return {
+            "observable": False,
+            "reason": f"schema_invalid: missing keys {missing}",
+            "details": {"raw_keys": sorted(parsed.keys())},
+        }
+    return {
+        "observable": True,
+        "observation": parsed,
+        "details": {"runtimeContext": runtime_ctx},
+    }

{devflow_engine-1.1.6 → devflow_engine-1.1.7}/src/devflow_engine/worker.py

@@ -16,7 +16,7 @@ from .scope_idea.dag import run_scope_to_idea_dag
 from .source_doc_mutation_dag import run_source_doc_mutation_dag
 from .source_docs_updater import process_source_doc_update_once
 from .stores.execution_store import ExecutionStore
-from .errors.runtime_observability import build_runtime_observability
+from .errors.runtime_observability import build_runtime_observability, build_user_report_observability
 from .worker_guard import ensure_worker_start_allowed
 
 
@@ -554,16 +554,26 @@ def process_once(*, project_id: str, repo_root: Path, store: ExecutionStore) ->
                 failure_message=None if result.exit_code == 0 else result.message,
             )
         elif claimed["queue_type"] == "error":
-            result = store.run_error_solver_dag(
-                error_task_id=str(claimed["item_id"]),
-                repo_root=repo_root,
-                build_observability_fn=lambda ctx: build_runtime_observability(
+            def _worker_build_observability(ctx: dict[str, Any]) -> dict[str, Any]:
+                rctx = ctx.get("runtimeContext") if isinstance(ctx.get("runtimeContext"), dict) else None
+                source_kind = (rctx or {}).get("source_kind") if isinstance(rctx, dict) else None
+                if source_kind == "user_report":
+                    return build_user_report_observability(
+                        repo_root=repo_root,
+                        runtime_context=rctx,
+                    )
+                return build_runtime_observability(
                     repo_root=repo_root,
-                    runtime_context=ctx.get("runtimeContext") if isinstance(ctx.get("runtimeContext"), dict) else None,
+                    runtime_context=rctx,
                     repro_command=None,
                     project_id=project_id,
                     store=store,
-                ),
+                )
+
+            result = store.run_error_solver_dag(
+                error_task_id=str(claimed["item_id"]),
+                repo_root=repo_root,
+                build_observability_fn=_worker_build_observability,
                 first_pass_fix_fn=lambda _ctx: {"fixed": False},
                 iterative_fix_fn=lambda _ctx: {"fixed": False},
                 needs_user_input_fn=lambda _ctx: True,

{devflow_engine-1.1.6 → devflow_engine-1.1.7}/uv.lock

@@ -172,7 +172,7 @@ wheels = [
 
 [[package]]
 name = "devflow-engine"
-version = "1.1.5"
+version = "1.1.6"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },

devflow_engine-1.1.6/src/devflow_engine/errors/runtime_observability.py

@@ -1,67 +0,0 @@
-"""Runtime observability bundle builder for the error-solver DAG."""
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-from typing import Any
-
-
-def build_runtime_observability(
-    *,
-    repo_root: Path,
-    runtime_context: dict[str, Any] | None = None,
-    repro_command: str | None = None,
-    project_id: str | None = None,
-    store: Any = None,
-    error_task_id: str | None = None,
-) -> dict[str, Any]:
-    """Gather observable runtime context for the error-solver DAG.
-
-    Returns a structured evidence bundle that the error-solver DAG passes to
-    its build_observability_fn hook so diagnose/fix nodes have environment
-    context (git status, recent logs, runtime_context payload, etc.).
-    """
-    git_status: str = ""
-    git_log: str = ""
-    try:
-        r = subprocess.run(["git", "status", "--short"], cwd=str(repo_root), capture_output=True, text=True, check=False)
-        git_status = r.stdout.strip()
-    except Exception:
-        pass
-    try:
-        r = subprocess.run(["git", "log", "--oneline", "-10"], cwd=str(repo_root), capture_output=True, text=True, check=False)
-        git_log = r.stdout.strip()
-    except Exception:
-        pass
-
-    return {
-        "artifactVersion": "runtime_evidence_bundle/v1",
-        "observable": True,
-        "repo_root": str(repo_root),
-        "project_id": project_id,
-        "error_task_id": error_task_id,
-        "runtime_context": runtime_context or {},
-        "repro_command": repro_command,
-        "git_status": git_status,
-        "git_log": git_log,
-    }
-
-
-def collect_runtime_evidence_bundle(
-    *,
-    repo_root: Path,
-    runtime_context: dict[str, Any] | None = None,
-    repro_command: str | None = None,
-    project_id: str | None = None,
-    store: Any = None,
-    error_task_id: str | None = None,
-) -> dict[str, Any]:
-    """Compatibility wrapper for the error-solver DAG import path."""
-    return build_runtime_observability(
-        repo_root=repo_root,
-        runtime_context=runtime_context,
-        repro_command=repro_command,
-        project_id=project_id,
-        store=store,
-        error_task_id=error_task_id,
-    )