min-agent 0.5.1 → 0.6.0

package/dist/tools/bash.js

@@ -1,231 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { spawn } from "child_process";
-import path from "path";
-import { confirm, isDangerousCommand, isAutoApprove } from "../confirm.js";
-import { writeFullToolOutput } from "../tool-output.js";
-import { planSandboxedSpawn } from "../sandbox.js";
-import { getEffectiveConfig } from "../config.js";
-const MAX_STREAM_BYTES = 200 * 1024;
-const MAX_OUTPUT_BYTES = 100_000;
-/** Default wall-clock limit so one hung command cannot stall the whole turn. */
-export const DEFAULT_BASH_TIMEOUT_MS = 10 * 60 * 1000;
-/** Resolve the timeout for a command: explicit > config > default. 0 disables. */
-export function resolveBashTimeout(explicit) {
-    if (typeof explicit === "number" && Number.isFinite(explicit) && explicit >= 0)
-        return Math.floor(explicit);
-    const configured = getEffectiveConfig().tools?.bashTimeoutMs;
-    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0)
-        return Math.floor(configured);
-    return DEFAULT_BASH_TIMEOUT_MS;
-}
-/** Track active child processes so they can be killed on abort (e.g. ESC). */
-const activeRuns = new Set();
-let sigintRegistered = false;
-/** Sandbox caveats are shown once per process to avoid spamming every command. */
-let sandboxWarningShown = false;
-/** Test hook: allow the sandbox caveat to be shown again. */
-export function resetSandboxWarningShown() {
-    sandboxWarningShown = false;
-}
-/**
- * Registered exactly once: Ctrl+C kills all active commands instead of leaking a handler per call.
- * When nothing is running, re-dispatch the signal so the process can exit normally
- * (single-shot mode must not swallow Ctrl+C).
- */
-function ensureSigintHandler() {
-    if (sigintRegistered)
-        return;
-    sigintRegistered = true;
-    const onSigint = () => {
-        if (activeRuns.size === 0) {
-            process.removeListener("SIGINT", onSigint);
-            sigintRegistered = false;
-            process.kill(process.pid, "SIGINT");
-            return;
-        }
-        for (const run of [...activeRuns]) {
-            interruptRun(run);
-        }
-    };
-    process.on("SIGINT", onSigint);
-}
-function interruptRun(run) {
-    run.killed = true;
-    run.settled = true;
-    if (run.timer)
-        clearTimeout(run.timer);
-    killProcess(run.proc.pid);
-    run.resolve(formatOutput(run) + "\n\n[Command interrupted by user.]");
-}
-/** Kill all active child processes spawned by the bash tool. */
-export function killActiveProcesses() {
-    for (const run of activeRuns) {
-        run.killed = true;
-        run.settled = true;
-        if (run.timer)
-            clearTimeout(run.timer);
-        killProcess(run.proc.pid);
-        run.resolve(formatOutput(run) + "\n\n[Command interrupted by user.]");
-    }
-    activeRuns.clear();
-}
-export const bashTool = tool({
-    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory (or `cwd` if specified). Commands are killed after 10 minutes by default; set `timeout` for anything expected to run longer (or shorter).",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            command: { type: "string", description: "The shell command to execute" },
-            timeout: {
-                type: "number",
-                description: "Timeout in milliseconds. Defaults to 600000 (10 minutes). Set a smaller value for quick commands or a larger one for long builds.",
-            },
-            cwd: {
-                type: "string",
-                description: "Working directory for the command (relative to the current directory or absolute)",
-            },
-        },
-        required: ["command"],
-    }),
-    execute: async ({ command, timeout, cwd }) => {
-        if (!isAutoApprove() && isDangerousCommand(command)) {
-            const approved = await confirm(`Execute dangerous command: ${command}`);
-            if (!approved)
-                return "Command rejected by user.";
-        }
-        return executeBash(command, timeout, cwd);
-    },
-});
-/** Shared bash execution engine (no permission prompt). Used by bashTool and the read-only variant. */
-export async function executeBash(command, timeout, cwd) {
-    ensureSigintHandler();
-    return new Promise((resolve) => {
-        const isWin = process.platform === "win32";
-        const resolvedCwd = cwd ? path.resolve(process.cwd(), cwd) : process.cwd();
-        const plan = planSandboxedSpawn(command, resolvedCwd, {
-            ...process.env,
-            ...(isWin ? { PYTHONIOENCODING: "utf-8" } : {}),
-        });
-        if ("error" in plan) {
-            resolve(plan.error);
-            return;
-        }
-        let notice = "";
-        if (plan.warning && !sandboxWarningShown) {
-            sandboxWarningShown = true;
-            notice = `${plan.warning}\n\n`;
-        }
-        const run = {
-            proc: undefined,
-            resolve: (value) => resolve(notice + value),
-            stdoutChunks: [],
-            stderrChunks: [],
-            killed: false,
-            settled: false,
-            stdoutTruncated: false,
-            stderrTruncated: false,
-        };
-        activeRuns.add(run);
-        const proc = spawn(plan.file, plan.args, {
-            shell: plan.shell,
-            cwd: plan.cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-            detached: process.platform !== "win32",
-            env: plan.env,
-        });
-        run.proc = proc;
-        const collect = (chunks, truncated) => (chunk) => {
-            const total = chunks.reduce((sum, c) => sum + c.byteLength, 0);
-            if (total >= MAX_STREAM_BYTES) {
-                run[truncated] = true;
-                return;
-            }
-            chunks.push(chunk);
-        };
-        proc.stdout?.on("data", collect(run.stdoutChunks, "stdoutTruncated"));
-        proc.stderr?.on("data", collect(run.stderrChunks, "stderrTruncated"));
-        // Timeout kill (explicit value, config default, or the 10 minute fallback)
-        const effectiveTimeout = resolveBashTimeout(timeout);
-        if (effectiveTimeout > 0) {
-            run.timer = setTimeout(() => {
-                run.killed = true;
-                run.settled = true;
-                killProcess(proc.pid);
-                run.resolve(formatOutput(run) +
-                    `\n\n[Command timed out after ${effectiveTimeout}ms and was killed. Retry with a larger timeout if needed.]`);
-            }, effectiveTimeout);
-        }
-        proc.on("close", (code) => {
-            activeRuns.delete(run);
-            if (run.timer)
-                clearTimeout(run.timer);
-            if (run.killed || run.settled)
-                return;
-            run.settled = true;
-            const output = formatOutput(run);
-            if (code === 0) {
-                run.resolve(output || "(no output)");
-            }
-            else {
-                run.resolve(`Exit code ${code}\n${output || "(no output)"}`);
-            }
-        });
-        proc.on("error", (err) => {
-            activeRuns.delete(run);
-            if (run.timer)
-                clearTimeout(run.timer);
-            if (run.killed || run.settled)
-                return;
-            run.settled = true;
-            run.resolve(`Error: ${err.message}`);
-        });
-    });
-}
-/** Merge stdout + stderr, saved to disk when too large for the response budget. */
-function formatOutput(run) {
-    const out = Buffer.concat(run.stdoutChunks).toString("utf-8").trim();
-    const err = Buffer.concat(run.stderrChunks).toString("utf-8").trim();
-    let text = out;
-    if (err)
-        text = text ? `${text}\n\n--- stderr ---\n${err}` : err;
-    if (run.stdoutTruncated || run.stderrTruncated) {
-        text += `\n\n[Output capped at ${MAX_STREAM_BYTES} bytes; the remainder was discarded.]`;
-    }
-    const total = Buffer.byteLength(text, "utf-8");
-    if (total <= MAX_OUTPUT_BYTES)
-        return text;
-    const filePath = writeFullToolOutput(text);
-    return `${truncateUtf8(text, MAX_OUTPUT_BYTES)}\n\nFull output saved to: ${filePath}`;
-}
-function truncateUtf8(text, maxBytes) {
-    const buf = Buffer.from(text, "utf-8");
-    const headLen = Math.floor(maxBytes * 0.5);
-    const tailLen = Math.floor(maxBytes * 0.1);
-    let h = headLen;
-    while (h > 0 && (buf[h] & 0xc0) === 0x80)
-        h--;
-    let t = buf.length - tailLen;
-    while (t < buf.length && (buf[t] & 0xc0) === 0x80)
-        t++;
-    return (buf.subarray(0, h).toString("utf-8") +
-        `\n\n...(truncated, ${buf.length} bytes total)...\n\n` +
-        buf.subarray(Math.max(t, h)).toString("utf-8"));
-}
-function killProcess(pid) {
-    if (!pid)
-        return;
-    try {
-        if (process.platform !== "win32") {
-            process.kill(-pid, "SIGTERM");
-            setTimeout(() => {
-                try {
-                    process.kill(-pid, "SIGKILL");
-                }
-                catch { }
-            }, 3000);
-        }
-        else {
-            process.kill(pid, "SIGTERM");
-        }
-    }
-    catch { }
-}

