bamboo-coding 0.1.7__tar.gz → 0.2.0__tar.gz

{bamboo_coding-0.1.7 → bamboo_coding-0.2.0}/PKG-INFO

@@ -1,13 +1,19 @@
 Metadata-Version: 2.4
 Name: bamboo-coding
-Version: 0.1.7
+Version: 0.2.0
 Summary: Bamboo Coding outbound client
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: gitpython==3.1.40
 Requires-Dist: websockets==13.1
 Requires-Dist: pydantic>=2.0
-Requires-Dist: bamboo-ssh
+Requires-Dist: bamboo-ssh>=0.2.0
+Requires-Dist: pyte>=0.8.2
+Requires-Dist: psutil>=5.9
+Requires-Dist: pywinpty>=2.0; sys_platform == "win32"
 
 # bamboo-coding
 

{bamboo_coding-0.1.7 → bamboo_coding-0.2.0}/pyproject.toml

@@ -4,15 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bamboo-coding"
-version = "0.1.7"
+version = "0.2.0"
 description = "Bamboo Coding outbound client"
 readme = "README.md"
 requires-python = ">=3.12"
+classifiers = [
+  "Operating System :: POSIX :: Linux",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: MacOS",
+]
 dependencies = [
   "gitpython==3.1.40",
   "websockets==13.1",
   "pydantic>=2.0",
-  "bamboo-ssh",
+  "bamboo-ssh>=0.2.0",
+  "pyte>=0.8.2",
+  "psutil>=5.9",
+  "pywinpty>=2.0; sys_platform == 'win32'",
 ]
 
 [project.scripts]
@@ -21,3 +29,6 @@ bamboo-coding = "bamboo_coding.main:main"
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["bamboo_coding*"]
+
+[tool.setuptools.package-data]
+"bamboo_coding.agents.builtin_skills" = ["*/SKILL.md", "*/assets/*"]

bamboo_coding-0.2.0/src/bamboo_coding/agents/__init__.py

@@ -0,0 +1,20 @@
+"""Headless Claude Code / Codex CLI integration.
+
+This package lets the client detect coding-agent CLIs installed on this
+machine, run them headlessly (no PTY, structured JSONL output), inject
+client-owned skills, and list/resume the CLIs' native history sessions.
+
+The agents never know Bamboo exists: prompts arrive on stdin, skills ride in
+the prompt plus an ``--add-dir`` grant, and nothing is written into the
+user's ``~/.claude`` / ``~/.codex`` configuration.
+"""
+
+from .types import AgentDef, DetectedAgent, ModelOption, RuntimeContext, Skill
+
+__all__ = [
+    "AgentDef",
+    "DetectedAgent",
+    "ModelOption",
+    "RuntimeContext",
+    "Skill",
+]

bamboo_coding-0.2.0/src/bamboo_coding/agents/builtin_skills/__init__.py

@@ -0,0 +1,3 @@
+# Marker so setuptools packages this directory; the skill folders inside are
+# package data (see [tool.setuptools.package-data]), discovered at runtime by
+# skills.builtin_skills_dir().

bamboo_coding-0.2.0/src/bamboo_coding/agents/builtin_skills/skill-create/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: skill-create
+description: Scaffold a new Bamboo skill folder (SKILL.md + assets) from a description of the workflow it should capture
+version: 1.0.0
+---
+
+# Create a new skill
+
+You are helping the user turn a workflow into a reusable Bamboo skill. A skill
+is a folder named after the skill containing a `SKILL.md` (frontmatter +
+instructions) and optional support files the instructions reference.
+
+## Steps
+
+1. From the user's request, identify: the skill's purpose, the steps an agent
+   should follow when the skill is active, and any reference material worth
+   shipping as support files. If the request is too vague to write concrete
+   steps, ask for the missing specifics before writing anything.
+2. Choose a short kebab-case name (lowercase letters, digits, and dashes only,
+   e.g. `api-review`). The folder and the frontmatter `name` must match.
+3. Create the skill folder **inside the current working directory**:
+
+   ```
+   <name>/
+   ├── SKILL.md
+   └── assets/          # only if the body references support files
+   ```
+
+4. Write `SKILL.md` with exactly this frontmatter shape, then the body:
+
+   ```
+   ---
+   name: <name>
+   description: <one line: when an agent should use this skill>
+   version: 0.1.0
+   ---
+
+   # <Title>
+
+   <numbered, imperative steps an agent can follow without asking questions>
+   ```
+
+5. Keep the body tight: every line costs prompt space on every run that
+   activates the skill. Move long reference material into `assets/` files and
+   reference them by relative path from the body.
+6. Finish by telling the user the folder is ready to install: zip it and
+   upload it from the Bamboo skill panel (or publish it to the team's skill
+   hub).
+
+## Rules
+
+- Never write into `~/.bamboo-coding`, `~/.claude`, or `~/.codex` — the skill
+  is installed through Bamboo's upload flow, which validates it first.
+- The `description` must say when to use the skill, not what it is.
+- Do not invent support files the body never references.

