@dxos/plugin-script 0.8.3 → 0.8.4-main.1068cf700f

package/src/notebook/eval.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { trim } from '@dxos/util';
+
+/**
+ * Evaluate the script (with dependencies as arguments).
+ */
+export const evalScript = async (code: string, deps: Record<string, any> = {}) => {
+  // Create a sandboxed environment that blocks access to window and document.
+  const sandbox = {
+    ...deps,
+
+    // Block access to global objects.
+    console: undefined,
+    document: undefined,
+    global: undefined,
+    globalThis: undefined,
+    self: undefined,
+    window: undefined,
+
+    // Allow some safe globals.
+    Array,
+    Boolean,
+    Date,
+    Error,
+    JSON,
+    Map,
+    Math,
+    Number,
+    Object,
+    Promise,
+    RegExp,
+    Set,
+    String,
+
+    // Functions.
+    isFinite,
+    isNaN,
+    parseFloat,
+    parseInt,
+
+    // Note: undefined and null are not included as they are keywords, not variables.
+  };
+
+  // Create function with all sandbox keys as parameters.
+  const sandboxKeys = Object.keys(sandbox);
+  const sandboxValues = Object.values(sandbox);
+
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const fn = new Function(
+    ...sandboxKeys,
+    trim`
+      'use strict';
+      return ${code};
+    `,
+  );
+
+  return fn(...sandboxValues);
+};
+
+/**
+ * Globals.
+ */
+export const builtIns = new Set([
+  // Types.
+  'Array',
+  'Date',
+  'Error',
+  'JSON',
+  'Map',
+  'Math',
+  'Number',
+  'Object',
+  'Promise',
+  'RegExp',
+  'Set',
+  'String',
+
+  // Functions.
+  'isFinite',
+  'isNaN',
+  'parseFloat',
+  'parseInt',
+]);
+
+/**
+ * Default system definitions.
+ */
+export const systemDefinitions = trim`
+  interface Array<T> { length: number; [n: number]: T; }
+  interface Boolean {}
+  interface Function {}
+  interface IArguments {}
+  interface Number {}
+  interface Object {}
+  interface RegExp {}
+  interface String { length: number; }
+
+  interface CallableFunction extends Function {}
+  interface NewableFunction extends Function {}
+
+  declare var console: { log(...args: any[]): void };
+`;

package/src/notebook/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './compute-graph';

package/src/notebook/vfs-parser.test.ts

