@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/memory/start.js

@@ -0,0 +1,50 @@
+import { runMemoryPhase1 } from "./phase1.js";
+import { runMemoryPhase2 } from "./phase2.js";
+export async function runMemoryStartupPipeline(options) {
+    if (options.disabled || isMemoryDisabled()) {
+        return { status: "skipped", reason: "disabled by BUBBLE_MEMORY_AUTO" };
+    }
+    if (!options.model) {
+        return { status: "skipped", reason: "no active model" };
+    }
+    const phase1 = await runMemoryPhase1({
+        cwd: options.cwd,
+        complete: options.complete,
+        model: options.model,
+        minEntries: options.minEntries,
+    });
+    const phase2 = await runMemoryPhase2({
+        cwd: options.cwd,
+        complete: options.complete,
+        model: options.model,
+    });
+    return {
+        status: phase2.status === "failed" || phase1.failed > 0 ? "failed" : "succeeded",
+        phase1,
+        phase2,
+        reason: phase2.reason,
+    };
+}
+export function startMemoryStartupTask(options) {
+    if (options.disabled || isMemoryDisabled() || !options.model)
+        return;
+    void runMemoryStartupPipeline(options).catch(() => {
+        // Startup memory is best-effort and must not take down the main session.
+    });
+}
+export function formatMemoryStartupResult(result) {
+    if (result.status === "skipped")
+        return `Memory startup skipped: ${result.reason ?? "not needed"}.`;
+    const lines = [
+        `Memory startup ${result.status}.`,
+        result.phase1 ? `Phase 1: scanned ${result.phase1.scanned}, claimed ${result.phase1.claimed}, succeeded ${result.phase1.succeeded}, empty ${result.phase1.empty}, failed ${result.phase1.failed}, skipped ${result.phase1.skipped}.` : undefined,
+        result.phase2 ? `Phase 2: ${result.phase2.status}, selected ${result.phase2.selected}${result.phase2.reason ? ` (${result.phase2.reason})` : ""}.` : undefined,
+        result.phase2?.memoryPath ? `Memory: ${result.phase2.memoryPath}` : undefined,
+        result.phase2?.summaryPath ? `Summary: ${result.phase2.summaryPath}` : undefined,
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function isMemoryDisabled() {
+    const value = process.env.BUBBLE_MEMORY_AUTO?.trim().toLowerCase();
+    return value === "0" || value === "false" || value === "off" || value === "no";
+}

package/dist/memory/storage.d.ts

@@ -0,0 +1,11 @@
+import type { Stage1Output } from "./db.js";
+export declare function ensureMemoryWorkspace(cwd: string): void;
+export declare function rebuildRawMemories(cwd: string, outputs: Stage1Output[], limit?: number): string;
+export declare function syncRolloutSummaries(cwd: string, outputs: Stage1Output[], limit?: number): void;
+export declare function writeConsolidatedMemory(cwd: string, input: {
+    memoryMd: string;
+    memorySummaryMd: string;
+}): void;
+export declare function clearGeneratedMemoryOutputs(cwd: string): void;
+export declare function resetMemoryWorkspace(cwd: string): void;
+export declare function rolloutSummaryFileName(output: Stage1Output): string;

package/dist/memory/storage.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getMemoryPaths } from "./paths.js";
+import { redactSecrets } from "./store.js";
+export function ensureMemoryWorkspace(cwd) {
+    const paths = getMemoryPaths(cwd);
+    mkdirSync(paths.globalRoot, { recursive: true });
+    mkdirSync(paths.globalRolloutSummaries, { recursive: true });
+    mkdirSync(paths.globalSkills, { recursive: true });
+}
+export function rebuildRawMemories(cwd, outputs, limit = 40) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    const retained = outputs.slice(0, limit);
+    const lines = ["# Raw Memories", "", "Merged stage-1 raw memories (latest first):", ""];
+    for (const output of retained) {
+        lines.push(`## Session \`${output.sessionFile}\``);
+        lines.push(`updated_at: ${output.sourceUpdatedAt}`);
+        lines.push(`cwd: ${output.cwd}`);
+        lines.push(`rollout_path: ${output.sessionFile}`);
+        lines.push(`rollout_summary_file: ${rolloutSummaryFileName(output)}`);
+        lines.push("");
+        lines.push(redactSecrets(output.rawMemory).text.trim());
+        lines.push("");
+    }
+    const content = `${lines.join("\n").trim()}\n`;
+    writeFileSync(paths.globalRawMemories, content, "utf-8");
+    return content;
+}
+export function syncRolloutSummaries(cwd, outputs, limit = 40) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    const retained = outputs.slice(0, limit);
+    const keep = new Set(retained.map(rolloutSummaryFileName));
+    if (existsSync(paths.globalRolloutSummaries)) {
+        for (const file of readdirSync(paths.globalRolloutSummaries)) {
+            if (file.endsWith(".md") && !keep.has(file)) {
+                rmSync(join(paths.globalRolloutSummaries, file), { force: true });
+            }
+        }
+    }
+    for (const output of retained) {
+        const lines = [
+            `session: ${output.sessionFile}`,
+            `updated_at: ${output.sourceUpdatedAt}`,
+            `cwd: ${output.cwd}`,
+            "",
+            redactSecrets(output.rolloutSummary).text.trim(),
+            "",
+        ];
+        writeFileSync(join(paths.globalRolloutSummaries, rolloutSummaryFileName(output)), lines.join("\n"), "utf-8");
+    }
+}
+export function writeConsolidatedMemory(cwd, input) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    writeFileSync(paths.globalMemory, normalizeMemoryMarkdown(input.memoryMd), "utf-8");
+    writeFileSync(paths.globalSummary, normalizeSummaryMarkdown(input.memorySummaryMd), "utf-8");
+}
+export function clearGeneratedMemoryOutputs(cwd) {
+    const paths = getMemoryPaths(cwd);
+    rmSync(paths.globalRawMemories, { force: true });
+    rmSync(paths.globalMemory, { force: true });
+    rmSync(paths.globalSummary, { force: true });
+    if (!existsSync(paths.globalRolloutSummaries))
+        return;
+    for (const file of readdirSync(paths.globalRolloutSummaries)) {
+        if (file.endsWith(".md")) {
+            rmSync(join(paths.globalRolloutSummaries, file), { force: true });
+        }
+    }
+}
+export function resetMemoryWorkspace(cwd) {
+    const paths = getMemoryPaths(cwd);
+    rmSync(paths.globalRoot, { recursive: true, force: true });
+}
+export function rolloutSummaryFileName(output) {
+    const timestamp = output.sourceUpdatedAt.replace(/[:.]/g, "-");
+    const slug = slugify(output.rolloutSlug || output.sessionFile.split("/").pop()?.replace(/\.jsonl$/, "") || "rollout");
+    return `${timestamp}-${slug}.md`;
+}
+function normalizeMemoryMarkdown(value) {
+    const cleaned = stripCodeFence(redactSecrets(value).text).trim();
+    return `${cleaned.startsWith("#") ? cleaned : `# Bubble Memory\n\n${cleaned}`}\n`;
+}
+function normalizeSummaryMarkdown(value) {
+    const cleaned = stripCodeFence(redactSecrets(value).text).trim();
+    return `${/^#\s+Bubble Memory Summary/m.test(cleaned) ? cleaned : `# Bubble Memory Summary\n\n${cleaned}`}\n`;
+}
+function stripCodeFence(value) {
+    return value.trim().replace(/^```(?:markdown|md)?\s*/i, "").replace(/```$/i, "").trim();
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "rollout";
+}

