@bubblebrain-ai/bubble 0.0.1

package/dist/main.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env bun
+/**
+ * Main entry point - assembles all layers and runs the agent.
+ */
+import chalk from "chalk";
+import { Agent } from "./agent.js";
+import { parseArgs, printHelp } from "./cli.js";
+import { UserConfig } from "./config.js";
+import { createProviderInstance, createUnavailableProvider } from "./provider.js";
+import { getDefaultThinkingLevel } from "./provider-transform.js";
+import { ProviderRegistry, displayModel, encodeModel, decodeModel } from "./provider-registry.js";
+import { SessionManager } from "./session.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { SkillRegistry } from "./skills/registry.js";
+import { createAllTools } from "./tools/index.js";
+import { PermissionAwareApprovalController } from "./approval/controller.js";
+import { BashAllowlist } from "./approval/session-cache.js";
+import { SettingsManager } from "./permissions/settings.js";
+import { getLspService } from "./lsp/index.js";
+import { loadMcpConfig } from "./mcp/config.js";
+import { McpManager } from "./mcp/manager.js";
+import { QuestionController } from "./question/index.js";
+import { buildMemoryPrompt, formatMemoryStartupResult, recordMemoryCitations, runMemoryPhase2, runMemoryStartupPipeline, startMemoryStartupTask, } from "./memory/index.js";
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (process.argv.includes("-h") || process.argv.includes("--help")) {
+        printHelp();
+        process.exit(0);
+    }
+    const userConfig = new UserConfig();
+    const registry = new ProviderRegistry(userConfig);
+    const skillRegistry = new SkillRegistry({
+        cwd: args.cwd,
+        skillPaths: userConfig.getSkillPaths(),
+    });
+    const printMode = args.print || !!args.prompt;
+    // Resolve configured providers only; do not auto-inject OpenRouter as a startup default.
+    const providers = registry.getConfigured();
+    if (providers.length === 0) {
+        if (printMode) {
+            console.error(chalk.red("Error: No provider configured. Start interactive mode and use /login or /provider --add <id>."));
+            process.exit(1);
+        }
+        console.log(chalk.dim("No provider configured yet. Start with /login for ChatGPT or /provider --add <id> for an API key."));
+    }
+    const defaultProvider = registry.getDefault();
+    const unavailableProviderMessage = "No provider configured. Use /login for ChatGPT or /provider --add <id> before sending a prompt.";
+    const provider = defaultProvider
+        ? createProviderInstance({
+            providerId: defaultProvider.id,
+            apiKey: defaultProvider.apiKey,
+            baseURL: defaultProvider.baseURL,
+            thinkingLevel: args.thinkingLevel,
+        })
+        : createUnavailableProvider(unavailableProviderMessage);
+    const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({ providerId, apiKey, baseURL, thinkingLevel: args.thinkingLevel });
+    let agentRef;
+    const todoStore = {
+        getTodos: () => agentRef?.getTodos() ?? [],
+        setTodos: (todos) => agentRef?.setTodos(todos),
+    };
+    const planHandlerRef = {};
+    const planController = {
+        getMode: () => agentRef?.mode ?? "default",
+        requestApproval: (plan) => planHandlerRef.current
+            ? planHandlerRef.current(plan)
+            : Promise.resolve({
+                action: "reject",
+                reason: "No interactive UI available to approve the plan.",
+            }),
+        setMode: (mode) => {
+            agentRef?.setMode(mode);
+        },
+    };
+    const approvalHandlerRef = {};
+    const questionController = new QuestionController();
+    const bashAllowlist = new BashAllowlist();
+    const settingsManager = new SettingsManager(args.cwd);
+    for (const d of settingsManager.getMerged().diagnostics) {
+        console.error(chalk.yellow(`[settings:${d.scope}] ${d.path}: ${d.message}`));
+    }
+    const approvalController = new PermissionAwareApprovalController({
+        getMode: () => agentRef?.mode ?? "default",
+        handlerRef: approvalHandlerRef,
+        bashAllowlist,
+        cwd: args.cwd,
+        getRuleSet: () => settingsManager.getMerged().ruleSet,
+    });
+    const toolSearchController = {
+        listDeferred: () => agentRef?.listDeferredTools() ?? [],
+        unlock: (names) => agentRef?.unlockDeferredTools(names),
+    };
+    const lspService = getLspService(args.cwd, settingsManager.getMerged().lsp);
+    const tools = createAllTools(args.cwd, skillRegistry, {
+        todoStore,
+        planController,
+        approvalController,
+        questionController: printMode ? undefined : questionController,
+        toolSearchController,
+        lspService,
+    });
+    // Bring up MCP servers (if any). Failures are captured per-server and never
+    // block the rest of startup; /mcp surfaces status at runtime.
+    const mcpLoaded = loadMcpConfig({ cwd: args.cwd });
+    for (const d of mcpLoaded.diagnostics) {
+        console.error(chalk.yellow(`[mcp:${d.scope}] ${d.path}: ${d.message}`));
+    }
+    const mcpManager = new McpManager({ servers: mcpLoaded.servers });
+    if (mcpLoaded.servers.length > 0) {
+        await mcpManager.start();
+        // Only surface failures at startup. Successful connections would push the
+        // welcome screen above the visible area on small terminals. /mcp shows the
+        // full status.
+        for (const state of mcpManager.getStates()) {
+            if (state.status.kind === "failed") {
+                console.error(chalk.yellow(`[mcp] ${state.name}: failed — ${state.status.error}`));
+            }
+        }
+        tools.push(...mcpManager.getToolEntries());
+    }
+    // Expose MCP prompts as slash commands. Queried live at each lookup so
+    // /mcp reconnect picks up new prompts without restarting the process.
+    {
+        const { registry: slashRegistry } = await import("./slash-commands/index.js");
+        slashRegistry.addDynamicSource(() => mcpManager.getPromptCommands());
+    }
+    // Signal-based shutdown for Ctrl-C / kill. For /quit the command handler
+    // shuts MCP down directly — process.once("exit", ...)
+    // runs synchronously and can't await async work, so relying on it is a trap.
+    const shutdownMcp = async () => {
+        try {
+            await mcpManager.shutdown();
+        }
+        catch {
+            // ignore — we're exiting anyway
+        }
+    };
+    process.once("SIGINT", () => { void shutdownMcp().then(() => process.exit(130)); });
+    process.once("SIGTERM", () => { void shutdownMcp().then(() => process.exit(143)); });
+    // Session management:
+    // - default: always start a fresh session
+    // - --resume: explicitly restore the latest or a named session
+    let sessionManager = args.resume
+        ? SessionManager.resume(args.cwd, args.sessionName)
+        : undefined;
+    let resumedExistingSession = !!sessionManager;
+    if (!sessionManager) {
+        sessionManager = args.sessionName && !args.resume
+            ? SessionManager.create(args.cwd, args.sessionName)
+            : SessionManager.createFresh(args.cwd);
+        resumedExistingSession = false;
+    }
+    // Model resolution:
+    // 1. Session metadata  2. User-configured default model  3. CLI flag
+    // No implicit built-in model fallback.
+    const fallbackProviderId = defaultProvider?.id || "";
+    const sessionModel = sessionManager?.getMetadata().model;
+    const configuredModel = sessionModel ?? userConfig.getDefaultModel() ?? args.model;
+    const sessionThinkingLevel = sessionManager?.getMetadata().thinkingLevel;
+    const configuredThinkingLevel = userConfig.getDefaultThinkingLevel();
+    const normalizedConfiguredModel = configuredModel
+        ? (configuredModel.includes(":")
+            ? configuredModel
+            : (fallbackProviderId ? encodeModel(fallbackProviderId, configuredModel) : ""))
+        : "";
+    const { providerId: effectiveProviderId, modelId: effectiveModelId } = normalizedConfiguredModel
+        ? decodeModel(normalizedConfiguredModel)
+        : { providerId: undefined, modelId: "" };
+    let activeProviderId = effectiveProviderId || fallbackProviderId;
+    if (registry.supportsOAuth(activeProviderId) && registry.getAuthStorage().has(activeProviderId)) {
+        await registry.prepareProvider(activeProviderId);
+    }
+    const activeProvider = registry.getConfigured().find((p) => p.id === activeProviderId) || defaultProvider;
+    const activeModel = activeProvider && effectiveModelId
+        ? encodeModel(activeProviderId, effectiveModelId)
+        : "";
+    if (!activeModel && !activeProvider) {
+        activeProviderId = "";
+    }
+    const initialThinkingLevel = activeModel
+        ? (sessionThinkingLevel
+            ?? args.thinkingLevel
+            ?? configuredThinkingLevel
+            ?? getDefaultThinkingLevel(activeProviderId, effectiveModelId))
+        : (sessionThinkingLevel ?? args.thinkingLevel ?? configuredThinkingLevel ?? "off");
+    const restoredTodos = sessionManager?.getTodos() ?? [];
+    const initialMode = args.mode ?? "default";
+    const systemPrompt = buildSystemPrompt({
+        agentName: "Bubble",
+        configuredProvider: activeProviderId || "none",
+        configuredModel: activeModel ? displayModel(activeModel) : "none",
+        configuredModelId: activeModel || "none",
+        thinkingLevel: initialThinkingLevel,
+        mode: initialMode,
+        workingDir: args.cwd,
+        tools: tools.map((tool) => tool.name),
+        skills: skillRegistry.summaries(),
+        memoryPrompt: buildMemoryPrompt(args.cwd),
+    });
+    const agent = new Agent({
+        provider: activeProvider
+            ? createProvider(activeProviderId, activeProvider.apiKey, activeProvider.baseURL)
+            : provider,
+        providerId: activeProviderId || "",
+        model: activeModel,
+        sessionID: sessionManager?.getSessionFile(),
+        tools,
+        systemPrompt,
+        temperature: 0.2,
+        thinkingLevel: initialThinkingLevel,
+        mode: initialMode,
+        todos: restoredTodos,
+        onMessageAppend: (message) => {
+            if (!sessionManager)
+                return;
+            if (message.role === "system")
+                return;
+            // <system-reminder> injections are runtime/ephemeral; don't persist them —
+            // they will be re-injected as needed on resume based on the current mode.
+            if (message.role === "user" && message.isMeta)
+                return;
+            sessionManager.appendMessage(message);
+            if (message.role === "assistant") {
+                recordMemoryCitations(args.cwd, message.content);
+            }
+        },
+        onToolResult: (toolName, result) => {
+            if (!sessionManager)
+                return;
+            if (toolName !== "skill" || result.isError)
+                return;
+            const match = result.content.match(/^Skill:\s+([^\n]+)$/m);
+            if (match?.[1]) {
+                sessionManager.appendMarker("skill_activated", match[1].trim());
+            }
+        },
+        onTodosUpdate: (todos) => {
+            sessionManager?.appendTodosSnapshot(todos);
+        },
+        onModeUpdate: (mode) => {
+            sessionManager?.appendMarker("mode_switch", mode);
+        },
+    });
+    agentRef = agent;
+    if (sessionManager) {
+        sessionManager.setMetadata({
+            ...(agent.model ? { model: agent.model } : {}),
+            cwd: args.cwd,
+            thinkingLevel: agent.thinking,
+            reasoningEffort: agent.thinking,
+        });
+    }
+    const flushMemory = async () => {
+        // Codex-style memory runs at startup over historical rollouts. Exit should
+        // not perform an ad-hoc extraction of the just-finished session.
+    };
+    const runMemoryCompaction = async () => formatMemoryStartupResult(await runMemoryStartupPipeline({
+        cwd: args.cwd,
+        complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
+        model: agent.apiModel,
+    }));
+    const runMemorySummary = async () => {
+        const result = await runMemoryPhase2({
+            cwd: args.cwd,
+            complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
+            model: agent.apiModel,
+        });
+        return `Memory Phase 2 ${result.status}: selected ${result.selected}${result.reason ? ` (${result.reason})` : ""}.`;
+    };
+    const runMemoryRefresh = runMemoryCompaction;
+    startMemoryStartupTask({
+        cwd: args.cwd,
+        complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
+        model: agent.apiModel,
+    });
+    if (activeModel && args.model && normalizedConfiguredModel === agent.model) {
+        userConfig.pushRecentModel(agent.model);
+    }
+    // Restore session if requested
+    if (resumedExistingSession && sessionManager) {
+        const history = sessionManager.getMessages();
+        if (history.length > 0) {
+            agent.messages = [{ role: "system", content: systemPrompt }, ...history];
+            // Reassigning agent.messages drops any <system-reminder> we injected during
+            // construction. Re-inject if the agent is starting in plan mode.
+            if (agent.mode === "plan") {
+                const { PLAN_MODE_ENTER_REMINDER } = await import("./prompt/reminders.js");
+                agent.injectSystemReminder(PLAN_MODE_ENTER_REMINDER);
+            }
+            console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
+        }
+    }
+    // Print mode: single prompt, then exit
+    if (args.print || args.prompt) {
+        const prompt = args.prompt || (await readPipedStdin()) || "";
+        if (!prompt) {
+            console.error(chalk.red("Error: No prompt provided."));
+            process.exit(1);
+        }
+        for await (const event of agent.run(prompt, args.cwd)) {
+            if (event.type === "text_delta") {
+                process.stdout.write(event.content);
+            }
+            else if (event.type === "tool_start") {
+                console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+            }
+            else if (event.type === "tool_end") {
+                const color = event.result.isError ? chalk.red : chalk.dim;
+                console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+            }
+        }
+        console.log();
+        return;
+    }
+    // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
+    const { runTui } = await import("./tui/run.js");
+    await runTui(agent, args, {
+        sessionManager,
+        createProvider,
+        registry,
+        skillRegistry,
+        planHandlerRef,
+        approvalHandlerRef,
+        questionController,
+        bashAllowlist,
+        settingsManager,
+        lspService,
+        mcpManager,
+        bypassEnabled: args.bypassEnabled,
+        theme: userConfig.getTheme(),
+        flushMemory,
+        runMemoryCompaction,
+        runMemorySummary,
+        runMemoryRefresh,
+    });
+    await flushMemory();
+}
+async function readPipedStdin() {
+    if (process.stdin.isTTY)
+        return undefined;
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => (data += chunk));
+        process.stdin.on("end", () => resolve(data.trim() || undefined));
+        process.stdin.resume();
+    });
+}
+main().catch((err) => {
+    console.error(chalk.red(`Fatal error: ${err.message}`));
+    process.exit(1);
+});

