@travisennis/acai 0.0.12 → 0.0.14

package/dist/subagents/index.js

@@ -1,231 +0,0 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { logger } from "../utils/logger.js";
-import { parseFrontMatter } from "../utils/yaml.js";
-const CONFIG_DIR_NAME = ".acai";
-const DEFAULT_TIMEOUT = 900;
-// Validation functions
-function validateSubagentName(name, fileName) {
-    // Check required field
-    if (!name) {
-        return { valid: false, error: "Name field is required" };
-    }
-    // Check length (1-64 characters)
-    if (name.length < 1 || name.length > 64) {
-        return { valid: false, error: "Name must be 1-64 characters long" };
-    }
-    // Check allowed characters (lowercase letters, numbers, hyphens)
-    if (!/^[a-z0-9-]+$/.test(name)) {
-        return {
-            valid: false,
-            error: "Name can only contain lowercase letters, numbers, and hyphens",
-        };
-    }
-    // Check no leading or trailing hyphens
-    if (name.startsWith("-") || name.endsWith("-")) {
-        return { valid: false, error: "Name cannot start or end with a hyphen" };
-    }
-    // Check no consecutive hyphens
-    if (name.includes("--")) {
-        return { valid: false, error: "Name cannot contain consecutive hyphens" };
-    }
-    // Check matches filename (without .md)
-    const expectedName = fileName.replace(/\.md$/, "");
-    if (name !== expectedName) {
-        return {
-            valid: false,
-            error: `Name "${name}" must match filename "${fileName}" (without .md)`,
-        };
-    }
-    return { valid: true };
-}
-function validateSubagentDescription(description) {
-    // Check required field
-    if (!description) {
-        return { valid: false, error: "Description field is required" };
-    }
-    // Check length (1-1024 characters)
-    if (description.length < 1 || description.length > 1024) {
-        return {
-            valid: false,
-            error: "Description must be 1-1024 characters long",
-        };
-    }
-    return { valid: true };
-}
-function validateSubagentTimeout(timeout) {
-    if (timeout === undefined) {
-        return { valid: true };
-    }
-    if (typeof timeout !== "number" || timeout < 1 || timeout > 3600) {
-        return {
-            valid: false,
-            error: "Timeout must be a number between 1 and 3600 seconds",
-        };
-    }
-    return { valid: true };
-}
-function parseFrontmatter(content) {
-    const { data, content: body } = parseFrontMatter(content);
-    // Type cast and validate required fields
-    const name = data["name"];
-    const description = data["description"];
-    // Set default empty values for optional fields
-    const frontmatter = {
-        name: name || "",
-        description: description || "",
-        model: data["model"] || undefined,
-        tools: data["tools"] || undefined,
-        timeout: data["timeout"] || undefined,
-    };
-    return { frontmatter, body };
-}
-async function loadSubagentsFromDir(dir, source) {
-    const subagents = [];
-    try {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            // Skip hidden files and directories
-            if (entry.name.startsWith(".")) {
-                continue;
-            }
-            // Only process .md files
-            if (!entry.isFile() || !entry.name.endsWith(".md")) {
-                continue;
-            }
-            const entryPath = join(dir, entry.name);
-            // Skip symbolic links to avoid infinite recursion
-            try {
-                const stats = await stat(entryPath);
-                if (stats.isSymbolicLink()) {
-                    continue;
-                }
-            }
-            catch {
-                // If we can't stat, skip it
-                continue;
-            }
-            try {
-                const content = await readFile(entryPath, "utf8");
-                const { frontmatter, body } = parseFrontmatter(content);
-                // Validate required fields
-                const nameValidation = validateSubagentName(frontmatter.name, entry.name);
-                if (!nameValidation.valid) {
-                    logger.warn(`Invalid subagent name in ${entryPath}: ${nameValidation.error}`);
-                    continue;
-                }
-                const descriptionValidation = validateSubagentDescription(frontmatter.description);
-                if (!descriptionValidation.valid) {
-                    logger.warn(`Invalid subagent description in ${entryPath}: ${descriptionValidation.error}`);
-                    continue;
-                }
-                const timeoutValidation = validateSubagentTimeout(frontmatter.timeout);
-                if (!timeoutValidation.valid) {
-                    logger.warn(`Invalid subagent timeout in ${entryPath}: ${timeoutValidation.error}`);
-                    continue;
-                }
-                // Parse tools if provided
-                let tools;
-                if (frontmatter.tools) {
-                    tools = frontmatter.tools
-                        .split(",")
-                        .map((t) => t.trim())
-                        .filter((t) => t.length > 0);
-                }
-                subagents.push({
-                    name: frontmatter.name,
-                    description: frontmatter.description,
-                    model: frontmatter.model,
-                    tools,
-                    timeout: frontmatter.timeout ?? DEFAULT_TIMEOUT,
-                    systemPrompt: body,
-                    filePath: entryPath,
-                    source,
-                });
-            }
-            catch (error) {
-                logger.warn(error, `Failed to load subagent from ${entryPath}:`);
-            }
-        }
-    }
-    catch (error) {
-        // Directory doesn't exist or can't be read
-        if (error.code !== "ENOENT") {
-            logger.error(error, `Error reading subagents directory ${dir}:`);
-        }
-    }
-    return subagents;
-}
-export async function loadSubagents() {
-    const subagentMap = new Map();
-    // Load from user directory (~/.acai/subagents)
-    const userDir = join(homedir(), CONFIG_DIR_NAME, "subagents");
-    for (const subagent of await loadSubagentsFromDir(userDir, "user")) {
-        subagentMap.set(subagent.name, subagent);
-    }
-    // Load from project directory (.acai/subagents) - overrides user
-    const projectDir = resolve(process.cwd(), CONFIG_DIR_NAME, "subagents");
-    for (const subagent of await loadSubagentsFromDir(projectDir, "project")) {
-        subagentMap.set(subagent.name, subagent);
-    }
-    return Array.from(subagentMap.values());
-}
-export async function getSubagent(name) {
-    const subagents = await loadSubagents();
-    return subagents.find((s) => s.name === name);
-}
-export function formatSubagentsForDescription(subagents) {
-    if (subagents.length === 0) {
-        return "  No subagents available";
-    }
-    const lines = subagents.map((subagent) => {
-        const toolsStr = subagent.tools
-            ? ` (tools: ${subagent.tools.join(", ")})`
-            : "";
-        return `  - ${subagent.name}: ${subagent.description}${toolsStr}`;
-    });
-    return lines.join("\n");
-}
-export function formatSubagentsForPrompt(subagents) {
-    if (subagents.length === 0) {
-        return "";
-    }
-    const lines = [
-        "## Subagents (Agent Tool)",
-        "",
-        "Use the Agent tool to delegate complex, multi-step tasks to specialized subagents. Subagents operate autonomously and return a single result.",
-        "",
-        "**When to use subagents:**",
-        "- Deep codebase research or architecture exploration",
-        "- Complex multi-file refactoring or implementation tasks",
-        "- Writing comprehensive tests across multiple files",
-        "- Creating detailed implementation plans",
-        "- Tasks requiring investigation across many files",
-        "",
-        "<available_subagents>",
-    ];
-    for (const subagent of subagents) {
-        lines.push("<subagent>");
-        lines.push("<name>");
-        lines.push(subagent.name);
-        lines.push("</name>");
-        lines.push("<description>");
-        lines.push(subagent.description);
-        lines.push("</description>");
-        if (subagent.tools && subagent.tools.length > 0) {
-            lines.push("<tools>");
-            lines.push(subagent.tools.join(", "));
-            lines.push("</tools>");
-        }
-        lines.push("</subagent>");
-    }
-    lines.push("</available_subagents>");
-    lines.push("");
-    lines.push("**Usage notes:**");
-    lines.push("- Subagents are stateless - provide all context in your prompt");
-    lines.push("- Be specific about what information you need returned");
-    lines.push("- Use longer timeouts for complex tasks (1800-3600 seconds)");
-    lines.push("- Launch multiple subagents concurrently for independent tasks");
-    return lines.join("\n");
-}