@@ -0,0 +1,149 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { NotebookVirtualParser, VirtualTypeScriptParser } from './vfs-parser';
+
+describe('vfs-parser', () => {
+  test('parse simple assignments', () => {
+    const parser = new VirtualTypeScriptParser();
+
+    const tests = [
+      {
+        input: 'const a = 1',
+        expected: {
+          name: 'a',
+          type: 'variable',
+        },
+      },
+      {
+        input: 'a = 1',
+        expected: {
+          name: 'a',
+          type: 'variable',
+        },
+      },
+    ];
+
+    tests.forEach(({ input, expected }) => {
+      const result = parser.parseExpression(input);
+      expect(result, input).toMatchObject(expected);
+    });
+  });
+
+  test('parse variable with references', () => {
+    const parser = new VirtualTypeScriptParser();
+
+    const tests = [
+      {
+        input: 'const y = x * 2',
+        expected: {
+          name: 'y',
+          type: 'variable',
+          references: ['x'],
+        },
+      },
+      {
+        input: 'y = x * 2',
+        expected: {
+          name: 'y',
+          type: 'variable',
+          references: ['x'],
+        },
+      },
+    ];
+
+    tests.forEach(({ input, expected }) => {
+      const result = parser.parseExpression(input);
+      expect(result, input).toMatchObject(expected);
+    });
+  });
+
+  test('parse simple expression with references', () => {
+    const parser = new VirtualTypeScriptParser();
+
+    const result = parser.parseExpression('(a + b) * c');
+    expect(result).toMatchObject({
+      references: ['a', 'b', 'c'],
+    });
+  });
+
+  test('parse single expression', () => {
+    const parser = new VirtualTypeScriptParser();
+
+    const result = parser.parseExpression('const add = (a: number, b: number): number => a + b;');
+    expect(result).toMatchObject({
+      name: 'add',
+      type: 'function',
+      valueType: expect.stringContaining('(a: number, b: number) => number'),
+      returnType: 'number',
+      parameters: [
+        { name: 'a', type: 'number' },
+        { name: 'b', type: 'number' },
+      ],
+    });
+  });
+
+  test('analyze multiple files', () => {
+    const parser = new VirtualTypeScriptParser();
+
+    const files = [
+      {
+        filename: '/test.ts',
+        content: 'export const PI = 3.14159;\nexport function square(x: number): number { return x * x; }',
+      },
+    ];
+
+    const results = parser.analyzeFiles(files);
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({
+      name: 'PI',
+      type: 'variable',
+      valueType: '3.14159',
+    });
+    expect(results[1]).toMatchObject({
+      name: 'square',
+      type: 'function',
+      returnType: 'number',
+      parameters: [{ name: 'x', type: 'number' }],
+    });
+  });
+
+  test('notebook cell analysis', () => {
+    const parser = new NotebookVirtualParser();
+
+    const cells = [
+      { id: 'cell1', code: 'const x: number = 10;' },
+      { id: 'cell2', code: 'const y = x * 2;' },
+      { id: 'cell3', code: 'console.log(y);' },
+    ];
+
+    const analysis = parser.analyzeNotebook(cells);
+
+    // Cell 1 exports x.
+    const cell1 = analysis.get('cell1');
+    expect(cell1?.exports).toHaveLength(1);
+    expect(cell1?.exports[0]).toMatchObject({
+      name: 'x',
+      type: 'variable',
+      valueType: 'number',
+    });
+    expect(cell1?.imports).toHaveLength(0);
+
+    // Cell 2 imports x and exports y.
+    const cell2 = analysis.get('cell2');
+    expect(cell2?.exports).toHaveLength(1);
+    expect(cell2?.exports[0]).toMatchObject({
+      name: 'y',
+      type: 'variable',
+    });
+    expect(cell2?.imports).toContain('x');
+
+    // Cell 3 imports y.
+    const cell3 = analysis.get('cell3');
+    expect(cell3?.exports).toHaveLength(0);
+    expect(cell3?.imports).toContain('y');
+  });
+});

package/src/notebook/vfs-parser.ts

