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

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

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

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

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

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

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

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

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

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

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

@@ -128,6 +128,11 @@ _PLAN_DEADLINE_S = float(os.getenv("AGENTOS_PLAN_DEADLINE_S", "") or 180.0)
 # plan (the "follows my instructions sometimes, not others" failure mode). ~6k
 # tokens at ~4 chars/token.
 _DESC_MAX_CHARS = 24_000
+# Analysis/generation prompts (epic decomposition, PRD, validation) must see the
+# WHOLE epic/story, not a middle-elided slice — dropping requirements is what makes
+# the model hallucinate to fill the gap on large tickets. Claude has a large context
+# window, so give these a generous budget (~30k tokens). Env-tunable.
+_GEN_MAX_CHARS = int(os.getenv("AGENTOS_GEN_MAX_CHARS", "") or 120_000)
 
 
 def _clip_text(text: str, max_chars: int = _DESC_MAX_CHARS) -> str:
@@ -545,12 +550,18 @@ def _build_epic_prompt(jira_key: str, summary: str, description: str | None,
         "in that story's Notes — do NOT fabricate a solution.\n"
         "- Prefer fewer, well-grounded stories over many speculative ones. Every story "
         "must trace back to something in the epic.\n"
+        "- The epic may be LONG: read ALL of it and cover every stated requirement across "
+        "the stories — do not drop, summarise away, or skip parts, and do not pad with "
+        "invented scope to look complete. If you cannot ground a piece, note it as an open "
+        "question instead of fabricating.\n"
+        "- Before finalising, self-check: does every story trace to the epic, and do the "
+        "stories together cover the epic's scope? Drop any story you cannot ground.\n"
         "- This epic may be for ANY domain (software, Finance, HR, operations, …). Match "
         "the stories to the epic's actual domain; do not assume it is software.",
         f"=== EPIC {jira_key} ===\nSummary: {summary}",
     ]
     if description and description.strip():
-        parts.append("Description:\n" + _clip_text(description.strip()))
+        parts.append("Description:\n" + _clip_text(description.strip(), _GEN_MAX_CHARS))
     if human_instructions and human_instructions.strip():
         parts.append(
             "Operator instructions (authoritative — carry any project location / "
@@ -770,7 +781,7 @@ def _build_validation_prompt(kind: str, jira_key: str, summary: str,
         "the required structure or information is not strictly present, REJECT it — a "
         "vague or under-specified ticket must NOT pass.",
         f"=== {k} {jira_key} ===\nSummary: {summary or '(none)'}",
-        "Description:\n" + (_clip_text(description.strip()) if description and description.strip() else "(none provided)"),
+        "Description:\n" + (_clip_text(description.strip(), _GEN_MAX_CHARS) if description and description.strip() else "(none provided)"),
         "Human Instructions:\n" + (human.strip() if human and human.strip() else "(none provided)"),
     ]
     is_epic = kind == "epic"
@@ -899,11 +910,67 @@ async def _validate_ticket_or_reject(
     return False
 
 
+def _build_epic_titles_prompt(jira_key: str, summary: str, description: str | None,
+                              human_instructions: str | None, story_count: int | None = None,
+                              story_titles: list[str] | None = None) -> str:
+    """Phase-1 prompt: produce the epic PLAN + a small list of story TITLES only (no
+    full descriptions). Kept small so the output can't overflow; each story is
+    expanded individually afterwards to avoid context pressure / hallucination."""
+    parts: list[str] = [
+        "You are decomposing a JIRA EPIC into a LIST of user-story TITLES — titles only, "
+        "NOT full descriptions yet. This is ANALYSIS ONLY — do NOT create/edit any file.",
+        "Faithfulness (critical): derive the stories STRICTLY from the epic's own "
+        "Scope / Requirements / User-Stories content. Do NOT invent, add, or split "
+        "stories based on assumptions or on what the codebase happens to contain. Cover "
+        "the epic's stated scope and NOTHING beyond it. If the epic is too vague to split "
+        "faithfully, produce FEWER stories and note the ambiguity in the plan — never "
+        "guess to look complete.",
+        f"=== EPIC {jira_key} ===\nSummary: {summary}",
+    ]
+    if description and description.strip():
+        parts.append("Description:\n" + _clip_text(description.strip(), _GEN_MAX_CHARS))
+    if human_instructions and human_instructions.strip():
+        parts.append("Operator instructions:\n" + human_instructions.strip())
+    parts.append(
+        "You MAY glance at the codebase (CLAUDE.md, graphify, Read/Glob/Grep) ONLY to "
+        "phrase a title accurately or confirm a module name — NEVER to introduce scope "
+        "the epic does not state. The stories come from the EPIC, not the code.\n\n"
+        + (("The epic already lists its stories — use EXACTLY these titles, VERBATIM, in "
+            "order; do NOT invent, rename, merge, add, drop, or reorder:\n"
+            + "\n".join(f"  {i}. {t}" for i, t in enumerate(story_titles, 1)) + "\n")
+           if story_titles else
+           (f"Produce EXACTLY {story_count} story titles.\n" if story_count else
+            "Produce as many story titles as the epic genuinely needs (no padding).\n"))
+        + "\nOutput ONLY a single fenced ```json block, nothing else:\n"
+        "{\n"
+        '  "plan": "an ordered, numbered high-level implementation plan for the epic",\n'
+        '  "stories": [ {"summary": "short imperative story title", '
+        '"assigneeEmail": "only if the epic assigns it to a named person", "points": 5} ]\n'
+        "}"
+    )
+    return "\n\n".join(parts)
+
+
+def _build_one_story_prompt(jira_key: str, title: str, index: int, total: int) -> str:
+    """Phase-2 prompt: expand ONE story's full description, resuming the grounding
+    session from the titles pass so the codebase context is retained."""
+    return (
+        f"Now write user story {index} of {total} for epic {jira_key}.\n"
+        f"Story title (use it VERBATIM as the summary): {title}\n\n"
+        "Using the epic and the codebase you already explored, write ONLY this ONE "
+        "story's description in the USER STORY FORMAT below — grounded and specific, with "
+        "no invented scope and nothing about other stories. Output ONLY the Markdown "
+        "(no JSON, no preamble, no closing commentary).\n\n"
+        "=== USER STORY FORMAT ===\n" + _USER_STORY_FORMAT
+    )
+
+
 async def _handle_epic(
     client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: str,
 ) -> None:
-    """Decompose an Epic: generate user stor(y|ies), mark the Epic Done with the
-    detailed description + plan, then create a To Do child Task per story.
+    """Decompose an Epic ONE STORY AT A TIME: a small plan+titles pass, then expand
+    each story individually (resuming the grounding session), creating each To Do
+    child Story (and optional .md file) as it is produced.
 
     Child tasks are created in "To Do"; a later `agentos-auto` run picks them up and
     implements them through the normal grounded pipeline. Best-effort throughout —
@@ -925,47 +992,51 @@ async def _handle_epic(
               "current_step": f"Epic {jira_key}: analysing & generating user stories"},
     ).model_dump())
 
