@bubblebrain-ai/bubble 0.0.1

package/dist/question/controller.js

@@ -0,0 +1,97 @@
+import { QuestionRejectedError } from "./types.js";
+export class QuestionController {
+    pending = new Map();
+    listeners = new Set();
+    counter = 0;
+    ask(input) {
+        const request = {
+            id: this.nextID(),
+            sessionID: input.sessionID,
+            questions: input.questions.map(normalizePrompt),
+            tool: input.tool,
+            createdAt: Date.now(),
+        };
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(request.id, {
+                request,
+                resolve,
+                reject,
+            });
+        });
+        this.emit({ type: "asked", request });
+        return promise.finally(() => {
+            this.pending.delete(request.id);
+        });
+    }
+    reply(requestID, answers) {
+        const pending = this.pending.get(requestID);
+        if (!pending)
+            return false;
+        const normalized = normalizeAnswers(pending.request.questions.length, answers);
+        this.pending.delete(requestID);
+        this.emit({ type: "replied", request: pending.request, answers: normalized });
+        pending.resolve(normalized);
+        return true;
+    }
+    reject(requestID) {
+        const pending = this.pending.get(requestID);
+        if (!pending)
+            return false;
+        this.pending.delete(requestID);
+        this.emit({ type: "rejected", request: pending.request });
+        pending.reject(new QuestionRejectedError());
+        return true;
+    }
+    list(sessionID) {
+        const items = Array.from(this.pending.values(), (entry) => entry.request);
+        return sessionID === undefined ? items : items.filter((request) => request.sessionID === sessionID);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    rejectAll() {
+        for (const id of [...this.pending.keys()]) {
+            this.reject(id);
+        }
+    }
+    emit(event) {
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error("[question] listener failed", err);
+            }
+        }
+    }
+    nextID() {
+        this.counter += 1;
+        return `question_${Date.now().toString(36)}_${this.counter.toString(36)}`;
+    }
+}
+function normalizePrompt(input) {
+    return {
+        header: String(input.header ?? "").trim(),
+        question: String(input.question ?? "").trim(),
+        options: Array.isArray(input.options)
+            ? input.options.map((option) => ({
+                label: String(option?.label ?? "").trim(),
+                description: String(option?.description ?? "").trim(),
+            }))
+            : [],
+        multiple: input.multiple === true,
+        custom: input.custom === false ? false : undefined,
+    };
+}
+function normalizeAnswers(count, answers) {
+    return Array.from({ length: count }, (_, index) => {
+        const answer = answers[index];
+        if (!Array.isArray(answer))
+            return [];
+        return answer.map((item) => String(item).trim()).filter(Boolean);
+    });
+}
+export { QuestionRejectedError };

package/dist/question/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./controller.js";

package/dist/question/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./controller.js";

package/dist/question/types.d.ts

@@ -0,0 +1,42 @@
+export interface QuestionOption {
+    label: string;
+    description: string;
+}
+export interface QuestionPrompt {
+    /** Very short label used in tabs for multi-question prompts. */
+    header: string;
+    /** Complete user-facing question text. */
+    question: string;
+    /** Fixed choices shown to the user. */
+    options: QuestionOption[];
+    /** Allow selecting more than one option. Defaults to false. */
+    multiple?: boolean;
+    /** Allow a custom free-form answer. Defaults to true. */
+    custom?: boolean;
+}
+export type QuestionAnswer = string[];
+export interface QuestionToolRef {
+    messageID?: string;
+    callID: string;
+}
+export interface QuestionRequest {
+    id: string;
+    sessionID?: string;
+    questions: QuestionPrompt[];
+    tool?: QuestionToolRef;
+    createdAt: number;
+}
+export type QuestionEvent = {
+    type: "asked";
+    request: QuestionRequest;
+} | {
+    type: "replied";
+    request: QuestionRequest;
+    answers: QuestionAnswer[];
+} | {
+    type: "rejected";
+    request: QuestionRequest;
+};
+export declare class QuestionRejectedError extends Error {
+    constructor(message?: string);
+}

package/dist/question/types.js

