@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tools/index.js

@@ -0,0 +1,76 @@
+/**
+ * Tool registry factory.
+ */
+export { createReadTool } from "./read.js";
+export { createBashTool } from "./bash.js";
+export { createManagedServerTools } from "./server.js";
+export { createWriteTool } from "./write.js";
+export { createEditTool } from "./edit.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
+export { createLsTool } from "./ls.js";
+export { createGrepTool } from "./grep.js";
+export { createLspTool } from "./lsp.js";
+export { createWebFetchTool } from "./web-fetch.js";
+export { createWebSearchTool } from "./web-search.js";
+export { createSkillTool } from "./skill.js";
+export { createSkillSearchTool } from "./skill-search.js";
+export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
+export { createExitPlanModeTool } from "./exit-plan-mode.js";
+export { createToolSearchTool } from "./tool-search.js";
+export { createQuestionTool } from "./question.js";
+export { createMemoryTool } from "./memory.js";
+import { createBashTool } from "./bash.js";
+import { createManagedServerTools } from "./server.js";
+import { createEditTool } from "./edit.js";
+import { createExitPlanModeTool } from "./exit-plan-mode.js";
+import { createLsTool } from "./ls.js";
+import { createGrepTool } from "./grep.js";
+import { getLspService } from "../lsp/index.js";
+import { createLspTool } from "./lsp.js";
+import { createReadTool } from "./read.js";
+import { createSkillTool } from "./skill.js";
+import { createSkillSearchTool } from "./skill-search.js";
+import { createAgentLifecycleTools } from "./agent-lifecycle.js";
+import { createToolSearchTool } from "./tool-search.js";
+import { createWebFetchTool } from "./web-fetch.js";
+import { createWebSearchTool } from "./web-search.js";
+import { createWriteTool } from "./write.js";
+import { createQuestionTool } from "./question.js";
+import { createMemoryTool } from "./memory.js";
+import { FileStateTracker } from "./file-state.js";
+import { createGoalTools } from "../goal/tools.js";
+import { createBackgroundTaskTools } from "./task-tools.js";
+export function createAllTools(cwd, skillRegistry, options = {}) {
+    const approval = options.approvalController;
+    const lsp = options.lspService ?? getLspService(cwd);
+    const fileState = options.fileStateTracker ?? new FileStateTracker(cwd);
+    const backgroundTasks = options.allowBackgroundTasks === true && !!options.processManager;
+    return [
+        createReadTool(cwd, approval, lsp, fileState),
+        createBashTool(cwd, approval, fileState, {
+            processManager: options.processManager,
+            allowBackgroundTasks: backgroundTasks,
+            promotionChannel: backgroundTasks ? options.promotionChannel : undefined,
+            autoBackgroundAfterMs: backgroundTasks ? options.autoBackgroundAfterMs : false,
+        }),
+        ...(backgroundTasks ? createBackgroundTaskTools(options.processManager) : []),
+        ...createManagedServerTools(cwd, approval),
+        createWriteTool(cwd, {}, approval, lsp, fileState, options.checkpoints),
+        createEditTool(cwd, approval, lsp, fileState, options.checkpoints),
+        createLsTool(cwd),
+        createGrepTool(cwd),
+        createLspTool(cwd, lsp, approval),
+        createWebSearchTool(),
+        createWebFetchTool(approval),
+        createMemoryTool(cwd),
+        ...createAgentLifecycleTools({ cwd, approval }),
+        // Always registered: any host can carry deferred tools (MCP entries mark
+        // themselves deferred), so every host needs the unlock path. Falls back
+        // to the executing agent when no controller is wired.
+        createToolSearchTool(options.toolSearchController),
+        ...(options.questionController ? [createQuestionTool(options.questionController)] : []),
+        ...(skillRegistry ? [createSkillSearchTool(skillRegistry), createSkillTool(skillRegistry)] : []),
+        ...(options.planController ? [createExitPlanModeTool(options.planController)] : []),
+        ...(options.goalStore ? createGoalTools(options.goalStore) : []),
+    ];
+}

