bumblebee-cli 0.1.0 → 0.2.0

package/python/bb_cli/progress.py

@@ -0,0 +1,117 @@
+"""Rich Live progress tracker for batch agent operations."""
+
+from __future__ import annotations
+
+import time
+import threading
+
+from rich.live import Live
+from rich.table import Table
+from rich.text import Text
+
+
+class AgentProgressTracker:
+    """Thread-safe progress tracker with Rich Live table display.
+
+    Usage:
+        with AgentProgressTracker() as tracker:
+            # From worker threads:
+            tracker.update("BB-42", "execute", "running", "Modifying auth.py")
+            tracker.complete("BB-42", True, "Done")
+    """
+
+    def __init__(self):
+        self._data: dict[str, dict] = {}
+        self._lock = threading.Lock()
+        self._start_time = time.monotonic()
+        self._completed = 0
+        self._total = 0
+        self._live: Live | None = None
+
+    def register(self, item_key: str):
+        """Register an item before work starts."""
+        with self._lock:
+            self._data[item_key] = {
+                "phase": "pending",
+                "status": "waiting",
+                "last_line": "",
+                "start": time.monotonic(),
+            }
+            self._total += 1
+
+    def update(self, item_key: str, phase: str, status: str, last_line: str):
+        """Update progress for an item (called from worker threads)."""
+        with self._lock:
+            if item_key not in self._data:
+                self._data[item_key] = {"start": time.monotonic()}
+            self._data[item_key].update({
+                "phase": phase,
+                "status": status,
+                "last_line": last_line,
+            })
+
+    def complete(self, item_key: str, success: bool, message: str = ""):
+        """Mark an item as completed."""
+        with self._lock:
+            status = "done" if success else "failed"
+            if item_key in self._data:
+                self._data[item_key].update({
+                    "status": status,
+                    "last_line": message[:60],
+                })
+            self._completed += 1
+
+    def _build_table(self) -> Table:
+        """Build the Rich table (called on each Live refresh)."""
+        table = Table(show_header=True, header_style="bold cyan", expand=True)
+        table.add_column("Item", style="bold", width=12)
+        table.add_column("Phase", width=14)
+        table.add_column("Status", width=10)
+        table.add_column("Last Output", ratio=1)
+
+        with self._lock:
+            for key, info in self._data.items():
+                status = info.get("status", "?")
+                phase = info.get("phase", "?")
+                last_line = info.get("last_line", "")
+
+                # Color status
+                if status == "running":
+                    status_text = Text(status, style="yellow")
+                elif status == "done":
+                    status_text = Text(status, style="green")
+                elif status == "failed":
+                    status_text = Text(status, style="red")
+                else:
+                    status_text = Text(status, style="dim")
+
+                table.add_row(key, phase, status_text, Text(last_line, overflow="ellipsis"))
+
+            elapsed = time.monotonic() - self._start_time
+            mins, secs = divmod(int(elapsed), 60)
+
+        table.caption = f"Elapsed: {mins}m {secs:02d}s | {self._completed}/{self._total} complete | Ctrl+C to abort"
+        return table
+
+    def __enter__(self):
+        self._live = Live(self._build_table(), refresh_per_second=2)
+        self._live.__enter__()
+        # Start refresh loop
+        self._refresh_thread = threading.Thread(target=self._refresh_loop, daemon=True)
+        self._stop_refresh = threading.Event()
+        self._refresh_thread.start()
+        return self
+
+    def __exit__(self, *args):
+        self._stop_refresh.set()
+        self._refresh_thread.join(timeout=2)
+        if self._live:
+            self._live.update(self._build_table())
+            self._live.__exit__(*args)
+
+    def _refresh_loop(self):
+        """Refresh the Live display periodically."""
+        while not self._stop_refresh.is_set():
+            if self._live:
+                self._live.update(self._build_table())
+            self._stop_refresh.wait(0.5)

package/python/bb_cli/streaming.py

