@aexol/spectral 0.9.159 → 0.9.161

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

@@ -1,216 +0,0 @@
-import { constants } from "fs";
-import { access as fsAccess, readFile as fsReadFile, stat as fsStat, writeFile as fsWriteFile } from "fs/promises";
-import { Type } from "typebox";
-import { renderDiff } from "./render-diff.js";
-import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
-import { atomicWriteFile } from "./atomic-write.js";
-import { withFileMutationQueue } from "./file-mutation-queue.js";
-import { resolveToCwd } from "./path-utils.js";
-import { 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),
-    stat: (path) => fsStat(path),
-};
-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 (error) {
-            const reason = error instanceof Error ? error.message : String(error);
-            throw new Error(`Invalid "edits" argument for edit tool: expected an array but received a string that could not be parsed as JSON. Parse error: ${reason}`);
-        }
-    }
-    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.");
-    }
-    for (const edit of input.edits) {
-        if (!edit ||
-            typeof edit !== "object" ||
-            typeof edit.oldText !== "string" ||
-            typeof edit.newText !== "string") {
-            throw new Error("Edit tool input is invalid. Each edit must have string oldText and newText properties.");
-        }
-    }
-    return { path: input.path, edits: input.edits };
-}
-function formatEditCall(args, _theme) {
-    const rawPath = str(args?.file_path ?? args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath) : null;
-    const pathDisplay = path === null ? "[invalid]" : path || "...";
-    return `edit ${pathDisplay}`;
-}
-function formatEditResult(args, result, _theme, isError) {
-    const rawPath = str(args?.file_path ?? args?.path);
-    if (isError) {
-        const errorText = result.content
-            .filter((c) => c.type === "text")
-            .map((c) => c.text || "")
-            .join("\n");
-        if (!errorText) {
-            return undefined;
-        }
-        return errorText;
-    }
-    const resultDiff = result.details?.diff;
-    if (resultDiff) {
-        return renderDiff(resultDiff, { filePath: rawPath ?? undefined });
-    }
-    return undefined;
-}
-export function createEditToolDefinition(cwd, options) {
-    const ops = options?.operations ?? defaultEditOperations;
-    return {
-        name: "edit",
-        label: "edit",
-        description: "Edit a single file using targeted text replacement. Prefer apply_patch for manual code edits when that tool is available; use edit for small exact replacements only. Prefer copying edits[].oldText from a fresh read of the current file. Every oldText must identify one unique, non-overlapping region of the original file snapshot for this tool call. 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 targeted text replacement, including multiple disjoint edits in one call",
-        promptGuidelines: [
-            "Prefer apply_patch for manual code edits when that tool is available, especially with OpenAI/GPT/Codex models; use edit only for small exact replacements where edits[].oldText is copied from the latest file contents.",
-            "Read or re-read the target file immediately before risky edits, especially after another tool or agent may have changed it.",
-            "Never use edit from memory or from stale snippets. oldText must be copied byte-for-byte from the latest read output, including indentation, blank lines, comments, and punctuation.",
-            "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 snapshot for that edit call, not after earlier edits are applied. Do not emit sequential edits where a later oldText depends on an earlier replacement.",
-            "Do not emit overlapping or nested edits. If edits touch the same block or nearby lines, merge them into one edit.",
-            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
-            "If edit reports that oldText was not found, stop and re-read the file before retrying; do not retry the same oldText.",
-        ],
-        parameters: editSchema,
-        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");
-                        // Capture a freshness token so we can detect stale reads before writing.
-                        const freshnessTokenBefore = ops.stat ? (await ops.stat(absolutePath)).mtimeMs : undefined;
-                        // 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, usedFuzzyMatch } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-                        // Check if aborted before writing.
-                        if (aborted) {
-                            return;
-                        }
-                        // Detect stale file: re-check freshness token before writing.
-                        if (freshnessTokenBefore !== undefined && ops.stat) {
-                            const freshnessTokenAfter = (await ops.stat(absolutePath)).mtimeMs;
-                            if (freshnessTokenAfter !== freshnessTokenBefore) {
-                                if (signal) {
-                                    signal.removeEventListener("abort", onAbort);
-                                }
-                                reject(new Error(`File ${path} was modified since read. Re-read the file and retry your edit.`));
-                                return;
-                            }
-                        }
-                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-                        await atomicWriteFile(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}.${usedFuzzyMatch ? " (used tolerant matching — verify the change)" : ""}`,
-                                },
-                            ],
-                            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)));
-                        }
-                    }
-                })();
-            }));
-        },
-    };
-}
-export function createEditTool(cwd, options) {
-    return wrapToolDefinition(createEditToolDefinition(cwd, options));
-}

package/dist/sdk/coding-agent/core/tools/grep.d.ts

@@ -1,37 +0,0 @@
-import type { AgentTool } from "../../../agent-core/index.js";
-import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.js";
-import { type TruncationResult } from "./truncate.js";
-declare const grepSchema: Type.TObject<{
-    pattern: Type.TString;
-    path: Type.TOptional<Type.TString>;
-    glob: Type.TOptional<Type.TString>;
-    ignoreCase: Type.TOptional<Type.TBoolean>;
-    literal: Type.TOptional<Type.TBoolean>;
-    context: Type.TOptional<Type.TNumber>;
-    limit: Type.TOptional<Type.TNumber>;
-}>;
-export type GrepToolInput = Static<typeof grepSchema>;
-export interface GrepToolDetails {
-    truncation?: TruncationResult;
-    matchLimitReached?: number;
-    linesTruncated?: boolean;
-}
-/**
- * Pluggable operations for the grep tool.
- * Override these to delegate search to remote systems (for example SSH).
- */
-export interface GrepOperations {
-    /** Check if path is a directory. Throws if path does not exist. */
-    isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
-    /** Read file contents for context lines */
-    readFile: (absolutePath: string) => Promise<string> | string;
-}
-export interface GrepToolOptions {
-    /** Custom operations for grep. Default: local filesystem plus ripgrep */
-    operations?: GrepOperations;
-}
-export declare function createGrepToolDefinition(cwd: string, options?: GrepToolOptions): ToolDefinition<typeof grepSchema, GrepToolDetails | undefined>;
-export declare function createGrepTool(cwd: string, options?: GrepToolOptions): AgentTool<typeof grepSchema>;
-export {};
-//# sourceMappingURL=grep.d.ts.map

package/dist/sdk/coding-agent/core/tools/grep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/grep.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAI9D,OAAO,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAI7D,OAAO,EAIN,KAAK,gBAAgB,EAGrB,MAAM,eAAe,CAAC;AAEvB,QAAA,MAAM,UAAU;;;;;;;;EAYd,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAGtD,MAAM,WAAW,eAAe;IAC/B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,mEAAmE;IACnE,WAAW,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAClE,2CAA2C;IAC3C,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC7D;AAOD,MAAM,WAAW,eAAe;IAC/B,yEAAyE;IACzE,UAAU,CAAC,EAAE,cAAc,CAAC;CAC5B;AAqDD,wBAAgB,wBAAwB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,eAAe,GACvB,cAAc,CAAC,OAAO,UAAU,EAAE,eAAe,GAAG,SAAS,CAAC,CAqPhE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,OAAO,UAAU,CAAC,CAEnG"}

package/dist/sdk/coding-agent/core/tools/grep.js

@@ -1,288 +0,0 @@
-import { createInterface } from "node:readline";
-import { spawn } from "child_process";
-import { readFileSync, statSync } from "fs";
-import path from "path";
-import { Type } from "typebox";
-import { ensureTool } from "../../utils/tools-manager.js";
-import { resolveToCwd } from "./path-utils.js";
-import { getTextOutput, shortenPath, str } from "./render-utils.js";
-import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { DEFAULT_MAX_BYTES, formatSize, GREP_MAX_LINE_LENGTH, truncateHead, truncateLine, } from "./truncate.js";
-const grepSchema = Type.Object({
-    pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
-    path: Type.Optional(Type.String({ description: "Directory or file to search (default: current directory)" })),
-    glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" })),
-    ignoreCase: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
-    literal: Type.Optional(Type.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })),
-    context: Type.Optional(Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
-});
-const DEFAULT_LIMIT = 100;
-const defaultGrepOperations = {
-    isDirectory: (p) => statSync(p).isDirectory(),
-    readFile: (p) => readFileSync(p, "utf-8"),
-};
-function formatGrepCall(args, _theme) {
-    const pattern = str(args?.pattern);
-    const rawPath = str(args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
-    const glob = str(args?.glob);
-    const limit = args?.limit;
-    const invalidArg = "[invalid]";
-    let text = `grep ${pattern === null ? invalidArg : `/${pattern || ""}/`} in ${path === null ? invalidArg : path}`;
-    if (glob)
-        text += ` (${glob})`;
-    if (limit !== undefined)
-        text += ` limit ${limit}`;
-    return text;
-}
-function formatGrepResult(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 : 15;
-        const displayLines = lines.slice(0, maxLines);
-        const remaining = lines.length - maxLines;
-        text += `\n${displayLines.join("\n")}`;
-        if (remaining > 0) {
-            text += `\n... (${remaining} more lines)`;
-        }
-    }
-    const matchLimit = result.details?.matchLimitReached;
-    const truncation = result.details?.truncation;
-    const linesTruncated = result.details?.linesTruncated;
-    if (matchLimit || truncation?.truncated || linesTruncated) {
-        const warnings = [];
-        if (matchLimit)
-            warnings.push(`${matchLimit} matches limit`);
-        if (truncation?.truncated)
-            warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-        if (linesTruncated)
-            warnings.push("some lines truncated");
-        text += `\n[Truncated: ${warnings.join(", ")}]`;
-    }
-    return text;
-}
-export function createGrepToolDefinition(cwd, options) {
-    const customOps = options?.operations;
-    return {
-        name: "grep",
-        label: "grep",
-        description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
-        promptSnippet: "Search file contents for patterns (respects .gitignore)",
-        parameters: grepSchema,
-        async execute(_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit, }, signal, _onUpdate, _ctx) {
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let settled = false;
-                const settle = (fn) => {
-                    if (!settled) {
-                        settled = true;
-                        fn();
-                    }
-                };
-                (async () => {
-                    try {
-                        const rgPath = await ensureTool("rg", true);
-                        if (!rgPath) {
-                            settle(() => reject(new Error("ripgrep (rg) is not available and could not be downloaded")));
-                            return;
-                        }
-                        const searchPath = resolveToCwd(searchDir || ".", cwd);
-                        const ops = customOps ?? defaultGrepOperations;
-                        let isDirectory;
-                        try {
-                            isDirectory = await ops.isDirectory(searchPath);
-                        }
-                        catch {
-                            settle(() => reject(new Error(`Path not found: ${searchPath}`)));
-                            return;
-                        }
-                        const contextValue = context && context > 0 ? context : 0;
-                        const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
-                        const formatPath = (filePath) => {
-                            if (isDirectory) {
-                                const relative = path.relative(searchPath, filePath);
-                                if (relative && !relative.startsWith("..")) {
-                                    return relative.replace(/\\/g, "/");
-                                }
-                            }
-                            return path.basename(filePath);
-                        };
-                        const fileCache = new Map();
-                        const getFileLines = async (filePath) => {
-                            let lines = fileCache.get(filePath);
-                            if (!lines) {
-                                try {
-                                    const content = await ops.readFile(filePath);
-                                    lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-                                }
-                                catch {
-                                    lines = [];
-                                }
-                                fileCache.set(filePath, lines);
-                            }
-                            return lines;
-                        };
-                        const args = ["--json", "--line-number", "--color=never", "--hidden"];
-                        if (ignoreCase)
-                            args.push("--ignore-case");
-                        if (literal)
-                            args.push("--fixed-strings");
-                        if (glob)
-                            args.push("--glob", glob);
-                        args.push("--", pattern, searchPath);
-                        const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
-                        const rl = createInterface({ input: child.stdout });
-                        let stderr = "";
-                        let matchCount = 0;
-                        let matchLimitReached = false;
-                        let linesTruncated = false;
-                        let aborted = false;
-                        let killedDueToLimit = false;
-                        const outputLines = [];
-                        const cleanup = () => {
-                            rl.close();
-                            signal?.removeEventListener("abort", onAbort);
-                        };
-                        const stopChild = (dueToLimit = false) => {
-                            if (!child.killed) {
-                                killedDueToLimit = dueToLimit;
-                                child.kill();
-                            }
-                        };
-                        const onAbort = () => {
-                            aborted = true;
-                            stopChild();
-                        };
-                        signal?.addEventListener("abort", onAbort, { once: true });
-                        child.stderr?.on("data", (chunk) => {
-                            stderr += chunk.toString();
-                        });
-                        const formatBlock = async (filePath, lineNumber) => {
-                            const relativePath = formatPath(filePath);
-                            const lines = await getFileLines(filePath);
-                            if (!lines.length)
-                                return [`${relativePath}:${lineNumber}: (unable to read file)`];
-                            const block = [];
-                            const start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber;
-                            const end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
-                            for (let current = start; current <= end; current++) {
-                                const lineText = lines[current - 1] ?? "";
-                                const sanitized = lineText.replace(/\r/g, "");
-                                const isMatchLine = current === lineNumber;
-                                // Truncate long lines so grep output stays compact.
-                                const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
-                                if (wasTruncated)
-                                    linesTruncated = true;
-                                if (isMatchLine)
-                                    block.push(`${relativePath}:${current}: ${truncatedText}`);
-                                else
-                                    block.push(`${relativePath}-${current}- ${truncatedText}`);
-                            }
-                            return block;
-                        };
-                        // Collect matches during streaming, then format them after rg exits.
-                        const matches = [];
-                        rl.on("line", (line) => {
-                            if (!line.trim() || matchCount >= effectiveLimit)
-                                return;
-                            let event;
-                            try {
-                                event = JSON.parse(line);
-                            }
-                            catch {
-                                return;
-                            }
-                            if (event.type === "match") {
-                                matchCount++;
-                                const filePath = event.data?.path?.text;
-                                const lineNumber = event.data?.line_number;
-                                const lineText = event.data?.lines?.text;
-                                if (filePath && typeof lineNumber === "number")
-                                    matches.push({ filePath, lineNumber, lineText });
-                                if (matchCount >= effectiveLimit) {
-                                    matchLimitReached = true;
-                                    stopChild(true);
-                                }
-                            }
-                        });
-                        child.on("error", (error) => {
-                            cleanup();
-                            settle(() => reject(new Error(`Failed to run ripgrep: ${error.message}`)));
-                        });
-                        child.on("close", async (code) => {
-                            cleanup();
-                            if (aborted) {
-                                settle(() => reject(new Error("Operation aborted")));
-                                return;
-                            }
-                            if (!killedDueToLimit && code !== 0 && code !== 1) {
-                                const errorMsg = stderr.trim() || `ripgrep exited with code ${code}`;
-                                settle(() => reject(new Error(errorMsg)));
-                                return;
-                            }
-                            if (matchCount === 0) {
-                                settle(() => resolve({ content: [{ type: "text", text: "No matches found" }], details: undefined }));
-                                return;
-                            }
-                            // Format matches after streaming finishes so custom readFile() backends can be async.
-                            for (const match of matches) {
-                                if (contextValue === 0 && match.lineText !== undefined) {
-                                    const relativePath = formatPath(match.filePath);
-                                    const sanitized = match.lineText
-                                        .replace(/\r\n/g, "\n")
-                                        .replace(/\r/g, "")
-                                        .replace(/\n$/, "");
-                                    const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
-                                    if (wasTruncated)
-                                        linesTruncated = true;
-                                    outputLines.push(`${relativePath}:${match.lineNumber}: ${truncatedText}`);
-                                }
-                                else {
-                                    const block = await formatBlock(match.filePath, match.lineNumber);
-                                    outputLines.push(...block);
-                                }
-                            }
-                            const rawOutput = outputLines.join("\n");
-                            // Apply byte truncation. There is no line limit here because the match limit already capped rows.
-                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-                            let output = truncation.content;
-                            const details = {};
-                            // Build actionable notices for truncation and match limits.
-                            const notices = [];
-                            if (matchLimitReached) {
-                                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
-                                details.matchLimitReached = effectiveLimit;
-                            }
-                            if (truncation.truncated) {
-                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-                                details.truncation = truncation;
-                            }
-                            if (linesTruncated) {
-                                notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
-                                details.linesTruncated = true;
-                            }
-                            if (notices.length > 0)
-                                output += `\n\n[${notices.join(". ")}]`;
-                            settle(() => resolve({
-                                content: [{ type: "text", text: output }],
-                                details: Object.keys(details).length > 0 ? details : undefined,
-                            }));
-                        });
-                    }
-                    catch (err) {
-                        settle(() => reject(err));
-                    }
-                })();
-            });
-        },
-    };
-}
-export function createGrepTool(cwd, options) {
-    return wrapToolDefinition(createGrepToolDefinition(cwd, options));
-}

package/dist/sdk/coding-agent/core/tools/ls.d.ts

@@ -1,37 +0,0 @@
-import type { AgentTool } from "../../../agent-core/index.js";
-import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.js";
-import { type TruncationResult } from "./truncate.js";
-declare const lsSchema: Type.TObject<{
-    path: Type.TOptional<Type.TString>;
-    limit: Type.TOptional<Type.TNumber>;
-}>;
-export type LsToolInput = Static<typeof lsSchema>;
-export interface LsToolDetails {
-    truncation?: TruncationResult;
-    entryLimitReached?: number;
-}
-/**
- * Pluggable operations for the ls tool.
- * Override these to delegate directory listing to remote systems (for example SSH).
- */
-export interface LsOperations {
-    /** Check if path exists */
-    exists: (absolutePath: string) => Promise<boolean> | boolean;
-    /** Get file or directory stats. Throws if not found. */
-    stat: (absolutePath: string) => Promise<{
-        isDirectory: () => boolean;
-    }> | {
-        isDirectory: () => boolean;
-    };
-    /** Read directory entries */
-    readdir: (absolutePath: string) => Promise<string[]> | string[];
-}
-export interface LsToolOptions {
-    /** Custom operations for directory listing. Default: local filesystem */
-    operations?: LsOperations;
-}
-export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition<typeof lsSchema, LsToolDetails | undefined>;
-export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
-export {};
-//# sourceMappingURL=ls.d.ts.map

package/dist/sdk/coding-agent/core/tools/ls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/ls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAI7D,OAAO,EAAiC,KAAK,gBAAgB,EAAgB,MAAM,eAAe,CAAC;AAEnG,QAAA,MAAM,QAAQ;;;EAGZ,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,QAAQ,CAAC,CAAC;AAIlD,MAAM,WAAW,aAAa;IAC7B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,2BAA2B;IAC3B,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAC7D,wDAAwD;IACxD,IAAI,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,OAAO,CAAA;KAAE,CAAC,GAAG;QAAE,WAAW,EAAE,MAAM,OAAO,CAAA;KAAE,CAAC;IACzG,6BAA6B;IAC7B,OAAO,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC;CAChE;AAQD,MAAM,WAAW,aAAa;IAC7B,yEAAyE;IACzE,UAAU,CAAC,EAAE,YAAY,CAAC;CAC1B;AAkDD,wBAAgB,sBAAsB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,aAAa,GACrB,cAAc,CAAC,OAAO,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC,CAiH5D;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC,OAAO,QAAQ,CAAC,CAE7F"}