bamboo_coding-0.2.0/src/bamboo_coding/agents/builtin_skills/skill-optimize/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: skill-optimize
+description: Review an installed Bamboo skill and write an improved version of its SKILL.md
+version: 1.0.0
+---
+
+# Optimize an existing skill
+
+You are improving another skill that is active in this same run (its body
+appears above as another "## Active skill" section, and its folder is listed
+as readable). If no other skill is active, ask the user which skill to
+optimize and stop.
+
+## Steps
+
+1. Read the target skill's `SKILL.md` from its support directory, plus any
+   asset files its body references.
+2. Judge it against these criteria, in order:
+   - **Actionable**: steps are imperative and concrete enough for an agent to
+     follow without asking questions.
+   - **Lean**: the body carries no prose an agent doesn't need; long
+     reference material belongs in `assets/` files, referenced by relative
+     path.
+   - **Scoped**: the `description` says when to use the skill; the body does
+     one job and doesn't drift into adjacent workflows.
+   - **Self-contained**: no references to files, tools, or conventions that
+     don't exist in the skill folder or a standard environment.
+3. Write the improved skill **into the current working directory** as
+   `<name>/SKILL.md` (same folder layout as the original; copy forward any
+   assets that survive the review, dropping unreferenced ones). Keep the
+   frontmatter `name` unchanged and bump the patch part of `version`.
+4. Summarize what changed and why in a short list, then tell the user to
+   reinstall the folder from the Bamboo skill panel to apply it.
+
+## Rules
+
+- Never edit the installed skill in place — its directory is read-only input;
+  the improved copy goes to the working directory for reinstall.
+- Preserve behavior the user didn't ask to change; this is a rewrite for
+  clarity and economy, not a redesign.

bamboo_coding-0.2.0/src/bamboo_coding/agents/compose.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import hashlib
+from typing import Sequence
+
+from .types import Skill
+
+# Some models start their reply by echoing the top of the user message
+# verbatim, so the rendered output begins with a spurious "# Instructions"
+# block. One explicit guard line cuts that without changing the turn shape.
+ECHO_GUARD = (
+    "\n\n(Do not quote, restate, or echo the # Instructions block above in "
+    "your reply. Begin your response with the answer to the # User request below.)"
+)
+
+
+def compose_stable_block(*, skills: Sequence[Skill] = (), cwd: str | None,
+                         extra_instructions: str = "") -> str:
+    """The turn-invariant instruction prefix (skill bodies, cwd contract).
+
+    Kept separate from the user request so resumed sessions can skip
+    re-sending it when unchanged (see ``stable_block_hash``) — changing the
+    skill selection mid-conversation changes the hash, so the next turn
+    re-sends the updated block automatically.
+    """
+    instructions: list[str] = []
+    if extra_instructions:
+        instructions.append(extra_instructions)
+    for skill in skills:
+        instructions.append(
+            f"## Active skill: {skill.name}\n\n{skill.body}\n\n"
+            f"(This skill's support files live at `{skill.path}` — you have "
+            f"read access to that directory.)"
+        )
+    if cwd:
+        instructions.append(
+            f"Your working directory is `{cwd}`. Create all output files inside it."
+        )
+    return "\n\n".join(instructions)
+
+
+def compose_prompt(*, user_request: str, stable_block: str = "") -> str:
+    """There is no system-prompt API for a spawned CLI, so everything rides
+    in one composed user message."""
+    if stable_block:
+        head = ("# Instructions (read first)\n\n"
+                + stable_block
+                + ECHO_GUARD + "\n\n---\n")
+    else:
+        head = ""
+    return f"{head}# User request\n\n{user_request}"
+
+
+def stable_block_hash(stable_block: str) -> str:
+    return hashlib.sha256(stable_block.encode("utf-8")).hexdigest()

