@travisennis/acai 0.0.4 → 0.0.6

package/dist/tools/web-search.js

@@ -1,68 +1,121 @@
-import { tool } from "ai";
-import chalk from "chalk";
 import { SafeSearchType, search } from "duck-duck-scrape";
-import Exa from "exa-js";
 import { z } from "zod";
+import Exa from "../api/exa/index.js";
+import style from "../terminal/style.js";
+import { manageTokenLimit } from "../tokens/threshold.js";
 export const WebSearchTool = {
     name: "webSearch",
 };
-export const createWebSearchTool = ({ sendData, tokenCounter, }) => {
+const inputSchema = z.object({
+    query: z.string().describe("The search query."),
+});
+export const createWebSearchTool = ({ tokenCounter, }) => {
+    const toolDef = {
+        description: "Searches the web and returns match documents with their title, url, and text content. The query should be formulated as a natural language question.",
+        inputSchema,
+    };
+    const execute = async function* ({ query }, { toolCallId, abortSignal }) {
+        try {
+            // Check if execution has been aborted
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted");
+            }
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-init",
+                id: toolCallId,
+                data: `${style.cyan(query)}`,
+            };
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted before search execution");
+            }
+            const result = await performSearch(query, abortSignal);
+            const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
+            const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
+            const searchResult = await manageTokenLimit(resultText, tokenCounter, "WebSearch", "Use more specific search queries or reduce number of results");
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-completion",
+                id: toolCallId,
+                data: `Found ${result.results.length} results (${searchResult.tokenCount} tokens)`,
+            };
+            yield searchResult.content;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-error",
+                id: toolCallId,
+                data: errorMessage,
+            };
+            yield errorMessage;
+        }
+    };
     return {
-        [WebSearchTool.name]: tool({
-            description: "Searches the web and returns match documents with their title, url, and text content. The query should be formulated as a natural language question.",
-            inputSchema: z.object({
-                query: z.string().describe("The search query."),
-            }),
-            execute: async ({ query }, { toolCallId }) => {
-                sendData?.({
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `Web search: ${chalk.cyan(query)}`,
-                });
-                const result = await performSearch(query);
-                const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
-                const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
-                const tokenCount = tokenCounter.count(resultText);
-                sendData?.({
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: `Found ${result.results.length} results. (${tokenCount} tokens)`,
-                });
-                return resultText;
-            },
-        }),
+        toolDef,
+        execute,
+        // No ask method needed for read-only tool
     };
 };