@@ -0,0 +1,451 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createSystem, createVirtualTypeScriptEnvironment } from '@typescript/vfs';
+import ts from 'typescript';
+
+import { invariant } from '@dxos/invariant';
+
+import { builtIns, systemDefinitions } from './eval';
+
+/**
+ * Default system definitions.
+ */
+const systemFiles: VirtualFile[] = [
+  {
+    filename: '/lib.d.ts',
+    content: systemDefinitions,
+  },
+];
+
+export type ParsedExpression = {
+  name?: string;
+  type?: 'function' | 'variable' | 'class' | 'interface';
+  value?: any;
+  valueType?: string;
+  parameters?: Array<{ name: string; type: string }>;
+  returnType?: string;
+  references?: string[];
+};
+
+export type VirtualFile = {
+  filename: string;
+  content: string;
+};
+
+/**
+ * TypeScript parser using Virtual File System for browser compatibility.
+ * This provides full TypeScript analysis including type information.
+ */
+export class VirtualTypeScriptParser {
+  protected compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    forceConsistentCasingInfilenames: true,
+    jsx: ts.JsxEmit.React,
+    noLib: true, // Don't automatically include default lib files.
+  };
+
+  /**
+   * Parse a single expression or statement.
+   */
+  parseExpression(input: string): ParsedExpression {
+    invariant(input.trim() !== '', 'input must not be empty');
+    const files: VirtualFile[] = [{ filename: '/temp.ts', content: input }];
+    const analysis = this.analyzeFiles(files);
+
+    // If no declarations found, check for standalone expression references.
+    if (analysis.length === 0) {
+      const sourcefilename = '/temp.ts';
+      const env = this.createEnvironment([{ filename: sourcefilename, content: input }]);
+      const sourceFile = env.getSourceFile(sourcefilename);
+      const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+
+      if (sourceFile && typeChecker) {
+        // Check for assignment expressions.
+        const assignmentInfo = this.findAssignmentExpression(sourceFile, typeChecker);
+        if (assignmentInfo) {
+          return assignmentInfo;
+        }
+
+        const references = this.findAllReferences(sourceFile, typeChecker);
+        return { references };
+      }
+    }
+
+    return analysis[0];
+  }
+
+  /**
+   * Analyze multiple files with full type information.
+   */
+  analyzeFiles(files: VirtualFile[]): ParsedExpression[] {
+    const env = this.createEnvironment(files);
+    const results: ParsedExpression[] = [];
+    const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+
+    // Analyze each file.
+    files.forEach((file) => {
+      const sourceFile = env.getSourceFile(file.filename);
+      if (!sourceFile || !typeChecker) return;
+
+      const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
+      results.push(...fileResults);
+    });
+
+    return results;
+  }
+
+  /**
+   * Analyze a source file with type information.
+   */
+  protected analyzeSourceFile(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): ParsedExpression[] {
+    const results: ParsedExpression[] = [];
+
+    const visit = (node: ts.Node) => {
+      // Function declarations.
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        const symbol = typeChecker.getSymbolAtLocation(node.name);
+        const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+        const signature = type && typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)[0];
+
+        results.push({
+          name: node.name.text,
+          type: 'function',
+          parameters: this.extractParameters(signature, typeChecker),
+          returnType: signature ? typeChecker.typeToString(signature.getReturnType()) : 'any',
+          references: this.findReferences(node, sourceFile, typeChecker),
+        });
+      }
+
+      // Variable declarations.
+      else if (ts.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((declaration) => {
+          if (ts.isIdentifier(declaration.name)) {
+            const symbol = typeChecker.getSymbolAtLocation(declaration.name);
+            const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
+
+            let kind: 'function' | 'variable' = 'variable';
+            let parameters: Array<{ name: string; type: string }> | undefined;
+            let returnType: string | undefined;
+            let value: any;
+
+            // Get the type string.
+            const typeString = type ? typeChecker.typeToString(type) : 'any';
+
+            // Check if it's a function.
+            if (declaration.initializer) {
+              if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+                kind = 'function';
+                const funcType = typeChecker.getTypeAtLocation(declaration.initializer);
+                const signature = typeChecker.getSignaturesOfType(funcType, ts.SignatureKind.Call)[0];
+                if (signature) {
+                  parameters = this.extractParameters(signature, typeChecker);
+                  returnType = typeChecker.typeToString(signature.getReturnType());
+                }
+              } else {
+                // Extract literal values
+                if (ts.isNumericLiteral(declaration.initializer)) {
+                  value = Number(declaration.initializer.text);
+                } else if (ts.isStringLiteral(declaration.initializer)) {
+                  value = declaration.initializer.text;
+                }
+              }
+            }
+
+            // Find references in the initializer only.
+            const refs = declaration.initializer
+              ? this.findReferences(declaration.initializer, sourceFile, typeChecker)
+              : [];
+
+            results.push({
+              name: declaration.name.text,
+              type: kind,
+              valueType: typeString,
+              value,
+              parameters,
+              returnType,
+              references: refs,
+            });
+          }
+        });
+      }
+
+      // Class declarations.
+      else if (ts.isClassDeclaration(node) && node.name) {
+        results.push({
+          name: node.name.text,
+          type: 'class',
+          references: this.findReferences(node, sourceFile, typeChecker),
+        });
+      }
+
+      // Interface declarations.
+      else if (ts.isInterfaceDeclaration(node)) {
+        results.push({
+          name: node.name.text,
+          type: 'interface',
+          references: this.findReferences(node, sourceFile, typeChecker),
+        });
+      }
+
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return results;
+  }
+
+  /**
+   * Extract parameter information from a signature.
+   */
+  private extractParameters(
+    signature: ts.Signature | undefined,
+    typeChecker: ts.TypeChecker,
+  ): Array<{ name: string; type: string }> {
+    if (!signature) return [];
+
+    return signature.parameters.map((param) => ({
+      name: param.getName(),
+      type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(param, param.valueDeclaration!)),
+    }));
+  }
+
+  /**
+   * Find all references to variables used in a node.
+   */
+  private findReferences(node: ts.Node, _sourceFile: ts.SourceFile, _typeChecker: ts.TypeChecker): string[] {
+    const references = new Set<string>();
+    const localSymbols = new Set<string>();
+
+    // First, collect local symbols (parameters, local variables).
+    const collectLocalSymbols = (node: ts.Node) => {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        node.parameters.forEach((param) => {
+          if (ts.isIdentifier(param.name)) {
+            localSymbols.add(param.name.text);
+          }
+        });
+      }
+
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        localSymbols.add(node.name.text);
+      }
+
+      ts.forEachChild(node, collectLocalSymbols);
+    };
+
+    collectLocalSymbols(node);
+
+    // Then find all identifier references.
+    const findRefs = (node: ts.Node) => {
+      if (ts.isIdentifier(node)) {
+        // Skip if it's a local symbol.
+        if (!localSymbols.has(node.text)) {
+          // Check if it's a reference (not a declaration).
+          const parent = node.parent;
+          const isDeclaration =
+            (ts.isVariableDeclaration(parent) && parent.name === node) ||
+            (ts.isFunctionDeclaration(parent) && parent.name === node) ||
+            (ts.isParameter(parent) && parent.name === node);
+
+          if (!isDeclaration && !this.isBuiltIn(node.text)) {
+            references.add(node.text);
+          }
+        }
+      }
+      ts.forEachChild(node, findRefs);
+    };
+
+    findRefs(node);
+    return Array.from(references);
+  }
+
+  /**
+   * Check if a name is a built-in global.
+   */
+  protected isBuiltIn(name: string): boolean {
+    return builtIns.has(name);
+  }
+
+  /**
+   * Find assignment expressions in a source file.
+   */
+  private findAssignmentExpression(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): ParsedExpression | null {
+    let result: ParsedExpression | null = null;
+
+    const visit = (node: ts.Node) => {
+      if (ts.isExpressionStatement(node) && ts.isBinaryExpression(node.expression)) {
+        const expr = node.expression;
+        if (expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(expr.left)) {
+          const type = typeChecker.getTypeAtLocation(expr.right);
+          const typeString = typeChecker.typeToString(type);
+
+          // Get the literal value if it's a literal.
+          let value: any;
+          if (ts.isNumericLiteral(expr.right)) {
+            value = Number(expr.right.text);
+          } else if (ts.isStringLiteral(expr.right)) {
+            value = expr.right.text;
+          }
+
+          // Find references in the right-hand side.
+          const references = this.findReferences(expr.right, sourceFile, typeChecker);
+
+          result = {
+            name: expr.left.text,
+            type: 'variable',
+            valueType: typeString,
+            value,
+            references,
+          };
+        }
+      }
+      if (!result) {
+        ts.forEachChild(node, visit);
+      }
+    };
+
+    visit(sourceFile);
+    return result;
+  }
+
+  /**
+   * Find all identifier references in a source file.
+   */
+  protected findAllReferences(sourceFile: ts.SourceFile, _typeChecker: ts.TypeChecker): string[] {
+    const references = new Set<string>();
+
+    const visit = (node: ts.Node) => {
+      if (ts.isIdentifier(node)) {
+        // Skip if it's a declaration.
+        const parent = node.parent;
+        const isDeclaration =
+          (ts.isVariableDeclaration(parent) && parent.name === node) ||
+          (ts.isFunctionDeclaration(parent) && parent.name === node) ||
+          (ts.isParameter(parent) && parent.name === node);
+
+        // Skip if it's the left-hand side of an assignment.
+        const isAssignmentTarget =
+          ts.isBinaryExpression(parent) &&
+          parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+          parent.left === node;
+
+        if (!isDeclaration && !isAssignmentTarget && !this.isBuiltIn(node.text)) {
+          references.add(node.text);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return Array.from(references);
+  }
+
+  protected createEnvironment(files: VirtualFile[]) {
+    const allFiles = [...systemFiles, ...files];
+
+    const fileMap = new Map<string, string>();
+    allFiles.forEach(({ filename, content }) => {
+      fileMap.set(filename, content);
+    });
+
+    const system = createSystem(fileMap);
+    return createVirtualTypeScriptEnvironment(
+      system,
+      allFiles.map(({ filename }) => filename),
+      ts,
+      this.compilerOptions,
+    );
+  }
+}
+
+/**
+ * Notebook-specific parser with dependency analysis.
+ */
+export class NotebookVirtualParser extends VirtualTypeScriptParser {
+  /**
+   * Analyze notebook cells with full type checking.
+   */
+  analyzeNotebook(cells: Array<{ id: string; code: string }>) {
+    // Create cumulative environment where each cell can see previous cells.
+    const cumulativeCode: string[] = [];
+    const cellAnalysis: Map<
+      string,
+      {
+        exports: ParsedExpression[];
+        imports: string[];
+        errors: ts.Diagnostic[];
+      }
+    > = new Map();
+
+    cells.forEach((cell) => {
+      // Create files for all cells up to current.
+      const files: VirtualFile[] = [];
+
+      // Add previous cells as context.
+      if (cumulativeCode.length > 0) {
+        files.push({
+          filename: '/context.ts',
+          content: cumulativeCode.join('\n'),
+        });
+      }
+
+      // Add current cell.
+      const filename = `/cell/${cell.id}.ts`;
+      files.push({
+        filename,
+        content: cell.code,
+      });
+
+      // Create environment.
+      const env = this.createEnvironment(files);
+
+      // Get diagnostics (errors).
+      const diagnostics = env.languageService.getSemanticDiagnostics(filename);
+
+      // Analyze current cell.
+      const sourceFile = env.getSourceFile(filename);
+      const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+
+      if (sourceFile && typeChecker) {
+        const exports = this.analyzeSourceFile(sourceFile, typeChecker);
+
+        // Find all references in the current cell.
+        const allRefs = new Set<string>();
+        exports.forEach((exp) => {
+          exp.references?.forEach((ref) => allRefs.add(ref));
+        });
+
+        // Also check for references not in exports (e.g., console.log(y)).
+        const additionalRefs = this.findAllReferences(sourceFile, typeChecker);
+        additionalRefs.forEach((ref) => allRefs.add(ref));
+
+        // Determine which references are imports from previous cells.
+        const previousExports = new Set<string>();
+        for (const [_prevCellId, prevAnalysis] of cellAnalysis) {
+          prevAnalysis.exports.forEach((exp) => {
+            if (exp.name) previousExports.add(exp.name);
+          });
+        }
+
+        const imports = Array.from(allRefs).filter((ref) => previousExports.has(ref));
+
+        cellAnalysis.set(cell.id, {
+          exports,
+          imports,
+          errors: diagnostics,
+        });
+      }
+
+      // Add current cell code to cumulative.
+      cumulativeCode.push(cell.code);
+    });
+
+    return cellAnalysis;
+  }
+}