@dxos/plugin-script 0.8.4-main.5ea62a8 → 0.8.4-main.ae835ea

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;
+  }
+}

package/src/templates/chess.ts

@@ -8,6 +8,8 @@ import { S, defineFunction } from 'dxos:functions';
 import { Chess } from 'https://esm.sh/chess.js@0.13.1?bundle=false';
 
 export default defineFunction({
+  key: 'dxos.org/script/chess',
+  name: 'Chess',
   description: 'Plays a random move in a chess game.',
 
   inputSchema: S.Struct({

package/src/templates/data-generator.ts

@@ -8,6 +8,8 @@ import { Expando, S, create, defineFunction } from 'dxos:functions';
 import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1?bundle=false';
 
 export default defineFunction({
+  key: 'dxos.org/script/data-generator',
+  name: 'Data Generator',
   inputSchema: S.Struct({
     documentAmount: S.optional(S.Number),
     textSize: S.optional(S.Number),

package/src/templates/discord.ts

@@ -13,7 +13,13 @@ import {
   // @ts-ignore
 } from 'https://esm.sh/dfx@0.113.0?deps=effect@3.17.0&bundle=false';
 // @ts-ignore
-import { Config, Effect, Redacted, Ref } from 'https://esm.sh/effect@3.17.0?bundle=false';
+import * as Config from 'https://esm.sh/effect@3.17.0/Config?bundle=false';
+// @ts-ignore
+import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
+// @ts-ignore
+import * as Redacted from 'https://esm.sh/effect@3.17.0/Redacted?bundle=false';
+// @ts-ignore
+import * as Ref from 'https://esm.sh/effect@3.17.0/Ref?bundle=false';
 
 const MessageSchema = S.Struct({
   id: ObjectId,
@@ -36,6 +42,8 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
+  key: 'dxos.org/script/discord',
+  name: 'Discord',
   inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
     tick: S.optional(S.String),

package/src/templates/forex-effect.ts

@@ -11,9 +11,13 @@ import {
   // @ts-ignore
 } from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
 // @ts-ignore
-import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
+import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
+// @ts-ignore
+import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
 
 export default defineFunction({
+  key: 'dxos.org/script/forex-effect',
+  name: 'Forex Effect',
   description: 'Returns the exchange rate between two currencies.',
 
   inputSchema: S.Struct({

package/src/templates/forex.ts

@@ -6,6 +6,8 @@
 import { S, defineFunction } from 'dxos:functions';
 
 export default defineFunction({
+  key: 'dxos.org/script/forex',
+  name: 'Forex',
   description: 'Returns the exchange rate between two currencies.',
 
   inputSchema: S.Struct({

package/src/templates/gmail.ts

@@ -14,9 +14,21 @@ import {
 // @ts-ignore
 import { format, subDays } from 'https://esm.sh/date-fns@3.3.1?bundle=false';
 // @ts-ignore
-import { Chunk, Effect, Ref, Schedule, Stream, pipe } from 'https://esm.sh/effect@3.17.0?bundle=false';
+import * as Chunk from 'https://esm.sh/effect@3.17.0/Chunk?bundle=false';
+// @ts-ignore
+import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
+// @ts-ignore
+import * as Function from 'https://esm.sh/effect@3.17.0/Function?bundle=false';
+// @ts-ignore
+import * as Ref from 'https://esm.sh/effect@3.17.0/Ref?bundle=false';
+// @ts-ignore
+import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+// @ts-ignore
+import * as Stream from 'https://esm.sh/effect@3.17.0/Stream?bundle=false';
 
 export default defineFunction({
+  key: 'dxos.org/script/gmail',
+  name: 'Gmail',
   inputSchema: S.Struct({
     mailboxId: S.String,
     userId: S.optional(S.String).pipe(S.withDecodingDefault(() => 'me')),
@@ -41,7 +53,7 @@ export default defineFunction({
 
       // NOTE: Google API bundles size is v. large and caused runtime issues.
       const makeRequest = (url: string) =>
-        pipe(
+        Function.pipe(
           url,
           HttpClientRequest.get,
           HttpClientRequest.setHeaders({ Authorization: `Bearer ${token}`, Accept: 'application/json' }),
@@ -80,7 +92,7 @@ export default defineFunction({
           const messageDetails = yield* getMessage(userId, message.id);
           const created = new Date(parseInt(messageDetails.internalDate)).toISOString();
           const from = messageDetails.payload.headers.find((h: any) => h.name === 'From');
-          const sender = from && parseEmailString(from.value);
+          const sender = from && parseFromHeader(from.value);
           // TODO(wittjosiah): Improve parsing of email contents.
           const content =
             messageDetails.payload.body?.data ??
@@ -114,7 +126,7 @@ export default defineFunction({
 
       const queueMessages = yield* Ref.get(newMessages);
       if (queueMessages.length > 0) {
-        yield* pipe(
+        yield* Function.pipe(
           queueMessages,
           Stream.fromIterable,
           Stream.grouped(10),
@@ -145,17 +157,17 @@ const getUrl = (userId: string, messageId?: string, params?: Record<string, any>
 /**
  * Parses an email string in the format "Name <email@example.com>" into separate name and email components.
  */
-const parseEmailString = (emailString: string): { name?: string; email: string } | undefined => {
-  const match = emailString.match(/^([^<]+?)\s*<([^>]+@[^>]+)>$/);
+const parseFromHeader = (value: string): { name?: string; email: string } | undefined => {
+  const EMAIL_REGEX = /^([^<]+?)\s*<([^>]+@[^>]+)>$/;
+  const removeOuterQuotes = (str: string) => str.replace(/^['"]|['"]$/g, '');
+  const match = value.match(EMAIL_REGEX);
   if (match) {
     const [, name, email] = match;
     return {
-      name: name.trim(),
+      name: removeOuterQuotes(name.trim()),
       email: email.trim(),
     };
   }
-
-  return undefined;
 };
 
 //

package/src/templates/index.ts

@@ -6,11 +6,11 @@ import chat from './chat.ts?raw';
 import chess from './chess.ts?raw';
 import dataGenerator from './data-generator.ts?raw';
 import discord from './discord.ts?raw';
-import echo from './echo.ts?raw';
 import email from './email.ts?raw';
 import forexEffect from './forex-effect.ts?raw';
 import forex from './forex.ts?raw';
 import gmail from './gmail.ts?raw';
+import ping from './ping.ts?raw';
 
 const removeHeader = (str: string) => str.split('\n').slice(4).join('\n');
 
@@ -23,11 +23,11 @@ export type Template = {
   presetId?: string;
 };
 
-export const templates: Template[] = [
+export const templates = [
   {
-    id: 'dxos.org/script/echo',
-    name: 'Echo',
-    source: removeHeader(echo),
+    id: 'dxos.org/script/ping',
+    name: 'Ping',
+    source: removeHeader(ping),
   },
   {
     id: 'dxos.org/script/forex',
@@ -75,4 +75,4 @@ export const templates: Template[] = [
     source: removeHeader(dataGenerator),
     presetId: 'dxos.org/function/data-generator',
   },
-];
+] as const;