@travisennis/acai 0.0.6 → 0.0.8

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

@@ -0,0 +1,90 @@
+export class CommandProvider {
+    commands;
+    constructor(commands = []) {
+        this.commands = commands;
+    }
+    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,
+            };
+        }
+        return null;
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        const currentLine = lines[cursorLine] || "";
+        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 beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+            const afterCursor = currentLine.slice(cursorCol);
+            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 beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+            const afterCursor = currentLine.slice(cursorCol);
+            const newLine = beforePrefix + item.value + afterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return {
+                lines: newLines,
+                cursorLine,
+                cursorCol: beforePrefix.length + item.value.length,
+            };
+        }
+        // If we get here, this provider shouldn't handle the completion
+        // Return unchanged to let other providers handle it
+        return { lines, cursorLine, cursorCol };
+    }
+}

package/dist/tui/autocomplete/file-search-provider.d.ts

@@ -0,0 +1,16 @@
+import type { AutocompleteItem, AutocompleteProvider } from "./base-provider.ts";
+export declare class FileSearchProvider implements AutocompleteProvider {
+    private maxResults;
+    private maxDepth;
+    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 searchFiles;
+}
+//# sourceMappingURL=file-search-provider.d.ts.map

package/dist/tui/autocomplete/file-search-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-search-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/file-search-provider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AA+B5B,qBAAa,kBAAmB,YAAW,oBAAoB;IAC7D,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,QAAQ,CAAK;IAEf,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;IAuBhE,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;YAqB/C,WAAW;CA+D1B"}

package/dist/tui/autocomplete/file-search-provider.js