@@ -0,0 +1,168 @@
+"""Buffered agent output streaming with local log fallback."""
+
+from __future__ import annotations
+
+import json
+import queue
+import threading
+import time
+from pathlib import Path
+
+from .api_client import api_post
+
+
+def _logs_dir() -> Path:
+    d = Path.home() / ".bumblebee" / "logs"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+class AgentStreamer:
+    """Thread-safe buffered relay for Claude CLI stream-json output.
+
+    - Reads JSON lines via feed()
+    - Writes each line to a local log file immediately (safety net)
+    - Batches events and POSTs to /relay-batch every FLUSH_INTERVAL_S or BATCH_SIZE events
+    - Extracts text blocks for summary
+    """
+
+    BATCH_SIZE = 20
+    FLUSH_INTERVAL_S = 0.5
+
+    def __init__(self, session_id: int | str):
+        self._session_id = session_id
+        self._queue: queue.Queue[dict] = queue.Queue()
+        self._done = threading.Event()
+        self._text_blocks: list[str] = []
+        self._log_path = _logs_dir() / f"session-{session_id}.jsonl"
+        self._log_file = open(self._log_path, "a", encoding="utf-8")
+        self._sender_thread: threading.Thread | None = None
+        self._callback: callable | None = None
+
+    @property
+    def text_blocks(self) -> list[str]:
+        return self._text_blocks
+
+    @property
+    def log_path(self) -> Path:
+        return self._log_path
+
+    def set_callback(self, cb: callable):
+        """Set a callback(payload: dict, text: str|None) for each event."""
+        self._callback = cb
+
+    def start(self):
+        """Start the background sender thread."""
+        self._sender_thread = threading.Thread(
+            target=self._sender_loop, daemon=True, name=f"streamer-{self._session_id}"
+        )
+        self._sender_thread.start()
+
+    def feed(self, line: str):
+        """Feed a raw line from Claude CLI stdout."""
+        line = line.strip()
+        if not line:
+            return
+
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError:
+            return
+
+        # Write to log file immediately
+        self._log_file.write(line + "\n")
+        self._log_file.flush()
+
+        # Extract text blocks
+        text = None
+        if payload.get("type") == "assistant":
+            for block in payload.get("content", []):
+                if block.get("type") == "text":
+                    text = block["text"]
+                    self._text_blocks.append(text)
+
+        # Notify callback (for terminal display, progress tracker, etc.)
+        if self._callback:
+            try:
+                self._callback(payload, text)
+            except Exception:
+                pass
+
+        # Enqueue for batch relay
+        self._queue.put(payload)
+
+    def stop(self) -> list[str]:
+        """Signal completion, flush remaining events, return text blocks."""
+        self._done.set()
+        if self._sender_thread:
+            self._sender_thread.join(timeout=10)
+        self._log_file.close()
+        return self._text_blocks
+
+    def _sender_loop(self):
+        """Background thread: batch events and POST to API."""
+        buffer: list[dict] = []
+        last_flush = time.monotonic()
+
+        while not self._done.is_set() or not self._queue.empty():
+            # Drain queue
+            try:
+                item = self._queue.get(timeout=0.25)
+                buffer.append(item)
+            except queue.Empty:
+                pass
+
+            # Flush conditions
+            now = time.monotonic()
+            should_flush = (
+                len(buffer) >= self.BATCH_SIZE
+                or (buffer and now - last_flush >= self.FLUSH_INTERVAL_S)
+                or (buffer and self._done.is_set())
+            )
+
+            if should_flush:
+                self._flush(buffer)
+                buffer = []
+                last_flush = now
+
+    def _flush(self, events: list[dict]):
+        """POST batch to API. Swallow errors — log file is the safety net."""
+        if not events:
+            return
+        try:
+            api_post(
+                f"/api/agent-sessions/{self._session_id}/relay-batch",
+                json={"events": events},
+            )
+        except Exception:
+            pass  # Data preserved in log file
+
+
+def api_patch(path: str, json: dict) -> dict:
+    """PATCH request helper (not in api_client.py yet)."""
+    from .api_client import get_client
+
+    with get_client() as client:
+        resp = client.patch(path, json=json)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def update_phase(session_id: int | str, phase: str, **kwargs):
+    """Update agent session phase via API."""
+    body: dict = {"phase": phase}
+    body.update(kwargs)
+    try:
+        api_patch(f"/api/agent-sessions/{session_id}/phase", json=body)
+    except Exception:
+        pass
+
+
+def complete_session(session_id: int | str, status: str, **kwargs):
+    """Mark agent session as completed/failed via API."""
+    body: dict = {"status": status}
+    body.update(kwargs)
+    try:
+        api_post(f"/api/agent-sessions/{session_id}/complete", json=body)
+    except Exception:
+        pass

