stone-lang 0.1.0

package/cli/commands/ps.js

@@ -0,0 +1,65 @@
+/**
+ * ps command - List running Stone processes
+ *
+ * Usage:
+ *   stone ps
+ *   stone ps --mine
+ *   stone ps --status running
+ */
+
+import { DaemonClient } from '../DaemonClient.js';
+
+/**
+ * List running processes
+ * @param {Object} options - Command options
+ */
+export async function psCommand(options = {}) {
+  const { mine = false, status = null, json = false } = options;
+
+  try {
+    const client = new DaemonClient({ autoStartDaemon: false });
+
+    // Check if daemon is running
+    const isRunning = await DaemonClient.isDaemonRunning();
+    if (!isRunning) {
+      if (json) {
+        console.log(JSON.stringify({ processes: [], error: 'Daemon not running' }));
+      } else {
+        console.log('No Stone daemon running.');
+      }
+      return;
+    }
+
+    await client.connect();
+
+    const processes = await client.list({ mine, status });
+
+    if (json) {
+      console.log(JSON.stringify({ processes }));
+    } else {
+      if (processes.length === 0) {
+        console.log('No processes.');
+      } else {
+        // Print table header
+        console.log('ID\t\tSTATUS\t\tSCRIPT\t\tDURATION');
+        console.log('-'.repeat(60));
+
+        for (const proc of processes) {
+          const duration = proc.duration ? `${proc.duration}ms` : '-';
+          console.log(`${proc.id}\t\t${proc.status}\t\t${proc.script}\t\t${duration}`);
+        }
+      }
+    }
+
+    client.disconnect();
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+export default psCommand;

package/cli/commands/run.js

@@ -0,0 +1,537 @@
+/**
+ * run command - Execute a Stone script
+ *
+ * Usage:
+ *   stone run <file.stn>
+ *   stone run <file.stn> --json
+ *   stone run <file.stn> --headless
+ *
+ * Modes:
+ * - Default: Human-readable output, opens browser for graphs
+ * - --json: JSON Lines output for IDE/desktop integration
+ * - --headless: No browser, exports graphs to files
+ *
+ * Execution:
+ * - Tries to use daemon first (shared with desktop app)
+ * - Falls back to direct StoneEngine if daemon unavailable
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { StoneEngine } from '../../StoneEngine.js';
+import { CLIOutputAdapter } from '../CLIOutputAdapter.js';
+import { JSONOutputAdapter } from '../JSONOutputAdapter.js';
+import { ViewerServer } from '../ViewerServer.js';
+import { IPCClientConnection } from '../../daemon/IPCServer.js';
+import { createNodePackageContext } from '../../packages/packageResolver.js';
+
+/**
+ * Execute a Stone script
+ * @param {string} scriptPath - Path to script file
+ * @param {Object} options - Command options
+ */
+export async function runCommand(scriptPath, options = {}) {
+  const {
+    json = false,
+    headless = false,
+    verbose = false,
+    quiet = false,
+    ast = false,
+    bytecode = false,
+    noServe = false,
+    daemon = true, // --no-daemon sets this to false
+  } = options;
+  const noDaemon = !daemon;
+
+  // Resolve script path
+  const fullPath = path.isAbsolute(scriptPath)
+    ? scriptPath
+    : path.resolve(process.cwd(), scriptPath);
+
+  // Check file exists
+  if (!fs.existsSync(fullPath)) {
+    console.error(`Error: Script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+
+  // Read source code
+  const source = fs.readFileSync(fullPath, 'utf8');
+
+  // Handle special output modes (these don't need daemon)
+  if (ast) {
+    const engine = new StoneEngine({ debug: verbose });
+    try {
+      const parsed = engine.parse(source, { filename: scriptPath });
+      console.log(JSON.stringify(parsed, null, 2));
+      process.exit(0);
+    } catch (err) {
+      console.error(`Parse error: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Try daemon execution first (unless --no-daemon)
+  if (!noDaemon) {
+    try {
+      const result = await runViaDaemon(fullPath, source, options);
+      if (result !== null) {
+        // Daemon handled it
+        return;
+      }
+      // result === null means daemon unavailable, fall through to direct
+    } catch (err) {
+      if (verbose) {
+        console.log(`[Daemon unavailable: ${err.message}, using direct execution]`);
+      }
+    }
+  }
+
+  // Fall back to direct execution
+  await runDirect(fullPath, source, options);
+}
+
+/**
+ * Run script via daemon
+ * @returns {Promise<boolean|null>} true if success, false if failed, null if daemon unavailable
+ */
+async function runViaDaemon(fullPath, source, options) {
+  const { json, verbose, quiet } = options;
+
+  const client = new IPCClientConnection();
+
+  try {
+    await client.connect();
+  } catch (err) {
+    // Daemon not running - try to start it
+    if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+      const started = await startDaemon(verbose);
+      if (!started) {
+        return null; // Can't start daemon, fall back to direct
+      }
+
+      // Wait a bit and retry
+      await new Promise(r => setTimeout(r, 500));
+      try {
+        await client.connect();
+      } catch (retryErr) {
+        return null; // Still can't connect
+      }
+    } else {
+      return null;
+    }
+  }
+
+  // When running via daemon, the desktop app handles graph visualization
+  // No ViewerServer needed - just print output and terminal creation messages
+
+  // Handle events from daemon - set up BEFORE run command to not miss early events
+  let exitCode = 0;
+  let finished = false;
+  let processId = null;
+  let terminalsCreated = [];
+
+  client.on('event', (event) => {
+    // Ignore events for other processes
+    if (processId && event.processId && event.processId !== processId) {
+      return;
+    }
+
+    // Track terminal creation
+    if (event.event === 'terminal:create') {
+      const termType = event.type || event.terminalType;
+      terminalsCreated.push({ id: event.id, type: termType });
+
+      // For graph terminals, show creation message (console terminals just print their content)
+      if (!json && !quiet && (termType === 'graph2d' || termType === 'graph3d')) {
+        console.log(`\x1b[36m[Terminal created: ${termType}]\x1b[0m`);
+      }
+    }
+
+    // Handle console terminal output - print the actual lines
+    if (event.event === 'terminal:add') {
+      const terminal = terminalsCreated.find(t => t.id === event.id);
+      if (terminal && terminal.type === 'console') {
+        const lines = Array.isArray(event.data) ? event.data : [event.data];
+        for (const line of lines) {
+          if (json) {
+            console.log(JSON.stringify({ type: 'output', value: line }));
+          } else if (!quiet) {
+            console.log(line);
+          }
+        }
+      }
+    }
+
+    // Handle print events (for direct print() calls)
+    if (event.event === 'print') {
+      if (json) {
+        console.log(JSON.stringify({ type: 'output', value: event.value }));
+      } else if (!quiet) {
+        console.log(event.value);
+      }
+    }
+
+    // Handle error events
+    if (event.event === 'error') {
+      if (json) {
+        console.log(JSON.stringify({ type: 'error', message: event.message, location: event.location }));
+      } else if (!quiet) {
+        console.error(`Error: ${event.message}`);
+        if (event.location) {
+          console.error(`  at ${event.location.file}:${event.location.line}:${event.location.column}`);
+        }
+      }
+    }
+
+    // Check for completion
+    if (event.event === 'process:end') {
+      finished = true;
+      exitCode = event.success ? 0 : 1;
+
+      if (verbose && !json) {
+        console.log(`\nCompleted in ${event.duration}ms`);
+      }
+
+      if (!event.success && !quiet) {
+        if (json) {
+          console.log(JSON.stringify({ type: 'failed', error: event.error }));
+        } else {
+          console.error(`\nExecution failed: ${event.error}`);
+        }
+      }
+
+      // Show message about viewing graph terminals in desktop app
+      if (!json && !quiet && terminalsCreated.length > 0) {
+        const graphTerminals = terminalsCreated.filter(t => t.type === 'graph2d' || t.type === 'graph3d');
+        if (graphTerminals.length > 0) {
+          console.log(`\n\x1b[33m📊 ${graphTerminals.length} graph terminal(s) created. View in Riva Viewport.\x1b[0m`);
+        }
+      }
+    }
+  });
+
+  // Send run command to daemon
+  const response = await client.request('run', {
+    script: fullPath,
+    source: source,
+    cwd: path.dirname(fullPath),
+  });
+
+  if (!response.processId) {
+    console.error('Daemon failed to start process');
+    client.disconnect();
+    return false;
+  }
+
+  processId = response.processId;
+  if (verbose) {
+    console.log(`[Running via daemon, processId: ${processId}]`);
+  }
+
+  // Wait for process to complete
+  await new Promise((resolve) => {
+    const checkInterval = setInterval(() => {
+      if (finished) {
+        clearInterval(checkInterval);
+        resolve();
+      }
+    }, 50);
+  });
+
+  client.disconnect();
+  process.exit(exitCode);
+}
+
+/**
+ * Handle a daemon event
+ */
+function handleDaemonEvent(event, processId, ctx) {
+  const { json, quiet, verbose, viewerServer, sessionId } = ctx;
+
+  // Ignore events for other processes (only filter if we have a processId to compare)
+  if (processId && event.processId && event.processId !== processId) {
+    return;
+  }
+
+  switch (event.event) {
+    case 'print':
+      if (json) {
+        console.log(JSON.stringify({ type: 'output', value: event.value }));
+      } else if (!quiet) {
+        console.log(event.value);
+      }
+      break;
+
+    case 'terminal:create':
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.addTerminal(event.id, event.type, event.config);
+          session.broadcast({ type: 'terminal:create', id: event.id, terminalType: event.type, config: event.config });
+        }
+
+        // Open browser on first graph
+        if (!ctx.browserOpened && (event.type === 'graph2d' || event.type === 'graph3d')) {
+          ctx.onBrowserOpened();
+          const viewUrl = viewerServer.getViewUrl(sessionId);
+          console.log(`\n  View graphs at: \x1b[36m${viewUrl}\x1b[0m\n`);
+
+          import('child_process').then(({ exec }) => {
+            const cmd = process.platform === 'win32' ? 'start' :
+                        process.platform === 'darwin' ? 'open' : 'xdg-open';
+            exec(`${cmd} ${viewUrl}`);
+          }).catch(() => {});
+        }
+      }
+      break;
+
+    case 'terminal:add':
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.addToTerminal(event.id, event.data);
+          session.broadcast({ type: 'terminal:add', id: event.id, data: event.data });
+        }
+      }
+      break;
+
+    case 'terminal:set':
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.setTerminal(event.id, event.data);
+          session.broadcast({ type: 'terminal:set', id: event.id, data: event.data });
+        }
+      }
+      break;
+
+    case 'terminal:clear':
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.clearTerminal(event.id);
+          session.broadcast({ type: 'terminal:clear', id: event.id });
+        }
+      }
+      break;
+
+    case 'error':
+      if (json) {
+        console.log(JSON.stringify({ type: 'error', message: event.message, location: event.location }));
+      } else if (!quiet) {
+        console.error(`Error: ${event.message}`);
+        if (event.location) {
+          console.error(`  at ${event.location.file}:${event.location.line}:${event.location.column}`);
+        }
+      }
+      break;
+
+    case 'process:end':
+      if (verbose && !json) {
+        console.log(`\nCompleted in ${event.duration}ms`);
+      }
+      if (!event.success && !quiet) {
+        if (json) {
+          console.log(JSON.stringify({ type: 'failed', error: event.error }));
+        } else {
+          console.error(`\nExecution failed: ${event.error}`);
+        }
+      }
+      break;
+  }
+}
+
+/**
+ * Start the daemon process
+ */
+async function startDaemon(verbose) {
+  const { spawn } = await import('child_process');
+
+  // Find daemon path
+  const daemonPath = path.join(
+    path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1')),
+    '..', '..', 'daemon', 'daemon.js'
+  );
+
+  if (!fs.existsSync(daemonPath)) {
+    if (verbose) {
+      console.log(`[Daemon not found at ${daemonPath}]`);
+    }
+    return false;
+  }
+
+  if (verbose) {
+    console.log(`[Starting daemon at ${daemonPath}]`);
+  }
+
+  const daemon = spawn('node', [daemonPath], {
+    detached: true,
+    stdio: 'ignore',
+  });
+
+  daemon.unref();
+  return true;
+}
+
+/**
+ * Direct execution (fallback when daemon unavailable)
+ */
+async function runDirect(fullPath, source, options) {
+  const { json, headless, verbose, quiet, noServe } = options;
+  const scriptPath = path.basename(fullPath);
+
+  // ViewerServer for graphs
+  let viewerServer = null;
+  let sessionId = null;
+  let browserOpened = false;
+
+  const usesGraphs = source.includes('graph2d') || source.includes('graph3d');
+  if (usesGraphs && !headless && !json) {
+    viewerServer = new ViewerServer();
+    try {
+      await viewerServer.start();
+      sessionId = viewerServer.createSession();
+      if (verbose) {
+        console.log(`[Viewer server started on port ${viewerServer.port}]`);
+      }
+    } catch (err) {
+      console.error(`Failed to start viewer server: ${err.message}`);
+    }
+  }
+
+  // Create appropriate adapter
+  let adapter;
+  if (json) {
+    adapter = new JSONOutputAdapter();
+  } else {
+    adapter = new CLIOutputAdapter({
+      verbose,
+      quiet,
+      onGraphCreated: (id, type, config) => {
+        if (viewerServer && sessionId) {
+          const session = viewerServer.getSession(sessionId);
+          if (session) {
+            session.addTerminal(id, type, config);
+            session.broadcast({ type: 'terminal:create', id, terminalType: type, config });
+          }
+
+          if (!browserOpened) {
+            browserOpened = true;
+            const viewUrl = viewerServer.getViewUrl(sessionId);
+            console.log(`\n  View graphs at: \x1b[36m${viewUrl}\x1b[0m\n`);
+
+            import('child_process').then(({ exec }) => {
+              const cmd = process.platform === 'win32' ? 'start' :
+                          process.platform === 'darwin' ? 'open' : 'xdg-open';
+              exec(`${cmd} ${viewUrl}`);
+            }).catch(() => {});
+          }
+        }
+      },
+    });
+  }
+
+  // Wrap adapter to forward graph updates to viewer
+  const wrappedAdapter = {
+    print: (text) => adapter.print(text),
+    createTerminal: (id, type, config) => {
+      adapter.createTerminal(id, type, config);
+    },
+    addToTerminal: (id, data) => {
+      adapter.addToTerminal(id, data);
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.addToTerminal(id, data);
+          session.broadcast({ type: 'terminal:add', id, data });
+        }
+      }
+    },
+    setTerminal: (id, data) => {
+      adapter.setTerminal(id, data);
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.setTerminal(id, data);
+          session.broadcast({ type: 'terminal:set', id, data });
+        }
+      }
+    },
+    clearTerminal: (id) => {
+      adapter.clearTerminal(id);
+      if (viewerServer && sessionId) {
+        const session = viewerServer.getSession(sessionId);
+        if (session) {
+          session.clearTerminal(id);
+          session.broadcast({ type: 'terminal:clear', id });
+        }
+      }
+    },
+    error: (message, location) => adapter.error(message, location),
+    finish: (success, result) => adapter.finish(success, result),
+    progress: (info) => adapter.progress?.(info),
+  };
+
+  // Create engine
+  const engine = new StoneEngine({
+    outputAdapter: wrappedAdapter,
+    debug: verbose,
+  });
+
+  // Set up package context for stone_modules resolution
+  try {
+    const packageContext = await createNodePackageContext();
+    engine.setPackageContext(packageContext);
+  } catch (e) {
+    // Package context not available, continue without it
+  }
+
+  // Execute
+  try {
+    const startTime = Date.now();
+
+    const result = await engine.execute(source, {
+      filename: scriptPath,
+      currentPath: path.dirname(fullPath),
+    });
+
+    const duration = Date.now() - startTime;
+
+    if (result.success) {
+      if (verbose && !json) {
+        console.log(`\nCompleted in ${duration}ms`);
+      }
+
+      if (viewerServer && !noServe) {
+        console.log('Press Ctrl+C to exit...');
+        await new Promise(() => {});
+      }
+
+      process.exit(0);
+    } else {
+      if (!json && !quiet) {
+        console.error(`\nExecution failed: ${result.error}`);
+      }
+
+      if (viewerServer) {
+        await viewerServer.stop();
+      }
+
+      process.exit(1);
+    }
+  } catch (err) {
+    if (!json) {
+      console.error(`\nFatal error: ${err.message}`);
+    } else {
+      console.log(JSON.stringify({ type: 'fatal', error: err.message }));
+    }
+
+    if (viewerServer) {
+      await viewerServer.stop();
+    }
+
+    process.exit(1);
+  }
+}
+
+export default runCommand;