devops-bot-sdk 1.4.86__tar.gz → 1.4.90__tar.gz

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/PKG-INFO

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

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/pyproject.toml

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

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/sdk/__init__.py

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

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.86"
+SDK_VERSION    = "1.4.90"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -848,7 +848,10 @@ class BackendClient:
         url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml"
         headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
-        files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
+        # POST /tasks-ml must never carry an SLA target — the backend validator
+        # rejects any value not shaped like "8h", and SLA is not ours to set.
+        files = [(k, (None, str(v))) for k, v in fields.items()
+                 if v is not None and k not in ("slaTarget", "slaTargets")]
         for m in (model_used or []):
             files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:

{devops_bot_sdk-1.4.86 → devops_bot_sdk-1.4.90}/sdk/ipc/handlers.py

@@ -648,12 +648,20 @@ def _extract_email(text: str | None) -> str | None:
     return m.group(0).strip().lower() if m else None
 
 
+# Time fields inherited from the parent Epic onto each generated child.
+# Passed through VERBATIM (exactly as the backend returned them on GET) so the
+# POST never carries a reformatted-and-wrong date; absent/empty ones are dropped.
+# slaTarget[s] are deliberately excluded: POST /tasks-ml must never receive an
+# SLA target (its validator rejects anything not shaped like "8h").
+_EPIC_TIME_FIELDS = ("startDate", "endDate", "dueDate")
+
+
 def _epic_inherited_fields(task: dict) -> dict:
     """Parent-Epic fields a child Task should inherit (drops empties).
 
-    Time-related fields (startDate, dueDate, slaTarget) are intentionally NOT
-    inherited/sent — they're optional on the POST and left for the backend/board to
-    set, so the create call never carries a stale or wrongly-formatted date.
+    Includes the Epic's time targets (startDate, endDate, dueDate) when
+    present, so generated stories/tasks carry the same deadlines instead of
+    being created without any.
     """
     fields = {
         "projectKey": task.get("projectKey"),
@@ -661,6 +669,11 @@ def _epic_inherited_fields(task: dict) -> dict:
         "assigneeEmail": (task.get("assignee") or {}).get("email"),
         "teamId": task.get("teamId"),
     }
+    for k in _EPIC_TIME_FIELDS:
+        v = task.get(k)
+        # Scalars only: a nested object would be mangled by the multipart str().
+        if v and isinstance(v, (str, int, float)):
+            fields[k] = v
     sprint = task.get("sprint") or {}
     if sprint.get("jiraSprintId"):
         fields["jiraSprintId"] = sprint["jiraSprintId"]
@@ -1158,6 +1171,28 @@ def _wants_prd(text: str | None) -> bool:
     return bool(text and _PRD_RE.search(text))
 
 
+# An explicit directive to UPDATE the user story ITSELF ("update my user story
+# based on these parameters", "revise the story", "the user story should be
+# updated"). Here the story text IS the deliverable: its description is rewritten
+# per the given parameters and the ticket is marked Done — no Task conversion, no
+# PRD, no coding. The verb must sit DIRECTLY on the story object ("update the
+# user story"), so dev instructions that merely reference the story ("modify the
+# login form as per the user story") don't false-positive.
+_STORY_UPDATE_RE = re.compile(
+    r"\b(?:update|revise|rewrite|refine|rework|amend|modify|edit)\s+"
+    r"(?:(?:my|the|this|that|our|its)\s+)?(?:user[\s-]+)?stor(?:y|ies)\b"
+    r"|\b(?:user[\s-]+)?stor(?:y|ies)\s+"
+    r"(?:should\s+be|to\s+be|needs?(?:\s+to\s+be)?|must\s+be)\s+"
+    r"(?:updated|revised|rewritten|refined|reworked|amended|modified)\b",
+    re.I,
+)
+
+
+def _wants_story_update(text: str | None) -> bool:
+    """True when the humanInstructions explicitly ask to update the user story itself."""
+    return bool(text and _STORY_UPDATE_RE.search(text))
+
+
 # Signals that a ticket is DEVELOPMENT work (→ always gets a PRD). Deliberately
 # code-specific so Finance/HR/ops tickets don't false-positive (they get a PRD
 # only when explicitly requested).
