tarsk 0.3.43 → 0.4.4

package/dist/tools/bash.js

@@ -0,0 +1,186 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { spawnProcess } from "../core/utils.js";
+import { getShellConfig, getShellEnv, killProcessTree } from "./shell.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail, } from "./truncate.js";
+function getTempFilePath() {
+    return join(tmpdir(), `tarsk-bash-${randomBytes(8).toString("hex")}.log`);
+}
+const bashSchema = Type.Object({
+    command: Type.String({ description: "Bash command to execute" }),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
+});
+const defaultBashOperations = {
+    exec: (command, cwd, { onData, signal, timeout, env }) => {
+        return new Promise((resolve, reject) => {
+            const { shell, args } = getShellConfig();
+            if (!existsSync(cwd)) {
+                reject(new Error(`Working directory does not exist: ${cwd}`));
+                return;
+            }
+            const child = spawnProcess(shell, [...args, command], {
+                cwd,
+                detached: true,
+                env: (env
+                    ? Object.fromEntries(Object.entries(env)
+                        .filter(([_, v]) => v !== undefined)
+                        .map(([k, v]) => [k, v]))
+                    : undefined) ??
+                    Object.fromEntries(Object.entries(getShellEnv())
+                        .filter(([_, v]) => v !== undefined)
+                        .map(([k, v]) => [k, v])),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let timedOut = false;
+            let timeoutHandle;
+            if (timeout !== undefined && timeout > 0) {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    if (child.pid)
+                        killProcessTree(child.pid);
+                }, timeout * 1000);
+            }
+            if (child.stdout)
+                child.stdout.on("data", onData);
+            if (child.stderr)
+                child.stderr.on("data", onData);
+            child.on("error", (err) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+                reject(err);
+            });
+            const onAbort = () => {
+                if (child.pid)
+                    killProcessTree(child.pid);
+            };
+            if (signal) {
+                if (signal.aborted)
+                    onAbort();
+                else
+                    signal.addEventListener("abort", onAbort, { once: true });
+            }
+            child.on("close", (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+                if (signal?.aborted) {
+                    reject(new Error("aborted"));
+                    return;
+                }
+                if (timedOut) {
+                    reject(new Error(`timeout:${timeout}`));
+                    return;
+                }
+                resolve({ exitCode: code });
+            });
+        });
+    },
+};
+export function createBashTool(cwd, options) {
+    const ops = options?.operations ?? defaultBashOperations;
+    const commandPrefix = options?.commandPrefix;
+    return {
+        name: "bash",
+        label: "bash",
+        description: `Execute a bash command in the current working directory. Output truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. Optionally provide a timeout in seconds.`,
+        parameters: bashSchema,
+        execute: async (_toolCallId, { command, timeout }, signal, onUpdate) => {
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            console.log(`[ai] bash-start: ${resolvedCommand}`);
+            return new Promise((resolve, reject) => {
+                let tempFilePath;
+                let tempFileStream;
+                let totalBytes = 0;
+                const chunks = [];
+                let chunksBytes = 0;
+                const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
+                const handleData = (data) => {
+                    totalBytes += data.length;
+                    if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+                        tempFilePath = getTempFilePath();
+                        tempFileStream = createWriteStream(tempFilePath);
+                        for (const chunk of chunks)
+                            tempFileStream.write(chunk);
+                    }
+                    if (tempFileStream)
+                        tempFileStream.write(data);
+                    chunks.push(data);
+                    chunksBytes += data.length;
+                    while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+                        const removed = chunks.shift();
+                        chunksBytes -= removed.length;
+                    }
+                    if (onUpdate) {
+                        const fullText = Buffer.concat(chunks).toString("utf-8");
+                        const truncation = truncateTail(fullText);
+                        onUpdate({
+                            content: [{ type: "text", text: truncation.content || "" }],
+                            details: {
+                                truncation: truncation.truncated ? truncation : undefined,
+                                fullOutputPath: tempFilePath,
+                            },
+                        });
+                    }
+                };
+                ops
+                    .exec(resolvedCommand, cwd, { onData: handleData, signal, timeout, env: getShellEnv() })
+                    .then(({ exitCode }) => {
+                    console.log(`[ai] bash-end: ${resolvedCommand}`);
+                    if (tempFileStream)
+                        tempFileStream.end();
+                    const fullOutput = Buffer.concat(chunks).toString("utf-8");
+                    const truncation = truncateTail(fullOutput);
+                    let outputText = truncation.content || "(no output)";
+                    let details;
+                    if (truncation.truncated) {
+                        details = { truncation, fullOutputPath: tempFilePath };
+                        const startLine = truncation.totalLines - truncation.outputLines + 1;
+                        const endLine = truncation.totalLines;
+                        if (truncation.lastLinePartial) {
+                            outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}. Full output: ${tempFilePath}]`;
+                        }
+                        else if (truncation.truncatedBy === "lines") {
+                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+                        }
+                        else {
+                            outputText += `\n\n[Showing lines ${startLine}-${endLine} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+                        }
+                    }
+                    if (exitCode !== 0 && exitCode !== null) {
+                        outputText += `\n\nCommand exited with code ${exitCode}`;
+                        reject(new Error(outputText));
+                    }
+                    else {
+                        resolve({ content: [{ type: "text", text: outputText }], details });
+                    }
+                })
+                    .catch((err) => {
+                    console.log(`[ai] bash-end: ${resolvedCommand}`);
+                    if (tempFileStream)
+                        tempFileStream.end();
+                    const output = Buffer.concat(chunks).toString("utf-8");
+                    if (err.message === "aborted") {
+                        reject(new Error(output ? `${output}\n\nCommand aborted` : "Command aborted"));
+                    }
+                    else if (err.message.startsWith("timeout:")) {
+                        const secs = err.message.split(":")[1];
+                        reject(new Error(output
+                            ? `${output}\n\nCommand timed out after ${secs} seconds`
+                            : `Command timed out after ${secs} seconds`));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        },
+    };
+}
+export const bashTool = createBashTool(process.cwd());
+//# sourceMappingURL=bash.js.map

package/dist/tools/edit-diff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ */
+export declare function detectLineEnding(content: string): "\r\n" | "\n";
+export declare function normalizeToLF(text: string): string;
+export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
+export declare function normalizeForFuzzyMatch(text: string): string;
+export interface FuzzyMatchResult {
+    found: boolean;
+    index: number;
+    matchLength: number;
+    usedFuzzyMatch: boolean;
+    contentForReplacement: string;
+}
+export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
+export declare function stripBom(content: string): {
+    bom: string;
+    text: string;
+};
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): {
+    diff: string;
+    firstChangedLine: number | undefined;
+};
+//# sourceMappingURL=edit-diff.d.ts.map

package/dist/tools/edit-diff.js

@@ -0,0 +1,136 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ */
+import * as Diff from "diff";
+export function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    if (lfIdx === -1)
+        return "\n";
+    if (crlfIdx === -1)
+        return "\n";
+    return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+export function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+export function normalizeForFuzzyMatch(text) {
+    return text
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+export function fuzzyFindText(content, oldText) {
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent,
+    };
+}
+export function stripBom(content) {
+    return content.startsWith("\uFEFF")
+        ? { bom: "\uFEFF", text: content.slice(1) }
+        : { bom: "", text: content };
+}
+export function generateDiffString(oldContent, newContent, contextLines = 4) {
+    const parts = Diff.diffLines(oldContent, newContent);
+    const output = [];
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const maxLineNum = Math.max(oldLines.length, newLines.length);
+    const lineNumWidth = String(maxLineNum).length;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    let firstChangedLine;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const raw = part.value.split("\n");
+        if (raw[raw.length - 1] === "") {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            firstChangedLine ??= newLineNum;
+            for (const line of raw) {
+                if (part.added) {
+                    output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            if (lastWasChange || nextPartIsChange) {
+                let linesToShow = raw;
+                let skipStart = 0;
+                let skipEnd = 0;
+                if (!lastWasChange) {
+                    skipStart = Math.max(0, raw.length - contextLines);
+                    linesToShow = raw.slice(skipStart);
+                }
+                if (!nextPartIsChange && linesToShow.length > contextLines) {
+                    skipEnd = linesToShow.length - contextLines;
+                    linesToShow = linesToShow.slice(0, contextLines);
+                }
+                if (skipStart > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skipStart;
+                    newLineNum += skipStart;
+                }
+                for (const line of linesToShow) {
+                    output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                if (skipEnd > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skipEnd;
+                    newLineNum += skipEnd;
+                }
+            }
+            else {
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join("\n"), firstChangedLine };
+}
+//# sourceMappingURL=edit-diff.js.map

package/dist/tools/edit.d.ts

@@ -0,0 +1,28 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { type Static } from "@sinclair/typebox";
+declare const editSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    oldText: import("@sinclair/typebox").TString;
+    newText: import("@sinclair/typebox").TString;
+}>;
+export type EditToolInput = Static<typeof editSchema>;
+export interface EditToolDetails {
+    diff: string;
+    firstChangedLine?: number;
+}
+export interface EditOperations {
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    operations?: EditOperations;
+}
+export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
+export declare const editTool: AgentTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    oldText: import("@sinclair/typebox").TString;
+    newText: import("@sinclair/typebox").TString;
+}>, any>;
+export {};
+//# sourceMappingURL=edit.d.ts.map

package/dist/tools/edit.js

@@ -0,0 +1,78 @@
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+import { detectLineEnding, fuzzyFindText, generateDiffString, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { resolveToCwd, validatePathWithinCwd } from "./path-utils.js";
+import { withAbortSignal } from "./tool-helpers.js";
+const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+    oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+    newText: Type.String({ description: "New text to replace the old text with" }),
+});
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+};
+export function createEditTool(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: "edit",
+        label: "edit",
+        description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+        parameters: editSchema,
+        execute: async (_toolCallId, { path, oldText, newText }, signal) => {
+            const absolutePath = resolveToCwd(path, cwd);
+            validatePathWithinCwd(absolutePath, cwd);
+            return withAbortSignal(signal, async (isAborted) => {
+                try {
+                    await ops.access(absolutePath);
+                }
+                catch {
+                    throw new Error(`File not found: ${path}`);
+                }
+                if (isAborted())
+                    return { content: [], details: undefined };
+                const buffer = await ops.readFile(absolutePath);
+                const rawContent = buffer.toString("utf-8");
+                if (isAborted())
+                    return { content: [], details: undefined };
+                const { bom, text: content } = stripBom(rawContent);
+                const originalEnding = detectLineEnding(content);
+                const normalizedContent = normalizeToLF(content);
+                const normalizedOldText = normalizeToLF(oldText);
+                const normalizedNewText = normalizeToLF(newText);
+                const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+                if (!matchResult.found) {
+                    throw new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`);
+                }
+                const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+                const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+                const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+                if (occurrences > 1) {
+                    throw new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`);
+                }
+                if (isAborted())
+                    return { content: [], details: undefined };
+                const baseContent = matchResult.contentForReplacement;
+                const newContent = baseContent.substring(0, matchResult.index) +
+                    normalizedNewText +
+                    baseContent.substring(matchResult.index + matchResult.matchLength);
+                if (baseContent === newContent) {
+                    throw new Error(`No changes made to ${path}. The replacement produced identical content.`);
+                }
+                const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                await ops.writeFile(absolutePath, finalContent);
+                if (isAborted())
+                    return { content: [], details: undefined };
+                const diffResult = generateDiffString(baseContent, newContent);
+                return {
+                    content: [{ type: "text", text: `Successfully replaced text in ${path}.` }],
+                    details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+                };
+            });
+        },
+    };
+}
+export const editTool = createEditTool(process.cwd());
+//# sourceMappingURL=edit.js.map

