@travisennis/acai 0.0.7 → 0.0.9

package/dist/tools/agent.js

@@ -1,117 +0,0 @@
-import { generateText, stepCountIs } from "ai";
-import { z } from "zod";
-import { AiConfig } from "../models/ai-config.js";
-import { DirectoryTreeTool } from "./directory-tree.js";
-import { GlobTool } from "./glob.js";
-import { GrepTool } from "./grep.js";
-import { initCliTools } from "./index.js";
-import { ReadFileTool } from "./read-file.js";
-import { ReadMultipleFilesTool } from "./read-multiple-files.js";
-export const AgentTool = {
-    name: "agent",
-};
-const TOOLS = [
-    GrepTool.name,
-    GlobTool.name,
-    ReadFileTool.name,
-    ReadMultipleFilesTool.name,
-    DirectoryTreeTool.name,
-];
-function getToolDescription() {
-    const toolNames = TOOLS.join(", ");
-    return `Launch a new agent that has access to the following tools: ${toolNames}. This agent is specifically designed for file discovery and code search tasks. Use the ${AgentTool.name} tool when you need to search for files or code patterns across the codebase.
-
-Use cases:
-- Search for files matching specific patterns (e.g., "*.ts", "**/*.test.ts") using ${GlobTool.name}
-- Find code patterns or text within files using ${GrepTool.name}
-- Read specific files or multiple files using ${ReadFileTool.name} and ${ReadMultipleFilesTool.name}
-
-Important limitations:
-- This agent cannot execute shell commands or run external tools
-- It is focused purely on file discovery and content reading
-- For complex operations or command execution, use the main assistant directly
-
-Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-4. The agent's outputs should generally be trusted.`;
-}
-const inputSchema = z.object({
-    prompt: z.string().describe("The task for the agent to perform"),
-});
-export const createAgentTools = (options) => {
-    const { modelManager, tokenTracker, tokenCounter } = options;
-    const toolDef = {
-        description: getToolDescription(),
-        inputSchema,
-    };
-    async function* execute({ prompt }, { toolCallId, abortSignal }) {
-        if (abortSignal?.aborted) {
-            throw new Error("Agent execution aborted");
-        }
-        yield {
-            name: AgentTool.name,
-            event: "tool-init",
-            id: toolCallId,
-            data: "Invoking agent...",
-        };
-        yield {
-            name: AgentTool.name,
-            event: "tool-update",
-            id: toolCallId,
-            data: `## Prompt:\n\n${prompt}`,
-        };
-        try {
-            const modelConfig = modelManager.getModelMetadata("task-agent");
-            const aiConfig = new AiConfig({
-                modelMetadata: modelConfig,
-                prompt,
-            });
-            const { text, usage } = await generateText({
-                model: modelManager.getModel("task-agent"),
-                maxOutputTokens: aiConfig.maxOutputTokens(),
-                system: "You are a code search assistant that will be given a task that will require you to search a code base to find relevant code and files.",
-                prompt: prompt,
-                temperature: aiConfig.temperature(),
-                topP: aiConfig.topP(),
-                stopWhen: stepCountIs(30),
-                providerOptions: aiConfig.providerOptions(),
-                tools: (await initCliTools({
-                    tokenCounter,
-                    workspace: options.workspace,
-                })).toolDefs,
-                abortSignal: abortSignal,
-                // biome-ignore lint/style/useNamingConvention: third-party code
-                experimental_activeTools: [...TOOLS],
-            });
-            tokenTracker.trackUsage("task-agent", usage);
-            yield {
-                name: AgentTool.name,
-                event: "tool-update",
-                id: toolCallId,
-                data: `## Response:\n\n${text}`,
-            };
-            yield {
-                name: AgentTool.name,
-                event: "tool-completion",
-                id: toolCallId,
-                data: `Finished (${usage.totalTokens} tokens)`,
-            };
-            yield text;
-        }
-        catch (error) {
-            yield {
-                name: AgentTool.name,
-                event: "tool-error",
-                id: toolCallId,
-                data: error.message,
-            };
-            yield error.message;
-        }
-    }
-    return {
-        toolDef,
-        execute,
-    };
-};

