devops-bot-sdk 1.4.39__tar.gz → 1.4.46__tar.gz

{devops_bot_sdk-1.4.39 → devops_bot_sdk-1.4.46}/PKG-INFO

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

{devops_bot_sdk-1.4.39 → devops_bot_sdk-1.4.46}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.39 → devops_bot_sdk-1.4.46}/pyproject.toml

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

{devops_bot_sdk-1.4.39 → devops_bot_sdk-1.4.46}/sdk/__init__.py

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

{devops_bot_sdk-1.4.39 → devops_bot_sdk-1.4.46}/sdk/client.py

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

@@ -393,12 +393,16 @@ def _build_epic_prompt(jira_key: str, summary: str, description: str | None,
         '      "humanInstructions": "Operator instructions to implement THIS story. MUST '
         "repeat the same project location/path and constraints from the epic so the "
         'coding run works in the right place.",\n'
+        '      "assigneeEmail": "dev@company.com",\n'
         '      "points": 5\n'
         "    }\n"
         "  ]\n"
         "}\n"
         "Create as many stories as the epic genuinely needs (do not pad or truncate "
-        "artificially); each story must be independently implementable."
+        "artificially); each story must be independently implementable.\n"
+        "assigneeEmail is OPTIONAL per story: set it ONLY when the epic explicitly "
+        "assigns that specific work to a named person/email (e.g. 'assign the API to "
+        "alice@x.com'); otherwise omit it."
     )
     return "\n\n".join(parts)
 
@@ -423,6 +427,17 @@ def _extract_json_block(text: str | None) -> dict | None:
     return None
 
 
+_EMAIL_RE = re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")
+
+
+def _extract_email(text: str | None) -> str | None:
+    """First email address mentioned in `text`, lower-cased, or None."""
+    if not text:
+        return None
+    m = _EMAIL_RE.search(text)
+    return m.group(0).strip().lower() if m else None
+
+
 def _epic_inherited_fields(task: dict) -> dict:
     """Parent-Epic fields a child Task should inherit (drops empties)."""
     def _date(v: object) -> str | None:
@@ -502,24 +517,34 @@ async def _handle_epic(
     await send(Envelope(
         type="step_update", thread_id=thread_id,
         data={"jira_task_id": tid, "current_step": f"Epic {jira_key}: marked Done — "
-              f"creating {min(len(stories), _MAX_EPIC_STORIES)} child task(s)"},
+              f"creating {min(len(stories), _MAX_EPIC_STORIES)} user Story(ies)"},
     ).model_dump())
 
     # 3. Create a To Do child Task per story, inheriting the Epic's fields.
     inherited = _epic_inherited_fields(task)
+    # An assignee email named in the EPIC's description/instructions overrides the
+    # inherited assignee — but ONLY on the CHILD task, never on the parent Epic.
+    desc_email = _extract_email(description) or _extract_email(human)
     created: list[str] = []
     for st in stories[:_MAX_EPIC_STORIES]:
         if not isinstance(st, dict) or not (st.get("summary") or "").strip():
             continue
+        # Precedence: a per-story email the model extracted → an email in the
+        # epic description/instructions → the inherited parent assignee.
+        story_email = _extract_email(str(st.get("assigneeEmail") or ""))
+        child_email = story_email or desc_email or inherited.get("assigneeEmail")
         fields = {
             **inherited,
-            "type": "Task",
+            "type": "Story",   # Epic decomposes into user Stories; a Story later
+                               # becomes a Task (see _handle_story) when it is run.
             "status": "To Do",
             "summary": str(st.get("summary", "")).strip()[:250],
             "description": str(st.get("description", "") or "")[:20000],
             "humanInstructions": str(st.get("humanInstructions") or human or "")[:20000] or None,
             "parentTaskId": tid,
         }
+        if child_email:
+            fields["assigneeEmail"] = child_email
         if st.get("points"):
             fields["points"] = st["points"]
         new_id = await client.create_task_ml(fields, model_used=_EPIC_MODELS)