bamboo_coding-0.2.0/src/bamboo_coding/agents/defs.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+
+from .types import AgentDef, ModelOption, RuntimeContext
+
+
+def _build_claude_args(model, extra_dirs, caps, ctx: RuntimeContext) -> list[str]:
+    # -p (print mode) with the prompt on stdin: argv delivery hits the Linux
+    # per-entry ~128 KB limit (E2BIG) and Windows CreateProcess limits long
+    # before a skill-carrying prompt does. `claude -p` with no positional
+    # prompt reads stdin.
+    args = ["-p", "--output-format", "stream-json", "--verbose"]
+
+    # Richer streaming deltas, but the flag only exists on newer builds; old
+    # installs exit 1 on "unknown option", so gate on the --help probe.
+    if caps.get("partial_messages"):
+        args.append("--include-partial-messages")
+
+    if model and model != "default":
+        args += ["--model", model]
+
+    # Grant read access to skill dirs living outside the workspace cwd.
+    dirs = [d for d in (extra_dirs or []) if d]
+    if dirs and caps.get("add_dir", True):
+        args.append("--add-dir")
+        args += dirs
+
+    # Continue Claude's own CLI session across turns so it keeps working
+    # memory instead of re-deriving everything from a re-packed transcript.
+    if ctx.resume_session_id:
+        args += ["--resume", ctx.resume_session_id]
+    elif ctx.new_session_id:
+        args += ["--session-id", ctx.new_session_id]
+
+    # No TTY means no interactive approval prompt is possible; an approval
+    # request would hang the run forever.
+    args += ["--permission-mode", "bypassPermissions"]
+    return args
+
+
+def _codex_needs_danger_full_access() -> bool:
+    """Codex's workspace-write sandbox blocks shell invocations on Windows
+    (no OS-level sandbox there) and under WSL, which reports linux but hits
+    the same path. macOS (Seatbelt) and Linux (Landlock+seccomp) keep
+    workspace-write."""
+    override = os.environ.get("BAMBOO_CODING_CODEX_SANDBOX", "").strip()
+    if override:
+        return override == "danger-full-access"
+    if platform.system() == "Windows":
+        return True
+    return bool(os.environ.get("WSL_DISTRO_NAME", "").strip())
+
+
+def _build_codex_args(model, extra_dirs, caps, ctx: RuntimeContext) -> list[str]:
+    if ctx.resume_session_id:
+        # `codex exec resume` accepts only a subset of exec's flags — no
+        # --sandbox / -C / --add-dir (it exits 2 on them). Sandbox selection
+        # rides through -c config overrides instead; the workspace cwd comes
+        # from the spawn cwd, and the resumed thread keeps its prior context.
+        args = ["exec", "resume", ctx.resume_session_id,
+                "--json", "--skip-git-repo-check"]
+        if _codex_needs_danger_full_access():
+            args += ["-c", 'sandbox_mode="danger-full-access"']
+        else:
+            args += ["-c", 'sandbox_mode="workspace-write"',
+                     "-c", "sandbox_workspace_write.network_access=true"]
+        args += ["-c", 'default_permissions=":workspace"']
+        if model and model != "default":
+            args += ["--model", model]
+        return args
+
+    if _codex_needs_danger_full_access():
+        args = ["exec", "--json", "--skip-git-repo-check",
+                "--sandbox", "danger-full-access"]
+    else:
+        args = ["exec", "--json", "--skip-git-repo-check",
+                "--sandbox", "workspace-write",
+                "-c", "sandbox_workspace_write.network_access=true"]
+    args += ["-c", 'default_permissions=":workspace"']
+
+    if ctx.cwd:
+        args += ["-C", ctx.cwd]
+    for d in (extra_dirs or []):
+        if d:
+            args += ["--add-dir", d]
+    if model and model != "default":
+        args += ["--model", model]
+    return args
+
+
+def _parse_codex_debug_models(stdout: str) -> list[ModelOption] | None:
+    """`codex debug models` prints JSON {models:[{slug,display_name,visibility}]}
+    on recent CLIs."""
+    try:
+        parsed = json.loads(stdout or "")
+    except (ValueError, TypeError):
+        return None
+    models = parsed.get("models") if isinstance(parsed, dict) else None
+    if not isinstance(models, list):
+        return None
+    out, seen = [ModelOption("default", "Default")], {"default"}
+    for m in models:
+        if not isinstance(m, dict) or m.get("visibility") == "hidden":
+            continue
+        mid = str(m.get("slug") or m.get("id") or "").strip()
+        if not mid or mid in seen:
+            continue
+        seen.add(mid)
+        out.append(ModelOption(mid, str(m.get("display_name") or m.get("name") or mid)))
+    return out if len(out) > 1 else None
+
+
+CLAUDE_DEF = AgentDef(
+    id="claude",
+    name="Claude Code",
+    bin="claude",
+    version_args=("--version",),
+    # --add-dir / --include-partial-messages only appear under `claude -p
+    # --help`, not the global help.
+    help_args=("-p", "--help"),
+    capability_flags={
+        "--include-partial-messages": "partial_messages",
+        "--add-dir": "add_dir",
+    },
+    build_args=_build_claude_args,
+    stream_format="claude-stream-json",
+    fallback_models=(
+        ModelOption("default", "Default"),
+        ModelOption("sonnet", "Sonnet (alias)"),
+        ModelOption("opus", "Opus (alias)"),
+        ModelOption("haiku", "Haiku (alias)"),
+    ),
+    resumes_session_via_cli=True,
+)
+
+
+CODEX_DEF = AgentDef(
+    id="codex",
+    name="Codex CLI",
+    bin="codex",
+    version_args=("--version",),
+    build_args=_build_codex_args,
+    stream_format="codex-json",
+    list_models_args=("debug", "models"),
+    parse_models=_parse_codex_debug_models,
+    fallback_models=(
+        ModelOption("default", "Default"),
+        ModelOption("gpt-5-codex", "gpt-5-codex"),
+        ModelOption("gpt-5", "gpt-5"),
+    ),
+    resumes_session_via_cli=True,
+)
+
+
+AGENT_DEFS: tuple[AgentDef, ...] = (CLAUDE_DEF, CODEX_DEF)
+
+_ids: set[str] = set()
+for _d in AGENT_DEFS:
+    if _d.id in _ids:
+        raise RuntimeError(f"Duplicate agent definition id: {_d.id}")
+    _ids.add(_d.id)
+
+
+def get_agent_def(agent_id: str) -> AgentDef | None:
+    return next((d for d in AGENT_DEFS if d.id == agent_id), None)