package/dist/tools/find.d.ts

@@ -0,0 +1,31 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { type Static } from "@sinclair/typebox";
+import { type TruncationResult } from "./truncate.js";
+declare const findSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type FindToolInput = Static<typeof findSchema>;
+export interface FindToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+}
+export interface FindOperations {
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    glob: (pattern: string, cwd: string, options: {
+        ignore: string[];
+        limit: number;
+    }) => Promise<string[]> | string[];
+}
+export interface FindToolOptions {
+    operations?: FindOperations;
+}
+export declare function createFindTool(cwd: string, options?: FindToolOptions): AgentTool<typeof findSchema>;
+export declare const findTool: AgentTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};
+//# sourceMappingURL=find.d.ts.map

package/dist/tools/find.js

@@ -0,0 +1,117 @@
+import { Type } from "@sinclair/typebox";
+import { existsSync } from "fs";
+import os from "node:os";
+import path from "path";
+import { globSync } from "glob";
+import { resolveToCwd, validatePathWithinCwd } from "./path-utils.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+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,
+    glob: async (pattern, searchCwd, { ignore, limit }) => {
+        const results = [];
+        try {
+            const found = globSync(pattern, {
+                cwd: searchCwd,
+                dot: true,
+                ignore: ["**/node_modules/**", "**/.git/**", ...ignore],
+                mark: false,
+            });
+            for (let i = 0; i < Math.min(found.length, limit); i++) {
+                results.push(path.join(searchCwd, found[i]));
+            }
+        }
+        catch {
+            // return empty on error
+        }
+        return results;
+    },
+};
+export function createFindTool(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. Output truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB.`,
+        parameters: findSchema,
+        execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                const onAbort = () => reject(new Error("Operation aborted"));
+                signal?.addEventListener("abort", onAbort, { once: true });
+                void (async () => {
+                    try {
+                        const searchPath = resolveToCwd(searchDir ?? ".", cwd);
+                        const normalizedSearchPath = path.resolve(searchPath);
+                        const homeDir = path.resolve(os.homedir());
+                        if (normalizedSearchPath === homeDir) {
+                            reject(new Error("Access denied: Searching the home directory is not allowed. Use a subdirectory instead."));
+                            return;
+                        }
+                        validatePathWithinCwd(searchPath, cwd);
+                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+                        const ops = customOps ?? defaultFindOperations;
+                        if (!(await ops.exists(searchPath))) {
+                            reject(new Error(`Path not found: ${searchPath}`));
+                            return;
+                        }
+                        const results = await ops.glob(pattern, searchPath, {
+                            ignore: ["**/node_modules/**", "**/.git/**"],
+                            limit: effectiveLimit,
+                        });
+                        signal?.removeEventListener("abort", onAbort);
+                        if (results.length === 0) {
+                            resolve({
+                                content: [{ type: "text", text: "No files found matching pattern" }],
+                                details: undefined,
+                            });
+                            return;
+                        }
+                        const relativized = results.map((p) => {
+                            if (p.startsWith(searchPath + path.sep) || p.startsWith(searchPath + "/")) {
+                                return p.slice(searchPath.length + 1).replace(/\\/g, "/");
+                            }
+                            return path.relative(searchPath, p).replace(/\\/g, "/");
+                        });
+                        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(". ")}]`;
+                        resolve({
+                            content: [{ type: "text", text: resultOutput }],
+                            details: Object.keys(details).length > 0 ? details : undefined,
+                        });
+                    }
+                    catch (e) {
+                        signal?.removeEventListener("abort", onAbort);
+                        reject(e);
+                    }
+                })();
+            });
+        },
+    };
+}
+export const findTool = createFindTool(process.cwd());
+//# sourceMappingURL=find.js.map

package/dist/tools/grep.d.ts

@@ -0,0 +1,37 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { type Static } from "@sinclair/typebox";
+import { type TruncationResult } from "./truncate.js";
+declare const grepSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type GrepToolInput = Static<typeof grepSchema>;
+export interface GrepToolDetails {
+    truncation?: TruncationResult;
+    matchLimitReached?: number;
+    linesTruncated?: boolean;
+}
+export interface GrepOperations {
+    isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
+    readFile: (absolutePath: string) => Promise<string> | string;
+}
+export interface GrepToolOptions {
+    operations?: GrepOperations;
+}
+export declare function createGrepTool(cwd: string, options?: GrepToolOptions): AgentTool<typeof grepSchema>;
+export declare const grepTool: AgentTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};
+//# sourceMappingURL=grep.d.ts.map