package/dist/tools/batch.d.ts

@@ -1,34 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const BatchTool: {
-    name: "batch";
-};
-declare const inputSchema: z.ZodObject<{
-    calls: z.ZodArray<z.ZodObject<{
-        tool: z.ZodString;
-        arguments: z.ZodRecord<z.ZodAny, z.ZodAny>;
-        id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type BatchInputSchema = z.infer<typeof inputSchema>;
-type ToolExecutor = (args: Record<string, unknown>, options: ToolCallOptions) => AsyncGenerator<ToolResult> | Promise<string>;
-export declare const createBatchTool: ({ tokenCounter, executors, }: {
-    tokenCounter: TokenCounter;
-    executors: Map<string, ToolExecutor>;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            calls: z.ZodArray<z.ZodObject<{
-                tool: z.ZodString;
-                arguments: z.ZodRecord<z.ZodAny, z.ZodAny>;
-                id: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-    };
-    execute({ calls }: BatchInputSchema, { toolCallId, messages, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=batch.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../source/tools/batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAaF,QAAA,MAAM,WAAW;;;;;;iBAMf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACpD,KAAK,YAAY,GAAG,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,eAAe,KACrB,cAAc,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,eAAe,GAAU,8BAGnC;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtC;;;;;;;;;;;uBAQgB,gBAAgB,yCACY,eAAe,GACrD,cAAc,CAAC,UAAU,CAAC;EAkLhC,CAAC"}

package/dist/tools/batch.js

@@ -1,174 +0,0 @@
-import { z } from "zod";
-import { logger } from "../logger.js";
-import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
-export const BatchTool = {
-    name: "batch",
-};
-const toolCallSchema = z.object({
-    tool: z.string().describe("Name of the tool to execute"),
-    arguments: z
-        .record(z.any(), z.any())
-        .describe("Arguments to pass to the tool"),
-    id: z
-        .string()
-        .optional()
-        .describe("Optional ID for tracking this specific call"),
-});
-const inputSchema = z.object({
-    calls: z
-        .array(toolCallSchema)
-        .min(1)
-        .max(10)
-        .describe("Array of tool calls to execute in sequence"),
-});
-export const createBatchTool = async ({ tokenCounter, executors, }) => {
-    return {
-        toolDef: {
-            description: "Execute multiple tool calls in a single request. Reduces roundtrips by batching operations. Tools are executed sequentially in the order provided.",
-            inputSchema,
-        },
-        async *execute({ calls }, { toolCallId, messages, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("Batch execution aborted");
-                }
-                const totalCalls = calls.length;
-                yield {
-                    name: BatchTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `Starting batch execution of ${totalCalls} tool calls`,
-                };
-                const results = [];
-                for (let i = 0; i < calls.length; i++) {
-                    const call = calls[i];
-                    const { tool: toolName, arguments: args, id: callId } = call;
-                    const callNumber = i + 1;
-                    if (abortSignal?.aborted) {
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: "Batch execution aborted",
-                        });
-                        continue;
-                    }
-                    const executor = executors.get(toolName);
-                    if (!executor) {
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: `Unknown tool '${toolName}'`,
-                        });
-                        continue;
-                    }
-                    yield {
-                        name: BatchTool.name,
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: `[${callNumber}/${totalCalls}] ${style.cyan(toolName)}${callId ? ` (${callId})` : ""} ${style.dim(JSON.stringify(args).slice(0, 60))}...`,
-                    };
-                    try {
-                        const executorResult = executor(args, {
-                            toolCallId: callId || `${toolCallId}-${i}`,
-                            messages,
-                            abortSignal,
-                        });
-                        let toolOutput = "";
-                        // Handle both async generators and regular async functions
-                        if (typeof executorResult[Symbol.asyncIterator] === "function") {
-                            // It's an async generator
-                            const generator = executorResult;
-                            for await (const chunk of generator) {
-                                if (typeof chunk === "string") {
-                                    toolOutput += chunk;
-                                }
-                                else if (chunk.event === "tool-completion") {
-                                    // Capture completion message
-                                    toolOutput += chunk.data;
-                                }
-                            }
-                        }
-                        else {
-                            // It's a regular async function returning a string
-                            toolOutput = await executorResult;
-                        }
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "success",
-                            result: toolOutput,
-                        });
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        logger.error({ error, toolName, args }, "Batch tool execution failed");
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: errorMessage,
-                        });
-                        // Yield update for failed command
-                        yield {
-                            name: BatchTool.name,
-                            event: "tool-update",
-                            id: toolCallId,
-                            data: `[${callNumber}/${totalCalls}] ${style.red("✗")} ${style.cyan(toolName)} failed: ${errorMessage.slice(0, 100)}`,
-                        };
-                    }
-                }
-                // Format results as JSON
-                const jsonResults = JSON.stringify(results, null, 2);
-                try {
-                    const result = await manageTokenLimit(jsonResults, tokenCounter, "Batch", "Consider reducing the number of calls or using more specific tool calls");
-                    // Create a more informative completion message
-                    const successful = results.filter((r) => r.status === "success").length;
-                    const failed = results.filter((r) => r.status === "error").length;
-                    let completionMessage = `Batch execution completed: ${successful}/${totalCalls} successful`;
-                    if (failed > 0) {
-                        const failedTools = results
-                            .filter((r) => r.status === "error")
-                            .map((r) => `${r.tool}${r.id ? ` (${r.id})` : ""}`)
-                            .join(", ");
-                        completionMessage += `, ${failed} failed: ${failedTools}`;
-                    }
-                    completionMessage += ` (${result.tokenCount} tokens)`;
-                    yield {
-                        name: BatchTool.name,
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: completionMessage,
-                    };
-                    yield result.content;
-                }
-                catch (error) {
-                    if (error instanceof TokenLimitExceededError) {
-                        yield {
-                            name: BatchTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: error.message,
-                        };
-                        yield error.message;
-                        return;
-                    }
-                    throw error;
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error({ error }, "Batch tool failed");
-                yield {
-                    name: BatchTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMessage,
-                };
-                yield errorMessage;
-            }
-        },
-    };
-};

