stone-lang 0.1.0

package/cli/ViewerServer.js

@@ -0,0 +1,590 @@
+/**
+ * ViewerServer - Minimal HTTP + WebSocket server for graph viewing
+ *
+ * Provides a lightweight browser-based viewer for Stone graphs:
+ * - HTTP server for serving the viewer HTML
+ * - WebSocket server for live updates
+ * - REST API for initial state
+ *
+ * The viewer is a minimal HTML page that loads Plotly/Three.js from CDN
+ * and connects via WebSocket for live updates.
+ */
+
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { EventEmitter } from 'events';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Default port range for viewer server
+const DEFAULT_PORT_START = 3847;
+const DEFAULT_PORT_END = 3857;
+
+/**
+ * Session - Holds state for a viewing session
+ */
+class ViewerSession {
+  constructor(id) {
+    this.id = id;
+    this.terminals = {};
+    this.created = Date.now();
+    this.clients = new Set(); // WebSocket clients
+  }
+
+  addTerminal(id, type, config) {
+    this.terminals[id] = {
+      type,
+      config,
+      data: [],
+    };
+  }
+
+  addToTerminal(id, data) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      const items = Array.isArray(data) ? data : [data];
+      terminal.data.push(...items);
+    }
+  }
+
+  setTerminal(id, data) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      terminal.data = Array.isArray(data) ? data : [data];
+    }
+  }
+
+  clearTerminal(id) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      terminal.data = [];
+    }
+  }
+
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      if (client.readyState === 1) { // WebSocket.OPEN
+        client.send(data);
+      }
+    }
+  }
+
+  getState() {
+    return {
+      id: this.id,
+      terminals: this.terminals,
+      created: this.created,
+    };
+  }
+}
+
+/**
+ * ViewerServer - HTTP + WebSocket server for graph viewing
+ */
+export class ViewerServer extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.port = options.port || DEFAULT_PORT_START;
+    this.host = options.host || 'localhost';
+    this.server = null;
+    this.wss = null;
+    this.sessions = new Map(); // sessionId -> ViewerSession
+    this.sessionCounter = 0;
+  }
+
+  /**
+   * Start the server
+   * @returns {Promise<number>} The port the server is listening on
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        this._handleRequest(req, res);
+      });
+
+      // Set up WebSocket server once, before trying ports
+      this.wss = new WebSocketServer({ noServer: true });
+      this.wss.on('connection', (ws, req) => {
+        this._handleWebSocket(ws, req);
+      });
+
+      // Track sockets being upgraded to prevent double handling
+      const upgradingSocketsSet = new WeakSet();
+
+      // Handle upgrade requests - only add once
+      this.server.on('upgrade', (req, socket, head) => {
+        // Prevent double-handling of the same socket
+        if (upgradingSocketsSet.has(socket)) {
+          return;
+        }
+        upgradingSocketsSet.add(socket);
+
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+          this.wss.emit('connection', ws, req);
+        });
+      });
+
+      // Try ports in range
+      const tryPort = (port) => {
+        if (port > DEFAULT_PORT_END) {
+          reject(new Error('No available ports'));
+          return;
+        }
+
+        this.server.once('error', (err) => {
+          if (err.code === 'EADDRINUSE') {
+            tryPort(port + 1);
+          } else {
+            reject(err);
+          }
+        });
+
+        this.server.listen(port, this.host, () => {
+          this.port = port;
+          this.emit('listening', this.port);
+          resolve(this.port);
+        });
+      };
+
+      tryPort(this.port);
+    });
+  }
+
+  /**
+   * Stop the server
+   */
+  async stop() {
+    // Close all WebSocket connections
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        client.close();
+      }
+      this.wss.close();
+    }
+
+    // Close HTTP server
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(resolve);
+      });
+    }
+  }
+
+  /**
+   * Create a new viewing session
+   * @returns {string} Session ID
+   */
+  createSession() {
+    const id = `s${++this.sessionCounter}_${Date.now().toString(36)}`;
+    const session = new ViewerSession(id);
+    this.sessions.set(id, session);
+    return id;
+  }
+
+  /**
+   * Get a session by ID
+   * @param {string} id - Session ID
+   * @returns {ViewerSession|null}
+   */
+  getSession(id) {
+    return this.sessions.get(id) || null;
+  }
+
+  /**
+   * Get the URL for a session
+   * @param {string} sessionId - Session ID
+   * @returns {string}
+   */
+  getViewUrl(sessionId) {
+    return `http://${this.host}:${this.port}/view/${sessionId}`;
+  }
+
+  /**
+   * Handle HTTP requests
+   */
+  _handleRequest(req, res) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+
+    // Serve viewer HTML
+    if (pathname.startsWith('/view/')) {
+      const sessionId = pathname.split('/')[2];
+      this._serveViewer(res, sessionId);
+      return;
+    }
+
+    // API: Get session state
+    if (pathname.startsWith('/api/terminals/')) {
+      const sessionId = pathname.split('/')[3];
+      this._serveSessionState(res, sessionId);
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+  }
+
+  /**
+   * Serve the viewer HTML
+   */
+  _serveViewer(res, sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Session not found');
+      return;
+    }
+
+    // Check for custom viewer file
+    const viewerPath = path.join(__dirname, 'viewer', 'index.html');
+    if (fs.existsSync(viewerPath)) {
+      const html = fs.readFileSync(viewerPath, 'utf8');
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+      return;
+    }
+
+    // Fallback: inline minimal viewer
+    const html = this._getInlineViewer(sessionId);
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(html);
+  }
+
+  /**
+   * Serve session state as JSON
+   */
+  _serveSessionState(res, sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Session not found' }));
+      return;
+    }
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(session.getState()));
+  }
+
+  /**
+   * Handle WebSocket connections
+   */
+  _handleWebSocket(ws, req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+
+    // Extract session ID from /ws/:sessionId
+    if (!pathname.startsWith('/ws/')) {
+      ws.close(4000, 'Invalid path');
+      return;
+    }
+
+    const sessionId = pathname.split('/')[2];
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      ws.close(4001, 'Session not found');
+      return;
+    }
+
+    // Add client to session
+    session.clients.add(ws);
+
+    // Send initial state
+    ws.send(JSON.stringify({
+      type: 'init',
+      ...session.getState(),
+    }));
+
+    ws.on('close', () => {
+      session.clients.delete(ws);
+    });
+
+    ws.on('error', () => {
+      session.clients.delete(ws);
+    });
+  }
+
+  /**
+   * Generate inline minimal viewer HTML
+   */
+  _getInlineViewer(sessionId) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Stone Viewer</title>
+  <script src="https://cdn.plot.ly/plotly-2.27.0.min.js"></script>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui, -apple-system, sans-serif; background: #1a1a1a; color: #fff; }
+    .container { display: flex; flex-wrap: wrap; gap: 16px; padding: 16px; }
+    .terminal { background: #2a2a2a; border-radius: 8px; padding: 16px; min-width: 400px; flex: 1; }
+    .terminal-title { font-size: 14px; color: #888; margin-bottom: 8px; }
+    .console-lines { font-family: monospace; font-size: 13px; max-height: 400px; overflow-y: auto; }
+    .console-line { padding: 2px 0; }
+    .graph { min-height: 300px; }
+    .status { position: fixed; bottom: 16px; right: 16px; padding: 8px 16px; background: #333; border-radius: 4px; font-size: 12px; }
+    .status.connected { background: #1a472a; }
+    .status.disconnected { background: #472a1a; }
+  </style>
+</head>
+<body>
+  <div class="container" id="terminals"></div>
+  <div class="status" id="status">Connecting...</div>
+
+  <script>
+    const sessionId = '${sessionId}';
+    const container = document.getElementById('terminals');
+    const statusEl = document.getElementById('status');
+    let terminals = {};
+
+    // Connect WebSocket
+    const wsUrl = \`ws://\${location.host}/ws/\${sessionId}\`;
+    let ws;
+
+    function connect() {
+      ws = new WebSocket(wsUrl);
+
+      ws.onopen = () => {
+        statusEl.textContent = 'Connected';
+        statusEl.className = 'status connected';
+      };
+
+      ws.onclose = () => {
+        statusEl.textContent = 'Disconnected';
+        statusEl.className = 'status disconnected';
+        // Reconnect after delay
+        setTimeout(connect, 2000);
+      };
+
+      ws.onerror = () => {
+        statusEl.textContent = 'Error';
+        statusEl.className = 'status disconnected';
+      };
+
+      ws.onmessage = (e) => {
+        const msg = JSON.parse(e.data);
+        handleMessage(msg);
+      };
+    }
+
+    function handleMessage(msg) {
+      switch (msg.type) {
+        case 'init':
+          // Initialize all terminals
+          for (const [id, data] of Object.entries(msg.terminals)) {
+            createTerminal(id, data.type, data.config);
+            if (data.data && data.data.length > 0) {
+              updateTerminal(id, data.type, data.data, false);
+            }
+          }
+          break;
+
+        case 'terminal:create':
+          createTerminal(msg.id, msg.terminalType, msg.config);
+          break;
+
+        case 'terminal:add':
+          updateTerminal(msg.id, terminals[msg.id]?.type, msg.data, true);
+          break;
+
+        case 'terminal:set':
+          updateTerminal(msg.id, terminals[msg.id]?.type, msg.data, false);
+          break;
+
+        case 'terminal:clear':
+          clearTerminal(msg.id);
+          break;
+      }
+    }
+
+    function createTerminal(id, type, config) {
+      if (terminals[id]) return;
+
+      const div = document.createElement('div');
+      div.className = 'terminal';
+      div.id = \`terminal-\${id}\`;
+
+      const title = document.createElement('div');
+      title.className = 'terminal-title';
+      title.textContent = config.title || id;
+      div.appendChild(title);
+
+      if (type === 'console') {
+        const lines = document.createElement('div');
+        lines.className = 'console-lines';
+        lines.id = \`lines-\${id}\`;
+        div.appendChild(lines);
+      } else {
+        const graph = document.createElement('div');
+        graph.className = 'graph';
+        graph.id = \`graph-\${id}\`;
+        div.appendChild(graph);
+      }
+
+      container.appendChild(div);
+      terminals[id] = { type, config, element: div, data: [] };
+    }
+
+    function updateTerminal(id, type, data, append) {
+      const terminal = terminals[id];
+      if (!terminal) return;
+
+      const items = Array.isArray(data) ? data : [data];
+
+      if (append) {
+        terminal.data.push(...items);
+      } else {
+        terminal.data = items;
+      }
+
+      if (type === 'console') {
+        const linesEl = document.getElementById(\`lines-\${id}\`);
+        if (linesEl) {
+          if (!append) linesEl.innerHTML = '';
+          for (const item of items) {
+            const line = document.createElement('div');
+            line.className = 'console-line';
+            line.textContent = String(item);
+            linesEl.appendChild(line);
+          }
+          linesEl.scrollTop = linesEl.scrollHeight;
+        }
+      } else if (type === 'graph2d') {
+        renderGraph2D(id, terminal.data, terminal.config);
+      } else if (type === 'graph3d') {
+        renderGraph3D(id, terminal.data, terminal.config);
+      }
+    }
+
+    function clearTerminal(id) {
+      const terminal = terminals[id];
+      if (!terminal) return;
+
+      terminal.data = [];
+
+      if (terminal.type === 'console') {
+        const linesEl = document.getElementById(\`lines-\${id}\`);
+        if (linesEl) linesEl.innerHTML = '';
+      } else {
+        const graphEl = document.getElementById(\`graph-\${id}\`);
+        if (graphEl) Plotly.purge(graphEl);
+      }
+    }
+
+    // Convert StoneArray to regular JS array
+    function stoneArrayToJS(arr) {
+      if (!arr || arr._type !== 'StoneArray') return arr;
+      const data = arr.data;
+      if (ArrayBuffer.isView(data)) return Array.from(data);
+      if (Array.isArray(data)) return data;
+      if (typeof data === 'object') {
+        const size = arr.size || Object.keys(data).length;
+        const result = [];
+        for (let i = 0; i < size; i++) result.push(data[i]);
+        return result;
+      }
+      return [];
+    }
+
+    // Process Stone plot data to Plotly format
+    function processPlotData(plot) {
+      const type = plot.type || 'line';
+      let x = plot.x;
+      let y = plot.y;
+
+      // Handle StoneArray format first
+      if (x && x._type === 'StoneArray') x = stoneArrayToJS(x);
+      if (y && y._type === 'StoneArray') y = stoneArrayToJS(y);
+
+      // If only y is provided, generate x as indices
+      if (y && !x) {
+        const yArr = Array.isArray(y) ? y : [];
+        x = yArr.map((_, i) => i);
+      }
+
+      const color = plot.style?.color || plot.color || null;
+
+      switch (type) {
+        case 'line':
+          return { x: x || [], y: y || [], type: 'scatter', mode: 'lines+markers', name: plot.title || plot.name || 'Line', line: { color }, marker: { color } };
+        case 'scatter':
+          return { x: x || [], y: y || [], type: 'scatter', mode: 'markers', name: plot.title || plot.name || 'Scatter', marker: { color, size: 8 } };
+        case 'bar':
+          return { x: x || plot.labels || [], y: y || plot.values || [], type: 'bar', name: plot.title || plot.name || 'Bar', marker: { color } };
+        case 'area':
+          return { x: x || [], y: y || [], type: 'scatter', mode: 'lines', fill: 'tozeroy', name: plot.title || plot.name || 'Area', line: { color } };
+        default:
+          return { x: x || [], y: y || [], type: plot.type || 'scatter', mode: plot.mode || 'lines+markers', name: plot.title || plot.name || 'Plot', line: { color }, marker: { color } };
+      }
+    }
+
+    function renderGraph2D(id, plots, config) {
+      const graphEl = document.getElementById(\`graph-\${id}\`);
+      if (!graphEl) return;
+
+      const traces = plots.map((plot, i) => {
+        const processed = processPlotData(plot);
+        if (!processed.name || processed.name === 'Line' || processed.name === 'Plot') processed.name = \`Series \${i + 1}\`;
+        return processed;
+      });
+
+      const layout = {
+        title: config.title || '',
+        xaxis: { title: config.x_label || 'x' },
+        yaxis: { title: config.y_label || 'y' },
+        paper_bgcolor: '#2a2a2a',
+        plot_bgcolor: '#2a2a2a',
+        font: { color: '#fff' },
+        margin: { t: 40, r: 20, b: 40, l: 50 },
+      };
+
+      Plotly.react(graphEl, traces, layout, { responsive: true });
+    }
+
+    function renderGraph3D(id, objects, config) {
+      const graphEl = document.getElementById(\`graph-\${id}\`);
+      if (!graphEl) return;
+
+      // Basic 3D scatter plot
+      const traces = objects.map((obj, i) => ({
+        x: obj.x || [],
+        y: obj.y || [],
+        z: obj.z || [],
+        name: obj.label || \`Object \${i + 1}\`,
+        type: 'scatter3d',
+        mode: 'markers',
+        marker: { size: 3 },
+      }));
+
+      const layout = {
+        title: config.title || '',
+        paper_bgcolor: '#2a2a2a',
+        scene: {
+          bgcolor: '#2a2a2a',
+          xaxis: { title: 'x', gridcolor: '#444' },
+          yaxis: { title: 'y', gridcolor: '#444' },
+          zaxis: { title: 'z', gridcolor: '#444' },
+        },
+        font: { color: '#fff' },
+        margin: { t: 40, r: 20, b: 20, l: 20 },
+      };
+
+      Plotly.react(graphEl, traces, layout, { responsive: true });
+    }
+
+    // Start connection
+    connect();
+  </script>
+</body>
+</html>`;
+  }
+}
+
+export default ViewerServer;

package/cli/commands/check.js

@@ -0,0 +1,84 @@
+/**
+ * check command - Type-check a Stone script without executing
+ *
+ * Usage:
+ *   stone check <file.stn>
+ *   stone check <file.stn> --json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { StoneEngine } from '../../StoneEngine.js';
+
+/**
+ * Type-check a Stone script
+ * @param {string} scriptPath - Path to script file
+ * @param {Object} options - Command options
+ */
+export async function checkCommand(scriptPath, options = {}) {
+  const { json = false, verbose = false } = options;
+
+  // Resolve script path
+  const fullPath = path.isAbsolute(scriptPath)
+    ? scriptPath
+    : path.resolve(process.cwd(), scriptPath);
+
+  // Check file exists
+  if (!fs.existsSync(fullPath)) {
+    if (json) {
+      console.log(JSON.stringify({ valid: false, error: `Script not found: ${scriptPath}` }));
+    } else {
+      console.error(`Error: Script not found: ${scriptPath}`);
+    }
+    process.exit(1);
+  }
+
+  // Read source code
+  const source = fs.readFileSync(fullPath, 'utf8');
+
+  // Create engine
+  const engine = new StoneEngine({ debug: verbose });
+
+  try {
+    // Parse
+    const ast = engine.parse(source, { filename: scriptPath });
+
+    // Type check
+    const result = engine.typeCheck(ast);
+
+    if (json) {
+      console.log(JSON.stringify({
+        valid: result.success,
+        errors: result.success ? [] : result.errors.map(e => ({
+          message: e.message,
+          location: e.location,
+        })),
+      }));
+    } else {
+      if (result.success) {
+        console.log(`✓ ${scriptPath}: No type errors`);
+      } else {
+        console.error(`✗ ${scriptPath}: ${result.errors.length} type error(s)\n`);
+
+        for (const err of result.errors) {
+          const loc = err.location
+            ? `${scriptPath}:${err.location.line}:${err.location.column}`
+            : scriptPath;
+          console.error(`  ${loc}`);
+          console.error(`    ${err.message}\n`);
+        }
+      }
+    }
+
+    process.exit(result.success ? 0 : 1);
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ valid: false, error: err.message }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+export default checkCommand;