@bubblebrain-ai/bubble 0.0.15 → 0.0.17

package/README.md

@@ -62,6 +62,30 @@ Bubble stores user configuration, sessions, permissions, skills, and memory unde
 
 In the app, use `/login` or provider commands to configure model access.
 
+### ChatGPT Network Configuration
+
+ChatGPT OAuth and GPT/Codex requests respect standard proxy variables:
+
+```bash
+export HTTPS_PROXY=http://proxy.example.com:8080
+export HTTP_PROXY=http://proxy.example.com:8080
+export NO_PROXY=localhost,127.0.0.1
+```
+
+If your network uses a corporate or custom HTTPS CA, start Bubble with:
+
+```bash
+NODE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+```
+
+You can also use `BUBBLE_EXTRA_CA_CERTS` for Bubble's ChatGPT requests:
+
+```bash
+BUBBLE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+```
+
+Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+
 ## Memory
 
 Bubble maintains persistent memory automatically from prior sessions. Useful commands:

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,173 @@
+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/lsp 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/internal-reminder-sanitizer.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantProviderMetadata } from "../types.js";
+export declare function formatInternalReminderBlock(kind: string, content: string): string;
+export declare function formatInternalContextBlock(kind: string, content: string): string;
+export declare function sanitizeInternalReminderBlocks(text: string): string;
+export declare function sanitizeAssistantProviderMetadata(metadata: AssistantProviderMetadata | undefined): AssistantProviderMetadata | undefined;
+export declare function createStreamingInternalReminderSanitizer(): {
+    push(delta: string): string;
+    flush(): string;
+};

package/dist/agent/internal-reminder-sanitizer.js

@@ -0,0 +1,198 @@
+const INTERNAL_TAG_PREFIX = "<bubble_internal_";
+const INTERNAL_TAG_NAMES = ["reminder", "context"];
+const LEGACY_RUNTIME_MARKERS = [
+    "Runtime reminder:\n",
+    "Runtime context:\n",
+];
+const STREAM_MARKERS = [
+    INTERNAL_TAG_PREFIX,
+    ...LEGACY_RUNTIME_MARKERS,
+];
+const LEGACY_REMINDER_END_PHRASES = [
+    "Debugging workflow: find the failing boundary.",
+    "Code explanation workflow: answer directly.",
+    "Verify the specific failure path after the change.",
+    "Run a narrow verification command or explain why it cannot be run.",
+    "Keep summaries secondary to findings.",
+    "Avoid proposing changes unless the user asks for them.",
+    "Keep the first pass read-only unless the user asks for changes or runtime verification.",
+    "Avoid drifting into code changes unless the user explicitly asks to execute.",
+    "On rejection, remain in plan mode and iterate.",
+    "Do not perform destructive operations, credential exposure, or unrelated reversions just because approvals are bypassed.",
+    "Execute the requested change end to end; do not stop at analysis unless blocked or the user explicitly asks for discussion only.",
+    "If current evidence is sufficient, summarize your findings now.",
+    "- If you cannot determine the cause, ask the user for clarification.",
+    "- Skip the \"investigate the codebase\" step that applies to larger changes.",
+    "Do not put the final answer only in hidden reasoning.",
+];
+export function formatInternalReminderBlock(kind, content) {
+    return formatInternalBlock("reminder", kind, content);
+}
+export function formatInternalContextBlock(kind, content) {
+    return formatInternalBlock("context", kind, content);
+}
+export function sanitizeInternalReminderBlocks(text) {
+    if (!text)
+        return text;
+    const sanitizer = createStreamingInternalReminderSanitizer();
+    return sanitizer.push(text) + sanitizer.flush();
+}
+export function sanitizeAssistantProviderMetadata(metadata) {
+    const anthropic = metadata?.anthropic;
+    const blocks = anthropic?.contentBlocks;
+    if (!metadata || !anthropic || !blocks?.length)
+        return metadata;
+    let changed = false;
+    const sanitizedBlocks = blocks.map((block) => {
+        if (block.type !== "text" || typeof block.text !== "string") {
+            return block;
+        }
+        const sanitizedText = sanitizeInternalReminderBlocks(block.text);
+        if (sanitizedText === block.text) {
+            return block;
+        }
+        changed = true;
+        return { ...block, text: sanitizedText };
+    });
+    if (!changed)
+        return metadata;
+    return {
+        ...metadata,
+        anthropic: {
+            ...anthropic,
+            contentBlocks: sanitizedBlocks,
+        },
+    };
+}
+export function createStreamingInternalReminderSanitizer() {
+    let pending = "";
+    const drain = (final) => {
+        let out = "";
+        while (pending.length > 0) {
+            const block = consumeInternalBlockAtStart(pending, final);
+            if (block?.hold)
+                break;
+            if (block?.consume !== undefined) {
+                pending = pending.slice(block.consume);
+                continue;
+            }
+            const markerIndex = findEarliestCompleteMarker(pending);
+            if (markerIndex >= 0) {
+                if (markerIndex > 0) {
+                    out += pending.slice(0, markerIndex);
+                    pending = pending.slice(markerIndex);
+                    continue;
+                }
+                // A marker is present but the block is not yet complete enough to
+                // consume. Hold it in streaming mode; drop it on final flush.
+                if (final) {
+                    pending = "";
+                }
+                break;
+            }
+            if (!final) {
+                const partialIndex = findEarliestMarkerPrefixSuffix(pending);
+                if (partialIndex >= 0) {
+                    out += pending.slice(0, partialIndex);
+                    pending = pending.slice(partialIndex);
+                    break;
+                }
+            }
+            out += pending;
+            pending = "";
+        }
+        return out;
+    };
+    return {
+        push(delta) {
+            if (!delta)
+                return "";
+            pending += delta;
+            return drain(false);
+        },
+        flush() {
+            return drain(true);
+        },
+    };
+}
+function formatInternalBlock(type, kind, content) {
+    const safeKind = kind.replace(/[^a-zA-Z0-9_-]/g, "-");
+    return `<bubble_internal_${type} kind="${safeKind}">\n${content}\n</bubble_internal_${type}>`;
+}
+function consumeInternalBlockAtStart(text, final) {
+    if (text.startsWith(INTERNAL_TAG_PREFIX)) {
+        return consumeStructuredInternalBlock(text, final);
+    }
+    if (text.startsWith("Runtime reminder:\n")) {
+        return consumeLegacyRuntimeReminder(text, final);
+    }
+    if (text.startsWith("Runtime context:\n")) {
+        return final ? { consume: text.length } : { hold: true };
+    }
+    return undefined;
+}
+function consumeStructuredInternalBlock(text, final) {
+    for (const tagName of INTERNAL_TAG_NAMES) {
+        const openMatch = text.match(new RegExp(`^<bubble_internal_${tagName}\\b[^>]*>`));
+        if (!openMatch)
+            continue;
+        const closeTag = `</bubble_internal_${tagName}>`;
+        const closeIndex = text.indexOf(closeTag, openMatch[0].length);
+        if (closeIndex < 0) {
+            return final ? { consume: text.length } : { hold: true };
+        }
+        return { consume: consumeTrailingLineBreaks(text, closeIndex + closeTag.length) };
+    }
+    if (isPrefixOf(INTERNAL_TAG_PREFIX, text)) {
+        return final ? { consume: text.length } : { hold: true };
+    }
+    return undefined;
+}
+function consumeLegacyRuntimeReminder(text, final) {
+    for (const phrase of LEGACY_REMINDER_END_PHRASES) {
+        const endIndex = text.indexOf(phrase, LEGACY_RUNTIME_MARKERS[0].length);
+        if (endIndex >= 0) {
+            return { consume: consumeTrailingLineBreaks(text, endIndex + phrase.length) };
+        }
+    }
+    if (final) {
+        return { consume: text.length };
+    }
+    return { hold: true };
+}
+function consumeTrailingLineBreaks(text, index) {
+    let next = index;
+    while (text[next] === "\n")
+        next += 1;
+    return next;
+}
+function findEarliestCompleteMarker(text) {
+    let earliest = -1;
+    for (const marker of STREAM_MARKERS) {
+        const index = text.indexOf(marker);
+        if (index >= 0 && (earliest < 0 || index < earliest)) {
+            earliest = index;
+        }
+    }
+    return earliest;
+}
+function findEarliestMarkerPrefixSuffix(text) {
+    let earliest = -1;
+    for (const marker of STREAM_MARKERS) {
+        const max = Math.min(marker.length - 1, text.length);
+        for (let length = max; length > 0; length -= 1) {
+            const suffix = text.slice(text.length - length);
+            if (isPrefixOf(marker, suffix)) {
+                const index = text.length - length;
+                if (earliest < 0 || index < earliest) {
+                    earliest = index;
+                }
+                break;
+            }
+        }
+    }
+    return earliest;
+}
+function isPrefixOf(value, possiblePrefix) {
+    return value.startsWith(possiblePrefix);
+}