package/dist/memory/store.d.ts

@@ -0,0 +1,43 @@
+import { type BubbleEnvironment } from "../bubble-home.js";
+import { type MemoryJob } from "./db.js";
+import { type MemoryPaths } from "./paths.js";
+export type MemoryScope = "global" | "project";
+export type MemorySearchScope = MemoryScope | "all";
+export interface MemoryStatus {
+    paths: MemoryPaths;
+    bubbleHome: string;
+    environment: BubbleEnvironment;
+    files: Array<{
+        label: string;
+        path: string;
+        exists: boolean;
+        bytes: number;
+    }>;
+    database: {
+        path: string;
+        stage1Outputs: number;
+        disabledThreads: number;
+        jobs: MemoryJob[];
+    };
+}
+export interface MemorySearchResult {
+    scope: MemoryScope;
+    path: string;
+    line: number;
+    text: string;
+}
+export declare function buildMemoryPrompt(cwd: string): string | undefined;
+export declare function getMemoryStatus(cwd: string): MemoryStatus;
+export declare function searchMemory(cwd: string, query: string, options?: {
+    scope?: MemorySearchScope;
+    limit?: number;
+}): MemorySearchResult[];
+export declare function readMemorySummary(cwd: string, scope?: MemorySearchScope): Array<{
+    scope: MemoryScope;
+    path: string;
+    content: string;
+}>;
+export declare function redactSecrets(value: string): {
+    text: string;
+    redacted: boolean;
+};