package/dist/tools/ls.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRegistryEntry } from "../types.js";
+/** A shallow directory listing: nested files never crowd out sibling directories. */
+export declare function createLsTool(cwd: string): ToolRegistryEntry;

package/dist/tools/ls.js

@@ -0,0 +1,85 @@
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { resolveToolPath } from "./path-utils.js";
+import { isSensitivePath } from "./sensitive-paths.js";
+const DEFAULT_LIMIT = 500;
+const MAX_BYTES = 50 * 1024;
+/** A shallow directory listing: nested files never crowd out sibling directories. */
+export function createLsTool(cwd) {
+    return {
+        name: "ls",
+        readOnly: true,
+        effect: "read",
+        promptSnippet: "List directory contents, including hidden files and subdirectories",
+        description: `List one directory, sorted alphabetically, including hidden entries. Directories end in '/', symbolic links in '@' (not followed). Defaults to ${DEFAULT_LIMIT} entries; increase limit for more. Output is capped at 50 KiB. Does not recurse.`,
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Directory to list (default: cwd)" },
+                limit: { type: "integer", description: "Positive maximum entries to return (default: 500)" },
+            },
+        },
+        async execute(args, ctx) {
+            const cancelled = () => ({ content: "Directory listing cancelled.", isError: true, status: "cancelled" });
+            if (ctx.abortSignal?.aborted)
+                return cancelled();
+            const limit = args.limit ?? DEFAULT_LIMIT;
+            if (!Number.isSafeInteger(limit) || limit < 1) {
+                return { content: "Error: limit must be a positive integer", isError: true, status: "command_error" };
+            }
+            if (args.path !== undefined && typeof args.path !== "string") {
+                return { content: "Error: path must be a string", isError: true, status: "command_error" };
+            }
+            const root = resolveToolPath(cwd, args.path?.trim() ? args.path : ".");
+            if (isSensitivePath(root)) {
+                return { content: `Error: Listing blocked for sensitive credential storage: ${root}`, isError: true, status: "blocked" };
+            }
+            try {
+                const entries = await readdir(root, { withFileTypes: true });
+                if (ctx.abortSignal?.aborted)
+                    return cancelled();
+                entries.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) || a.name.localeCompare(b.name));
+                const lines = [];
+                const paths = [];
+                let bytes = 0;
+                let byteLimitReached = false;
+                for (const entry of entries) {
+                    if (ctx.abortSignal?.aborted)
+                        return cancelled();
+                    if (lines.length >= limit)
+                        break;
+                    // Quote control characters so one entry always occupies one output line.
+                    const name = /[\u0000-\u001f\u007f]/.test(entry.name) ? JSON.stringify(entry.name) : entry.name;
+                    const suffix = entry.isDirectory() ? "/" : entry.isSymbolicLink() ? "@" : "";
+                    const line = name + suffix;
+                    const size = Buffer.byteLength(line, "utf8") + (lines.length ? 1 : 0);
+                    if (bytes + size > MAX_BYTES) {
+                        byteLimitReached = true;
+                        break;
+                    }
+                    lines.push(line);
+                    paths.push(resolve(root, entry.name) + (entry.isDirectory() ? "/" : ""));
+                    bytes += size;
+                }
+                const truncated = lines.length < entries.length;
+                const notice = !truncated ? "" : byteLimitReached
+                    ? `\n\n[Output truncated at 50 KiB: showing ${lines.length} of ${entries.length} entries. Use bash with ls/find to filter or page the listing.]`
+                    : `\n\n[Output truncated: showing ${lines.length} of ${entries.length} entries. Increase limit to see more.]`;
+                return {
+                    content: (entries.length === 0 ? "(empty directory)" : lines.join("\n")) + notice,
+                    status: truncated ? "partial" : "success",
+                    metadata: { kind: "search", path: root, matches: lines.length, totalEntries: entries.length, truncated, paths },
+                };
+            }
+            catch (error) {
+                if (ctx.abortSignal?.aborted)
+                    return cancelled();
+                return {
+                    content: `Error: Cannot list directory: ${root} (${error instanceof Error ? error.message : String(error)})`,
+                    isError: true,
+                    status: "command_error",
+                };
+            }
+        },
+    };
+}