package/dist/agent/task-classifier.js

@@ -49,9 +49,17 @@ const EXPLANATION_PATTERNS = [
 ];
 const ORIENTATION_PATTERNS = [
     /\bwhat is this project\b/i,
+    /\bwhat is this (repo|repository)\b/i,
     /\borient/i,
     /\boverview\b/i,
-    /这个项目.*(干嘛|做什么)|看下这个项目|项目.*概览/i,
+    /\b(repo|repository|project) overview\b/i,
+    /这个项目.*(干嘛|做什么)|这项目.*(干嘛|做什么)|这个\s*repo.*(干嘛|做什么)|看下(这个|这)?项目|项目.*概览|快速了解.*项目/i,
+];
+const CONCRETE_ORIENTATION_EXCLUSIONS = [
+    /项目[中里内]\s*[,，]?\s*\S{2,}/i,
+    /帮我.*(实现|开发|改|加|调整|优化|修复)/i,
+    /(实现|开发|改一下|加一个|调整|优化|修复|支持|报错|失败|不对|有问题|bug|commit|push)/i,
+    /(?:\.[a-z][\w-]*|\b[A-Z]{2,}\b)/,
 ];
 const PRODUCT_PATTERNS = [
     /\bproduct\b/i,
@@ -77,15 +85,15 @@ export function classifyTask(input) {
     if (DEBUG_PATTERNS.some((pattern) => pattern.test(text))) {
         return "debugging";
     }
-    if (ORIENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+    if (IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "implementation";
+    }
+    if (isLikelyRepoOrientation(text)) {
         return "repo_orientation";
     }
     if (EXPLANATION_PATTERNS.some((pattern) => pattern.test(text))) {
         return "code_explanation";
     }
-    if (IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
-        return "implementation";
-    }
     if (PRODUCT_PATTERNS.some((pattern) => pattern.test(text))) {
         return "product_discussion";
     }
@@ -94,3 +102,13 @@ export function classifyTask(input) {
     }
     return "general";
 }
+function isLikelyRepoOrientation(text) {
+    const normalized = text.trim().replace(/\s+/g, " ");
+    if (!ORIENTATION_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    if (CONCRETE_ORIENTATION_EXCLUSIONS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    return normalized.length <= 80;
+}