rip-lang 2.5.1 → 2.7.1

package/src/repl.js

@@ -1,5 +1,5 @@
 /**
- * Rip REPL - Interactive Read-Eval-Print Loop
+ * Rip REPL - Interactive Read-Eval-Print Loop (Bun-native version)
  *
  * Features:
  * - Multi-line input detection
@@ -7,14 +7,15 @@
  * - Special commands (.help, .clear, .vars, etc.)
  * - Colored output
  * - Persistent context
+ * - Full dynamic import() support (Bun-native)
  */
 
 import * as readline from 'readline';
 import { inspect } from 'util';
-import * as vm from 'vm';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { pathToFileURL } from 'url';
 import { Compiler } from './compiler.js';
 import packageJson from '../package.json' with { type: 'json' };
 
@@ -34,6 +35,13 @@ const colors = {
   gray: '\x1b[90m'
 };
 
+// Use globalThis for persistent context (works across async evaluations)
+globalThis.__ripRepl = globalThis.__ripRepl || {
+  vars: {},
+  tempCounter: 0,
+  cwd: process.cwd()
+};
+
 export class RipREPL {
   constructor() {
     this.buffer = '';   // Multi-line input buffer
@@ -41,19 +49,7 @@ export class RipREPL {
     this.historyFile = path.join(os.homedir(), '.rip_history');
     this.reactiveVars = new Set();  // Track reactive variables across lines
 
-    // Create persistent VM context (like a sandboxed global scope)
-    this.context = vm.createContext({
-      console,
-      process,
-      Buffer,
-      setTimeout,
-      setInterval,
-      clearTimeout,
-      clearInterval,
-      // Add any other globals you want available
-    });
-
-    // Inject reactive runtime once into context (so all reactive code shares same tracking)
+    // Inject reactive runtime into global context
     this.injectReactiveRuntime();
 
     this.rl = readline.createInterface({
@@ -68,6 +64,14 @@ export class RipREPL {
     this.loadHistory();
   }
 
+  get context() {
+    return globalThis.__ripRepl.vars;
+  }
+
+  set context(val) {
+    globalThis.__ripRepl.vars = val;
+  }
+
   getPrompt() {
     if (this.buffer) {
       return `${colors.dim}....>${colors.reset} `;  // Continuation prompt
@@ -78,11 +82,12 @@ export class RipREPL {
   start() {
     this.printWelcome();
 
-    this.rl.on('line', (line) => {
-      this.handleLine(line);
+    this.rl.on('line', async (line) => {
+      await this.handleLine(line);
     });
 
     this.rl.on('close', () => {
+      this.cleanup();
       this.saveHistory();
       console.log(`\n${colors.gray}Goodbye!${colors.reset}`);
       process.exit(0);
@@ -92,89 +97,95 @@ export class RipREPL {
   }
 
   printWelcome() {
-    console.log(`${colors.bright}Rip ${VERSION}${colors.reset} - Interactive REPL`);
+    console.log(`${colors.bright}Rip ${VERSION}${colors.reset} - Interactive REPL ${colors.dim}(Bun-native)${colors.reset}`);
     console.log(`${colors.gray}Type ${colors.cyan}.help${colors.gray} for commands, ${colors.cyan}Ctrl+C${colors.gray} to exit${colors.reset}\n`);
   }
 
   injectReactiveRuntime() {
-    // Inject reactive runtime into REPL context once
-    // This ensures all reactive code shares the same __currentEffect, etc.
-    const runtimeCode = `
-let __currentEffect = null, __pendingEffects = new Set();
-function __signal(v) {
-  const subs = new Set();
-  let notifying = false, locked = false, dead = false;
-  const s = {
-    get value() { if (dead) return v; if (__currentEffect) { subs.add(__currentEffect); __currentEffect.dependencies.add(subs); } return v; },
-    set value(n) {
-      if (dead || locked || n === v || notifying) return;
-      v = n;
-      notifying = true;
-      for (const sub of subs) if (sub.markDirty) sub.markDirty();
-      for (const sub of subs) if (!sub.markDirty) __pendingEffects.add(sub);
-      const fx = [...__pendingEffects]; __pendingEffects.clear();
-      for (const e of fx) e.run();
-      notifying = false;
-    },
-    read() { return v; },
-    lock() { locked = true; return s; },
-    free() { subs.clear(); return s; },
-    kill() { dead = true; subs.clear(); return v; },
-    valueOf() { return this.value; },
-    toString() { return String(this.value); },
-    [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
-  };
-  return s;
-}
-function __computed(fn) {
-  let v, dirty = true, locked = false, dead = false;
-  const subs = new Set();
-  const c = {
-    dependencies: new Set(),
-    markDirty() {
-      if (dead || locked || !dirty) { if (!dead && !locked && !dirty) { dirty = true; for (const s of subs) if (s.markDirty) s.markDirty(); for (const s of subs) if (!s.markDirty) __pendingEffects.add(s); } }
-    },
-    get value() {
-      if (dead) return v;
-      if (__currentEffect) { subs.add(__currentEffect); __currentEffect.dependencies.add(subs); }
-      if (dirty && !locked) {
-        for (const d of c.dependencies) d.delete(c); c.dependencies.clear();
-        const prev = __currentEffect; __currentEffect = c;
-        try { v = fn(); } finally { __currentEffect = prev; }
-        dirty = false;
-      }
-      return v;
-    },
-    read() { return dead ? v : c.value; },
-    lock() { locked = true; c.value; return c; },
-    free() { for (const d of c.dependencies) d.delete(c); c.dependencies.clear(); subs.clear(); return c; },
-    kill() { dead = true; const result = v; c.free(); return result; },
-    valueOf() { return this.value; },
-    toString() { return String(this.value); },
-    [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
-  };
-  return c;
-}
-function __effect(fn) {
-  const e = {
-    dependencies: new Set(),
-    run() {
-      for (const d of e.dependencies) d.delete(e); e.dependencies.clear();
-      const prev = __currentEffect; __currentEffect = e;
-      try { fn(); } finally { __currentEffect = prev; }
-    },
-    free() { for (const d of e.dependencies) d.delete(e); e.dependencies.clear(); }
-  };
-  e.run();
-  return () => e.free();
-}
-function __batch(fn) { fn(); }
-function __readonly(v) { return Object.freeze({ value: v }); }
-`;
-    vm.runInContext(runtimeCode, this.context);
+    // Inject reactive runtime into global context once
+    if (globalThis.__ripRepl.runtimeInjected) return;
+
+    // Define reactive primitives on globalThis so they're available in all evaluations
+    globalThis.__currentEffect = null;
+    globalThis.__pendingEffects = new Set();
+
+    globalThis.__state = function(v) {
+      const subs = new Set();
+      let notifying = false, locked = false, dead = false;
+      const s = {
+        get value() { if (dead) return v; if (__currentEffect) { subs.add(__currentEffect); __currentEffect.dependencies.add(subs); } return v; },
+        set value(n) {
+          if (dead || locked || n === v || notifying) return;
+          v = n;
+          notifying = true;
+          for (const sub of subs) if (sub.markDirty) sub.markDirty();
+          for (const sub of subs) if (!sub.markDirty) __pendingEffects.add(sub);
+          const fx = [...__pendingEffects]; __pendingEffects.clear();
+          for (const e of fx) e.run();
+          notifying = false;
+        },
+        read() { return v; },
+        lock() { locked = true; return s; },
+        free() { subs.clear(); return s; },
+        kill() { dead = true; subs.clear(); return v; },
+        valueOf() { return this.value; },
+        toString() { return String(this.value); },
+        [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
+      };
+      return s;
+    };
+
+    globalThis.__computed = function(fn) {
+      let v, dirty = true, locked = false, dead = false;
+      const subs = new Set();
+      const c = {
+        dependencies: new Set(),
+        markDirty() {
+          if (dead || locked || !dirty) { if (!dead && !locked && !dirty) { dirty = true; for (const s of subs) if (s.markDirty) s.markDirty(); for (const s of subs) if (!s.markDirty) __pendingEffects.add(s); } }
+        },
+        get value() {
+          if (dead) return v;
+          if (__currentEffect) { subs.add(__currentEffect); __currentEffect.dependencies.add(subs); }
+          if (dirty && !locked) {
+            for (const d of c.dependencies) d.delete(c); c.dependencies.clear();
+            const prev = __currentEffect; __currentEffect = c;
+            try { v = fn(); } finally { __currentEffect = prev; }
+            dirty = false;
+          }
+          return v;
+        },
+        read() { return dead ? v : c.value; },
+        lock() { locked = true; c.value; return c; },
+        free() { for (const d of c.dependencies) d.delete(c); c.dependencies.clear(); subs.clear(); return c; },
+        kill() { dead = true; const result = v; c.free(); return result; },
+        valueOf() { return this.value; },
+        toString() { return String(this.value); },
+        [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
+      };
+      return c;
+    };
+
+    globalThis.__effect = function(fn) {
+      const e = {
+        dependencies: new Set(),
+        run() {
+          for (const d of e.dependencies) d.delete(e); e.dependencies.clear();
+          const prev = __currentEffect; __currentEffect = e;
+          try { fn(); } finally { __currentEffect = prev; }
+        },
+        free() { for (const d of e.dependencies) d.delete(e); e.dependencies.clear(); }
+      };
+      e.run();
+      return () => e.free();
+    };
+
+    globalThis.__batch = function(fn) { fn(); };
+    globalThis.__readonly = function(v) { return Object.freeze({ value: v }); };
+
+    globalThis.__ripRepl.runtimeInjected = true;
   }
 
-  handleLine(line) {
+  async handleLine(line) {
     // Handle special commands
     if (line.startsWith('.')) {
       this.handleCommand(line);
@@ -192,7 +203,7 @@ function __readonly(v) { return Object.freeze({ value: v }); }
 
     // Check if input is complete
     if (this.isComplete(this.buffer)) {
-      this.evaluate(this.buffer);
+      await this.evaluate(this.buffer);
       this.buffer = '';
     }
 
@@ -289,14 +300,12 @@ function __readonly(v) { return Object.freeze({ value: v }); }
     return true;
   }
 
-  evaluate(code) {
+  async evaluate(code) {
     try {
       // Add to history
       this.history.push(code);
 
-      // Compile Rip to JavaScript with debug options
-      // skipReactiveRuntime: runtime is already injected into context
-      // reactiveVars: track reactive variables across REPL lines
+      // Compile Rip to JavaScript
       const compiler = new Compiler({
         showTokens: this.showTokens,
         showSExpr: this.showSExp,
@@ -312,7 +321,7 @@ function __readonly(v) { return Object.freeze({ value: v }); }
         }
       }
 
-      const js = result.code;
+      let js = result.code;
 
       // Show compiled JS if enabled
       if (this.showJS) {
@@ -320,18 +329,8 @@ function __readonly(v) { return Object.freeze({ value: v }); }
         console.log(`${colors.dim}${js}${colors.reset}\n`);
       }
 
-      // Convert let/const to var for REPL persistence in vm context
-      // In vm.runInContext, var declarations persist while let/const are scoped
-      let processedJs = js;
-
-      // Replace 'let x, y, z;' with 'var x, y, z;'
-      processedJs = processedJs.replace(/^let\s+/m, 'var ');
-
-      // Replace 'const x =' with 'var x ='
-      processedJs = processedJs.replace(/^const\s+/gm, 'var ');
-
-      // Evaluate in persistent context
-      const evalResult = vm.runInContext(processedJs, this.context);
+      // Execute using Bun's native async evaluation with import support
+      const evalResult = await this.bunEval(js);
 
       // Store result in _ for convenience
       if (evalResult !== undefined) {
@@ -343,6 +342,92 @@ function __readonly(v) { return Object.freeze({ value: v }); }
     }
   }
 
+  async bunEval(js) {
+    // Extract variable declarations from the compiled JS
+    const varMatches = [...js.matchAll(/^let\s+(\w+)(?:,\s*(\w+))*;$/gm)];
+    const declaredVars = new Set();
+    for (const match of varMatches) {
+      for (let i = 1; i < match.length; i++) {
+        if (match[i]) declaredVars.add(match[i]);
+      }
+    }
+
+    // Also check for let x = ... pattern
+    const assignMatches = [...js.matchAll(/^let\s+(\w+)\s*=/gm)];
+    for (const match of assignMatches) {
+      declaredVars.add(match[1]);
+    }
+
+    // Build code that restores context
+    const ctx = this.context;
+    const existingVars = Object.keys(ctx);
+
+    // Remove let declarations for vars we're restoring from context
+    let cleanJs = js;
+    for (const v of existingVars) {
+      cleanJs = cleanJs.replace(new RegExp(`^let ${v};\\n`, 'm'), '');
+      cleanJs = cleanJs.replace(new RegExp(`^let ${v}(\\s*=)`, 'm'), `${v}$1`);
+    }
+
+    // Restore existing variables
+    const restoreCtx = existingVars
+      .filter(k => k !== '_')
+      .map(k => `let ${k} = globalThis.__ripRepl.vars["${k}"];`)
+      .join('\n');
+
+    // Find the last expression to capture as result
+    const lines = cleanJs.trim().split('\n');
+    let lastLine = lines[lines.length - 1];
+
+    // If it's a simple expression (ends with ;), capture it
+    if (lastLine && lastLine.endsWith(';') &&
+        !lastLine.startsWith('let ') &&
+        !lastLine.startsWith('const ') &&
+        !lastLine.startsWith('var ') &&
+        !lastLine.includes('import ') &&
+        !lastLine.includes('export ')) {
+      lines[lines.length - 1] = `globalThis.__ripRepl_result = ${lastLine.slice(0, -1)};`;
+    }
+
+    // Save variables back to context
+    const allVars = [...new Set([...existingVars, ...declaredVars])].filter(k => k !== '_');
+    const saveCtx = allVars.map(v =>
+      `if (typeof ${v} !== 'undefined') globalThis.__ripRepl.vars["${v}"] = ${v};`
+    ).join('\n');
+
+    const wrapped = `
+${restoreCtx}
+${lines.join('\n')}
+${saveCtx}
+`;
+
+    // Write to temp file and import it (enables dynamic imports)
+    const tempFile = path.join(globalThis.__ripRepl.cwd, `.rip-repl-${globalThis.__ripRepl.tempCounter++}.mjs`);
+
+    try {
+      fs.writeFileSync(tempFile, wrapped);
+      await import(pathToFileURL(tempFile).href + `?t=${Date.now()}`);
+      const result = globalThis.__ripRepl_result;
+      delete globalThis.__ripRepl_result;
+      return result;
+    } finally {
+      try { fs.unlinkSync(tempFile); } catch {}
+    }
+  }
+
+  cleanup() {
+    // Clean up any leftover temp files
+    const cwd = globalThis.__ripRepl.cwd;
+    try {
+      const files = fs.readdirSync(cwd);
+      for (const f of files) {
+        if (f.startsWith('.rip-repl-') && f.endsWith('.mjs')) {
+          fs.unlinkSync(path.join(cwd, f));
+        }
+      }
+    } catch {}
+  }
+
   printResult(value) {
     // Pretty print the result
     const formatted = inspect(value, {
@@ -370,18 +455,8 @@ function __readonly(v) { return Object.freeze({ value: v }); }
         break;
 
       case '.clear':
-        // Recreate the context to clear all variables
-        this.context = vm.createContext({
-          console,
-          process,
-          Buffer,
-          setTimeout,
-          setInterval,
-          clearTimeout,
-          clearInterval,
-        });
-        // Re-inject reactive runtime and clear reactive vars
-        this.injectReactiveRuntime();
+        // Clear all variables
+        globalThis.__ripRepl.vars = {};
         this.reactiveVars = new Set();
         this.buffer = '';
         console.log(`${colors.green}Context cleared${colors.reset}`);
@@ -438,6 +513,7 @@ ${colors.cyan}Debug Toggles:${colors.reset}
 
 ${colors.cyan}Tips:${colors.reset}
   - Multi-line input is supported (press Enter mid-expression)
+  - Full import() support: { x } = await import('./file.js')
   - Use Tab for history navigation
   - Previous results stored in _ variable
   - Use Ctrl+C to cancel multi-line input or exit
@@ -445,10 +521,8 @@ ${colors.cyan}Tips:${colors.reset}
   }
 
   printVars() {
-    // Get all variables from the context (excluding built-in globals)
-    const builtins = new Set(['console', 'process', 'Buffer', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', '_']);
-    const allKeys = Object.keys(this.context);
-    const userVars = allKeys.filter(k => !builtins.has(k) && !k.startsWith('_'));
+    // Get all variables from the context
+    const userVars = Object.keys(this.context).filter(k => k !== '_');
 
     if (userVars.length === 0) {
       console.log(`${colors.gray}No variables defined${colors.reset}`);

package/src/tags.js

@@ -1,62 +0,0 @@
-// ============================================================================
-// Shared HTML/SVG Tag Definitions
-// ============================================================================
-// Single source of truth for tag recognition in templates.
-// Used by lexer and codegen at compile time.
-
-export const HTML_TAGS = new Set([
-  // Document metadata
-  'html', 'head', 'title', 'base', 'link', 'meta', 'style',
-  // Sectioning
-  'body', 'address', 'article', 'aside', 'footer', 'header',
-  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'main', 'nav', 'section',
-  // Grouping
-  'blockquote', 'dd', 'div', 'dl', 'dt', 'figcaption', 'figure',
-  'hr', 'li', 'ol', 'p', 'pre', 'ul',
-  // Text-level
-  'a', 'abbr', 'b', 'bdi', 'bdo', 'br', 'cite', 'code', 'data',
-  'dfn', 'em', 'i', 'kbd', 'mark', 'q', 'rp', 'rt', 'ruby', 's',
-  'samp', 'small', 'span', 'strong', 'sub', 'sup', 'time', 'u', 'var', 'wbr',
-  // Embedded
-  'area', 'audio', 'img', 'map', 'track', 'video',
-  'embed', 'iframe', 'object', 'param', 'picture', 'portal', 'source',
-  // SVG/Math
-  'svg', 'math', 'canvas',
-  // Scripting
-  'noscript', 'script',
-  // Edits
-  'del', 'ins',
-  // Tables
-  'caption', 'col', 'colgroup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr',
-  // Forms
-  'button', 'datalist', 'fieldset', 'form', 'input', 'label', 'legend',
-  'meter', 'optgroup', 'option', 'output', 'progress', 'select', 'textarea',
-  // Interactive
-  'details', 'dialog', 'menu', 'summary',
-  // Web components
-  'slot', 'template'
-]);
-
-export const SVG_TAGS = new Set([
-  // Container elements
-  'svg', 'g', 'defs', 'symbol', 'use', 'marker', 'clipPath', 'mask', 'pattern',
-  // Shape elements
-  'circle', 'ellipse', 'line', 'path', 'polygon', 'polyline', 'rect',
-  // Text elements
-  'text', 'textPath', 'tspan',
-  // Gradient elements
-  'linearGradient', 'radialGradient', 'stop',
-  // Filter elements
-  'filter', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite',
-  'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight',
-  'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR',
-  'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology',
-  'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence',
-  // Animation elements
-  'animate', 'animateMotion', 'animateTransform', 'set', 'mpath',
-  // Other elements
-  'desc', 'foreignObject', 'image', 'metadata', 'switch', 'title', 'view'
-]);
-
-// Combined set for template element detection (HTML + common SVG)
-export const TEMPLATE_TAGS = new Set([...HTML_TAGS, ...SVG_TAGS]);