stone-lang 0.1.0

package/cli/ReplSession.js

@@ -0,0 +1,567 @@
+/**
+ * Stone REPL Session
+ *
+ * Interactive Read-Eval-Print Loop for Stone language.
+ * Maintains state between commands and supports meta-commands.
+ *
+ * Usage:
+ *   $ stone
+ *   Stone v1.0.0
+ *   Type "help" for commands, "exit" to quit.
+ *
+ *   stone> print("hello")
+ *   hello
+ *   stone> x = 5
+ *   stone> x * 2
+ *   10
+ */
+
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import { StoneEngine } from '../StoneEngine.js';
+import { CLIOutputAdapter } from './CLIOutputAdapter.js';
+import { ReplVM } from '../backends/js-vm/vm/index.js';
+import { Lexer } from '../frontend/parsing/tokenizer.js';
+import { Parser } from '../frontend/parsing/astBuilder.js';
+import { Compiler } from '../backends/js-vm/compiler.js';
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+const c = (color, text) => `${colors[color]}${text}${colors.reset}`;
+
+/**
+ * Stone REPL Session
+ */
+export class ReplSession {
+  constructor(options = {}) {
+    this.options = options;
+    this.version = options.version || '1.0.0';
+    this.prompt = options.prompt || 'stone> ';
+    this.continuationPrompt = options.continuationPrompt || '  ... ';
+
+    // Multiline input state
+    this.history = [];
+    this.multilineBuffer = '';
+    this.bracketDepth = 0;
+    this.parenDepth = 0;
+
+    // Working directory for file operations
+    this.cwd = process.cwd();
+
+    // Create output adapter
+    this.adapter = new CLIOutputAdapter({
+      colorize: true,
+      quiet: false,
+    });
+
+    // Create ReplVM for persistent state execution
+    this.replVM = new ReplVM({
+      outputAdapter: this.adapter,
+    });
+
+    // Create engine for file operations (run command)
+    this.engine = new StoneEngine({
+      outputAdapter: this.adapter,
+    });
+
+    // Readline interface
+    this.rl = null;
+    this.running = false;
+  }
+
+  /**
+   * Start the REPL session
+   */
+  async start() {
+    this.running = true;
+
+    // Print banner
+    this.printBanner();
+
+    // Create readline interface
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: this.prompt,
+      historySize: 1000,
+    });
+
+    // Handle line input
+    this.rl.on('line', async (line) => {
+      await this.handleLine(line);
+      if (this.running) {
+        this.rl.prompt();
+      }
+    });
+
+    // Handle close (Ctrl+D)
+    this.rl.on('close', () => {
+      this.exit();
+    });
+
+    // Handle SIGINT (Ctrl+C)
+    this.rl.on('SIGINT', () => {
+      if (this.multilineBuffer) {
+        // Cancel multiline input
+        this.multilineBuffer = '';
+        this.bracketDepth = 0;
+        this.parenDepth = 0;
+        console.log('\n' + c('dim', '(input cancelled)'));
+        this.rl.setPrompt(this.prompt);
+        this.rl.prompt();
+      } else {
+        console.log('\n' + c('dim', 'Use "exit" or Ctrl+D to quit'));
+        this.rl.prompt();
+      }
+    });
+
+    // Start prompting
+    this.rl.prompt();
+  }
+
+  /**
+   * Print welcome banner
+   */
+  printBanner() {
+    console.log('');
+    console.log(c('bold', `Stone v${this.version}`));
+    console.log(c('dim', 'Type "help" for commands, "exit" to quit.'));
+    console.log('');
+  }
+
+  /**
+   * Handle a line of input
+   */
+  async handleLine(line) {
+    const trimmed = line.trim();
+
+    // Handle empty input
+    if (!trimmed && !this.multilineBuffer) {
+      return;
+    }
+
+    // Check for meta-commands (only if not in multiline mode)
+    if (!this.multilineBuffer && trimmed.startsWith(':')) {
+      await this.handleMetaCommand(trimmed.slice(1));
+      return;
+    }
+
+    // Check for simple commands without colon prefix
+    if (!this.multilineBuffer) {
+      const firstWord = trimmed.split(/\s+/)[0].toLowerCase();
+      if (['help', 'exit', 'quit', 'clear', 'reset', 'vars', 'pwd', 'cd'].includes(firstWord)) {
+        await this.handleMetaCommand(trimmed);
+        return;
+      }
+      // Handle 'run' command
+      if (firstWord === 'run') {
+        await this.handleMetaCommand(trimmed);
+        return;
+      }
+    }
+
+    // Accumulate multiline input
+    this.multilineBuffer += (this.multilineBuffer ? '\n' : '') + line;
+
+    // Update bracket tracking
+    this.updateBracketDepth(line);
+
+    // Check if input is complete
+    if (this.isInputComplete()) {
+      const code = this.multilineBuffer;
+      this.multilineBuffer = '';
+      this.bracketDepth = 0;
+      this.parenDepth = 0;
+      this.rl.setPrompt(this.prompt);
+
+      await this.executeCode(code);
+    } else {
+      // Continue multiline input
+      this.rl.setPrompt(this.continuationPrompt);
+    }
+  }
+
+  /**
+   * Update bracket depth tracking
+   */
+  updateBracketDepth(line) {
+    // Simple bracket counting (doesn't handle strings/comments perfectly)
+    for (const char of line) {
+      if (char === '{' || char === '[') this.bracketDepth++;
+      if (char === '}' || char === ']') this.bracketDepth--;
+      if (char === '(') this.parenDepth++;
+      if (char === ')') this.parenDepth--;
+    }
+  }
+
+  /**
+   * Check if multiline input is complete
+   */
+  isInputComplete() {
+    // If brackets are balanced, input is complete
+    return this.bracketDepth <= 0 && this.parenDepth <= 0;
+  }
+
+  /**
+   * Handle meta-commands
+   */
+  async handleMetaCommand(cmd) {
+    const parts = cmd.trim().split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+
+    switch (command) {
+      case 'help':
+      case 'h':
+      case '?':
+        this.printHelp();
+        break;
+
+      case 'exit':
+      case 'quit':
+      case 'q':
+        this.exit();
+        break;
+
+      case 'clear':
+      case 'cls':
+        console.clear();
+        break;
+
+      case 'reset':
+        this.replVM.reset();
+        console.log(c('dim', 'State cleared'));
+        break;
+
+      case 'vars':
+      case 'variables':
+        this.printVariables();
+        break;
+
+      case 'run':
+      case 'r':
+        if (args.length === 0) {
+          console.log(c('red', 'Usage: run <filename.stn>'));
+        } else {
+          await this.runFile(args[0]);
+        }
+        break;
+
+      case 'load':
+      case 'l':
+        if (args.length === 0) {
+          console.log(c('red', 'Usage: load <filename.stn>'));
+        } else {
+          await this.loadFile(args[0]);
+        }
+        break;
+
+      case 'pwd':
+        console.log(this.cwd);
+        break;
+
+      case 'cd':
+        if (args.length === 0) {
+          this.cwd = process.cwd();
+        } else {
+          const newPath = path.resolve(this.cwd, args[0]);
+          if (fs.existsSync(newPath) && fs.statSync(newPath).isDirectory()) {
+            this.cwd = newPath;
+          } else {
+            console.log(c('red', `Directory not found: ${args[0]}`));
+          }
+        }
+        break;
+
+      case 'ls':
+      case 'dir':
+        try {
+          const files = fs.readdirSync(this.cwd);
+          const stoneFiles = files.filter(f => f.endsWith('.stn'));
+          const otherFiles = files.filter(f => !f.endsWith('.stn'));
+
+          if (stoneFiles.length > 0) {
+            console.log(c('cyan', 'Stone files:'));
+            stoneFiles.forEach(f => console.log('  ' + c('green', f)));
+          }
+          if (otherFiles.length > 0) {
+            console.log(c('dim', 'Other:'));
+            otherFiles.slice(0, 10).forEach(f => console.log('  ' + f));
+            if (otherFiles.length > 10) {
+              console.log(c('dim', `  ... and ${otherFiles.length - 10} more`));
+            }
+          }
+        } catch (e) {
+          console.log(c('red', `Error: ${e.message}`));
+        }
+        break;
+
+      default:
+        console.log(c('red', `Unknown command: ${command}`));
+        console.log(c('dim', 'Type "help" for available commands'));
+    }
+  }
+
+  /**
+   * Execute Stone code using ReplVM with incremental compilation
+   */
+  async executeCode(code) {
+    try {
+      // 1. Parse the code
+      const lexer = new Lexer(code, '<repl>');
+      const tokens = lexer.tokenize();
+      const parser = new Parser(tokens, '<repl>');
+      const ast = parser.parse();
+
+      // 2. Compile with incremental compilation (preserving existing state)
+      const compiler = new Compiler({
+        existingLocals: this.replVM.getExistingLocals(),
+        existingFunctions: this.replVM.getExistingFunctions(),
+      });
+      const compiled = compiler.compile(ast);
+
+      if (!compiled.success) {
+        const errorMsg = compiled.errors.map(e => e.message).join('\n');
+        console.log(c('red', `Compile error: ${errorMsg}`));
+        return;
+      }
+
+      // 3. Execute with ReplVM (maintains state between commands)
+      const result = this.replVM.executeCommand(compiled);
+
+      if (result.success) {
+        // Print result if it's an expression (not assignment/statement)
+        if (result.result !== undefined && result.result !== null) {
+          // Don't print if it was just printed by the script
+          const isPrintStatement = code.trim().startsWith('print(');
+          if (!isPrintStatement) {
+            this.printValue(result.result);
+          }
+        }
+      } else {
+        console.log(c('red', `Error: ${result.error}`));
+      }
+    } catch (error) {
+      console.log(c('red', `Error: ${error.message}`));
+    }
+  }
+
+  /**
+   * Print a value with formatting
+   */
+  printValue(value) {
+    if (value === undefined || value === null) {
+      return;
+    }
+
+    if (typeof value === 'number') {
+      console.log(c('yellow', String(value)));
+    } else if (typeof value === 'string') {
+      console.log(c('green', `"${value}"`));
+    } else if (typeof value === 'boolean') {
+      console.log(c('magenta', String(value)));
+    } else if (Array.isArray(value)) {
+      console.log(c('cyan', JSON.stringify(value)));
+    } else if (value && value._type === 'StoneArray') {
+      console.log(c('cyan', value.toString()));
+    } else if (typeof value === 'object') {
+      console.log(c('cyan', JSON.stringify(value, null, 2)));
+    } else {
+      console.log(String(value));
+    }
+  }
+
+  /**
+   * Run a Stone file
+   */
+  async runFile(filename) {
+    const fullPath = path.resolve(this.cwd, filename);
+
+    if (!fs.existsSync(fullPath)) {
+      console.log(c('red', `File not found: ${filename}`));
+      return;
+    }
+
+    try {
+      const source = fs.readFileSync(fullPath, 'utf8');
+      console.log(c('dim', `Running ${filename}...`));
+      console.log('');
+
+      // Get current REPL variables to pass to file execution
+      const currentVars = {};
+      for (const name of this.replVM.getVariableNames()) {
+        currentVars[name] = this.replVM.getVariable(name);
+      }
+
+      const result = await this.engine.execute(source, {
+        filename: fullPath,
+        currentPath: path.dirname(fullPath),
+        variables: currentVars,
+      });
+
+      if (result.success) {
+        console.log('');
+        console.log(c('green', `Completed in ${result.duration || 0}ms`));
+      } else {
+        console.log(c('red', `Execution failed: ${result.error}`));
+      }
+    } catch (error) {
+      console.log(c('red', `Error: ${error.message}`));
+    }
+  }
+
+  /**
+   * Load a file into the current context (execute and import variables)
+   */
+  async loadFile(filename) {
+    const fullPath = path.resolve(this.cwd, filename);
+
+    if (!fs.existsSync(fullPath)) {
+      console.log(c('red', `File not found: ${filename}`));
+      return;
+    }
+
+    try {
+      const source = fs.readFileSync(fullPath, 'utf8');
+      console.log(c('dim', `Loading ${filename}...`));
+
+      // Track variable count before loading
+      const varCountBefore = this.replVM.getVariableNames().length;
+
+      // Parse and compile with incremental compilation
+      const lexer = new Lexer(source, fullPath);
+      const tokens = lexer.tokenize();
+      const parser = new Parser(tokens, fullPath);
+      const ast = parser.parse();
+
+      const compiler = new Compiler({
+        existingLocals: this.replVM.getExistingLocals(),
+        existingFunctions: this.replVM.getExistingFunctions(),
+      });
+      const compiled = compiler.compile(ast);
+
+      if (!compiled.success) {
+        const errorMsg = compiled.errors.map(e => e.message).join('\n');
+        console.log(c('red', `Compile error: ${errorMsg}`));
+        return;
+      }
+
+      // Execute through ReplVM to load variables into current context
+      const result = this.replVM.executeCommand(compiled);
+
+      if (result.success) {
+        const varCountAfter = this.replVM.getVariableNames().length;
+        const newVarCount = varCountAfter - varCountBefore;
+        console.log(c('green', `Loaded ${newVarCount >= 0 ? newVarCount : varCountAfter} variable(s)`));
+      } else {
+        console.log(c('red', `Load failed: ${result.error}`));
+      }
+    } catch (error) {
+      console.log(c('red', `Error: ${error.message}`));
+    }
+  }
+
+  /**
+   * Print available variables
+   */
+  printVariables() {
+    const vars = this.replVM.getVariableNames();
+
+    if (vars.length === 0) {
+      console.log(c('dim', 'No variables defined'));
+      return;
+    }
+
+    console.log(c('bold', 'Variables:'));
+    for (const name of vars) {
+      const value = this.replVM.getVariable(name);
+      const type = typeof value;
+      const preview = this.getValuePreview(value);
+      console.log(`  ${c('cyan', name)}: ${c('dim', type)} = ${preview}`);
+    }
+  }
+
+  /**
+   * Get a short preview of a value
+   */
+  getValuePreview(value) {
+    if (value === undefined) return c('dim', 'undefined');
+    if (value === null) return c('dim', 'null');
+    if (typeof value === 'number') return c('yellow', String(value));
+    if (typeof value === 'string') {
+      if (value.length > 30) {
+        return c('green', `"${value.slice(0, 30)}..."`);
+      }
+      return c('green', `"${value}"`);
+    }
+    if (typeof value === 'boolean') return c('magenta', String(value));
+    if (typeof value === 'function') return c('blue', '[function]');
+    if (Array.isArray(value)) {
+      return c('cyan', `[${value.length} items]`);
+    }
+    if (value && value._type === 'StoneArray') {
+      return c('cyan', `StoneArray(${value.shape.join('x')})`);
+    }
+    if (typeof value === 'object') {
+      return c('cyan', `{${Object.keys(value).length} keys}`);
+    }
+    return String(value);
+  }
+
+  /**
+   * Print help
+   */
+  printHelp() {
+    console.log('');
+    console.log(c('bold', 'Stone REPL Commands:'));
+    console.log('');
+    console.log('  ' + c('cyan', 'help, ?') + '        Show this help');
+    console.log('  ' + c('cyan', 'exit, quit') + '    Exit the REPL');
+    console.log('  ' + c('cyan', 'clear') + '         Clear the screen');
+    console.log('  ' + c('cyan', 'reset') + '         Clear all variables');
+    console.log('  ' + c('cyan', 'vars') + '          Show defined variables');
+    console.log('');
+    console.log(c('bold', 'File Commands:'));
+    console.log('');
+    console.log('  ' + c('cyan', 'run <file>') + '    Execute a Stone script');
+    console.log('  ' + c('cyan', 'load <file>') + '   Load script into current context');
+    console.log('  ' + c('cyan', 'ls, dir') + '       List files in current directory');
+    console.log('  ' + c('cyan', 'cd <dir>') + '      Change directory');
+    console.log('  ' + c('cyan', 'pwd') + '           Print working directory');
+    console.log('');
+    console.log(c('bold', 'Keyboard:'));
+    console.log('');
+    console.log('  ' + c('cyan', 'Ctrl+C') + '        Cancel current input');
+    console.log('  ' + c('cyan', 'Ctrl+D') + '        Exit the REPL');
+    console.log('  ' + c('cyan', 'Up/Down') + '       Navigate history');
+    console.log('');
+  }
+
+  /**
+   * Exit the REPL
+   */
+  exit() {
+    if (!this.running) return; // Already exiting
+    this.running = false;
+    console.log('');
+    console.log(c('dim', 'Goodbye!'));
+    if (this.rl) {
+      this.rl.close();
+    }
+    process.exit(0);
+  }
+}
+
+export default ReplSession;