devops-bot-sdk 1.4.60__tar.gz → 1.4.65__tar.gz

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.60
+Version: 1.4.65
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.60
+Version: 1.4.65
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.60"
+version = "1.4.65"
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.60
+Version: 1.4.65
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.60"
+__version__ = "1.4.65"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.60"
+SDK_VERSION    = "1.4.65"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -821,7 +821,7 @@ class BackendClient:
         # field like `modelUsed` can repeat.
         files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
         for m in (model_used or []):
-            files.append(("modelUsed", (None, str(m))))
+            files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.put(url, files=files, headers=headers)
@@ -850,7 +850,7 @@ class BackendClient:
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
         files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
         for m in (model_used or []):
-            files.append(("modelUsed", (None, str(m))))
+            files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.post(url, files=files, headers=headers)

{devops_bot_sdk-1.4.60 → devops_bot_sdk-1.4.65}/sdk/ipc/handlers.py

@@ -371,6 +371,50 @@ def _parse_scope(recon_text: str | None) -> str:
     return "in"
 
 
+# Heartbeat cadence for long, quiet local runs (PRD generation, validation) so the
+# log shows liveness even when the agent is generating text with no tool calls.
+_HEARTBEAT_S = float(os.getenv("AGENTOS_HEARTBEAT_S", "") or 20.0)
+
+
+async def _run_with_heartbeat(coro, *, send: Callable, thread_id: str, label: str,
+                              name: str | None = None, interval: float = _HEARTBEAT_S):
+    """Await `coro` while emitting a periodic 'still working (Ns)' step_update, so a
+    long-but-quiet local run (e.g. PRD generation) never looks frozen in the log."""
+    import time as _t
+
+    prefix = f"[{name}] " if name else ""
+    stop = asyncio.Event()
+    started = _t.monotonic()
+
+    async def _beat() -> None:
+        try:
+            while not stop.is_set():
+                try:
+                    await asyncio.wait_for(stop.wait(), timeout=interval)
+                    return
+                except asyncio.TimeoutError:
+                    pass
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"status": "running",
+                          "current_step": f"{prefix}{label} … still working "
+                                          f"({int(_t.monotonic() - started)}s)"},
+                ).model_dump())
+        except asyncio.CancelledError:
+            return
+
+    beat = asyncio.create_task(_beat())
+    try:
+        return await coro
+    finally:
+        stop.set()
+        beat.cancel()
+        try:
+            await beat
+        except Exception:  # noqa: BLE001
+            pass
+
+
 # ── Epic decomposition ────────────────────────────────────────────────────
 # An EPIC is not coded directly. It is analysed (grounded in the codebase when a
 # project path exists) into a detailed user-story description + an implementation
@@ -624,9 +668,14 @@ async def _validate_ticket_or_reject(
     we never block a ticket on our own infrastructure error."""
     from sdk import local_exec
 
+    from pathlib import Path
+
     tid = str(task.get("id", ""))
     jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "") or kind.upper()
-    project_path = _resolve_local_project_path(task, payload)
+    # Validation is a pure text judgment — run it in a guaranteed-writable scratch
+    # dir, never the resolved project path (which may not exist yet or be unwritable,
+    # e.g. a code-reference like /components). This decouples the gate from the repo.
+    scratch = str(Path.home() / ".agentos" / "validate")
 
     await send(Envelope(
         type="step_update", thread_id=thread_id,
@@ -634,11 +683,14 @@ async def _validate_ticket_or_reject(
               "current_step": f"{kind.title()} {jira_key}: validating ticket against the standard"},
     ).model_dump())
 
-    res = await local_exec.run_claude_local(
-        _build_validation_prompt(kind, jira_key, task.get("summary", "") or "",
-                                 task.get("description"), task.get("humanInstructions")),
-        project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only judgment
-        github_token=await client.github_token(),
+    res = await _run_with_heartbeat(
+        local_exec.run_claude_local(
+            _build_validation_prompt(kind, jira_key, task.get("summary", "") or "",
+                                     task.get("description"), task.get("humanInstructions")),
+            scratch, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only judgment, scratch dir
+            github_token=await client.github_token(),
+        ),
+        send=send, thread_id=thread_id, label=f"{kind.title()} {jira_key}: validating",
     )
     if not res.get("ok"):
         await client.log_activity(
@@ -854,10 +906,14 @@ def _build_prd_prompt(jira_key: str, summary: str, user_story: str | None,
 
 async def _handle_story(
     client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: str,
-) -> None:
+) -> str | None:
     """Run a Story: optionally generate a PRD (when instructed) into the description,
     then convert the ticket to a Task (To Do) for the coding run.
 
+    Returns the effective (PRD-enriched) description on success, or None on failure.
+    The caller uses the returned description to code the now-Task in the SAME run
+    (default `agentos-auto`); the `story` command discards it (convert-only).
+
     Best-effort. If a PRD was explicitly instructed but generation fails, the ticket
     goes to Backlog for retry (so the PRD requirement isn't silently dropped); a
     conversion failure likewise backlogs it.
@@ -955,9 +1011,11 @@ async def _handle_story(
         type="step_update", thread_id=thread_id,
         data={"jira_task_id": tid,
               "current_step": f"Story {jira_key} → Task (To Do)"
-                              + (" + PRD in description" if prd_in_desc else "")
-                              + " — run again to implement"},
+                              + (" + PRD in description" if prd_in_desc else "")},
     ).model_dump())