package/dist/tools/lsp.d.ts

@@ -0,0 +1,4 @@
+import type { ApprovalController } from "../approval/types.js";
+import { type LspService } from "../lsp/index.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createLspTool(cwd: string, lsp?: LspService, approval?: ApprovalController): ToolRegistryEntry;

package/dist/tools/lsp.js

@@ -0,0 +1,95 @@
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { gateToolAction } from "../approval/tool-helper.js";
+import { getLspService } from "../lsp/index.js";
+import { resolveToolPath } from "./path-utils.js";
+const OPERATIONS = [
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "documentSymbol",
+    "workspaceSymbol",
+    "goToImplementation",
+    "prepareCallHierarchy",
+    "incomingCalls",
+    "outgoingCalls",
+];
+export function createLspTool(cwd, lsp = getLspService(cwd), approval) {
+    return {
+        name: "lsp",
+        deferred: true,
+        readOnly: true,
+        effect: "read",
+        requiresApproval: true,
+        description: "Use the language server for code navigation. Supports goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, and outgoingCalls.",
+        parameters: {
+            type: "object",
+            properties: {
+                operation: { type: "string", enum: [...OPERATIONS], description: "LSP operation to perform" },
+                filePath: { type: "string", description: "Path to the file, relative or absolute" },
+                line: { type: "number", description: "1-based line number for position-based operations" },
+                character: { type: "number", description: "1-based character offset for position-based operations" },
+                query: { type: "string", description: "Optional query for workspaceSymbol" },
+            },
+            required: ["operation", "filePath"],
+        },
+        async execute(args) {
+            const operation = args.operation;
+            if (!OPERATIONS.includes(operation)) {
+                return { content: `Error: Unsupported LSP operation: ${args.operation}`, isError: true };
+            }
+            const file = resolveToolPath(cwd, args.filePath);
+            try {
+                await access(file, constants.R_OK);
+            }
+            catch {
+                return { content: `Error: File not found or not readable: ${file}`, isError: true };
+            }
+            const available = await lsp.hasClients(file);
+            if (!available) {
+                return { content: "Error: No LSP server available for this file type.", isError: true };
+            }
+            const gate = await gateToolAction(approval, {
+                type: "lsp",
+                path: file,
+                operation,
+            });
+            if (!gate.approved)
+                return gate.result;
+            await lsp.touchFile(file, "document");
+            const position = {
+                file,
+                line: Math.max(0, Number(args.line ?? 1) - 1),
+                character: Math.max(0, Number(args.character ?? 1) - 1),
+            };
+            const result = await runOperation(lsp, operation, position, String(args.query ?? ""));
+            return {
+                content: result.length === 0 ? `No results found for ${operation}` : JSON.stringify(result, null, 2),
+                status: "success",
+                metadata: { kind: "lsp", path: file },
+            };
+        },
+    };
+}
+async function runOperation(lsp, operation, position, query) {
+    switch (operation) {
+        case "goToDefinition":
+            return lsp.definition(position);
+        case "findReferences":
+            return lsp.references(position);
+        case "hover":
+            return lsp.hover(position);
+        case "documentSymbol":
+            return lsp.documentSymbol(position.file);
+        case "workspaceSymbol":
+            return lsp.workspaceSymbol(query);
+        case "goToImplementation":
+            return lsp.implementation(position);
+        case "prepareCallHierarchy":
+            return lsp.prepareCallHierarchy(position);
+        case "incomingCalls":
+            return lsp.incomingCalls(position);
+        case "outgoingCalls":
+            return lsp.outgoingCalls(position);
+    }
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,8 @@
+import type { ToolRegistryEntry } from "../types.js";
+/**
+ * Single entry point to persistent memory: without a query it reads the
+ * concise memory summary, with a query it searches memory. One schema in the
+ * per-turn tool list instead of two (the read/search split cost context on
+ * every turn while both modes share this file's backing code).
+ */
+export declare function createMemoryTool(cwd: string): ToolRegistryEntry;

package/dist/tools/memory.js

@@ -0,0 +1,77 @@
+import { readMemorySummary, searchMemory } from "../memory/index.js";
+const MEMORY_SCOPE_ENUM = ["project", "global", "all"];
+/**
+ * Single entry point to persistent memory: without a query it reads the
+ * concise memory summary, with a query it searches memory. One schema in the
+ * per-turn tool list instead of two (the read/search split cost context on
+ * every turn while both modes share this file's backing code).
+ */
+export function createMemoryTool(cwd) {
+    return {
+        name: "memory",
+        description: "Read or search persistent Bubble memory (prior project facts, user preferences, workflows, decisions, gotchas). " +
+            "Without query, returns the concise memory summary (scope defaults to project). " +
+            "With query, searches memory entries (scope defaults to all, project memory first).",
+        readOnly: true,
+        effect: "read",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query. Use concrete terms such as file names, feature names, commands, or error text. Omit to read the memory summary instead.",
+                },
+                scope: {
+                    type: "string",
+                    enum: MEMORY_SCOPE_ENUM,
+                    description: "Memory scope. Defaults to project when reading the summary, all when searching.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of search results to return. Defaults to 12. Ignored for summary reads.",
+                },
+            },
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const query = typeof args.query === "string" ? args.query.trim() : "";
+            if (!query) {
+                const scope = parseScope(args.scope, "project");
+                const summaries = readMemorySummary(cwd, scope);
+                if (summaries.length === 0) {
+                    return { content: `No ${scope} memory summary is available.`, status: "no_match" };
+                }
+                return {
+                    content: summaries.map((summary) => [
+                        `# ${summary.scope} memory summary`,
+                        `Path: ${summary.path}`,
+                        "",
+                        summary.content,
+                    ].join("\n")).join("\n\n---\n\n"),
+                    metadata: { kind: "read", matches: summaries.length },
+                };
+            }
+            const scope = parseScope(args.scope);
+            const limit = typeof args.limit === "number" && Number.isFinite(args.limit)
+                ? Math.max(1, Math.min(50, Math.floor(args.limit)))
+                : undefined;
+            const results = searchMemory(cwd, query, { scope, limit });
+            if (results.length === 0) {
+                return { content: `No memory matches for "${query}".`, status: "no_match" };
+            }
+            return {
+                content: [
+                    `Memory search results for "${query}":`,
+                    ...results.flatMap((result) => [
+                        `- ${result.scope} ${result.path}:${result.line}`,
+                        `  ${result.text}`,
+                    ]),
+                ].join("\n"),
+                metadata: { kind: "search", matches: results.length },
+            };
+        },
+    };
+}
+function parseScope(value, fallback = "all") {
+    return value === "project" || value === "global" || value === "all" ? value : fallback;
+}

