@lanonasis/cli 3.8.0 → 3.9.0

package/dist/ux/implementations/TextInputHandlerImpl.js

@@ -0,0 +1,342 @@
+/**
+ * Text Input Handler Implementation
+ *
+ * Provides seamless multi-line text input without external editors
+ * Implementation of the TextInputHandler interface.
+ */
+/**
+ * Default input options for the text input handler
+ */
+const DEFAULT_INPUT_OPTIONS = {
+    placeholder: 'Enter your text (Ctrl+D to finish, Ctrl+C to cancel):',
+    maxLines: 100,
+    submitKeys: ['ctrl+d'],
+    cancelKeys: ['ctrl+c'],
+    showLineNumbers: true,
+};
+/**
+ * TextInputHandlerImpl provides seamless multi-line text input without external editors
+ *
+ * This implementation uses process.stdin.setRawMode(true) to capture individual keystrokes
+ * and handles special characters manually to provide a smooth editing experience.
+ */
+export class TextInputHandlerImpl {
+    currentSession = null;
+    isRawModeEnabled = false;
+    originalStdinMode;
+    /**
+     * Collect multi-line text input from the user
+     */
+    async collectMultilineInput(prompt, options) {
+        const mergedOptions = { ...DEFAULT_INPUT_OPTIONS, ...options };
+        // Initialize content with defaultContent if provided
+        const initialContent = mergedOptions.defaultContent
+            ? mergedOptions.defaultContent.split('\n')
+            : [''];
+        // Create new input session
+        this.currentSession = {
+            id: `session_${Date.now()}`,
+            prompt,
+            content: initialContent,
+            cursorPosition: {
+                line: initialContent.length - 1,
+                column: initialContent[initialContent.length - 1].length
+            },
+            startTime: new Date(),
+            options: mergedOptions,
+            status: 'active',
+        };
+        return new Promise((resolve, reject) => {
+            try {
+                this.enableRawMode();
+                this.displayInputPrompt('');
+                const handleKeypress = (chunk) => {
+                    const key = this.parseKeyEvent(chunk);
+                    if (this.handleSpecialKeys(key)) {
+                        return;
+                    }
+                    // Handle regular character input
+                    if (key.sequence && this.currentSession) {
+                        this.addCharacterToInput(key.sequence);
+                        this.displayInputPrompt(this.getCurrentContent());
+                    }
+                };
+                const cleanup = () => {
+                    process.stdin.removeListener('data', handleKeypress);
+                    this.disableRawMode();
+                };
+                // Set up completion handlers
+                const complete = (result) => {
+                    cleanup();
+                    if (this.currentSession) {
+                        this.currentSession.status = 'completed';
+                    }
+                    resolve(result);
+                };
+                const cancel = () => {
+                    cleanup();
+                    if (this.currentSession) {
+                        this.currentSession.status = 'cancelled';
+                    }
+                    reject(new Error('Input cancelled by user'));
+                };
+                // Store handlers for special key processing
+                this._completeHandler = complete;
+                this._cancelHandler = cancel;
+                process.stdin.on('data', handleKeypress);
+            }
+            catch (error) {
+                this.disableRawMode();
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Enable raw mode for direct keystroke capture
+     */
+    enableRawMode() {
+        if (!this.isRawModeEnabled && process.stdin.isTTY) {
+            this.originalStdinMode = process.stdin.isRaw;
+            process.stdin.setRawMode(true);
+            this.isRawModeEnabled = true;
+        }
+    }
+    /**
+     * Disable raw mode and return to normal terminal behavior
+     */
+    disableRawMode() {
+        if (this.isRawModeEnabled && process.stdin.isTTY) {
+            process.stdin.setRawMode(this.originalStdinMode || false);
+            this.isRawModeEnabled = false;
+        }
+    }
+    /**
+     * Handle special keyboard events
+     */
+    handleSpecialKeys(key) {
+        if (!this.currentSession)
+            return false;
+        const { options } = this.currentSession;
+        // Handle submit keys (default: Ctrl+D)
+        if (options.submitKeys?.some((submitKey) => this.matchesKey(key, submitKey))) {
+            const content = this.getCurrentContent();
+            this._completeHandler?.(content);
+            return true;
+        }
+        // Handle cancel keys (default: Ctrl+C)
+        if (options.cancelKeys?.some((cancelKey) => this.matchesKey(key, cancelKey))) {
+            this._cancelHandler?.();
+            return true;
+        }
+        // Handle Enter key (new line)
+        if (key.name === 'return' || key.name === 'enter') {
+            this.addNewLine();
+            this.displayInputPrompt(this.getCurrentContent());
+            return true;
+        }
+        // Handle Backspace
+        if (key.name === 'backspace') {
+            this.handleBackspace();
+            this.displayInputPrompt(this.getCurrentContent());
+            return true;
+        }
+        // Handle arrow keys
+        if (key.name === 'up' || key.name === 'down' || key.name === 'left' || key.name === 'right') {
+            this.handleArrowKey(key.name);
+            this.displayInputPrompt(this.getCurrentContent());
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Display the input prompt with current content
+     */
+    displayInputPrompt(content) {
+        if (!this.currentSession)
+            return;
+        // Clear the screen and move cursor to top
+        process.stdout.write('\x1b[2J\x1b[H');
+        // Display prompt
+        console.log(this.currentSession.prompt);
+        console.log('─'.repeat(50));
+        // Display content with line numbers if enabled
+        const lines = content.split('\n');
+        if (this.currentSession.options.showLineNumbers) {
+            lines.forEach((line, index) => {
+                const lineNum = (index + 1).toString().padStart(3, ' ');
+                const cursor = this.currentSession.cursorPosition.line === index ? '→' : ' ';
+                console.log(`${lineNum}${cursor} ${line}`);
+            });
+        }
+        else {
+            console.log(content);
+        }
+        // Display help text
+        console.log('─'.repeat(50));
+        console.log('Ctrl+D to finish, Ctrl+C to cancel, Enter for new line');
+    }
+    /**
+     * Get the current input session
+     */
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    /**
+     * Cancel the current input session
+     */
+    cancelInput() {
+        if (this.currentSession) {
+            this.currentSession.status = 'cancelled';
+            this._cancelHandler?.();
+        }
+    }
+    /**
+     * Parse raw key event from buffer
+     */
+    parseKeyEvent(chunk) {
+        const sequence = chunk.toString();
+        const key = { sequence };
+        // Parse common key combinations
+        if (sequence === '\u0003') {
+            key.name = 'c';
+            key.ctrl = true;
+        }
+        else if (sequence === '\u0004') {
+            key.name = 'd';
+            key.ctrl = true;
+        }
+        else if (sequence === '\r' || sequence === '\n') {
+            key.name = 'return';
+        }
+        else if (sequence === '\u007f' || sequence === '\b') {
+            key.name = 'backspace';
+        }
+        else if (sequence === '\u001b[A') {
+            key.name = 'up';
+        }
+        else if (sequence === '\u001b[B') {
+            key.name = 'down';
+        }
+        else if (sequence === '\u001b[C') {
+            key.name = 'right';
+        }
+        else if (sequence === '\u001b[D') {
+            key.name = 'left';
+        }
+        return key;
+    }
+    /**
+     * Check if a key event matches a key pattern
+     */
+    matchesKey(key, pattern) {
+        if (pattern.startsWith('ctrl+')) {
+            const keyName = pattern.substring(5);
+            return key.ctrl === true && key.name === keyName;
+        }
+        return key.name === pattern;
+    }
+    /**
+     * Add a character to the current input
+     */
+    addCharacterToInput(char) {
+        if (!this.currentSession)
+            return;
+        const { cursorPosition, content } = this.currentSession;
+        const currentLine = content[cursorPosition.line] || '';
+        const newLine = currentLine.slice(0, cursorPosition.column) + char + currentLine.slice(cursorPosition.column);
+        content[cursorPosition.line] = newLine;
+        cursorPosition.column += char.length;
+    }
+    /**
+     * Add a new line to the input
+     */
+    addNewLine() {
+        if (!this.currentSession)
+            return;
+        const { cursorPosition, content, options } = this.currentSession;
+        // Check max lines limit
+        if (options.maxLines && content.length >= options.maxLines) {
+            return;
+        }
+        const currentLine = content[cursorPosition.line] || '';
+        const beforeCursor = currentLine.slice(0, cursorPosition.column);
+        const afterCursor = currentLine.slice(cursorPosition.column);
+        content[cursorPosition.line] = beforeCursor;
+        content.splice(cursorPosition.line + 1, 0, afterCursor);
+        cursorPosition.line++;
+        cursorPosition.column = 0;
+    }
+    /**
+     * Handle backspace key
+     */
+    handleBackspace() {
+        if (!this.currentSession)
+            return;
+        const { cursorPosition, content } = this.currentSession;
+        if (cursorPosition.column > 0) {
+            // Remove character from current line
+            const currentLine = content[cursorPosition.line];
+            const newLine = currentLine.slice(0, cursorPosition.column - 1) + currentLine.slice(cursorPosition.column);
+            content[cursorPosition.line] = newLine;
+            cursorPosition.column--;
+        }
+        else if (cursorPosition.line > 0) {
+            // Merge with previous line
+            const currentLine = content[cursorPosition.line];
+            const previousLine = content[cursorPosition.line - 1];
+            content[cursorPosition.line - 1] = previousLine + currentLine;
+            content.splice(cursorPosition.line, 1);
+            cursorPosition.line--;
+            cursorPosition.column = previousLine.length;
+        }
+    }
+    /**
+     * Handle arrow key navigation
+     */
+    handleArrowKey(direction) {
+        if (!this.currentSession)
+            return;
+        const { cursorPosition, content } = this.currentSession;
+        switch (direction) {
+            case 'up':
+                if (cursorPosition.line > 0) {
+                    cursorPosition.line--;
+                    const newLineLength = content[cursorPosition.line]?.length || 0;
+                    cursorPosition.column = Math.min(cursorPosition.column, newLineLength);
+                }
+                break;
+            case 'down':
+                if (cursorPosition.line < content.length - 1) {
+                    cursorPosition.line++;
+                    const newLineLength = content[cursorPosition.line]?.length || 0;
+                    cursorPosition.column = Math.min(cursorPosition.column, newLineLength);
+                }
+                break;
+            case 'left':
+                if (cursorPosition.column > 0) {
+                    cursorPosition.column--;
+                }
+                else if (cursorPosition.line > 0) {
+                    cursorPosition.line--;
+                    cursorPosition.column = content[cursorPosition.line]?.length || 0;
+                }
+                break;
+            case 'right':
+                const currentLineLength = content[cursorPosition.line]?.length || 0;
+                if (cursorPosition.column < currentLineLength) {
+                    cursorPosition.column++;
+                }
+                else if (cursorPosition.line < content.length - 1) {
+                    cursorPosition.line++;
+                    cursorPosition.column = 0;
+                }
+                break;
+        }
+    }
+    /**
+     * Get the current content as a string
+     */
+    getCurrentContent() {
+        return this.currentSession?.content.join('\n') || '';
+    }
+}

package/dist/ux/implementations/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI UX Improvements - Core Implementations
+ *
+ * This module exports all the implementation classes for the CLI UX improvements
+ * as specified in the design document. These implementations provide the concrete
+ * functionality for the TextInputHandler, ConnectionManager, and OnboardingFlow interfaces.
+ */
+export { TextInputHandlerImpl } from './TextInputHandlerImpl.js';
+export { ConnectionManagerImpl } from './ConnectionManagerImpl.js';
+export { OnboardingFlowImpl } from './OnboardingFlowImpl.js';
+export type { TextInputHandler, KeyEvent, CursorPosition, InputOptions, InputSession, ConnectionManager, ConnectionResult, ConfigResult, ServerInstance, ConnectionStatus, MCPConfig, OnboardingFlow, SetupResult, TestResult, UserPreferences, OnboardingState, } from '../interfaces/index.js';

package/dist/ux/implementations/index.js

@@ -0,0 +1,11 @@
+/**
+ * CLI UX Improvements - Core Implementations
+ *
+ * This module exports all the implementation classes for the CLI UX improvements
+ * as specified in the design document. These implementations provide the concrete
+ * functionality for the TextInputHandler, ConnectionManager, and OnboardingFlow interfaces.
+ */
+// Implementation classes
+export { TextInputHandlerImpl } from './TextInputHandlerImpl.js';
+export { ConnectionManagerImpl } from './ConnectionManagerImpl.js';
+export { OnboardingFlowImpl } from './OnboardingFlowImpl.js';

package/dist/ux/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI UX Improvements - Main Module
+ *
+ * This is the main entry point for the CLI UX improvements module.
+ * It provides a clean API for accessing all the UX enhancement components
+ * including interfaces and implementations.
+ */
+export type { TextInputHandler, KeyEvent, CursorPosition, InputOptions, InputSession, ConnectionManager, ConnectionResult, ConfigResult, ServerInstance, ConnectionStatus, MCPConfig, OnboardingFlow, SetupResult, TestResult, UserPreferences, OnboardingState, } from './interfaces/index.js';
+export { TextInputHandlerImpl, ConnectionManagerImpl, OnboardingFlowImpl, } from './implementations/index.js';
+export declare function createTextInputHandler(): TextInputHandler;
+export declare function createConnectionManager(configPath?: string): ConnectionManager;
+export declare function createOnboardingFlow(configPath?: string): OnboardingFlow;
+import type { TextInputHandler } from './interfaces/TextInputHandler.js';
+import type { ConnectionManager } from './interfaces/ConnectionManager.js';
+import type { OnboardingFlow } from './interfaces/OnboardingFlow.js';

package/dist/ux/index.js

@@ -0,0 +1,22 @@
+/**
+ * CLI UX Improvements - Main Module
+ *
+ * This is the main entry point for the CLI UX improvements module.
+ * It provides a clean API for accessing all the UX enhancement components
+ * including interfaces and implementations.
+ */
+// Export all implementations
+export { TextInputHandlerImpl, ConnectionManagerImpl, OnboardingFlowImpl, } from './implementations/index.js';
+// Convenience factory functions
+export function createTextInputHandler() {
+    return new TextInputHandlerImpl();
+}
+export function createConnectionManager(configPath) {
+    return new ConnectionManagerImpl(configPath);
+}
+export function createOnboardingFlow(configPath) {
+    return new OnboardingFlowImpl(configPath);
+}
+import { TextInputHandlerImpl } from './implementations/TextInputHandlerImpl.js';
+import { ConnectionManagerImpl } from './implementations/ConnectionManagerImpl.js';
+import { OnboardingFlowImpl } from './implementations/OnboardingFlowImpl.js';

package/dist/ux/interfaces/ConnectionManager.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Connection Manager Interface
+ *
+ * Manages MCP server discovery, configuration, and connection lifecycle
+ * for CLI UX improvements as specified in the design document.
+ */
+export interface ConnectionResult {
+    success: boolean;
+    serverPath?: string;
+    error?: string;
+    suggestions?: string[];
+}
+export interface ConfigResult {
+    success: boolean;
+    configPath?: string;
+    serverPath?: string;
+    error?: string;
+}
+export interface ServerInstance {
+    pid: number;
+    port: number;
+    status: 'starting' | 'running' | 'stopped' | 'error';
+    startTime: Date;
+    logPath: string;
+}
+export interface ConnectionStatus {
+    isConnected: boolean;
+    serverPath?: string;
+    serverInstance?: ServerInstance;
+    lastConnected?: Date;
+    connectionAttempts: number;
+    lastError?: string;
+}
+export interface MCPConfig {
+    localServerPath: string;
+    serverPort?: number;
+    autoStart: boolean;
+    connectionTimeout: number;
+    retryAttempts: number;
+    logLevel: 'error' | 'warn' | 'info' | 'debug';
+}
+/**
+ * ConnectionManager manages MCP server discovery, configuration, and connection lifecycle
+ *
+ * Key Methods:
+ * - connectLocal(): Connect to the local embedded MCP server
+ * - autoConfigureLocalServer(): Automatically configure server paths
+ * - detectServerPath(): Find the embedded MCP server location
+ * - startLocalServer(): Start the server process automatically
+ * - verifyConnection(): Test server connectivity and functionality
+ * - getConnectionStatus(): Get current connection state
+ *
+ * Implementation Strategy:
+ * - Automatically detect embedded MCP server location within CLI package
+ * - Generate configuration files with correct server paths
+ * - Start server processes automatically when needed
+ * - Implement health checks and connection verification
+ */
+export interface ConnectionManager {
+    /**
+     * Initialize the connection manager by loading persisted configuration
+     * @returns Promise that resolves when initialization is complete
+     */
+    init(): Promise<void>;
+    /**
+     * Connect to the local embedded MCP server
+     * @returns Promise that resolves to connection result
+     */
+    connectLocal(): Promise<ConnectionResult>;
+    /**
+     * Automatically configure the local MCP server with correct paths
+     * @returns Promise that resolves to configuration result
+     */
+    autoConfigureLocalServer(): Promise<ConfigResult>;
+    /**
+     * Detect the embedded MCP server path within the CLI package
+     * @returns Promise that resolves to server path or null if not found
+     */
+    detectServerPath(): Promise<string | null>;
+    /**
+     * Start the local MCP server process
+     * @returns Promise that resolves to server instance
+     */
+    startLocalServer(): Promise<ServerInstance>;
+    /**
+     * Verify that the MCP server connection is working
+     * @param serverPath Path to the server to verify
+     * @returns Promise that resolves to true if connection is valid
+     */
+    verifyConnection(serverPath: string): Promise<boolean>;
+    /**
+     * Get the current connection status
+     * @returns Current connection status information
+     */
+    getConnectionStatus(): ConnectionStatus;
+    /**
+     * Stop the local MCP server if running
+     * @returns Promise that resolves when server is stopped
+     */
+    stopLocalServer(): Promise<void>;
+    /**
+     * Get the current MCP configuration
+     * @returns Current MCP configuration
+     */
+    getConfig(): MCPConfig;
+    /**
+     * Update the MCP configuration
+     * @param config New configuration to apply
+     * @returns Promise that resolves when configuration is updated
+     */
+    updateConfig(config: Partial<MCPConfig>): Promise<void>;
+}

package/dist/ux/interfaces/ConnectionManager.js

@@ -0,0 +1,7 @@
+/**
+ * Connection Manager Interface
+ *
+ * Manages MCP server discovery, configuration, and connection lifecycle
+ * for CLI UX improvements as specified in the design document.
+ */
+export {};

package/dist/ux/interfaces/OnboardingFlow.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Onboarding Flow Interface
+ *
+ * Guides new users through initial setup and configuration
+ * for CLI UX improvements as specified in the design document.
+ */
+export interface SetupResult {
+    completed: boolean;
+    mcpConfigured: boolean;
+    memorySystemReady: boolean;
+    issues?: string[];
+}
+export interface TestResult {
+    component: string;
+    status: 'pass' | 'fail' | 'warning';
+    message: string;
+    details?: string;
+}
+export interface UserPreferences {
+    inputMode: 'inline' | 'editor';
+    preferredEditor?: string;
+    autoStartMCP: boolean;
+    showOnboardingTips: boolean;
+    verboseErrors: boolean;
+}
+export interface OnboardingState {
+    isFirstRun: boolean;
+    currentStep: number;
+    totalSteps: number;
+    completedSteps: string[];
+    skippedSteps: string[];
+    userPreferences: UserPreferences;
+}
+/**
+ * OnboardingFlow guides new users through initial setup and configuration
+ *
+ * Key Methods:
+ * - runInitialSetup(): Execute the complete onboarding process
+ * - detectFirstRun(): Check if this is a first-time user
+ * - configureDefaults(): Set up working default configurations
+ * - testConnectivity(): Test all major functionality
+ * - showWelcomeDemo(): Demonstrate key features
+ *
+ * Implementation Strategy:
+ * - Detect first-run scenarios by checking for configuration files
+ * - Create working default configurations automatically
+ * - Test all major functionality and report status
+ * - Provide interactive demonstrations of key features
+ */
+export interface OnboardingFlow {
+    /**
+     * Run the complete initial setup process for new users
+     * @returns Promise that resolves to setup result
+     */
+    runInitialSetup(): Promise<SetupResult>;
+    /**
+     * Detect if this is a first-run scenario
+     * @returns true if this appears to be a first run
+     */
+    detectFirstRun(): boolean;
+    /**
+     * Configure working default settings for immediate productivity
+     * @returns Promise that resolves when defaults are configured
+     */
+    configureDefaults(): Promise<void>;
+    /**
+     * Test connectivity and functionality of all major components
+     * @returns Promise that resolves to array of test results
+     */
+    testConnectivity(): Promise<TestResult[]>;
+    /**
+     * Show welcome demonstration of key features
+     * @returns Promise that resolves when demo is complete
+     */
+    showWelcomeDemo(): Promise<void>;
+    /**
+     * Get the current onboarding state
+     * @returns Current onboarding state
+     */
+    getOnboardingState(): OnboardingState;
+    /**
+     * Update user preferences during onboarding
+     * @param preferences New preferences to apply
+     * @returns Promise that resolves when preferences are updated
+     */
+    updateUserPreferences(preferences: Partial<UserPreferences>): Promise<void>;
+    /**
+     * Skip the current onboarding step
+     * @param reason Optional reason for skipping
+     * @returns Promise that resolves when step is skipped
+     */
+    skipCurrentStep(reason?: string): Promise<void>;
+    /**
+     * Complete the onboarding process
+     * @returns Promise that resolves when onboarding is complete
+     */
+    completeOnboarding(): Promise<void>;
+    /**
+     * Reset onboarding state (for testing or re-running)
+     * @returns Promise that resolves when state is reset
+     */
+    resetOnboarding(): Promise<void>;
+}

package/dist/ux/interfaces/OnboardingFlow.js

@@ -0,0 +1,7 @@
+/**
+ * Onboarding Flow Interface
+ *
+ * Guides new users through initial setup and configuration
+ * for CLI UX improvements as specified in the design document.
+ */
+export {};