package/dist/tools/code_search.js

@@ -1,98 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { truncateToolOutput } from "../tool-output.js";
-import { getEffectiveSandboxPolicy, networkDeniedMessage } from "../sandbox.js";
-const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
-export const codeSearchTool = tool({
-    description: `Search and get relevant context for any programming task using Exa Code API.
-Provides high-quality, fresh context for libraries, SDKs, and APIs.
-Use this for ANY question or task related to programming — finding code examples, documentation, API references, and patterns.
-
-Usage:
-- Adjustable token count (1000-50000) for focused or comprehensive results
-- Default 5000 tokens for balanced context
-- Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware', 'Rust async trait implementation'`,
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            query: {
-                type: "string",
-                description: "Search query for APIs, libraries, SDKs. E.g. 'React useState hook examples', 'Express.js middleware'",
-            },
-            tokensNum: {
-                type: "number",
-                description: "Number of tokens to return (1000-50000). Default 5000. Use lower for focused queries, higher for comprehensive docs.",
-            },
-        },
-        required: ["query"],
-    }),
-    execute: async ({ query, tokensNum }) => {
-        if (getEffectiveSandboxPolicy().network === "deny")
-            return `Code search error: ${networkDeniedMessage()}`;
-        if (!process.env.EXA_API_KEY?.trim()) {
-            return "Code search error: EXA_API_KEY is not set. Configure it in your environment to enable code search.";
-        }
-        const tokens = Math.max(1000, Math.min(50000, tokensNum ?? 5000));
-        try {
-            const result = await callExaCode(query, tokens);
-            if (!result) {
-                return "No code snippets or documentation found. Try a different query, be more specific about the library or concept, or check spelling.";
-            }
-            return truncateToolOutput(result, { direction: "head" }).content;
-        }
-        catch (err) {
-            return `Code search error: ${err instanceof Error ? err.message : String(err)}`;
-        }
-    },
-});
-/**
- * Call Exa's MCP endpoint for code context.
- * Uses JSON-RPC over HTTP with SSE response format.
- */
-async function callExaCode(query, tokensNum) {
-    const body = JSON.stringify({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "tools/call",
-        params: {
-            name: "get_code_context_exa",
-            arguments: { query, tokensNum },
-        },
-    });
-    const response = await fetch(EXA_MCP_URL, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/event-stream",
-            ...(process.env.EXA_API_KEY ? { Authorization: `Bearer ${process.env.EXA_API_KEY}` } : {}),
-        },
-        body,
-        signal: AbortSignal.timeout(30000),
-    });
-    if (!response.ok) {
-        throw new Error(`Exa API returned ${response.status}`);
-    }
-    return await parseExaResponse(await response.text());
-}
-/** Parse either an SSE stream or a direct JSON body into the tool result text. */
-async function parseExaResponse(text) {
-    for (const line of text.split("\n")) {
-        if (!line.startsWith("data: "))
-            continue;
-        try {
-            const data = JSON.parse(line.slice(6));
-            const content = data?.result?.content?.[0]?.text;
-            if (content)
-                return content;
-        }
-        catch { }
-    }
-    // Try parsing as direct JSON response
-    try {
-        const data = JSON.parse(text);
-        const content = data?.result?.content?.[0]?.text;
-        if (content)
-            return content;
-    }
-    catch { }
-    return null;
-}