bamboo_coding-0.2.0/src/bamboo_coding/agents/detection.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from .defs import AGENT_DEFS
+from .types import AgentDef, DetectedAgent, ModelOption
+
+LOGGER = logging.getLogger(__name__)
+
+VERSION_PROBE_TIMEOUT = 3.0
+HELP_PROBE_TIMEOUT = 5.0
+MODELS_PROBE_TIMEOUT = 5.0
+CACHE_TTL_SECONDS = 60.0
+
+# Synchronous on purpose: detection runs inside asyncio.to_thread from the
+# task executor, where blocking subprocess calls are fine and an event loop
+# is not available.
+
+
+def resolve_bin(def_: AgentDef) -> str | None:
+    """Resolve the exact path that will later be spawned.
+
+    Honors a per-agent override (BAMBOO_CODING_CLAUDE_BIN=...) first, then
+    walks the declared binary names on PATH.
+    """
+    override = os.environ.get(f"BAMBOO_CODING_{def_.id.upper()}_BIN")
+    if override:
+        if sys.platform == "win32":
+            # CreateProcess won't resolve `.cmd`/`.exe`-less names; which()
+            # honors PATHEXT and passes absolute paths through.
+            return shutil.which(override)
+        return override if os.access(override, os.X_OK) else None
+    for candidate in (def_.bin, *def_.fallback_bins):
+        path = shutil.which(candidate)
+        if path:
+            return path
+    return None
+
+
+def probe_version(path: str, def_: AgentDef) -> tuple[bool, str | None, str | None]:
+    """Returns (invocable, version, diagnostic).
+
+    Two failure modes are discriminated: the OS rejecting the spawn (binary
+    missing/not executable -> unavailable) versus the CLI running but
+    --version misbehaving (timeout/nonzero -> still usable, version unknown).
+    """
+    try:
+        proc = subprocess.run(
+            [path, *def_.version_args],
+            capture_output=True,
+            timeout=VERSION_PROBE_TIMEOUT,
+        )
+    except subprocess.TimeoutExpired:
+        return True, None, None  # ran, just slow — still usable
+    except PermissionError:
+        return False, None, "not-executable"
+    except FileNotFoundError:
+        return False, None, "missing-target"
+    except OSError as exc:
+        return False, None, f"spawn-failed: {exc}"
+    if proc.returncode in (126, 127):
+        return False, None, "not-executable" if proc.returncode == 126 else "missing-target"
+    first_line = proc.stdout.decode(errors="replace").strip().splitlines()
+    return True, (first_line[0] if first_line else None), None
+
+
+def probe_capabilities(path: str, def_: AgentDef) -> dict[str, bool]:
+    if not def_.help_args or not def_.capability_flags:
+        return {}
+    try:
+        proc = subprocess.run(
+            [path, *def_.help_args],
+            capture_output=True,
+            timeout=HELP_PROBE_TIMEOUT,
+        )
+        text = proc.stdout.decode(errors="replace")
+        return {key: flag in text for flag, key in def_.capability_flags.items()}
+    except Exception:
+        return {}  # --help failed -> safe baseline: no optional flags
+
+
+def fetch_models(path: str, def_: AgentDef) -> list[ModelOption]:
+    if def_.list_models_args and def_.parse_models:
+        try:
+            proc = subprocess.run(
+                [path, *def_.list_models_args],
+                capture_output=True,
+                timeout=MODELS_PROBE_TIMEOUT,
+            )
+            parsed = def_.parse_models(proc.stdout.decode(errors="replace"))
+            # Empty parse means fallback, otherwise the picker gets stuck.
+            if parsed:
+                return parsed
+        except Exception:
+            pass
+    return list(def_.fallback_models)
+
+
+def probe(def_: AgentDef) -> DetectedAgent:
+    path = resolve_bin(def_)
+    if not path:
+        return DetectedAgent(def_, available=False, diagnostic="not on PATH")
+    ok, version, diag = probe_version(path, def_)
+    if not ok:
+        return DetectedAgent(def_, available=False, path=path, diagnostic=diag)
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        caps_future = pool.submit(probe_capabilities, path, def_)
+        models_future = pool.submit(fetch_models, path, def_)
+        caps, models = caps_future.result(), models_future.result()
+    return DetectedAgent(def_, available=True, path=path, version=version, caps=caps, models=models)
+
+
+def detect_agents() -> list[DetectedAgent]:
+    """Probe every defined agent; one probe blowing up must not collapse the list."""
+    with ThreadPoolExecutor(max_workers=len(AGENT_DEFS)) as pool:
+        futures = [(d, pool.submit(probe, d)) for d in AGENT_DEFS]
+        results = []
+        for def_, future in futures:
+            try:
+                results.append(future.result())
+            except Exception as exc:  # noqa: BLE001 - fault isolation per agent
+                LOGGER.exception("Detection probe failed for %s", def_.id)
+                results.append(DetectedAgent(def_, available=False, diagnostic=str(exc)))
+    return results
+
+
+_cache_lock = threading.Lock()
+_cache: tuple[float, list[DetectedAgent]] | None = None
+
+
+def detect_agents_cached(refresh: bool = False) -> list[DetectedAgent]:
+    """TTL-cached detection so UI polls don't spawn probe subprocesses each time."""
+    global _cache
+    with _cache_lock:
+        if not refresh and _cache is not None and time.monotonic() - _cache[0] < CACHE_TTL_SECONDS:
+            return _cache[1]
+    results = detect_agents()
+    with _cache_lock:
+        _cache = (time.monotonic(), results)
+    return results
+
+
+def get_detected(agent_id: str, refresh: bool = False) -> DetectedAgent | None:
+    for detected in detect_agents_cached(refresh=refresh):
+        if detected.def_.id == agent_id:
+            return detected
+    return None