bumblebee-cli 0.2.0 → 0.3.0

package/python/bb_cli/streaming.py

@@ -1,168 +0,0 @@
-"""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,18 +0,0 @@
-[project]
-name = "bumblebee-cli"
-version = "0.2.0"
-description = "Bumblebee CLI - bb command for dev task management"
-requires-python = ">=3.12"
-dependencies = [
-    "typer>=0.15.0",
-    "httpx>=0.28.0",
-    "rich>=13.9.0",
-    "toml>=0.10.2",
-]
-
-[project.scripts]
-bb = "bb_cli.main:app"
-
-[build-system]
-requires = ["setuptools>=75.0"]
-build-backend = "setuptools.build_meta"

package/python/requirements.txt

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

package/scripts/build.sh

@@ -1,20 +0,0 @@
-#!/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,146 +0,0 @@
-#!/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.");
-}