@bubblebrain-ai/bubble 0.0.46 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -9,6 +9,18 @@
   "bin": {
     "bubble": "dist/bin.js"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/sdk/index.d.ts",
+      "default": "./dist/sdk/index.js"
+    },
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "default": "./dist/sdk/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "!dist/**/__tests__/**",
@@ -18,6 +30,8 @@
   "scripts": {
     "build": "rm -rf dist && tsc && chmod +x dist/bin.js dist/main.js",
     "dev": "tsc && bun dist/main.js",
+    "refresh-models": "NODE_USE_ENV_PROXY=1 node scripts/generate-model-data.mjs",
+    "eval": "bun evals/run.ts",
     "prepack": "npm run build",
     "start": "bun dist/main.js",
     "test": "vitest run",
@@ -31,7 +45,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/react": "^19.2.14",
     "@vue/language-server": "^3.2.7",
-    "better-sqlite3": "^12.9.0",
+    "better-sqlite3": "^13.0.1",
     "chalk": "^5.3.0",
     "diff": "^9.0.0",
     "ink": "^7.0.3",

package/dist/agent/discovery-barrier.d.ts

@@ -1,21 +0,0 @@
-import type { ContentPart, ParsedToolCall, ToolResult, ToolResultMetadata } from "../types.js";
-export interface DiscoveryBarrierOptions {
-    cwd: string;
-    input: string | ContentPart[];
-    enabled: boolean;
-}
-export declare class DiscoveryBarrier {
-    private readonly cwd;
-    private readonly enabled;
-    private readonly knownPaths;
-    private readonly userMentionedPaths;
-    constructor(options: DiscoveryBarrierOptions);
-    isEnabled(): boolean;
-    shouldBufferStreamingToolCall(name: string): boolean;
-    orderToolCalls<T extends ParsedToolCall>(toolCalls: T[]): T[];
-    beforeToolCall(toolCall: ParsedToolCall): ToolResult | undefined;
-    afterToolCall(toolCall: ParsedToolCall, result: ToolResult): void;
-    observeMetadata(metadata: ToolResultMetadata | undefined): void;
-}
-export declare function isHiddenToolResult(result: ToolResult | undefined): result is ToolResult;
-export declare function isHiddenToolMetadata(metadata: ToolResultMetadata | undefined): boolean;

package/dist/agent/discovery-barrier.js

@@ -1,173 +0,0 @@
-import { existsSync, realpathSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { analyzeToolIntent } from "./tool-intent.js";
-import { resolveToolPath } from "../tools/path-utils.js";
-export class DiscoveryBarrier {
-    cwd;
-    enabled;
-    knownPaths = new Set();
-    userMentionedPaths = new Set();
-    constructor(options) {
-        this.cwd = options.cwd;
-        this.enabled = options.enabled;
-        for (const path of extractUserMentionedPaths(options.input)) {
-            this.userMentionedPaths.add(canonicalPath(this.cwd, path));
-        }
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    shouldBufferStreamingToolCall(name) {
-        return this.enabled && (name === "read" || name === "bash" || name === "lsp");
-    }
-    orderToolCalls(toolCalls) {
-        if (!this.enabled || toolCalls.length < 2)
-            return toolCalls;
-        const discovery = [];
-        const rest = [];
-        for (const toolCall of toolCalls) {
-            if (isDiscoveryToolCall(toolCall))
-                discovery.push(toolCall);
-            else
-                rest.push(toolCall);
-        }
-        if (discovery.length === 0 || rest.length === 0)
-            return toolCalls;
-        return [...discovery, ...rest];
-    }
-    beforeToolCall(toolCall) {
-        if (!this.enabled)
-            return undefined;
-        const target = pathSensitiveReadTarget(toolCall);
-        if (!target)
-            return undefined;
-        const canonical = canonicalPath(this.cwd, target.path);
-        if (this.knownPaths.has(canonical) || this.userMentionedPaths.has(canonical))
-            return undefined;
-        return {
-            content: `Blocked speculative ${target.kind}. The path "${target.path}" has not been discovered in this repository context ` +
-                "and was not explicitly requested by the user. Run glob/grep discovery first, then read only returned paths. " +
-                "Do not infer from this blocked call whether the path exists.",
-            isError: true,
-            status: "blocked",
-            metadata: {
-                kind: "internal",
-                reason: "speculative_read_blocked",
-                hiddenFromTranscript: true,
-                path: canonical,
-                requestedPath: target.path,
-                toolName: toolCall.name,
-            },
-        };
-    }
-    afterToolCall(toolCall, result) {
-        if (!this.enabled || result.metadata?.hiddenFromTranscript === true)
-            return;
-        this.observeMetadata(result.metadata);
-        if (isSuccessfulAccessResult(result)) {
-            const target = pathSensitiveReadTarget(toolCall);
-            if (target)
-                this.knownPaths.add(canonicalPath(this.cwd, target.path));
-        }
-    }
-    observeMetadata(metadata) {
-        if (!metadata)
-            return;
-        for (const path of metadataPaths(metadata)) {
-            this.knownPaths.add(canonicalPath(this.cwd, path));
-        }
-    }
-}
-export function isHiddenToolResult(result) {
-    return result?.metadata?.hiddenFromTranscript === true;
-}
-export function isHiddenToolMetadata(metadata) {
-    return metadata?.hiddenFromTranscript === true;
-}
-function isDiscoveryToolCall(toolCall) {
-    if (toolCall.name === "glob" || toolCall.name === "grep")
-        return true;
-    return analyzeToolIntent(toolCall).family === "search";
-}
-function pathSensitiveReadTarget(toolCall) {
-    if (toolCall.name === "read") {
-        const path = stringArg(toolCall.parsedArgs.path ?? toolCall.parsedArgs.file);
-        return path ? { kind: "read", path } : undefined;
-    }
-    if (toolCall.name === "bash") {
-        const intent = analyzeToolIntent(toolCall);
-        const path = intent.read?.path;
-        return path ? { kind: "bash read", path } : undefined;
-    }
-    if (toolCall.name === "lsp") {
-        const path = stringArg(toolCall.parsedArgs.filePath);
-        return path ? { kind: "lsp", path } : undefined;
-    }
-    return undefined;
-}
-function metadataPaths(metadata) {
-    const paths = new Set();
-    addPathValue(paths, metadata.path);
-    addPathValue(paths, metadata.paths);
-    return [...paths];
-}
-function addPathValue(out, value) {
-    if (typeof value === "string" && value.trim()) {
-        out.add(value);
-        return;
-    }
-    if (!Array.isArray(value))
-        return;
-    for (const item of value) {
-        if (typeof item === "string" && item.trim())
-            out.add(item);
-    }
-}
-function isSuccessfulAccessResult(result) {
-    return !result.isError
-        && result.status !== "blocked"
-        && result.status !== "cancelled"
-        && result.status !== "command_error"
-        && result.status !== "timeout";
-}
-function canonicalPath(cwd, value) {
-    const absolute = resolveToolPath(cwd, value);
-    try {
-        if (existsSync(absolute))
-            return realpathSync.native(absolute);
-    }
-    catch {
-        // Fall back to lexical resolution for unreadable or racing paths.
-    }
-    return resolve(absolute);
-}
-function extractUserMentionedPaths(input) {
-    const text = typeof input === "string"
-        ? input
-        : input
-            .filter((part) => part.type === "text")
-            .map((part) => part.text)
-            .join("\n");
-    const paths = new Set();
-    const regex = /(?:^|[\s`'"])(~?\.{0,2}\/[^\s`'"]+|[\w@.-]+\.[A-Za-z0-9][\w.-]*)(?=$|[\s`'",.;:!?，。；：！？）)])/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        const value = match[1]?.trim();
-        if (value && isLikelyFilePath(value))
-            paths.add(stripTrailingPunctuation(value));
-    }
-    return [...paths];
-}
-function isLikelyFilePath(value) {
-    const stripped = stripTrailingPunctuation(value);
-    if (stripped.startsWith("./") || stripped.startsWith("../") || stripped.startsWith("~/") || stripped.startsWith("/")) {
-        return true;
-    }
-    return /\.[A-Za-z0-9][\w.-]*$/.test(basename(stripped));
-}
-function stripTrailingPunctuation(value) {
-    return value.replace(/[.,;:!?，。；：！？）)]+$/u, "");
-}
-function stringArg(value) {
-    return typeof value === "string" ? value.trim() : "";
-}

package/dist/agent/evidence-tracker.d.ts

@@ -1,15 +0,0 @@
-import type { ParsedToolCall, ToolResult } from "../types.js";
-export interface InvestigationCoverage {
-    configLoadPaths: boolean;
-    envReads: boolean;
-    persistencePaths: boolean;
-    exposurePaths: boolean;
-    maskingSignals: boolean;
-}
-export declare class EvidenceTracker {
-    private coverage;
-    observe(toolCall: Pick<ParsedToolCall, "name" | "parsedArgs">, result: ToolResult): void;
-    snapshot(): InvestigationCoverage;
-    key(): string;
-    isCoreCoverageComplete(): boolean;
-}

package/dist/agent/evidence-tracker.js

@@ -1,93 +0,0 @@
-const DEFAULT_COVERAGE = {
-    configLoadPaths: false,
-    envReads: false,
-    persistencePaths: false,
-    exposurePaths: false,
-    maskingSignals: false,
-};
-const CONFIG_PATTERNS = [
-    /\bconfig\.(json|ya?ml|toml|ini)\b/i,
-    /\bsettings\.(json|ya?ml|toml)\b/i,
-    /\bauth\.json\b/i,
-    /\buserconfig\b/i,
-    /\breadfilesync\b/i,
-];
-const ENV_PATTERNS = [
-    /\bprocess\.env\b/i,
-    /\bimport\.meta\.env\b/i,
-    /\bgetenv\(/i,
-    /\bloadenv\b/i,
-    /\bdotenv\b/i,
-    /\b\.env\b/i,
-];
-const PERSISTENCE_PATTERNS = [
-    /\bwritefilesync\b/i,
-    /\bwritefile\b/i,
-    /\bauth\.json\b/i,
-    /\bconfig\.json\b/i,
-    /\blocalstorage\b/i,
-    /\bsqlite\b/i,
-    /\bkeychain\b/i,
-    /\bcredential\b/i,
-    /\bstore\b/i,
-];
-const EXPOSURE_PATTERNS = [
-    /\bconsole\.log\b/i,
-    /\blogger\./i,
-    /\bres\.json\b/i,
-    /\breturn\s+\{/i,
-    /\bwindow\./i,
-    /\bdocument\./i,
-    /\bserialize\b/i,
-    /\bresponse\b/i,
-];
-const MASKING_PATTERNS = [
-    /\bmask(key|ed)?\b/i,
-    /\bredact(ed|ion)?\b/i,
-    /\bhidden\b/i,
-    /\bobfuscated\b/i,
-    /\*\*\*\*/i,
-    /\.\.\./i,
-];
-export class EvidenceTracker {
-    coverage = { ...DEFAULT_COVERAGE };
-    observe(toolCall, result) {
-        const haystack = [
-            typeof toolCall.parsedArgs.path === "string" ? toolCall.parsedArgs.path : "",
-            typeof toolCall.parsedArgs.command === "string" ? toolCall.parsedArgs.command : "",
-            typeof toolCall.parsedArgs.pattern === "string" ? toolCall.parsedArgs.pattern : "",
-            result.content,
-        ].join("\n");
-        if (!this.coverage.configLoadPaths && matchesAny(CONFIG_PATTERNS, haystack)) {
-            this.coverage.configLoadPaths = true;
-        }
-        if (!this.coverage.envReads && matchesAny(ENV_PATTERNS, haystack)) {
-            this.coverage.envReads = true;
-        }
-        if (!this.coverage.persistencePaths && matchesAny(PERSISTENCE_PATTERNS, haystack)) {
-            this.coverage.persistencePaths = true;
-        }
-        if (!this.coverage.exposurePaths && matchesAny(EXPOSURE_PATTERNS, haystack)) {
-            this.coverage.exposurePaths = true;
-        }
-        if (!this.coverage.maskingSignals && matchesAny(MASKING_PATTERNS, haystack)) {
-            this.coverage.maskingSignals = true;
-        }
-    }
-    snapshot() {
-        return { ...this.coverage };
-    }
-    key() {
-        const coverage = this.snapshot();
-        return Object.values(coverage).map((value) => (value ? "1" : "0")).join("");
-    }
-    isCoreCoverageComplete() {
-        return this.coverage.configLoadPaths
-            && this.coverage.envReads
-            && this.coverage.persistencePaths
-            && this.coverage.exposurePaths;
-    }
-}
-function matchesAny(patterns, haystack) {
-    return patterns.some((pattern) => pattern.test(haystack));
-}

