@travisennis/acai 0.0.5 → 0.0.6

package/dist/terminal/select-prompt.js

@@ -67,10 +67,14 @@ function findLastEnabledIndex(choices) {
     }
     return choices.length - 1;
 }
-function render(choices, pointerIndex, pageStart, pageSize, prompt, typed) {
+function render(choices, pointerIndex, pageStart, pageSize, prompt, typed, totalChoices) {
     const visible = choices.slice(pageStart, pageStart + pageSize);
     const lines = [];
-    lines.push(`${prompt}${typed ? ` (search: ${typed})` : ""}`);
+    const searchInfo = typed ? ` (search: ${typed})` : "";
+    const filterInfo = typed && choices.length !== totalChoices
+        ? ` [${choices.length}/${totalChoices}]`
+        : "";
+    lines.push(`${prompt}${searchInfo}${filterInfo}`);
     for (let i = 0; i < visible.length; i++) {
         const actualIndex = pageStart + i;
         const ch = visible[i];
@@ -110,13 +114,20 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
     if (!stdin.isTTY)
         throw new Error("TTY required");
     let searchBuffer = "";
-    let searchTimer = null;
-    const resetSearchBuffer = () => {
+    const searchTimer = null;
+    let filteredChoices = [...normalized];
+    const clearSearchBuffer = () => {
+        searchBuffer = "";
+        filteredChoices = [...normalized];
+        // Reset pointer to first enabled choice when clearing search
+        pointer = findFirstEnabledIndex(filteredChoices);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+        renderToScreen();
+    };
+    const resetSearchTimer = () => {
         if (searchTimer)
             clearTimeout(searchTimer);
-        searchTimer = setTimeout(() => {
-            searchBuffer = "";
-        }, 800);
+        // Don't auto-clear the search buffer - let user clear it explicitly
     };
     let previousOutputLines = 0;
     function clearPreviousOutput(lineCount) {
@@ -129,30 +140,26 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
         stdout.write(ANSI.moveToStart);
         stdout.write(ANSI.clearFromCursor);
         clearPreviousOutput(previousOutputLines);
-        const out = render(normalized, pointer, pageStart, pageSize, message, searchBuffer);
+        const out = render(filteredChoices, pointer, pageStart, pageSize, message, searchBuffer, normalized.length);
         previousOutputLines = out.split("\n").length;
         stdout.write(`${out}\n`);
     }
     function move(delta) {
-        pointer = findNextEnabledIndex(normalized, pointer, delta);
-        pageStart = updatePageStart(pointer, pageSize, normalized.length);
+        pointer = findNextEnabledIndex(filteredChoices, pointer, delta);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
         renderToScreen();
     }
-    function jumpToIndexStartingWith(prefix) {
-        const start = (pointer + 1) % normalized.length;
-        const lowerPref = prefix.toLowerCase();
-        for (let i = 0; i < normalized.length; i++) {
-            const idx = (start + i) % normalized.length;
-            if (normalized[idx].disabled)
-                continue;
-            if (normalized[idx].name.toLowerCase().startsWith(lowerPref)) {
-                pointer = idx;
-                pageStart = updatePageStart(pointer, pageSize, normalized.length);
-                renderToScreen();
-                return true;
-            }
+    function filterChoices(search) {
+        if (!search) {
+            filteredChoices = [...normalized];
         }
-        return false;
+        else {
+            const lowerSearch = search.toLowerCase();
+            filteredChoices = normalized.filter((choice) => choice.name.toLowerCase().includes(lowerSearch));
+        }
+        // Reset pointer to first enabled choice
+        pointer = findFirstEnabledIndex(filteredChoices);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
     }
     return new Promise((resolve, reject) => {
         let resolved = false;
@@ -192,7 +199,7 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
             }
             if (key === Keys.enter || key === Keys.newline) {
                 cleanup();
-                const chosen = normalized[pointer];
+                const chosen = filteredChoices[pointer];
                 stdout.write("\n");
                 resolve(chosen.value);
                 return;
@@ -206,35 +213,34 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
                 return;
             }
             if (key === Keys.home || key === Keys.homeAlt) {
-                pointer = findFirstEnabledIndex(normalized);
-                pageStart = updatePageStart(pointer, pageSize, normalized.length);
+                pointer = findFirstEnabledIndex(filteredChoices);
+                pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
                 renderToScreen();
                 return;
             }
             if (key === Keys.end || key === Keys.endAlt) {
-                pointer = findLastEnabledIndex(normalized);
-                pageStart = updatePageStart(pointer, pageSize, normalized.length);
+                pointer = findLastEnabledIndex(filteredChoices);
+                pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
                 renderToScreen();
                 return;
             }
             if (key === Keys.backspace || key === Keys.backspaceAlt) {
                 if (searchBuffer.length > 0) {
                     searchBuffer = searchBuffer.slice(0, -1);
-                    if (searchBuffer.length === 0)
-                        resetSearchBuffer();
-                    renderToScreen();
+                    if (searchBuffer.length === 0) {
+                        clearSearchBuffer();
+                    }
+                    else {
+                        filterChoices(searchBuffer);
+                        renderToScreen();
+                    }
                 }
                 return;
             }
             if (key && key >= " " && key <= "~") {
                 searchBuffer += key;
-                resetSearchBuffer();
-                const found = jumpToIndexStartingWith(searchBuffer);
-                if (!found) {
-                    searchBuffer = key;
-                    resetSearchBuffer();
-                    jumpToIndexStartingWith(searchBuffer);
-                }
+                resetSearchTimer();
+                filterChoices(searchBuffer);
                 renderToScreen();
                 return;
             }
@@ -244,6 +250,8 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
             stdin.resume();
             stdin.setEncoding("utf8");
             stdout.write(ANSI.hideCursor);
+            // Reset previous output lines counter to ensure clean start
+            previousOutputLines = 0;
             renderToScreen();
             stdin.on("data", onData);
             const exitHandler = () => {

package/dist/tokens/threshold.d.ts

@@ -0,0 +1,35 @@
+import type { TokenCounter } from "./counter.ts";
+export declare function clearTokenCache(): void;
+/**
+ * Standardized result when token limit is exceeded
+ */
+interface TokenLimitResult {
+    content: string;
+    tokenCount: number;
+    truncated: boolean;
+}
+/**
+ * Generates a standardized token limit message for LLM tools
+ * @param toolName - Name of the tool (e.g., "ReadFile", "Bash")
+ * @param tokenCount - Actual token count of content
+ * @param maxTokens - Maximum allowed tokens
+ * @param additionalGuidance - Optional specific guidance for this tool
+ * @returns TokenLimitResult with message and metadata
+ */
+export declare function createTokenLimitResult(toolName: string, tokenCount: number, additionalGuidance?: string): TokenLimitResult;
+/**
+ * Check if content should be truncated and return appropriate result
+ * @param content - The content to check
+ * @param tokenCounter - Token counter instance
+ * @param toolName - Name of the tool for messages
+ * @param additionalGuidance - Optional tool-specific guidance
+ * @param encoding - Optional encoding type for non-text file handling
+ * @returns Either the original content or token limit message
+ */
+export declare function manageTokenLimit<T extends string>(content: T, tokenCounter: TokenCounter, toolName: string, additionalGuidance?: string, encoding?: string): Promise<{
+    content: T | string;
+    tokenCount: number;
+    truncated: boolean;
+}>;
+export {};
+//# sourceMappingURL=threshold.d.ts.map

package/dist/tokens/threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threshold.d.ts","sourceRoot":"","sources":["../../source/tokens/threshold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQjD,wBAAgB,eAAe,SAG9B;AAyBD;;GAEG;AACH,UAAU,gBAAgB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,gBAAgB,CAgBlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EACrD,OAAO,EAAE,CAAC,EACV,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAChB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CA+B1E"}

package/dist/tokens/threshold.js

@@ -0,0 +1,85 @@
+import { config } from "../config.js";
+// Cache for maxTokens config to avoid repeated async calls
+let maxTokensCache = null;
+let cacheExpiry = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+// Export cache management for testing
+export function clearTokenCache() {
+    maxTokensCache = null;
+    cacheExpiry = 0;
+}
+/**
+ * Get maxTokens from config with caching
+ */
+async function getMaxTokens() {
+    const now = Date.now();
+    if (maxTokensCache !== null && now < cacheExpiry) {
+        return maxTokensCache;
+    }
+    try {
+        const projectConfig = await config.readProjectConfig();
+        maxTokensCache = projectConfig.tools.maxTokens;
+        cacheExpiry = now + CACHE_DURATION;
+        return maxTokensCache;
+    }
+    catch (error) {
+        console.info("Failed to read config for maxTokens, using default:", error);
+        maxTokensCache = 8000; // Default fallback
+        cacheExpiry = now + CACHE_DURATION;
+        return maxTokensCache;
+    }
+}
+/**
+ * Generates a standardized token limit message for LLM tools
+ * @param toolName - Name of the tool (e.g., "ReadFile", "Bash")
+ * @param tokenCount - Actual token count of content
+ * @param maxTokens - Maximum allowed tokens
+ * @param additionalGuidance - Optional specific guidance for this tool
+ * @returns TokenLimitResult with message and metadata
+ */
+export function createTokenLimitResult(toolName, tokenCount, additionalGuidance) {
+    const truncated = true;
+    const baseMessage = `${toolName}: Content (${tokenCount} tokens) exceeds maximum allowed tokens`;
+    const guidance = additionalGuidance ??
+        "Please adjust your parameters to reduce content size";
+    const content = `${baseMessage}. ${guidance}`;
+    return {
+        content,
+        tokenCount,
+        truncated,
+    };
+}
+/**
+ * Check if content should be truncated and return appropriate result
+ * @param content - The content to check
+ * @param tokenCounter - Token counter instance
+ * @param toolName - Name of the tool for messages
+ * @param additionalGuidance - Optional tool-specific guidance
+ * @param encoding - Optional encoding type for non-text file handling
+ * @returns Either the original content or token limit message
+ */
+export async function manageTokenLimit(content, tokenCounter, toolName, additionalGuidance, encoding) {
+    // For non-text files, return content directly without token management
+    if (encoding && !encoding.startsWith("utf")) {
+        return { content, tokenCount: 0, truncated: false };
+    }
+    let tokenCount = 0;
+    try {
+        tokenCount = tokenCounter.count(content);
+    }
+    catch (tokenError) {
+        console.info("Error calculating token count:", tokenError);
+        // Return content if token counting fails
+        return { content, tokenCount: 0, truncated: false };
+    }
+    const maxTokens = await getMaxTokens();
+    if (tokenCount <= maxTokens) {
+        return { content, tokenCount, truncated: false };
+    }
+    const limitResult = createTokenLimitResult(toolName, tokenCount, additionalGuidance);
+    return {
+        content: limitResult.content,
+        tokenCount,
+        truncated: true,
+    };
+}

package/dist/tools/advanced-edit-file.d.ts

@@ -0,0 +1,69 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
+export declare const AdvancedEditFileTool: {
+    name: "advancedEditFile";
+};
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        exact: "exact";
+        regex: "regex";
+        ast: "ast";
+    }>>;
+    operations: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            replace: "replace";
+            "insert-before": "insert-before";
+            "insert-after": "insert-after";
+            delete: "delete";
+        }>;
+        pattern: z.ZodString;
+        replacement: z.ZodOptional<z.ZodString>;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    astPattern: z.ZodOptional<z.ZodString>;
+    astReplacement: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type AdvancedEditFileInputSchema = z.infer<typeof inputSchema>;
+interface FileOperation {
+    type: "replace" | "insert-before" | "insert-after" | "delete";
+    pattern: string;
+    replacement?: string;
+    flags?: string;
+}
+export declare const createAdvancedEditFileTool: ({ workingDir, allowedDirs, }: {
+    workingDir: string;
+    allowedDirs?: string[];
+}) => Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            mode: z.ZodDefault<z.ZodEnum<{
+                exact: "exact";
+                regex: "regex";
+                ast: "ast";
+            }>>;
+            operations: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    replace: "replace";
+                    "insert-before": "insert-before";
+                    "insert-after": "insert-after";
+                    delete: "delete";
+                }>;
+                pattern: z.ZodString;
+                replacement: z.ZodOptional<z.ZodString>;
+                flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            astPattern: z.ZodOptional<z.ZodString>;
+            astReplacement: z.ZodOptional<z.ZodString>;
+            dryRun: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    };
+    execute({ path, mode, operations, astPattern, astReplacement, dryRun, }: AdvancedEditFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+}>;
+export declare function applyAdvancedFileEdits(filePath: string, mode: "exact" | "regex" | "ast", operations: FileOperation[], astPattern?: string, astReplacement?: string, dryRun?: boolean, abortSignal?: AbortSignal): Promise<string>;
+export {};
+//# sourceMappingURL=advanced-edit-file.d.ts.map

package/dist/tools/advanced-edit-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/advanced-edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;CAEhC,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;iBAuCf,CAAC;AAEH,KAAK,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/D,UAAU,aAAa;IACrB,IAAI,EAAE,SAAS,GAAG,eAAe,GAAG,cAAc,GAAG,QAAQ,CAAC;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,0BAA0B,GAAU,8BAG9C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;6EAiBQ,2BAA2B,+BACD,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAgDhC,CAAC;AA2MF,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,EAC/B,UAAU,EAAE,aAAa,EAAE,EAC3B,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAyEjB"}

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,18 +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 { TokenCounter } from "../tokens/counter.ts";
 import type { TokenTracker } from "../tokens/tracker.ts";
-import type { SendData } from "./types.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

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAGA,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,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,SAAS;;CAErB,CAAC;AA+BF,eAAO,MAAM,gBAAgB,GAAI,SAAS;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC;;;;CAyDA,CAAC"}
+{"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"}