@travisennis/acai 0.0.7 → 0.0.9

package/dist/repl/tool-call-repair.js

@@ -1,54 +0,0 @@
-import { generateObject, NoSuchToolError, } from "ai";
-import { jsonrepair } from "jsonrepair";
-import { logger } from "../logger.js";
-async function remoteToolCallRepair(modelManager, toolCall, tool, inputSchema) {
-    const { object: repairedArgs } = await generateObject({
-        model: modelManager.getModel("tool-repair"),
-        schema: tool.inputSchema,
-        prompt: [
-            `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
-            JSON.stringify(toolCall.input),
-            "The tool accepts the following schema:",
-            JSON.stringify(inputSchema(toolCall)),
-            "Please fix the arguments.",
-        ].join("\n"),
-    });
-    return { ...toolCall, input: JSON.stringify(repairedArgs) };
-}
-const localToolCallRepair = async (toolCall, tool) => {
-    const schema = tool.inputSchema;
-    const repairedArgs = jsonrepair(toolCall.input);
-    const validatedArgs = schema.parse(JSON.parse(repairedArgs));
-    return { ...toolCall, input: JSON.stringify(validatedArgs) };
-};
-export const toolCallRepair = (modelManager) => {
-    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
-        if (NoSuchToolError.isInstance(error)) {
-            return null;
-        }
-        logger.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
-        const tool = tools[toolCall.toolName];
-        if (typeof tool === "undefined") {
-            logger.error(new Error("Tool not found"), `Failed to repair tool call: ${toolCall.toolName}.`);
-            return null;
-        }
-        try {
-            const repaired = await localToolCallRepair(toolCall, tool);
-            logger.debug(`Tool call repaired with jsonrepair ${repaired.input}`);
-            return repaired;
-        }
-        catch (err) {
-            logger.error(err, `Failed to repair tool call locally: ${toolCall.toolName}.`);
-            try {
-                const repaired = await remoteToolCallRepair(modelManager, toolCall, tool, inputSchema);
-                logger.debug(`Tool call repaired with remote repair ${repaired.input}`);
-                return repaired;
-            }
-            catch (err2) {
-                logger.error(err2, `Failed to repair tool call remotely: ${toolCall.toolName}.`);
-                return null;
-            }
-        }
-    };
-    return fn;
-};

package/dist/terminal/markdown.d.ts

@@ -1,2 +0,0 @@
-export declare function applyMarkdown(content: string): string;
-//# sourceMappingURL=markdown.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../source/terminal/markdown.ts"],"names":[],"mappings":"AAcA,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMrD"}

package/dist/terminal/markdown.js

@@ -1,120 +0,0 @@
-import { EOL } from "node:os";
-import { marked } from "marked";
-import { logger } from "../logger.js";
-import { DEFAULT_HIGHLIGHT_THEME } from "./default-theme.js";
-import { link as terminalLink } from "./formatting.js";
-import { highlight, supportsLanguage } from "./highlight/index.js";
-import { getListNumber } from "./markdown-utils.js";
-import style from "./style.js";
-import { Table } from "./table/index.js";
-function logError(msg) {
-    logger.error(msg);
-}
-export function applyMarkdown(content) {
-    return marked
-        .lexer(content)
-        .map((token) => format(token))
-        .join("")
-        .trim();
-}
-function format(token, listDepth = 0, orderedListNumber = null, parent = null) {
-    switch (token.type) {
-        case "blockquote":
-            return style.dim.italic((token.tokens ?? [])
-                .map((_) => format(_))
-                .map((l) => `  ${l}`)
-                .join(""));
-        case "code": {
-            if (token.lang && supportsLanguage(token.lang)) {
-                return (highlight(token.text, {
-                    language: token.lang,
-                    theme: DEFAULT_HIGHLIGHT_THEME,
-                }) + EOL);
-            }
-            logError(`Language not supported while highlighting code, falling back to markdown: ${token.lang}`);
-            return (highlight(token.text, {
-                language: "markdown",
-                theme: DEFAULT_HIGHLIGHT_THEME,
-            }) + EOL);
-        }
-        case "codespan":
-            // inline code
-            return style.blue(token.text);
-        case "em":
-            return style.italic((token.tokens ?? []).map((_) => format(_)).join(""));
-        case "strong":
-            return style.bold((token.tokens ?? []).map((_) => format(_)).join(""));
-        case "heading":
-            switch (token.depth) {
-                case 1: // h1
-                    return (style.bold.italic.underline((token.tokens ?? []).map((_) => format(_)).join("")) +
-                        EOL +
-                        EOL);
-                case 2: // h2
-                    return (style.bold((token.tokens ?? []).map((_) => format(_)).join("")) +
-                        EOL +
-                        EOL);
-                default: // h3+
-                    return (style.bold.dim((token.tokens ?? []).map((_) => format(_)).join("")) +
-                        EOL +
-                        EOL);
-            }
-        case "hr":
-            return "---";
-        case "image": {
-            const alt = (token.title ?? token.text ?? "").toString().trim();
-            if (alt.length > 0) {
-                return `[Image: ${alt} (${token.href})]`;
-            }
-            return `[Image: ${token.href}]`;
-        }
-        case "link":
-            return terminalLink(token.text, token.href);
-        case "list": {
-            return token.items
-                .map((_, index) => format(_, listDepth, token.ordered ? token.start + index : null, token))
-                .join("");
-        }
-        case "list_item":
-            return (token.tokens ?? [])
-                .map((_) => `${"  ".repeat(listDepth)}${format(_, listDepth + 1, orderedListNumber, token)}`)
-                .join("");
-        case "paragraph":
-            return (token.tokens ?? []).map((_) => format(_)).join("") + EOL;
-        case "space":
-            return EOL;
-        case "text": {
-            if (parent?.type === "list_item") {
-                return `${orderedListNumber === null ? "-" : `${getListNumber(listDepth, orderedListNumber)}.`} ${token.tokens ? token.tokens.map((_) => format(_, listDepth, orderedListNumber, token)).join("") : token.text}${EOL}`;
-            }
-            return token.text;
-        }
-        case "table": {
-            const header = Array.isArray(token.header)
-                ? token.header
-                : [token.header];
-            const rows = Array.isArray(token.rows) ? token.rows : [token.rows];
-            // Calculate column widths based on terminal width
-            const padding = 5; // Account for table borders and padding
-            const availableWidth = Math.max(10, (process.stdout.columns || 80) - padding);
-            const colCount = header?.length ?? 1;
-            const width = Math.max(10, Math.floor(availableWidth / Math.max(1, colCount)));
-            const computedColWidths = new Array(colCount).fill(width);
-            const table = new Table({
-                head: header.map((h) => h.text),
-                colWidths: computedColWidths,
-                wordWrap: true, // Enable word wrapping for the description column
-            });
-            table.push(...rows.map((row) => row.map((c) => c.text)));
-            return `${table.toString()}\n`;
-        }
-        case "del": {
-            return style.strikethrough(token.text);
-        }
-        case "html":
-            // Render HTML tags with dim styling and content as normal text
-            return style.dim(token.text);
-        default:
-            return "";
-    }
-}

package/dist/tokens/threshold.d.ts

@@ -1,20 +0,0 @@
-import type { TokenCounter } from "./counter.ts";
-export declare function clearTokenCache(): void;
-export declare class TokenLimitExceededError extends Error {
-    constructor(toolName: string, tokenCount: number, maxTokens: number, guidance?: string);
-}
-/**
- * Check if content exceeds token limit
- * @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 Content with token count if under limit
- * @throws TokenLimitExceededError if content exceeds token limit
- */
-export declare function manageTokenLimit<T extends string>(content: T, tokenCounter: TokenCounter, toolName: string, additionalGuidance?: string, encoding?: string): Promise<{
-    content: T;
-    tokenCount: number;
-}>;
-//# sourceMappingURL=threshold.d.ts.map

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

@@ -1 +0,0 @@
-{"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,qBAAa,uBAAwB,SAAQ,KAAK;gBAE9C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM;CASpB;AAED;;;;;;;;;GASG;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,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CA2B7C"}

package/dist/tokens/threshold.js

@@ -1,67 +0,0 @@
-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.getConfig();
-        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;
-    }
-}
-export class TokenLimitExceededError extends Error {
-    constructor(toolName, tokenCount, maxTokens, guidance) {
-        super(`${toolName}: Content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). ${guidance || "Please adjust parameters to reduce content size."}`);
-        this.name = "TokenLimitExceededError";
-    }
-}
-/**
- * Check if content exceeds token limit
- * @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 Content with token count if under limit
- * @throws TokenLimitExceededError if content exceeds token limit
- */
-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 };
-    }
-    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 };
-    }
-    const maxTokens = await getMaxTokens();
-    if (tokenCount <= maxTokens) {
-        return { content, tokenCount };
-    }
-    throw new TokenLimitExceededError(toolName, tokenCount, maxTokens, additionalGuidance);
-}

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

@@ -1,69 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AAQxB,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;EAoDhC,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

@@ -1,285 +0,0 @@
-import { execSync } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { createTwoFilesPatch } from "diff";
-import { z } from "zod";
-import { config } from "../config.js";
-import style from "../terminal/style.js";
-import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.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 });
-                // Check if file is read-only
-                const projectConfig = await config.getConfig();
-                validateFileNotReadOnly(validPath, projectConfig, workingDir);
-                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,29 +0,0 @@
-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 { 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;
-    workspace: WorkspaceContext;
-}) => {
-    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 +0,0 @@
-{"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;CA+E9B,CAAC"}