devops-bot-sdk 1.4.58__tar.gz → 1.4.62__tar.gz

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/PKG-INFO

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

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/pyproject.toml

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

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.58
+Version: 1.4.62
 
 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.58"
+__version__ = "1.4.62"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.58"
+SDK_VERSION    = "1.4.62"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time

{devops_bot_sdk-1.4.58 → devops_bot_sdk-1.4.62}/sdk/ipc/handlers.py

@@ -573,27 +573,37 @@ def _build_validation_prompt(kind: str, jira_key: str, summary: str,
         "Human Instructions:\n" + (human.strip() if human and human.strip() else "(none provided)"),
     ]
     parts.append(
+        "Judge the ticket in the context of what it ACTUALLY asks for — it may be "
+        "software, documentation, analysis, Finance, HR or operations work. Do NOT "
+        "impose software requirements on a non-software ticket.\n\n"
         "A VALID ticket MUST have:\n"
         "- A clear, unambiguous goal and scope (no hand-waving).\n"
-        "- Explicit Human Instructions: for codebase work, the repository link(s) "
-        "and/or file path(s), the branch/PR convention, and build/run/test steps.\n"
-        "- Observable, testable acceptance criteria.\n"
+        "- A clearly-defined deliverable or outcome, and — when a location matters — "
+        "WHERE to produce it (a folder path, a repository, or a document).\n"
+        "- Observable, testable acceptance criteria (or an equally concrete definition of done).\n"
+        "- ONLY IF the work requires CODE CHANGES to a software project: the target "
+        "repository link(s) and/or file path(s), the branch/PR convention, and "
+        "build/run/test steps. Do NOT demand these for documentation, content, analysis "
+        "or other non-code deliverables.\n"
         + ("- Enough concrete detail to decompose into independent user stories.\n"
            if kind == "epic" else
            "- A clear 'As a <role>, I want <capability>, so that <benefit>' intent plus "
            "testable acceptance criteria.\n")
-        + "- Any THIRD-PARTY INTEGRATION or human-effort dependency (API keys, OAuth "
-        "credentials, external accounts, secrets, manual provisioning, DNS, billing) "
-        "MUST be named explicitly WITH who provides it. If such a dependency is implied "
-        "but undefined/missing, REJECT.\n\n"
+        + "- Any THIRD-PARTY INTEGRATION or human-effort dependency the work GENUINELY "
+        "needs (API keys, OAuth credentials, external accounts, secrets, manual "
+        "provisioning, DNS, billing) MUST be named WITH who provides it; if such a "
+        "REQUIRED dependency is undefined, REJECT.\n\n"
+        "A ticket that clearly states its deliverable and where to produce it is VALID "
+        "even without repository/branch details. Reject only for genuinely missing or "
+        "ambiguous information — not for absent software details the task does not need.\n\n"
         "Output ONLY a fenced ```json block, nothing else:\n"
         "{\n"
         '  "valid": true or false,\n'
         '  "comment": "When invalid: a concise, TECHNICAL rejection that lists EXACTLY '
-        "what is missing or ambiguous and must be added. Use precise engineering "
-        "terminology (API contract, data model/schema, auth/OAuth flow, env/config, "
-        "acceptance criteria, target repository/branch, integration credentials & "
-        'ownership). When valid: empty string."\n'
+        "what is missing or ambiguous and must be added, in terms appropriate to the "
+        "ticket's domain (for software: API contract, data model/schema, auth flow, "
+        "env/config, target repository/branch; for other work: the missing deliverable, "
+        'location, criteria, or dependency). When valid: empty string."\n'
         "}"
     )
     return "\n\n".join(parts)
@@ -651,6 +661,13 @@ async def _validate_ticket_or_reject(
                 "criteria; and the credentials/ownership for any third-party integration.")
     body = f"{_AI_COMMENT_LABEL}\n\n{comment or fallback}"
     await client.add_comment(tid, body)
+    # The backend only accepts a Backlog transition when a timer is running, so start
+    # one (mark In Progress) then park it — otherwise move_to_backlog 404s with
+    # "No running timer found". This In-Progress blip is the reject/park path only.
+    try:
+        await client.mark_in_progress(tid)
+    except Exception:  # noqa: BLE001
+        pass
     await client.move_to_backlog(tid)
     await client.log_activity(f"{kind} {jira_key}: REJECTED by validation gate — commented + moved to Backlog")
     await send(Envelope(
@@ -837,10 +854,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.
@@ -938,9 +959,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(
@@ -1281,35 +1304,55 @@ 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())
+    # 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 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
+            instruction, repo_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
             github_token=gh_token, resume_session_id=recon_session,
         )
         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
@@ -2829,38 +2872,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,