@compilr-dev/cli 0.4.0

package/dist/ui/init-overlay.js

@@ -0,0 +1,525 @@
+/**
+ * Init Overlay
+ *
+ * Modal overlay for the /init wizard - creates new projects with structured workflow.
+ * Steps:
+ *   0. Project type (new vs existing)
+ *   1. Project name
+ *   2. Description
+ *   3. Repo pattern (single vs two-repo)
+ *   4. Tech stack
+ *   5. Coding standards
+ *   6. Initialize git?
+ *   7. Confirmation
+ */
+import chalk from 'chalk';
+import * as terminal from './terminal.js';
+import { getStyles } from '../themes/index.js';
+import { TECH_STACK_LABELS, CODING_STANDARDS_LABELS, REPO_PATTERN_LABELS, generateProject, isValidProjectName, projectExists, } from '../templates/index.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const TECH_STACK_OPTIONS = ['react-node-pg', 'react-python-pg', 'vue-node-pg', 'custom'];
+const CODING_STANDARDS_OPTIONS = ['strict', 'relaxed', 'custom'];
+const REPO_PATTERN_OPTIONS = ['single', 'two-repo'];
+// =============================================================================
+// Rendering Helpers
+// =============================================================================
+function renderHeader(step) {
+    const s = getStyles();
+    const lines = [];
+    const cols = terminal.getTerminalWidth();
+    lines.push(s.muted('─'.repeat(Math.max(1, cols - 1))));
+    lines.push(' ' + s.primaryBold('Initialize New Project') + s.muted(` [${String(step)}/7]`));
+    lines.push('');
+    return lines;
+}
+function renderFooter(step) {
+    const s = getStyles();
+    const lines = [];
+    lines.push('');
+    if (step === 0) {
+        lines.push(s.muted(' ↑↓ Navigate · Enter Select · Esc Cancel'));
+    }
+    else if (step === 7) {
+        lines.push(s.muted(' ↑↓ Navigate · Enter Confirm · Esc Go back'));
+    }
+    else {
+        lines.push(s.muted(' Enter Confirm · Esc Go back'));
+    }
+    return lines;
+}
+function renderSelectionOption(index, selectedIndex, label, disabled = false) {
+    const s = getStyles();
+    const isSelected = index === selectedIndex;
+    const prefix = isSelected ? ' ❯ ' : '   ';
+    if (disabled) {
+        return s.muted(prefix + label + ' (coming soon)');
+    }
+    return isSelected ? s.primary(prefix + label) : s.muted(prefix + label);
+}
+// =============================================================================
+// Step Renderers
+// =============================================================================
+function renderStep0(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' What would you like to do?'));
+    lines.push('');
+    lines.push(renderSelectionOption(0, state.selectedIndex, '1. Start a new project'));
+    lines.push(renderSelectionOption(1, state.selectedIndex, '2. Add workflow to existing project', true));
+    lines.push('');
+    lines.push(s.muted(' Start fresh with a structured project layout'));
+    lines.push(s.muted(' optimized for AI-assisted development.'));
+    return lines;
+}
+function renderStep1(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Project name'));
+    lines.push('');
+    lines.push(` > ${state.inputBuffer}█`);
+    lines.push('');
+    if (state.error) {
+        lines.push(s.error(` ${state.error}`));
+    }
+    else {
+        lines.push(s.muted(' Use lowercase letters, numbers, hyphens (e.g., my-saas-app)'));
+        lines.push(s.muted(' 2-50 characters, must start with a letter'));
+    }
+    return lines;
+}
+function renderStep2(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' What are you building?'));
+    lines.push('');
+    lines.push(` > ${state.inputBuffer}█`);
+    lines.push('');
+    if (state.error) {
+        lines.push(s.error(` ${state.error}`));
+    }
+    else {
+        lines.push(s.muted(' Brief description (1-2 sentences)'));
+        lines.push(s.muted(' Example: "A task management SaaS for small teams"'));
+    }
+    return lines;
+}
+function renderStep3(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Documentation structure'));
+    lines.push('');
+    for (let i = 0; i < REPO_PATTERN_OPTIONS.length; i++) {
+        const pattern = REPO_PATTERN_OPTIONS[i];
+        lines.push(renderSelectionOption(i, state.selectedIndex, `${String(i + 1)}. ${REPO_PATTERN_LABELS[pattern]}`));
+    }
+    lines.push('');
+    lines.push(s.muted(' Single repo: All files in one repository'));
+    lines.push(s.muted(' Two repos: Code and docs in separate repositories'));
+    return lines;
+}
+function renderStep4(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Tech stack'));
+    lines.push('');
+    for (let i = 0; i < TECH_STACK_OPTIONS.length; i++) {
+        const stack = TECH_STACK_OPTIONS[i];
+        lines.push(renderSelectionOption(i, state.selectedIndex, `${String(i + 1)}. ${TECH_STACK_LABELS[stack]}`));
+    }
+    lines.push('');
+    lines.push(s.muted(' Choose a preset or configure later'));
+    return lines;
+}
+function renderStep5(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Coding standards preset'));
+    lines.push('');
+    for (let i = 0; i < CODING_STANDARDS_OPTIONS.length; i++) {
+        const standard = CODING_STANDARDS_OPTIONS[i];
+        lines.push(renderSelectionOption(i, state.selectedIndex, `${String(i + 1)}. ${CODING_STANDARDS_LABELS[standard]}`));
+    }
+    lines.push('');
+    lines.push(s.muted(' Strict: Full TypeScript with strict mode + ESLint'));
+    lines.push(s.muted(' Relaxed: TypeScript with basic strict mode'));
+    lines.push(s.muted(' Custom: Configure your own standards later'));
+    return lines;
+}
+function renderStep6(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Initialize git repository?'));
+    lines.push('');
+    lines.push(renderSelectionOption(0, state.selectedIndex, 'Yes'));
+    lines.push(renderSelectionOption(1, state.selectedIndex, 'No'));
+    lines.push('');
+    lines.push(s.muted(' Creates git repo with initial commit'));
+    return lines;
+}
+function renderStep7(state) {
+    const s = getStyles();
+    const lines = [];
+    lines.push(chalk.bold(' Ready to create project?'));
+    lines.push('');
+    lines.push(` Project:     ${s.primary(state.projectName)}`);
+    lines.push(` Location:    ${s.primary('./' + state.projectName + '/')}`);
+    lines.push(` Structure:   ${s.primary(state.repoPattern === 'single' ? 'Single repo' : 'Two repos')}`);
+    lines.push(` Tech:        ${s.primary(state.techStack ? TECH_STACK_LABELS[state.techStack] : 'Not set')}`);
+    lines.push(` Standards:   ${s.primary(state.codingStandards ? CODING_STANDARDS_LABELS[state.codingStandards] : 'Not set')}`);
+    lines.push(` Git:         ${s.primary(state.initGit ? 'Yes' : 'No')}`);
+    if (state.repoPattern === 'two-repo') {
+        lines.push('');
+        lines.push(s.muted(` Docs repo:   ./${state.projectName}-docs/`));
+    }
+    lines.push('');
+    if (state.error) {
+        lines.push(s.error(` ${state.error}`));
+        lines.push('');
+    }
+    lines.push(renderSelectionOption(0, state.selectedIndex, 'Create'));
+    lines.push(renderSelectionOption(1, state.selectedIndex, 'Cancel'));
+    return lines;
+}
+// =============================================================================
+// Unified Rendering
+// =============================================================================
+function buildLines(state) {
+    const lines = [];
+    lines.push(...renderHeader(state.step));
+    switch (state.step) {
+        case 0:
+            lines.push(...renderStep0(state));
+            break;
+        case 1:
+            lines.push(...renderStep1(state));
+            break;
+        case 2:
+            lines.push(...renderStep2(state));
+            break;
+        case 3:
+            lines.push(...renderStep3(state));
+            break;
+        case 4:
+            lines.push(...renderStep4(state));
+            break;
+        case 5:
+            lines.push(...renderStep5(state));
+            break;
+        case 6:
+            lines.push(...renderStep6(state));
+            break;
+        case 7:
+            lines.push(...renderStep7(state));
+            break;
+    }
+    lines.push(...renderFooter(state.step));
+    return lines;
+}
+function render(state, prevLineCount) {
+    const lines = buildLines(state);
+    // Clear previous content
+    terminal.clearLinesAbove(prevLineCount);
+    // Write new content
+    terminal.write(lines.join('\n'));
+    return lines.length;
+}
+// =============================================================================
+// Step Navigation
+// =============================================================================
+function getMaxOptionsForStep(step) {
+    switch (step) {
+        case 0:
+            return 2;
+        case 3:
+            return REPO_PATTERN_OPTIONS.length;
+        case 4:
+            return TECH_STACK_OPTIONS.length;
+        case 5:
+            return CODING_STANDARDS_OPTIONS.length;
+        case 6:
+            return 2;
+        case 7:
+            return 2;
+        default:
+            return 0;
+    }
+}
+function isSelectionStep(step) {
+    return [0, 3, 4, 5, 6, 7].includes(step);
+}
+function isInputStep(step) {
+    return [1, 2].includes(step);
+}
+/**
+ * Show the init wizard overlay
+ */
+export async function showInitOverlay() {
+    const state = {
+        step: 0,
+        projectType: null,
+        projectName: '',
+        description: '',
+        repoPattern: null,
+        techStack: null,
+        codingStandards: null,
+        initGit: true,
+        selectedIndex: 0,
+        inputBuffer: '',
+        error: null,
+    };
+    let lineCount = 0;
+    terminal.writeLine('');
+    terminal.hideCursor();
+    const wasRawMode = process.stdin.isRaw;
+    terminal.enableRawMode();
+    lineCount = render(state, 0);
+    // Navigate to next step
+    const nextStep = () => {
+        switch (state.step) {
+            case 0:
+                // Only "new" option works (index 0)
+                if (state.selectedIndex === 0) {
+                    state.projectType = 'new';
+                    state.step = 1;
+                    state.inputBuffer = '';
+                    state.selectedIndex = 0;
+                }
+                break;
+            case 1:
+                state.projectName = state.inputBuffer.trim();
+                state.step = 2;
+                state.inputBuffer = '';
+                break;
+            case 2:
+                state.description = state.inputBuffer.trim();
+                state.step = 3;
+                state.selectedIndex = 0;
+                break;
+            case 3:
+                state.repoPattern = REPO_PATTERN_OPTIONS[state.selectedIndex];
+                state.step = 4;
+                state.selectedIndex = 0;
+                break;
+            case 4:
+                state.techStack = TECH_STACK_OPTIONS[state.selectedIndex];
+                state.step = 5;
+                state.selectedIndex = 0;
+                break;
+            case 5:
+                state.codingStandards = CODING_STANDARDS_OPTIONS[state.selectedIndex];
+                state.step = 6;
+                state.selectedIndex = 0;
+                break;
+            case 6:
+                state.initGit = state.selectedIndex === 0;
+                state.step = 7;
+                state.selectedIndex = 0;
+                break;
+        }
+        state.error = null;
+    };
+    // Navigate to previous step
+    const prevStep = () => {
+        switch (state.step) {
+            case 1:
+                state.step = 0;
+                state.selectedIndex = 0;
+                break;
+            case 2:
+                state.step = 1;
+                state.inputBuffer = state.projectName;
+                break;
+            case 3:
+                state.step = 2;
+                state.inputBuffer = state.description;
+                break;
+            case 4:
+                state.step = 3;
+                state.selectedIndex = state.repoPattern ? REPO_PATTERN_OPTIONS.indexOf(state.repoPattern) : 0;
+                break;
+            case 5:
+                state.step = 4;
+                state.selectedIndex = state.techStack ? TECH_STACK_OPTIONS.indexOf(state.techStack) : 0;
+                break;
+            case 6:
+                state.step = 5;
+                state.selectedIndex = state.codingStandards ? CODING_STANDARDS_OPTIONS.indexOf(state.codingStandards) : 0;
+                break;
+            case 7:
+                state.step = 6;
+                state.selectedIndex = state.initGit ? 0 : 1;
+                break;
+        }
+        state.error = null;
+    };
+    // Validate input for current step
+    const validateInput = () => {
+        if (state.step === 1) {
+            const name = state.inputBuffer.trim();
+            if (!name) {
+                state.error = 'Project name is required';
+                return false;
+            }
+            if (!isValidProjectName(name)) {
+                state.error = 'Invalid name. Use lowercase letters, numbers, hyphens (2-50 chars, start with letter)';
+                return false;
+            }
+            if (projectExists(name)) {
+                state.error = `Directory "${name}" already exists`;
+                return false;
+            }
+        }
+        if (state.step === 2) {
+            const desc = state.inputBuffer.trim();
+            if (!desc) {
+                state.error = 'Description is required';
+                return false;
+            }
+            if (desc.length < 10) {
+                state.error = 'Description too short (min 10 characters)';
+                return false;
+            }
+        }
+        return true;
+    };
+    return new Promise((resolve) => {
+        const cleanup = () => {
+            terminal.clearLinesAbove(lineCount);
+            terminal.writeLine('');
+            terminal.showCursor();
+            if (!wasRawMode) {
+                terminal.disableRawMode();
+            }
+            process.stdin.removeListener('data', handleData);
+        };
+        const handleData = (data) => {
+            void onData(data);
+        };
+        const onData = async (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);
+            // Ctrl+C always cancels
+            if (isCtrlC) {
+                cleanup();
+                resolve({ created: false });
+                return;
+            }
+            // Escape on step 0 cancels, otherwise goes back
+            if (isEscape) {
+                if (state.step === 0) {
+                    cleanup();
+                    resolve({ created: false });
+                    return;
+                }
+                prevStep();
+                lineCount = render(state, lineCount);
+                return;
+            }
+            // Handle selection steps
+            if (isSelectionStep(state.step)) {
+                const maxOptions = getMaxOptionsForStep(state.step);
+                if (isUpArrow && state.selectedIndex > 0) {
+                    state.selectedIndex--;
+                    lineCount = render(state, lineCount);
+                    return;
+                }
+                if (isDownArrow && state.selectedIndex < maxOptions - 1) {
+                    state.selectedIndex++;
+                    lineCount = render(state, lineCount);
+                    return;
+                }
+                if (isEnter) {
+                    // Step 0 - only allow "new" option
+                    if (state.step === 0 && state.selectedIndex === 1) {
+                        state.error = 'This option is coming soon';
+                        lineCount = render(state, lineCount);
+                        return;
+                    }
+                    // Step 7 - confirmation
+                    if (state.step === 7) {
+                        if (state.selectedIndex === 1) {
+                            // Cancel
+                            cleanup();
+                            resolve({ created: false });
+                            return;
+                        }
+                        // Verify all required fields are set (they should be by step 7)
+                        if (!state.repoPattern || !state.techStack || !state.codingStandards) {
+                            state.error = 'Missing configuration values';
+                            lineCount = render(state, lineCount);
+                            return;
+                        }
+                        // Create project
+                        const config = {
+                            name: state.projectName,
+                            description: state.description,
+                            repoPattern: state.repoPattern,
+                            techStack: state.techStack,
+                            codingStandards: state.codingStandards,
+                            initGit: state.initGit,
+                        };
+                        cleanup();
+                        // Show "creating..." message
+                        terminal.writeLine(chalk.cyan(' Creating project...'));
+                        try {
+                            const result = await generateProject(config);
+                            if (result.success) {
+                                resolve({
+                                    created: true,
+                                    projectPath: result.projectPath,
+                                    docsPath: result.docsPath,
+                                    filesCreated: result.filesCreated,
+                                });
+                            }
+                            else {
+                                terminal.writeLine(chalk.red(` Error: ${result.error ?? 'Unknown error'}`));
+                                resolve({ created: false });
+                            }
+                        }
+                        catch (error) {
+                            terminal.writeLine(chalk.red(` Error: ${error.message}`));
+                            resolve({ created: false });
+                        }
+                        return;
+                    }
+                    nextStep();
+                    lineCount = render(state, lineCount);
+                    return;
+                }
+            }
+            // Handle input steps
+            if (isInputStep(state.step)) {
+                if (isEnter) {
+                    if (validateInput()) {
+                        nextStep();
+                        lineCount = render(state, lineCount);
+                    }
+                    else {
+                        lineCount = render(state, lineCount);
+                    }
+                    return;
+                }
+                if (isBackspace) {
+                    state.inputBuffer = state.inputBuffer.slice(0, -1);
+                    state.error = null;
+                    lineCount = render(state, lineCount);
+                    return;
+                }
+                // Regular character input
+                const char = data.toString('utf-8');
+                if (char.length === 1 && char.charCodeAt(0) >= 32) {
+                    state.inputBuffer += char;
+                    state.error = null;
+                    lineCount = render(state, lineCount);
+                }
+            }
+        };
+        process.stdin.on('data', handleData);
+    });
+}

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

