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

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

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

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

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

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

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

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

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

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

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.90"
+SDK_VERSION    = "1.4.92"
 _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.90 → devops_bot_sdk-1.4.92}/sdk/git_ops.py

@@ -72,6 +72,19 @@ async def _is_git_repo(path: str, env: dict) -> bool:
     return rc == 0 and out == "true"
 
 
+# A branch named exactly like a Jira ticket id (e.g. "LDA-6", "OCR-103"). The
+# "name the branch exactly the ticket id" convention produces these, so a
+# leftover checkout from a PREVIOUS ticket's run must be treated as a stale
+# feature branch — never as a base to cut the next ticket's branch from.
+_TICKET_BRANCH_RE = re.compile(r"^[A-Za-z][A-Za-z0-9]{1,9}-\d+$")
+
+
+def _is_work_branch(name: str) -> bool:
+    """True when `name` is one of OUR generated work branches (feature/* or a
+    bare ticket id) — i.e. never a legitimate base."""
+    return name.startswith("feature/") or bool(_TICKET_BRANCH_RE.match(name))
+
+
 async def detect_default_branch(path: str, env: dict) -> str:
     """Repo default branch — the PR base.
 
@@ -100,9 +113,10 @@ async def detect_default_branch(path: str, env: dict) -> str:
         )
         if rc == 0:
             return cand
-    # 4. Last resort: the current branch, but never a feature branch.
+    # 4. Last resort: the current branch, but never one of our work branches
+    #    (feature/* or a bare ticket id like "LDA-6").
     rc, out, _ = await _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], path, env)
-    if rc == 0 and out and not out.startswith("feature/"):
+    if rc == 0 and out and not _is_work_branch(out):
         return out
     return "main"
 
@@ -167,9 +181,10 @@ async def start_branch(
       - `base` omitted → the repo's CURRENT checked-out branch (the branch the
         user is actually working on); the feature branch is cut from local HEAD
         so the user's working state is preserved. If HEAD is detached or already
-        one of OUR `feature/*` branches (a stale checkout from a prior re-run in
-        a shared working tree), fall back to `detect_default_branch` so we never
-        chain a feature branch onto another feature branch.
+        one of OUR work branches — `feature/*` or a bare ticket-id branch like
+        "LDA-6" (a stale checkout from a prior ticket's run in a shared working
+        tree) — fall back to `detect_default_branch` so we never chain one
+        ticket's branch onto another's.
 
     Returns {"branch", "base"} or None when the path isn't a git repo (e.g. a
     fresh scratch dir) or the checkout failed. The returned `base` is the branch
@@ -210,7 +225,7 @@ async def start_branch(
     # Default: base = the CURRENT checked-out branch (the user's working branch).
     rc, cur, _ = await _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], path, env)
     cur = cur.strip() if rc == 0 else ""
-    if cur and cur != "HEAD" and not cur.startswith("feature/"):
+    if cur and cur != "HEAD" and not _is_work_branch(cur):
         # Cut from local HEAD — preserve the user's working state, do not pull.
         rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
         if rc != 0:
@@ -218,7 +233,8 @@ async def start_branch(
         logger.info("git_ops.branch | %s ← current branch %s", branch, cur)
         return {"branch": branch, "base": cur}
 
-    # HEAD detached or a stale feature/* checkout → fall back to repo default.
+    # HEAD detached or a stale work-branch checkout (feature/* or a previous
+    # ticket's id-named branch) → fall back to the repo default.
     resolved = await detect_default_branch(path, env)
     if resolved == branch:
         resolved = "main"
@@ -300,7 +316,10 @@ async def finish_pr(
         `gh auth login`). SSH alone covers git transport, not the PR.
 
     Every failure path is logged so a missing PR is diagnosable instead of silent.
-    Returns {"pushed": bool, "pr_url": str | None, "pr_error": str | None}.
+    Returns {"pushed": bool, "pr_url": str | None, "pr_error": str | None,
+    "committed": bool, "pr_unavailable": bool} — `pr_unavailable` is True when
+    the box simply has no way to open a PR (no token AND no `gh`), which callers
+    treat as a warning rather than a failed PR attempt.
     """
     path = str(Path(project_path).expanduser())
     env = _git_env(github_token)