-    # 1. Generate the decomposition, grounded in the codebase where one exists.
-    #    Priority for how many stories + their titles:
-    #      (a) the epic ENUMERATES its stories (a "User Stories" list) → use those
-    #          exact titles and count, verbatim;
-    #      (b) else an explicit "build N stories" count → exactly N;
-    #      (c) else the model decides (bounded by _MAX_EPIC_STORIES).
+    # How many stories + their titles:
+    #   (a) the epic ENUMERATES its stories → use those exact titles/count, verbatim;
+    #   (b) else an explicit "build N stories" count → exactly N;
+    #   (c) else the model decides (bounded by _MAX_EPIC_STORIES).
     story_titles = _extract_story_titles(description) or _extract_story_titles(human)
     story_count = (len(story_titles) if story_titles
                    else (_extract_story_count(description) or _extract_story_count(human)))
     limit = story_count or _MAX_EPIC_STORIES
+    gh_token = await client.github_token()
     try:
         await graphify.prepare(project_path)
     except Exception:  # noqa: BLE001
         pass
-    gen = await _run_generation(
-        _build_epic_prompt(jira_key, summary, description, human,
-                           story_count=story_count, story_titles=story_titles or None),
+
+    # ── Phase 1: PLAN + story TITLES (one small, grounded pass) ──────────────
+    plan_gen = await _run_generation(
+        _build_epic_titles_prompt(jira_key, summary, description, human,
+                                  story_count=story_count, story_titles=story_titles or None),
         project_path, send=send, thread_id=thread_id,
-        label=f"Epic {jira_key}: generating user stories",
-        github_token=await client.github_token(),
+        label=f"Epic {jira_key}: planning & listing stories",
+        github_token=gh_token,
     )
-    # A usage-limit hit must stop and retry later. For ANY other outcome, still try
-    # to parse the JSON — the model often produces a valid decomposition even when the
-    # run is flagged is_error (e.g. a stray read-only tool denial during exploration),
-    # and the result then lands in `error`. Don't discard that work over an is_error flag.
-    if gen.get("limit_exceeded"):
-        await client.log_activity(f"Epic {jira_key}: usage limit during decomposition — will retry after reset")
+    if plan_gen.get("limit_exceeded"):
+        await client.log_activity(f"Epic {jira_key}: usage limit while planning — will retry after reset")
         await client.move_to_backlog(tid)
         await send(Envelope(
             type=Envelope.TYPE_ERROR, thread_id=thread_id,
             data={"code": "EPIC_DECOMPOSE_LIMIT", "task_id": tid,
-                  "message": "Claude usage limit reached during epic decomposition"},
+                  "message": "Claude usage limit reached while planning the epic"},
         ).model_dump())
         return