@@ -0,0 +1,6 @@
+export class QuestionRejectedError extends Error {
+    constructor(message = "The user dismissed this question") {
+        super(message);
+        this.name = "QuestionRejectedError";
+    }
+}

package/dist/session-log.d.ts

@@ -0,0 +1,16 @@
+import type { Message, Todo } from "./types.js";
+import type { SessionLogEntry, SessionMarkerKind, SessionMetadata, SessionSummaryEntry, SessionTodosSnapshotEntry } from "./session-types.js";
+export declare class SessionLog {
+    private entries;
+    load(lines: string[]): void;
+    replace(entries: SessionLogEntry[]): void;
+    list(): SessionLogEntry[];
+    getMetadata(): SessionMetadata;
+    setMetadata(metadata: SessionMetadata): SessionLogEntry[];
+    appendMessage(message: Message): SessionLogEntry[];
+    appendSummary(summary: string): SessionSummaryEntry;
+    appendTodosSnapshot(todos: Todo[]): SessionTodosSnapshotEntry;
+    getTodos(): Todo[];
+    appendMarker(kind: SessionMarkerKind, value: string): SessionLogEntry;
+    toMessages(): Message[];
+}

package/dist/session-log.js

@@ -0,0 +1,267 @@
+export class SessionLog {
+    entries = [];
+    load(lines) {
+        this.entries = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                this.entries.push(...normalizeEntry(raw));
+            }
+            catch {
+                // skip corrupt lines
+            }
+        }
+    }
+    replace(entries) {
+        this.entries = entries;
+    }
+    list() {
+        return [...this.entries];
+    }
+    getMetadata() {
+        const entry = this.entries.find((item) => item.type === "metadata");
+        const metadata = entry?.metadata ?? {};
+        return {
+            ...metadata,
+            thinkingLevel: metadata.thinkingLevel ?? metadata.reasoningEffort,
+        };
+    }
+    setMetadata(metadata) {
+        const next = [...this.entries];
+        const entry = {
+            id: "metadata",
+            type: "metadata",
+            metadata,
+            timestamp: Date.now(),
+        };
+        const existingIndex = next.findIndex((item) => item.type === "metadata");
+        if (existingIndex >= 0) {
+            next[existingIndex] = entry;
+        }
+        else {
+            next.unshift(entry);
+        }
+        this.entries = next;
+        return next;
+    }
+    appendMessage(message) {
+        const normalized = normalizeMessageToEntries(message, nextEntryId(this.entries), Date.now());
+        this.entries.push(...normalized);
+        return normalized;
+    }
+    appendSummary(summary) {
+        const entry = {
+            id: nextEntryId(this.entries),
+            type: "summary",
+            summary,
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        return entry;
+    }
+    appendTodosSnapshot(todos) {
+        const entry = {
+            id: nextEntryId(this.entries),
+            type: "todos_snapshot",
+            todos: todos.map((todo) => ({ ...todo })),
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        return entry;
+    }
+    getTodos() {
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            const entry = this.entries[i];
+            if (entry.type === "todos_snapshot") {
+                return entry.todos.map((todo) => ({ ...todo }));
+            }
+        }
+        return [];
+    }
+    appendMarker(kind, value) {
+        const entry = {
+            id: nextEntryId(this.entries),
+            type: "marker",
+            kind,
+            value,
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        return entry;
+    }
+    toMessages() {
+        const messages = [];
+        let latestSummaryIndex = -1;
+        for (let index = this.entries.length - 1; index >= 0; index--) {
+            if (this.entries[index].type === "summary") {
+                latestSummaryIndex = index;
+                break;
+            }
+        }
+        if (latestSummaryIndex >= 0) {
+            const summary = this.entries[latestSummaryIndex];
+            messages.push({
+                role: "system",
+                content: `Previous conversation summary: ${summary.summary}`,
+            });
+        }
+        const startIndex = latestSummaryIndex >= 0 ? latestSummaryIndex + 1 : 0;
+        for (let index = startIndex; index < this.entries.length; index++) {
+            const entry = this.entries[index];
+            switch (entry.type) {
+                case "user_message":
+                    messages.push(cloneMessage(entry.message));
+                    break;
+                case "assistant_message":
+                    messages.push({
+                        ...entry.message,
+                        role: "assistant",
+                    });
+                    break;
+                case "tool_call": {
+                    const last = messages[messages.length - 1];
+                    if (last?.role === "assistant") {
+                        const assistant = last;
+                        assistant.toolCalls = [...(assistant.toolCalls ?? []), { ...entry.toolCall }];
+                    }
+                    else {
+                        messages.push({
+                            role: "assistant",
+                            content: "",
+                            toolCalls: [{ ...entry.toolCall }],
+                        });
+                    }
+                    break;
+                }
+                case "tool_result":
+                    messages.push(cloneMessage(entry.message));
+                    break;
+                default:
+                    break;
+            }
+        }
+        return pruneIncompleteTail(messages);
+    }
+}
+function normalizeEntry(raw) {
+    if (isSessionLogEntry(raw)) {
+        return [raw];
+    }
+    if (raw.type === "metadata") {
+        return [{
+                id: raw.id,
+                type: "metadata",
+                metadata: raw.metadata ?? {},
+                timestamp: raw.timestamp,
+            }];
+    }
+    if (raw.type === "compaction") {
+        return [{
+                id: raw.id,
+                type: "summary",
+                summary: raw.summary ?? "",
+                timestamp: raw.timestamp,
+            }];
+    }
+    if (raw.type === "message" && raw.data) {
+        return normalizeMessageToEntries(raw.data, raw.id, raw.timestamp);
+    }
+    return [];
+}
+function normalizeMessageToEntries(message, id, timestamp) {
+    switch (message.role) {
+        case "user":
+            return [{ id, type: "user_message", message, timestamp }];
+        case "assistant": {
+            const assistantEntry = {
+                id,
+                type: "assistant_message",
+                message: {
+                    role: "assistant",
+                    content: message.content,
+                    reasoning: message.reasoning,
+                },
+                timestamp,
+            };
+            const toolCallEntries = (message.toolCalls ?? []).map((toolCall, index) => ({
+                id: `${id}:tool:${index + 1}`,
+                type: "tool_call",
+                toolCall,
+                timestamp,
+            }));
+            return [assistantEntry, ...toolCallEntries];
+        }
+        case "tool":
+            return [{ id, type: "tool_result", message, timestamp }];
+        case "system":
+            return [{
+                    id,
+                    type: "summary",
+                    summary: message.content,
+                    timestamp,
+                }];
+    }
+}
+function isSessionLogEntry(entry) {
+    return [
+        "metadata",
+        "summary",
+        "marker",
+        "user_message",
+        "assistant_message",
+        "tool_call",
+        "tool_result",
+        "todos_snapshot",
+    ].includes(entry.type);
+}
+function nextEntryId(entries) {
+    return `${entries.length + 1}`;
+}
+function cloneMessage(message) {
+    if (message.role === "assistant") {
+        return {
+            ...message,
+            toolCalls: message.toolCalls?.map((toolCall) => ({ ...toolCall })),
+        };
+    }
+    if (message.role === "user" && Array.isArray(message.content)) {
+        return {
+            ...message,
+            content: message.content.map((part) => ({
+                ...part,
+                ...(part.type === "image_url" ? { image_url: { ...part.image_url } } : {}),
+            })),
+        };
+    }
+    return { ...message };
+}
+function pruneIncompleteTail(messages) {
+    let currentTurnStart = -1;
+    let hasCompletedAssistant = false;
+    let sawNonUserInCurrentTurn = false;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (message.role === "system")
+            continue;
+        if (message.role === "user") {
+            currentTurnStart = i;
+            hasCompletedAssistant = false;
+            sawNonUserInCurrentTurn = false;
+            continue;
+        }
+        if (currentTurnStart === -1) {
+            continue;
+        }
+        sawNonUserInCurrentTurn = true;
+        if (message.role === "assistant") {
+            const hasPendingTools = !!message.toolCalls && message.toolCalls.length > 0;
+            if (!hasPendingTools) {
+                hasCompletedAssistant = true;
+            }
+        }
+    }
+    if (currentTurnStart >= 0 && sawNonUserInCurrentTurn && !hasCompletedAssistant) {
+        return messages.slice(0, currentTurnStart);
+    }
+    return messages;
+}