package/dist/terminal/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Terminal Interface Module
- *
- * Provides a user interface for interacting with Claude Code in the terminal.
- * Handles input/output, formatting, and display.
- */
-export { alert, getShell, isInteractive } from "./control.ts";
-export { emphasize, error, hr, info, success, warn } from "./formatting.ts";
-//# sourceMappingURL=index.d.ts.map

package/dist/terminal/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/terminal/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/terminal/index.js

@@ -1,8 +0,0 @@
-/**
- * Terminal Interface Module
- *
- * Provides a user interface for interacting with Claude Code in the terminal.
- * Handles input/output, formatting, and display.
- */
-export { alert, getShell, isInteractive } from "./control.js";
-export { emphasize, error, hr, info, success, warn } from "./formatting.js";

package/dist/tools/agent.d.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-import type { WorkspaceContext } from "../index.ts";
-import type { ToolExecutionOptions } from "./types.ts";
-export declare const AgentTool: {
-    name: "Agent";
-};
-declare const inputSchema: z.ZodObject<{
-    prompt: z.ZodString;
-    type: z.ZodString;
-    timeout: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const createAgentTools: (options: {
-    workspace: WorkspaceContext;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            prompt: z.ZodString;
-            type: z.ZodString;
-            timeout: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-    };
-    display: ({ prompt, type }: z.infer<typeof inputSchema>) => string;
-    execute: ({ prompt, type, timeout }: z.infer<typeof inputSchema>, { abortSignal }: ToolExecutionOptions) => Promise<string>;
-}>;
-export {};
-//# sourceMappingURL=agent.d.ts.map

package/dist/tools/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAMF,QAAA,MAAM,WAAW;;;;iBAOf,CAAC;AAsBH,eAAO,MAAM,gBAAgB,GAAU,SAAS;IAC9C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;gCAQoC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;yCAIjC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,mBACrC,oBAAoB,KACpC,OAAO,CAAC,MAAM,CAAC;EAkDnB,CAAC"}

package/dist/tools/agent.js

@@ -1,81 +0,0 @@
-import { z } from "zod";
-import { SubAgent } from "../agent/sub-agent.js";
-import { isSupportedModel } from "../models/providers.js";
-import { environmentInfo } from "../prompts/system-prompt.js";
-import { getSubagent, loadSubagents } from "../subagents/index.js";
-import style from "../terminal/style.js";
-export const AgentTool = {
-    name: "Agent",
-};
-async function getToolDescription() {
-    return "Delegate a task to a specialized subagent.";
-}
-const inputSchema = z.object({
-    prompt: z.string().describe("The task for the agent to perform"),
-    type: z.string().describe("The subagent type to use (matches subagent name)"),
-    timeout: z
-        .number()
-        .optional()
-        .describe("Override default timeout in seconds"),
-});
-async function loadSubAgentDefinition(type) {
-    const subagent = await getSubagent(type);
-    if (!subagent) {
-        const available = await loadSubagents();
-        const names = available.map((s) => s.name).join(", ");
-        throw new Error(`Unknown subagent type: "${type}". Available: ${names}`);
-    }
-    return {
-        model: subagent.model ?? "",
-        system: subagent.systemPrompt,
-        tools: subagent.tools,
-        timeout: subagent.timeout,
-    };
-}
-export const createAgentTools = async (options) => {
-    const description = await getToolDescription();
-    const toolDef = {
-        description,
-        inputSchema,
-    };
-    function display({ prompt, type }) {
-        return `${style.cyan(type)} - ${style.dim(prompt.substring(0, 25))}`;
-    }
-    async function execute({ prompt, type, timeout }, { abortSignal }) {
-        if (abortSignal?.aborted) {
-            throw new Error("Agent execution aborted");
-        }
-        const { model, system, tools, timeout: defaultTimeout, } = await loadSubAgentDefinition(type);
-        const systemPrompt = `${system}
-
-${await environmentInfo(options.workspace.primaryDir, options.workspace.allowedDirs)}`;
-        const subagent = new SubAgent({ workspace: options.workspace });
-        const effectiveTimeout = timeout ?? defaultTimeout;
-        try {
-            const result = await subagent.execute({
-                model: isSupportedModel(model) ? model : "opencode:minimax-m2.5",
-                system: systemPrompt,
-                prompt,
-                abortSignal,
-                allowedTools: tools,
-                timeout: effectiveTimeout,
-            });
-            return result;
-        }
-        catch (error) {
-            const err = error;
-            const message = err.message || "Unknown error";
-            if (message.includes("timed out") ||
-                err.name === "AbortError" ||
-                err.name === "TimeoutError") {
-                return `Agent failed: ${message}. The timeout was ${effectiveTimeout} seconds. Consider increasing the timeout or breaking the task into smaller subtasks.`;
-            }
-            return `Agent failed: ${message}`;
-        }
-    }
-    return {
-        toolDef,
-        display,
-        execute,
-    };
-};

package/dist/tools/directory-tree.d.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-import type { WorkspaceContext } from "../index.ts";
-import type { ToolExecutionOptions } from "./types.ts";
-export declare const DirectoryTreeTool: {
-    name: "DirectoryTree";
-};
-declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-    maxDepth: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-}, z.core.$strip>;
-type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
-export declare const createDirectoryTreeTool: (options: {
-    workspace: WorkspaceContext;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            path: z.ZodString;
-            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-            maxDepth: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-        }, z.core.$strip>;
-    };
-    display({ path, maxDepth, maxResults }: DirectoryTreeInputSchema): string;
-    execute({ path, maxResults, maxDepth }: DirectoryTreeInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
-}>;
-export {};
-//# sourceMappingURL=directory-tree.d.ts.map