package/dist/tools/code-interpreter.d.ts

@@ -1,25 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const CodeInterpreterTool: {
-    name: "codeInterpreter";
-};
-declare const inputSchema: z.ZodObject<{
-    code: z.ZodString;
-    timeoutSeconds: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const createCodeInterpreterTool: ({ tokenCounter, }: {
-    tokenCounter: TokenCounter;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            code: z.ZodString;
-            timeoutSeconds: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>;
-    };
-    execute: ({ code, timeoutSeconds }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions) => AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=code-interpreter.d.ts.map

package/dist/tools/code-interpreter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-interpreter.d.ts","sourceRoot":"","sources":["../../source/tools/code-interpreter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,mBAAmB;;CAE/B,CAAC;AAmBF,QAAA,MAAM,WAAW;;;iBASf,CAAC;AAEH,eAAO,MAAM,yBAAyB,GAAU,mBAE7C;IACD,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;wCAO6B,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACxB,eAAe,KAC3C,cAAc,CAAC,UAAU,CAAC;EAoL9B,CAAC"}

package/dist/tools/code-interpreter.js

@@ -1,183 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import process from "node:process";
-import { z } from "zod";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
-export const CodeInterpreterTool = {
-    name: "codeInterpreter",
-};
-const toolDescription = `Executes Typescript code in a separate Node.js process using Node's Permission Model. 
-
-⚠️ **IMPORTANT**: This tool uses ES Modules (ESM) only.
-- Use \`import\` statements, NOT \`require()\`
-- Examples: \`import fs from 'node:fs'\` NOT \`const fs = require('fs')\`
-- Add file extensions for relative imports: \`import { utils } from './utils.js'\`
-
-These scripts are run in the \`${process.cwd()}/.acai-ci-tmp\`. You can import project source files using relative paths from the project root with .ts extensions:
-
-\`\`\` typescript
-import { functionName } from '../source/path/to/module.ts';
-\`\`\`
-
-The interpreter supports ES Modules with TypeScript files directly.
-
-Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
-const inputSchema = z.object({
-    code: z.string().describe("The Typescript code to be executed."),
-    timeoutSeconds: z
-        .number()
-        .int()
-        .min(1)
-        .max(60)
-        .nullable()
-        .describe("Execution timeout in seconds (1-60). Default 5."),
-});
-export const createCodeInterpreterTool = async ({ tokenCounter, }) => {
-    const toolDef = {
-        description: toolDescription,
-        inputSchema,
-    };
-    async function* execute({ code, timeoutSeconds }, { toolCallId, abortSignal }) {
-        // Check if execution has been aborted
-        if (abortSignal?.aborted) {
-            throw new Error("Code interpretation aborted");
-        }
-        const workingDirectory = process.cwd();
-        const lines = code.split("\n");
-        try {
-            yield {
-                name: CodeInterpreterTool.name,
-                event: "tool-init",
-                id: toolCallId,
-                data: `Executing ${lines.length} lines of code.`,
-            };
-            if (code.trim().length === 0) {
-                throw new Error("No code provided");
-            }
-            if (abortSignal?.aborted) {
-                throw new Error("Code interpretation aborted before execution");
-            }
-            const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
-            const tmpBase = join(workingDirectory, ".acai-ci-tmp");
-            await mkdir(tmpBase, { recursive: true });
-            const ext = ".ts";
-            const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
-            await writeFile(scriptPath, code, { encoding: "utf8" });
-            const args = [
-                "--permission",
-                `--allow-fs-read=${workingDirectory}`,
-                `--allow-fs-write=${workingDirectory}`,
-                "--allow-net",
-                scriptPath,
-            ];
-            const child = spawn(process.execPath, args, {
-                cwd: workingDirectory,
-                // do not rely solely on spawn's timeout; we implement manual timeout below
-                stdio: "pipe",
-                env: Object.assign({}, process.env, {
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    NO_COLOR: "true",
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    NODE_OPTIONS: "",
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    ACAI_CODE_INTERPRETER: "true",
-                }),
-            });
-            // Handle abort signal by killing the child process
-            if (abortSignal) {
-                const abortHandler = () => {
-                    try {
-                        child.kill("SIGKILL");
-                    }
-                    catch { }
-                    throw new Error("Code interpretation aborted during execution");
-                };
-                abortSignal.addEventListener("abort", abortHandler);
-            }
-            let stdout = "";
-            let stderr = "";
-            let timedOut = false;
-            const timer = setTimeout(() => {
-                timedOut = true;
-                try {
-                    child.kill("SIGKILL");
-                }
-                catch { }
-            }, timeoutMs);
-            child.stdout.setEncoding("utf8");
-            child.stderr.setEncoding("utf8");
-            child.stdout.on("data", (chunk) => {
-                stdout += String(chunk);
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += String(chunk);
-            });
-            const completed = await new Promise((resolve, reject) => {
-                child.on("error", (err) => reject(err));
-                child.on("close", (code, signal) => resolve({ code, signal }));
-            });
-            clearTimeout(timer);
-            // Cleanup temp file/directory
-            await rm(scriptPath, { force: true });
-            await rm(tmpBase, { force: true, recursive: true });
-            if (timedOut) {
-                throw new Error("Script timed out");
-            }
-            if (completed.code === null) {
-                throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
-            }
-            if (completed.code !== 0) {
-                const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
-                throw new Error(message);
-            }
-            const result = {
-                stdout: stdout.trim(),
-                stderr: stderr.trim(),
-                exitCode: completed.code ?? -1,
-            };
-            const resultJson = JSON.stringify(result, null, 2);
-            try {
-                const managedResult = await manageTokenLimit(resultJson, tokenCounter, "CodeInterpreter", "Reduce script complexity or output size");
-                yield {
-                    name: CodeInterpreterTool.name,
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: `Completed successfully${managedResult.tokenCount > 0 ? ` (${managedResult.tokenCount} tokens)` : ""}`,
-                };
-                yield managedResult.content;
-            }
-            catch (error) {
-                if (error instanceof TokenLimitExceededError) {
-                    yield {
-                        name: CodeInterpreterTool.name,
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: error.message,
-                    };
-                    yield error.message;
-                    return;
-                }
-                throw error;
-            }
-        }
-        catch (err) {
-            const errorMessage = err.name === "ETIMEDOUT" ||
-                err.message.includes("timed out")
-                ? "Script timed out"
-                : err.message;
-            yield {
-                name: CodeInterpreterTool.name,
-                event: "tool-error",
-                id: toolCallId,
-                data: errorMessage,
-            };
-            yield errorMessage;
-        }
-    }
-    return {
-        toolDef,
-        execute,
-    };
-};

package/dist/tools/delete-file.d.ts

@@ -1,24 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { ToolResult } from "./types.ts";
-export declare const DeleteFileTool: {
-    name: "deleteFile";
-};
-declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strip>;
-type DeleteFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createDeleteFileTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strip>;
-    };
-    execute({ path: userPath }: DeleteFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=delete-file.d.ts.map

package/dist/tools/delete-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../source/tools/delete-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAU,8BAGxC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;gCAUyB,qBAAqB,+BACZ,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAmEhC,CAAC"}

package/dist/tools/delete-file.js

@@ -1,77 +0,0 @@
-import { existsSync } from "node:fs";
-import fs from "node:fs/promises";
-import { z } from "zod";
-import { config } from "../config.js";
-import { clearProjectStatusCache } from "../repl/project-status-line.js";
-import style from "../terminal/style.js";
-import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
-export const DeleteFileTool = {
-    name: "deleteFile",
-};
-const inputSchema = z.object({
-    path: z.string().describe("Absolute path to the file to delete"),
-});
-export const createDeleteFileTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
-    return {
-        toolDef: {
-            description: "Delete a file permanently. Only deletes files within allowed directories.",
-            inputSchema,
-        },
-        async *execute({ path: userPath }, { toolCallId, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("File deletion aborted");
-                }
-                yield {
-                    name: DeleteFileTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(userPath)}`,
-                };
-                const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { abortSignal });
-                // Check if file is read-only
-                const projectConfig = await config.getConfig();
-                validateFileNotReadOnly(filePath, projectConfig, workingDir);
-                // Check if file exists before attempting delete
-                if (!existsSync(filePath)) {
-                    throw new Error(`File not found: ${filePath}`);
-                }
-                // Pre-check for stat
-                if (abortSignal?.aborted) {
-                    throw new Error("File deletion aborted before stat");
-                }
-                // Ensure it's a file, not a directory
-                const stats = await fs.stat(filePath);
-                if (stats.isDirectory()) {
-                    throw new Error(`Path is a directory, not a file: ${filePath}`);
-                }
-                // Pre-side-effect check
-                if (abortSignal?.aborted) {
-                    throw new Error("File deletion aborted before unlink");
-                }
-                // Delete the file with signal
-                await fs.unlink(filePath);
-                yield {
-                    name: DeleteFileTool.name,
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: "File deleted",
-                };
-                // Clear project status cache since file operations change git status
-                clearProjectStatusCache();
-                yield `Successfully deleted ${filePath}`;
-            }
-            catch (error) {
-                const errorMessage = error.message;
-                yield {
-                    name: DeleteFileTool.name,
-                    id: toolCallId,
-                    event: "tool-error",
-                    data: errorMessage,
-                };
-                yield errorMessage;
-            }
-        },
-    };
-};

package/dist/tools/dynamic-tool-parser.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-declare const toolMetadataSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    parameters: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        type: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-        }>;
-        description: z.ZodString;
-        required: z.ZodDefault<z.ZodBoolean>;
-        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-    }, z.core.$strip>>;
-    needsApproval: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
-export declare function parseToolMetadata(output: string): ToolMetadata;
-export {};
-//# sourceMappingURL=dynamic-tool-parser.d.ts.map

package/dist/tools/dynamic-tool-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic-tool-parser.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D"}