package/dist/tools/path-utils.d.ts

@@ -0,0 +1,8 @@
+export declare function expandHomePath(value: unknown): string;
+export declare function resolveToolPath(cwd: string, value: unknown, fallback?: string): string;
+/**
+ * Where a path really leads once symlinks are followed — including links in
+ * its parent directories and dangling links (writing through a dangling link
+ * creates its target). Parts that do not exist yet are kept as written.
+ */
+export declare function resolveThroughLinks(path: string): string;

package/dist/tools/path-utils.js

@@ -0,0 +1,53 @@
+import { lstatSync, readlinkSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+export function expandHomePath(value) {
+    const text = String(value ?? "");
+    if (text === "~")
+        return homedir();
+    if (text.startsWith("~/") || text.startsWith("~\\")) {
+        return join(homedir(), text.slice(2));
+    }
+    return text;
+}
+export function resolveToolPath(cwd, value, fallback = ".") {
+    const text = String(value ?? "");
+    const path = text === "" ? fallback : text;
+    return resolve(cwd, expandHomePath(path));
+}
+/**
+ * Where a path really leads once symlinks are followed — including links in
+ * its parent directories and dangling links (writing through a dangling link
+ * creates its target). Parts that do not exist yet are kept as written.
+ */
+export function resolveThroughLinks(path) {
+    return followLinks(path, 0);
+}
+function followLinks(path, depth) {
+    let current = resolve(path);
+    const rest = [];
+    for (;;) {
+        try {
+            return join(realpathSync.native(current), ...rest);
+        }
+        catch {
+            // Missing (or dangling): follow a dangling link, else step up.
+        }
+        if (depth < 16) {
+            try {
+                if (lstatSync(current).isSymbolicLink()) {
+                    const target = resolve(dirname(current), readlinkSync(current));
+                    return followLinks(join(target, ...rest), depth + 1);
+                }
+            }
+            catch {
+                // Not there at all.
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return resolve(path);
+        rest.unshift(basename(current));
+        current = parent;
+    }
+}

package/dist/tools/prompt-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { SystemPromptOptions } from "../system-prompt.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function buildToolPromptOptions(tools: ToolRegistryEntry[]): Pick<SystemPromptOptions, "tools" | "toolSnippets" | "guidelines">;

package/dist/tools/prompt-metadata.js

@@ -0,0 +1,17 @@
+export function buildToolPromptOptions(tools) {
+    const toolSnippets = {};
+    const guidelines = [];
+    for (const tool of tools) {
+        if (tool.promptSnippet) {
+            toolSnippets[tool.name] = tool.promptSnippet;
+        }
+        for (const guideline of tool.promptGuidelines ?? []) {
+            guidelines.push(guideline);
+        }
+    }
+    return {
+        tools: tools.map((tool) => tool.name),
+        toolSnippets,
+        guidelines,
+    };
+}

package/dist/tools/question.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRegistryEntry } from "../types.js";
+import type { QuestionController } from "../question/index.js";
+export declare function createQuestionTool(controller: QuestionController): ToolRegistryEntry;

package/dist/tools/question.js

@@ -0,0 +1,177 @@
+import { QuestionRejectedError } from "../question/index.js";
+import { normalizeQuestionInlineText } from "../question/normalize.js";
+export function createQuestionTool(controller) {
+    return {
+        name: "question",
+        readOnly: true,
+        effect: "read",
+        requiresApproval: true,
+        description: `Ask the user one or more structured questions during execution.
+
+Use this when you need to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices
+4. Offer choices about what direction to take
+
+Usage notes:
+- Each question needs a short header, complete question text, and concise options.
+- When custom is enabled (default), the UI adds "Type your own answer"; do not include "Other" or catch-all options yourself.
+- Answers are returned as arrays of labels; set multiple: true when more than one answer may be selected.
+- If you recommend a specific option, make it the first option and add "(Recommended)" to the label.
+- Ask only targeted questions that unblock real work; do not ask "Should I proceed?".`,
+        parameters: {
+            type: "object",
+            properties: {
+                questions: {
+                    type: "array",
+                    description: "Questions to ask the user.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            header: {
+                                type: "string",
+                                description: "Very short label for this question, ideally 1-4 words.",
+                            },
+                            question: {
+                                type: "string",
+                                description: "Complete user-facing question.",
+                            },
+                            options: {
+                                type: "array",
+                                description: "Available choices. Do not include Other when custom is enabled.",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        label: {
+                                            type: "string",
+                                            description: "Display label, concise and selectable.",
+                                        },
+                                        description: {
+                                            type: "string",
+                                            description: "Short explanation of the choice and its tradeoff.",
+                                        },
+                                    },
+                                    required: ["label", "description"],
+                                    additionalProperties: false,
+                                },
+                            },
+                            multiple: {
+                                type: "boolean",
+                                description: "Allow selecting multiple choices.",
+                            },
+                            custom: {
+                                type: "boolean",
+                                description: "Allow typing a custom answer. Defaults to true.",
+                            },
+                        },
+                        required: ["header", "question", "options"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["questions"],
+            additionalProperties: false,
+        },
+        async execute(args, ctx) {
+            const normalized = normalizeQuestions(args.questions);
+            if ("error" in normalized) {
+                return { content: normalized.error, isError: true };
+            }
+            try {
+                const answers = await controller.ask({
+                    sessionID: ctx.sessionID,
+                    questions: normalized.questions,
+                    tool: ctx.toolCall ? { callID: ctx.toolCall.id } : undefined,
+                });
+                return {
+                    content: formatQuestionToolResult(normalized.questions, answers),
+                    status: "success",
+                    metadata: {
+                        kind: "question",
+                        questions: normalized.questions,
+                        answers,
+                    },
+                };
+            }
+            catch (err) {
+                const message = err instanceof QuestionRejectedError
+                    ? err.message
+                    : err instanceof Error
+                        ? err.message
+                        : String(err);
+                return {
+                    content: `QuestionRejectedError: ${message}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "question",
+                        questions: normalized.questions,
+                        rejected: true,
+                    },
+                };
+            }
+        },
+    };
+}
+function normalizeQuestions(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return { error: "Error: questions must be a non-empty array." };
+    }
+    if (input.length > 3) {
+        return { error: "Error: ask at most 3 questions at a time." };
+    }
+    const questions = [];
+    for (let index = 0; index < input.length; index++) {
+        const raw = input[index];
+        if (!raw || typeof raw !== "object") {
+            return { error: `Error: question at index ${index} must be an object.` };
+        }
+        const q = raw;
+        const header = typeof q.header === "string" ? normalizeQuestionInlineText(q.header) : "";
+        const question = typeof q.question === "string" ? normalizeQuestionInlineText(q.question) : "";
+        const options = q.options;
+        if (!header)
+            return { error: `Error: question at index ${index} has an empty header.` };
+        if (!question)
+            return { error: `Error: question at index ${index} has empty question text.` };
+        if (!Array.isArray(options) || options.length === 0) {
+            return { error: `Error: question at index ${index} needs at least one option.` };
+        }
+        if (options.length > 9) {
+            return { error: `Error: question at index ${index} has too many options; max is 9.` };
+        }
+        const normalizedOptions = [];
+        for (let optIndex = 0; optIndex < options.length; optIndex++) {
+            const opt = options[optIndex];
+            if (!opt || typeof opt !== "object") {
+                return { error: `Error: option ${optIndex + 1} for "${header}" must be an object.` };
+            }
+            const value = opt;
+            const label = typeof value.label === "string" ? normalizeQuestionInlineText(value.label) : "";
+            const description = typeof value.description === "string" ? normalizeQuestionInlineText(value.description) : "";
+            if (!label)
+                return { error: `Error: option ${optIndex + 1} for "${header}" has empty label.` };
+            if (!description)
+                return { error: `Error: option "${label}" for "${header}" has empty description.` };
+            normalizedOptions.push({ label, description });
+        }
+        questions.push({
+            header,
+            question,
+            options: normalizedOptions,
+            multiple: q.multiple === true,
+            custom: q.custom === false ? false : undefined,
+        });
+    }
+    return { questions };
+}
+function formatQuestionToolResult(questions, answers) {
+    const formatted = questions
+        .map((question, index) => {
+        const answer = answers[index]?.length ? answers[index].join(", ") : "Unanswered";
+        return `"${question.question}"="${answer}"`;
+    })
+        .join(", ");
+    return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+}

package/dist/tools/read.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Read tool - read file contents with truncation, dedup, and auto-pagination.
+ */
+import type { ApprovalController } from "../approval/types.js";
+import type { ToolRegistryEntry } from "../types.js";
+import type { LspService } from "../lsp/index.js";
+import { FileStateTracker } from "./file-state.js";
+export declare function createReadTool(cwd: string, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;