@bubblebrain-ai/bubble 0.0.3 → 0.0.5

package/dist/agent/tool-intent.js

@@ -38,10 +38,20 @@ export function analyzeToolIntent(toolCall) {
                     search: buildSearchIntent(parsed.pattern, parsed.path, parsed.include),
                 };
             }
+            const parsedRead = parseReadBashCommand(stringArg(toolCall.parsedArgs.command));
+            if (parsedRead) {
+                return {
+                    family: "read",
+                    read: buildReadIntent(parsedRead.path, parsedRead.offset, parsedRead.limit),
+                };
+            }
             return { family: "shell" };
         }
         case "read":
-            return { family: "read" };
+            return {
+                family: "read",
+                read: buildReadIntent(stringArg(toolCall.parsedArgs.path ?? toolCall.parsedArgs.file), numberOrStringArg(toolCall.parsedArgs.offset), numberOrStringArg(toolCall.parsedArgs.limit)),
+            };
         case "write":
             return { family: "write" };
         case "edit":
@@ -99,6 +109,36 @@ export function parseSearchBashCommand(command) {
         include,
     };
 }
+export function parseReadBashCommand(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 (binary === "cat" || binary === "nl") {
+        const path = lastPositional(tokens.slice(1));
+        return path ? { path } : undefined;
+    }
+    if (binary === "head") {
+        const { path, lineCount } = parseHeadTailArgs(tokens.slice(1));
+        return path ? { path, offset: 1, limit: lineCount ?? "head" } : undefined;
+    }
+    if (binary === "tail") {
+        const { path, lineCount } = parseHeadTailArgs(tokens.slice(1));
+        return path ? { path, offset: `tail:${lineCount ?? "default"}`, limit: lineCount ?? "tail" } : undefined;
+    }
+    if (binary === "sed") {
+        return parseSedReadCommand(tokens.slice(1));
+    }
+    return undefined;
+}
 function buildSearchIntent(pattern, path, include) {
     const normalizedPath = normalizePath(path ?? ".");
     const rawNormalizedPattern = normalizeRawPattern(pattern);
@@ -114,6 +154,18 @@ function buildSearchIntent(pattern, path, include) {
         familyKey,
     };
 }