-async function performSearch(query) {
+async function performSearch(query, abortSignal) {
     // Check if EXA API key is available
     const hasExaApiKey = process.env["EXA_API_KEY"] && process.env["EXA_API_KEY"].trim() !== "";
     if (hasExaApiKey) {
         // Use Exa search
         try {
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted before Exa search");
+            }
             const exa = new Exa(process.env["EXA_API_KEY"]);
-            const result = await exa.searchAndContents(query, {
+            // Create a promise that races with the abort signal
+            const searchPromise = exa.searchAndContents(query, {
                 numResults: 5,
                 text: true,
             });
+            const result = await Promise.race([
+                searchPromise,
+                new Promise((_, reject) => {
+                    if (abortSignal) {
+                        abortSignal.addEventListener("abort", () => {
+                            reject(new Error("Web search aborted during Exa search"));
+                        });
+                    }
+                }),
+            ]);
             return result;
         }
         catch (error) {
             // If Exa fails, fall back to duck duck scrape
             console.info("Exa search failed, falling back to DuckDuckGo:", error);
-            return await searchWithDuckDuckGo(query);
+            return await searchWithDuckDuckGo(query, abortSignal);
         }
     }
     else {
         // Use DuckDuckGo search as fallback
         console.info("EXA_API_KEY not set, using DuckDuckGo search");
-        return await searchWithDuckDuckGo(query);
+        return await searchWithDuckDuckGo(query, abortSignal);
     }
 }
-async function searchWithDuckDuckGo(query) {
+async function searchWithDuckDuckGo(query, abortSignal) {
     try {
-        const searchResults = await search(query, {
+        if (abortSignal?.aborted) {
+            throw new Error("Web search aborted before DuckDuckGo search");
+        }
+        // Create a promise that races with the abort signal
+        const searchPromise = search(query, {
             safeSearch: SafeSearchType.MODERATE,
         });
+        const searchResults = await Promise.race([
+            searchPromise,
+            new Promise((_, reject) => {
+                if (abortSignal) {
+                    abortSignal.addEventListener("abort", () => {
+                        reject(new Error("Web search aborted during DuckDuckGo search"));
+                    });
+                }
+            }),
+        ]);
         // Transform duck-duck-scrape results to match Exa format
         // Take only first 5 results to match Exa behavior
         const results = searchResults.results

package/dist/tui/autocomplete.d.ts

@@ -0,0 +1,44 @@
+export interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface SlashCommand {
+    name: string;
+    description?: string;
+    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+}
+export interface AutocompleteProvider {
+    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;
+    };
+}
+export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+    private commands;
+    private allowedDirs;
+    constructor(commands?: (SlashCommand | AutocompleteItem)[], allowedDirs?: string[]);
+    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;
+    };
+    private extractPathPrefix;
+    private isPathWithinAllowedDirs;
+    private getFileSuggestions;
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+//# sourceMappingURL=autocomplete.d.ts.map

package/dist/tui/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../source/tui/autocomplete.ts"],"names":[],"mappings":"AAyHA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,sBAAsB,CAAC,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,EAAE,GAAG,IAAI,CAAC;CAC5E;AAED,MAAM,WAAW,oBAAoB;IAGnC,cAAc,CACZ,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QACT,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,IAAI,CAAC,CAAC;IAIV,eAAe,CACb,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACb;QACD,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAGD,qBAAa,4BAA6B,YAAW,oBAAoB;IACvE,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,WAAW,CAAW;gBAG5B,QAAQ,GAAE,CAAC,YAAY,GAAG,gBAAgB,CAAC,EAAO,EAClD,WAAW,GAAE,MAAM,EAAoB;IAMnC,cAAc,CAClB,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;IAyEhE,eAAe,CACb,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;IA6D7D,OAAO,CAAC,iBAAiB;YA8EX,uBAAuB;YAyBvB,kBAAkB;IAgJ1B,uBAAuB,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;IAyBhE,2BAA2B,CACzB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO;CAWX"}

package/dist/tui/autocomplete.js

@@ -0,0 +1,466 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, } from "node:path";
+// Cache for directory listings to improve performance
+class DirectoryCache {
+    cache = new Map();
+    ttl = 3000; // 3 seconds
+    async get(dir) {
+        const cached = this.cache.get(dir);
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            return cached.entries;
+        }
+        return null;
+    }
+    set(dir, entries) {
+        this.cache.set(dir, { entries, timestamp: Date.now() });
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const directoryCache = new DirectoryCache();
+// Helper function to get directory entries with caching and timeout
+async function getDirectoryEntries(dir) {
+    const cached = await directoryCache.get(dir);
+    if (cached) {
+        return cached;
+    }
+    try {
+        // Add timeout to prevent hanging on slow file systems
+        const entries = await Promise.race([
+            readdir(dir, { withFileTypes: true }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Directory read timeout")), 2000)),
+        ]);
+        directoryCache.set(dir, entries);
+        return entries;
+    }
+    catch (_e) {
+        return [];
+    }
+}
+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);
+}
+// Combined provider that handles both slash commands and file paths
+export class CombinedAutocompleteProvider {
+    commands;
+    allowedDirs;
+    constructor(commands = [], allowedDirs = [process.cwd()]) {
+        this.commands = commands;
+        this.allowedDirs = allowedDirs;
+    }
+    async getSuggestions(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Check for slash commands
+        if (textBeforeCursor.startsWith("/")) {
+            const spaceIndex = textBeforeCursor.indexOf(" ");
+            if (spaceIndex === -1) {
+                // No space yet - complete command names
+                const prefix = textBeforeCursor.slice(1); // Remove the "/"
+                const filtered = this.commands
+                    .filter((cmd) => {
+                    const name = "name" in cmd ? cmd.name : cmd.value; // Check if SlashCommand or AutocompleteItem
+                    return name?.toLowerCase().startsWith(prefix.toLowerCase());
+                })
+                    .map((cmd) => ({
+                    value: "name" in cmd ? cmd.name : cmd.value,
+                    label: "name" in cmd ? cmd.name : cmd.label,
+                    ...(cmd.description && { description: cmd.description }),
+                }));
+                if (filtered.length === 0)
+                    return null;
+                return {
+                    items: filtered,
+                    prefix: prefix, // Return the actual prefix used for filtering (without "/")
+                };
+            }
+            // Space found - complete command arguments
+            const commandName = textBeforeCursor.slice(1, spaceIndex); // Command without "/"
+            const argumentText = textBeforeCursor.slice(spaceIndex + 1); // Text after space
+            const command = this.commands.find((cmd) => {
+                const name = "name" in cmd ? cmd.name : cmd.value;
+                return name === commandName;
+            });
+            if (!command ||
+                !("getArgumentCompletions" in command) ||
+                !command.getArgumentCompletions) {
+                return null; // No argument completion for this command
+            }
+            const argumentSuggestions = command.getArgumentCompletions?.(argumentText);
+            if (!argumentSuggestions || argumentSuggestions.length === 0) {
+                return null;
+            }
+            return {
+                items: argumentSuggestions,
+                prefix: argumentText,
+            };
+        }
+        // Check for file paths - triggered by Tab or if we detect a path pattern
+        const pathMatch = this.extractPathPrefix(textBeforeCursor, false);
+        if (pathMatch !== null) {
+            const suggestions = await this.getFileSuggestions(pathMatch);
+            if (suggestions.length === 0)
+                return null;
+            return {
+                items: suggestions,
+                prefix: pathMatch,
+            };
+        }
+        return null;
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        const currentLine = lines[cursorLine] || "";
+        const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+        const afterCursor = currentLine.slice(cursorCol);
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Check if we're completing a slash command (prefix doesn't start with "/" but we're in slash command context)
+        if (textBeforeCursor.startsWith("/") && !textBeforeCursor.includes(" ")) {
+            // This is a command name 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
+            };
+        }
+        // Check if we're completing a file attachment (prefix starts with "@")
+        if (prefix.startsWith("@")) {
+            // This is a 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
+            };
+        }
+        // Check if we're in a slash command context (beforePrefix contains "/command ")
+        if (textBeforeCursor.includes("/") && textBeforeCursor.includes(" ")) {
+            // This is likely a command argument completion
+            const newLine = beforePrefix + item.value + afterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return {
+                lines: newLines,
+                cursorLine,
+                cursorCol: beforePrefix.length + item.value.length,
+            };
+        }
+        // For file paths, complete the path
+        const newLine = beforePrefix + item.value + afterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return {
+            lines: newLines,
+            cursorLine,
+            cursorCol: beforePrefix.length + item.value.length,
+        };
+    }
+    // Extract a path-like prefix from the text before cursor
+    extractPathPrefix(text, forceExtract = false) {
+        // Check for @ file attachment syntax first
+        const atMatch = text.match(/@([^\s]*)$/);
+        if (atMatch) {
+            // For forced extraction, always return the @ prefix
+            if (forceExtract) {
+                return atMatch[0];
+            }
+            // For natural triggers, always return @ prefixes (they're always file-related)
+            return atMatch[0];
+        }
+        // Match paths - more conservative approach to avoid matching already completed paths
+        // This regex captures:
+        // - Paths starting from beginning of line or after space
+        // - Optional ./ or ../ or ~/ prefix
+        // - The path itself (must contain at least one / or start with ./ or ../ or ~/)
+        const matches = text.match(/(?:^|\s)((?:\.{1,2}\/|~\/)?(?:[^\s]*\/)*[^\s/]*)$/);
+        if (!matches) {
+            // If forced extraction and no matches, return empty string to trigger from current dir
+            return forceExtract ? "" : null;
+        }
+        const pathPrefix = matches[1] || "";
+        // For forced extraction (Tab key), always return something
+        if (forceExtract) {
+            // If we're not in a clear path context and we're at the end of a word,
+            // return empty string to complete from current directory
+            if (!pathPrefix.includes("/") &&
+                !pathPrefix.endsWith("/") &&
+                !pathPrefix.startsWith(".") &&
+                !pathPrefix.startsWith("~/")) {
+                // Only return empty string if we're at the beginning or after space
+                // This prevents completing "source" as empty string
+                if (text === "" || text.endsWith(" ")) {
+                    return "";
+                }
+            }
+            return pathPrefix;
+        }
+        // For natural triggers, be more conservative:
+        // Only trigger if we have a clear path indicator
+        const hasPathIndicator = pathPrefix.includes("/") ||
+            pathPrefix.endsWith("/") ||
+            pathPrefix.startsWith(".") ||
+            pathPrefix.startsWith("~/");
+        if (!hasPathIndicator) {
+            return null;
+        }
+        // Additional check: don't trigger if the path looks like it's already completed
+        // (i.e., doesn't end with a partial filename)
+        // Only apply this check for paths that don't have clear path indicators
+        // and look like single directory names (no path separators)
+        if (!pathPrefix.includes("/") &&
+            !pathPrefix.includes(".") &&
+            !pathPrefix.startsWith("./") &&
+            !pathPrefix.startsWith("../") &&
+            !pathPrefix.startsWith("~/") &&
+            pathPrefix.length > 3) {
+            // This might be a completed directory name, not a partial path
+            return null;
+        }
+        return pathPrefix;
+    }
+    // Check if a path is within any allowed directory
+    async isPathWithinAllowedDirs(requestedPath) {
+        for (const allowedDir of this.allowedDirs) {
+            // Resolve both paths to handle relative paths and symlinks
+            const absRequested = resolve(requestedPath);
+            const absAllowed = resolve(allowedDir);
+            let target = absRequested;
+            try {
+                // Try to resolve symlinks for the target path
+                target = await realpath(absRequested);
+            }
+            catch {
+                // If target doesn't exist, use the intended path
+            }
+            const rel = relative(absAllowed, target);
+            if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Get file/directory suggestions for a given path prefix
+    async getFileSuggestions(prefix) {
+        try {
+            let searchDir;
+            let searchPrefix;
+            let expandedPrefix = prefix;
+            let isAtPrefix = false;
+            // Handle @ file attachment prefix
+            if (prefix.startsWith("@")) {
+                isAtPrefix = true;
+                expandedPrefix = prefix.slice(1); // Remove the @
+            }
+            // Remove home directory expansion - not allowed
+            if (expandedPrefix.startsWith("~")) {
+                // Home directory access not allowed - return empty suggestions
+                return [];
+            }
+            // Check if we're trying to access root - not allowed
+            if (expandedPrefix.startsWith("/")) {
+                // Root access not allowed - return empty suggestions
+                return [];
+            }
+            if (expandedPrefix === "" ||
+                expandedPrefix === "./" ||
+                expandedPrefix === "../" ||
+                prefix === "@") {
+                // Start from primary directory
+                searchDir = this.allowedDirs[0];
+                searchPrefix = "";
+            }
+            else if (expandedPrefix.endsWith("/")) {
+                // If prefix ends with /, show contents of that directory
+                // Try to find which allowed directory this path belongs to
+                const resolvedPath = join(this.allowedDirs[0], expandedPrefix);
+                const isWithinAllowed = await this.isPathWithinAllowedDirs(resolvedPath);
+                if (!isWithinAllowed) {
+                    return [];
+                }
+                searchDir = resolvedPath;
+                searchPrefix = "";
+            }
+            else {
+                // Split into directory and file prefix
+                const dir = dirname(expandedPrefix);
+                const file = basename(expandedPrefix);
+                const resolvedPath = join(this.allowedDirs[0], dir);
+                // Check if the resolved path is within allowed directories
+                const isWithinAllowed = await this.isPathWithinAllowedDirs(resolvedPath);
+                if (!isWithinAllowed) {
+                    return [];
+                }
+                searchDir = resolvedPath;
+                searchPrefix = file;
+            }
+            const entries = await getDirectoryEntries(searchDir);
+            const suggestions = [];
+            for (const entry of entries) {
+                const entryName = entry.name;
+                if (!entryName.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
+                    continue;
+                }
+                const fullPath = join(searchDir, entryName);
+                let isDirectory = false;
+                try {
+                    // Add timeout to prevent hanging on slow file systems
+                    const stats = await Promise.race([
+                        stat(fullPath),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("File stat timeout")), 1000)),
+                    ]);
+                    isDirectory = stats.isDirectory();
+                }
+                catch {
+                    // If stat fails or times out, skip this entry
+                    continue;
+                }
+                // For @ prefix, filter to only show directories and attachable files
+                if (isAtPrefix && !isDirectory && !isAttachableFile(fullPath)) {
+                    continue;
+                }
+                // Check if the resulting path is within allowed directories
+                if (!(await this.isPathWithinAllowedDirs(fullPath))) {
+                    continue;
+                }
+                let relativePath;
+                // Handle @ prefix path construction
+                if (isAtPrefix) {
+                    const pathWithoutAt = expandedPrefix;
+                    if (pathWithoutAt.endsWith("/")) {
+                        relativePath = `@${pathWithoutAt}${entryName}`;
+                    }
+                    else if (pathWithoutAt.includes("/")) {
+                        relativePath = `@${join(dirname(pathWithoutAt), entryName)}`;
+                    }
+                    else {
+                        relativePath = `@${entryName}`;
+                    }
+                }
+                else if (prefix.endsWith("/")) {
+                    // If prefix ends with /, append entry to the prefix
+                    relativePath = prefix + entryName;
+                }
+                else if (prefix.includes("/")) {
+                    relativePath = join(dirname(prefix), entryName);
+                }
+                else {
+                    relativePath = entryName;
+                }
+                suggestions.push({
+                    value: isDirectory ? `${relativePath}/` : relativePath,
+                    label: entryName,
+                    description: isDirectory ? "directory" : "file",
+                });
+            }
+            // Sort directories first, then alphabetically
+            suggestions.sort((a, b) => {
+                const aIsDir = a.description === "directory";
+                const bIsDir = b.description === "directory";
+                if (aIsDir && !bIsDir)
+                    return -1;
+                if (!aIsDir && bIsDir)
+                    return 1;
+                return a.label.localeCompare(b.label);
+            });
+            return suggestions;
+        }
+        catch (_e) {
+            // Directory doesn't exist or not accessible
+            return [];
+        }
+    }
+    // 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);
+        // Don't trigger if we're in a slash command
+        if (textBeforeCursor.startsWith("/") && !textBeforeCursor.includes(" ")) {
+            return null;
+        }
+        // Force extract path prefix - this will always return something
+        const pathMatch = this.extractPathPrefix(textBeforeCursor, true);
+        if (pathMatch !== null) {
+            const suggestions = await this.getFileSuggestions(pathMatch);
+            if (suggestions.length === 0)
+                return null;
+            return {
+                items: suggestions,
+                prefix: pathMatch,
+            };
+        }
+        return null;
+    }
+    // Check if we should trigger file completion (called on Tab key)
+    shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Don't trigger if we're in a slash command
+        if (textBeforeCursor.startsWith("/") && !textBeforeCursor.includes(" ")) {
+            return false;
+        }
+        return true;
+    }
+}