@travisennis/acai 0.0.7 → 0.0.9

package/dist/tools/read-file.js

@@ -2,106 +2,73 @@ import fs from "node:fs/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
 import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
+import { convertNullString } from "../utils/zod.js";
 import { fileEncodingSchema } from "./types.js";
+// default limit in bytes
+const DEFAULT_BYTE_LIMIT = 80 * 1024;
 export const ReadFileTool = {
-    name: "readFile",
+    name: "Read",
 };
 const inputSchema = z.object({
     path: z.string().describe("Absolute path to file to read"),
-    encoding: fileEncodingSchema.describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
-    startLine: z.coerce
-        .number()
+    encoding: fileEncodingSchema
         .nullable()
+        .default("utf-8")
+        .describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
+    startLine: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
         .describe("1-based line number to start reading from. Required but nullable. Pass null to start at beginning of file"),
-    lineCount: z.coerce
-        .number()
-        .nullable()
+    lineCount: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
         .describe("Maximum number of lines to read. Required but nullable. Pass null to get all lines."),
+    maxBytes: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of bytes to read. Set to 0 for no limit. (Default: 80KB)"),
 });
-export const createReadFileTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+export const createReadFileTool = async ({ workingDir, allowedDirs, }) => {
     const allowedDirectory = allowedDirs ?? [workingDir];
     return {
         toolDef: {
-            description: "Read the complete contents of a file from the file system unless startLine and lineCount are given to read a file selection. Handles various text encodings and provides detailed error messages if the file cannot be read. Use this tool when you need to examine the contents of a single file. Only works within allowed directories.",
+            description: `Read the complete contents of a file from the file system unless startLine and lineCount are given to read a file selection. Handles various text encodings and provides detailed error messages if the file cannot be read. Use this tool when you need to examine the contents of a single file. Only works within allowed directories. Automatically limits file size to prevent overwhelming output. Default limit is ${DEFAULT_BYTE_LIMIT} bytes (${DEFAULT_BYTE_LIMIT / 1024}KB). Use maxBytes parameter to override this limit.`,
             inputSchema,
         },
-        async *execute({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) {
-            try {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("File reading aborted");
-                }
-                yield {
-                    name: ReadFileTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
-                };
-                const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
-                if (abortSignal?.aborted) {
-                    throw new Error("File reading aborted before file read");
-                }
-                let file = await fs.readFile(filePath, { encoding });
-                // Apply line-based selection if requested
-                if (isNumber(startLine) || isNumber(lineCount)) {
-                    const lines = file.split("\n");
-                    const totalLines = lines.length;
-                    const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
-                    const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
-                    if (startIndex < 0 || startIndex >= totalLines) {
-                        const errorMsg = `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
-                        yield {
-                            name: ReadFileTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: errorMsg,
-                        };
-                        yield errorMsg;
-                        return;
-                    }
-                    const endIndex = Math.min(startIndex + count, totalLines);
-                    file = lines.slice(startIndex, endIndex).join("\n");
-                }
-                try {
-                    const result = await manageTokenLimit(file, tokenCounter, "ReadFile", isNumber(startLine) || isNumber(lineCount)
-                        ? "Consider adjusting startLine/lineCount or using grepFiles"
-                        : "Use startLine and lineCount parameters to read specific portions, or use grepFiles for targeted access", encoding);
-                    // Calculate line count for the returned content
-                    const linesRead = result.content.split("\n").length;
-                    yield {
-                        name: ReadFileTool.name,
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: `Read ${linesRead} lines (${result.tokenCount} tokens)`,
-                    };
-                    yield result.content;
-                }
-                catch (error) {
-                    if (error instanceof TokenLimitExceededError) {
-                        yield {
-                            name: ReadFileTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: error.message,
-                        };
-                        yield error.message;
-                        return;
-                    }
-                    throw error;
+        display({ path: providedPath, startLine, lineCount }) {
+            return `\n> ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`;
+        },
+        async execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("File reading aborted");
+            }
+            const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
+            if (abortSignal?.aborted) {
+                throw new Error("File reading aborted before file read");
+            }
+            let file = await fs.readFile(filePath, {
+                encoding: encoding ?? "utf-8",
+            });
+            if (isNumber(startLine) || isNumber(lineCount)) {
+                const lines = file.split("\n");
+                const totalLines = lines.length;
+                const startIndex = (startLine ?? 1) - 1;
+                const count = lineCount ?? totalLines - startIndex;
+                if (startIndex < 0 || startIndex >= totalLines) {
+                    throw new Error(`startLine ${startLine} is out of bounds for file with ${totalLines} lines.`);
                 }
+                const endIndex = Math.min(startIndex + count, totalLines);
+                file = lines.slice(startIndex, endIndex).join("\n");
             }
-            catch (error) {
-                const errorMsg = `${error.message}`;
-                yield {
-                    name: ReadFileTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMsg,
-                };
-                yield errorMsg;
+            const effectiveMaxBytes = maxBytes ?? DEFAULT_BYTE_LIMIT;
+            if (effectiveMaxBytes !== null &&
+                effectiveMaxBytes !== undefined &&
+                effectiveMaxBytes > 0) {
+                const buffer = Buffer.from(file, encoding ?? "utf-8");
+                if (buffer.byteLength > effectiveMaxBytes) {
+                    const truncatedBuffer = buffer.subarray(0, effectiveMaxBytes);
+                    file = truncatedBuffer.toString(encoding ?? "utf-8");
+                }
             }
+            return file;
         },
     };
 };

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

@@ -1,8 +1,7 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import { type ToolResult } from "./types.ts";
+import { type ToolExecutionOptions } from "./types.ts";
 export declare const SaveFileTool: {
-    name: "saveFile";
+    name: "Write";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
@@ -46,7 +45,8 @@ export declare const createSaveFileTool: ({ workingDir, allowedDirs, }: {
             }>>;
         }, z.core.$strip>;
     };
-    execute({ path: userPath, content, encoding }: SaveFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ path }: SaveFileInputSchema): string;
+    execute({ path: userPath, content, encoding }: SaveFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 export {};
 //# sourceMappingURL=save-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;mDAa4C,mBAAmB,+BAC7B,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAuFhC,CAAC"}
+{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3E,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;sBAYqB,mBAAmB;mDAII,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqDrB,CAAC"}

package/dist/tools/save-file.js

@@ -2,12 +2,12 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { config } from "../config.js";
-import { clearProjectStatusCache } from "../repl/project-status-line.js";
+import { clearProjectStatusCache } from "../repl/project-status.js";
 import style from "../terminal/style.js";
 import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
 import { fileEncodingSchema } from "./types.js";
 export const SaveFileTool = {
-    name: "saveFile",
+    name: "Write",
 };
 const inputSchema = z.object({
     path: z.string().describe("Absolute path to file to save to"),
@@ -26,76 +26,47 @@ export const createSaveFileTool = async ({ workingDir, allowedDirs, }) => {
                 "Handles text content with proper encoding. Only works within allowed directories.",
             inputSchema,
         },
-        async *execute({ path: userPath, content, encoding }, { toolCallId, abortSignal }) {
+        display({ path }) {
+            return `\n> ${style.cyan(path)}`;
+        },
+        async execute({ path: userPath, content, encoding }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("File saving aborted");
+            }
+            const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
             try {
-                if (abortSignal?.aborted) {
-                    throw new Error("File saving aborted");
-                }
-                yield {
-                    name: SaveFileTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `${style.cyan(userPath)}`,
-                };
-                const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
-                // Check if file is read-only (only if it exists)
-                try {
-                    await fs.stat(filePath);
-                    const projectConfig = await config.getConfig();
-                    validateFileNotReadOnly(filePath, projectConfig, workingDir);
-                }
-                catch (error) {
-                    // File doesn't exist, so it's not read-only
-                    if (error.code !== "ENOENT") {
-                        throw error;
-                    }
-                }
-                // Check if path exists and is a directory
-                try {
-                    const stat = await fs.stat(filePath);
-                    if (stat.isDirectory()) {
-                        throw new Error(`Cannot save file - path is a directory: ${filePath}`);
-                    }
-                }
-                catch (error) {
-                    // Only re-throw if it's our directory error, otherwise continue (file doesn't exist)
-                    if (error instanceof Error &&
-                        error.message.includes("is a directory")) {
-                        throw error;
-                    }
+                await fs.stat(filePath);
+                const projectConfig = await config.getConfig();
+                validateFileNotReadOnly(filePath, projectConfig, workingDir);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
                 }
-                // Pre-side-effect check
-                if (abortSignal?.aborted) {
-                    throw new Error("File saving aborted before writing");
+            }
+            try {
+                const stat = await fs.stat(filePath);
+                if (stat.isDirectory()) {
+                    throw new Error(`Cannot save file - path is a directory: ${filePath}`);
                 }
-                // Ensure parent directory exists (create missing parents)
-                const parentDir = path.dirname(filePath);
-                await fs.mkdir(parentDir, { recursive: true });
-                await fs.writeFile(filePath, content, {
-                    encoding,
-                    signal: abortSignal,
-                });
-                const lines = content.split("\n").length;
-                const bytes = Buffer.byteLength(content, encoding);
-                yield {
-                    name: SaveFileTool.name,
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: `Saved ${lines} lines, ${bytes} bytes`,
-                };
-                // Clear project status cache since file operations change git status
-                clearProjectStatusCache();
-                yield `File saved successfully: ${filePath}`;
             }
             catch (error) {
-                yield {
-                    name: SaveFileTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield `Failed to save file: ${error.message}`;
+                if (error instanceof Error &&
+                    error.message.includes("is a directory")) {
+                    throw error;
+                }
+            }
+            if (abortSignal?.aborted) {
+                throw new Error("File saving aborted before writing");
             }
+            const parentDir = path.dirname(filePath);
+            await fs.mkdir(parentDir, { recursive: true });
+            await fs.writeFile(filePath, content, {
+                encoding,
+                signal: abortSignal,
+            });
+            clearProjectStatusCache();
+            return `File saved successfully: ${filePath}`;
         },
     };
 };

package/dist/tools/think.d.ts

@@ -1,8 +1,7 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const ThinkTool: {
-    name: "think";
+    name: "Think";
 };
 declare const inputSchema: z.ZodObject<{
     thought: z.ZodString;
@@ -14,7 +13,8 @@ export declare const createThinkTool: () => {
             thought: z.ZodString;
         }, z.core.$strip>;
     };
-    execute({ thought }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display(): string;
+    execute({ thought }: z.infer<typeof inputSchema>, { abortSignal }: ToolExecutionOptions): Promise<string>;
 };
 export {};
 //# sourceMappingURL=think.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAWF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;yBAOT,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACX,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CA4ChC,CAAC"}
+{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAWF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;yBAUT,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,mBACvB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAUrB,CAAC"}

package/dist/tools/think.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export const ThinkTool = {
-    name: "think",
+    name: "Think",
 };
 const toolDescription = `Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed.
 Common use cases:
@@ -20,44 +20,15 @@ export const createThinkTool = () => {
             description: toolDescription,
             inputSchema,
         },
-        async *execute({ thought }, { toolCallId, abortSignal }) {
-            try {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("Thinking process aborted");
-                }
-                // Replace literal '\\n' with actual newline characters
-                const formattedThought = thought.replace(/\\n/g, "\n");
-                yield {
-                    name: ThinkTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: "Logging thought",
-                };
-                yield {
-                    name: ThinkTool.name,
-                    event: "tool-update",
-                    id: toolCallId,
-                    data: `${formattedThought}`,
-                };
-                yield {
-                    name: ThinkTool.name,
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: "Thought logged",
-                };
-                yield "Your thought has been logged.";
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                yield {
-                    name: ThinkTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMessage,
-                };
-                yield errorMessage;
+        display() {
+            return "\n> Logging thought";
+        },
+        async execute({ thought }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Thinking process aborted");
             }
+            const formattedThought = thought.replace(/\\n/g, "\n");
+            return `Thought: ${formattedThought}`;
         },
     };
 };

package/dist/tools/types.d.ts

@@ -12,29 +12,9 @@ export declare const fileEncodingSchema: z.ZodEnum<{
     binary: "binary";
     hex: "hex";
 }>;
-interface BaseMessage {
-    name: string;
-    id: string;
-    retry?: number;
-}
-interface ToolInitMessage extends BaseMessage {
-    event: "tool-init";
-    data: string;
-}
-interface ToolUpdateMessage extends BaseMessage {
-    event: "tool-update";
-    data: string;
-}
-interface ToolErrorMessage extends BaseMessage {
-    event: "tool-error";
-    data: string;
-}
-interface ToolCompletionMessage extends BaseMessage {
-    event: "tool-completion";
-    data: string;
-}
-type Message = ToolInitMessage | ToolUpdateMessage | ToolErrorMessage | ToolCompletionMessage;
-export type ToolResult = Message | string;
-export declare function isToolMessage(value: unknown): value is Message;
-export {};
+export type ToolExecutionOptions = {
+    toolCallId: string;
+    messages?: any[];
+    abortSignal?: AbortSignal;
+};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAgB,SAAQ,WAAW;IAC3C,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,iBAAkB,SAAQ,WAAW;IAC7C,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAiB,SAAQ,WAAW;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,qBAAsB,SAAQ,WAAW;IACjD,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,KAAK,OAAO,GACR,eAAe,GACf,iBAAiB,GACjB,gBAAgB,GAChB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC;AAE1C,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAc9D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC"}

package/dist/tools/types.js

@@ -12,12 +12,3 @@ export const fileEncodingSchema = z.enum([
     "binary",
     "hex",
 ]);
-export function isToolMessage(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const candidate = value;
-    return (typeof candidate.event === "string" &&
-        typeof candidate.id === "string" &&
-        ("data" in candidate || "retry" in candidate));
-}

package/dist/tui/autocomplete/attachment-provider.d.ts

@@ -0,0 +1,18 @@
+import type { AutocompleteItem } from "./base-provider.ts";
+import { PathProvider } from "./path-provider.ts";
+export declare class AttachmentProvider extends PathProvider {
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+}
+//# sourceMappingURL=attachment-provider.d.ts.map

package/dist/tui/autocomplete/attachment-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/attachment-provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,qBAAa,kBAAmB,SAAQ,YAAY;IACnC,cAAc,CAC3B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAyCvD,eAAe,CACtB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACb;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAwB9C,uBAAuB,CACpC,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CA0CjE"}

package/dist/tui/autocomplete/attachment-provider.js

@@ -0,0 +1,159 @@
+import { extname } from "node:path";
+import { PathProvider } from "./path-provider.js";
+export class AttachmentProvider extends PathProvider {
+    async getSuggestions(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Only handle @ file attachments
+        const pathMatch = textBeforeCursor.match(/@([^\s]*)$/);
+        if (!pathMatch) {
+            return null;
+        }
+        let prefix = pathMatch[0]; // Includes the @
+        // Handle @ file attachment prefix
+        if (prefix.startsWith("@")) {
+            prefix = prefix.slice(1); // Remove the @
+        }
+        else {
+            return null;
+        }
+        const suggestions = await this.getFileSuggestions(prefix);
+        if (suggestions.length === 0)
+            return null;
+        // For @ prefix, filter to only show directories and attachable files
+        const filteredSuggestions = [];
+        for (const suggestion of suggestions) {
+            if (!suggestion.value.endsWith("/") &&
+                !isAttachableFile(suggestion.value)) {
+                continue;
+            }
+            suggestion.value = `@${suggestion.value}`;
+            filteredSuggestions.push(suggestion);
+        }
+        if (filteredSuggestions.length === 0)
+            return null;
+        return {
+            items: filteredSuggestions,
+            prefix: pathMatch[0],
+        };
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        const currentLine = lines[cursorLine] || "";
+        const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+        const afterCursor = currentLine.slice(cursorCol);
+        // Only handle @ file attachment completion if prefix starts with "@"
+        if (prefix.startsWith("@")) {
+            // Handle @ file attachment completion
+            const newLine = `${beforePrefix + item.value} ${afterCursor}`;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return {
+                lines: newLines,
+                cursorLine,
+                cursorCol: beforePrefix.length + item.value.length + 1, // +1 for space
+            };
+        }
+        // If not an @ attachment, let other providers handle it
+        return { lines, cursorLine, cursorCol };
+    }
+    // Force file completion (called on Tab key) - always returns suggestions
+    async getForceFileSuggestions(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Check for @ file attachment syntax first
+        const atMatch = textBeforeCursor.match(/@([^\s]*)$/);
+        const pathMatch = atMatch ? atMatch[0] : null;
+        console.log("pathMatch", textBeforeCursor, pathMatch);
+        if (pathMatch !== null) {
+            let prefix = pathMatch; // Includes the @
+            // Handle @ file attachment prefix
+            if (prefix.startsWith("@")) {
+                prefix = prefix.slice(1); // Remove the @
+            }
+            else {
+                return null;
+            }
+            const suggestions = await this.getFileSuggestions(prefix);
+            if (suggestions.length === 0)
+                return null;
+            // For @ prefix, filter to only show directories and attachable files
+            const filteredSuggestions = [];
+            for (const suggestion of suggestions) {
+                if (!suggestion.value.endsWith("/") &&
+                    !isAttachableFile(suggestion.value)) {
+                    continue;
+                }
+                suggestion.value = `@${suggestion.value}`;
+                filteredSuggestions.push(suggestion);
+            }
+            if (filteredSuggestions.length === 0)
+                return null;
+            return {
+                items: suggestions,
+                prefix: pathMatch,
+            };
+        }
+        return null;
+    }
+}
+function isAttachableFile(filePath) {
+    // Check file extension for common text files that might be misidentified
+    const textExtensions = [
+        ".txt",
+        ".md",
+        ".markdown",
+        ".js",
+        ".ts",
+        ".tsx",
+        ".jsx",
+        ".py",
+        ".java",
+        ".c",
+        ".cpp",
+        ".h",
+        ".hpp",
+        ".cs",
+        ".php",
+        ".rb",
+        ".go",
+        ".rs",
+        ".swift",
+        ".kt",
+        ".scala",
+        ".sh",
+        ".bash",
+        ".zsh",
+        ".fish",
+        ".html",
+        ".htm",
+        ".css",
+        ".scss",
+        ".sass",
+        ".less",
+        ".xml",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".toml",
+        ".ini",
+        ".cfg",
+        ".conf",
+        ".log",
+        ".sql",
+        ".r",
+        ".R",
+        ".m",
+        ".pl",
+        ".lua",
+        ".vim",
+        ".dockerfile",
+        ".makefile",
+        ".cmake",
+        ".gradle",
+        ".maven",
+        ".properties",
+        ".env",
+    ];
+    const ext = extname(filePath).toLowerCase();
+    return textExtensions.includes(ext);
+}