@aexol/spectral 0.7.1 → 0.7.5

package/dist/pi/coding-agent/core/tools/edit.js

@@ -0,0 +1,324 @@
+import { Box, Container, Spacer, Text } from "../../../tui/index.js";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+import { Type } from "typebox";
+import { renderDiff } from "../../modes/interactive/components/diff.js";
+import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { invalidArgText, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const replaceEditSchema = Type.Object({
+    oldText: Type.String({
+        description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
+    }),
+    newText: Type.String({ description: "Replacement text for this targeted edit." }),
+}, { additionalProperties: false });
+const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+    edits: Type.Array(replaceEditSchema, {
+        description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
+    }),
+}, { additionalProperties: false });
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+};
+function prepareEditArguments(input) {
+    if (!input || typeof input !== "object") {
+        return input;
+    }
+    const args = input;
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array
+    if (typeof args.edits === "string") {
+        try {
+            const parsed = JSON.parse(args.edits);
+            if (Array.isArray(parsed))
+                args.edits = parsed;
+        }
+        catch { }
+    }
+    const legacy = args;
+    if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
+        return args;
+    }
+    const edits = Array.isArray(legacy.edits) ? [...legacy.edits] : [];
+    edits.push({ oldText: legacy.oldText, newText: legacy.newText });
+    const { oldText: _oldText, newText: _newText, ...rest } = legacy;
+    return { ...rest, edits };
+}
+function validateEditInput(input) {
+    if (!Array.isArray(input.edits) || input.edits.length === 0) {
+        throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
+    }
+    return { path: input.path, edits: input.edits };
+}
+function createEditCallRenderComponent() {
+    return Object.assign(new Box(1, 1, (text) => text), {
+        preview: undefined,
+        previewArgsKey: undefined,
+        previewPending: false,
+        settledError: false,
+    });
+}
+function getEditCallRenderComponent(state, lastComponent) {
+    if (lastComponent instanceof Box) {
+        const component = lastComponent;
+        state.callComponent = component;
+        return component;
+    }
+    if (state.callComponent) {
+        return state.callComponent;
+    }
+    const component = createEditCallRenderComponent();
+    state.callComponent = component;
+    return component;
+}
+function getRenderablePreviewInput(args) {
+    if (!args) {
+        return null;
+    }
+    const path = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : null;
+    if (!path) {
+        return null;
+    }
+    if (Array.isArray(args.edits) &&
+        args.edits.length > 0 &&
+        args.edits.every((edit) => typeof edit?.oldText === "string" && typeof edit?.newText === "string")) {
+        return { path, edits: args.edits };
+    }
+    if (typeof args.oldText === "string" && typeof args.newText === "string") {
+        return { path, edits: [{ oldText: args.oldText, newText: args.newText }] };
+    }
+    return null;
+}
+function formatEditCall(args, theme) {
+    const invalidArg = invalidArgText(theme);
+    const rawPath = str(args?.file_path ?? args?.path);
+    const path = rawPath !== null ? shortenPath(rawPath) : null;
+    const pathDisplay = path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+    return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
+}
+function formatEditResult(args, preview, result, theme, isError) {
+    const rawPath = str(args?.file_path ?? args?.path);
+    const previewDiff = preview && !("error" in preview) ? preview.diff : undefined;
+    const previewError = preview && "error" in preview ? preview.error : undefined;
+    if (isError) {
+        const errorText = result.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text || "")
+            .join("\n");
+        if (!errorText || errorText === previewError) {
+            return undefined;
+        }
+        return theme.fg("error", errorText);
+    }
+    const resultDiff = result.details?.diff;
+    if (resultDiff && resultDiff !== previewDiff) {
+        return renderDiff(resultDiff, { filePath: rawPath ?? undefined });
+    }
+    return undefined;
+}
+function getEditHeaderBg(preview, settledError, theme) {
+    if (preview) {
+        if ("error" in preview) {
+            return (text) => theme.bg("toolErrorBg", text);
+        }
+        return (text) => theme.bg("toolSuccessBg", text);
+    }
+    if (settledError) {
+        return (text) => theme.bg("toolErrorBg", text);
+    }
+    return (text) => theme.bg("toolPendingBg", text);
+}
+function buildEditCallComponent(component, args, theme) {
+    component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme));
+    component.clear();
+    component.addChild(new Text(formatEditCall(args, theme), 0, 0));
+    if (!component.preview) {
+        return component;
+    }
+    const body = "error" in component.preview ? theme.fg("error", component.preview.error) : renderDiff(component.preview.diff);
+    component.addChild(new Spacer(1));
+    component.addChild(new Text(body, 0, 0));
+    return component;
+}
+function setEditPreview(component, preview, argsKey) {
+    const current = component.preview;
+    const changed = current === undefined ||
+        ("error" in current && "error" in preview
+            ? current.error !== preview.error
+            : "error" in current !== "error" in preview) ||
+        (!("error" in current) &&
+            !("error" in preview) &&
+            (current.diff !== preview.diff || current.firstChangedLine !== preview.firstChangedLine));
+    component.preview = preview;
+    component.previewArgsKey = argsKey;
+    component.previewPending = false;
+    return changed;
+}
+export function createEditToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: "edit",
+        label: "edit",
+        description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+        promptGuidelines: [
+            "Use edit for precise changes (edits[].oldText must match exactly)",
+            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+        ],
+        parameters: editSchema,
+        renderShell: "self",
+        prepareArguments: prepareEditArguments,
+        async execute(_toolCallId, input, signal, _onUpdate, _ctx) {
+            const { path, edits } = validateEditInput(input);
+            const absolutePath = resolveToCwd(path, cwd);
+            return withFileMutationQueue(absolutePath, () => new Promise((resolve, reject) => {
+                // Check if already aborted.
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler.
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error("Operation aborted"));
+                };
+                if (signal) {
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+                // Perform the edit operation.
+                void (async () => {
+                    try {
+                        // Check if file exists.
+                        try {
+                            await ops.access(absolutePath);
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`Could not edit file: ${path}. ${errorMessage}.`));
+                            return;
+                        }
+                        // Check if aborted before reading.
+                        if (aborted) {
+                            return;
+                        }
+                        // Read the file.
+                        const buffer = await ops.readFile(absolutePath);
+                        const rawContent = buffer.toString("utf-8");
+                        // Check if aborted after reading.
+                        if (aborted) {
+                            return;
+                        }
+                        // Strip BOM before matching. The model will not include an invisible BOM in oldText.
+                        const { bom, text: content } = stripBom(rawContent);
+                        const originalEnding = detectLineEnding(content);
+                        const normalizedContent = normalizeToLF(content);
+                        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+                        // Check if aborted before writing.
+                        if (aborted) {
+                            return;
+                        }
+                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                        await ops.writeFile(absolutePath, finalContent);
+                        // Check if aborted after writing.
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler.
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        const diffResult = generateDiffString(baseContent, newContent);
+                        const patch = generateUnifiedPatch(path, baseContent, newContent);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Successfully replaced ${edits.length} block(s) in ${path}.`,
+                                },
+                            ],
+                            details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },
+                        });
+                    }
+                    catch (error) {
+                        // Clean up abort handler.
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error instanceof Error ? error : new Error(String(error)));
+                        }
+                    }
+                })();
+            }));
+        },
+        renderCall(args, theme, context) {
+            const component = getEditCallRenderComponent(context.state, context.lastComponent);
+            const previewInput = getRenderablePreviewInput(args);
+            const argsKey = previewInput
+                ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits })
+                : undefined;
+            if (component.previewArgsKey !== argsKey) {
+                component.preview = undefined;
+                component.previewArgsKey = argsKey;
+                component.previewPending = false;
+                component.settledError = false;
+            }
+            if (context.argsComplete && previewInput && !component.preview && !component.previewPending) {
+                component.previewPending = true;
+                const requestKey = argsKey;
+                void computeEditsDiff(previewInput.path, previewInput.edits, context.cwd).then((preview) => {
+                    if (component.previewArgsKey === requestKey) {
+                        setEditPreview(component, preview, requestKey);
+                        context.invalidate();
+                    }
+                });
+            }
+            return buildEditCallComponent(component, args, theme);
+        },
+        renderResult(result, _options, theme, context) {
+            const callComponent = context.state.callComponent;
+            const previewInput = getRenderablePreviewInput(context.args);
+            const argsKey = previewInput
+                ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits })
+                : undefined;
+            const typedResult = result;
+            const resultDiff = !context.isError ? typedResult.details?.diff : undefined;
+            let changed = false;
+            if (callComponent) {
+                if (typeof resultDiff === "string") {
+                    changed =
+                        setEditPreview(callComponent, { diff: resultDiff, firstChangedLine: typedResult.details?.firstChangedLine }, argsKey) || changed;
+                }
+                if (callComponent.settledError !== context.isError) {
+                    callComponent.settledError = context.isError;
+                    changed = true;
+                }
+                if (changed) {
+                    buildEditCallComponent(callComponent, context.args, theme);
+                }
+            }
+            const output = formatEditResult(context.args, callComponent?.preview, typedResult, theme, context.isError);
+            const component = context.lastComponent ?? new Container();
+            component.clear();
+            if (!output) {
+                return component;
+            }
+            component.addChild(new Spacer(1));
+            component.addChild(new Text(output, 1, 0));
+            return component;
+        },
+    };
+}
+export function createEditTool(cwd, options) {
+    return wrapToolDefinition(createEditToolDefinition(cwd, options));
+}

package/dist/pi/coding-agent/core/tools/file-mutation-queue.js

@@ -0,0 +1,36 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+const fileMutationQueues = new Map();
+function getMutationQueueKey(filePath) {
+    const resolvedPath = resolve(filePath);
+    try {
+        return realpathSync.native(resolvedPath);
+    }
+    catch {
+        return resolvedPath;
+    }
+}
+/**
+ * Serialize file mutation operations targeting the same file.
+ * Operations for different files still run in parallel.
+ */
+export async function withFileMutationQueue(filePath, fn) {
+    const key = getMutationQueueKey(filePath);
+    const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
+    let releaseNext;
+    const nextQueue = new Promise((resolveQueue) => {
+        releaseNext = resolveQueue;
+    });
+    const chainedQueue = currentQueue.then(() => nextQueue);
+    fileMutationQueues.set(key, chainedQueue);
+    await currentQueue;
+    try {
+        return await fn();
+    }
+    finally {
+        releaseNext();
+        if (fileMutationQueues.get(key) === chainedQueue) {
+            fileMutationQueues.delete(key);
+        }
+    }
+}

package/dist/pi/coding-agent/core/tools/find.js

@@ -0,0 +1,297 @@
+import { createInterface } from "node:readline";
+import { Text } from "../../../tui/index.js";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { Type } from "typebox";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { ensureTool } from "../../utils/tools-manager.js";
+import { resolveToCwd } from "./path-utils.js";
+import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+function toPosixPath(value) {
+    return value.split(path.sep).join("/");
+}
+const findSchema = Type.Object({
+    pattern: Type.String({
+        description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'",
+    }),
+    path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
+});
+const DEFAULT_LIMIT = 1000;
+const defaultFindOperations = {
+    exists: existsSync,
+    // This is a placeholder. Actual fd execution happens in execute() when no custom glob is provided.
+    glob: () => [],
+};
+function formatFindCall(args, theme) {
+    const pattern = str(args?.pattern);
+    const rawPath = str(args?.path);
+    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
+    const limit = args?.limit;
+    const invalidArg = invalidArgText(theme);
+    let text = theme.fg("toolTitle", theme.bold("find")) +
+        " " +
+        (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) +
+        theme.fg("toolOutput", ` in ${path === null ? invalidArg : path}`);
+    if (limit !== undefined) {
+        text += theme.fg("toolOutput", ` (limit ${limit})`);
+    }
+    return text;
+}
+function formatFindResult(result, options, theme, showImages) {
+    const output = getTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 20;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")})`;
+        }
+    }
+    const resultLimit = result.details?.resultLimitReached;
+    const truncation = result.details?.truncation;
+    if (resultLimit || truncation?.truncated) {
+        const warnings = [];
+        if (resultLimit)
+            warnings.push(`${resultLimit} results limit`);
+        if (truncation?.truncated)
+            warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export function createFindToolDefinition(cwd, options) {
+    const customOps = options?.operations;
+    return {
+        name: "find",
+        label: "find",
+        description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
+        promptSnippet: "Find files by glob pattern (respects .gitignore)",
+        parameters: findSchema,
+        async execute(_toolCallId, { pattern, path: searchDir, limit }, signal, _onUpdate, _ctx) {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let settled = false;
+                let stopChild;
+                const settle = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal?.removeEventListener("abort", onAbort);
+                    stopChild = undefined;
+                    fn();
+                };
+                const onAbort = () => {
+                    stopChild?.();
+                    settle(() => reject(new Error("Operation aborted")));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                (async () => {
+                    try {
+                        const searchPath = resolveToCwd(searchDir || ".", cwd);
+                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+                        const ops = customOps ?? defaultFindOperations;
+                        // If custom operations provide glob(), use that instead of fd.
+                        if (customOps?.glob) {
+                            if (!(await ops.exists(searchPath))) {
+                                settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+                                return;
+                            }
+                            if (signal?.aborted) {
+                                settle(() => reject(new Error("Operation aborted")));
+                                return;
+                            }
+                            const results = await ops.glob(pattern, searchPath, {
+                                ignore: ["**/node_modules/**", "**/.git/**"],
+                                limit: effectiveLimit,
+                            });
+                            if (signal?.aborted) {
+                                settle(() => reject(new Error("Operation aborted")));
+                                return;
+                            }
+                            if (results.length === 0) {
+                                settle(() => resolve({
+                                    content: [{ type: "text", text: "No files found matching pattern" }],
+                                    details: undefined,
+                                }));
+                                return;
+                            }
+                            // Relativize paths against the search root for stable output.
+                            const relativized = results.map((p) => {
+                                if (p.startsWith(searchPath))
+                                    return toPosixPath(p.slice(searchPath.length + 1));
+                                return toPosixPath(path.relative(searchPath, p));
+                            });
+                            const resultLimitReached = relativized.length >= effectiveLimit;
+                            const rawOutput = relativized.join("\n");
+                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+                            let resultOutput = truncation.content;
+                            const details = {};
+                            const notices = [];
+                            if (resultLimitReached) {
+                                notices.push(`${effectiveLimit} results limit reached`);
+                                details.resultLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (notices.length > 0) {
+                                resultOutput += `\n\n[${notices.join(". ")}]`;
+                            }
+                            settle(() => resolve({
+                                content: [{ type: "text", text: resultOutput }],
+                                details: Object.keys(details).length > 0 ? details : undefined,
+                            }));
+                            return;
+                        }
+                        // Default implementation uses fd.
+                        const fdPath = await ensureTool("fd", true);
+                        if (signal?.aborted) {
+                            settle(() => reject(new Error("Operation aborted")));
+                            return;
+                        }
+                        if (!fdPath) {
+                            settle(() => reject(new Error("fd is not available and could not be downloaded")));
+                            return;
+                        }
+                        // Build fd arguments. --no-require-git makes fd apply hierarchical .gitignore
+                        // semantics whether or not the search path is inside a git repository, without
+                        // leaking sibling-directory rules the way --ignore-file (a global source) would.
+                        const args = [
+                            "--glob",
+                            "--color=never",
+                            "--hidden",
+                            "--no-require-git",
+                            "--max-results",
+                            String(effectiveLimit),
+                        ];
+                        // fd --glob matches against the basename unless --full-path is set; in --full-path
+                        // mode it matches against the absolute candidate path, so a path-containing
+                        // pattern like 'src/**/*.spec.ts' needs a leading '**/' to match anything.
+                        let effectivePattern = pattern;
+                        if (pattern.includes("/")) {
+                            args.push("--full-path");
+                            if (!pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**") {
+                                effectivePattern = `**/${pattern}`;
+                            }
+                        }
+                        args.push("--", effectivePattern, searchPath);
+                        const child = spawn(fdPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+                        const rl = createInterface({ input: child.stdout });
+                        let stderr = "";
+                        const lines = [];
+                        stopChild = () => {
+                            if (!child.killed) {
+                                child.kill();
+                            }
+                        };
+                        const cleanup = () => {
+                            rl.close();
+                        };
+                        child.stderr?.on("data", (chunk) => {
+                            stderr += chunk.toString();
+                        });
+                        rl.on("line", (line) => {
+                            lines.push(line);
+                        });
+                        child.on("error", (error) => {
+                            cleanup();
+                            settle(() => reject(new Error(`Failed to run fd: ${error.message}`)));
+                        });
+                        child.on("close", (code) => {
+                            cleanup();
+                            if (signal?.aborted) {
+                                settle(() => reject(new Error("Operation aborted")));
+                                return;
+                            }
+                            const output = lines.join("\n");
+                            if (code !== 0) {
+                                const errorMsg = stderr.trim() || `fd exited with code ${code}`;
+                                if (!output) {
+                                    settle(() => reject(new Error(errorMsg)));
+                                    return;
+                                }
+                            }
+                            if (!output) {
+                                settle(() => resolve({
+                                    content: [{ type: "text", text: "No files found matching pattern" }],
+                                    details: undefined,
+                                }));
+                                return;
+                            }
+                            const relativized = [];
+                            for (const rawLine of lines) {
+                                const line = rawLine.replace(/\r$/, "").trim();
+                                if (!line)
+                                    continue;
+                                const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
+                                let relativePath = line;
+                                if (line.startsWith(searchPath)) {
+                                    relativePath = line.slice(searchPath.length + 1);
+                                }
+                                else {
+                                    relativePath = path.relative(searchPath, line);
+                                }
+                                if (hadTrailingSlash && !relativePath.endsWith("/"))
+                                    relativePath += "/";
+                                relativized.push(toPosixPath(relativePath));
+                            }
+                            const resultLimitReached = relativized.length >= effectiveLimit;
+                            const rawOutput = relativized.join("\n");
+                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+                            let resultOutput = truncation.content;
+                            const details = {};
+                            const notices = [];
+                            if (resultLimitReached) {
+                                notices.push(`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                                details.resultLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (notices.length > 0) {
+                                resultOutput += `\n\n[${notices.join(". ")}]`;
+                            }
+                            settle(() => resolve({
+                                content: [{ type: "text", text: resultOutput }],
+                                details: Object.keys(details).length > 0 ? details : undefined,
+                            }));
+                        });
+                    }
+                    catch (e) {
+                        if (signal?.aborted) {
+                            settle(() => reject(new Error("Operation aborted")));
+                            return;
+                        }
+                        const error = e instanceof Error ? e : new Error(String(e));
+                        settle(() => reject(error));
+                    }
+                })();
+            });
+        },
+        renderCall(args, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatFindCall(args, theme));
+            return text;
+        },
+        renderResult(result, options, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatFindResult(result, options, theme, context.showImages));
+            return text;
+        },
+    };
+}
+export function createFindTool(cwd, options) {
+    return wrapToolDefinition(createFindToolDefinition(cwd, options));
+}