devops-bot-sdk 1.4.55__tar.gz → 1.4.60__tar.gz

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/PKG-INFO

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

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/pyproject.toml

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

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/sdk/__init__.py

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

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.55"
+SDK_VERSION    = "1.4.60"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -868,6 +868,34 @@ class BackendClient:
             logger.warning("client.create_task_ml error err=%s", exc)
             return None
 
+    async def add_comment(self, task_id: str, body: str) -> bool:
+        """POST /tasks-ml/{id}/comments — add a comment to a ticket (best-effort).
+
+        Used by the validation gate to post AI feedback (prefixed with an
+        [AI Comments] label) when an Epic/Story is rejected. JSON body: {"body": ...}.
+        Returns True on 2xx.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}/comments"
+        headers = {
+            **self._headers,           # includes Content-Type: application/json
+            "accept": "*/*",
+            "developer-name": "null",
+            "product": "",
+        }
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                resp = await client.post(url, json={"body": str(body)}, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.add_comment failed task=%s status=%s body=%s",
+                               task_id, resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.add_comment error task=%s err=%s", task_id, exc)
+            return False
+
     async def log_activity(self, activity: str) -> bool:
         """POST /ml-api/agent-activity — emit an agent activity event (best-effort).
 

{devops_bot_sdk-1.4.55 → devops_bot_sdk-1.4.60}/sdk/ipc/handlers.py

@@ -550,6 +550,134 @@ def _epic_inherited_fields(task: dict) -> dict:
     return {k: v for k, v in fields.items() if v}
 
 
+# ── Ticket validation gate (Epics + USER-driven Stories) ────────────────────
+# A strict quality gate: before the bot actions an Epic or a USER-created Story it
+# checks the ticket meets the required standard. On failure it posts a harsh,
+# technical comment (prefixed with the label below) and moves the ticket to
+# Backlog. SYSTEM-created Stories (spun off an Epic by the bot) are trusted and
+# skip validation. A later run re-validates; once the gaps are addressed in the
+# description / Human Instructions, it passes and the normal flow proceeds.
+_AI_COMMENT_LABEL = "[AI Comments]"
+
+
+def _build_validation_prompt(kind: str, jira_key: str, summary: str,
+                             description: str | None, human: str | None) -> str:
+    k = kind.upper()
+    parts: list[str] = [
+        f"You are a STRICT ticket-quality gate for a JIRA {k}. Decide whether this "
+        "ticket meets the required standard to be actioned autonomously. Be HARSH: if "
+        "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)"),
+        "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"
+        "- 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 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, 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)
+
+
+def _parse_validation(text: str | None) -> tuple[bool, str]:
+    """(valid, comment) from the validator's JSON output. Defaults to invalid."""
+    obj = _extract_json_block(text) or {}
+    return bool(obj.get("valid")), str(obj.get("comment") or "").strip()
+
+
+async def _validate_ticket_or_reject(
+    client: BackendClient, task: dict, kind: str, payload: dict,
+    send: Callable, thread_id: str,
+) -> bool:
+    """Strict gate. Returns True to proceed, False if the ticket was rejected
+    (comment posted + moved to Backlog). Fails OPEN if the validator can't run —
+    we never block a ticket on our own infrastructure error."""
+    from sdk import local_exec
+
+    tid = str(task.get("id", ""))
+    jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "") or kind.upper()
+    project_path = _resolve_local_project_path(task, payload)
+
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"jira_task_id": tid, "task_id": tid,
+              "current_step": f"{kind.title()} {jira_key}: validating ticket against the standard"},
+    ).model_dump())
+
+    res = await local_exec.run_claude_local(
+        _build_validation_prompt(kind, jira_key, task.get("summary", "") or "",
+                                 task.get("description"), task.get("humanInstructions")),
+        project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only judgment
+        github_token=await client.github_token(),
+    )
+    if not res.get("ok"):
+        await client.log_activity(
+            f"{kind} {jira_key}: validation could not run ({(res.get('error') or '')[:120]}) — proceeding"
+        )
+        return True  # fail-open on validator infra error
+
+    valid, comment = _parse_validation(res.get("result"))
+    if valid:
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"jira_task_id": tid, "current_step": f"{kind.title()} {jira_key}: validation passed"},
+        ).model_dump())
+        return True
+
+    # Rejected — post a labelled, technical comment and move to Backlog.
+    fallback = ("This ticket does not meet the required standard. Provide: a clear goal "
+                "and scope; explicit Human Instructions (target repository/branch and/or "
+                "file paths, PR convention, build/run/test steps); testable acceptance "
+                "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(
+        type=Envelope.TYPE_ERROR, thread_id=thread_id,
+        data={"code": f"{kind.upper()}_VALIDATION_REJECTED", "task_id": tid,
+              "message": (comment or fallback)[:300]},
+    ).model_dump())
+    return False
+
+
 async def _handle_epic(
     client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: str,
 ) -> None:
@@ -628,6 +756,7 @@ async def _handle_epic(
             **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
             "status": "To Do",
             "summary": str(st.get("summary", "")).strip()[:250],
             "description": str(st.get("description", "") or "")[:20000],
@@ -2720,7 +2849,17 @@ async def handle_orchestrate_auto_local_run(
             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")
                 try:
+                    if needs_validation and not await _validate_ticket_or_reject(
+                        client, task, ttype, payload, send, thread_id
+                    ):
+                        processed += 1
+                        continue
                     await handler(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)