@travisennis/acai 0.0.5 → 0.0.7

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;
+    }
+}

package/dist/tui/components/assistant-message.d.ts

@@ -0,0 +1,18 @@
+import { Container } from "../tui.ts";
+/**
+ * Component that renders a complete assistant message
+ */
+export declare class AssistantMessageComponent extends Container {
+    private contentContainer;
+    constructor(message?: {
+        type: "message-start" | "message" | "message-end";
+        role: "assistant";
+        content: string;
+    });
+    updateContent(message: {
+        type: "message-start" | "message" | "message-end";
+        role: "assistant";
+        content: string;
+    }): void;
+}
+//# sourceMappingURL=assistant-message.d.ts.map

package/dist/tui/components/assistant-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-message.d.ts","sourceRoot":"","sources":["../../../source/tui/components/assistant-message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACtD,OAAO,CAAC,gBAAgB,CAAY;gBAExB,OAAO,CAAC,EAAE;QACpB,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,aAAa,CAAC;QAClD,IAAI,EAAE,WAAW,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB;IAYD,aAAa,CAAC,OAAO,EAAE;QACrB,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,aAAa,CAAC;QAClD,IAAI,EAAE,WAAW,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,GAAG,IAAI;CAeT"}

package/dist/tui/components/assistant-message.js

@@ -0,0 +1,29 @@
+import { Container } from "../tui.js";
+import { Markdown } from "./markdown.js";
+import { Spacer } from "./spacer.js";
+/**
+ * Component that renders a complete assistant message
+ */
+export class AssistantMessageComponent extends Container {
+    contentContainer;
+    constructor(message) {
+        super();
+        // Container for text/thinking content
+        this.contentContainer = new Container();
+        this.addChild(this.contentContainer);
+        if (message) {
+            this.updateContent(message);
+        }
+    }
+    updateContent(message) {
+        // Clear content container
+        this.contentContainer.clear();
+        if (message.content.length > 0) {
+            this.contentContainer.addChild(new Spacer(1));
+        }
+        const content = message.content;
+        // Assistant text messages with no background - trim the text
+        // Set paddingY=0 to avoid extra spacing before tool executions
+        this.contentContainer.addChild(new Markdown(content.trim(), { paddingX: 1, paddingY: 0 }));
+    }
+}

package/dist/tui/components/box.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from "../tui.ts";
+/**
+ * Box component - displays content in a bordered box with header
+ */
+export declare class BoxComponent implements Component {
+    private header;
+    private content;
+    private width;
+    private cachedOutput?;
+    private cachedHeader?;
+    private cachedContent?;
+    private cachedWidth?;
+    constructor(header: string, content: string, width?: number);
+    setHeader(header: string): void;
+    setContent(content: string): void;
+    setWidth(width: number): void;
+    private invalidateCache;
+    render(width: number): string[];
+}
+//# sourceMappingURL=box.d.ts.map

package/dist/tui/components/box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box.d.ts","sourceRoot":"","sources":["../../../source/tui/components/box.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;GAEG;AACH,qBAAa,YAAa,YAAW,SAAS;IAC5C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IAGtB,OAAO,CAAC,YAAY,CAAC,CAAW;IAChC,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAS;gBAEjB,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAM3D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B,OAAO,CAAC,eAAe;IAOvB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CAuDhC"}

package/dist/tui/components/box.js

@@ -0,0 +1,81 @@
+import { getTerminalSize } from "../../terminal/control.js";
+import { applyMarkdown } from "../../terminal/markdown.js";
+import stripAnsi from "../../terminal/strip-ansi.js";
+import wrapAnsi from "../../terminal/wrap-ansi.js";
+/**
+ * Box component - displays content in a bordered box with header
+ */
+export class BoxComponent {
+    header;
+    content;
+    width;
+    // Cache for rendered output
+    cachedOutput;
+    cachedHeader;
+    cachedContent;
+    cachedWidth;
+    constructor(header, content, width) {
+        this.header = header;
+        this.content = content;
+        this.width = width || 0;
+    }
+    setHeader(header) {
+        this.header = header;
+        this.invalidateCache();
+    }
+    setContent(content) {
+        this.content = content;
+        this.invalidateCache();
+    }
+    setWidth(width) {
+        this.width = width;
+        this.invalidateCache();
+    }
+    invalidateCache() {
+        this.cachedOutput = undefined;
+        this.cachedHeader = undefined;
+        this.cachedContent = undefined;
+        this.cachedWidth = undefined;
+    }
+    render(width) {
+        // Use provided width if specified, otherwise use component width or terminal size
+        let renderWidth = width || this.width;
+        if (renderWidth === 0) {
+            const { columns } = getTerminalSize();
+            const cols = columns > 0 ? columns : 80;
+            renderWidth = Math.max(4, cols - 4);
+        }
+        // Check cache
+        if (this.cachedOutput &&
+            this.cachedHeader === this.header &&
+            this.cachedContent === this.content &&
+            this.cachedWidth === renderWidth) {
+            return this.cachedOutput;
+        }
+        const paddedHeader = ` ${this.header} `;
+        const headerVisibleLen = stripAnsi(paddedHeader).length;
+        const headerStartPos = 1;
+        // Top border with header (use visible header length)
+        const leftDashes = headerStartPos;
+        const rightDashes = Math.max(0, renderWidth - leftDashes - headerVisibleLen);
+        const topBorder = `┌${"─".repeat(leftDashes)}${paddedHeader}${"─".repeat(rightDashes)}┐`;
+        // Prepare inner content: format markdown first, then wrap to inner width
+        const innerWidth = Math.max(1, renderWidth - 2);
+        const formatted = applyMarkdown(this.content);
+        const wrapped = wrapAnsi(formatted, innerWidth, { trim: false });
+        const contentLines = wrapped.split("\n").map((line) => {
+            const visibleLen = stripAnsi(line).length;
+            const padCount = Math.max(0, innerWidth - visibleLen);
+            return `│ ${line}${" ".repeat(padCount)} │`;
+        });
+        // Bottom border
+        const bottomBorder = `└${"─".repeat(renderWidth)}┘`;
+        const result = [topBorder, ...contentLines, bottomBorder];
+        // Update cache
+        this.cachedOutput = result;
+        this.cachedHeader = this.header;
+        this.cachedContent = this.content;
+        this.cachedWidth = renderWidth;
+        return result;
+    }
+}