@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/ui/guardrail-overlay.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Guardrail Confirmation Overlay
+ *
+ * Shows when a guardrail with action='confirm' is triggered.
+ * User must approve or deny the risky operation.
+ */
+export interface GuardrailConfirmOptions {
+    /** Guardrail name */
+    name: string;
+    /** Guardrail description/message */
+    message: string;
+    /** Action type (for display) */
+    action: 'warn' | 'confirm' | 'block';
+    /** Tool that triggered the guardrail */
+    toolName: string;
+    /** The input that matched the pattern */
+    matchedInput: string;
+    /** Category (e.g., 'git', 'filesystem', 'database') */
+    category?: string;
+}
+export interface GuardrailConfirmResult {
+    /** Whether to proceed with the operation */
+    approved: boolean;
+}
+/**
+ * Show the guardrail confirmation overlay.
+ * Returns { approved: true } if user allows, { approved: false } if denied.
+ */
+export declare function showGuardrailOverlay(options: GuardrailConfirmOptions): Promise<GuardrailConfirmResult>;

package/dist/ui/guardrail-overlay.js

@@ -0,0 +1,145 @@
+/**
+ * Guardrail Confirmation Overlay
+ *
+ * Shows when a guardrail with action='confirm' is triggered.
+ * User must approve or deny the risky operation.
+ */
+import chalk from 'chalk';
+import { getStyles } from '../themes/index.js';
+import { InlineOverlay } from './base/inline-overlay.js';
+// =============================================================================
+// Overlay Implementation
+// =============================================================================
+class GuardrailOverlayImpl extends InlineOverlay {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    getInitialState() {
+        return {
+            selectedIndex: 0, // Default to Deny (safer)
+        };
+    }
+    render() {
+        const s = getStyles();
+        const lines = [];
+        const cols = this.getTerminalWidth();
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Header with warning icon
+        lines.push(border);
+        lines.push(' ' + s.warning('⚠ Risky Operation Detected'));
+        lines.push('');
+        // Guardrail info
+        const category = this.options.category ? `[${this.options.category}]` : '';
+        lines.push(s.muted(` ${category} `) + chalk.bold(this.options.name));
+        lines.push('');
+        // Message
+        const msgLines = this.wrapText(this.options.message, cols - 4);
+        for (const line of msgLines) {
+            lines.push('   ' + s.muted(line));
+        }
+        lines.push('');
+        // Tool and matched input
+        lines.push(s.muted(' Tool: ') + s.primary(this.options.toolName));
+        // Show truncated matched input
+        const maxInputLen = cols - 12;
+        let displayInput = this.options.matchedInput;
+        if (displayInput.length > maxInputLen) {
+            displayInput = displayInput.substring(0, maxInputLen - 3) + '...';
+        }
+        // Replace newlines with visible markers
+        displayInput = displayInput.replace(/\n/g, '↵');
+        lines.push(s.muted(' Match: ') + s.warning(displayInput));
+        lines.push('');
+        // Action buttons
+        const denyLabel = this.state.selectedIndex === 0
+            ? s.error(' ❯ Deny ')
+            : s.muted('   Deny ');
+        const allowLabel = this.state.selectedIndex === 1
+            ? s.warning(' ❯ Allow ')
+            : s.muted('   Allow ');
+        lines.push(' ' + denyLabel + '  ' + allowLabel);
+        lines.push('');
+        // Footer
+        lines.push(s.muted(' ←/→ Select · Enter Confirm · Esc Deny'));
+        lines.push(border);
+        return lines;
+    }
+    handleKey(data) {
+        // Ctrl+C or Escape = Deny
+        if (this.isCtrlCKey(data) || this.isEscapeKey(data)) {
+            return { type: 'close', result: { approved: false } };
+        }
+        // Left/Right arrows or h/l for navigation
+        if (this.isLeftArrowKey(data) || data.toString() === 'h') {
+            this.state.selectedIndex = 0;
+            return { type: 'continue' };
+        }
+        if (this.isRightArrowKey(data) || data.toString() === 'l') {
+            this.state.selectedIndex = 1;
+            return { type: 'continue' };
+        }
+        // Tab to toggle
+        if (this.isTabKey(data)) {
+            this.state.selectedIndex = this.state.selectedIndex === 0 ? 1 : 0;
+            return { type: 'continue' };
+        }
+        // Enter to confirm selection
+        if (this.isEnterKey(data)) {
+            return {
+                type: 'close',
+                result: { approved: this.state.selectedIndex === 1 },
+            };
+        }
+        // 'd' or 'n' for Deny
+        const keyStr = data.toString().toLowerCase();
+        if (keyStr === 'd' || keyStr === 'n') {
+            return { type: 'close', result: { approved: false } };
+        }
+        // 'a' or 'y' for Allow
+        if (keyStr === 'a' || keyStr === 'y') {
+            return { type: 'close', result: { approved: true } };
+        }
+        return { type: 'continue' };
+    }
+    getCleanupSummary(result) {
+        const s = getStyles();
+        if (result.approved) {
+            return s.muted('Guardrail: ') + s.warning('Allowed ') + s.muted(this.options.name);
+        }
+        return s.muted('Guardrail: ') + s.error('Denied ') + s.muted(this.options.name);
+    }
+    /**
+     * Wrap text to fit within maxWidth
+     */
+    wrapText(text, maxWidth) {
+        const words = text.split(' ');
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            if (currentLine.length + word.length + 1 <= maxWidth) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            }
+            else {
+                if (currentLine)
+                    lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+        if (currentLine)
+            lines.push(currentLine);
+        return lines;
+    }
+}
+// =============================================================================
+// Main Export
+// =============================================================================
+/**
+ * Show the guardrail confirmation overlay.
+ * Returns { approved: true } if user allows, { approved: false } if denied.
+ */
+export async function showGuardrailOverlay(options) {
+    const overlay = new GuardrailOverlayImpl(options);
+    return overlay.show();
+}

