devops-bot-sdk 1.4.45__tar.gz → 1.4.47__tar.gz

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/PKG-INFO

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

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/pyproject.toml

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

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/sdk/__init__.py

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

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.45"
+SDK_VERSION    = "1.4.47"
 _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.45 → devops_bot_sdk-1.4.47}/sdk/ipc/handlers.py

@@ -653,18 +653,24 @@ async def _handle_story(
             github_token=await client.github_token(),
         )
         prd = (gen.get("result") or "").strip() if gen.get("ok") else ""
-        if not prd:
+        if prd:
+            # PRD lives alongside the user story in the (now Task) description.
+            new_description = f"{user_story}\n\n---\n\n{_PRD_MARKER}\n\n{prd}"[:20000]
+        else:
+            # PRD generation failed — do NOT abandon the story: it must still become
+            # a Task (per "a Story once run should be changed into Task"). The PRD
+            # directive stays in humanInstructions, so the later coding run can still
+            # produce the PRD.md file.
             reason = (gen.get("error") or "PRD generation produced no content")[:200]
-            # Leave the Story To Do (never mark it In Progress/Done/Backlog) so a
-            # retry or the developer can pick it up.
-            await client.log_activity(f"Story {jira_key}: PRD generation failed — {reason}")
+            await client.log_activity(
+                f"Story {jira_key}: PRD not pre-generated ({reason}) — converting to Task anyway"
+            )
             await send(Envelope(
-                type=Envelope.TYPE_ERROR, thread_id=thread_id,
-                data={"code": "STORY_PRD_FAILED", "task_id": tid, "message": reason},
+                type="step_update", thread_id=thread_id,
+                data={"jira_task_id": tid,
+                      "current_step": f"Story {jira_key}: PRD generation skipped ({reason[:60]}) "
+                                      "— converting to Task"},
             ).model_dump())
-            return
-        # PRD lives alongside the user story in the (now Task) description.
-        new_description = f"{user_story}\n\n---\n\n{_PRD_MARKER}\n\n{prd}"[:20000]
 
     # Convert Story → Task on the SAME ticket; leave it To Do so the next run codes
     # it. humanInstructions are untouched (they still carry the location + any PRD
@@ -682,14 +688,15 @@ async def _handle_story(
         ).model_dump())
         return
 
+    prd_in_desc = bool(new_description) or already_has_prd
     await client.log_activity(
-        f"Story {jira_key}: converted to Task{' with PRD' if wants_prd else ''} (To Do)"
+        f"Story {jira_key}: converted to Task{' with PRD' if prd_in_desc else ''} (To Do)"
     )
     await send(Envelope(
         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 wants_prd else "")
+                              + (" + PRD in description" if prd_in_desc else "")
                               + " — run again to implement"},
     ).model_dump())
 
@@ -2493,10 +2500,16 @@ async def handle_orchestrate_auto_local_run(
             # raised earliest is started first. Unknown/invalid timestamps sort last.
             tasks = sorted(tasks, key=_task_created_key)
 
+        # `stories_only` (agentos-auto story) → convert Stories to Tasks ONLY: no
+        # epic decomposition, no coding. Narrow the queue to Story-type tickets.
+        stories_only = bool(payload.get("stories_only"))
+        if stories_only:
+            tasks = [t for t in tasks if str(t.get("type") or "").strip().lower() == "story"]
+
         await send(Envelope(
             type="pipeline_started", thread_id=thread_id,
             data={"mode": "orchestrate-auto-local", "task_count": len(tasks),
-                  "only_keys": only_keys or None},
+                  "only_keys": only_keys or None, "stories_only": stories_only or None},
         ).model_dump())
 
         if not tasks:
