@compilr-dev/cli 0.4.0

package/dist/ui/file-autocomplete.d.ts

@@ -0,0 +1,45 @@
+/**
+ * File Path Autocomplete
+ *
+ * Uses ripgrep to provide fast file/folder suggestions when user types @path
+ */
+export interface FileMatch {
+    /** Display name (filename or dirname/) */
+    name: string;
+    /** Full path from cwd */
+    path: string;
+    /** Is this a directory? */
+    isDirectory: boolean;
+}
+/**
+ * Get file/folder matches for a partial path
+ *
+ * @param partial - The partial path after @ (e.g., "src/comp" or "package")
+ * @param cwd - Current working directory
+ * @returns Array of matching files/folders
+ */
+export declare function getFileMatches(partial: string, cwd?: string): FileMatch[];
+/**
+ * Extract the @ mention from input text
+ *
+ * @param input - Full input text
+ * @param cursorPos - Current cursor position
+ * @returns The partial path after @ or null if not in @ context
+ */
+export declare function extractAtMention(input: string, cursorPos: number): string | null;
+/**
+ * Replace the @ mention with completed path
+ *
+ * @param input - Full input text
+ * @param cursorPos - Current cursor position
+ * @param completedPath - The completed path to insert
+ * @returns New input text and new cursor position
+ */
+export declare function replaceAtMention(input: string, cursorPos: number, completedPath: string): {
+    input: string;
+    cursorPos: number;
+};
+/**
+ * Clear the file cache (call when cwd changes)
+ */
+export declare function clearFileCache(): void;

package/dist/ui/file-autocomplete.js