package/dist/ui/index.d.ts

@@ -8,5 +8,5 @@ export * from './terminal.js';
 export * from './conversation.js';
 export * from './overlays.js';
 export * from './todo-zone.js';
-export * from './input-prompt-v2.js';
+export * from './input-prompt.js';
 export * from './footer.js';

package/dist/ui/index.js

@@ -9,7 +9,5 @@ export * from './conversation.js';
 export * from './overlays.js';
 // Refactored components (event-driven, persistent footer)
 export * from './todo-zone.js';
-export * from './input-prompt-v2.js';
+export * from './input-prompt.js';
 export * from './footer.js';
-// Note: ephemeral.js and input-prompt.js are legacy and not re-exported
-// to avoid naming conflicts. Import directly if needed.

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

@@ -0,0 +1,51 @@
+/**
+ * Input state controller.
+ *
+ * Extracted from TerminalUI — owns all input state (lines, cursor,
+ * history, suggestion, queued inputs) and their manipulation methods.
+ * TerminalUI delegates to this controller via getter/setter wrappers.
+ */
+export declare class InputController {
+    lines: string[];
+    currentLine: number;
+    cursorPos: number;
+    readonly history: string[];
+    historyIndex: number;
+    savedInput: string;
+    suggestion: string | null;
+    queuedInputs: string[];
+    /** Get the full input value (all lines joined with newlines). */
+    getInputValue(): string;
+    /** Get the current line content. */
+    getCurrentLineContent(): string;
+    /** Clear input and reset to single empty line. */
+    clearInput(): void;
+    addToHistory(input: string): void;
+    /**
+     * Navigate to older history entry.
+     * @param isAutocompleteActive - when true, navigation is blocked
+     * @returns true if input changed
+     */
+    navigateHistoryUp(isAutocompleteActive: boolean): boolean;
+    /**
+     * Navigate to newer history entry.
+     * @param isAutocompleteActive - when true, navigation is blocked
+     * @returns true if input changed
+     */
+    navigateHistoryDown(isAutocompleteActive: boolean): boolean;
+    resetHistoryNavigation(): void;
+    /**
+     * Move cursor to previous word boundary (Option+Left).
+     * @returns true if cursor moved (caller should trigger render)
+     */
+    moveWordLeft(): boolean;
+    /**
+     * Move cursor to next word boundary (Option+Right).
+     * @returns true if cursor moved (caller should trigger render)
+     */
+    moveWordRight(): boolean;
+    getQueuedInputs(): string[];
+    popQueuedInput(): string | null;
+    hasQueuedInput(): boolean;
+    clearQueue(): void;
+}

