@bubblebrain-ai/bubble 0.0.1

package/dist/agent/tool-intent.js

@@ -0,0 +1,176 @@
+const SEARCH_TOKEN_CANONICAL = new Map([
+    ["api_key", "secret"],
+    ["apikey", "secret"],
+    ["api", "secret"],
+    ["key", "secret"],
+    ["keys", "secret"],
+    ["secret", "secret"],
+    ["secrets", "secret"],
+    ["token", "secret"],
+    ["tokens", "secret"],
+    ["credential", "secret"],
+    ["credentials", "secret"],
+    ["auth", "secret"],
+    ["password", "secret"],
+    ["passwd", "secret"],
+    ["bearer", "secret"],
+    ["env", "config"],
+    ["config", "config"],
+    ["dotenv", "config"],
+]);
+export function analyzeToolIntent(toolCall) {
+    switch (toolCall.name) {
+        case "glob":
+            return {
+                family: "search",
+                search: buildSearchIntent(stringArg(toolCall.parsedArgs.pattern), stringArg(toolCall.parsedArgs.path)),
+            };
+        case "grep":
+            return {
+                family: "search",
+                search: buildSearchIntent(stringArg(toolCall.parsedArgs.pattern), stringArg(toolCall.parsedArgs.path), stringArg(toolCall.parsedArgs.glob)),
+            };
+        case "bash": {
+            const parsed = parseSearchBashCommand(stringArg(toolCall.parsedArgs.command));
+            if (parsed) {
+                return {
+                    family: "search",
+                    search: buildSearchIntent(parsed.pattern, parsed.path, parsed.include),
+                };
+            }
+            return { family: "shell" };
+        }
+        case "read":
+            return { family: "read" };
+        case "write":
+            return { family: "write" };
+        case "edit":
+            return { family: "edit" };
+        case "web_search":
+        case "web_fetch":
+            return { family: "web" };
+        default:
+            return { family: "other" };
+    }
+}
+export function parseSearchBashCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (/[|;&><`]/.test(trimmed)) {
+        return undefined;
+    }
+    const tokens = shellSplit(trimmed);
+    if (tokens.length === 0) {
+        return undefined;
+    }
+    const binary = tokens[0];
+    if (!["grep", "rg", "ripgrep"].includes(binary)) {
+        return undefined;
+    }
+    const positional = [];
+    let include;
+    for (let index = 1; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (!token)
+            continue;
+        if (token === "--glob" || token === "--iglob" || token === "--include") {
+            include = tokens[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--glob=") || token.startsWith("--iglob=") || token.startsWith("--include=")) {
+            include = token.slice(token.indexOf("=") + 1);
+            continue;
+        }
+        if (token.startsWith("-")) {
+            continue;
+        }
+        positional.push(token);
+    }
+    if (positional.length === 0) {
+        return undefined;
+    }
+    const [pattern, maybePath] = positional;
+    return {
+        pattern,
+        path: maybePath,
+        include,
+    };
+}
+function buildSearchIntent(pattern, path, include) {
+    const normalizedPath = normalizePath(path ?? ".");
+    const rawNormalizedPattern = normalizeRawPattern(pattern);
+    const normalizedTokens = canonicalizeSearchTokens(pattern);
+    const signature = `${normalizedPath}::${include ?? "*"}::${rawNormalizedPattern || normalizedTokens.join("|")}`;
+    const familyTokens = normalizedTokens.filter((token) => token === "secret" || token === "config");
+    const familyKey = `${normalizedPath}::${familyTokens.join("|") || normalizedTokens.slice(0, 3).join("|") || "generic-search"}`;
+    return {
+        pattern,
+        path,
+        include,
+        signature,
+        familyKey,
+    };
+}
+function canonicalizeSearchTokens(pattern) {
+    const normalized = normalizeRawPattern(pattern);
+    const tokens = normalized.split(/[^a-z0-9_]+/).filter(Boolean);
+    const canonical = new Set();
+    for (const token of tokens) {
+        canonical.add(SEARCH_TOKEN_CANONICAL.get(token) ?? token);
+    }
+    return [...canonical].sort();
+}
+function normalizeRawPattern(pattern) {
+    return pattern.trim().toLowerCase().replace(/\\s\+/g, " ").replace(/\s+/g, " ");
+}
+function normalizePath(pathValue) {
+    return pathValue.trim().replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function stringArg(value) {
+    return typeof value === "string" ? value : "";
+}
+function shellSplit(command) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}

package/dist/agent.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Agent - The core decision loop.
+ * It maintains message state, calls the LLM, executes tools, and auto-continues.
+ */
+import type { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry } from "./types.js";
+import { type TurnHooks } from "./orchestrator/hooks.js";
+export interface AgentOptions {
+    provider: Provider;
+    sessionID?: string;
+    providerId?: string;
+    model: string;
+    tools: ToolRegistryEntry[];
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    mode?: PermissionMode;
+    steps?: number;
+    maxTurns?: number;
+    taskBudget?: {
+        total: number;
+    };
+    todos?: Todo[];
+    systemPrompt?: string;
+    onMessageAppend?: (message: Message) => void;
+    onToolResult?: (toolName: string, result: ToolResult) => void;
+    onTodosUpdate?: (todos: Todo[]) => void;
+    onModeUpdate?: (mode: PermissionMode) => void;
+    hooks?: TurnHooks[];
+}
+export declare class Agent {
+    messages: Message[];
+    private provider;
+    private sessionID?;
+    private _providerId;
+    private _model;
+    private tools;
+    private unlockedDeferred;
+    private temperature;
+    private thinkingLevel;
+    private _mode;
+    private _modeVersion;
+    private onModeUpdate?;
+    private _todos;
+    private _todosVersion;
+    private onTodosUpdate?;
+    private onMessageAppend?;
+    private onToolResult?;
+    private hookDefinitions;
+    private maxTurns?;
+    private taskBudget?;
+    private lastInputTokens;
+    private lastAnchorMessageCount;
+    constructor(options: AgentOptions);
+    /** Unlock a list of deferred tools so they're included in subsequent turns. */
+    unlockDeferredTools(names: string[]): void;
+    /** All deferred tools in this session (for tool_search to inspect). */
+    listDeferredTools(): ToolRegistryEntry[];
+    /** Whether a given tool is deferred and not yet unlocked. */
+    isDeferredAndLocked(name: string): boolean;
+    injectSystemReminder(content: string): void;
+    get model(): string;
+    set model(value: string);
+    get providerId(): string;
+    set providerId(value: string);
+    get apiModel(): string;
+    setProvider(provider: Provider): void;
+    complete(messages: Message[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }): Promise<string>;
+    get thinking(): ThinkingLevel;
+    set thinking(value: ThinkingLevel);
+    get reasoning(): ThinkingLevel;
+    set reasoning(value: ThinkingLevel);
+    get mode(): PermissionMode;
+    set mode(value: PermissionMode);
+    setMode(value: PermissionMode): void;
+    /** Internal: snapshot counter that bumps on every mode change. Used by run loop. */
+    get modeVersion(): number;
+    getTodos(): Todo[];
+    setTodos(next: Todo[]): void;
+    /** Internal: snapshot counter that bumps on every setTodos. Used by run loop to detect mutations. */
+    get todosVersion(): number;
+    setSystemPrompt(prompt: string): void;
+    run(userInput: string | ContentPart[], cwd: string): AsyncIterable<AgentEvent>;
+    private recoverFromOverflow;
+    compactResidentHistory(): void;
+    runSubtask(input: string | ContentPart[], cwd: string, options?: {
+        subtaskType?: string;
+        description?: string;
+    }): Promise<ToolResult>;
+    private maybeCompactResidentHistory;
+    private appendMessage;
+    private executeTool;
+}