devops-bot-sdk 1.4.6__tar.gz → 1.4.8__tar.gz

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/PKG-INFO

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/pyproject.toml

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/sdk/__init__.py

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.6"
+SDK_VERSION    = "1.4.8"
 _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.6 → devops_bot_sdk-1.4.8}/sdk/git_ops.py

@@ -143,34 +143,78 @@ async def ensure_repo(
 
 
 async def start_branch(
-    project_path: str, jira_key: str | None, summary: str | None, github_token: str | None,
+    project_path: str,
+    jira_key: str | None,
+    summary: str | None,
+    github_token: str | None,
+    base: str | None = None,
 ) -> dict | None:
-    """Create + check out `feature/<jira_key>-<slug>` off the default branch.
+    """Create + check out `feature/<jira_key>-<slug>` off the resolved base.
+
+    Base resolution (per repo):
+      - `base` given (named in the Jira humanInstructions, possibly per-repo) →
+        branch off the FRESH `origin/<base>` (fetched), falling back to a local
+        `<base>` ref. This is the explicit-override path.
+      - `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.
 
     Returns {"branch", "base"} or None when the path isn't a git repo (e.g. a
-    fresh scratch dir) or the checkout failed.
+    fresh scratch dir) or the checkout failed. The returned `base` is the branch
+    the feature was actually cut from — `finish_pr` uses it as the PR base.
     """
     path = str(Path(project_path).expanduser())
     env = _git_env(github_token)
     if not await _is_git_repo(path, env):
         return None
-    # Fetch first so origin/HEAD and origin/main refs are present/fresh before we
-    # detect the base (avoids resolving the base to the current feature branch).
-    await _run(["git", "fetch", "origin"], path, env, timeout=180.0)
-    base = await detect_default_branch(path, env)
+
     key = slugify(jira_key or "task", max_len=24)
     branch = f"feature/{key}-{slugify(summary)}"
-    if base == branch:
-        # Defensive: never base a PR on the branch we're about to create.
-        base = "main"
-    # Cut the feature branch from the FRESH remote base so it never chains off a
-    # previous ticket's feature branch left checked out in a shared working tree.
-    rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{base}"], path, env)
+    # Fetch so any remote base ref (origin/HEAD, origin/<base>) is present/fresh.
+    await _run(["git", "fetch", "origin"], path, env, timeout=180.0)
+
+    explicit = (base or "").strip()
+    if explicit:
+        # Explicit base from instructions → branch off the FRESH remote tip
+        # (satisfies "pull latest from <base>, then branch"). Fall back to a
+        # local ref of that name, then to a bare branch, if the remote lacks it.
+        await _run(["git", "fetch", "origin", explicit], path, env, timeout=120.0)
+        resolved = "main" if explicit == branch else explicit
+        rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{resolved}"], path, env)
+        if rc != 0:
+            rc, _, _ = await _run(["git", "checkout", "-B", branch, resolved], path, env)
+        if rc != 0:
+            rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
+        if rc != 0:
+            return None
+        logger.info("git_ops.branch | %s ← explicit base %s", branch, resolved)
+        return {"branch": branch, "base": resolved}
+
+    # 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/"):
+        # 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:
+            return None
+        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.
+    resolved = await detect_default_branch(path, env)
+    if resolved == branch:
+        resolved = "main"
+    rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{resolved}"], path, env)
     if rc != 0:
         rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
     if rc != 0:
         return None
-    return {"branch": branch, "base": base}
+    logger.info("git_ops.branch | %s ← default base %s (HEAD was %r)", branch, resolved, cur or "detached")
+    return {"branch": branch, "base": resolved}
 
 
 async def _remote_owner_repo(path: str, env: dict) -> tuple[str, str] | None:

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.8}/sdk/ipc/handlers.py

@@ -117,6 +117,32 @@ _POLL_INTERVAL_S = 1.5
 _PLAN_DEADLINE_S = 180.0  # planning + approval gate should be quick
 
 
+# Raw task-description budget (chars). The structured plan already distills the
+# task into acceptance criteria + steps, so the raw description is REFERENCE: a
+# very large one is bounded so it cannot bury the operator instructions or the
+# plan (the "follows my instructions sometimes, not others" failure mode). ~6k
+# tokens at ~4 chars/token.
+_DESC_MAX_CHARS = 24_000
+
+
+def _clip_text(text: str, max_chars: int = _DESC_MAX_CHARS) -> str:
+    """Bound a reference string to a char budget, keeping head + tail.
+
+    Pure-python (no tiktoken in the thin SDK). Keeps the start and end and elides
+    the middle with a marker pointing back at the distilled plan.
+    """
+    if not text or len(text) <= max_chars:
+        return text
+    head = max_chars // 2
+    tail = max_chars - head
+    elided = len(text) - head - tail
+    return (
+        f"{text[:head]}\n\n[... {elided} chars elided — the acceptance criteria "
+        f"and implementation steps above are the distilled, authoritative "
+        f"requirements ...]\n\n{text[-tail:]}"
+    )
+
+
 def _build_local_prompt(
     user_input: str | None,
     structured_plan: dict | None,
@@ -125,6 +151,12 @@ def _build_local_prompt(
 ) -> str:
     """Compose the coding prompt for the local claude CLI from the server plan.
 
+    Prompt order matters: a model attends most to the start (and end) of a long
+    prompt, so the MUST-FOLLOW operator instructions LEAD, the distilled plan
+    (acceptance criteria + steps) comes next, and the raw task description is
+    DEMOTED to bounded reference material at the end — never first, never
+    unbounded. This stops a large Jira description from burying the instructions.
+
     `user_input` may be empty when the desktop relied on backend hydration
     (jira_task_id-only run) — the structured plan then carries the task detail.
 
@@ -135,6 +167,7 @@ def _build_local_prompt(
     locally itself.
     """
     parts: list[str] = []
+    # 1. Operator instructions — FIRST, verbatim, authoritative.
     if human_instructions and human_instructions.strip():
         parts.append(
             "=== Operator instructions (Jira humanInstructions) — AUTHORITATIVE ===\n"
@@ -149,8 +182,8 @@ def _build_local_prompt(
             "before changing it.\n\n"
             + human_instructions.strip()
         )
-    if user_input and user_input.strip():
-        parts.append(user_input.strip())
+    # 2. Distilled plan (acceptance criteria + steps) — the compact, actionable
+    #    content the backend planner derived from the full description.
     sp = structured_plan or {}
     criteria = sp.get("acceptance_criteria") or []
     steps = sp.get("task_steps") or []
@@ -163,6 +196,13 @@ def _build_local_prompt(
                 lines.append(f"- {s.get('title', '')}: {s.get('description', '')}".rstrip(": "))
         if lines:
             parts.append("Implementation steps:\n" + "\n".join(lines))
+    # 3. Raw task description — DEMOTED to bounded reference (plan above wins).
+    if user_input and user_input.strip():
+        parts.append(
+            "=== Task description (reference — the operator instructions and plan "
+            "above are authoritative if anything conflicts) ===\n"
+            + _clip_text(user_input.strip())
+        )
     parts.append(
         "Implement all of the above in the current project directory. "
         "Create and edit every file needed for a complete, working result.\n"
@@ -313,6 +353,45 @@ async def _run_local_pipeline(
     await send(_error_envelope(thread_id, RuntimeError("Planning timed out before approval gate.")).model_dump())
 
 
+def _tool_detail(tool_name: str, inp: dict) -> str:
+    """A short, human-readable detail for a tool_use event, for the step timeline.
+
+    Turns a bare "Bash" into the actual command, "Read" into the file, "Grep"
+    into the pattern, etc. — so the progress log says what the agent is doing.
+    """
+    inp = inp or {}
+
+    def _short(s, n=140):
+        return " ".join(str(s).split())[:n]
+
+    if tool_name == "Bash":
+        # Prefer claude's own one-line description, then the command itself.
+        return _short(inp.get("description") or inp.get("command") or "")
+    if tool_name in ("Read", "Write", "Edit", "MultiEdit", "NotebookEdit"):
+        fp = str(inp.get("file_path") or inp.get("notebook_path") or "")
+        return fp.split("/")[-1] if fp else ""
+    if tool_name == "Grep":
+        pat = inp.get("pattern", "")
+        where = inp.get("path") or inp.get("glob") or ""
+        return _short(f"{pat}" + (f" in {where}" if where else ""))
+    if tool_name == "Glob":
+        return _short(inp.get("pattern", ""))
+    if tool_name in ("WebFetch", "WebSearch"):
+        return _short(inp.get("url") or inp.get("query") or "")
+    if tool_name == "Task":
+        return _short(inp.get("description") or inp.get("subagent_type") or "")
+    if tool_name == "TodoWrite":
+        todos = inp.get("todos") or []
+        active = next((t.get("content") for t in todos if t.get("status") == "in_progress"), None)
+        return _short(active) if active else f"{len(todos)} item(s)"
+    # Generic fallback: first useful string field.
+    for k in ("description", "prompt", "query", "command", "path", "url", "file_path"):
+        v = inp.get(k)
+        if isinstance(v, str) and v.strip():
+            return _short(v)
+    return ""
+
+
 async def _code_one_repo(
     client: BackendClient,
     *,
@@ -326,6 +405,7 @@ async def _code_one_repo(
     send: Callable,
     thread_id: str,
     task_id: str,
+    base: str | None = None,
 ) -> dict:
     """Clone-if-needed → branch → run claude → open a PR, for ONE repo.
 
@@ -347,8 +427,8 @@ async def _code_one_repo(
             for c in event.get("message", {}).get("content", []):
                 if c.get("type") == "tool_use":
                     tname = c.get("name", "tool")
-                    fp = (c.get("input", {}) or {}).get("file_path", "")
-                    label = f"Local claude [{name}]: {tname}" + (f" → {fp.split('/')[-1]}" if fp else "")
+                    detail = _tool_detail(tname, c.get("input") or {})
+                    label = f"Local claude [{name}]: {tname}" + (f" → {detail}" if detail else "")
                     await send(Envelope(
                         type="step_update", thread_id=thread_id,
                         data={"status": "running", "current_step": label},
@@ -371,11 +451,13 @@ async def _code_one_repo(
     except Exception:  # noqa: BLE001
         pass
 
-    # 2. feature branch off the repo's real default
+    # 2. feature branch off the resolved base (explicit base from instructions,
+    #    else the repo's current checked-out branch — see git_ops.start_branch).
     branch_info = None
     try:
         branch_info = await git_ops.start_branch(
             repo_path, pending.get("jira_key"), pending.get("summary"), gh_token,
+            base=base,
         )
         if branch_info:
             await send(Envelope(
@@ -574,7 +656,11 @@ async def handle_pipeline_approve(
     # Branch + code + PR each independently; fall back to the single resolved path.
     targets = _extract_repo_targets(pending.get("human_instructions"))
     if not targets:
-        targets = [{"path": pending["project_path"], "url": None}]
+        # No repos named in the instructions → the single resolved project path.
+        # It still honours a global base mentioned in the instructions; None →
+        # start_branch falls back to the repo's current checked-out branch.
+        _, _global_base = _extract_base_branches(pending.get("human_instructions"))
+        targets = [{"path": pending["project_path"], "url": None, "base": _global_base}]
     await send(Envelope(
         type="step_update", thread_id=thread_id,
         data={"current_step": f"{len(targets)} repo(s) to update: "
@@ -587,6 +673,7 @@ async def handle_pipeline_approve(
         try:
             runs.append(await _code_one_repo(
                 client, repo_path=tgt["path"], repo_url=tgt.get("url"),
+                base=tgt.get("base"),
                 pending=pending, prompt=prompt, gh_token=gh_token,
                 agent_mode=agent_mode, approval_dir=approval_dir,
                 send=send, thread_id=thread_id, task_id=task_id,
@@ -1171,13 +1258,113 @@ def _extract_all_paths(text: str | None) -> list[str]:
     return out
 
 
+# Base-branch directives in free-text humanInstructions. Order matters — the
+# more explicit "branch from X" / "base branch: X" forms are tried before the
+# looser "X branch" form so "create a feature branch from main" resolves to
+# `main`, not `feature`. Noise words are filtered out so "the/new/feature/this
+# branch" never resolves to a base.
+import re as _re  # noqa: E402
+
+_BASE_NOISE = {
+    "the", "a", "an", "this", "that", "new", "feature", "features",
+    "your", "same", "current", "default", "its", "please", "create",
+}
+_BASE_DIRECTIVE_RES = [
+    # "branch from/off <base>" — most explicit, tried first. Greedy so a full
+    # name like "release/2.0" is captured, not truncated to "release".
+    _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),
+    # "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.
+    _re.compile(r"[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\s+branch\b", _re.I),
+]
+
+# Repo-role keywords so a base named alongside "FE"/"backend"/… maps to the
+# matching target even when the path basename doesn't literally contain it.
+_REPO_ROLE_KEYWORDS = (
+    "frontend", "front-end", "fe", "backend", "back-end", "be", "desktop",
+    "mobile", "api", "web", "server", "client",
+)
+
+
+def _find_base_in(text: str | None) -> str | None:
+    """First plausible base-branch name in `text`, or None. Filters noise words."""
+    if not text:
+        return None
+    for rx in _BASE_DIRECTIVE_RES:
+        for m in rx.finditer(text):
+            cand = (m.group(1) or "").strip().strip("./")
+            if cand and cand.lower() not in _BASE_NOISE and not cand.startswith("feature/"):
+                return cand
+    return None
+
+
+def _extract_base_branches(text: str | None) -> tuple[dict[str, str], str | None]:
+    """Parse base-branch directives from humanInstructions.
+
+    Returns (per_repo_bases, global_base):
+      - per_repo_bases: {repo_token: base} where repo_token is a repo name /
+        path basename / role keyword (fe/be/desktop/…) that appeared on the SAME
+        line as a base directive — supports "FE from develop, BE from main".
+      - global_base: a base directive found anywhere (applies to any repo with no
+        more-specific per-repo base). None when no base is mentioned at all.
+    """
+    if not text:
+        return {}, None
+    from pathlib import Path
+
+    def _repo_name(u: str) -> str:
+        n = u.rstrip("/").rsplit("/", 1)[-1]
+        return (n[:-4] if n.lower().endswith(".git") else n).lower()
+
+    per_repo: dict[str, str] = {}
+    for line in text.splitlines():
+        b = _find_base_in(line)
+        if not b:
+            continue
+        tokens: set[str] = set()
+        for u in _GITHUB_URL_RE.findall(line):
+            tokens.add(_repo_name(u))
+        for p in _extract_all_paths(line):
+            tokens.add(Path(p).name.lower())
+        low = line.lower()
+        for kw in _REPO_ROLE_KEYWORDS:
+            if _re.search(rf"\b{_re.escape(kw)}\b", low):
+                tokens.add(kw)
+        for t in tokens:
+            per_repo.setdefault(t, b)
+    return per_repo, _find_base_in(text)
+
+
+def _resolve_base_for(name: str, url: str | None,
+                      per_repo: dict[str, str], global_base: str | None) -> str | None:
+    """Pick the base for one repo: per-repo match (name / url / role keyword) → global."""
+    candidates: list[str] = [name.lower()]
+    if url:
+        n = url.rstrip("/").rsplit("/", 1)[-1]
+        candidates.append((n[:-4] if n.lower().endswith(".git") else n).lower())
+    low = name.lower()
+    for kw in _REPO_ROLE_KEYWORDS:
+        if kw in low:
+            candidates.append(kw)
+    for c in candidates:
+        if c in per_repo:
+            return per_repo[c]
+    return global_base
+
+
 def _extract_repo_targets(text: str | None) -> list[dict]:
-    """All repo work-targets named in `text`: ``[{"path", "url"}]``.
+    """All repo work-targets named in `text`: ``[{"path", "url", "base"}]``.
 
     A single ticket may name several repos (e.g. FE + BE). Each local path is
     paired with a GitHub URL whose repo name matches the path's last segment
     (FE path ↔ FE url, BE path ↔ BE url) so a missing folder can be cloned. A
     path with no matching URL still appears (url=None) — it must already exist.
+    Each target also carries its resolved `base` branch (per-repo override from
+    the instructions, else the global mentioned base, else None → the SDK uses
+    the repo's current checked-out branch).
     """
     if not text:
         return []
@@ -1187,10 +1374,17 @@ def _extract_repo_targets(text: str | None) -> list[dict]:
         n = u.rstrip("/").rsplit("/", 1)[-1]
         return (n[:-4] if n.lower().endswith(".git") else n).lower()
 
+    per_repo_bases, global_base = _extract_base_branches(text)
     by_name = {_repo_name(u): u for u in _GITHUB_URL_RE.findall(text)}
     targets: list[dict] = []
     for p in _extract_all_paths(text):
-        targets.append({"path": p, "url": by_name.get(Path(p).name.lower())})
+        name = Path(p).name
+        url = by_name.get(name.lower())
+        targets.append({
+            "path": p,
+            "url": url,
+            "base": _resolve_base_for(name, url, per_repo_bases, global_base),
+        })
     return targets