package/dist/mcp/client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MCPClient — protocol layer over a transport.
+ *
+ * Handles JSON-RPC id correlation, the `initialize` handshake, and typed
+ * wrappers for `tools/list` / `tools/call`. Enough surface for the tool
+ * registry to plug MCP tools in; more methods can be added the same way.
+ */
+import type { McpPromptInfo, McpToolInfo, McpTransport } from "./types.js";
+export interface ClientInfo {
+    name: string;
+    version: string;
+}
+export interface ToolCallContent {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    [extra: string]: unknown;
+}
+export interface ToolCallResult {
+    content: ToolCallContent[];
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+/** One block from a prompt message. MCP content types mirror tools. */
+export interface PromptContentBlock {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    [extra: string]: unknown;
+}
+export interface PromptMessage {
+    role: "user" | "assistant";
+    /** Per MCP spec `content` is a single block; some servers return an array. */
+    content: PromptContentBlock | PromptContentBlock[];
+}
+export interface PromptResult {
+    description?: string;
+    messages: PromptMessage[];
+}
+export declare class MCPClient {
+    private readonly transport;
+    private readonly clientInfo;
+    private readonly defaultTimeoutMs;
+    private nextId;
+    private pending;
+    private closed;
+    private _serverInfo?;
+    private _capabilities?;
+    private _instructions?;
+    constructor(transport: McpTransport, clientInfo: ClientInfo, defaultTimeoutMs?: number);
+    start(): Promise<void>;
+    private initialize;
+    get serverInfo(): {
+        name: string;
+        version: string;
+    } | undefined;
+    get capabilities(): Record<string, unknown> | undefined;
+    get instructions(): string | undefined;
+    listTools(): Promise<McpToolInfo[]>;
+    listPrompts(): Promise<McpPromptInfo[]>;
+    getPrompt(name: string, args: Record<string, string>, timeoutMs?: number): Promise<PromptResult>;
+    callTool(name: string, args: Record<string, unknown>, timeoutMs?: number): Promise<ToolCallResult>;
+    private request;
+    private onMessage;
+    close(): Promise<void>;
+}

package/dist/mcp/client.js

@@ -0,0 +1,163 @@
+/**
+ * MCPClient — protocol layer over a transport.
+ *
+ * Handles JSON-RPC id correlation, the `initialize` handshake, and typed
+ * wrappers for `tools/list` / `tools/call`. Enough surface for the tool
+ * registry to plug MCP tools in; more methods can be added the same way.
+ */
+const PROTOCOL_VERSION = "2025-06-18";
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class MCPClient {
+    transport;
+    clientInfo;
+    defaultTimeoutMs;
+    nextId = 1;
+    pending = new Map();
+    closed = false;
+    _serverInfo;
+    _capabilities;
+    _instructions;
+    constructor(transport, clientInfo, defaultTimeoutMs = DEFAULT_TIMEOUT_MS) {
+        this.transport = transport;
+        this.clientInfo = clientInfo;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        transport.onMessage((msg) => this.onMessage(msg));
+        transport.onError((err) => {
+            // Fail all outstanding calls; the manager will surface this.
+            for (const [, pending] of this.pending) {
+                clearTimeout(pending.timer);
+                pending.reject(err);
+            }
+            this.pending.clear();
+        });
+        transport.onClose(() => {
+            this.closed = true;
+            for (const [, pending] of this.pending) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error("MCP transport closed"));
+            }
+            this.pending.clear();
+        });
+    }
+    async start() {
+        await this.transport.start();
+        await this.initialize();
+    }
+    async initialize() {
+        const result = (await this.request("initialize", {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: this.clientInfo,
+        }));
+        this._serverInfo = result.serverInfo;
+        this._capabilities = result.capabilities;
+        this._instructions = result.instructions;
+        // Per spec, client must send `notifications/initialized` after the response.
+        await this.transport.send({
+            jsonrpc: "2.0",
+            method: "notifications/initialized",
+        });
+    }
+    get serverInfo() {
+        return this._serverInfo;
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get instructions() {
+        return this._instructions;
+    }
+    async listTools() {
+        const tools = [];
+        let cursor;
+        do {
+            const result = (await this.request("tools/list", cursor ? { cursor } : {}));
+            if (Array.isArray(result.tools)) {
+                for (const t of result.tools) {
+                    tools.push({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    });
+                }
+            }
+            cursor = result.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async listPrompts() {
+        const prompts = [];
+        let cursor;
+        do {
+            const result = (await this.request("prompts/list", cursor ? { cursor } : {}));
+            if (Array.isArray(result.prompts)) {
+                for (const p of result.prompts) {
+                    prompts.push({
+                        name: p.name,
+                        description: p.description,
+                        arguments: p.arguments,
+                    });
+                }
+            }
+            cursor = result.nextCursor;
+        } while (cursor);
+        return prompts;
+    }
+    async getPrompt(name, args, timeoutMs) {
+        const result = (await this.request("prompts/get", { name, arguments: args }, timeoutMs));
+        return {
+            description: result.description,
+            messages: Array.isArray(result.messages) ? result.messages : [],
+        };
+    }
+    async callTool(name, args, timeoutMs) {
+        const result = (await this.request("tools/call", { name, arguments: args }, timeoutMs));
+        return {
+            content: Array.isArray(result.content) ? result.content : [],
+            isError: result.isError,
+            structuredContent: result.structuredContent,
+        };
+    }
+    request(method, params, timeoutMs) {
+        if (this.closed)
+            return Promise.reject(new Error("MCP client is closed"));
+        const id = this.nextId++;
+        const req = { jsonrpc: "2.0", id, method, params };
+        return new Promise((resolve, reject) => {
+            const ms = timeoutMs ?? this.defaultTimeoutMs;
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request "${method}" timed out after ${ms}ms`));
+            }, ms);
+            this.pending.set(id, { resolve, reject, timer });
+            this.transport.send(req).catch((err) => {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+    }
+    onMessage(msg) {
+        // Response: has "id" plus "result" or "error".
+        if ("id" in msg && (("result" in msg) || ("error" in msg))) {
+            const id = typeof msg.id === "number" ? msg.id : Number(msg.id);
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            if ("error" in msg && msg.error) {
+                pending.reject(new Error(`${msg.error.message} (code ${msg.error.code})`));
+            }
+            else {
+                pending.resolve(msg.result);
+            }
+            return;
+        }
+        // Server→client request or notification. v1 ignores these (no sampling, no roots).
+    }
+    async close() {
+        this.closed = true;
+        await this.transport.close();
+    }
+}

package/dist/mcp/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Load and validate mcpServers from user / project / local settings files.
+ *
+ * Precedence: later scope wins (user → project → local). Each server is
+ * identified by its key in mcpServers; if the same name appears in multiple
+ * scopes, the higher-precedence scope overwrites, and we record a diagnostic.
+ *
+ * Env expansion: ${VAR} in command, args, env values, url, or header values
+ * is replaced with the matching process.env entry. Missing vars become empty
+ * strings and yield a diagnostic (non-fatal).
+ */
+import type { ScopedMcpServerConfig } from "./types.js";
+export interface McpConfigDiagnostic {
+    scope: "user" | "project" | "local";
+    path: string;
+    message: string;
+}
+export interface LoadedMcpConfig {
+    servers: ScopedMcpServerConfig[];
+    diagnostics: McpConfigDiagnostic[];
+}
+export interface LoadMcpConfigOptions {
+    cwd: string;
+    bubbleHome?: string;
+}
+export declare function loadMcpConfig(options: LoadMcpConfigOptions): LoadedMcpConfig;