@@ -0,0 +1,237 @@
+/**
+ * File Path Autocomplete
+ *
+ * Uses ripgrep to provide fast file/folder suggestions when user types @path
+ */
+import { execSync } from 'child_process';
+import * as path from 'path';
+// =============================================================================
+// Constants
+// =============================================================================
+/** Max results to return */
+const MAX_RESULTS = 15;
+/** Cache for file list (refreshed periodically) */
+let fileCache = [];
+let lastCacheTime = 0;
+const CACHE_TTL_MS = 5000; // 5 seconds
+// =============================================================================
+// Ripgrep File Listing
+// =============================================================================
+/**
+ * Get all files using ripgrep
+ * Results are cached for performance
+ */
+function getAllFiles(cwd) {
+    const now = Date.now();
+    // Return cached results if fresh
+    if (fileCache.length > 0 && now - lastCacheTime < CACHE_TTL_MS) {
+        return fileCache;
+    }
+    try {
+        // Use ripgrep to list all files
+        // --files: list files instead of searching
+        // Respects .gitignore by default
+        const result = execSync('rg --files 2>/dev/null', {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            timeout: 3000, // 3 second timeout
+        });
+        fileCache = result
+            .split('\n')
+            .filter((line) => line.trim())
+            .map((line) => line.replace(/\\/g, '/')); // Normalize paths
+        lastCacheTime = now;
+        return fileCache;
+    }
+    catch {
+        // Ripgrep failed or not available, return empty
+        return fileCache; // Return stale cache if available
+    }
+}
+/**
+ * Extract unique directories from file paths
+ */
+function extractDirectories(files) {
+    const dirs = new Set();
+    for (const file of files) {
+        const parts = file.split('/');
+        let current = '';
+        // Add all parent directories
+        for (let i = 0; i < parts.length - 1; i++) {
+            current = current ? `${current}/${parts[i]}` : parts[i];
+            dirs.add(current);
+        }
+    }
+    return dirs;
+}
+// =============================================================================
+// File Matching
+// =============================================================================
+/**
+ * Get file/folder matches for a partial path
+ *
+ * @param partial - The partial path after @ (e.g., "src/comp" or "package")
+ * @param cwd - Current working directory
+ * @returns Array of matching files/folders
+ */
+export function getFileMatches(partial, cwd = process.cwd()) {
+    const files = getAllFiles(cwd);
+    const dirs = extractDirectories(files);
+    const matches = [];
+    const seen = new Set();
+    const normalizedPartial = partial.toLowerCase().replace(/\\/g, '/');
+    // If partial has a directory component, filter by that
+    const lastSlash = normalizedPartial.lastIndexOf('/');
+    const dirPrefix = lastSlash >= 0 ? normalizedPartial.slice(0, lastSlash + 1) : '';
+    const namePrefix = lastSlash >= 0 ? normalizedPartial.slice(lastSlash + 1) : normalizedPartial;
+    // Match directories first
+    for (const dir of dirs) {
+        const dirLower = dir.toLowerCase();
+        const dirWithSlash = `${dir}/`;
+        // Check if this directory matches
+        if (dirPrefix) {
+            // Has directory prefix - match directories under that path
+            if (dirLower.startsWith(dirPrefix.slice(0, -1))) {
+                const remaining = dir.slice(dirPrefix.length - 1);
+                if (remaining && !remaining.includes('/')) {
+                    // Direct child directory
+                    if (!namePrefix || remaining.toLowerCase().startsWith(namePrefix)) {
+                        if (!seen.has(dirWithSlash)) {
+                            seen.add(dirWithSlash);
+                            matches.push({
+                                name: `${remaining}/`,
+                                path: dirWithSlash,
+                                isDirectory: true,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // No directory prefix - match top-level directories
+            if (!dir.includes('/')) {
+                if (!namePrefix || dirLower.startsWith(namePrefix)) {
+                    if (!seen.has(dirWithSlash)) {
+                        seen.add(dirWithSlash);
+                        matches.push({
+                            name: `${dir}/`,
+                            path: dirWithSlash,
+                            isDirectory: true,
+                        });
+                    }
+                }
+            }
+        }
+        if (matches.length >= MAX_RESULTS)
+            break;
+    }
+    // Then match files
+    for (const file of files) {
+        if (matches.length >= MAX_RESULTS)
+            break;
+        const fileLower = file.toLowerCase();
+        if (dirPrefix) {
+            // Has directory prefix - match files under that path
+            if (fileLower.startsWith(dirPrefix)) {
+                const remaining = file.slice(dirPrefix.length);
+                if (!remaining.includes('/')) {
+                    // Direct child file
+                    if (!namePrefix || remaining.toLowerCase().startsWith(namePrefix)) {
+                        if (!seen.has(file)) {
+                            seen.add(file);
+                            matches.push({
+                                name: remaining,
+                                path: file,
+                                isDirectory: false,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // No directory prefix - match top-level files or by filename anywhere
+            const fileName = path.basename(file);
+            if (!namePrefix || fileName.toLowerCase().startsWith(namePrefix) || fileLower.startsWith(namePrefix)) {
+                if (!seen.has(file)) {
+                    seen.add(file);
+                    matches.push({
+                        name: file.includes('/') ? file : fileName,
+                        path: file,
+                        isDirectory: false,
+                    });
+                }
+            }
+        }
+    }
+    // Sort: directories first, then alphabetically
+    matches.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory)
+            return -1;
+        if (!a.isDirectory && b.isDirectory)
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    return matches.slice(0, MAX_RESULTS);
+}
+/**
+ * Extract the @ mention from input text
+ *
+ * @param input - Full input text
+ * @param cursorPos - Current cursor position
+ * @returns The partial path after @ or null if not in @ context
+ */
+export function extractAtMention(input, cursorPos) {
+    // Look backwards from cursor to find @
+    let start = cursorPos - 1;
+    while (start >= 0) {
+        const char = input[start];
+        // Found @
+        if (char === '@') {
+            // Make sure it's at start or after whitespace
+            if (start === 0 || /\s/.test(input[start - 1])) {
+                return input.slice(start + 1, cursorPos);
+            }
+            return null;
+        }
+        // Hit whitespace without finding @ - not in @ context
+        if (/\s/.test(char)) {
+            return null;
+        }
+        start--;
+    }
+    return null;
+}
+/**
+ * Replace the @ mention with completed path
+ *
+ * @param input - Full input text
+ * @param cursorPos - Current cursor position
+ * @param completedPath - The completed path to insert
+ * @returns New input text and new cursor position
+ */
+export function replaceAtMention(input, cursorPos, completedPath) {
+    // Find the @ position
+    let atPos = cursorPos - 1;
+    while (atPos >= 0 && input[atPos] !== '@') {
+        atPos--;
+    }
+    if (atPos < 0) {
+        return { input, cursorPos };
+    }
+    // Replace from @ to cursor with the completed path
+    const before = input.slice(0, atPos);
+    const after = input.slice(cursorPos);
+    const newInput = `${before}@${completedPath}${after}`;
+    const newCursorPos = atPos + 1 + completedPath.length;
+    return { input: newInput, cursorPos: newCursorPos };
+}
+/**
+ * Clear the file cache (call when cwd changes)
+ */
+export function clearFileCache() {
+    fileCache = [];
+    lastCacheTime = 0;
+}

package/dist/ui/footer.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Footer Orchestrator
+ *
+ * Manages all persistent UI elements below the scrolling zone:
+ * - TodoZone (spinner + todo list)
+ * - Queued input display
+ * - InputPrompt
+ *
+ * Handles:
+ * - Coordinated rendering via single render loop
+ * - Event forwarding from InputPrompt
+ * - Clearing for scrolling output
+ * - State management for agent running/idle modes
+ */
+import { EventEmitter } from 'events';
+import type { TodoItem, AgentMode } from './types.js';
+export interface FooterEvents {
+    submit: (input: string) => void;
+    command: (command: string, args: string) => void;
+    cancel: () => void;
+    escape: () => void;
+    modeChange: () => void;
+}
+export interface FooterOptions {
+    prompt?: string;
+    showSeparators?: boolean;
+    renderInterval?: number;
+    initialMode?: AgentMode;
+}
+export declare class Footer extends EventEmitter {
+    private readonly todoZone;
+    private readonly inputPrompt;
+    private agentRunning;
+    private mode;
+    private lastRenderHeight;
+    private isRunning;
+    private isPaused;
+    private cursorLineFromBottom;
+    private readonly renderInterval;
+    private renderTimer;
+    private needsRender;
+    constructor(options?: FooterOptions);
+    /**
+     * Start the footer (begins render loop and input capture)
+     */
+    start(): void;
+    /**
+     * Stop the footer
+     */
+    stop(): void;
+    /**
+     * Set whether agent is running
+     * Enables/disables queue mode and spinner
+     */
+    setAgentRunning(running: boolean): void;
+    /**
+     * Check if agent is running
+     */
+    isAgentRunning(): boolean;
+    /**
+     * Set the current mode
+     */
+    setMode(mode: AgentMode): void;
+    /**
+     * Get the current mode
+     */
+    getMode(): AgentMode;
+    /**
+     * Update the todo list
+     */
+    setTodos(todos: TodoItem[]): void;
+    /**
+     * Set the current tool being executed
+     */
+    setCurrentTool(tool: string | null): void;
+    /**
+     * Set a suggestion for the next action (ghost text in input prompt)
+     */
+    setSuggestion(action: string | null): void;
+    /**
+     * Set custom spinner text (overrides todo activeForm and random thinking word)
+     * Pass null to clear and use default behavior.
+     */
+    setSpinnerText(text: string | null): void;
+    /**
+     * Add tokens to the spinner counter
+     */
+    addTokens(count: number): void;
+    /**
+     * Get queued inputs
+     */
+    getQueuedInputs(): string[];
+    /**
+     * Pop the first queued input
+     */
+    popQueuedInput(): string | null;
+    /**
+     * Check if there are queued inputs
+     */
+    hasQueuedInput(): boolean;
+    /**
+     * Clear the queue
+     */
+    clearQueue(): void;
+    /**
+     * Clear footer before scrolling output
+     * Call this before writing to the scrolling zone
+     */
+    clearForOutput(): void;
+    /**
+     * Force an immediate render
+     */
+    forceRender(): void;
+    /**
+     * Pause footer completely (for overlays)
+     * Stops render loop, input capture, and animation
+     */
+    pauseAnimation(): void;
+    /**
+     * Resume footer after pause
+     * Restarts render loop, input capture, and animation
+     */
+    resumeAnimation(): void;
+    /**
+     * Get the height of last render
+     */
+    getLastRenderHeight(): number;
+    /**
+     * Refresh the prompt with current theme colors
+     * Call after theme changes to apply new colors immediately
+     */
+    refreshPrompt(): void;
+    /**
+     * Clear the footer area
+     */
+    private clear;
+    /**
+     * Render the entire footer
+     */
+    private render;
+    /**
+     * Render mode indicator line
+     */
+    private renderModeIndicator;
+    /**
+     * Calculate how many terminal rows a line takes (accounting for wrapping)
+     */
+    private getTerminalRowsForLine;
+    /**
+     * Position cursor correctly within the input prompt
+     */
+    private positionCursor;
+}