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

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

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

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

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

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

@@ -5615,6 +5615,18 @@ def error_solve_runtime(
         return
 
     def build_observability_fn(ctx: dict[str, Any]) -> dict[str, Any]:
+        runtime_ctx = ctx.get("runtimeContext") if isinstance(ctx, dict) else None
+        source_kind = (
+            (runtime_ctx or {}).get("source_kind") if isinstance(runtime_ctx, dict) else None
+        )
+        # User-reported errors don't have a repro_command; they have a
+        # human description. Route to a single-shot LLM analysis via the
+        # canonical invoke_llm + tier path. Result lives in
+        # `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)
+
         if not repro_command:
             return {"observable": False, "reason": "missing_repro_command"}
         cp = subprocess.run(
@@ -5630,7 +5642,118 @@ def error_solve_runtime(
             "returncode": cp.returncode,
             "stdout": (cp.stdout or "")[-4000:],
             "stderr": (cp.stderr or "")[-4000:],
-            "runtimeContext": ctx.get("runtimeContext") if isinstance(ctx, dict) else None,
+            "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

{devflow_engine-1.1.5 → devflow_engine-1.1.6}/src/devflow_engine/errors/error_solver_dag.py

@@ -267,11 +267,15 @@ class BuildObservabilityNode(Node):
             "context_persistor", ContextPersistor(repo_root=repo_root, error_task_id=error_task_id)
         )
         context: dict[str, Any] = task_context.metadata.get("context_json")
+        source_kind: str | None = None
+        user_report_fields: dict[str, Any] = {}
         if context is None:
             db_fingerprint = None
             with store._connect() as conn:  # best-effort read
                 row = conn.execute(
-                    "SELECT title, error_type, fingerprint FROM error_tasks WHERE error_task_id=?",
+                    "SELECT title, error_type, fingerprint, source_kind, message, "
+                    "expected_behavior, steps_to_reproduce_json, report_context_json "
+                    "FROM error_tasks WHERE error_task_id=?",
                     (error_task_id,),
                 ).fetchone()
             title = None
@@ -280,7 +284,33 @@ class BuildObservabilityNode(Node):
                 title = row[0]
                 error_type = row[1]
                 db_fingerprint = row[2]
+                source_kind = row[3] or None
+                # Stash user_report payload so the injected
+                # build_observability_fn can read it from runtimeContext
+                # without re-querying the store.
+                if source_kind == "user_report":
+                    try:
+                        steps = json.loads(row[6] or "[]")
+                    except (TypeError, ValueError):
+                        steps = []
+                    try:
+                        report_ctx = json.loads(row[7] or "{}")
+                    except (TypeError, ValueError):
+                        report_ctx = {}
+                    user_report_fields = {
+                        "title": title,
+                        "message": row[4] or "",
+                        "expected_behavior": row[5],
+                        "steps_to_reproduce": steps,
+                        "report_context": report_ctx,
+                    }
             runtime_context = task_context.event.runtime_context if isinstance(task_context.event.runtime_context, dict) else None
+            if source_kind is not None or user_report_fields:
+                runtime_context = dict(runtime_context or {})
+                if source_kind is not None:
+                    runtime_context["source_kind"] = source_kind
+                if user_report_fields:
+                    runtime_context["user_report"] = user_report_fields
             prior_runs = _load_prior_runs(
                 store=store,
                 repo_root=repo_root,
@@ -294,11 +324,45 @@ class BuildObservabilityNode(Node):
                 prior_runs=prior_runs,
             )
             task_context.metadata["context_json"] = context
+        else:
+            # Context already initialized (re-entrant). Recover source_kind
+            # so the user-report branch below still fires.
+            rc = context.get("runtimeContext") or {}
+            source_kind = rc.get("source_kind") if isinstance(rc, dict) else None
 
         fn: Callable[[dict[str, Any]], dict[str, Any]] = funcs["build_observability_fn"]
         out = fn(context)
         persistor.persist(context=context, node_name="BuildObservability", output=out)
         self.save_output(BuildObservabilityNode.OutputType(**{"observable": bool(out.get("observable", True)), "details": out}))
+
+        # User-report rows skip the rest of the DAG (FirstPassFix etc are
+        # not appropriate for a human-filed bug). Persist the analysis
+        # result to the row's queryable columns and stop the workflow.
+        # `outcome` defaults to 'blocked' in run_error_solver_dag when
+        # unset — that's misleading for a successful analysis, so set
+        # it explicitly here.
+        if source_kind == "user_report":
+            now = int(time.time())
+            observation = out.get("observation") if isinstance(out, dict) else None
+            reason = out.get("reason") if isinstance(out, dict) else None
+            with store._connect() as conn:
+                if isinstance(observation, dict):
+                    conn.execute(
+                        "UPDATE error_tasks SET observability_json=?, observability_error=NULL, "
+                        "status='observed', updated_at=? WHERE error_task_id=?",
+                        (json.dumps(observation, ensure_ascii=False, sort_keys=True), now, error_task_id),
+                    )
+                    task_context.metadata["outcome"] = "observed"
+                elif reason:
+                    conn.execute(
+                        "UPDATE error_tasks SET observability_error=?, updated_at=? "
+                        "WHERE error_task_id=?",
+                        (str(reason), now, error_task_id),
+                    )
+                    task_context.metadata["outcome"] = "observation_failed"
+                    task_context.metadata["reason"] = str(reason)
+            task_context.stop_workflow()
+
         return task_context
 
 

devflow_engine-1.1.6/tests/area8_errors/test_us85_error_solver_dag_contract.py

@@ -0,0 +1,302 @@
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+from devflow_engine.stores.execution_store import ExecutionStore
+
+
+@pytest.mark.story_id("US-8.5")
+@pytest.mark.story_uuid("759b3214-9fe4-41e6-8bf1-efed00a3b06f")
+@pytest.mark.plane("ops")
+def test_US_8_5__error_solver_dag_writes_context_and_resolves_on_first_pass(tmp_path: Path) -> None:
+    repo_root = tmp_path
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+
+    run = store.start_run(kind="story.execute", repo_root=repo_root, args={"story_id": "STORY:demo"})
+    error_task_id = store.create_error_task_from_failure(
+        project_id="proj_demo",
+        run_id=run.run_id,
+        plane="ops",
+        source_kind="execution",
+        source_ref=run.run_id,
+        title="Story execute failed",
+        severity="high",
+        error_type="Exception",
+        message="Boom",
+        stacktrace="Traceback...",
+        next_steps=["Do X"],
+        fingerprint_inputs={"message": "Boom", "plane": "ops"},
+    )
+
+    assert hasattr(store, "run_error_solver_dag"), "ExecutionStore.run_error_solver_dag must exist (US-8.5)"
+
+    result = store.run_error_solver_dag(  # type: ignore[attr-defined]
+        error_task_id=error_task_id,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": True},
+        first_pass_fix_fn=lambda _ctx: {"fixed": True, "verification": {"green_gate": True}},
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: False,
+    )
+
+    assert result["outcome"] == "resolved"
+
+    context_path = repo_root / ".devflow" / "errors" / "logs" / error_task_id / "context.json"
+    assert context_path.exists(), "context.json must be written under .devflow/errors/logs/<id>/context.json"
+
+    data = json.loads(context_path.read_text())
+    assert "metadata" in data
+    assert data["metadata"]["errorId"] == error_task_id
+    assert data["metadata"]["projectPath"] == str(repo_root)
+    assert data["metadata"].get("node_order") == [
+        "BuildObservability",
+        "FirstPassFix",
+        "FinalOutcomeRoute",
+        "Resolve",
+    ]
+
+    with sqlite3.connect(db_path) as conn:
+        row = conn.execute(
+            "SELECT status FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+        assert row is not None
+        assert row[0] == "resolved"
+
+
+@pytest.mark.story_id("US-8.5")
+@pytest.mark.story_uuid("759b3214-9fe4-41e6-8bf1-efed00a3b06f")
+@pytest.mark.plane("ops")
+def test_US_8_5__error_solver_dag_routes_to_block_when_user_input_needed(tmp_path: Path) -> None:
+    repo_root = tmp_path
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+
+    run = store.start_run(kind="play.preflight", repo_root=repo_root, args={"mode": "json"})
+    error_task_id = store.create_error_task_from_failure(
+        project_id=None,
+        run_id=run.run_id,
+        plane="ops",
+        source_kind="execution",
+        source_ref=run.run_id,
+        title="Preflight failed",
+        severity="high",
+        error_type="preflight",
+        message="Missing creds",
+        stacktrace=None,
+        next_steps=["Add creds"],
+        fingerprint_inputs={"message": "Missing creds", "plane": "ops"},
+    )
+
+    assert hasattr(store, "run_error_solver_dag")
+
+    result = store.run_error_solver_dag(  # type: ignore[attr-defined]
+        error_task_id=error_task_id,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": True},
+        first_pass_fix_fn=lambda _ctx: {"fixed": False},
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: True,
+    )
+
+    assert result["outcome"] == "blocked"
+
+    context_path = repo_root / ".devflow" / "errors" / "logs" / error_task_id / "context.json"
+    data = json.loads(context_path.read_text())
+    assert data["metadata"].get("node_order")[-1] == "Block"
+
+    with sqlite3.connect(db_path) as conn:
+        row = conn.execute(
+            "SELECT status FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+        assert row is not None
+        assert row[0] == "blocked"
+
+
+@pytest.mark.story_id("US-8.5")
+@pytest.mark.plane("ops")
+def test_build_observability_user_report_writes_observation_to_row(tmp_path: Path) -> None:
+    """For source_kind='user_report', a successful build_observability_fn
+    (returning {observable:True, observation:{...}}) must:
+    - persist the observation dict to error_tasks.observability_json
+    - flip status to 'observed'
+    - clear observability_error
+    - cause the workflow to stop (FirstPassFix etc. don't run)
+    """
+    repo_root = tmp_path
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    error_task_id = store.create_error_task_from_user_report(
+        project_id="proj_ur",
+        source_app="nbna_app",
+        external_id="e-1",
+        title="Save broken",
+        message="Clicked save, nothing happened",
+        expected_behavior="Save and close",
+        steps_to_reproduce=["Open form", "Click Save"],
+        report_context={"page_url": "/admin/profile"},
+    )
+
+    observation = {
+        "summary": "Save handler returns 200 but doesn't persist.",
+        "affected_files": [{"path": "src/handlers/save.py", "reason": "handler"}],
+        "likely_location": "save() in src/handlers/save.py:42-68",
+        "repro_tests": [],
+        "open_questions": [],
+        "confidence": "medium",
+    }
+    first_pass_called = {"n": 0}
+
+    def _first_pass(_ctx):
+        first_pass_called["n"] += 1
+        return {"fixed": False}
+
+    result = store.run_error_solver_dag(
+        error_task_id=error_task_id,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": True, "observation": observation},
+        first_pass_fix_fn=_first_pass,
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: False,
+    )
+
+    # stop_workflow should have prevented FirstPassFix from running.
+    assert first_pass_called["n"] == 0, "FirstPassFix ran despite stop_workflow"
+    assert result.get("outcome") == "observed", (
+        f"expected outcome='observed' for successful user_report analysis, got {result.get('outcome')!r}"
+    )
+
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT status, observability_json, observability_error "
+            "FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+    assert row is not None
+    assert row["status"] == "observed", f"expected status='observed', got {row['status']!r}"
+    assert row["observability_error"] is None
+    assert row["observability_json"] is not None
+    stored_obs = json.loads(row["observability_json"])
+    assert stored_obs["summary"] == observation["summary"]
+    assert stored_obs["confidence"] == "medium"
+
+
+@pytest.mark.story_id("US-8.5")
+@pytest.mark.plane("ops")
+def test_build_observability_user_report_failure_writes_error_reason(tmp_path: Path) -> None:
+    """For source_kind='user_report', a failing build_observability_fn
+    (returning {observable:False, reason:...}) must:
+    - persist the reason to error_tasks.observability_error
+    - leave observability_json NULL
+    - still stop the workflow (user-report rows don't go to FirstPassFix
+      whether observability succeeded or failed)
+    """
+    repo_root = tmp_path
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    error_task_id = store.create_error_task_from_user_report(
+        project_id="proj_ur",
+        source_app="nbna_app",
+        external_id="e-2",
+        title="Save broken 2",
+        message="dup",
+    )
+
+    first_pass_called = {"n": 0}
+
+    def _first_pass(_ctx):
+        first_pass_called["n"] += 1
+        return {"fixed": False}
+
+    store.run_error_solver_dag(
+        error_task_id=error_task_id,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": False, "reason": "llm_not_ok: rc=1 stderr=boom"},
+        first_pass_fix_fn=_first_pass,
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: True,
+    )
+
+    assert first_pass_called["n"] == 0, "FirstPassFix ran on failed user_report observability"
+
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT status, observability_json, observability_error "
+            "FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+    assert row is not None
+    # Status stays whatever the DAG set it to (typically 'in_progress'
+    # after first observability touch; not 'observed' since we failed).
+    assert row["status"] != "observed"
+    assert row["observability_json"] is None
+    assert row["observability_error"] is not None
+    assert "llm_not_ok" in row["observability_error"]
+
+
+@pytest.mark.story_id("US-8.5")
+@pytest.mark.plane("ops")
+def test_build_observability_runtime_error_does_not_stop_workflow(tmp_path: Path) -> None:
+    """Non-user_report rows (e.g. source_kind='execution') must NOT
+    trigger the stop_workflow path — the DAG should proceed to
+    FirstPassFix as it always has. This pins that the user_report branch
+    is properly gated on source_kind.
+    """
+    repo_root = tmp_path
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+
+    run = store.start_run(kind="story.execute", repo_root=repo_root, args={"story_id": "STORY:rt"})
+    error_task_id = store.create_error_task_from_failure(
+        project_id="proj_rt",
+        run_id=run.run_id,
+        plane="ops",
+        source_kind="execution",  # NOT user_report
+        source_ref=run.run_id,
+        title="Runtime boom",
+        severity="medium",
+        error_type="Exception",
+        message="Boom",
+        stacktrace="Traceback...",
+        next_steps=[],
+        fingerprint_inputs={"message": "Boom", "plane": "ops"},
+    )
+
+    first_pass_called = {"n": 0}
+
+    def _first_pass(_ctx):
+        first_pass_called["n"] += 1
+        return {"fixed": True, "verification": {"green_gate": True}}
+
+    store.run_error_solver_dag(
+        error_task_id=error_task_id,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": True},
+        first_pass_fix_fn=_first_pass,
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: False,
+    )
+
+    # The non-user_report path MUST continue past observability.
+    assert first_pass_called["n"] == 1, (
+        "FirstPassFix should have run for source_kind!='user_report'; "
+        f"got first_pass call count = {first_pass_called['n']}"
+    )
+
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT status, observability_json, observability_error "
+            "FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+    # The runtime path is NOT supposed to touch observability_json /
+    # observability_error — those are user_report-specific columns.
+    assert row["observability_json"] is None
+    assert row["observability_error"] is None

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

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