package/dist/agent/execution-governor.d.ts

@@ -1,36 +0,0 @@
-import type { ParsedToolCall, ToolRegistryEntry, ToolResult } from "../types.js";
-import type { TaskType } from "./task-classifier.js";
-export interface GovernorDecision {
-    blockedResult?: ToolResult;
-}
-export declare class ExecutionGovernor {
-    private budget;
-    private history;
-    private totalSteps;
-    private searchSteps;
-    private readSteps;
-    private mutationVersion;
-    private reminderQueue;
-    private warnedFamilies;
-    private warnedSignatures;
-    private softTotalWarned;
-    private softSearchWarned;
-    private softReadWarned;
-    constructor(taskType: TaskType);
-    consumePendingReminders(): string[];
-    snapshot(): {
-        totalSteps: number;
-        searchSteps: number;
-        readSteps: number;
-        searchFrozen: boolean;
-        explorationFrozen: boolean;
-        phase: "observe";
-    };
-    filterToolDefinitions(toolDefinitions: ToolRegistryEntry[]): ToolRegistryEntry[];
-    beforeToolCall(toolCall: ParsedToolCall): GovernorDecision;
-    afterToolResult(toolCall: ParsedToolCall, result: ToolResult): void;
-    private trailingNoProgressCount;
-    private hasCurrentMutationObservation;
-    private warnOnce;
-    private maybeWarnOnSoftBudgets;
-}