package/python/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bumblebee-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Bumblebee CLI - bb command for dev task management"
 requires-python = ">=3.12"
 dependencies = [

package/python/{bb_cli/bumblebee_cli.egg-info/requires.txt → requirements.txt}

@@ -1,4 +1,4 @@
-typer>=0.15.0
-httpx>=0.28.0
-rich>=13.9.0
-toml>=0.10.2
+typer>=0.15.0
+httpx>=0.28.0
+rich>=13.9.0
+toml>=0.10.2

package/scripts/build.sh

@@ -1,20 +1,20 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Build script: copies the Python CLI source into the npm package for publishing.
-# Run from repo root: bash packages/npm-cli/scripts/build.sh
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PKG_DIR="$(dirname "$SCRIPT_DIR")"
-REPO_ROOT="$(dirname "$(dirname "$PKG_DIR")")"
-
-DEST="$PKG_DIR/python"
-
-echo "Copying CLI source to $DEST..."
-rm -rf "$DEST"
-cp -r "$REPO_ROOT/cli" "$DEST"
-
-# Clean up build artifacts
-rm -rf "$DEST"/__pycache__ "$DEST"/**/__pycache__ "$DEST"/*.egg-info "$DEST"/dist "$DEST"/build
-
-echo "Build complete. Ready to publish with: cd $PKG_DIR && npm publish"
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build script: copies the Python CLI source into the npm package for publishing.
+# Run from repo root: bash packages/npm-cli/scripts/build.sh
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PKG_DIR="$(dirname "$SCRIPT_DIR")"
+REPO_ROOT="$(dirname "$(dirname "$PKG_DIR")")"
+
+DEST="$PKG_DIR/python"
+
+echo "Copying CLI source to $DEST..."
+rm -rf "$DEST"
+cp -r "$REPO_ROOT/cli" "$DEST"
+
+# Clean up build artifacts
+rm -rf "$DEST"/__pycache__ "$DEST"/**/__pycache__ "$DEST"/*.egg-info "$DEST"/dist "$DEST"/build
+
+echo "Build complete. Ready to publish with: cd $PKG_DIR && npm publish"

package/scripts/postinstall.mjs

@@ -1,121 +1,146 @@
-#!/usr/bin/env node
-
-/**
- * Postinstall script for bumblebee-cli
- *
- * - Checks for Python 3.12+
- * - Skips if `bb` is already on PATH (user installed via pip)
- * - Creates a local .venv and installs the Python CLI
- * - NEVER fails npm install — warns instead
- */
-
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = join(__dirname, "..");
-const pythonDir = join(pkgRoot, "python");
-
-function log(msg) {
-  console.log(`[bumblebee-cli] ${msg}`);
-}
-
-function warn(msg) {
-  console.warn(`[bumblebee-cli] WARNING: ${msg}`);
-}
-
-// Check if bb is already available
-function isBbInstalled() {
-  try {
-    const which = process.platform === "win32" ? "where" : "which";
-    execSync(`${which} bb`, { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Find python and check version
-function findPython() {
-  const candidates = ["python3", "python"];
-  for (const cmd of candidates) {
-    try {
-      const version = execSync(`${cmd} --version`, {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-      }).trim();
-      // Parse "Python 3.12.x"
-      const match = version.match(/Python (\d+)\.(\d+)/);
-      if (match) {
-        const major = parseInt(match[1], 10);
-        const minor = parseInt(match[2], 10);
-        if (major === 3 && minor >= 12) {
-          return { cmd, version };
-        }
-      }
-    } catch {
-      // try next
-    }
-  }
-  return null;
-}
-
-function main() {
-  // Skip if bb already installed via pip
-  if (isBbInstalled()) {
-    log("'bb' command found on PATH — skipping Python setup.");
-    return;
-  }
-
-  // Find suitable Python
-  const python = findPython();
-  if (!python) {
-    warn(
-      "Python 3.12+ not found. The 'bb' command won't work until you:\n" +
-        "  1. Install Python 3.12+ (https://python.org)\n" +
-        "  2. Run: pip install bumblebee-cli"
-    );
-    return;
-  }
-
-  log(`Found ${python.version} (${python.cmd})`);
-
-  // Create .venv and install
-  const venvDir = join(pkgRoot, ".venv");
-  const isWin = process.platform === "win32";
-  const pip = isWin
-    ? join(venvDir, "Scripts", "pip.exe")
-    : join(venvDir, "bin", "pip");
-
-  try {
-    if (!existsSync(venvDir)) {
-      log("Creating virtual environment...");
-      execSync(`${python.cmd} -m venv "${venvDir}"`, { stdio: "pipe" });
-    }
-
-    // Install from bundled python/ dir if available, otherwise from PyPI
-    if (existsSync(pythonDir)) {
-      log("Installing Bumblebee CLI from bundled source...");
-      execSync(`"${pip}" install "${pythonDir}"`, { stdio: "pipe" });
-    } else {
-      log("Installing Bumblebee CLI from PyPI...");
-      execSync(`"${pip}" install bumblebee-cli`, { stdio: "pipe" });
-    }
-
-    log("Setup complete! Run 'bb --help' to get started.");
-  } catch (e) {
-    warn(
-      `Python setup failed: ${e.message}\n` +
-        "You can still install manually: pip install bumblebee-cli"
-    );
-  }
-}
-
-try {
-  main();
-} catch {
-  // Never fail npm install
-  warn("Postinstall encountered an error, but npm install will continue.");
-}
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for bumblebee-cli
+ *
+ * - Checks for Python 3.12+
+ * - Skips if a real (pip-installed) `bb` is already on PATH
+ * - Creates a local .venv and installs the Python CLI
+ * - NEVER fails npm install — warns instead
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(__dirname, "..");
+const pythonDir = join(pkgRoot, "python");
+
+function log(msg) {
+  console.log(`[bumblebee-cli] ${msg}`);
+}
+
+function warn(msg) {
+  console.warn(`[bumblebee-cli] WARNING: ${msg}`);
+}
+
+// Check if a real (non-npm-wrapper) bb is already available
+function isPipBbInstalled() {
+  try {
+    // Try running bb --help and check if it's the Python CLI (not our wrapper)
+    const which = process.platform === "win32" ? "where" : "which";
+    const result = execSync(`${which} bb`, { encoding: "utf8", stdio: "pipe" });
+    const paths = result.trim().split(/\r?\n/);
+
+    // Get npm global prefix to filter out our own wrapper
+    let npmPrefix = null;
+    try {
+      npmPrefix = execSync("npm prefix -g", { encoding: "utf8", stdio: "pipe" }).trim();
+    } catch {}
+
+    for (const bbPath of paths) {
+      const p = bbPath.trim();
+      if (!p) continue;
+      const normalized = resolve(p).toLowerCase();
+      // Skip if it's inside npm global prefix (that's our own wrapper)
+      if (npmPrefix && normalized.startsWith(resolve(npmPrefix).toLowerCase())) {
+        continue;
+      }
+      // Skip if it's inside node_modules
+      if (normalized.includes("node_modules") && normalized.includes("bumblebee-cli")) {
+        continue;
+      }
+      // Found a real bb (pip-installed)
+      return true;
+    }
+  } catch {
+    // not found
+  }
+  return false;
+}
+
+// Find python and check version
+function findPython() {
+  const candidates =
+    process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+  for (const cmd of candidates) {
+    try {
+      const version = execSync(`${cmd} --version`, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      // Parse "Python 3.12.x"
+      const match = version.match(/Python (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        if (major === 3 && minor >= 12) {
+          return { cmd, version };
+        }
+      }
+    } catch {
+      // try next
+    }
+  }
+  return null;
+}
+
+function main() {
+  // Skip if bb already installed via pip
+  if (isPipBbInstalled()) {
+    log("'bb' command found on PATH (pip) — skipping Python setup.");
+    return;
+  }
+
+  // Find suitable Python
+  const python = findPython();
+  if (!python) {
+    warn(
+      "Python 3.12+ not found. The 'bb' command won't work until you:\n" +
+        "  1. Install Python 3.12+ (https://python.org)\n" +
+        "  2. Run: pip install bumblebee-cli"
+    );
+    return;
+  }
+
+  log(`Found ${python.version} (${python.cmd})`);
+
+  // Create .venv and install
+  const venvDir = join(pkgRoot, ".venv");
+  const isWin = process.platform === "win32";
+  const pip = isWin
+    ? join(venvDir, "Scripts", "pip.exe")
+    : join(venvDir, "bin", "pip");
+
+  try {
+    if (!existsSync(venvDir)) {
+      log("Creating virtual environment...");
+      execSync(`${python.cmd} -m venv "${venvDir}"`, { stdio: "pipe" });
+    }
+
+    // Install from bundled python/ dir if available, otherwise from PyPI
+    if (existsSync(pythonDir)) {
+      log("Installing Bumblebee CLI from bundled source...");
+      execSync(`"${pip}" install "${pythonDir}"`, { stdio: "pipe" });
+    } else {
+      log("Installing Bumblebee CLI from PyPI...");
+      execSync(`"${pip}" install bumblebee-cli`, { stdio: "pipe" });
+    }
+
+    log("Setup complete! Run 'bb --help' to get started.");
+  } catch (e) {
+    warn(
+      `Python setup failed: ${e.message}\n` +
+        "You can still install manually: pip install bumblebee-cli"
+    );
+  }
+}
+
+try {
+  main();
+} catch {
+  // Never fail npm install
+  warn("Postinstall encountered an error, but npm install will continue.");
+}

package/python/bb_cli/bumblebee_cli.egg-info/PKG-INFO

@@ -1,9 +0,0 @@
-Metadata-Version: 2.4
-Name: bumblebee-cli
-Version: 0.1.0
-Summary: Bumblebee CLI — bb command for dev task management
-Requires-Python: >=3.12
-Requires-Dist: typer>=0.15.0
-Requires-Dist: httpx>=0.28.0
-Requires-Dist: rich>=13.9.0
-Requires-Dist: toml>=0.10.2

package/python/bb_cli/bumblebee_cli.egg-info/SOURCES.txt

@@ -1,21 +0,0 @@
-pyproject.toml
-src/__init__.py
-src/api_client.py
-src/config.py
-src/main.py
-src/bumblebee_cli.egg-info/PKG-INFO
-src/bumblebee_cli.egg-info/SOURCES.txt
-src/bumblebee_cli.egg-info/dependency_links.txt
-src/bumblebee_cli.egg-info/entry_points.txt
-src/bumblebee_cli.egg-info/requires.txt
-src/bumblebee_cli.egg-info/top_level.txt
-src/commands/__init__.py
-src/commands/agent.py
-src/commands/auth.py
-src/commands/board.py
-src/commands/comment.py
-src/commands/label.py
-src/commands/project.py
-src/commands/sprint.py
-src/commands/story.py
-src/commands/task.py

package/python/bb_cli/bumblebee_cli.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

package/python/bb_cli/bumblebee_cli.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-bb = src.main:app

package/python/bb_cli/bumblebee_cli.egg-info/top_level.txt

@@ -1,5 +0,0 @@
-__init__
-api_client
-commands
-config
-main