@travisennis/acai 0.0.4 → 0.0.6

package/dist/tools/advanced-edit-file.js

@@ -0,0 +1,281 @@
+import { execSync } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
+import { createTwoFilesPatch } from "diff";
+import { z } from "zod";
+import style from "../terminal/style.js";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+export const AdvancedEditFileTool = {
+    name: "advancedEditFile",
+};
+const inputSchema = z.object({
+    path: z.string().describe("The path of the file to edit."),
+    mode: z
+        .enum(["exact", "regex", "ast"])
+        .default("exact")
+        .describe("Editing mode: exact (literal text), regex (pattern matching), or ast (AST-aware)"),
+    operations: z.array(z.object({
+        type: z
+            .enum(["replace", "insert-before", "insert-after", "delete"])
+            .describe("Type of operation to perform"),
+        pattern: z
+            .string()
+            .describe("Pattern to match (text, regex, or AST pattern depending on mode)"),
+        replacement: z
+            .string()
+            .optional()
+            .describe("Replacement text (required for replace operations)"),
+        flags: z
+            .string()
+            .optional()
+            .describe("Regex flags for regex mode (e.g., 'g', 'i', 'm')"),
+    })),
+    astPattern: z
+        .string()
+        .optional()
+        .describe("AST-grep search pattern for AST mode (e.g., 'var $V = $VAL')"),
+    astReplacement: z
+        .string()
+        .optional()
+        .describe("AST-grep replacement pattern for AST mode (e.g., 'let $V = $VAL')"),
+    dryRun: z.boolean().default(false).describe("Show changes without writing"),
+});
+export const createAdvancedEditFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
+    return {
+        toolDef: {
+            description: "Advanced file editing with multiple modes: exact text matching, regex pattern matching, and AST-aware editing. " +
+                "Supports replace, insert-before, insert-after, and delete operations. AST mode requires ast-grep to be installed.",
+            inputSchema,
+        },
+        async *execute({ path, mode, operations, astPattern, astReplacement, dryRun, }, { toolCallId, abortSignal }) {
+            try {
+                if (abortSignal?.aborted) {
+                    throw new Error("File editing aborted");
+                }
+                yield {
+                    name: AdvancedEditFileTool.name,
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `${style.cyan(path)} (mode: ${mode})`,
+                };
+                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+                const result = await applyAdvancedFileEdits(validPath, mode, operations, astPattern, astReplacement, dryRun, abortSignal);
+                yield {
+                    name: AdvancedEditFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: `Applied ${operations.length} edits`,
+                };
+                yield result;
+            }
+            catch (error) {
+                yield {
+                    name: AdvancedEditFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield `Failed to edit file: ${error.message}`;
+            }
+        },
+    };
+};
+// file editing and diffing utilities
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+function createUnifiedDiff(originalContent, newContent, filepath = "file") {
+    // Ensure consistent line endings for diff
+    const normalizedOriginal = normalizeLineEndings(originalContent);
+    const normalizedNew = normalizeLineEndings(newContent);
+    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
+}
+function applyExactModeEdits(content, operations) {
+    let modifiedContent = content;
+    for (const op of operations) {
+        switch (op.type) {
+            case "replace": {
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for replace operation");
+                }
+                // Exact text replacement (global)
+                let currentIndex = 0;
+                let matchCount = 0;
+                while (currentIndex < modifiedContent.length) {
+                    const matchIndex = modifiedContent.indexOf(op.pattern, currentIndex);
+                    if (matchIndex === -1) {
+                        break;
+                    }
+                    matchCount++;
+                    modifiedContent =
+                        modifiedContent.slice(0, matchIndex) +
+                            op.replacement +
+                            modifiedContent.slice(matchIndex + op.pattern.length);
+                    currentIndex = matchIndex + op.replacement.length;
+                }
+                if (matchCount === 0) {
+                    throw new Error(`Pattern not found in content: ${op.pattern}`);
+                }
+                break;
+            }
+            case "insert-before": {
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for insert-before operation");
+                }
+                const beforeIndex = modifiedContent.indexOf(op.pattern);
+                if (beforeIndex === -1) {
+                    throw new Error(`Pattern not found for insert-before: ${op.pattern}`);
+                }
+                modifiedContent =
+                    modifiedContent.slice(0, beforeIndex) +
+                        op.replacement +
+                        "\n" +
+                        modifiedContent.slice(beforeIndex);
+                break;
+            }
+            case "insert-after": {
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for insert-after operation");
+                }
+                const afterIndex = modifiedContent.indexOf(op.pattern);
+                if (afterIndex === -1) {
+                    throw new Error(`Pattern not found for insert-after: ${op.pattern}`);
+                }
+                const insertPosition = afterIndex + op.pattern.length;
+                modifiedContent =
+                    modifiedContent.slice(0, insertPosition) +
+                        "\n" +
+                        op.replacement +
+                        modifiedContent.slice(insertPosition);
+                break;
+            }
+            case "delete": {
+                // For delete operations, use line-based approach to handle newlines properly
+                const lines = modifiedContent.split("\n");
+                const filteredLines = lines.filter((line) => !line.includes(op.pattern));
+                if (filteredLines.length === lines.length) {
+                    throw new Error(`Pattern not found for delete: ${op.pattern}`);
+                }
+                modifiedContent = filteredLines.join("\n");
+                break;
+            }
+        }
+    }
+    return modifiedContent;
+}
+function applyRegexModeEdits(content, operations) {
+    let modifiedContent = content;
+    for (const op of operations) {
+        const flags = op.flags || "g";
+        const regex = new RegExp(op.pattern, flags);
+        switch (op.type) {
+            case "replace":
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for replace operation");
+                }
+                modifiedContent = modifiedContent.replace(regex, op.replacement);
+                break;
+            case "insert-before":
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for insert-before operation");
+                }
+                modifiedContent = modifiedContent.replace(regex, `${op.replacement}\n$&`);
+                break;
+            case "insert-after":
+                if (!op.replacement) {
+                    throw new Error("Replacement text required for insert-after operation");
+                }
+                modifiedContent = modifiedContent.replace(regex, `$&\n${op.replacement}`);
+                break;
+            case "delete":
+                modifiedContent = modifiedContent.replace(regex, "");
+                break;
+        }
+    }
+    return modifiedContent;
+}
+function applyAstModeEdits(filePath, astPattern, astReplacement, dryRun) {
+    if (!astPattern || !astReplacement) {
+        throw new Error("AST mode requires both astPattern and astReplacement");
+    }
+    try {
+        const cmd = [
+            "ast-grep",
+            "--pattern",
+            `"${astPattern}"`,
+            "--rewrite",
+            `"${astReplacement}"`,
+            dryRun ? "--dry-run" : "--write",
+            filePath,
+        ].join(" ");
+        if (dryRun) {
+            const output = execSync(cmd, { encoding: "utf-8" });
+            return `AST edit preview:\n${output}`;
+        }
+        execSync(cmd, { stdio: "inherit" });
+        return `AST edit applied to ${filePath}`;
+    }
+    catch (err) {
+        throw new Error(`AST edit failed: ${err.message}`);
+    }
+}
+export async function applyAdvancedFileEdits(filePath, mode, operations, astPattern, astReplacement, dryRun = false, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw new Error("File edit operation aborted");
+    }
+    // Read file content literally with signal
+    const originalContent = await readFile(filePath, {
+        encoding: "utf-8",
+        signal: abortSignal,
+    });
+    let modifiedContent = originalContent;
+    let resultMessage = "";
+    if (mode === "ast") {
+        // AST mode uses external ast-grep tool
+        if (!astPattern || !astReplacement) {
+            throw new Error("AST mode requires both astPattern and astReplacement");
+        }
+        resultMessage = applyAstModeEdits(filePath, astPattern, astReplacement, dryRun);
+        if (dryRun) {
+            return resultMessage;
+        }
+        // For actual AST edits, read the modified content back
+        modifiedContent = await readFile(filePath, {
+            encoding: "utf-8",
+            signal: abortSignal,
+        });
+    }
+    else {
+        // Text-based modes (exact and regex)
+        if (operations.length === 0) {
+            throw new Error("No operations specified for text-based editing mode");
+        }
+        switch (mode) {
+            case "exact":
+                modifiedContent = applyExactModeEdits(originalContent, operations);
+                break;
+            case "regex":
+                modifiedContent = applyRegexModeEdits(originalContent, operations);
+                break;
+        }
+        // Create unified diff
+        const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
+        // Format diff with appropriate number of backticks
+        let numBackticks = 3;
+        while (diff.includes("`".repeat(numBackticks))) {
+            numBackticks++;
+        }
+        resultMessage = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+        if (!dryRun) {
+            if (abortSignal?.aborted) {
+                throw new Error("File edit operation aborted before writing");
+            }
+            // Write the modified content with signal
+            await writeFile(filePath, modifiedContent, {
+                encoding: "utf-8",
+                signal: abortSignal,
+            });
+        }
+    }
+    return resultMessage;
+}