package/dist/agent/execution-governor.js

@@ -1,218 +0,0 @@
-import { analyzeToolIntent } from "./tool-intent.js";
-import { buildInvestigationReminder, buildLoopWarningReminder } from "../prompt/reminders.js";
-const BUDGETS = {
-    security_investigation: {
-        softTotalSteps: 14,
-        softSearchSteps: 6,
-        softReadSteps: 8,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 2,
-    },
-    code_search: {
-        softTotalSteps: 16,
-        softSearchSteps: 8,
-        softReadSteps: 10,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 3,
-    },
-    debugging: {
-        softTotalSteps: 18,
-        softSearchSteps: 8,
-        softReadSteps: 7,
-        warningExactRepeats: 1,
-        warningFamilyRepeats: 3,
-    },
-    implementation: {
-        softTotalSteps: 18,
-        softSearchSteps: 8,
-        softReadSteps: 6,
-        warningExactRepeats: 1,
-        warningFamilyRepeats: 3,
-    },
-    code_review: {
-        softTotalSteps: 14,
-        softSearchSteps: 6,
-        softReadSteps: 8,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 3,
-    },
-    code_explanation: {
-        softTotalSteps: 12,
-        softSearchSteps: 6,
-        softReadSteps: 8,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 3,
-    },
-    repo_orientation: {
-        softTotalSteps: 12,
-        softSearchSteps: 6,
-        softReadSteps: 8,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 3,
-    },
-    product_discussion: {
-        softTotalSteps: 10,
-        softSearchSteps: 4,
-        softReadSteps: 4,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 2,
-    },
-    general: {
-        softTotalSteps: 18,
-        softSearchSteps: 8,
-        softReadSteps: 10,
-        warningExactRepeats: 2,
-        warningFamilyRepeats: 3,
-    },
-};
-export class ExecutionGovernor {
-    budget;
-    history = [];
-    totalSteps = 0;
-    searchSteps = 0;
-    readSteps = 0;
-    mutationVersion = 0;
-    reminderQueue = [];
-    warnedFamilies = new Set();
-    warnedSignatures = new Set();
-    softTotalWarned = false;
-    softSearchWarned = false;
-    softReadWarned = false;
-    constructor(taskType) {
-        this.budget = BUDGETS[taskType];
-        if (taskType === "security_investigation") {
-            this.reminderQueue.push(buildInvestigationReminder());
-        }
-    }
-    consumePendingReminders() {
-        const reminders = [...this.reminderQueue];
-        this.reminderQueue.length = 0;
-        return reminders;
-    }
-    snapshot() {
-        return {
-            totalSteps: this.totalSteps,
-            searchSteps: this.searchSteps,
-            readSteps: this.readSteps,
-            searchFrozen: false,
-            explorationFrozen: false,
-            phase: "observe",
-        };
-    }
-    filterToolDefinitions(toolDefinitions) {
-        return toolDefinitions;
-    }
-    beforeToolCall(toolCall) {
-        const intent = analyzeToolIntent(toolCall);
-        if (intent.family === "read") {
-            const signature = intent.read?.signature;
-            if (signature && this.hasCurrentMutationObservation((entry) => entry.signature === signature)) {
-                this.warnOnce(`read:${signature}`, "This exact file range was already read since the last successful edit/write. If the content is still available and nothing changed, use the prior result; otherwise it is okay to re-read to recover context or verify a change.");
-            }
-        }
-        if (intent.family === "search") {
-            const signature = intent.search?.signature;
-            const familyKey = intent.search?.familyKey;
-            if (signature && this.trailingNoProgressCount((entry) => entry.signature === signature) >= this.budget.warningExactRepeats) {
-                this.warnOnce(`search:${signature}`, "This search is very similar to one you already ran and it did not produce new evidence. Change the query/path, follow a concrete lead, or summarize the strongest findings.");
-            }
-            if (familyKey) {
-                const familyNoProgress = this.trailingNoProgressCount((entry) => entry.familyKey === familyKey);
-                if (familyNoProgress >= this.budget.warningFamilyRepeats && !this.warnedFamilies.has(familyKey)) {
-                    this.warnedFamilies.add(familyKey);
-                    this.reminderQueue.push(buildLoopWarningReminder("Repeated searches in the same family are yielding little new evidence. Change your hypothesis, narrow the path, follow a specific file lead, or summarize current findings instead of repeating variants."));
-                }
-            }
-        }
-        this.totalSteps += 1;
-        if (intent.family === "search") {
-            this.searchSteps += 1;
-        }
-        if (intent.family === "read") {
-            this.readSteps += 1;
-        }
-        this.maybeWarnOnSoftBudgets(intent.family === "search", intent.family === "read");
-        return {};
-    }
-    afterToolResult(toolCall, result) {
-        const intent = analyzeToolIntent(toolCall);
-        const repeatedRead = intent.family === "read"
-            && !!intent.read?.signature
-            && this.history.some((entry) => entry.signature === intent.read?.signature);
-        const progress = inferProgress(intent, result) && !repeatedRead;
-        this.history.push({
-            family: intent.family,
-            signature: intent.search?.signature ?? intent.read?.signature,
-            familyKey: intent.search?.familyKey ?? intent.read?.familyKey,
-            progress,
-            mutationVersion: this.mutationVersion,
-        });
-        if (isSuccessfulWriteIntent(intent, result)) {
-            this.mutationVersion += 1;
-        }
-    }
-    trailingNoProgressCount(predicate) {
-        let count = 0;
-        for (let index = this.history.length - 1; index >= 0; index--) {
-            const entry = this.history[index];
-            if (entry.mutationVersion !== this.mutationVersion) {
-                break;
-            }
-            if (!predicate(entry)) {
-                break;
-            }
-            if (entry.progress) {
-                break;
-            }
-            count += 1;
-        }
-        return count;
-    }
-    hasCurrentMutationObservation(predicate) {
-        return this.history.some((entry) => entry.mutationVersion === this.mutationVersion && predicate(entry));
-    }
-    warnOnce(key, reason) {
-        if (this.warnedSignatures.has(key)) {
-            return;
-        }
-        this.warnedSignatures.add(key);
-        this.reminderQueue.push(buildLoopWarningReminder(reason));
-    }
-    maybeWarnOnSoftBudgets(isSearchStep, isReadStep) {
-        if (!this.softTotalWarned && this.totalSteps >= this.budget.softTotalSteps) {
-            this.softTotalWarned = true;
-            this.reminderQueue.push(buildLoopWarningReminder("This task has already used many tool steps. Do not keep exploring by default; synthesize what you know unless a concrete missing gap remains."));
-        }
-        if (isSearchStep && !this.softSearchWarned && this.searchSteps >= this.budget.softSearchSteps) {
-            this.softSearchWarned = true;
-            this.reminderQueue.push(buildLoopWarningReminder("This task has already used many search steps. Stop broad searching unless you can point to a specific remaining evidence gap."));
-        }
-        if (isReadStep && !this.softReadWarned && this.readSteps >= this.budget.softReadSteps) {
-            this.softReadWarned = true;
-            this.reminderQueue.push(buildLoopWarningReminder("This task has already used many file reads. Stop re-reading context unless a concrete edit requires one exact missing snippet."));
-        }
-    }
-}
-function isSuccessfulWriteIntent(intent, result) {
-    if (result.isError || result.status === "blocked" || result.status === "command_error") {
-        return false;
-    }
-    return intent.family === "write" || intent.family === "edit" || result.metadata?.kind === "write" || result.metadata?.kind === "edit" || result.metadata?.kind === "patch";
-}
-function inferProgress(intent, result) {
-    if (result.status === "blocked" || result.status === "timeout" || result.status === "command_error") {
-        return false;
-    }
-    if (intent.family === "search") {
-        const matches = result.metadata?.matches;
-        if (typeof matches === "number") {
-            return matches > 0;
-        }
-        const normalized = result.content.toLowerCase();
-        if (normalized.includes("no matches found") || normalized.includes("(no matches)")) {
-            return false;
-        }
-        return !result.isError;
-    }
-    return !result.isError;
-}

package/dist/agent/task-classifier.d.ts

@@ -1,3 +0,0 @@
-import type { ContentPart } from "../types.js";
-export type TaskType = "security_investigation" | "debugging" | "implementation" | "code_review" | "code_explanation" | "repo_orientation" | "product_discussion" | "code_search" | "general";
-export declare function classifyTask(input: string | ContentPart[]): TaskType;