@bubblebrain-ai/bubble 0.0.1

package/dist/tui/sidebar-mcp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure helpers for the TUI MCP sidebar widget.
+ *
+ * Kept separate from run.ts so they can be unit-tested without mounting the
+ * full opentui renderer. run.ts imports sidebarMcpRowsFromStates and
+ * renderMcpRowMarker for display; everything else stays in-TUI because it
+ * depends on theme / renderable construction.
+ */
+import type { McpServerState } from "../mcp/types.js";
+export interface SidebarMcpRow {
+    name: string;
+    kind: "connected" | "failed" | "disabled";
+    label: string;
+    toolCount: number;
+    promptCount: number;
+    errorDetail?: string;
+    canReconnect: boolean;
+}
+/**
+ * Project raw McpServerState[] (from McpManager.getStates()) into the display
+ * shape consumed by the sidebar's row renderer. Deterministic and side-effect
+ * free — the single source of truth for what the widget shows per server.
+ */
+export declare function sidebarMcpRowsFromStates(states: McpServerState[]): SidebarMcpRow[];
+/**
+ * Single-char status marker used at the start of each sidebar row.
+ * Mirrors opencode's convention so a connected row reads as a bullet, failed
+ * as a cross, disabled as a hollow circle. Colour is applied separately by
+ * the caller using theme mapping.
+ */
+export declare function renderMcpRowMarker(kind: SidebarMcpRow["kind"]): string;

package/dist/tui/sidebar-mcp.js

@@ -0,0 +1,62 @@
+/**
+ * Pure helpers for the TUI MCP sidebar widget.
+ *
+ * Kept separate from run.ts so they can be unit-tested without mounting the
+ * full opentui renderer. run.ts imports sidebarMcpRowsFromStates and
+ * renderMcpRowMarker for display; everything else stays in-TUI because it
+ * depends on theme / renderable construction.
+ */
+const ERROR_LABEL_MAX = 32;
+function truncateInline(s, n) {
+    return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}
+/**
+ * Project raw McpServerState[] (from McpManager.getStates()) into the display
+ * shape consumed by the sidebar's row renderer. Deterministic and side-effect
+ * free — the single source of truth for what the widget shows per server.
+ */
+export function sidebarMcpRowsFromStates(states) {
+    return states.map((state) => {
+        const kind = state.status.kind;
+        const toolCount = kind === "connected" ? state.status.tools.length : 0;
+        const promptCount = kind === "connected" ? state.status.prompts.length : 0;
+        const errorDetail = kind === "failed" ? state.status.error : undefined;
+        let label;
+        if (kind === "connected") {
+            const parts = [];
+            parts.push(`${toolCount} tool${toolCount === 1 ? "" : "s"}`);
+            if (promptCount > 0) {
+                parts.push(`${promptCount} prompt${promptCount === 1 ? "" : "s"}`);
+            }
+            label = parts.join(", ");
+        }
+        else if (kind === "failed") {
+            label = truncateInline(state.status.error, ERROR_LABEL_MAX);
+        }
+        else {
+            label = "disabled";
+        }
+        return {
+            name: state.name,
+            kind,
+            label,
+            toolCount,
+            promptCount,
+            errorDetail,
+            canReconnect: kind === "failed" || kind === "disabled",
+        };
+    });
+}
+/**
+ * Single-char status marker used at the start of each sidebar row.
+ * Mirrors opencode's convention so a connected row reads as a bullet, failed
+ * as a cross, disabled as a hollow circle. Colour is applied separately by
+ * the caller using theme mapping.
+ */
+export function renderMcpRowMarker(kind) {
+    if (kind === "connected")
+        return "●";
+    if (kind === "failed")
+        return "✗";
+    return "○";
+}

package/dist/tui/sidebar-state.d.ts

@@ -0,0 +1,12 @@
+export interface SidebarFileChange {
+    file: string;
+    additions: number;
+    deletions: number;
+}
+export interface SidebarGitState {
+    branch?: string;
+    files: SidebarFileChange[];
+}
+export declare function parseGitNumstat(output: string): SidebarFileChange[];
+export declare function mergeFileChanges(...groups: SidebarFileChange[][]): SidebarFileChange[];
+export declare function readGitSidebarState(cwd: string): SidebarGitState;

package/dist/tui/sidebar-state.js