@@ -531,13 +556,148 @@ async def _handle_epic(
             ).model_dump())
 
     await client.log_activity(
-        f"Epic {jira_key}: Done — created {len(created)}/{len(stories)} child To Do task(s)"
+        f"Epic {jira_key}: Done — created {len(created)}/{len(stories)} To Do user Story(ies)"
     )
     await send(Envelope(
         type="step_update", thread_id=thread_id,
         data={"jira_task_id": tid,
-              "current_step": f"Epic {jira_key} complete — {len(created)} child task(s) queued "
-                              "(run again to implement them)"},
+              "current_step": f"Epic {jira_key} complete — {len(created)} Story(ies) queued "
+                              "(run again: each Story → PRD + Task)"},
+    ).model_dump())
+
+
+# ── Story → Task (with optional PRD) ───────────────────────────────────────
+# A Story (produced by decomposing an Epic) is not coded directly. When it is
+# run: if a PRD is asked for in the instructions, generate one and fold it into
+# the description alongside the user story; then convert the ticket to a Task
+# (kept To Do) so the next run implements it through the normal pipeline.
+_PRD_RE = re.compile(r"\bprd\b|product\s+requirements?\s+document", re.I)
+# Section header the generated PRD is filed under in the description. Also the
+# idempotency marker: if it's already present we neither regenerate nor re-write.
+_PRD_MARKER = "# PRD — Product Requirements Document"
+
+
+def _wants_prd(text: str | None) -> bool:
+    """True when the text asks for a PRD / product-requirements document."""
+    return bool(text and _PRD_RE.search(text))
+
+
+def _build_prd_prompt(jira_key: str, summary: str, user_story: str | None,
+                      human_instructions: str | None) -> str:
+    """Read-only prompt that produces a PRD (Markdown) for a user story."""
+    parts: list[str] = [
+        "Write a PRD (Product Requirements Document) for the user story below. This is "
+        "ANALYSIS ONLY — do NOT create, edit, or delete any file.",
+        f"=== USER STORY {jira_key} ===\nSummary: {summary}",
+    ]
+    if user_story and user_story.strip():
+        parts.append("User story / description:\n" + _clip_text(user_story.strip()))
+    if human_instructions and human_instructions.strip():
+        parts.append("Operator instructions:\n" + human_instructions.strip())
+    parts.append(
+        "Explore the codebase (CLAUDE.md, graphify, Read/Glob/Grep) to ground the PRD in "
+        "the REAL system. Output ONLY the PRD as Markdown — no preamble, no code edits — "
+        "with sections: Overview, Goals & Success Metrics, User Stories, Functional "
+        "Requirements, Non-Functional Requirements, Acceptance Criteria, Out of Scope, "
+        "Dependencies & Risks."
+    )
+    return "\n\n".join(parts)
+
+
+async def _handle_story(
+    client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: 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.
+
+    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.
+    """
+    from sdk import local_exec, graphify
+
+    tid = str(task.get("id", ""))
+    jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "") or "STORY"
+    summary = task.get("summary", "") or ""
+    user_story = task.get("description") or ""
+    human = task.get("humanInstructions")
+    wants_prd = _wants_prd(human) or _wants_prd(user_story)
+
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"jira_task_id": tid, "task_id": tid,
+              "current_step": f"Story {jira_key}: "
+                              + ("generating PRD, then " if wants_prd else "")
+                              + "converting to Task"},
+    ).model_dump())
+
+    # Idempotent: if a PRD is already in the description, don't regenerate it or
+    # re-write the description — only the type conversion (if still needed) runs.
+    already_has_prd = _PRD_MARKER in (user_story or "")
+    new_description: str | None = None
+    if wants_prd and already_has_prd:
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"jira_task_id": tid,
+                  "current_step": f"Story {jira_key}: PRD already present — skipping regeneration"},
+        ).model_dump())
+    elif wants_prd:
+        project_path = _resolve_local_project_path(task, payload)
+        try:
+            await graphify.prepare(project_path)
+        except Exception:  # noqa: BLE001
+            pass
+        gen = await local_exec.run_claude_local(
+            _build_prd_prompt(jira_key, summary, user_story, human),
+            project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only analysis
+            github_token=await client.github_token(),
+        )
+        prd = (gen.get("result") or "").strip() if gen.get("ok") else ""
+        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]
+            await client.log_activity(
+                f"Story {jira_key}: PRD not pre-generated ({reason}) — converting to Task anyway"
+            )
+            await send(Envelope(
+                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())
+
+    # 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
+    # directive, so the coding run can also write the PRD.md file if asked).
+    update: dict = {"type": "Task"}
+    if new_description:
+        update["description"] = new_description
+    if not await client.update_task_ml(tid, update, model_used=_EPIC_MODELS):
+        # Leave the Story To Do (never In Progress/Done/Backlog) on failure.
+        await client.log_activity(f"Story {jira_key}: convert-to-Task failed")
+        await send(Envelope(
+            type=Envelope.TYPE_ERROR, thread_id=thread_id,
+            data={"code": "STORY_CONVERT_FAILED", "task_id": tid,
+                  "message": "could not convert Story to Task"},
+        ).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 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 prd_in_desc else "")
+                              + " — run again to implement"},
     ).model_dump())
 
 
@@ -2372,6 +2532,7 @@ async def handle_orchestrate_auto_local_run(
             jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "")
             agent_mode = bool(task.get("agentMode", True))   # default True (fail-safe)
             project_path = _resolve_local_project_path(task, payload)
+            ttype = str(task.get("type") or "").strip().lower()
 
             await send(Envelope(
                 type="step_update", thread_id=thread_id,
@@ -2379,23 +2540,30 @@ async def handle_orchestrate_auto_local_run(
                       "project_path": project_path, "jira_task_id": tid, "agent_mode": agent_mode},
             ).model_dump())
 
-            # EPIC → decompose (generate user stories, mark Done, create To Do
-            # child tasks) instead of coding it directly. Isolated like every other
-            # task: a failure here must not abort the remaining queue.
-            if str(task.get("type") or "").strip().lower() == "epic":
+            # Staged decomposition — an EPIC and a STORY are transformed, not coded:
+            #   Epic  → decompose into user Stories (To Do), mark Epic Done
+            #   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
+                code = "EPIC_DECOMPOSE_FAILED" if ttype == "epic" else "STORY_HANDLE_FAILED"
                 try:
-                    await _handle_epic(client, task, payload, send, thread_id)
+                    await handler(client, task, payload, send, thread_id)
                 except Exception as exc:  # noqa: BLE001
-                    logger.warning("auto_local.epic_failed task=%s err=%s", tid, exc)
+                    logger.warning("auto_local.%s_failed task=%s err=%s", ttype, tid, exc)
                     try:
-                        await client.log_activity(f"Task {tid}: epic decomposition errored — {str(exc)[:200]}")
-                        await client.move_to_backlog(tid)
+                        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)
                     except Exception:  # noqa: BLE001
                         pass
                     await send(Envelope(
                         type=Envelope.TYPE_ERROR, thread_id=thread_id,
-                        data={"code": "EPIC_DECOMPOSE_FAILED", "task_id": tid,
-                              "message": str(exc)[:200]},
+                        data={"code": code, "task_id": tid, "message": str(exc)[:200]},
                     ).model_dump())
                 processed += 1
                 continue