package/dist/memory/store.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { getBubbleHomeInfo } from "../bubble-home.js";
+import { MemoryDatabase } from "./db.js";
+import { getMemoryPaths } from "./paths.js";
+import { buildReadPathPrompt } from "./prompts.js";
+const MAX_PROMPT_FILE_CHARS = 12_000;
+const MAX_SEARCH_RESULTS = 12;
+export function buildMemoryPrompt(cwd) {
+    const paths = getMemoryPaths(cwd);
+    const sections = [];
+    addFileSection(sections, "Global AGENTS.md", paths.globalAgents);
+    addFileSection(sections, "Project AGENTS.md", paths.projectAgents);
+    addFileSection(sections, "Project .bubble/AGENTS.md", paths.projectLocalAgents);
+    const memorySummary = readOptional(paths.globalSummary)?.trim();
+    if (sections.length === 0 && !memorySummary) {
+        return undefined;
+    }
+    const memoryPrompt = memorySummary
+        ? buildReadPathPrompt({ memoryRoot: paths.globalRoot, memorySummary })
+        : undefined;
+    return [...sections, memoryPrompt].filter(Boolean).join("\n\n");
+}
+export function getMemoryStatus(cwd) {
+    const paths = getMemoryPaths(cwd);
+    const bubbleHome = getBubbleHomeInfo();
+    const files = [
+        { label: "global AGENTS.md", path: paths.globalAgents },
+        { label: "global memory_summary.md", path: paths.globalSummary },
+        { label: "global MEMORY.md", path: paths.globalMemory },
+        { label: "global raw_memories.md", path: paths.globalRawMemories },
+        { label: "global state.sqlite", path: paths.globalDatabase },
+        { label: "project AGENTS.md", path: paths.projectAgents },
+        { label: "project .bubble/AGENTS.md", path: paths.projectLocalAgents },
+    ].map((item) => {
+        const content = readOptional(item.path);
+        return {
+            ...item,
+            exists: content !== undefined,
+            bytes: content?.length ?? 0,
+        };
+    });
+    const db = new MemoryDatabase(cwd);
+    try {
+        const stats = db.stats();
+        return {
+            paths,
+            bubbleHome: bubbleHome.home,
+            environment: bubbleHome.environment,
+            files,
+            database: {
+                path: paths.globalDatabase,
+                ...stats,
+            },
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function searchMemory(cwd, query, options = {}) {
+    const paths = getMemoryPaths(cwd);
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) {
+        return [];
+    }
+    const scope = options.scope ?? "all";
+    const files = [
+        ...(scope === "global" || scope === "all" ? [
+            { scope: "global", path: paths.globalSummary },
+            { scope: "global", path: paths.globalMemory },
+            { scope: "global", path: paths.globalRawMemories },
+        ] : []),
+        ...(scope === "project" || scope === "all" ? [
+            { scope: "project", path: paths.globalSummary },
+            { scope: "project", path: paths.globalMemory },
+            { scope: "project", path: paths.globalRawMemories },
+        ] : []),
+    ];
+    const seenFiles = new Set();
+    const results = [];
+    const limit = options.limit ?? MAX_SEARCH_RESULTS;
+    for (const file of files) {
+        if (seenFiles.has(file.path))
+            continue;
+        seenFiles.add(file.path);
+        const content = readOptional(file.path);
+        if (!content)
+            continue;
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line.toLowerCase().includes(normalized))
+                continue;
+            results.push({
+                scope: file.scope,
+                path: file.path,
+                line: index + 1,
+                text: collapseWhitespace(line).slice(0, 220),
+            });
+            if (results.length >= limit) {
+                return results;
+            }
+        }
+    }
+    for (const rollout of listRolloutSummaryFiles(paths.globalRolloutSummaries)) {
+        const content = readOptional(rollout);
+        if (!content)
+            continue;
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line.toLowerCase().includes(normalized))
+                continue;
+            results.push({
+                scope: "global",
+                path: rollout,
+                line: index + 1,
+                text: collapseWhitespace(line).slice(0, 220),
+            });
+            if (results.length >= limit)
+                return results;
+        }
+    }
+    return results;
+}
+export function readMemorySummary(cwd, scope = "project") {
+    const paths = getMemoryPaths(cwd);
+    const files = [
+        ...(scope === "global" || scope === "all" ? [{ scope: "global", path: paths.globalSummary }] : []),
+        ...(scope === "project" || scope === "all" ? [{ scope: "project", path: paths.globalSummary }] : []),
+    ];
+    return files
+        .map((file) => ({ ...file, content: readOptional(file.path)?.trim() ?? "" }))
+        .filter((file) => file.content);
+}
+function listRolloutSummaryFiles(dir) {
+    try {
+        if (!existsSync(dir))
+            return [];
+        return readdirSync(dir)
+            .filter((file) => file.endsWith(".md"))
+            .sort()
+            .reverse()
+            .map((file) => join(dir, file));
+    }
+    catch {
+        return [];
+    }
+}
+function addFileSection(sections, label, path) {
+    const content = readOptional(path)?.trim();
+    if (!content)
+        return;
+    sections.push(`### ${label}\nPath: ${path}\n\n${truncate(content, MAX_PROMPT_FILE_CHARS)}`);
+}
+function readOptional(path) {
+    try {
+        if (!existsSync(path))
+            return undefined;
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function truncate(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars - 80).trimEnd()}\n\n[truncated ${value.length - maxChars + 80} chars]`;
+}
+function collapseWhitespace(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+export function redactSecrets(value) {
+    const patterns = [
+        /\b(sk-[A-Za-z0-9_-]{12,})\b/g,
+        /\b([A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,})\b/g,
+        /\b((?:api[_-]?key|token|password|secret)\s*[:=]\s*)\S+/gi,
+    ];
+    let text = value;
+    let redacted = false;
+    for (const pattern of patterns) {
+        text = text.replace(pattern, (...args) => {
+            redacted = true;
+            if (args.length > 2 && typeof args[1] === "string" && args[1].match(/[:=]\s*$/)) {
+                return `${args[1]}[REDACTED_SECRET]`;
+            }
+            return "[REDACTED_SECRET]";
+        });
+    }
+    return { text, redacted };
+}

package/dist/memory/usage.d.ts

@@ -0,0 +1 @@
+export declare function recordMemoryCitations(cwd: string, text: string): number;

package/dist/memory/usage.js

@@ -0,0 +1,38 @@
+import { MemoryDatabase } from "./db.js";
+import { existsSync, readFileSync } from "node:fs";
+const CITATION_BLOCK_RE = /<oai-mem-citation>[\s\S]*?<citation_entries>([\s\S]*?)<\/citation_entries>[\s\S]*?<\/oai-mem-citation>/g;
+const SESSION_RE = /session:\s*([^\n]+)/i;
+export function recordMemoryCitations(cwd, text) {
+    const sessionFiles = [];
+    for (const match of text.matchAll(CITATION_BLOCK_RE)) {
+        const entries = match[1] ?? "";
+        for (const line of entries.split("\n")) {
+            const session = line.match(SESSION_RE)?.[1]?.trim();
+            if (session)
+                sessionFiles.push(session);
+            const citedPath = parseCitedPath(line);
+            if (citedPath && existsSync(citedPath)) {
+                const content = readFileSync(citedPath, "utf-8");
+                const citedSession = content.match(SESSION_RE)?.[1]?.trim();
+                if (citedSession)
+                    sessionFiles.push(citedSession);
+            }
+        }
+    }
+    if (sessionFiles.length === 0)
+        return 0;
+    const db = new MemoryDatabase(cwd);
+    try {
+        return db.recordUsage(sessionFiles);
+    }
+    finally {
+        db.close();
+    }
+}
+function parseCitedPath(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    const path = trimmed.split("|", 1)[0]?.replace(/:\d+(?:-\d+)?$/, "");
+    return path && path.startsWith("/") ? path : undefined;
+}

package/dist/model-catalog.d.ts

@@ -0,0 +1,65 @@
+import type { ReasoningEffort } from "./types.js";
+export type ProviderProtocol = "openai-chat" | "openai-responses" | "anthropic-messages" | "ark-responses" | "ai-sdk";
+export interface BuiltinProviderDefinition {
+    id: string;
+    name: string;
+    baseURL: string;
+    protocol?: ProviderProtocol;
+    hidden?: boolean;
+    supportsOAuth?: boolean;
+}
+/**
+ * Relative capability/cost tier within one provider's lineup (never a
+ * cross-provider comparison). Drives rank-guarded category routing and the
+ * routing menu (docs/model-routing-design.md §2). Untiered models never
+ * participate in automatic routing but stay reachable by explicit name.
+ */
+export type ModelTier = "fast" | "balanced" | "strong";
+export interface BuiltinModelDefinition {
+    id: string;
+    name: string;
+    providerId: string;
+    reasoningLevels: ReasoningEffort[];
+    defaultReasoningLevel?: ReasoningEffort;
+    tier?: ModelTier;
+    contextWindow?: number;
+    /** Routes this model through the Codex Responses Lite backend when true. */
+    useResponsesLite?: boolean;
+    /**
+     * Server-declared cap on per-tool-output tokens. When set, the agent must
+     * truncate each tool result to this token budget before adding it to history
+     * — otherwise the server's input window is exceeded by raw tool dumps.
+     * (For codex models this comes from the API's `truncation_policy.limit`.)
+     */
+    toolOutputTokenLimit?: number;
+}
+export declare const BUILTIN_PROVIDERS: BuiltinProviderDefinition[];
+export declare const BUILTIN_MODELS: BuiltinModelDefinition[];
+export declare function listBuiltinModels(providerId: string): BuiltinModelDefinition[];
+export declare function registerDynamicModelMetadata(model: BuiltinModelDefinition): void;
+export declare function clearDynamicModelMetadata(providerId: string): void;
+export declare function replaceDynamicModelMetadata(providerId: string, models: readonly BuiltinModelDefinition[]): void;
+/**
+ * All dynamic-overlay entries for a provider (openai includes its
+ * openai-codex catalog alias). The overlay was previously visible only via
+ * getBuiltinModel point lookups; the routing snapshot builder needs the list.
+ */
+export declare function listDynamicModelMetadata(providerId: string): BuiltinModelDefinition[];
+export declare function getBuiltinModel(providerId: string, modelId: string): BuiltinModelDefinition | undefined;
+export declare function getModelDefaultReasoningLevel(providerId: string, modelId: string): ReasoningEffort | undefined;
+export declare function getBuiltinProvider(providerId: string): BuiltinProviderDefinition | undefined;
+/**
+ * Infer capability metadata for a Grok model id the /models endpoint returned
+ * without metadata. Flagship reasoning models (grok-N.M) expose low/medium/high
+ * with thinking always on and a 500K context window — matching the curated
+ * grok-4.5 entry — while composer/fast/mini/flash variants have no effort
+ * control and a 200K window. Pure (id-only) so it works even before remote
+ * model discovery runs.
+ */
+export declare function inferGrokModelMetadata(modelId: string): {
+    levels: ReasoningEffort[];
+    defaultLevel?: ReasoningEffort;
+    contextWindow?: number;
+};
+export declare function getModelContextWindow(providerId: string, modelId: string): number | undefined;
+export declare function getToolOutputTokenLimit(providerId: string, modelId: string): number | undefined;