@@ -353,18 +372,27 @@ async def finish_pr(
             pr_error = f"gh pr create failed: {gh_err[:200]}"
             logger.warning("git_ops.gh_pr_failed branch=%s error=%s", branch, gh_err[:300])
 
+    pr_unavailable = False
     if not pr_url and pr_error is None:
         # Pushed, but no PR and no specific error captured above.
         if github_token and owner_repo:
             pr_error = "no PR created — REST API returned no URL"
         elif not github_token and not shutil.which("gh"):
-            pr_error = ("no PR created — no token and `gh` not installed; SSH "
-                        "transport can't open a PR. Install gh + `gh auth login`, "
-                        "or provide a GitHub token.")
+            # This box CANNOT open a PR at all (no token, no gh) — SSH covers
+            # git transport only. Not a failed attempt: on SSH-only setups the
+            # PR is opened externally (platform/human), so flag it as
+            # `pr_unavailable` so the caller treats it as a warning, not a
+            # compliance failure.
+            pr_unavailable = True
+            pr_error = ("PR not opened from this machine — no GitHub token and "
+                        "`gh` not installed (SSH covers push only). The PR must "
+                        "be opened externally, or install gh + `gh auth login` / "
+                        "provide a token.")
         elif not shutil.which("gh"):
             pr_error = "no PR created — missing GitHub token or unrecognized origin remote"
         else:
             pr_error = "no PR created"
         logger.warning("git_ops.no_pr branch=%s reason=%s", branch, pr_error)
 
-    return {"pushed": pushed, "pr_url": pr_url, "pr_error": pr_error, "committed": committed}
+    return {"pushed": pushed, "pr_url": pr_url, "pr_error": pr_error,
+            "committed": committed, "pr_unavailable": pr_unavailable}

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

@@ -2078,8 +2078,19 @@ async def _code_one_repo(
                 issues.append("in scope but produced 0 committed changes")
             elif not pr.get("pushed"):
                 issues.append("branch was not pushed")
-            elif not pr.get("pr_url"):
+            elif not pr.get("pr_url") and not pr.get("pr_unavailable"):
                 issues.append(f"no PR opened ({(pr or {}).get('pr_error') or 'unknown'})")
+            elif pr.get("pr_unavailable"):
+                # Committed + pushed, but this box has NO way to open a PR (no
+                # token, no gh — SSH transport only). The PR is opened
+                # externally on such setups, so this is a WARNING, not a
+                # compliance failure: the ticket still completes (Done).
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"status": "running",
+                          "current_step": f"[{name}] Pushed OK — PR to be opened "
+                                          "externally (no token/gh on this machine)"},
+                ).model_dump())
         else:
             # Plain working folder (documentation / analyst deliverables, non-git):
             # no branch/PR to verify, but it must still have PRODUCED something.
@@ -2878,6 +2889,7 @@ import re as _re  # noqa: E402
 _BASE_NOISE = {
     "the", "a", "an", "this", "that", "new", "feature", "features",
     "your", "same", "current", "default", "its", "please", "create",
+    "origin", "latest", "upstream", "branch",
 }
 _BASE_DIRECTIVE_RES = [
     # "branch from/off <base>" — most explicit, tried first. Greedy so a full
@@ -2885,6 +2897,15 @@ _BASE_DIRECTIVE_RES = [
     _re.compile(r"branch(?:es|ed|ing)?\s+(?:from|off(?:\s+of)?)\s+(?:the\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?(?:\s+branch)?\b", _re.I),
     # "base branch: <base>" / "base is <base>"
     _re.compile(r"base(?:\s+branch)?\s*(?:[:=]|\bis\b|\bshould\s+be\b)\s*[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\b", _re.I),
+    # Literal git-workflow steps: "git checkout <base>" (NOT -b/-B — that's the
+    # NEW branch) and "git pull origin <base>". This is how the standard
+    # Human Instructions template names the base ("git checkout main && git
+    # pull origin main").
+    _re.compile(r"git\s+checkout\s+(?!-)[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?", _re.I),
+    _re.compile(r"git\s+pull\s+(?:origin\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?", _re.I),
+    # "open a PR into <base>" / "merge to <base>" / "PR Requirements (target: <base>"
+    _re.compile(r"(?:PR|pull\s+request|merge[sd]?)\s+(?:in)?to\s+(?:the\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?", _re.I),
+    _re.compile(r"target\s*:\s*[\"'`]?([A-Za-z][A-Za-z0-9._\-/]*)[\"'`]?", _re.I),
     # "from the <base> branch"
     _re.compile(r"from\s+(?:the\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\s+branch\b", _re.I),
     # loose "<base> branch" (e.g. "main branch") — last, most permissive.