+function buildReadIntent(path, offset, limit) {
+    const normalizedPath = normalizePath(path || ".");
+    const normalizedOffset = offset ?? 1;
+    const normalizedLimit = limit ?? "default";
+    return {
+        path,
+        offset,
+        limit,
+        signature: `${normalizedPath}::${normalizedOffset}::${normalizedLimit}`,
+        familyKey: normalizedPath,
+    };
+}
 function canonicalizeSearchTokens(pattern) {
     const normalized = normalizeRawPattern(pattern);
     const tokens = normalized.split(/[^a-z0-9_]+/).filter(Boolean);
@@ -132,6 +184,78 @@ function normalizePath(pathValue) {
 function stringArg(value) {
     return typeof value === "string" ? value : "";
 }
+function numberOrStringArg(value) {
+    return typeof value === "number" || typeof value === "string" ? value : undefined;
+}
+function lastPositional(tokens) {
+    for (let index = tokens.length - 1; index >= 0; index--) {
+        const token = tokens[index];
+        if (!token.startsWith("-")) {
+            return token;
+        }
+    }
+    return undefined;
+}
+function parseHeadTailArgs(tokens) {
+    let lineCount;
+    const positional = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === "-n" || token === "--lines") {
+            lineCount = parseLineCount(tokens[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("-n") && token.length > 2) {
+            lineCount = parseLineCount(token.slice(2));
+            continue;
+        }
+        if (token.startsWith("--lines=")) {
+            lineCount = parseLineCount(token.slice("--lines=".length));
+            continue;
+        }
+        if (token.startsWith("-")) {
+            continue;
+        }
+        positional.push(token);
+    }
+    return {
+        path: positional[positional.length - 1],
+        lineCount,
+    };
+}
+function parseSedReadCommand(tokens) {
+    const positional = [];
+    for (const token of tokens) {
+        if (token === "-n" || token.startsWith("-")) {
+            continue;
+        }
+        positional.push(token);
+    }
+    if (positional.length < 2) {
+        return undefined;
+    }
+    const expression = positional[0];
+    const path = positional[positional.length - 1];
+    const range = expression.match(/^(\d+)(?:,(\d+))?p$/);
+    if (!range) {
+        return { path, offset: expression };
+    }
+    const start = Number(range[1]);
+    const end = range[2] ? Number(range[2]) : start;
+    return {
+        path,
+        offset: start,
+        limit: Math.max(1, end - start + 1),
+    };
+}
+function parseLineCount(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value.replace(/^\+/, ""));
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function shellSplit(command) {
     const tokens = [];
     let current = "";

package/dist/agent.d.ts

@@ -2,8 +2,12 @@
  * 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 { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
 import { type TurnHooks } from "./orchestrator/hooks.js";
+import { BudgetLedger } from "./agent/budget-ledger.js";
+import { type AgentProfile, type SubagentRunResult } from "./agent/profiles.js";
+import { type SubagentThreadSnapshot } from "./agent/subagent-control.js";
+import type { SkillSummary } from "./skills/types.js";
 export declare class AgentAbortError extends Error {
     constructor(message?: string);
 }
@@ -28,6 +32,13 @@ export interface AgentOptions {
     onTodosUpdate?: (todos: Todo[]) => void;
     onModeUpdate?: (mode: PermissionMode) => void;
     hooks?: TurnHooks[];
+    budgetLedger?: BudgetLedger;
+    budgetSource?: {
+        runId: string;
+        subAgentId?: string;
+    };
+    skills?: SkillSummary[];
+    memoryPrompt?: string;
 }
 export declare class Agent {
     messages: Message[];
@@ -50,6 +61,12 @@ export declare class Agent {
     private hookDefinitions;
     private maxTurns?;
     private taskBudget?;
+    private budgetLedger?;
+    private budgetSource;
+    private skillSummaries;
+    private memoryPrompt?;
+    private subagentThreads;
+    private pendingSubagentUpdates;
     private lastInputTokens;
     private lastAnchorMessageCount;
     constructor(options: AgentOptions);
@@ -96,6 +113,48 @@ export declare class Agent {
         subtaskType?: string;
         description?: string;
     }): Promise<ToolResult>;
+    runSubAgent(input: string | ContentPart[], cwd: string, options: {
+        profile: AgentProfile;
+        runId: string;
+        subAgentId: string;
+        parentToolCallId: string;
+        approval?: "fail" | "disabled";
+        emitUpdate?: (update: ToolUpdate) => void;
+        description?: string;
+        abortSignal?: AbortSignal;
+        nickname?: string;
+        forkContext?: boolean;
+    }): Promise<SubagentRunResult>;
+    spawnSubAgent(input: string | ContentPart[], cwd: string, options: {
+        profile: AgentProfile;
+        parentToolCallId: string;
+        approval?: "fail" | "disabled";
+        description?: string;
+        abortSignal?: AbortSignal;
+        forkContext?: boolean;
+    }): Promise<SubagentThreadSnapshot>;
+    waitSubAgents(options?: {
+        agentIds?: string[];
+        timeoutMs?: number;
+    }): Promise<SubagentThreadSnapshot[]>;
+    sendSubAgentInput(agentId: string, input: string | ContentPart[], cwd: string, options?: {
+        interrupt?: boolean;
+        parentToolCallId?: string;
+        abortSignal?: AbortSignal;
+    }): Promise<SubagentThreadSnapshot>;
+    closeSubAgent(agentId: string): Promise<SubagentThreadSnapshot>;
+    listSubAgents(): SubagentThreadSnapshot[];
+    private createSubagentThreadRecord;
+    private runSubagentThread;
+    private runSubagentFinalSummaryTurn;
+    private createSubAgentInstance;
+    private forkMessagesForSubagent;
+    private buildSubagentUpdate;
+    private queueSubagentUpdate;
+    private drainSubagentToolUpdates;
+    private activeSubagentNicknames;
+    private resolveSubagentTargets;
+    private notifySubagentWaiters;
     private maybeCompactResidentHistory;
     private appendMessage;
     private executeTool;