@syrin/cli 1.3.0

package/dist/runtime/dev/repl.js

@@ -0,0 +1,310 @@
+/**
+ * Interactive REPL (Read-Eval-Print Loop) for Dev Mode.
+ * Provides command-line interface with history, autocomplete, and navigation.
+ */
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { log } from '../../utils/logger.js';
+/**
+ * REPL special commands.
+ */
+export var REPLCommand;
+(function (REPLCommand) {
+    REPLCommand["EXIT"] = "/exit";
+    REPLCommand["QUIT"] = "/quit";
+    REPLCommand["CLEAR"] = "/clear";
+    REPLCommand["HELP"] = "/help";
+    REPLCommand["HISTORY"] = "/history";
+    REPLCommand["TOOLS"] = "/tools";
+})(REPLCommand || (REPLCommand = {}));
+/**
+ * Interactive REPL implementation.
+ */
+export class InteractiveREPL {
+    options;
+    eventEmitter;
+    rl;
+    history = [];
+    historyIndex = -1;
+    currentInput = '';
+    maxHistorySize;
+    constructor(options = {}, eventEmitter) {
+        this.options = options;
+        this.eventEmitter = eventEmitter;
+        this.maxHistorySize = options.maxHistorySize || 1000;
+        this.loadHistory();
+        // Create readline interface
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: options.prompt || 'User > ',
+            completer: this.completer.bind(this),
+        });
+        // Set up event handlers
+        this.setupEventHandlers();
+    }
+    /**
+     * Start the REPL.
+     * @param onInput - Callback for user input
+     * @param onClose - Callback for REPL close (can be async)
+     */
+    start(onInput, onClose) {
+        this.rl.prompt();
+        this.rl.on('line', (line) => {
+            void (async () => {
+                const trimmed = line.trim();
+                // Handle empty input
+                if (!trimmed) {
+                    this.rl.prompt();
+                    return;
+                }
+                // Handle special commands
+                if (trimmed.startsWith('/')) {
+                    await this.handleSpecialCommand(trimmed, onInput);
+                    this.rl.prompt();
+                    return;
+                }
+                // Add to history
+                this.addToHistory(trimmed);
+                this.historyIndex = -1;
+                this.currentInput = '';
+                // Process input
+                try {
+                    await onInput(trimmed);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    log.blank();
+                    log.error(`Error: ${errorMessage}`);
+                    log.blank();
+                }
+                this.rl.prompt();
+            })();
+        });
+        this.rl.on('close', () => {
+            this.saveHistory();
+            // Wait for cleanup before exiting
+            void (async () => {
+                if (onClose) {
+                    await onClose();
+                }
+                log.blank();
+                log.plain('Goodbye!');
+                process.exit(0);
+            })();
+        });
+        // Note: SIGINT handling is done by the parent (dev.ts)
+        // We don't handle it here to allow proper cleanup
+        // Load history into readline (for arrow key navigation)
+        this.loadHistoryIntoReadline();
+    }
+    /**
+     * Load history into readline for arrow key navigation.
+     */
+    loadHistoryIntoReadline() {
+        // readline automatically handles history with arrow keys
+        // We can add our history to it
+        if (this.rl && 'history' in this.rl) {
+            const rlHistory = this.rl.history;
+            rlHistory.push(...this.history);
+        }
+    }
+    /**
+     * Stop the REPL.
+     */
+    stop() {
+        this.saveHistory();
+        this.rl.close();
+    }
+    /**
+     * Set a new prompt.
+     */
+    setPrompt(prompt) {
+        this.rl.setPrompt(prompt);
+    }
+    /**
+     * Write output to the console.
+     */
+    write(message) {
+        process.stdout.write(message);
+    }
+    /**
+     * Write a line to the console.
+     */
+    writeLine(message) {
+        log.plain(message);
+    }
+    /**
+     * Clear the current line.
+     */
+    clearLine() {
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+    }
+    /**
+     * Get history.
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Clear history.
+     */
+    clearHistory() {
+        this.history = [];
+        this.historyIndex = -1;
+        if (this.options.saveHistory && this.options.historyFile) {
+            try {
+                fs.unlinkSync(this.options.historyFile);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    /**
+     * Setup event handlers for history navigation.
+     * Note: readline handles arrow keys automatically, but we can enhance it.
+     */
+    setupEventHandlers() {
+        // The readline interface handles arrow keys automatically
+        // We just need to track the current input for restoration
+        this.rl.on('line', () => {
+            this.currentInput = '';
+            this.historyIndex = -1;
+        });
+    }
+    /**
+     * Handle special REPL commands.
+     */
+    async handleSpecialCommand(command, onInput) {
+        const parts = command.split(/\s+/);
+        const cmd = parts[0]?.toLowerCase();
+        switch (cmd) {
+            case REPLCommand.EXIT:
+            case REPLCommand.QUIT:
+                this.stop();
+                break;
+            case REPLCommand.CLEAR:
+                // Clear console (ANSI escape code)
+                process.stdout.write('\x1B[2J\x1B[0f');
+                break;
+            case REPLCommand.HELP:
+                this.showHelp();
+                break;
+            case REPLCommand.HISTORY:
+                this.showHistory();
+                break;
+            case REPLCommand.TOOLS:
+                // This will be handled by the dev session
+                await onInput(command);
+                break;
+            default:
+                log.plain(`Unknown command: ${cmd}. Type /help for available commands.`);
+        }
+    }
+    /**
+     * Show help message.
+     */
+    showHelp() {
+        log.blank();
+        log.plain('Available commands:');
+        log.plain('  /exit, /quit  - Exit dev mode');
+        log.plain('  /clear        - Clear the console');
+        log.plain('  /help         - Show this help message');
+        log.plain('  /history      - Show command history');
+        log.plain('  /tools        - List available tools');
+        log.blank();
+        log.plain('Navigation:');
+        log.plain('  ↑/↓ Arrow keys - Navigate command history');
+        log.plain('  Ctrl+C        - Interrupt (use /exit to quit)');
+        log.blank();
+    }
+    /**
+     * Show command history.
+     */
+    showHistory() {
+        if (this.history.length === 0) {
+            log.plain('No history yet.');
+            return;
+        }
+        log.blank();
+        log.plain('Command History:');
+        const recentHistory = this.history.slice(-20); // Show last 20
+        recentHistory.forEach((cmd, index) => {
+            log.plain(`  ${index + 1}. ${cmd}`);
+        });
+        log.blank();
+    }
+    /**
+     * Add input to history.
+     */
+    addToHistory(input) {
+        // Don't add empty lines or duplicates of the last command
+        if (!input ||
+            (this.history.length > 0 &&
+                this.history[this.history.length - 1] === input)) {
+            return;
+        }
+        this.history.push(input);
+        // Limit history size
+        if (this.history.length > this.maxHistorySize) {
+            this.history.shift();
+        }
+    }
+    /**
+     * Load history from file.
+     */
+    loadHistory() {
+        if (!this.options.saveHistory || !this.options.historyFile) {
+            return;
+        }
+        try {
+            if (fs.existsSync(this.options.historyFile)) {
+                const content = fs.readFileSync(this.options.historyFile, 'utf-8');
+                this.history = content
+                    .split('\n')
+                    .filter(line => line.trim())
+                    .slice(-this.maxHistorySize); // Only keep last N entries
+            }
+        }
+        catch {
+            // Ignore errors loading history
+        }
+    }
+    /**
+     * Save history to file.
+     */
+    saveHistory() {
+        if (!this.options.saveHistory || !this.options.historyFile) {
+            return;
+        }
+        try {
+            const dir = path.dirname(this.options.historyFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.options.historyFile, this.history.join('\n') + '\n', 'utf-8');
+        }
+        catch {
+            // Ignore errors saving history
+        }
+    }
+    /**
+     * Completer function for tab completion.
+     */
+    completer(line) {
+        const completions = [
+            '/exit',
+            '/quit',
+            '/clear',
+            '/help',
+            '/history',
+            '/tools',
+        ];
+        const hits = completions.filter(c => c.startsWith(line));
+        return [hits.length ? hits : completions, line];
+    }
+}
+//# sourceMappingURL=repl.js.map

package/dist/runtime/dev/session.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Dev Mode Session.
+ * Orchestrates LLM-MCP interactions with event emission.
+ */
+import type { DevSessionConfig, DevSessionState, ToolCallInfo } from './types.js';
+import type { ToolDefinition } from '../../runtime/llm/types.js';
+import { DataManager } from './data-manager.js';
+/**
+ * Dev Mode Session implementation.
+ */
+export declare class DevSession {
+    private readonly config;
+    private state;
+    private availableTools;
+    private currentPromptId;
+    private dataManager;
+    private readonly MAX_HISTORY_LENGTH;
+    private readonly MAX_MESSAGE_SIZE;
+    constructor(config: DevSessionConfig);
+    /**
+     * Initialize the session.
+     * Loads available tools and emits session started event.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add user message to conversation history without processing.
+     * Useful for special commands that don't need LLM processing.
+     */
+    addUserMessageToHistory(userInput: string): void;
+    /**
+     * Process user input.
+     * This is the main entry point for handling user messages.
+     */
+    processUserInput(userInput: string): Promise<void>;
+    /**
+     * Process the conversation.
+     * Handles LLM calls and tool execution in a loop until final response.
+     */
+    private processConversation;
+    /**
+     * Build LLM context from conversation history and available tools.
+     * Truncates history to prevent context from growing too large.
+     */
+    private buildLLMContext;
+    /**
+     * Process tool calls from LLM.
+     */
+    private processToolCalls;
+    /**
+     * Validate a tool call.
+     */
+    private validateToolCall;
+    /**
+     * Build prompt after tool execution.
+     */
+    private buildPostToolPrompt;
+    /**
+     * Get session state.
+     */
+    getState(): DevSessionState;
+    /**
+     * Get available tools.
+     */
+    getAvailableTools(): ToolDefinition[];
+    /**
+     * Complete the session.
+     */
+    complete(): Promise<void>;
+    /**
+     * Halt the session due to error.
+     */
+    halt(reason: string, errorCode?: string): Promise<void>;
+    /**
+     * Clear conversation history.
+     */
+    clearHistory(): void;
+    /**
+     * Get tool result (loads from file if large data was externalized).
+     */
+    getToolResult(toolCallInfo: ToolCallInfo): unknown;
+    /**
+     * Get the data manager instance.
+     */
+    getDataManager(): DataManager;
+}
+//# sourceMappingURL=session.d.ts.map