@@ -0,0 +1,69 @@
+import { execFileSync } from "node:child_process";
+export function parseGitNumstat(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [rawAdditions, rawDeletions, ...pathParts] = line.split(/\t/);
+        const file = pathParts.join("\t").trim();
+        if (!file)
+            return undefined;
+        return {
+            file,
+            additions: parseGitCount(rawAdditions),
+            deletions: parseGitCount(rawDeletions),
+        };
+    })
+        .filter((item) => !!item);
+}
+export function mergeFileChanges(...groups) {
+    const merged = new Map();
+    for (const group of groups) {
+        for (const item of group) {
+            const existing = merged.get(item.file);
+            if (!existing) {
+                merged.set(item.file, { ...item });
+                continue;
+            }
+            existing.additions += item.additions;
+            existing.deletions += item.deletions;
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.file.localeCompare(b.file));
+}
+export function readGitSidebarState(cwd) {
+    const branch = runGit(cwd, ["branch", "--show-current"]).trim()
+        || runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).trim()
+        || undefined;
+    const unstaged = parseGitNumstat(runGit(cwd, ["--no-pager", "diff", "--numstat"]));
+    const staged = parseGitNumstat(runGit(cwd, ["--no-pager", "diff", "--cached", "--numstat"]));
+    const untracked = runGit(cwd, ["ls-files", "--others", "--exclude-standard"])
+        .split(/\r?\n/)
+        .map((file) => file.trim())
+        .filter(Boolean)
+        .map((file) => ({ file, additions: 0, deletions: 0 }));
+    return {
+        branch,
+        files: mergeFileChanges(unstaged, staged, untracked),
+    };
+}
+function runGit(cwd, args) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 750,
+        });
+    }
+    catch {
+        return "";
+    }
+}
+function parseGitCount(value) {
+    if (value === "-")
+        return 0;
+    const count = Number.parseInt(value, 10);
+    return Number.isFinite(count) ? count : 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Core types for the coding agent.
+ */
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export interface ImageContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+}
+export type ContentPart = TextContent | ImageContent;
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ReasoningEffort = ThinkingLevel;
+export interface UserMessage {
+    role: "user";
+    content: string | ContentPart[];
+    /**
+     * Marks this message as harness-emitted metadata (e.g. a <system-reminder>),
+     * not actual user input. Renderers may hide these; compaction should generally preserve them.
+     */
+    isMeta?: boolean;
+}
+export interface AssistantMessage {
+    role: "assistant";
+    content: string;
+    reasoning?: string;
+    toolCalls?: ToolCall[];
+}
+export interface ToolMessage {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+    metadata?: ToolResultMetadata;
+    isError?: boolean;
+}
+export interface SystemMessage {
+    role: "system";
+    content: string;
+}
+export type Message = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
+export interface ToolParameter {
+    type?: string;
+    description?: string;
+    enum?: string[];
+    items?: ToolParameter;
+    properties?: Record<string, ToolParameter>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface ToolSchema {
+    type: "object";
+    properties: Record<string, ToolParameter>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolSchema;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ParsedToolCall extends ToolCall {
+    parsedArgs: Record<string, any>;
+}
+export type ToolResultStatus = "success" | "no_match" | "partial" | "timeout" | "blocked" | "command_error";
+export interface ToolResultMetadata {
+    kind?: "search" | "read" | "write" | "edit" | "shell" | "web" | "security" | "lsp" | "question";
+    path?: string;
+    pattern?: string;
+    matches?: number;
+    truncated?: boolean;
+    searchSignature?: string;
+    searchFamily?: string;
+    reason?: string;
+    arbiterNote?: string;
+    [key: string]: unknown;
+}
+export interface ToolResult {
+    content: string;
+    isError?: boolean;
+    status?: ToolResultStatus;
+    metadata?: ToolResultMetadata;
+}
+export type ToolExecutor = (args: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>;
+export interface ToolContext {
+    cwd: string;
+    sessionID?: string;
+    abortSignal?: AbortSignal;
+    toolCall?: {
+        id: string;
+        name: string;
+    };
+    agent?: {
+        runSubtask: (input: string | ContentPart[], cwd: string, options?: {
+            subtaskType?: string;
+            description?: string;
+        }) => Promise<ToolResult>;
+    };
+}
+export interface ToolRegistryEntry extends ToolDefinition {
+    execute: ToolExecutor;
+    /** Whether this tool is allowed in plan mode. Defaults to false (treated as write-capable). */
+    readOnly?: boolean;
+    /**
+     * If true, this tool is omitted from the tool list sent to the model on each
+     * turn until unlocked via `tool_search`. Only the tool's name appears in a
+     * startup &lt;system-reminder&gt;. Used for MCP tools to keep them out of the
+     * per-turn context cost when not in use.
+     */
+    deferred?: boolean;
+}
+/**
+ * Runtime permission policy for tool execution. Mirrors Claude Code's
+ * `EXTERNAL_PERMISSION_MODES`:
+ *
+ * - `default`         — every destructive tool asks via the approval UI.
+ * - `acceptEdits`     — edits/writes auto-approve; bash still asks.
+ * - `plan`            — read-only tools only; the model must propose via
+ *                       exit_plan_mode and get user approval before executing.
+ * - `bypassPermissions` — everything auto-approves. Must be explicitly enabled
+ *                       via --dangerously-skip-permissions at startup.
+ * - `dontAsk`         — same as bypass but silent (no prompts, no extra
+ *                       narration). Not in the Shift+Tab cycle.
+ */
+export type PermissionMode = "default" | "acceptEdits" | "plan" | "bypassPermissions" | "dontAsk";
+export type PlanDecision = {
+    action: "approve";
+    plan: string;
+} | {
+    action: "reject";
+    reason?: string;
+};
+export type TodoStatus = "pending" | "in_progress" | "completed";
+export interface Todo {
+    content: string;
+    status: TodoStatus;
+    activeForm: string;
+}
+export type StreamChunk = {
+    type: "text";
+    content: string;
+} | {
+    type: "reasoning_delta";
+    content: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    arguments: string;
+    isStart: boolean;
+    isEnd: boolean;
+} | {
+    type: "usage";
+    usage: TokenUsage;
+} | {
+    type: "done";
+};
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    promptCacheHitTokens?: number;
+    promptCacheMissTokens?: number;
+    reasoningTokens?: number;
+    totalTokens?: number;
+}
+export interface Provider {
+    streamChat(messages: Message[], options: {
+        model: string;
+        tools?: ToolDefinition[];
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }): AsyncIterable<StreamChunk>;
+    complete(messages: Message[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }): Promise<string>;
+}
+export type AgentEvent = {
+    type: "turn_start";
+} | {
+    type: "text_delta";
+    content: string;
+} | {
+    type: "reasoning_delta";
+    content: string;
+} | {
+    type: "tool_start";
+    id: string;
+    name: string;
+    args: Record<string, any>;
+} | {
+    type: "tool_end";
+    id: string;
+    name: string;
+    result: ToolResult;
+} | {
+    type: "turn_end";
+    usage?: TokenUsage;
+} | {
+    type: "context_recovered";
+    droppedMessages: number;
+    reason: "overflow";
+} | {
+    type: "mode_changed";
+    mode: PermissionMode;
+} | {
+    type: "todos_updated";
+    todos: Todo[];
+} | {
+    type: "agent_end";
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for the coding agent.
+ */
+export {};

package/dist/variant/thinking-level.d.ts

@@ -0,0 +1,5 @@
+import type { ThinkingLevel } from "../types.js";
+export declare const THINKING_LEVELS: ThinkingLevel[];
+export declare function isThinkingLevel(value: string | undefined): value is ThinkingLevel;
+export declare function clampThinkingLevel(requestedLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;
+export declare function getNextThinkingLevel(currentLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;

package/dist/variant/thinking-level.js

@@ -0,0 +1,25 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export function isThinkingLevel(value) {
+    return !!value && THINKING_LEVELS.includes(value);
+}
+export function clampThinkingLevel(requestedLevel, supportedLevels) {
+    if (supportedLevels.length === 0) {
+        return "off";
+    }
+    if (supportedLevels.includes(requestedLevel)) {
+        return requestedLevel;
+    }
+    const requestedIndex = THINKING_LEVELS.indexOf(requestedLevel);
+    for (let index = requestedIndex; index >= 0; index--) {
+        const candidate = THINKING_LEVELS[index];
+        if (supportedLevels.includes(candidate)) {
+            return candidate;
+        }
+    }
+    return supportedLevels[0];
+}
+export function getNextThinkingLevel(currentLevel, supportedLevels) {
+    const normalizedCurrent = clampThinkingLevel(currentLevel, supportedLevels);
+    const currentIndex = supportedLevels.indexOf(normalizedCurrent);
+    return supportedLevels[(currentIndex + 1) % supportedLevels.length];
+}

package/dist/variant/variant-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { ThinkingLevel } from "../types.js";
+export declare function getAvailableThinkingLevels(providerId: string, modelId: string): ThinkingLevel[];
+export declare function getDefaultThinkingLevel(providerId: string, modelId: string): ThinkingLevel;
+export declare function normalizeThinkingLevel(level: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;

package/dist/variant/variant-resolver.js

@@ -0,0 +1,12 @@
+import { getBuiltinModel } from "../model-catalog.js";
+import { clampThinkingLevel } from "./thinking-level.js";
+export function getAvailableThinkingLevels(providerId, modelId) {
+    return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
+}
+export function getDefaultThinkingLevel(providerId, modelId) {
+    const levels = getAvailableThinkingLevels(providerId, modelId);
+    return levels.includes("medium") ? "medium" : levels[0] || "off";
+}
+export function normalizeThinkingLevel(level, supportedLevels) {
+    return clampThinkingLevel(level, supportedLevels);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@bubblebrain-ai/bubble",
+  "version": "0.0.1",
+  "description": "A terminal coding agent",
+  "type": "module",
+  "bin": {
+    "bubble": "./dist/main.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/__tests__/**",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc && chmod +x dist/main.js",
+    "dev": "tsc && bun dist/main.js",
+    "prepack": "npm run build",
+    "start": "bun dist/main.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.99",
+    "@opentui/solid": "^0.1.99",
+    "@types/better-sqlite3": "^7.6.13",
+    "@vue/language-server": "^3.2.7",
+    "better-sqlite3": "^12.9.0",
+    "chalk": "^5.3.0",
+    "diff": "^7.0.0",
+    "openai": "^4.77.0",
+    "opentui-spinner": "^0.0.6",
+    "picomatch": "^4.0.4",
+    "solid-js": "^1.9.11",
+    "typescript-language-server": "^5.1.3",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-langservers-extracted": "^4.10.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.0",
+    "@types/node": "^22.0.0",
+    "@types/picomatch": "^4.0.3",
+    "@vitest/coverage-v8": "^4.1.4",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.4"
+  }
+}