package/dist/session-types.d.ts

@@ -0,0 +1,55 @@
+import type { AssistantMessage, Message, ThinkingLevel, Todo, ToolCall, ToolMessage, UserMessage } from "./types.js";
+export interface SessionMetadata {
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+    reasoningEffort?: ThinkingLevel;
+    cwd?: string;
+}
+export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch";
+interface BaseSessionLogEntry {
+    id: string;
+    timestamp: number;
+}
+export interface SessionMetadataEntry extends BaseSessionLogEntry {
+    type: "metadata";
+    metadata: SessionMetadata;
+}
+export interface SessionSummaryEntry extends BaseSessionLogEntry {
+    type: "summary";
+    summary: string;
+}
+export interface SessionMarkerEntry extends BaseSessionLogEntry {
+    type: "marker";
+    kind: SessionMarkerKind;
+    value: string;
+}
+export interface SessionUserMessageEntry extends BaseSessionLogEntry {
+    type: "user_message";
+    message: UserMessage;
+}
+export interface SessionAssistantMessageEntry extends BaseSessionLogEntry {
+    type: "assistant_message";
+    message: Omit<AssistantMessage, "toolCalls">;
+}
+export interface SessionToolCallEntry extends BaseSessionLogEntry {
+    type: "tool_call";
+    toolCall: ToolCall;
+}
+export interface SessionToolResultEntry extends BaseSessionLogEntry {
+    type: "tool_result";
+    message: ToolMessage;
+}
+export interface SessionTodosSnapshotEntry extends BaseSessionLogEntry {
+    type: "todos_snapshot";
+    todos: Todo[];
+}
+export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry | SessionTodosSnapshotEntry;
+export interface LegacySessionEntry {
+    id: string;
+    type: "metadata" | "message" | "compaction";
+    data?: Message;
+    summary?: string;
+    metadata?: SessionMetadata;
+    timestamp: number;
+}
+export {};

