@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/tools/DeveloperExperience.ts

@@ -0,0 +1,438 @@
+/**
+ * @holoscript/core Developer Experience
+ *
+ * REPL, better error formatting, interactive mode
+ */
+
+import * as readline from 'readline';
+
+/**
+ * Enhanced error formatter
+ */
+export class ErrorFormatter {
+  /**
+   * Format error with source context
+   */
+  static formatError(error: any, sourceCode?: string): string {
+    const { message, location, suggestion, token } = error;
+
+    let formatted = `\n❌ Error: ${message}\n`;
+
+    if (location) {
+      formatted += `   at line ${location.line}, column ${location.column}\n`;
+
+      if (sourceCode) {
+        const lines = sourceCode.split('\n');
+        const errorLine = lines[location.line - 1];
+
+        if (errorLine) {
+          formatted += `\n   ${location.line} | ${errorLine}\n`;
+          formatted += `     | ${' '.repeat(location.column - 1)}^\n`;
+        }
+      }
+    }
+
+    if (suggestion) {
+      formatted += `\n💡 Suggestion: ${suggestion}\n`;
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Format multiple errors
+   */
+  static formatErrors(errors: any[]): string {
+    if (errors.length === 0) return '';
+
+    let formatted = `\n❌ Found ${errors.length} error${errors.length !== 1 ? 's' : ''}:\n`;
+
+    for (let i = 0; i < Math.min(errors.length, 5); i++) {
+      formatted += this.formatError(errors[i]);
+    }
+
+    if (errors.length > 5) {
+      formatted += `\n... and ${errors.length - 5} more error${errors.length - 5 !== 1 ? 's' : ''}\n`;
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Format success message
+   */
+  static formatSuccess(message: string, details?: any): string {
+    let formatted = `\n✅ ${message}\n`;
+
+    if (details) {
+      if (typeof details === 'object') {
+        formatted += JSON.stringify(details, null, 2) + '\n';
+      } else {
+        formatted += `${details}\n`;
+      }
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Format help text
+   */
+  static formatHelp(): string {
+    return `
+HoloScript+ REPL v1.0.0
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Commands:
+  help          - Show this help message
+  clear         - Clear the screen
+  vars          - List all variables
+  types         - List all types
+  profile       - Show performance profile
+  exit          - Exit REPL
+
+Shortcuts:
+  .create orb#name    - Create orb
+  .position x y z     - Set position
+  .property key val   - Set property
+
+Examples:
+  > orb#myOrb { position: [0, 0, 0] }
+  > myOrb.position = [1, 1, 1]
+  > match state { "idle" => { ... } }
+
+For more info, visit: https://github.com/brianonbased-dev/holoscript
+`.trim();
+  }
+}
+
+/**
+ * Interactive REPL
+ */
+export class HoloScriptREPL {
+  private rl: readline.Interface;
+  private variables: Map<string, any> = new Map();
+  private types: Map<string, any> = new Map();
+  private history: string[] = [];
+  private parser: any;
+  private runtime: any;
+
+  constructor(parser: any, runtime: any) {
+    this.parser = parser;
+    this.runtime = runtime;
+
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      history: this.history,
+      historySize: 100,
+    });
+  }
+
+  /**
+   * Start REPL
+   */
+  async start(): Promise<void> {
+    console.log('\n🥽 HoloScript+ REPL v1.0.0');
+    console.log('Type "help" for commands, "exit" to quit\n');
+
+    await this.repl();
+  }
+
+  /**
+   * Main REPL loop
+   */
+  private async repl(): Promise<void> {
+    const prompt = () => {
+      this.rl.question('> ', async (input) => {
+        try {
+          const trimmed = input.trim();
+
+          if (!trimmed) {
+            prompt();
+            return;
+          }
+
+          // Handle commands
+          if (trimmed.startsWith('.')) {
+            this.handleCommand(trimmed);
+            prompt();
+            return;
+          }
+
+          // Handle built-in commands
+          switch (trimmed.toLowerCase()) {
+            case 'help':
+              console.log(ErrorFormatter.formatHelp());
+              prompt();
+              return;
+
+            case 'clear':
+              console.clear();
+              prompt();
+              return;
+
+            case 'vars':
+              this.showVariables();
+              prompt();
+              return;
+
+            case 'types':
+              this.showTypes();
+              prompt();
+              return;
+
+            case 'profile':
+              this.showProfile();
+              prompt();
+              return;
+
+            case 'exit':
+              this.rl.close();
+              console.log('\n👋 Goodbye!\n');
+              return;
+          }
+
+          // Parse and execute
+          const result = await this.evaluate(trimmed);
+
+          if (result !== undefined && result !== null) {
+            this.displayResult(result);
+          }
+        } catch (error: any) {
+          console.error(ErrorFormatter.formatError(error));
+        }
+
+        prompt();
+      });
+    };
+
+    prompt();
+  }
+
+  /**
+   * Handle dot commands
+   */
+  private handleCommand(command: string): void {
+    const parts = command.slice(1).split(' ');
+    const cmd = parts[0];
+
+    switch (cmd) {
+      case 'create':
+        console.log(`Creating: ${parts.slice(1).join(' ')}`);
+        break;
+
+      case 'position':
+        console.log(`Position: x=${parts[1]}, y=${parts[2]}, z=${parts[3]}`);
+        break;
+
+      case 'property':
+        console.log(`Property: ${parts[1]} = ${parts[2]}`);
+        break;
+
+      default:
+        console.log(`Unknown command: .${cmd}`);
+    }
+  }
+
+  /**
+   * Evaluate HoloScript code
+   */
+  private async evaluate(code: string): Promise<any> {
+    try {
+      const parseResult = this.parser.parse(code);
+
+      if (parseResult.errors && parseResult.errors.length > 0) {
+        throw {
+          message: 'Parse error',
+          errors: parseResult.errors,
+        };
+      }
+
+      const result = await this.runtime.execute(parseResult.ast);
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Show variables
+   */
+  private showVariables(): void {
+    if (this.variables.size === 0) {
+      console.log('No variables defined');
+      return;
+    }
+
+    console.log('\n📦 Variables:');
+    for (const [name, value] of this.variables) {
+      console.log(`  ${name}: ${this.formatValue(value)}`);
+    }
+    console.log();
+  }
+
+  /**
+   * Show types
+   */
+  private showTypes(): void {
+    if (this.types.size === 0) {
+      console.log('No custom types defined');
+      return;
+    }
+
+    console.log('\n🏷️  Types:');
+    for (const [name, type] of this.types) {
+      console.log(`  ${name}: ${JSON.stringify(type)}`);
+    }
+    console.log();
+  }
+
+  /**
+   * Show performance profile
+   */
+  private showProfile(): void {
+    console.log('\n⏱️  Performance Profile:');
+    console.log('  (Profiling data would be displayed here)');
+    console.log();
+  }
+
+  /**
+   * Display result
+   */
+  private displayResult(result: any): void {
+    const formatted = this.formatValue(result);
+    console.log(`=> ${formatted}`);
+  }
+
+  /**
+   * Format value for display
+   */
+  private formatValue(value: any): string {
+    if (value === null) return 'null';
+    if (value === undefined) return 'undefined';
+    if (typeof value === 'string') return `"${value}"`;
+    if (typeof value === 'number') return `${value}`;
+    if (typeof value === 'boolean') return `${value}`;
+    if (Array.isArray(value)) {
+      return `[ ${value.map((v) => this.formatValue(v)).join(', ')} ]`;
+    }
+    if (typeof value === 'object') {
+      const pairs = Object.entries(value)
+        .map(([k, v]) => `${k}: ${this.formatValue(v)}`)
+        .join(', ');
+      return `{ ${pairs} }`;
+    }
+    return String(value);
+  }
+}
+
+/**
+ * Create and start REPL
+ */
+export async function startREPL(parser: any, runtime: any): Promise<void> {
+  const repl = new HoloScriptREPL(parser, runtime);
+  await repl.start();
+}
+
+/**
+ * Hot reload watcher for development
+ */
+export class HotReloadWatcher {
+  private watchers: Map<string, any> = new Map();
+
+  /**
+   * Watch file for changes
+   */
+  watch(filePath: string, callback: () => Promise<void>): void {
+    // Using basic fs.watch (production would use chokidar)
+    const fs = require('fs');
+
+    fs.watchFile(filePath, { interval: 1000 }, async () => {
+      try {
+        console.log(`\n🔄 Reloading: ${filePath}`);
+        await callback();
+        console.log('✅ Reload complete\n');
+      } catch (error: any) {
+        console.error(ErrorFormatter.formatError(error));
+      }
+    });
+
+    this.watchers.set(filePath, true);
+  }
+
+  /**
+   * Stop watching
+   */
+  unwatch(filePath: string): void {
+    const fs = require('fs');
+    fs.unwatchFile(filePath);
+    this.watchers.delete(filePath);
+  }
+
+  /**
+   * Stop all watchers
+   */
+  clear(): void {
+    const fs = require('fs');
+    for (const filePath of this.watchers.keys()) {
+      fs.unwatchFile(filePath);
+    }
+    this.watchers.clear();
+  }
+}
+
+/**
+ * Source map generator
+ */
+export class SourceMapGenerator {
+  private mappings: Array<{
+    generatedLine: number;
+    generatedColumn: number;
+    sourceLine: number;
+    sourceColumn: number;
+    name?: string;
+  }> = [];
+
+  /**
+   * Add mapping
+   */
+  addMapping(
+    generatedLine: number,
+    generatedColumn: number,
+    sourceLine: number,
+    sourceColumn: number,
+    name?: string
+  ): void {
+    this.mappings.push({
+      generatedLine,
+      generatedColumn,
+      sourceLine,
+      sourceColumn,
+      name,
+    });
+  }
+
+  /**
+   * Generate source map
+   */
+  generate(sourceFile: string, generatedFile: string): any {
+    return {
+      version: 3,
+      file: generatedFile,
+      sourceRoot: '',
+      sources: [sourceFile],
+      sourcesContent: [],
+      mappings: this.encodeMappings(),
+      names: [],
+    };
+  }
+
+  /**
+   * Encode mappings in VLQ format
+   */
+  private encodeMappings(): string {
+    // Simplified VLQ encoding
+    return this.mappings.map((m) => `${m.generatedLine}:${m.generatedColumn}->${m.sourceLine}:${m.sourceColumn}`).join(';');
+  }
+}