tarsk 0.4.4 → 0.4.6

package/dist/tools/edit.d.ts

@@ -1,28 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

package/dist/tools/grep.js

@@ -1,231 +0,0 @@
-import { createInterface } from "node:readline";
-import { Type } from "@sinclair/typebox";
-import { spawnProcess } from "../core/utils.js";
-import { readFileSync, statSync } from "fs";
-import path from "path";
-import { resolveBin } from "./resolve-bin.js";
-import { resolveToCwd, validatePathWithinCwd } from "./path-utils.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'" })),
-    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 before/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"),
-};
-export function createGrepTool(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 truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB. Long lines truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
-        parameters: grepSchema,
-        execute: async (_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit }, signal) => {
-            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();
-                    }
-                };
-                void (async () => {
-                    try {
-                        const rgPath = await resolveBin("rg");
-                        if (!rgPath) {
-                            settle(() => reject(new Error("ripgrep (rg) is not available. Install rg or add it to PATH.")));
-                            return;
-                        }
-                        const searchPath = resolveToCwd(searchDir ?? ".", cwd);
-                        validatePathWithinCwd(searchPath, 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 = spawnProcess(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 { text: truncatedText, wasTruncated } = truncateLine(sanitized);
-                                if (wasTruncated)
-                                    linesTruncated = true;
-                                const isMatchLine = current === lineNumber;
-                                if (isMatchLine) {
-                                    block.push(`${relativePath}:${current}: ${truncatedText}`);
-                                }
-                                else {
-                                    block.push(`${relativePath}-${current}- ${truncatedText}`);
-                                }
-                            }
-                            return block;
-                        };
-                        const matches = [];
-                        rl.on("line", (line) => {
-                            if (!line.trim() || matchCount >= effectiveLimit)
-                                return;
-                            try {
-                                const event = JSON.parse(line);
-                                if (event.type === "match") {
-                                    matchCount++;
-                                    const filePath = event.data?.path?.text;
-                                    const lineNumber = event.data?.line_number;
-                                    if (filePath != null && typeof lineNumber === "number") {
-                                        matches.push({ filePath, lineNumber });
-                                    }
-                                    if (matchCount >= effectiveLimit) {
-                                        matchLimitReached = true;
-                                        stopChild(true);
-                                    }
-                                }
-                            }
-                            catch {
-                                // ignore non-JSON lines
-                            }
-                        });
-                        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) {
-                                settle(() => reject(new Error(stderr.trim() || `ripgrep exited with code ${code}`)));
-                                return;
-                            }
-                            if (matchCount === 0) {
-                                settle(() => resolve({
-                                    content: [{ type: "text", text: "No matches found" }],
-                                    details: undefined,
-                                }));
-                                return;
-                            }
-                            for (const match of matches) {
-                                const block = await formatBlock(match.filePath, match.lineNumber);
-                                outputLines.push(...block);
-                            }
-                            const rawOutput = outputLines.join("\n");
-                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-                            let output = truncation.content;
-                            const details = {};
-                            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 {
-                        settle(() => reject(new Error("Error processing grep request")));
-                    }
-                })();
-            });
-        },
-    };
-}
-export const grepTool = createGrepTool(process.cwd());
-//# sourceMappingURL=grep.js.map

package/dist/tools/index.d.ts

@@ -1,93 +0,0 @@
-/**
- * Coding tools for the Pi agent (read, bash, edit, write, grep, find, ls).
- * Mirrors pi-mono-main/packages/coding-agent/src/core/tools.
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import type { Skill } from "@tarsk/shared";
-import { type BashToolOptions } from "./bash.js";
-import { type ReadToolOptions } from "./read.js";
-export type Tool = AgentTool<any>;
-/** Default tools for full access (read, bash, edit, write, ask_user, todo) - using process.cwd() */
-export declare const codingTools: Tool[];
-/** Read-only tools (read, grep, find, ls) - using process.cwd() */
-export declare const readOnlyTools: Tool[];
-/** All tools by name - using process.cwd() */
-export declare const allTools: {
-    read: AgentTool<import("@sinclair/typebox").TObject<{
-        path: import("@sinclair/typebox").TString;
-        offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    }>, any>;
-    bash: AgentTool<import("@sinclair/typebox").TObject<{
-        command: import("@sinclair/typebox").TString;
-        timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    }>, any>;
-    edit: AgentTool<import("@sinclair/typebox").TObject<{
-        path: import("@sinclair/typebox").TString;
-        oldText: import("@sinclair/typebox").TString;
-        newText: import("@sinclair/typebox").TString;
-    }>, any>;
-    write: AgentTool<import("@sinclair/typebox").TObject<{
-        path: import("@sinclair/typebox").TString;
-        content: import("@sinclair/typebox").TString;
-    }>, any>;
-    grep: 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>;
-    ast_grep: AgentTool<import("@sinclair/typebox").TObject<{
-        command: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"run">, import("@sinclair/typebox").TLiteral<"scan">]>;
-        pattern: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        lang: import("@sinclair/typebox").TString;
-        rule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    }>, any>;
-    find: 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>;
-    ls: AgentTool<import("@sinclair/typebox").TObject<{
-        path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    }>, any>;
-    ask_user: AgentTool<import("@sinclair/typebox").TObject<{
-        question: import("@sinclair/typebox").TString;
-        options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-        context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>, any>;
-};
-export type ToolName = keyof typeof allTools;
-/**
- * Tools options interface
- */
-export interface ToolsOptions {
-    read?: ReadToolOptions;
-    bash?: BashToolOptions;
-    skills?: Skill[];
-    threadId?: string;
-}
-/**
- * Create coding tools (read, bash, edit, write) configured for a specific working directory.
- * Optionally includes skill tools if skills are provided.
- * Optionally includes MCP tools if project path is provided.
- */
-export declare function createCodingTools(cwd: string, options?: ToolsOptions): Promise<Tool[]>;
-/**
- * Create read-only tools configured for a specific working directory.
- */
-export declare function createReadOnlyTools(cwd: string, options?: ToolsOptions): Tool[];
-/**
- * Create all tools configured for a specific working directory.
- */
-export declare function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool>;
-export { createSkillScriptTool, listSkillScripts } from "./skill-tool.js";
-export { createSkillReferenceTool, listSkillReferences } from "./skill-reference-tool.js";
-export { createAskUserTool, submitAnswer, cancelPendingQuestion } from "./ask-user.js";
-//# sourceMappingURL=index.d.ts.map