+    # The effective description (PRD-enriched when generated/present) so the caller
+    # can code the now-Task in the same run.
+    return new_description or user_story
 
 
 async def _run_local_pipeline(
@@ -1231,13 +1289,16 @@ async def _code_one_repo(
             data={"status": "running",
                   "current_step": f"[{name}] Recon — exploring the repo to ground the plan"},
         ).model_dump())
-        recon = await local_exec.run_claude_local(
-            _build_recon_prompt(
-                name, pending["user_input"], pending.get("structured_plan"),
-                pending.get("human_instructions"),
+        recon = await _run_with_heartbeat(
+            local_exec.run_claude_local(
+                _build_recon_prompt(
+                    name, pending["user_input"], pending.get("structured_plan"),
+                    pending.get("human_instructions"),
+                ),
+                repo_path, on_event=_on_event, github_token=gh_token,
+                allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only: no Write/Edit/Bash
             ),
-            repo_path, on_event=_on_event, github_token=gh_token,
-            allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only: no Write/Edit/Bash
+            send=send, thread_id=thread_id, label="Exploring the repo (recon)", name=name,
         )
         recon_session = recon.get("session_id")
         # A usage-limit hit during recon must be surfaced so the loop waits/retries
@@ -1298,35 +1359,59 @@ async def _code_one_repo(
     except Exception:  # noqa: BLE001
         branch_info = None
 
-    # 3a. Technical PRD for a CODEBASE task that doesn't have one yet. A Task created
-    #     directly (not via a Story) may carry only a user-story/feature description —
-    #     for codebase work we first turn the recon understanding into a technical PRD
-    #     and build to it, exactly like a Story-derived Task. Resumes the recon session
-    #     (already understands the codebase) so it's cheap; persists the PRD to the
-    #     ticket and to pending (shared → other repos reuse it and skip regeneration).
-    #     Skipped when a PRD is already present, on a resume, or for non-git targets.
-    if (is_git and recon_session and not resume_session_id
-            and _PRD_MARKER not in (pending.get("user_input") or "")):
-        await send(Envelope(
-            type="step_update", thread_id=thread_id,
-            data={"status": "running",
-                  "current_step": f"[{name}] Codebase task — writing a technical PRD from the codebase"},
-        ).model_dump())
-        prd_res = await local_exec.run_claude_local(
-            "Using your exploration above, write a TECHNICAL PRD for this task that fully "
-            "specifies the mechanism (how it works end-to-end) against the REAL code you "
-            "found. Output ONLY the PRD as Markdown, following this format exactly:\n\n"
-            + _PRD_FORMAT,
-            repo_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
-            github_token=gh_token, resume_session_id=recon_session,
+    # 3a. Technical PRD grounding (codebase tasks). The BACKEND converts a Story to a
+    #     Task and adds a FIRST-PASS PRD to the description; here we GROUND that PRD
+    #     against the REAL codebase (correcting file paths, contracts, data models to
+    #     what actually exists) before building to it. If no PRD is present at all
+    #     (edge case), we generate one. Reuses the recon session (already understands
+    #     the codebase), persists the result to the ticket + pending (shared → other
+    #     repos reuse it), and runs once per ticket. Skipped on a resume / non-git.
+    if is_git and recon_session and not resume_session_id and not pending.get("_prd_grounded"):
+        current = pending.get("user_input") or ""
+        has_prd = _PRD_MARKER in current
+        if has_prd:
+            before, _, existing_prd = current.partition(_PRD_MARKER)
+            await send(Envelope(
+                type="step_update", thread_id=thread_id,
+                data={"status": "running",
+                      "current_step": f"[{name}] Grounding the PRD against the current codebase"},
+            ).model_dump())
+            instruction = (
+                "The task description contains a PRD (below), drafted by the planner and "
+                "NOT necessarily written against THIS exact codebase. Using your "
+                "exploration above, REFINE it so every file path, module, API contract, "
+                "data model and integration matches what ACTUALLY exists in this repo. "
+                "Keep the same PRD sections/format; correct anything inaccurate; do NOT "
+                "invent. Output ONLY the refined PRD as Markdown.\n\n"
+                "=== Current PRD ===\n" + existing_prd.strip()
+            )
+        else:
+            before = current.rstrip() + "\n\n---\n\n"
+            await send(Envelope(
+                type="step_update", thread_id=thread_id,
+                data={"status": "running",
+                      "current_step": f"[{name}] Codebase task — writing a technical PRD from the codebase"},
+            ).model_dump())
+            instruction = (
+                "Using your exploration above, write a TECHNICAL PRD for this task that "
+                "fully specifies the mechanism (how it works end-to-end) against the REAL "
+                "code you found. Output ONLY the PRD as Markdown, following this format "
+                "exactly:\n\n" + _PRD_FORMAT
+            )
+        prd_res = await _run_with_heartbeat(
+            local_exec.run_claude_local(
+                instruction, repo_path, on_event=_on_event,  # stream tool activity
+                allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
+                github_token=gh_token, resume_session_id=recon_session,
+            ),
+            send=send, thread_id=thread_id, label="Working on the PRD", name=name,
         )
         recon_session = prd_res.get("session_id") or recon_session
         prd = (prd_res.get("result") or "").strip() if prd_res.get("ok") else ""
         if prd:
-            enriched = (
-                f"{pending.get('user_input') or ''}\n\n---\n\n{_PRD_MARKER}\n\n{prd}"
-            )[:20000]
-            pending["user_input"] = enriched  # shared across repos → reused, not regenerated
+            enriched = f"{before}{_PRD_MARKER}\n\n{prd}"[:20000]
+            pending["user_input"] = enriched   # shared across repos → reused
+            pending["_prd_grounded"] = True    # ground once per ticket
             try:
                 await client.update_task_ml(task_id, {"description": enriched}, model_used=_EPIC_MODELS)
             except Exception:  # noqa: BLE001 — persisting the PRD is best-effort
@@ -2562,6 +2647,16 @@ def _extract_repo_targets(text: str | None) -> list[dict]:
     for p in _extract_all_paths(text):
         name = Path(p).name
         url = by_name.get(name.lower())
+        # Ignore bare code-reference paths mentioned in the instructions (e.g.
+        # "use shared components in `/components`") that are neither a real repo
+        # (paired with a GitHub URL) nor an existing local directory. Without this
+        # a path like /components gets picked as the work dir → Permission denied.
+        if not url:
+            try:
+                if not Path(p).expanduser().is_dir():
+                    continue
+            except OSError:
+                continue
         targets.append({
             "path": p,
             "url": url,
@@ -2600,13 +2695,25 @@ def _resolve_local_project_path(task: dict, payload: dict) -> str:
     if overrides.get(tid):
         return str(Path(overrides[tid]).expanduser())
 
-    # PRIMARY — honour the location the human wrote in the Jira task.
+    # PRIMARY — honour the location the human wrote in the Jira task. Prefer a REAL
+    # repo (a path paired with a GitHub URL), then any surviving repo target
+    # (existing local dir), then a bare path that actually exists — never a
+    # code-reference path like `/components` that doesn't exist on disk.
     for field in ("humanInstructions", "description"):
-        found = _extract_path_from_text(task.get(field))
-        if found:
+        text = task.get(field)
+        if not text:
+            continue
+        targets = _extract_repo_targets(text)  # spurious/non-existent paths filtered out
+        with_url = next((t["path"] for t in targets if t.get("url")), None)
+        if with_url:
+            return with_url
+        if targets:
+            return targets[0]["path"]
+        found = _extract_path_from_text(text)
+        if found and Path(found).expanduser().exists():
             return found
 
-    # FALLBACK — only when no location was instructed anywhere.
+    # FALLBACK — no usable location instructed anywhere.
     root = payload.get("workspace_root") or str(Path.home() / "AgentOS")
     key = (
         task.get("projectKey")
@@ -2846,38 +2953,63 @@ async def handle_orchestrate_auto_local_run(
             #           never marked In Progress/Done — only ever converted
             #   Task  → implemented by the normal pipeline below (In Progress → Done)
             # Each is isolated: a failure must not abort the remaining queue.
-            if ttype in ("epic", "story"):
-                handler = _handle_epic if ttype == "epic" else _handle_story
-                code = "EPIC_DECOMPOSE_FAILED" if ttype == "epic" else "STORY_HANDLE_FAILED"
-                # Validation gate: Epics are always validated; a Story only when it
-                # is USER-driven (a SYSTEM/bot-created Story is trusted). A rejected
-                # ticket is commented + moved to Backlog inside the gate — skip it.
-                driven_by = str(task.get("drivenBy") or "").strip().upper()
-                needs_validation = (ttype == "epic") or (ttype == "story" and driven_by != "SYSTEM")
+            # Validation gate: Epics always; a Story only when USER-driven (a
+            # SYSTEM/bot-created Story is trusted). A rejected ticket is commented +
+            # moved to Backlog inside the gate — skip it here.
+            driven_by = str(task.get("drivenBy") or "").strip().upper()
+
+            if ttype == "epic":
                 try:
-                    if needs_validation and not await _validate_ticket_or_reject(
-                        client, task, ttype, payload, send, thread_id
-                    ):
+                    if not await _validate_ticket_or_reject(client, task, "epic", payload, send, thread_id):
                         processed += 1
                         continue
-                    await handler(client, task, payload, send, thread_id)
+                    await _handle_epic(client, task, payload, send, thread_id)
                 except Exception as exc:  # noqa: BLE001
-                    logger.warning("auto_local.%s_failed task=%s err=%s", ttype, tid, exc)
+                    logger.warning("auto_local.epic_failed task=%s err=%s", tid, exc)
                     try:
-                        await client.log_activity(f"Task {tid}: {ttype} handling errored — {str(exc)[:200]}")
-                        # Backlog only Epics for retry; a Story is left To Do (never
-                        # marked In Progress/Done/Backlog) so developers keep it.
-                        if ttype == "epic":
-                            await client.move_to_backlog(tid)
+                        await client.log_activity(f"Task {tid}: epic handling errored — {str(exc)[:200]}")
+                        await client.move_to_backlog(tid)
                     except Exception:  # noqa: BLE001
                         pass
                     await send(Envelope(
                         type=Envelope.TYPE_ERROR, thread_id=thread_id,
-                        data={"code": code, "task_id": tid, "message": str(exc)[:200]},
+                        data={"code": "EPIC_DECOMPOSE_FAILED", "task_id": tid, "message": str(exc)[:200]},
                     ).model_dump())
                 processed += 1
                 continue
 
+            if ttype == "story":
+                try:
+                    if driven_by != "SYSTEM" and not await _validate_ticket_or_reject(
+                        client, task, "story", payload, send, thread_id
+                    ):
+                        processed += 1
+                        continue
+                    new_desc = await _handle_story(client, task, payload, send, thread_id)
+                except Exception as exc:  # noqa: BLE001
+                    logger.warning("auto_local.story_failed task=%s err=%s", tid, exc)
+                    await client.log_activity(f"Task {tid}: story handling errored — {str(exc)[:200]}")
+                    await send(Envelope(
+                        type=Envelope.TYPE_ERROR, thread_id=thread_id,
+                        data={"code": "STORY_HANDLE_FAILED", "task_id": tid, "message": str(exc)[:200]},
+                    ).model_dump())
+                    processed += 1
+                    continue
+                # `agentos-auto story` (stories_only) = convert-only, stop here.
+                # Conversion failure (new_desc None) also stops. Otherwise fall
+                # through and code the now-Task IN THE SAME RUN (default agentos-auto).
+                if stories_only or not new_desc:
+                    processed += 1
+                    continue
+                task = {**task, "type": "Task", "description": new_desc}
+                ttype = "task"
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"jira_task_id": tid,
+                          "current_step": f"{jira_key}: implementing the converted Task now (In Progress → Done)"},
+                ).model_dump())
+                # ↓ falls through to the normal Task pipeline below
+
             task_payload = {
                 "thread_id": thread_id,
                 "jira_task_id": tid,