@@ -0,0 +1,123 @@
+import { readFile } from "node:fs/promises";
+import { join, normalize, relative, resolve } from "node:path";
+import { fdir } from "fdir";
+import ignore from "../../utils/ignore.js";
+const defaultIgnoredPatterns = [
+    "**/node_modules",
+    "**/dist",
+    "**/.git",
+    "**/coverage",
+    "**/flow-typed",
+    "**/.DS_Store",
+    "**/*.log",
+    "**/*.lock",
+];
+async function loadGitignorePatterns(cwd) {
+    const gitignorePath = join(cwd, ".gitignore");
+    try {
+        const content = await readFile(gitignorePath, "utf8");
+        const patterns = [];
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            patterns.push(trimmed);
+        }
+        return patterns;
+    }
+    catch {
+        return [];
+    }
+}
+export class FileSearchProvider {
+    maxResults = 20;
+    maxDepth = 3;
+    async getSuggestions(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        const pathMatch = textBeforeCursor.match(/#([^\s]*)$/);
+        if (!pathMatch) {
+            return null;
+        }
+        const prefix = pathMatch[0];
+        const searchTerm = pathMatch[1];
+        const suggestions = await this.searchFiles(searchTerm);
+        if (suggestions.length === 0) {
+            return null;
+        }
+        return {
+            items: suggestions,
+            prefix,
+        };
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        // Only handle completions that start with #
+        if (!prefix.startsWith("#")) {
+            return { lines, cursorLine, cursorCol };
+        }
+        const currentLine = lines[cursorLine] || "";
+        const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+        const afterCursor = currentLine.slice(cursorCol);
+        const newLine = `${beforePrefix}${item.value} ${afterCursor}`;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return {
+            lines: newLines,
+            cursorLine,
+            cursorCol: beforePrefix.length + item.value.length + 1,
+        };
+    }
+    async searchFiles(searchTerm) {
+        const results = [];
+        const cwd = process.cwd();
+        // Build ignore instance with .gitignore patterns + defaults
+        const ig = ignore().add(defaultIgnoredPatterns);
+        const gitignorePatterns = await loadGitignorePatterns(cwd);
+        if (gitignorePatterns.length > 0) {
+            ig.add(gitignorePatterns);
+        }
+        try {
+            const crawler = new fdir()
+                .withBasePath()
+                .withMaxDepth(this.maxDepth)
+                .exclude((dirName, dirPath) => {
+                const fullPath = dirPath ? `${dirPath}/${dirName}` : dirName;
+                const absolutePath = resolve(cwd, fullPath);
+                const relativePath = normalize(relative(cwd, absolutePath));
+                return ig.ignores(relativePath);
+            });
+            const files = await crawler.crawl(cwd).withPromise();
+            const lowerSearchTerm = searchTerm.toLowerCase();
+            const matches = files.filter((file) => file.toLowerCase().includes(lowerSearchTerm));
+            for (const match of matches) {
+                const absolutePath = resolve(cwd, match);
+                const relativePath = normalize(relative(cwd, absolutePath));
+                if (ig.ignores(relativePath)) {
+                    continue;
+                }
+                const isDirectory = match.endsWith("/");
+                const pathWithoutTrailingSlash = isDirectory
+                    ? match.slice(0, -1)
+                    : match;
+                const label = pathWithoutTrailingSlash.split("/").pop() || pathWithoutTrailingSlash;
+                const parentPath = pathWithoutTrailingSlash
+                    .split("/")
+                    .slice(0, -1)
+                    .join("/");
+                results.push({
+                    value: isDirectory ? `${match} ` : match,
+                    label,
+                    description: parentPath || ".",
+                });
+                if (results.length >= this.maxResults) {
+                    break;
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or not accessible
+        }
+        return results;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { AutocompleteItem, AutocompleteProvider } from "./base-provider.ts";
+export declare class PathProvider implements AutocompleteProvider {
+    protected allowedDirs: string[];
+    constructor(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;
+    };
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+    protected getFileSuggestions(prefix: string): Promise<AutocompleteItem[]>;
+}
+//# sourceMappingURL=path-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/path-provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAQ5B,qBAAa,YAAa,YAAW,oBAAoB;IACvD,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;gBAEpB,WAAW,GAAE,MAAM,EAAoB;IAI7C,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;IAoBhE,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;IAkBvD,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;IAoBhE,2BAA2B,CACzB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO;cAaM,kBAAkB,CAChC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,EAAE,CAAC;CAgH/B"}

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

@@ -0,0 +1,164 @@
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { extractPathPrefix, getDirectoryEntries, isPathWithinAllowedDirs, } from "./utils.js";
+export class PathProvider {
+    allowedDirs;
+    constructor(allowedDirs = [process.cwd()]) {
+        this.allowedDirs = allowedDirs;
+    }
+    async getSuggestions(lines, cursorLine, cursorCol) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // Check for file paths - triggered by Tab or if we detect a path pattern
+        const pathMatch = 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);
+        // 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,
+        };
+    }
+    // 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);
+        // Force extract path prefix - this will always return something
+        const pathMatch = 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;
+    }
+    // Get file/directory suggestions for a given path prefix
+    async getFileSuggestions(prefix) {
+        try {
+            let searchDirs;
+            let searchPrefix;
+            if (prefix === "" || prefix === "./" || prefix === "../") {
+                searchDirs = this.allowedDirs;
+                searchPrefix = "";
+            }
+            else if (isAbsolute(prefix)) {
+                // Handle absolute paths
+                const isWithinAllowed = await isPathWithinAllowedDirs(prefix, this.allowedDirs);
+                if (!isWithinAllowed) {
+                    return [];
+                }
+                if (prefix.endsWith("/")) {
+                    searchDirs = [prefix];
+                    searchPrefix = "";
+                }
+                else {
+                    searchDirs = [dirname(prefix)];
+                    searchPrefix = basename(prefix);
+                }
+            }
+            else if (prefix.endsWith("/")) {
+                // If prefix ends with /, show contents of that directory
+                // Try to find which allowed directory this path belongs to
+                const allowedDirs = [];
+                for (const allowedDir of this.allowedDirs) {
+                    const resolvedPath = join(allowedDir, prefix);
+                    const isWithinAllowed = await isPathWithinAllowedDirs(resolvedPath, this.allowedDirs);
+                    if (isWithinAllowed) {
+                        allowedDirs.push(resolvedPath);
+                    }
+                }
+                if (allowedDirs.length === 0) {
+                    return [];
+                }
+                searchDirs = allowedDirs;
+                searchPrefix = "";
+            }
+            else {
+                // Split into directory and file prefix
+                const dir = dirname(prefix);
+                const file = basename(prefix);
+                const allowedDirs = [];
+                for (const allowedDir of this.allowedDirs) {
+                    const resolvedPath = join(allowedDir, dir);
+                    const isWithinAllowed = await isPathWithinAllowedDirs(resolvedPath, this.allowedDirs);
+                    if (isWithinAllowed) {
+                        allowedDirs.push(resolvedPath);
+                    }
+                }
+                if (allowedDirs.length === 0) {
+                    return [];
+                }
+                searchDirs = allowedDirs;
+                searchPrefix = file;
+            }
+            const entries = await getDirectoryEntries(searchDirs);
+            const suggestions = [];
+            // Filter entries by prefix first (fast string operation)
+            const matchingEntries = entries.filter((entry) => entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase()));
+            // Batch check allowed paths (reduces repeated realpath calls)
+            const validEntries = [];
+            for (const entry of matchingEntries) {
+                const fullPath = join(entry.parentPath, entry.name);
+                if (await isPathWithinAllowedDirs(fullPath, this.allowedDirs)) {
+                    validEntries.push({ entry, fullPath });
+                }
+            }
+            for (const { entry, fullPath } of validEntries) {
+                // Use Dirent.isDirectory() - no extra stat() call needed
+                const isDirectory = entry.isDirectory();
+                suggestions.push({
+                    value: isDirectory ? `${fullPath}/` : fullPath,
+                    label: entry.name,
+                    description: isDirectory
+                        ? `directory ${entry.parentPath}`
+                        : `file ${entry.parentPath}`,
+                });
+            }
+            // 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 [];
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { Dirent } from "node:fs";
+export declare class DirectoryCache {
+    private cache;
+    private ttl;
+    get(dir: string): Promise<Dirent[] | null>;
+    set(dir: string, entries: Dirent[]): void;
+    clear(): void;
+}
+export declare const directoryCache: DirectoryCache;
+export interface DirentWithPath extends Dirent {
+    parentPath: string;
+}
+export declare function getDirectoryEntries(dirs: string[]): Promise<DirentWithPath[]>;
+export declare function isPathWithinAllowedDirs(requestedPath: string, allowedDirs: string[]): Promise<boolean>;
+export declare function extractPathPrefix(text: string, forceExtract?: boolean): string | null;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKtC,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAA+D;IAC5E,OAAO,CAAC,GAAG,CAAQ;IAEb,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;IAQhD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIzC,KAAK,IAAI,IAAI;CAGd;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC;AAGnD,MAAM,WAAW,cAAe,SAAQ,MAAM;IAC5C,UAAU,EAAE,MAAM,CAAC;CACpB;AAGD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,cAAc,EAAE,CAAC,CA4B3B;AA8BD,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAWlB;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,YAAY,UAAQ,GACnB,MAAM,GAAG,IAAI,CAgEf"}

package/dist/tui/autocomplete/utils.js

@@ -0,0 +1,137 @@
+import { readdir, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+// Cache for directory listings to improve performance
+export 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();
+    }
+}
+export const directoryCache = new DirectoryCache();
+// Helper function to get directory entries with caching and timeout
+export async function getDirectoryEntries(dirs) {
+    const results = [];
+    for (const dir of dirs) {
+        const cached = await directoryCache.get(dir);
+        if (cached) {
+            for (const entry of cached) {
+                results.push(Object.assign(entry, { parentPath: dir }));
+            }
+            continue;
+        }
+        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);
+            for (const entry of entries) {
+                results.push(Object.assign(entry, { parentPath: dir }));
+            }
+        }
+        catch (_e) {
+            // ignore
+        }
+    }
+    return results;
+}
+// Cache for resolved allowed directories to avoid repeated realpath calls
+const resolvedAllowedDirsCache = new Map();
+async function getResolvedPath(path) {
+    const cached = resolvedAllowedDirsCache.get(path);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const absPath = resolve(path);
+    let resolved = absPath;
+    try {
+        resolved = await realpath(absPath);
+    }
+    catch {
+        // If path doesn't exist, use the resolved absolute path
+    }
+    // Cache with a size limit
+    if (resolvedAllowedDirsCache.size > 500) {
+        const firstKey = resolvedAllowedDirsCache.keys().next().value;
+        if (firstKey !== undefined) {
+            resolvedAllowedDirsCache.delete(firstKey);
+        }
+    }
+    resolvedAllowedDirsCache.set(path, resolved);
+    return resolved;
+}
+export async function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
+    const target = await getResolvedPath(requestedPath);
+    for (const allowedDir of allowedDirs) {
+        const absAllowed = await getResolvedPath(allowedDir);
+        const rel = relative(absAllowed, target);
+        if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) {
+            return true;
+        }
+    }
+    return false;
+}
+export function extractPathPrefix(text, forceExtract = false) {
+    // 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}|\.{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;
+}