-    doc = _extract_json_block(gen.get("result") or gen.get("error") or "")
-    stories = (doc or {}).get("stories") or []
-    if not doc or not stories:
-        had_output = bool(gen.get("result") or gen.get("error"))
-        reason = ("model output did not contain a parseable decomposition JSON"
-                  if had_output else
-                  (gen.get("error") or "no output from the decomposition run"))[:300]
+    recon_session = plan_gen.get("session_id")
+    doc = _extract_json_block(plan_gen.get("result") or plan_gen.get("error") or "") or {}
+    specs = doc.get("stories") or []
+    # Enumerated titles are authoritative — align to them (keep any per-story email/points).
+    if story_titles:
+        specs = [
+            {"summary": t,
+             "assigneeEmail": (specs[i].get("assigneeEmail") if i < len(specs) and isinstance(specs[i], dict) else None),
+             "points": (specs[i].get("points") if i < len(specs) and isinstance(specs[i], dict) else None)}
+            for i, t in enumerate(story_titles)
+        ]
+    specs = [s for s in specs[:limit] if isinstance(s, dict) and str(s.get("summary", "")).strip()]
+    if not specs:
+        reason = "could not produce a valid story list from the epic"
         await client.log_activity(f"Epic {jira_key}: decomposition failed — {reason}")
         await client.move_to_backlog(tid)
         await send(Envelope(
@@ -974,98 +1045,100 @@ async def _handle_epic(
         ).model_dump())
         return
 
-    # 2. Mark the Epic Done. Do NOT touch the Epic's description — the parent Epic's
-    #    description stays exactly as the human wrote it; only the status and the AI
-    #    plan are recorded.
-    plan = (doc.get("plan") or "")[:8000]
+    # ── Mark the Epic Done (description untouched; only status + AI plan recorded) ──
+    plan = str(doc.get("plan") or "")[:8000]
     await client.update_task_ml(
         tid, {"status": "Done", "initialAiPlan": plan}, model_used=_EPIC_MODELS,
     )
+    total = len(specs)
     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), limit)} user Story(ies)"},
+        data={"jira_task_id": tid,
+              "current_step": f"Epic {jira_key}: marked Done — building {total} user "
+                              f"stor{'y' if total == 1 else 'ies'} one by one"},
     ).model_dump())
 
-    # 3. Create a To Do child Task per story, inheriting the Epic's fields.
+    # Optional deliverables folder (from humanInstructions OR description).
+    from pathlib import Path
+    story_dir = _extract_stories_dir(human) or _extract_stories_dir(description)
+    dir_path = None
+    if story_dir:
+        try:
+            dir_path = Path(story_dir).expanduser()
+            dir_path.mkdir(parents=True, exist_ok=True)  # create from scratch
+        except Exception:  # noqa: BLE001
+            dir_path = None
+
+    # ── Phase 2: expand + create EACH story ONE BY ONE (resume the grounding session) ──
     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[:limit]:
-        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 ""))
+    written = 0
+    for i, spec in enumerate(specs, 1):
+        title = str(spec.get("summary", "")).strip()[:250]
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"jira_task_id": tid,
+                  "current_step": f"Epic {jira_key}: story {i}/{total} — {title}"},
+        ).model_dump())
+        one = await _run_generation(
+            _build_one_story_prompt(jira_key, title, i, total),
+            project_path, send=send, thread_id=thread_id,
+            label=f"Epic {jira_key}: story {i}/{total}",
+            github_token=gh_token, resume_session_id=recon_session,
+        )
+        recon_session = one.get("session_id") or recon_session
+        if one.get("limit_exceeded"):
+            await client.log_activity(
+                f"Epic {jira_key}: usage limit after {len(created)}/{total} stories — "
+                "run again to continue the rest"
+            )
+            break
+        story_desc = (one.get("result") or one.get("error") or "").strip() or f"## User Story\n{title}"
+
+        story_email = _extract_email(str(spec.get("assigneeEmail") or ""))
         child_email = story_email or desc_email or inherited.get("assigneeEmail")
         fields = {
             **inherited,
-            "type": "Story",   # Epic decomposes into user Stories; a Story later
-                               # becomes a Task (see _handle_story) when it is run.
-            "drivenBy": "SYSTEM",  # bot-created → trusted, skips the validation gate
+            "type": "Story",
+            "drivenBy": "SYSTEM",   # bot-created → trusted, skips the validation gate
             "status": "To Do",
-            "summary": str(st.get("summary", "")).strip()[:250],
-            "description": str(st.get("description", "") or "")[:20000],
-            # NO humanInstructions on AI-created stories — they are clean user-story
-            # artifacts; implementation instructions (repos/branch/etc.) are added
-            # later at the story/task stage, not baked in by the Epic.
+            "summary": title,
+            "description": story_desc[:20000],
+            # No humanInstructions on AI-created stories — added later at the task stage.
             "parentTaskId": tid,
         }
         if child_email:
             fields["assigneeEmail"] = child_email