@@ -2527,21 +2540,6 @@ async def handle_orchestrate_auto_local_run(
             project_path = _resolve_local_project_path(task, payload)
             ttype = str(task.get("type") or "").strip().lower()
 
-            # User STORIES are for the ASSIGNED DEVELOPERS, not the bot: the default
-            # auto-loop skips Story-type tickets and never marks them In Progress or
-            # Done. (An explicit target — `agentos-auto ticket <KEY>`, i.e. only_keys
-            # set — still lets the bot act on a Story: generate its PRD and convert
-            # it to a Task.) Once a ticket is a TASK it is coded normally
-            # (In Progress → Done), even when it descended from an Epic/Story.
-            if ttype == "story" and not only_keys:
-                await send(Envelope(
-                    type="step_update", thread_id=thread_id,
-                    data={"jira_task_id": tid,
-                          "current_step": f"({idx}/{total}) {jira_key}: skipped — user Story "
-                                          f"left for the assigned developer"},
-                ).model_dump())
-                continue
-
             await send(Envelope(
                 type="step_update", thread_id=thread_id,
                 data={"current_step": f"({idx}/{total}) {jira_key}: {task.get('summary', '')}".rstrip(": "),
@@ -2550,8 +2548,9 @@ async def handle_orchestrate_auto_local_run(
 
             # Staged decomposition — an EPIC and a STORY are transformed, not coded:
             #   Epic  → decompose into user Stories (To Do), mark Epic Done
-            #   Story → (optional PRD) + convert to Task (To Do)  [only when targeted]
-            #   Task  → implemented by the normal pipeline below
+            #   Story → (optional PRD) + ALWAYS convert to Task (To Do); a Story is
+            #           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

{devops_bot_sdk-1.4.45 → devops_bot_sdk-1.4.47}/sdk/run_auto.py

@@ -11,6 +11,8 @@ Commands:
     agentos-auto resume          alias for run — re-fetches remaining To Do tasks
     agentos-auto ticket K [K...] run ONLY the named Jira ticket(s), e.g. BBW-81 —
                                  any status, in the order given (alias: tickets)
+    agentos-auto story [K ...]   convert Story(ies) → Task(s) only (with PRD), NO
+                                 coding; no keys = all To Do Stories (alias: stories)
     agentos-auto stop            ask the running loop to pause after the current task
     agentos-auto status          show whether the background loop is running / stop pending
     agentos-auto update          upgrade the SDK to the latest version
@@ -298,7 +300,8 @@ async def _send(env: dict) -> None:
         print(f"  [{etype}] {json.dumps(data)[:200]}")
 
 
-def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None) -> None:
+def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
+              stories_only: bool = False) -> None:
     from sdk import local_exec
     from sdk.client import BackendClient, register_status_observer
     from sdk.ipc import handlers
@@ -320,6 +323,9 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None) ->
     if only_keys:
         # Targeted run: only these Jira tickets, in this order, regardless of status.
         payload["only_keys"] = only_keys
+    if stories_only:
+        # Story→Task-only run: convert Stories to Tasks (with PRD), no coding.
+        payload["stories_only"] = True
 
     _clear_stop()  # a fresh run/resume clears any stale stop flag
     _clear_backlogged()  # session-scoped: only track Backlog moves from THIS run
@@ -458,17 +464,22 @@ def main() -> None:
         print("stop pending: yes" if _stop_requested() else "stop pending: no")
         return
 
-    if cmd in ("run", "resume", "ticket", "tickets"):
-        # Targeted run: `ticket`/`tickets` runs ONLY the named Jira keys (any
-        # status, in the order given); `run`/`resume` runs the whole To Do queue.
+    if cmd in ("run", "resume", "ticket", "tickets", "story", "stories"):
+        # Run modes:
+        #   run/resume   → the whole To Do queue
+        #   ticket K...  → ONLY the named Jira keys (any status, in order)
+        #   story [K...] → convert Stories → Tasks only (with PRD); NO coding.
+        #                  With keys: those Stories; without: every To Do Story.
         only_keys: list[str] | None = None
-        if cmd in ("ticket", "tickets"):
+        stories_only = cmd in ("story", "stories")
+        if cmd in ("ticket", "tickets", "story", "stories"):
             only_keys = _parse_ticket_keys(argv)
-            if not only_keys:
+            if cmd in ("ticket", "tickets") and not only_keys:
                 print("usage: agentos-auto ticket <JIRA-KEY> [<JIRA-KEY> ...]")
                 print("   e.g. agentos-auto ticket BBW-81")
                 print("        agentos-auto ticket BBW-81 BBW-80")
                 sys.exit(1)
+            # `story` keys are OPTIONAL — no keys means "all To Do Stories".
 
         # Self-update FIRST (before the already-running check) so the installed
         # package is refreshed even when a daemon is already running — otherwise a
@@ -494,14 +505,18 @@ def main() -> None:
         # attached (useful for debugging). On platforms without fork we stay attached.
         foreground = "--foreground" in argv or "-f" in argv
         if not foreground and hasattr(os, "fork"):
-            target = f" — tickets: {', '.join(only_keys)}" if only_keys else ""
+            if stories_only:
+                target = (f" — stories→tasks: {', '.join(only_keys)}" if only_keys
+                          else " — converting all To Do Stories → Tasks")
+            else:
+                target = f" — tickets: {', '.join(only_keys)}" if only_keys else ""
             print(f"▶ agentos-auto started in the background{target} — it keeps running "
                   "after you close this terminal.")
             print(f"  logs:   {_LOG_FILE}")
             print("  status: agentos-auto status")
             print("  stop:   agentos-auto stop")
         if not foreground and _daemonize():
-            _run_loop(workspace_root, only_keys)  # only the detached daemon child reaches here
+            _run_loop(workspace_root, only_keys, stories_only)  # detached daemon child only
             return
         if not foreground:
             print("note: background mode unavailable on this platform — running in the "
@@ -510,10 +525,10 @@ def main() -> None:
             # Foreground run still records a PID so stop/status can find it.
             _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
             _PID_FILE.write_text(str(os.getpid()))
-        _run_loop(workspace_root, only_keys)
+        _run_loop(workspace_root, only_keys, stories_only)
         return
 
-    print(f"unknown command '{cmd}'. use: run | resume | ticket | stop | status | update")
+    print(f"unknown command '{cmd}'. use: run | resume | ticket | story | stop | status | update")
     sys.exit(1)