package/dist/tools/directory-tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAcf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,SAAS;IACrD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;4CAS2C,wBAAwB;4CAY9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}

package/dist/tools/directory-tree.js

@@ -1,154 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import style from "../terminal/style.js";
-import { toDisplayPath } from "../utils/filesystem/path-display.js";
-import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
-import ignore from "../utils/ignore.js";
-import { convertNullString } from "../utils/zod.js";
-const DEFAULT_ITEM_LIMIT = 500;
-const DEFAULT_DEPTH_LIMIT = 10;
-export const DirectoryTreeTool = {
-    name: "DirectoryTree",
-};
-const inputSchema = z.object({
-    path: z.string().describe("The path"),
-    maxResults: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .default(null)
-        .describe(`Maximum number of items (files + directories) to return. Set to 0 for no limit. (default: ${DEFAULT_ITEM_LIMIT})`),
-    maxDepth: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .default(null)
-        .describe(`Maximum recursion depth. Set to 0 for no limit. (default: ${DEFAULT_DEPTH_LIMIT})`),
-});
-export const createDirectoryTreeTool = async (options) => {
-    const { primaryDir, allowedDirs } = options.workspace;
-    const allowedDirectory = allowedDirs ?? [primaryDir];
-    return {
-        toolDef: {
-            description: "Show directory structure as a recursive tree. Use this to explore nested directories and understand the overall project structure. For a simple flat list of a single directory, use LS instead.",
-            inputSchema,
-        },
-        display({ path, maxDepth, maxResults }) {
-            const displayPath = toDisplayPath(path);
-            let display = `${style.cyan(displayPath)}`;
-            if (maxDepth || maxResults) {
-                const parts = [];
-                if (maxDepth)
-                    parts.push(`depth: ${maxDepth}`);
-                if (maxResults)
-                    parts.push(`max: ${maxResults}`);
-                display += ` (${parts.join(", ")})`;
-            }
-            return display;
-        },
-        async execute({ path, maxResults, maxDepth }, { abortSignal }) {
-            if (abortSignal?.aborted) {
-                throw new Error("Directory tree listing aborted");
-            }
-            const validPath = await validatePath(joinWorkingDir(path, primaryDir), allowedDirectory, { abortSignal });
-            if (abortSignal?.aborted) {
-                throw new Error("Directory tree listing aborted before tree generation");
-            }
-            const treeResult = await directoryTree(validPath, {
-                maxResults: maxResults ?? DEFAULT_ITEM_LIMIT,
-                maxDepth: maxDepth ?? DEFAULT_DEPTH_LIMIT,
-            });
-            return treeResult.tree;
-        },
-    };
-};
-/**
- * Generates the indentation string for a given level in the directory tree.
- * @param level - The current level in the directory tree.
- * @param isLast - Indicates if the current item is the last in its parent directory.
- * @returns The indentation string for the current level.
- */
-function getIndent(level, isLast) {
-    const indent = "│   ".repeat(Math.max(level - 1, 0));
-    return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
-}
-/**
- * Recursively generates a string representation of a directory tree.
- * @param dirPath - The path of the directory to generate the tree for.
- * @param ig - The ignore instance for filtering files.
- * @param level - The current level in the directory tree (default: 0).
- * @param options - Options for limiting results.
- * @returns A Promise that resolves to a string representation of the directory tree with counts.
- * @throws Will log an error if there's an issue reading the directory.
- */
-async function generateDirectoryTree(dirPath, ig, level = 0, options = {}) {
-    const name = path.basename(dirPath);
-    let output = `${getIndent(level, false)}${name}\n`;
-    let fileCount = 0;
-    let directoryCount = 1; // Count the current directory
-    let totalCount = 1; // Count the current directory
-    let isTruncated = false;
-    // Check maxDepth limit - when maxDepth is reached, we should indicate truncation
-    if (options.maxDepth !== null &&
-        options.maxDepth !== undefined &&
-        options.maxDepth > 0 &&
-        level >= options.maxDepth) {
-        // When maxDepth is reached, return with truncation flag set
-        return {
-            tree: output,
-            fileCount: 0,
-            directoryCount: 1, // Count the current directory
-            totalCount: 1, // Count the current directory
-            isTruncated: true, // Set truncation flag when depth limit is reached
-        };
-    }
-    const items = await fs.readdir(dirPath);
-    const filteredItems = ig.filter(items);
-    for (let i = 0; i < filteredItems.length; i++) {
-        // Check maxResults limit BEFORE processing each item to ensure strict adherence to limits
-        if (options.maxResults !== null &&
-            options.maxResults !== undefined &&
-            options.maxResults > 0 &&
-            totalCount >= options.maxResults) {
-            isTruncated = true;
-            break;
-        }
-        const item = filteredItems[i] ?? "";
-        const itemPath = path.join(dirPath, item);
-        const isLast = i === filteredItems.length - 1;
-        const stats = await fs.stat(itemPath);
-        if (stats.isDirectory()) {
-            const subTreeResult = await generateDirectoryTree(itemPath, ig, level + 1, options);
-            output += subTreeResult.tree;
-            fileCount += subTreeResult.fileCount;
-            directoryCount += subTreeResult.directoryCount;
-            totalCount += subTreeResult.totalCount;
-            // Propagate truncation from subtree results
-            if (subTreeResult.isTruncated) {
-                isTruncated = true;
-            }
-        }
-        else {
-            output += `${getIndent(level + 1, isLast)}${item}\n`;
-            fileCount += 1;
-            totalCount += 1;
-        }
-    }
-    return { tree: output, fileCount, directoryCount, totalCount, isTruncated };
-}
-async function directoryTree(dirPath, options = {}) {
-    let ig;
-    try {
-        const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
-        ig = ignore().add(ignoreFile.toString()).add(".git");
-    }
-    catch (_error) {
-        // If .gitignore doesn't exist, create basic ignore with just .git
-        ig = ignore().add(".git");
-    }
-    const result = await generateDirectoryTree(dirPath, ig, 0, options);
-    return {
-        tree: result.tree.trim(),
-        fileCount: result.fileCount,
-        directoryCount: result.directoryCount,
-        totalCount: result.totalCount,
-        isTruncated: result.isTruncated,
-    };
-}

package/dist/tools/glob.d.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import type { ToolExecutionOptions } from "./types.ts";
-export declare const GlobTool: {
-    name: "Glob";
-};
-export declare const inputSchema: z.ZodObject<{
-    patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
-    gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-    recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-    expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-    ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
-    cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
-    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-}, z.core.$strip>;
-type GlobInputSchema = z.infer<typeof inputSchema>;
-export declare const createGlobTool: () => {
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-            path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
-            gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-            recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-            expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-            ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
-            cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
-            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-        }, z.core.$strip>;
-    };
-    display({ patterns, path }: GlobInputSchema): string;
-    execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }: GlobInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
-};
-export {};
-//# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6EvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBAkFtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAmBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAuCrB,CAAC"}