package/dist/tools/edit.js

@@ -1,68 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { readFile } from "fs/promises";
-import path from "path";
-import { confirm, isEditAutoApprove } from "../confirm.js";
-import { pathAccessError } from "../sandbox.js";
-import { atomicWriteFile } from "./atomic-file.js";
-export const editTool = tool({
-    description: "Edit a file by replacing a specific text block with new content. The oldText must match exactly (including whitespace and indentation). Use this for precise edits instead of rewriting entire files.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            filePath: { type: "string", description: "Path to the file to edit (relative to cwd or absolute)" },
-            oldText: { type: "string", description: "The exact text to find and replace (must match exactly)" },
-            newText: { type: "string", description: "The new text to replace it with" },
-        },
-        required: ["filePath", "oldText", "newText"],
-    }),
-    execute: async ({ filePath, oldText, newText }) => {
-        if (!oldText)
-            return "Error: oldText must not be empty";
-        if (oldText === newText)
-            return "No change: oldText equals newText";
-        const denied = pathAccessError(filePath, "write");
-        if (denied)
-            return `Error: ${denied}`;
-        const resolved = path.resolve(process.cwd(), filePath);
-        let content;
-        try {
-            content = await readFile(resolved, "utf-8");
-        }
-        catch (err) {
-            return `Error: cannot read ${filePath}: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        const occurrences = content.split(oldText).length - 1;
-        if (occurrences === 0) {
-            // Try to help: show nearby content
-            const lines = content.split("\n");
-            const searchLines = oldText.split("\n");
-            const firstLine = searchLines[0].trim();
-            const nearbyIdx = lines.findIndex((l) => l.includes(firstLine));
-            if (nearbyIdx >= 0) {
-                const context = lines.slice(Math.max(0, nearbyIdx - 1), nearbyIdx + 3).join("\n");
-                return `Error: oldText not found exactly. Found similar content near line ${nearbyIdx + 1}:\n${context}\n\nMake sure whitespace and indentation match exactly.`;
-            }
-            return `Error: oldText not found in ${filePath}. Make sure the text matches exactly including whitespace.`;
-        }
-        if (occurrences > 1) {
-            return `Error: oldText found ${occurrences} times in ${filePath}. Please provide more context to make the match unique.`;
-        }
-        // Confirm edit
-        if (!isEditAutoApprove()) {
-            const preview = (s) => (s.length > 80 ? s.slice(0, 80) + "..." : s);
-            const approved = await confirm(`Edit ${filePath}:\nreplace "${preview(oldText)}"\nwith "${preview(newText)}"`);
-            if (!approved)
-                return "Edit rejected by user.";
-        }
-        const updated = content.replace(oldText, newText);
-        try {
-            await atomicWriteFile(resolved, updated);
-        }
-        catch (err) {
-            return `Error: cannot write ${filePath}: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        const oldLines = oldText.split("\n").length;
-        const newLines = newText.split("\n").length;
-        return `Edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)`;
-    },
-});