package/dist/tools/agent.d.ts

@@ -1,17 +1,29 @@
+import { type ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ModelManager } from "../models/manager.ts";
-import type { TokenTracker } from "../token-tracker.ts";
-import type { TokenCounter } from "../token-utils.ts";
-import type { SendData } from "./types.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
+import type { ToolResult } from "./types.ts";
 export declare const AgentTool: {
     name: "agent";
 };
+declare const inputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+}, z.core.$strip>;
 export declare const createAgentTools: (options: {
     modelManager: ModelManager;
     tokenTracker: TokenTracker;
     tokenCounter: TokenCounter;
-    sendData?: SendData | undefined;
+    workspace: WorkspaceContext;
 }) => {
-    agent: import("ai").Tool<{
-        prompt: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            prompt: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute: ({ prompt }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions) => AsyncGenerator<ToolResult>;
 };
+export {};
+//# sourceMappingURL=agent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,IAAI,CAAC;AACrE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAiCF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,SAAS;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;0BASe,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACV,eAAe,KAC3C,cAAc,CAAC,UAAU,CAAC;CA8D9B,CAAC"}

package/dist/tools/agent.js

@@ -1,9 +1,9 @@
-import { generateText, stepCountIs, tool } from "ai";
-import chalk from "chalk";
+import { generateText, stepCountIs } from "ai";
 import { z } from "zod";
 import { AiConfig } from "../models/ai-config.js";
-import { BashTool } from "./bash.js";
+import style from "../terminal/style.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";
@@ -13,18 +13,24 @@ export const AgentTool = {
 };
 const TOOLS = [
     GrepTool.name,
-    BashTool.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}. When you are searching for a keyword or file and are not confident that you will find the right match on the first try, use the ${AgentTool.name} tool to perform the search for you. For example:
+    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.
 
-- If you are searching for a keyword like "config" or "logger", the ${AgentTool.name} tool is appropriate
-- If you want to read a specific file path, use the ${ReadFileTool.name} or appropriate command via the ${BashTool.name} tool instead of this tool, to find the match more quickly
-- If you are searching for a specific class definition like "class Foo", use the ${GrepTool.name} tool instead, to find the match more quickly
+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
@@ -36,52 +42,62 @@ const inputSchema = z.object({
     prompt: z.string().describe("The task for the agent to perform"),
 });
 export const createAgentTools = (options) => {
-    const { modelManager, tokenTracker, tokenCounter, sendData } = 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: `\n${style.cyan(prompt)}`,
+        };
+        try {
+            const modelConfig = modelManager.getModelMetadata("task-agent");
+            const aiConfig = new AiConfig({
+                modelMetadata: modelConfig,
+                prompt: 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-completion",
+                id: toolCallId,
+                data: `Finished running the agent tool (${usage.totalTokens} tokens)`,
+            };
+            yield text;
+        }
+        catch (error) {
+            yield {
+                name: AgentTool.name,
+                event: "tool-error",
+                id: toolCallId,
+                data: error.message,
+            };
+            yield error.message;
+        }
+    }
     return {
-        [AgentTool.name]: tool({
-            description: getToolDescription(),
-            inputSchema: inputSchema,
-            execute: async ({ prompt }, { abortSignal, toolCallId }) => {
-                sendData?.({
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `Initializing agent with prompt: ${chalk.cyan(prompt)}`,
-                });
-                try {
-                    const modelConfig = modelManager.getModelMetadata("task-agent");
-                    const aiConfig = new AiConfig({
-                        modelMetadata: modelConfig,
-                        prompt: prompt,
-                    });
-                    const { text, usage } = await generateText({
-                        model: modelManager.getModel("task-agent"),
-                        maxOutputTokens: aiConfig.getMaxTokens(),
-                        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,
-                        stopWhen: stepCountIs(30),
-                        providerOptions: aiConfig.getProviderOptions(),
-                        tools: await initCliTools({ tokenCounter }),
-                        abortSignal: abortSignal,
-                        // biome-ignore lint/style/useNamingConvention: third-party code
-                        experimental_activeTools: [...TOOLS],
-                    });
-                    tokenTracker.trackUsage("task-agent", usage);
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: "Finished running the agent tool.",
-                    });
-                    return text;
-                }
-                catch (error) {
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: "Error running agent tool.",
-                    });
-                    return Promise.resolve(error.message);
-                }
-            },
-        }),
+        toolDef,
+        execute,
     };
 };

package/dist/tools/bash-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function validatePaths(command: string, allowedDirs: string[], cwd: string, allowedPaths?: string[]): {
+    isValid: boolean;
+    error?: string;
+};
+export declare const resolveCwd: (cwdInput: string | null | undefined, workingDir: string) => string;
+export declare const isMutatingCommand: (rawCommand: string) => boolean;
+//# sourceMappingURL=bash-utils.d.ts.map

package/dist/tools/bash-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-utils.d.ts","sourceRoot":"","sources":["../../source/tools/bash-utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAgFtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,KACjB,MAiDF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAmHtD,CAAC"}