-        if st.get("points"):
-            fields["points"] = st["points"]
+        if spec.get("points"):
+            fields["points"] = spec["points"]
         new_id = await client.create_task_ml(fields, model_used=_EPIC_MODELS)
         if new_id:
             created.append(new_id)
             await send(Envelope(
                 type="step_update", thread_id=thread_id,
-                data={"current_step": f"  ↳ created To Do task: {fields['summary']}"},
+                data={"current_step": f"  ↳ created To Do story {i}/{total}: {title}"},
             ).model_dump())
 
-    # 3b. Optionally ALSO write each story as a Markdown file to a directory named in
-    #     the instructions (e.g. "create /home/me/new_tasks and write the user stories
-    #     there"). This is IN ADDITION to the Story tickets. Best-effort — a file-write
-    #     failure never fails the Epic.
-    # Folder may be named in the humanInstructions OR the description — check both.
-    stories_dir = _extract_stories_dir(human) or _extract_stories_dir(description)
-    if stories_dir:
-        from pathlib import Path
-        try:
-            d = Path(stories_dir).expanduser()
-            d.mkdir(parents=True, exist_ok=True)  # create from scratch
-            written = 0
-            for i, st in enumerate(stories[:limit], 1):
-                if not isinstance(st, dict) or not (st.get("summary") or "").strip():
-                    continue
-                title = str(st.get("summary", "")).strip()
+        # Write this story's .md immediately (incremental), if a folder was given.
+        if dir_path is not None:
+            try:
                 slug = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")[:50] or f"story-{i}"
-                content = f"# {title}\n\n{str(st.get('description', '') or '').strip()}\n"
-                (d / f"{i:02d}-{slug}.md").write_text(content, encoding="utf-8")
+                (dir_path / f"{i:02d}-{slug}.md").write_text(
+                    f"# {title}\n\n{story_desc}\n", encoding="utf-8")
                 written += 1
-            await client.log_activity(f"Epic {jira_key}: wrote {written} user-story file(s) to {stories_dir}")
-            await send(Envelope(
-                type="step_update", thread_id=thread_id,
-                data={"jira_task_id": tid,
-                      "current_step": f"Epic {jira_key}: wrote {written} user-story file(s) to {stories_dir}"},
-            ).model_dump())
-        except Exception as exc:  # noqa: BLE001
-            await send(Envelope(
-                type="step_update", thread_id=thread_id,
-                data={"jira_task_id": tid,
-                      "current_step": f"Epic {jira_key}: could not write story files to {stories_dir} — {str(exc)[:120]}"},
-            ).model_dump())
+            except Exception:  # noqa: BLE001
+                pass
 
+    tail = f"; wrote {written} .md file(s) to {story_dir}" if dir_path is not None else ""
     await client.log_activity(
-        f"Epic {jira_key}: Done — created {len(created)}/{len(stories)} To Do user Story(ies)"
+        f"Epic {jira_key}: Done — created {len(created)}/{total} To Do user Story(ies){tail}"
     )
     await send(Envelope(
         type="step_update", thread_id=thread_id,
         data={"jira_task_id": tid,
-              "current_step": f"Epic {jira_key} complete — {len(created)} Story(ies) queued "
-                              "(run again: each Story → PRD + Task)"},
+              "current_step": f"Epic {jira_key} complete — {len(created)} Story(ies) queued"
+                              + (f" · {written} file(s) in {story_dir}" if dir_path is not None else "")},
     ).model_dump())
 
 
@@ -1116,7 +1189,7 @@ def _build_prd_prompt(jira_key: str, summary: str, user_story: str | None,
         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()))
+        parts.append("User story / description:\n" + _clip_text(user_story.strip(), _GEN_MAX_CHARS))
     if human_instructions and human_instructions.strip():
         parts.append("Operator instructions:\n" + human_instructions.strip())
     parts.append(