package/dist/session-types.js

@@ -0,0 +1 @@
+export {};

package/dist/session.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Session Manager - Append-only JSONL persistence over a structured session log.
+ */
+import { type CompactOptions, type CompactResult } from "./context/compact.js";
+import type { Message, Todo } from "./types.js";
+import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+export type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+export declare class SessionManager {
+    private sessionFile;
+    private log;
+    constructor(sessionFile: string);
+    static create(cwd: string, sessionName?: string): SessionManager;
+    static resume(cwd: string, sessionName?: string): SessionManager | undefined;
+    static createFresh(cwd: string): SessionManager;
+    static listSessions(cwd: string): string[];
+    private load;
+    private persist;
+    private rewrite;
+    getMetadata(): SessionMetadata;
+    setMetadata(metadata: SessionMetadata): void;
+    appendMessage(message: Message): void;
+    appendCompaction(summary: string): void;
+    appendMarker(kind: SessionMarkerKind, value: string): void;
+    appendTodosSnapshot(todos: Todo[]): void;
+    getTodos(): Todo[];
+    compact(options?: CompactOptions): CompactResult;
+    getMessages(): Message[];
+    getEntries(): SessionLogEntry[];
+    getSessionFile(): string;
+    private maybeAutoCompact;
+}
+export declare function getSessionsDir(cwd: string): string;

package/dist/session.js