@@ -1208,11 +1243,33 @@ def _build_prd_prompt(jira_key: str, summary: str, user_story: str | None,
     return "\n\n".join(parts)
 
 
+def _build_story_update_prompt(jira_key: str, summary: str, user_story: str | None,
+                               human_instructions: str) -> str:
+    """Prompt that REWRITES a user story's description per the operator's parameters."""
+    parts: list[str] = [
+        "UPDATE the user story below by applying the operator's parameters/changes. "
+        "This is a TEXT revision ONLY — do NOT create, edit, or delete any file. Keep "
+        "every part of the story that still applies, change exactly what the parameters "
+        "require, and keep it business-focused (no code, no technical design).",
+        f"=== USER STORY {jira_key} ===\nSummary: {summary}",
+        "Current description:\n"
+        + (_clip_text(user_story.strip(), _GEN_MAX_CHARS)
+           if user_story and user_story.strip() else "(none provided)"),
+        "Operator parameters / instructions:\n" + human_instructions.strip(),
+        "Output ONLY the full UPDATED user story as Markdown — no preamble, no "
+        "commentary, no diff — following this format exactly:\n\n" + _USER_STORY_FORMAT,
+    ]
+    return "\n\n".join(parts)
+
+
 async def _handle_story(
     client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: str,
 ) -> 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.
+    """Run a Story: when the humanInstructions explicitly ask to UPDATE the user
+    story itself, rewrite its description per those parameters and mark it Done
+    (no conversion, no coding). Otherwise: 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
@@ -1229,6 +1286,56 @@ async def _handle_story(
     summary = task.get("summary", "") or ""
     user_story = task.get("description") or ""
     human = task.get("humanInstructions")
+
+    # STEP 0 — explicit UPDATE directive ("update my user story based on these
+    # parameters"): the story text is the deliverable. Rewrite the description per
+    # the parameters and mark the Story Done — no Task conversion, no PRD, no
+    # coding. This outranks the codebase heuristics below: the parameters may
+    # mention dev terms (endpoints, repos) without asking for any code.
+    if _wants_story_update(human):
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"jira_task_id": tid, "task_id": tid,
+                  "current_step": f"Story {jira_key}: updating the user story per the instructions"},
+        ).model_dump())
+        gen = await _run_generation(
+            _build_story_update_prompt(jira_key, summary, user_story, human),
+            _resolve_local_project_path(task, payload),
+            send=send, thread_id=thread_id,
+            label=f"Story {jira_key}: updating user story",
+            github_token=await client.github_token(),
+        )
+        updated = "" if gen.get("limit_exceeded") else (gen.get("result") or "").strip()
+        if not updated:
+            # Leave the Story To Do so a later run retries; never mark Done on failure.
+            reason = (gen.get("error") or "update generation produced no content")[:200]
+            await client.log_activity(
+                f"Story {jira_key}: user-story update failed ({reason}) — left To Do for retry"
+            )
+            await send(Envelope(
+                type=Envelope.TYPE_ERROR, thread_id=thread_id,
+                data={"code": "STORY_UPDATE_FAILED", "task_id": tid, "message": reason},
+            ).model_dump())
+            return None
+        if not await client.update_task_ml(
+            tid, {"description": updated[:20000], "status": "Done"}, model_used=_EPIC_MODELS,
+        ):
+            await client.log_activity(f"Story {jira_key}: user-story update could not be saved")
+            await send(Envelope(
+                type=Envelope.TYPE_ERROR, thread_id=thread_id,
+                data={"code": "STORY_UPDATE_FAILED", "task_id": tid,
+                      "message": "could not save the updated user story"},
+            ).model_dump())
+            return None
+        await client.log_activity(f"Story {jira_key}: user story updated per instructions — Done")
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"jira_task_id": tid,
+                  "current_step": f"Story {jira_key}: description updated → Done"},
+        ).model_dump())
+        # The Story is complete — nothing to convert or code in this run.
+        return None
+
     # STEP 1 — validate whether this is a CODEBASE (development) task: repo links /
     # file paths in the instructions, or dev signals (PRs, branches, endpoints,
     # deploy, …). A codebase task ALWAYS gets a technical PRD built from the current
@@ -3374,11 +3481,16 @@ async def handle_orchestrate_auto_local_run(
                     ):
                         processed += 1
                         continue
-                    # agentMode gate: wait for human approval before converting Story→Task.
+                    # agentMode gate: wait for human approval before actioning the
+                    # Story (update-in-place when instructed, else convert to Task).
                     if agent_mode:
+                        action = (
+                            "update this Story's description per the instructions and mark it Done"
+                            if _wants_story_update(task.get("humanInstructions"))
+                            else "convert this Story into a Task"
+                        )
                         dec = await _gate_transform_approval(
-                            client, tid, jira_key, task.get("summary"),
-                            "convert this Story into a Task",
+                            client, tid, jira_key, task.get("summary"), action,
                             send, thread_id, should_stop,
                         )
                         if dec == "stopped":
@@ -3391,7 +3503,7 @@ async def handle_orchestrate_auto_local_run(
                         if dec != "approved":
                             await send(Envelope(
                                 type="step_update", thread_id=thread_id,
-                                data={"current_step": f"{jira_key}: {dec} — Story not converted"},
+                                data={"current_step": f"{jira_key}: {dec} — Story not actioned"},
                             ).model_dump())
                             processed += 1
                             continue