package/dist/ui/input-controller.js

@@ -0,0 +1,176 @@
+/**
+ * Input state controller.
+ *
+ * Extracted from TerminalUI — owns all input state (lines, cursor,
+ * history, suggestion, queued inputs) and their manipulation methods.
+ * TerminalUI delegates to this controller via getter/setter wrappers.
+ */
+export class InputController {
+    // Core multiline input state
+    lines = [''];
+    currentLine = 0;
+    cursorPos = 0;
+    // Command history
+    history = [];
+    historyIndex = -1;
+    savedInput = '';
+    // Ghost text suggestion
+    suggestion = null;
+    // Queued user inputs (when agent is busy)
+    queuedInputs = [];
+    // ===========================================================================
+    // Input value helpers
+    // ===========================================================================
+    /** Get the full input value (all lines joined with newlines). */
+    getInputValue() {
+        return this.lines.join('\n');
+    }
+    /** Get the current line content. */
+    getCurrentLineContent() {
+        return this.lines[this.currentLine];
+    }
+    /** Clear input and reset to single empty line. */
+    clearInput() {
+        this.lines = [''];
+        this.currentLine = 0;
+        this.cursorPos = 0;
+    }
+    // ===========================================================================
+    // History
+    // ===========================================================================
+    addToHistory(input) {
+        const trimmed = input.trim();
+        // Don't add empty or duplicate consecutive entries
+        if (trimmed && (this.history.length === 0 || this.history[this.history.length - 1] !== trimmed)) {
+            this.history.push(trimmed);
+        }
+    }
+    /**
+     * Navigate to older history entry.
+     * @param isAutocompleteActive - when true, navigation is blocked
+     * @returns true if input changed
+     */
+    navigateHistoryUp(isAutocompleteActive) {
+        if (isAutocompleteActive)
+            return false;
+        if (this.history.length === 0)
+            return false;
+        // Save current input when starting to navigate
+        if (this.historyIndex === -1) {
+            this.savedInput = this.getInputValue();
+        }
+        // Navigate to older entry
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            const historyEntry = this.history[this.history.length - 1 - this.historyIndex];
+            // History entries are single-line (newlines stripped on save)
+            this.lines = [historyEntry];
+            this.currentLine = 0;
+            this.cursorPos = historyEntry.length;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Navigate to newer history entry.
+     * @param isAutocompleteActive - when true, navigation is blocked
+     * @returns true if input changed
+     */
+    navigateHistoryDown(isAutocompleteActive) {
+        if (isAutocompleteActive)
+            return false;
+        if (this.historyIndex < 0)
+            return false;
+        this.historyIndex--;
+        if (this.historyIndex === -1) {
+            // Restore saved input (may be multiline)
+            this.lines = this.savedInput.split('\n');
+            if (this.lines.length === 0)
+                this.lines = [''];
+            this.currentLine = this.lines.length - 1;
+            this.cursorPos = this.lines[this.currentLine].length;
+        }
+        else {
+            // Navigate to newer entry
+            const historyEntry = this.history[this.history.length - 1 - this.historyIndex];
+            this.lines = [historyEntry];
+            this.currentLine = 0;
+            this.cursorPos = historyEntry.length;
+        }
+        return true;
+    }
+    resetHistoryNavigation() {
+        this.historyIndex = -1;
+        this.savedInput = '';
+    }
+    // ===========================================================================
+    // Word movement
+    // ===========================================================================
+    /**
+     * Move cursor to previous word boundary (Option+Left).
+     * @returns true if cursor moved (caller should trigger render)
+     */
+    moveWordLeft() {
+        const line = this.lines[this.currentLine];
+        if (this.cursorPos > 0) {
+            let pos = this.cursorPos;
+            // Skip spaces
+            while (pos > 0 && line[pos - 1] === ' ')
+                pos--;
+            // Skip word
+            while (pos > 0 && line[pos - 1] !== ' ')
+                pos--;
+            this.cursorPos = pos;
+            return true;
+        }
+        else if (this.currentLine > 0) {
+            // Move to end of previous line
+            this.currentLine--;
+            this.cursorPos = this.lines[this.currentLine].length;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Move cursor to next word boundary (Option+Right).
+     * @returns true if cursor moved (caller should trigger render)
+     */
+    moveWordRight() {
+        const line = this.lines[this.currentLine];
+        if (this.cursorPos < line.length) {
+            let pos = this.cursorPos;
+            // Skip word
+            while (pos < line.length && line[pos] !== ' ')
+                pos++;
+            // Skip spaces
+            while (pos < line.length && line[pos] === ' ')
+                pos++;
+            this.cursorPos = pos;
+            return true;
+        }
+        else if (this.currentLine < this.lines.length - 1) {
+            // Move to start of next line
+            this.currentLine++;
+            this.cursorPos = 0;
+            return true;
+        }
+        return false;
+    }
+    // ===========================================================================
+    // Input queue
+    // ===========================================================================
+    getQueuedInputs() {
+        return [...this.queuedInputs];
+    }
+    popQueuedInput() {
+        if (this.queuedInputs.length === 0)
+            return null;
+        return this.queuedInputs.shift() ?? null;
+    }
+    hasQueuedInput() {
+        return this.queuedInputs.length > 0;
+    }
+    clearQueue() {
+        this.queuedInputs = [];
+    }
+}

package/dist/ui/input-prompt.d.ts

@@ -1,56 +1,137 @@
 /**
- * Input Prompt
+ * Input Prompt v2 (Event-Driven)
  *
- * @deprecated This module is superseded by input-prompt-v2.ts which uses
- * event-driven architecture for non-blocking input with queue mode support.
- * This file is kept for reference and may be removed in a future cleanup.
+ * Refactored input handling with event-driven architecture.
+ * - Emits events instead of blocking with getInput()
+ * - Supports queue mode for capturing input during agent execution
+ * - Always captures keystrokes (no blocking)
  *
- * Self-contained input handling with multiline support, autocomplete,
- * history navigation, and proper visual line navigation.
+ * Events:
+ * - 'submit' - User pressed Enter with input
+ * - 'command' - User submitted a slash command
+ * - 'cancel' - User pressed Ctrl+C
+ * - 'escape' - User pressed Esc (for aborting agent)
+ * - 'change' - Input text changed
  */
-import type { CommandOption, InputResult, TodoItem } from './types.js';
+import { EventEmitter } from 'events';
+import type { CommandOption } from './types.js';
 export declare const DEFAULT_COMMANDS: CommandOption[];
 /**
  * Strip ANSI codes from string
+ * Uses unified line-utils for consistent behavior across components.
  */
 export declare function stripAnsi(str: string): string;
+/**
+ * Agent suggestion for $ autocomplete
+ */
+export interface AgentSuggestion {
+    id: string;
+    displayName: string;
+    mascot: string;
+}
+export interface InputPromptEvents {
+    submit: (input: string) => void;
+    command: (command: string, args: string) => void;
+    cancel: () => void;
+    escape: () => void;
+    change: (input: string) => void;
+    modeChange: () => void;
+}
 export interface InputPromptOptions {
     prompt?: string;
     showSeparators?: boolean;
     commands?: CommandOption[];
-    getTodos?: () => TodoItem[];
+    /** Callback to get available team agents for $ autocomplete */
+    getAgentSuggestions?: () => AgentSuggestion[];
+    /** Callback to get available commands for / autocomplete */
+    getCommands?: () => CommandOption[];
 }
-export declare class InputPrompt {
-    private readonly prompt;
-    private readonly promptLen;
+export declare class InputPrompt extends EventEmitter {
+    private prompt;
+    private promptLen;
     private readonly showSeparators;
     private readonly commands;
-    private readonly getTodos?;
+    private getAgentSuggestions?;
+    private readonly getCommands?;
     private state;
     private autocomplete;
+    private fileAutocomplete;
+    private agentAutocomplete;
     private readonly history;
     private historyIndex;
     private savedInput;
+    private queueMode;
+    private queuedInputs;
     private renderedLines;
     private dropdownLines;
     private linesAboveCursor;
     private hasSeparators;
     private isRunning;
-    private resolveInput;
+    private lastEscTime;
+    private readonly DOUBLE_ESC_THRESHOLD_MS;
+    private suggestion;
     constructor(options?: InputPromptOptions);
     /**
-     * Get input from user (async)
-     * Returns when user submits or cancels
+     * Update the prompt string (for dynamic theme changes)
+     */
+    setPrompt(prompt: string): void;
+    /**
+     * Set a suggestion for the next action (ghost text)
+     */
+    setSuggestion(action: string | null): void;
+    /**
+     * Get the current suggestion
+     */
+    getSuggestion(): string | null;
+    /**
+     * Clear the current suggestion
+     */
+    clearSuggestion(): void;
+    /**
+     * Set the callback to get available team agents for $ autocomplete
      */
-    getInput(): Promise<InputResult>;
+    setAgentSuggestionsCallback(callback: (() => AgentSuggestion[]) | undefined): void;
     /**
-     * Start input mode
+     * Start input capture (non-blocking, event-driven)
      */
     start(): void;
     /**
-     * Stop input mode
+     * Stop input capture
      */
     stop(): void;
+    /**
+     * Check if running
+     */
+    isActive(): boolean;
+    /**
+     * Enable/disable queue mode
+     * In queue mode, Enter adds to queue instead of emitting 'submit'
+     */
+    setQueueMode(enabled: boolean): void;
+    /**
+     * Check if in queue mode
+     */
+    isQueueMode(): boolean;
+    /**
+     * Get all queued inputs (FIFO order)
+     */
+    getQueuedInputs(): string[];
+    /**
+     * Pop the first queued input
+     */
+    popQueuedInput(): string | null;
+    /**
+     * Check if there are queued inputs
+     */
+    hasQueuedInput(): boolean;
+    /**
+     * Get number of queued inputs
+     */
+    getQueueLength(): number;
+    /**
+     * Clear the queue
+     */
+    clearQueue(): void;
     /**
      * Get current buffer value
      */
@@ -60,28 +141,50 @@ export declare class InputPrompt {
      */
     setValue(value: string): void;
     /**
-     * Clear the rendered area
+     * Clear input buffer
      */
-    clear(): void;
-    /**
-     * Get number of rendered lines
-     */
-    getRenderedLines(): number;
+    clearInput(): void;
     /**
      * Add command to history
      */
     addToHistory(input: string): void;
-    private resetState;
-    private updateAutocomplete;
     /**
-     * Get physical layout of current buffer
+     * Render the input prompt - returns array of lines
+     * Does NOT write to terminal (Footer handles that)
+     */
+    render(): string[];
+    /**
+     * Get the cursor position info for rendering
+     */
+    getCursorInfo(): {
+        row: number;
+        col: number;
+    };
+    /**
+     * Get autocomplete dropdown lines (if active)
      */
-    private getPhysicalLayout;
+    getAutocompleteLines(): string[];
+    /**
+     * Check if autocomplete is showing
+     */
+    isAutocompleteActive(): boolean;
+    /**
+     * Get height of rendered content
+     */
+    getHeight(): number;
+    /**
+     * @deprecated Use event-driven start() instead
+     * Kept for backwards compatibility during migration
+     */
+    getInput(): Promise<{
+        action: string;
+        value?: string;
+        command?: string;
+        args?: string;
+    }>;
+    private resetState;
+    private updateAutocomplete;
     private getSeparatorLine;
-    private renderTodos;
-    private render;
-    private renderDropdown;
-    private clearDropdown;
     private readonly handleData;
     private handleKey;
     private handleEnter;
@@ -93,5 +196,4 @@ export declare class InputPrompt {
     private handleWordLeft;
     private handleWordRight;
     private handleBackspace;
-    private finishInput;
 }