@travisennis/acai 0.0.7 → 0.0.8

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

@@ -0,0 +1,17 @@
+export interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+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;
+    };
+}
+//# sourceMappingURL=base-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/base-provider.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IAGnC,cAAc,CACZ,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,CAAC;IAIjE,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,CAAC;CAC/D"}

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"combined-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/combined-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,gBAAiB,YAAW,oBAAoB;IAC3D,OAAO,CAAC,SAAS,CAAyB;gBAE9B,SAAS,EAAE,oBAAoB,EAAE;IAIvC,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;IAehE,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;IAwBvD,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;IAwBhE,2BAA2B,CACzB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO;CAmBX"}

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

@@ -0,0 +1,61 @@
+export class CombinedProvider {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    async getSuggestions(lines, cursorLine, cursorCol) {
+        // Try each provider in order until we get suggestions
+        for (const provider of this.providers) {
+            const result = await provider.getSuggestions(lines, cursorLine, cursorCol);
+            if (result) {
+                return result;
+            }
+        }
+        return null;
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        // Try each provider to find the one that can handle this completion
+        for (const provider of this.providers) {
+            const result = provider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+            // If the result is different from input, this provider handled it
+            if (result.lines !== lines ||
+                result.cursorLine !== cursorLine ||
+                result.cursorCol !== cursorCol) {
+                return result;
+            }
+        }
+        // If no provider handled it, return unchanged
+        return { lines, cursorLine, cursorCol };
+    }
+    // Force file completion (called on Tab key) - always returns suggestions
+    async getForceFileSuggestions(lines, cursorLine, cursorCol) {
+        if (!this.shouldTriggerFileCompletion(lines, cursorLine, cursorCol)) {
+            return null;
+        }
+        // Try each provider that has getForceFileSuggestions method
+        for (const provider of this.providers) {
+            if ("getForceFileSuggestions" in provider &&
+                typeof provider.getForceFileSuggestions === "function") {
+                const result = await provider.getForceFileSuggestions(lines, cursorLine, cursorCol);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    // Check if we should trigger file completion (called on Tab key)
+    shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+        // Try each provider that has shouldTriggerFileCompletion method
+        for (const provider of this.providers) {
+            if ("shouldTriggerFileCompletion" in provider &&
+                typeof provider.shouldTriggerFileCompletion === "function") {
+                const result = provider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+                if (result === false) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { AutocompleteItem, AutocompleteProvider } from "./base-provider.ts";
+export interface SlashCommand {
+    name: string;
+    description?: string;
+    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+}
+export declare class CommandProvider<T extends SlashCommand | AutocompleteItem> implements AutocompleteProvider {
+    private commands;
+    constructor(commands?: T[]);
+    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;
+    };
+}
+//# sourceMappingURL=command-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-provider.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/command-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,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,qBAAa,eAAe,CAAC,CAAC,SAAS,YAAY,GAAG,gBAAgB,CACpE,YAAW,oBAAoB;IAE/B,OAAO,CAAC,QAAQ,CAAM;gBAEV,QAAQ,GAAE,CAAC,EAAO;IAIxB,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;IA8DhE,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;CAwC9D"}

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"}