package/dist/tools/explore.js

@@ -1,232 +0,0 @@
-import { tool, jsonSchema, streamText, stepCountIs } from "ai";
-import { resolveModel } from "../provider.js";
-import { executeBash } from "./bash.js";
-import { readTool } from "./read.js";
-import { globTool } from "./glob.js";
-import { grepTool } from "./grep.js";
-import { stripThinkingFromAssistantText } from "../assistant-stream.js";
-import { unwrapXmlSearchTags } from "../xml-search.js";
-import { truncateToolOutput } from "../tool-output.js";
-import { log } from "../logger.js";
-import { getEffectiveConfig } from "../config.js";
-function exploreSystem() {
-    return `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
-
-Your strengths:
-- Rapidly finding files using glob patterns
-- Searching code and text with powerful regex patterns
-- Reading and analyzing file contents
-
-Guidelines:
-- Use glob for broad file pattern matching
-- Use grep for searching file contents with regex
-- Use read when you know the specific file path
-- Use bash ONLY for read-only inspection (ls, find, cat, wc, head, tail, grep, git status/log/diff)
-- Adapt your search approach based on the thoroughness level specified
-- Return file paths as absolute paths in your final response
-- Do NOT create, modify, or delete any files
-- Do NOT run commands that change system state
-
-Complete the search request efficiently and report findings clearly.
-
-Working directory: ${process.cwd()}
-Platform: ${process.platform}`;
-}
-const EXPLORE_MAX_STEPS = 20;
-function resolveExploreSteps(explicit) {
-    const configured = getEffectiveConfig().agent?.exploreMaxSteps;
-    const value = explicit ?? configured ?? EXPLORE_MAX_STEPS;
-    return Number.isFinite(value) && value >= 1 ? Math.floor(value) : EXPLORE_MAX_STEPS;
-}
-export function createExploreTool(modelId, abortSignal, onUsage, context = {}) {
-    return tool({
-        description: `Deep codebase exploration agent. Use this to understand project structure, find files by patterns, search code for keywords, trace module relationships, or answer questions about the codebase.
-
-Specify thoroughness:
-- "quick": basic search, 1-3 tool calls
-- "medium": moderate exploration, follow references
-- "thorough": comprehensive analysis across multiple locations and naming conventions
-
-Examples:
-- "Find all API route handlers" (medium)
-- "How does the auth system work?" (thorough)
-- "Where is the database config?" (quick)`,
-        inputSchema: jsonSchema({
-            type: "object",
-            properties: {
-                query: { type: "string", description: "What to explore or find in the codebase" },
-                thoroughness: { type: "string", description: "Search depth: quick, medium, or thorough (default: medium)" },
-            },
-            required: ["query"],
-        }),
-        execute: async ({ query, thoroughness }) => {
-            const level = thoroughness ?? "medium";
-            console.error(`\x1b[90m  ┌─ Explore (${level}): ${query.slice(0, 60)}\x1b[0m`);
-            try {
-                const result = await runExploreAgent(query, level, modelId, abortSignal, context);
-                if (result.usage)
-                    onUsage?.(result.usage);
-                console.error(`\x1b[90m  └─ ✓ Done\x1b[0m`);
-                return truncateToolOutput(result.text, { direction: "tail" }).content;
-            }
-            catch (err) {
-                if (abortSignal?.aborted)
-                    return "Explore cancelled by user.";
-                log("error", `explore agent failed: ${err?.message ?? String(err)}`);
-                console.error(`\x1b[90m  └─ ✗ Failed: ${err.message}\x1b[0m`);
-                return `Explore error: ${err.message}`;
-            }
-        },
-    });
-}
-async function runExploreAgent(query, thoroughness, modelId, abortSignal, context = {}) {
-    const model = resolveModel(modelId);
-    // Read-only tools only
-    const tools = {
-        glob: globTool,
-        grep: grepTool,
-        read: readTool,
-        bash: readOnlyBashTool,
-    };
-    const prompt = `Thoroughness level: ${thoroughness}
-${thoroughness === "quick" ? "Do a quick search (1-3 tool calls max)." : ""}
-${thoroughness === "medium" ? "Do a moderate exploration, follow references if needed." : ""}
-${thoroughness === "thorough" ? "Do a comprehensive analysis. Check multiple locations, naming conventions, and cross-references." : ""}
-
-Task: ${query}`;
-    const messages = [{ role: "user", content: prompt }];
-    const controller = new AbortController();
-    const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;
-    const result = streamText({
-        model,
-        system: exploreSystem(),
-        messages,
-        tools,
-        stopWhen: stepCountIs(resolveExploreSteps(context.maxSteps)),
-        maxRetries: 2,
-        abortSignal: signal,
-        onError({ error }) {
-            log("warn", `explore step failed (will retry): ${String(error)}`);
-        },
-    });
-    let assistantText = "";
-    for await (const event of result.fullStream) {
-        switch (event.type) {
-            case "text-delta":
-                assistantText += event.text;
-                break;
-            case "tool-call":
-                console.error(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
-                if (context.shouldStop?.()) {
-                    log("warn", "explore agent stopped: parent budget reached");
-                    controller.abort();
-                    return {
-                        text: unwrapXmlSearchTags(stripThinkingFromAssistantText(assistantText)) +
-                            "\n\n[Explore stopped: run budget reached]",
-                    };
-                }
-                break;
-            case "error":
-                log("error", `explore stream error: ${String(event.error)}`);
-                controller.abort();
-                return {
-                    text: unwrapXmlSearchTags(stripThinkingFromAssistantText(assistantText)) || `[Explore error: ${event.error}]`,
-                };
-        }
-    }
-    let usage;
-    try {
-        usage = await result.usage;
-    }
-    catch { }
-    return {
-        text: unwrapXmlSearchTags(stripThinkingFromAssistantText(assistantText)) || "(explore agent produced no output)",
-        usage,
-    };
-}
-/* ── Read-only bash: white-listed commands only, no redirection / chaining ── */
-const READ_ONLY_BINS = new Set([
-    "ls",
-    "find",
-    "cat",
-    "wc",
-    "head",
-    "tail",
-    "grep",
-    "rg",
-    "tree",
-    "pwd",
-    "stat",
-    "du",
-    "file",
-    "which",
-    "echo",
-    "printf",
-    "sort",
-    "uniq",
-    "cut",
-    "tr",
-    "awk",
-    "sed",
-    "basename",
-    "dirname",
-    "realpath",
-    "env",
-    "printenv",
-    "git",
-]);
-const READ_ONLY_GIT_CMDS = new Set([
-    "status",
-    "log",
-    "diff",
-    "show",
-    "rev-parse",
-    "branch",
-    "remote",
-    "tag",
-    "ls-files",
-    "help",
-    "--version",
-    "version",
-]);
-/** True if the command only inspects state (no writes, redirection, pipes, or chaining). */
-export function isReadOnlyCommand(command) {
-    const trimmed = command.trim();
-    if (!trimmed)
-        return false;
-    if (/[<>|]|&&|;|`|\$\(/.test(trimmed))
-        return false;
-    const tokens = trimmed.split(/\s+/);
-    const bin = tokens[0].toLowerCase();
-    if (!READ_ONLY_BINS.has(bin))
-        return false;
-    if (bin === "git") {
-        const sub = tokens[1]?.toLowerCase();
-        if (!sub || !READ_ONLY_GIT_CMDS.has(sub))
-            return false;
-    }
-    if (bin === "find" && /\s-(delete|exec|ok|execdir)\b/.test(trimmed))
-        return false;
-    if ((bin === "sed" || bin === "awk" || bin === "perl") && /\s-i(\.[a-zA-Z0-9_-]+)?\b/.test(trimmed))
-        return false;
-    return true;
-}
-export const readOnlyBashTool = tool({
-    description: "Run a READ-ONLY shell command (ls, find, cat, wc, head, tail, grep, git status/log/diff, etc.). " +
-        "File modification, redirection, and command chaining are blocked.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            command: { type: "string", description: "The read-only shell command to execute" },
-            timeout: { type: "number", description: "Timeout in milliseconds" },
-            cwd: { type: "string", description: "Working directory (relative or absolute)" },
-        },
-        required: ["command"],
-    }),
-    execute: async ({ command, timeout, cwd }) => {
-        if (!isReadOnlyCommand(command)) {
-            return `Error: "${command.slice(0, 80)}" is not a read-only command. Allowed: ${[...READ_ONLY_BINS].join(", ")} (read-only git subcommands only).`;
-        }
-        return executeBash(command, timeout, cwd);
-    },
-});

package/dist/tools/glob.js

@@ -1,40 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { glob } from "glob";
-import { truncateToolOutput } from "../tool-output.js";
-import { pathAccessError } from "../sandbox.js";
-export const globTool = tool({
-    description: "Find files matching a glob pattern. Returns a list of file paths. Use this to discover project structure and find files.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            pattern: { type: "string", description: "Glob pattern to match (e.g. 'src/**/*.ts', '*.json')" },
-            cwd: { type: "string", description: "Directory to search in (defaults to working directory)" },
-        },
-        required: ["pattern"],
-    }),
-    execute: async ({ pattern, cwd }) => {
-        const denied = pathAccessError(cwd ?? ".", "read");
-        if (denied)
-            return `Error: ${denied}`;
-        try {
-            const matches = await glob(pattern, {
-                cwd: cwd ?? process.cwd(),
-                ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
-                nodir: true,
-            });
-            if (matches.length === 0)
-                return "No files found matching pattern";
-            let text;
-            if (matches.length > 100) {
-                text = matches.slice(0, 100).join("\n") + `\n\n... (${matches.length - 100} more files)`;
-            }
-            else {
-                text = matches.join("\n");
-            }
-            return truncateToolOutput(text, { direction: "head" }).content;
-        }
-        catch (err) {
-            return `Error: ${err.message}`;
-        }
-    },
-});