package/dist/tui/autocomplete.d.ts

@@ -1,44 +1,13 @@
-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;
-}
+import type { AutocompleteItem } from "./autocomplete/base-provider.ts";
+import { CombinedProvider } from "./autocomplete/combined-provider.ts";
+import { type SlashCommand } from "./autocomplete/command-provider.ts";
+export { AttachmentProvider } from "./autocomplete/attachment-provider.ts";
+export type { AutocompleteItem, AutocompleteProvider, } from "./autocomplete/base-provider.ts";
+export { CombinedProvider } from "./autocomplete/combined-provider.ts";
+export type { SlashCommand } from "./autocomplete/command-provider.ts";
+export { CommandProvider } from "./autocomplete/command-provider.ts";
+export { FileSearchProvider } from "./autocomplete/file-search-provider.ts";
+export { PathProvider } from "./autocomplete/path-provider.ts";
+export { DirectoryCache, directoryCache, extractPathPrefix, getDirectoryEntries, isPathWithinAllowedDirs, } from "./autocomplete/utils.ts";
+export declare function createDefaultProvider<T extends SlashCommand | AutocompleteItem>(commands?: T[], allowedDirs?: string[]): CombinedProvider;
 //# sourceMappingURL=autocomplete.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../source/tui/autocomplete.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,oCAAoC,CAAC;AAI5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,YAAY,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EACL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAGjC,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,YAAY,GAAG,gBAAgB,EACzC,QAAQ,GAAE,CAAC,EAAO,EAAE,WAAW,GAAE,MAAM,EAAoB,oBAO5D"}