@@ -0,0 +1,135 @@
+/**
+ * Session Manager - Append-only JSONL persistence over a structured session log.
+ */
+import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "./bubble-home.js";
+import { compactSessionEntries } from "./context/compact.js";
+import { SessionLog } from "./session-log.js";
+const AUTO_COMPACT_ENTRY_THRESHOLD = 180;
+const AUTO_COMPACT_KEEP_RECENT_TURNS = 3;
+export class SessionManager {
+    sessionFile;
+    log = new SessionLog();
+    constructor(sessionFile) {
+        this.sessionFile = sessionFile;
+        if (existsSync(sessionFile)) {
+            this.load();
+        }
+    }
+    static create(cwd, sessionName) {
+        const file = resolveSessionFile(cwd, sessionName || `${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`);
+        return new SessionManager(file);
+    }
+    static resume(cwd, sessionName) {
+        if (sessionName) {
+            const file = resolveSessionFile(cwd, sessionName);
+            return existsSync(file) ? new SessionManager(file) : undefined;
+        }
+        const latest = this.listSessions(cwd).sort().at(-1);
+        if (!latest) {
+            return undefined;
+        }
+        return new SessionManager(resolveSessionFile(cwd, latest));
+    }
+    static createFresh(cwd) {
+        const file = resolveSessionFile(cwd, `${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`);
+        return new SessionManager(file);
+    }
+    static listSessions(cwd) {
+        const sessionsDir = getSessionsDir(cwd);
+        if (!existsSync(sessionsDir))
+            return [];
+        return readdirSync(sessionsDir).filter((file) => file.endsWith(".jsonl"));
+    }
+    load() {
+        const content = readFileSync(this.sessionFile, "utf-8");
+        const lines = content.split("\n").filter((line) => line.trim() !== "");
+        this.log.load(lines);
+    }
+    persist(entry) {
+        const dir = dirname(this.sessionFile);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const entries = Array.isArray(entry) ? entry : [entry];
+        if (entries.length === 0) {
+            return;
+        }
+        appendFileSync(this.sessionFile, entries.map((item) => JSON.stringify(item)).join("\n") + "\n");
+    }
+    rewrite(entries) {
+        const dir = dirname(this.sessionFile);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(this.sessionFile, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+        this.log.replace(entries);
+    }
+    getMetadata() {
+        return this.log.getMetadata();
+    }
+    setMetadata(metadata) {
+        const nextEntries = this.log.setMetadata(metadata);
+        this.rewrite(nextEntries);
+    }
+    appendMessage(message) {
+        const entries = this.log.appendMessage(message);
+        this.persist(entries);
+        this.maybeAutoCompact();
+    }
+    appendCompaction(summary) {
+        const entry = this.log.appendSummary(summary);
+        this.persist(entry);
+    }
+    appendMarker(kind, value) {
+        const entry = this.log.appendMarker(kind, value);
+        this.persist(entry);
+    }
+    appendTodosSnapshot(todos) {
+        const entry = this.log.appendTodosSnapshot(todos);
+        this.persist(entry);
+        this.maybeAutoCompact();
+    }
+    getTodos() {
+        return this.log.getTodos();
+    }
+    compact(options) {
+        const result = compactSessionEntries(this.log.list(), options);
+        if (result.compacted && result.entries) {
+            this.rewrite(result.entries);
+        }
+        return result;
+    }
+    getMessages() {
+        return this.log.toMessages();
+    }
+    getEntries() {
+        return this.log.list();
+    }
+    getSessionFile() {
+        return this.sessionFile;
+    }
+    maybeAutoCompact() {
+        const entries = this.log.list();
+        if (entries.length < AUTO_COMPACT_ENTRY_THRESHOLD) {
+            return;
+        }
+        const result = compactSessionEntries(entries, {
+            keepRecentTurns: AUTO_COMPACT_KEEP_RECENT_TURNS,
+        });
+        if (result.compacted && result.entries) {
+            this.rewrite(result.entries);
+        }
+    }
+}
+export function getSessionsDir(cwd) {
+    const agentDir = getBubbleHome();
+    const safeCwd = cwd.replace(/[/\\:]/g, "_");
+    const sessionsDir = join(agentDir, "sessions", safeCwd);
+    mkdirSync(sessionsDir, { recursive: true });
+    return sessionsDir;
+}
+function resolveSessionFile(cwd, sessionName) {
+    return join(getSessionsDir(cwd), sessionName);
+}

package/dist/skills/discovery.d.ts

@@ -0,0 +1,12 @@
+import type { SkillDiagnostic, SkillRecord } from "./types.js";
+export interface DiscoverSkillsOptions {
+    roots: Array<{
+        path: string;
+        source: SkillRecord["source"];
+    }>;
+}
+export interface DiscoverSkillsResult {
+    skills: SkillRecord[];
+    diagnostics: SkillDiagnostic[];
+}
+export declare function discoverSkills(options: DiscoverSkillsOptions): DiscoverSkillsResult;