@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/ui/ask-user-simple-overlay.d.ts

@@ -1,8 +1,8 @@
 /**
- * Ask User Simple Overlay
+ * Ask User Simple Overlay (Refactored)
  *
  * Simplified modal overlay for single-question input.
- * Used by the ask_user_simple tool during /sketch workflows.
+ * Uses InlineOverlay base class for consistent lifecycle management.
  *
  * Features:
  * - Single question (no tabs, no navigation)

package/dist/ui/ask-user-simple-overlay.js

@@ -1,8 +1,8 @@
 /**
- * Ask User Simple Overlay
+ * Ask User Simple Overlay (Refactored)
  *
  * Simplified modal overlay for single-question input.
- * Used by the ask_user_simple tool during /sketch workflows.
+ * Uses InlineOverlay base class for consistent lifecycle management.
  *
  * Features:
  * - Single question (no tabs, no navigation)
@@ -11,73 +11,197 @@
  * - Simple, clean UI
  */
 import chalk from 'chalk';
-import * as terminal from './terminal.js';
 import { getStyles } from '../themes/index.js';
+import { InlineOverlay } from './base/inline-overlay.js';
 // =============================================================================
-// Rendering
+// Overlay Implementation
 // =============================================================================
-function render(question, options, allowCustom, state, previousLineCount = 0, targetLineCount = 0) {
-    const s = getStyles();
-    const lines = [];
-    const cols = terminal.getTerminalWidth();
-    const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
-    // Clear previous render
-    if (previousLineCount > 0) {
-        terminal.clearLinesAbove(previousLineCount);
+class AskUserSimpleOverlayImpl extends InlineOverlay {
+    question;
+    choices;
+    allowCustom;
+    constructor(options) {
+        super();
+        this.question = options.question;
+        this.choices = options.options ?? [];
+        this.allowCustom = options.allowCustom ?? true;
     }
-    // Header
-    lines.push(border);
-    lines.push(' ' + s.primaryBold('Sketch'));
-    lines.push('');
-    // Question
-    lines.push(chalk.bold(` ${question}`));
-    lines.push('');
-    // Options
-    const customIndex = options.length;
-    for (let i = 0; i < options.length; i++) {
-        const isCursor = state.selectedIndex === i && !state.isTypingCustom;
-        const prefix = isCursor ? ' ❯ ' : '   ';
-        const num = `${String(i + 1)}. `;
-        if (isCursor) {
-            lines.push(s.primary(prefix + num + options[i]));
+    getInitialState() {
+        // If no predefined choices and custom is allowed, auto-start in typing mode
+        const autoTyping = this.choices.length === 0 && this.allowCustom;
+        return {
+            selectedIndex: 0,
+            inputBuffer: '',
+            isTypingCustom: autoTyping,
+        };
+    }
+    render() {
+        const s = getStyles();
+        const lines = [];
+        const cols = this.getTerminalWidth();
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Header
+        lines.push(border);
+        lines.push(' ' + s.primaryBold('Sketch'));
+        lines.push('');
+        // Question
+        lines.push(chalk.bold(` ${this.question}`));
+        lines.push('');
+        // Options
+        const customIndex = this.choices.length;
+        for (let i = 0; i < this.choices.length; i++) {
+            const isCursor = this.state.selectedIndex === i && !this.state.isTypingCustom;
+            const prefix = isCursor ? ' ❯ ' : '   ';
+            const num = `${String(i + 1)}. `;
+            if (isCursor) {
+                lines.push(s.primary(prefix + num + this.choices[i]));
+            }
+            else {
+                lines.push(s.muted(prefix + num + this.choices[i]));
+            }
+        }
+        // Custom input option (if allowed)
+        if (this.allowCustom) {
+            const isCursor = this.state.selectedIndex === customIndex && !this.state.isTypingCustom;
+            const prefix = isCursor ? ' ❯ ' : '   ';
+            const num = `${String(this.choices.length + 1)}. `;
+            if (this.state.isTypingCustom) {
+                // Show input field
+                lines.push(s.primary(prefix + num + 'Custom: ') + s.primaryBold(this.state.inputBuffer + '▋'));
+            }
+            else if (isCursor) {
+                lines.push(s.primary(prefix + num + 'Type something else...'));
+            }
+            else {
+                lines.push(s.muted(prefix + num + 'Type something else...'));
+            }
+        }
+        // Footer
+        lines.push('');
+        if (this.state.isTypingCustom) {
+            lines.push(s.muted(' Enter Submit · Esc Cancel'));
         }
         else {
-            lines.push(s.muted(prefix + num + options[i]));
+            lines.push(s.muted(' ↑↓ Navigate · Enter Select · s Skip · Esc Cancel'));
         }
+        // Bottom border
+        lines.push(border);
+        return lines;
     }
-    // Custom input option (if allowed)
-    if (allowCustom) {
-        const isCursor = state.selectedIndex === customIndex && !state.isTypingCustom;
-        const prefix = isCursor ? ' ❯ ' : '   ';
-        const num = `${String(options.length + 1)}. `;
-        if (state.isTypingCustom) {
-            // Show input field
-            lines.push(s.primary(prefix + num + 'Custom: ') + s.primaryBold(state.inputBuffer + '▋'));
+    handleKey(data) {
+        const customIndex = this.choices.length;
+        const optionCount = this.allowCustom ? this.choices.length + 1 : this.choices.length;
+        // Ctrl+C always cancels
+        if (this.isCtrlCKey(data)) {
+            return { type: 'close', result: { answer: '', skipped: true } };
         }
-        else if (isCursor) {
-            lines.push(s.primary(prefix + num + 'Type something else...'));
+        // If typing custom input
+        if (this.state.isTypingCustom) {
+            if (this.isEscapeKey(data)) {
+                // Cancel custom input
+                this.state.isTypingCustom = false;
+                this.state.inputBuffer = '';
+                return { type: 'continue' };
+            }
+            if (this.isUpArrowKey(data) && this.choices.length > 0) {
+                // Exit typing mode and navigate up (only if there are other options)
+                this.state.isTypingCustom = false;
+                this.state.inputBuffer = '';
+                this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                return { type: 'continue' };
+            }
+            if (this.isDownArrowKey(data)) {
+                // Exit typing mode (but stay on custom since it's last option)
+                // This effectively does nothing but we handle it to be consistent
+                return { type: 'continue' };
+            }
+            if (this.isEnterKey(data)) {
+                // Submit custom input
+                const custom = this.state.inputBuffer.trim();
+                if (custom) {
+                    return { type: 'close', result: { answer: custom, skipped: false } };
+                }
+                // Empty - stay in custom mode
+                return { type: 'continue' };
+            }
+            if (this.isBackspaceKey(data)) {
+                this.state.inputBuffer = this.state.inputBuffer.slice(0, -1);
+                return { type: 'continue' };
+            }
+            // Printable character
+            const char = this.getPrintableChar(data);
+            if (char) {
+                this.state.inputBuffer += char;
+                return { type: 'continue' };
+            }
+            return { type: 'continue' };
         }
-        else {
-            lines.push(s.muted(prefix + num + 'Type something else...'));
+        // Navigation mode
+        if (this.isEscapeKey(data)) {
+            // Cancel overlay
+            return { type: 'close', result: { answer: '', skipped: true } };
         }
+        // Skip question (s key)
+        const keyStr = data.toString();
+        if (keyStr.toLowerCase() === 's') {
+            return { type: 'close', result: { answer: '', skipped: true } };
+        }
+        if (this.isUpArrowKey(data)) {
+            this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+            // Auto-enable typing when navigating to custom option
+            if (this.allowCustom && this.state.selectedIndex === customIndex) {
+                this.state.isTypingCustom = true;
+            }
+            return { type: 'continue' };
+        }
+        if (this.isDownArrowKey(data)) {
+            this.state.selectedIndex = Math.min(optionCount - 1, this.state.selectedIndex + 1);
+            // Auto-enable typing when navigating to custom option
+            if (this.allowCustom && this.state.selectedIndex === customIndex) {
+                this.state.isTypingCustom = true;
+            }
+            return { type: 'continue' };
+        }
+        if (this.isEnterKey(data)) {
+            if (this.state.selectedIndex < this.choices.length) {
+                // Selected a predefined option
+                return { type: 'close', result: { answer: this.choices[this.state.selectedIndex], skipped: false } };
+            }
+            else if (this.allowCustom && this.state.selectedIndex === customIndex) {
+                // Enter custom input mode
+                this.state.isTypingCustom = true;
+                return { type: 'continue' };
+            }
+        }
+        // Number keys 1-9
+        if (data.length === 1 && data[0] >= 0x31 && data[0] <= 0x39) {
+            const numIndex = data[0] - 0x31; // 0-indexed
+            if (numIndex < optionCount) {
+                if (numIndex < this.choices.length) {
+                    // Select predefined option directly
+                    return { type: 'close', result: { answer: this.choices[numIndex], skipped: false } };
+                }
+                else if (this.allowCustom && numIndex === customIndex) {
+                    // Enter custom mode
+                    this.state.selectedIndex = customIndex;
+                    this.state.isTypingCustom = true;
+                    return { type: 'continue' };
+                }
+            }
+        }
+        return { type: 'continue' };
     }
-    // Footer
-    lines.push('');
-    if (state.isTypingCustom) {
-        lines.push(s.muted(' Enter Submit · Esc Cancel'));
-    }
-    else {
-        lines.push(s.muted(' ↑↓ Navigate · Enter Select · s Skip · Esc Cancel'));
-    }
-    // Bottom border
-    lines.push(border);
-    // Pad with empty lines to maintain consistent height
-    while (lines.length < targetLineCount) {
-        lines.push('');
+    getCleanupSummary(result) {
+        const s = getStyles();
+        if (result.skipped) {
+            return s.muted('Sketch: ') + s.warning('Skipped');
+        }
+        // Truncate long answers
+        const displayAnswer = result.answer.length > 50
+            ? result.answer.substring(0, 47) + '...'
+            : result.answer;
+        return s.muted('Sketch: ') + s.success(displayAnswer);
     }
-    // Render all lines
-    terminal.write(lines.join('\n'));
-    return lines.length;
 }
 // =============================================================================
 // Main Export
@@ -86,157 +210,6 @@ function render(question, options, allowCustom, state, previousLineCount = 0, ta
  * Show the simple ask user overlay
  */
 export async function showAskUserSimpleOverlay(options) {
-    const { question, options: choices = [], allowCustom = true } = options;
-    // If no predefined choices and custom is allowed, auto-start in typing mode
-    const autoTyping = choices.length === 0 && allowCustom;
-    const state = {
-        selectedIndex: autoTyping ? 0 : 0,
-        inputBuffer: '',
-        isTypingCustom: autoTyping,
-        cancelled: false,
-    };
-    let lineCount = 0;
-    let maxLineCount = 0;
-    // NOTE: Footer is already paused by the caller (index.ts handler calls sharedState.pauseFooter)
-    // Do NOT call pauseForOverlay() here - it causes double-pause issues
-    // The caller's pause already clears the footer from screen
-    // Text output is also buffered by repl.ts (not flushed until overlay closes)
-    // Ensure we start from a fresh line (like config-overlay does)
-    terminal.writeLine('');
-    terminal.hideCursor();
-    const wasRawMode = process.stdin.isRaw;
-    terminal.enableRawMode();
-    // Initial render
-    lineCount = render(question, choices, allowCustom, state, 0);
-    maxLineCount = Math.max(maxLineCount, lineCount);
-    // Helper: Get total option count
-    const getOptionCount = () => {
-        return allowCustom ? choices.length + 1 : choices.length;
-    };
-    return new Promise((resolve) => {
-        const cleanup = () => {
-            terminal.clearLinesAbove(maxLineCount);
-            terminal.writeLine('');
-            terminal.showCursor();
-            if (!wasRawMode) {
-                terminal.disableRawMode();
-            }
-            process.stdin.removeListener('data', handleData);
-            // NOTE: Footer resume is handled by the caller (index.ts) in the finally block
-        };
-        const handleData = (data) => {
-            const isEscape = data.length === 1 && data[0] === 0x1b;
-            const isUpArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x41;
-            const isDownArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x42;
-            const isCtrlC = data.length === 1 && data[0] === 0x03;
-            const isEnter = data.length === 1 && (data[0] === 0x0d || data[0] === 0x0a);
-            const isBackspace = data.length === 1 && (data[0] === 0x7f || data[0] === 0x08);
-            const isS = data.length === 1 && (data[0] === 0x73 || data[0] === 0x53); // 's' or 'S'
-            // Ctrl+C always cancels
-            if (isCtrlC) {
-                cleanup();
-                resolve({ answer: '', skipped: true });
-                return;
-            }
-            // If typing custom input
-            if (state.isTypingCustom) {
-                if (isEscape) {
-                    // Cancel custom input
-                    state.isTypingCustom = false;
-                    state.inputBuffer = '';
-                }
-                else if (isUpArrow && choices.length > 0) {
-                    // Exit typing mode and navigate up (only if there are other options)
-                    state.isTypingCustom = false;
-                    state.inputBuffer = '';
-                    state.selectedIndex = Math.max(0, state.selectedIndex - 1);
-                }
-                else if (isDownArrow) {
-                    // Exit typing mode (but stay on custom since it's last option)
-                    // This effectively does nothing but we handle it to be consistent
-                }
-                else if (isEnter) {
-                    // Submit custom input
-                    const custom = state.inputBuffer.trim();
-                    if (custom) {
-                        cleanup();
-                        resolve({ answer: custom, skipped: false });
-                        return;
-                    }
-                    // Empty - stay in custom mode
-                }
-                else if (isBackspace) {
-                    state.inputBuffer = state.inputBuffer.slice(0, -1);
-                }
-                else if (data.length === 1 && data[0] >= 0x20 && data[0] < 0x7f) {
-                    // Printable character
-                    state.inputBuffer += String.fromCharCode(data[0]);
-                }
-            }
-            else {
-                // Navigation mode
-                const optionCount = getOptionCount();
-                const customIndex = choices.length;
-                if (isEscape) {
-                    // Cancel overlay
-                    cleanup();
-                    resolve({ answer: '', skipped: true });
-                    return;
-                }
-                else if (isS) {
-                    // Skip question (only in navigation mode, not when typing)
-                    cleanup();
-                    resolve({ answer: '', skipped: true });
-                    return;
-                }
-                else if (isUpArrow) {
-                    state.selectedIndex = Math.max(0, state.selectedIndex - 1);
-                    // Auto-enable typing when navigating to custom option
-                    if (allowCustom && state.selectedIndex === customIndex) {
-                        state.isTypingCustom = true;
-                    }
-                }
-                else if (isDownArrow) {
-                    state.selectedIndex = Math.min(optionCount - 1, state.selectedIndex + 1);
-                    // Auto-enable typing when navigating to custom option
-                    if (allowCustom && state.selectedIndex === customIndex) {
-                        state.isTypingCustom = true;
-                    }
-                }
-                else if (isEnter) {
-                    if (state.selectedIndex < choices.length) {
-                        // Selected a predefined option
-                        cleanup();
-                        resolve({ answer: choices[state.selectedIndex], skipped: false });
-                        return;
-                    }
-                    else if (allowCustom && state.selectedIndex === customIndex) {
-                        // Enter custom input mode
-                        state.isTypingCustom = true;
-                    }
-                }
-                else if (data.length === 1 && data[0] >= 0x31 && data[0] <= 0x39) {
-                    // Number keys 1-9
-                    const numIndex = data[0] - 0x31; // 0-indexed
-                    if (numIndex < optionCount) {
-                        if (numIndex < choices.length) {
-                            // Select predefined option directly
-                            cleanup();
-                            resolve({ answer: choices[numIndex], skipped: false });
-                            return;
-                        }
-                        else if (allowCustom && numIndex === customIndex) {
-                            // Enter custom mode
-                            state.selectedIndex = customIndex;
-                            state.isTypingCustom = true;
-                        }
-                    }
-                }
-            }
-            // Re-render
-            lineCount = render(question, choices, allowCustom, state, maxLineCount, maxLineCount);
-            maxLineCount = Math.max(maxLineCount, lineCount);
-        };
-        process.stdin.on('data', handleData);
-    });
+    const overlay = new AskUserSimpleOverlayImpl(options);
+    return overlay.show();
 }

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

@@ -0,0 +1,42 @@
+/**
+ * Autocomplete controller for command, file, and agent autocomplete.
+ *
+ * Extracted from TerminalUI — owns all three autocomplete states and their
+ * management methods. Input state is passed in as parameters; accept() returns
+ * new input state instead of mutating directly.
+ */
+import type { AutocompleteState, FileAutocompleteState, AgentAutocompleteState, AgentSuggestion } from './terminal-types.js';
+import type { CommandOption } from './types.js';
+/** Return value from accept() — new input state to apply. */
+export interface AcceptResult {
+    lines: string[];
+    currentLine: number;
+    cursorPos: number;
+}
+export declare class AutocompleteController {
+    readonly command: AutocompleteState;
+    readonly file: FileAutocompleteState;
+    readonly agent: AgentAutocompleteState;
+    getAgentSuggestions?: () => AgentSuggestion[];
+    getCommands?: () => CommandOption[];
+    /** Whether any autocomplete is currently active. */
+    isActive(): boolean;
+    /**
+     * Detect and activate autocomplete based on current input state.
+     * Priority: @ file > $ agent > / command
+     */
+    update(lines: string[], currentLine: number, cursorPos: number): void;
+    /**
+     * Apply the selected autocomplete match.
+     * Returns new input state if something was accepted, null otherwise.
+     * Caller must also call update() after applying the result for file autocomplete
+     * (directory selection may trigger continued autocomplete).
+     */
+    accept(lines: string[], currentLine: number, cursorPos: number): AcceptResult | null;
+    close(): void;
+    navigateUp(): boolean;
+    navigateDown(): boolean;
+    buildCommandLines(termWidth: number): string[];
+    buildFileLines(termWidth: number): string[];
+    buildAgentLines(termWidth: number): string[];
+}