@@ -0,0 +1,179 @@
+/**
+ * Input Prompt v2 (Event-Driven)
+ *
+ * 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)
+ *
+ * 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 { EventEmitter } from 'events';
+import type { CommandOption } from './types.js';
+export declare const DEFAULT_COMMANDS: CommandOption[];
+/**
+ * Strip ANSI codes from string
+ */
+export declare function stripAnsi(str: string): 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[];
+}
+export declare class InputPrompt extends EventEmitter {
+    private prompt;
+    private promptLen;
+    private readonly showSeparators;
+    private readonly commands;
+    private state;
+    private autocomplete;
+    private fileAutocomplete;
+    private readonly history;
+    private historyIndex;
+    private savedInput;
+    private queueMode;
+    private queuedInputs;
+    private renderedLines;
+    private dropdownLines;
+    private linesAboveCursor;
+    private hasSeparators;
+    private isRunning;
+    private lastEscTime;
+    private readonly DOUBLE_ESC_THRESHOLD_MS;
+    private suggestion;
+    constructor(options?: InputPromptOptions);
+    /**
+     * 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;
+    /**
+     * Start input capture (non-blocking, event-driven)
+     */
+    start(): void;
+    /**
+     * 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
+     */
+    getValue(): string;
+    /**
+     * Set buffer value
+     */
+    setValue(value: string): void;
+    /**
+     * Clear input buffer
+     */
+    clearInput(): void;
+    /**
+     * Add command to history
+     */
+    addToHistory(input: string): void;
+    /**
+     * 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)
+     */
+    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 readonly handleData;
+    private handleKey;
+    private handleEnter;
+    private handleTab;
+    private handleArrowUp;
+    private handleArrowDown;
+    private handleArrowLeft;
+    private handleArrowRight;
+    private handleWordLeft;
+    private handleWordRight;
+    private handleBackspace;
+}