@dxos/plugin-script 0.8.4-main.67995b8 → 0.8.4-main.c4373fc

package/src/hooks/deploy.ts

@@ -4,15 +4,15 @@
 
 import { useEffect, useMemo } from 'react';
 
-import { FunctionType, type ScriptType, getUserFunctionUrlInMetadata } from '@dxos/functions';
+import { FunctionType, type ScriptType, getUserFunctionIdInMetadata } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { type Client, useClient } from '@dxos/react-client';
-import { getMeta, getSpace, Query, Ref, type Space, useQuery } from '@dxos/react-client/echo';
+import { Query, Ref, type Space, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
 import { type TFunction } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
 import { errorMessageColors } from '@dxos/react-ui-theme';
 
-import { SCRIPT_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { deployScript, getFunctionUrl, isScriptDeployed } from '../util';
 
 export type DeployActionProperties = { type: 'deploy' } | { type: 'copy' };
@@ -29,15 +29,15 @@ export type CreateDeployOptions = {
   script: ScriptType;
   fn: FunctionType;
   space?: Space;
-  existingFunctionUrl?: string;
+  existingFunctionId?: string;
   client: Client;
   t: TFunction;
 };
 
-export const createDeploy = ({ state, script, space, fn, client, existingFunctionUrl, t }: CreateDeployOptions) => {
+export const createDeploy = ({ state, script, space, fn, client, existingFunctionId, t }: CreateDeployOptions) => {
   // TODO(wittjosiah): Should this be an action?
   const errorItem = createMenuAction('error', () => {}, {
-    label: state.error ?? ['no error label', { ns: SCRIPT_PLUGIN }],
+    label: state.error ?? ['no error label', { ns: meta.id }],
     icon: 'ph--warning-circle--regular',
     hidden: !state.error,
     classNames: state.error && errorMessageColors,
@@ -53,7 +53,7 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
       state.error = undefined;
       state.deploying = true;
 
-      const result = await deployScript({ script, client, space, fn, existingFunctionUrl });
+      const result = await deployScript({ script, client, space, fn, existingFunctionId });
 
       if (!result.success) {
         log.catch(result.error);
@@ -64,7 +64,7 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
     },
     {
       type: 'deploy',
-      label: [state.deploying ? 'pending label' : 'deploy label', { ns: SCRIPT_PLUGIN }],
+      label: [state.deploying ? 'publishing label' : 'deploy label', { ns: meta.id }],
       icon: state.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
       disabled: state.deploying,
       classNames: state.deploying ? '[&_svg]:animate-spin' : '',
@@ -74,14 +74,13 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
   const copyAction = createMenuAction<DeployActionProperties>(
     'copy',
     async () => {
-      if (!state.functionUrl) {
-        return;
+      if (state.functionUrl) {
+        await navigator.clipboard.writeText(state.functionUrl);
       }
-      await navigator.clipboard.writeText(state.functionUrl);
     },
     {
       type: 'copy',
-      label: ['copy link label', { ns: SCRIPT_PLUGIN }],
+      label: ['copy link label', { ns: meta.id }],
       icon: 'ph--link--regular',
       disabled: !state.functionUrl,
     },
@@ -98,9 +97,9 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
 };
 
 export const useDeployState = ({ state, script }: { state: Partial<DeployState>; script: ScriptType }) => {
-  const { space, client, fn, existingFunctionUrl } = useDeployDeps({ script });
+  const { space, client, fn, existingFunctionId } = useDeployDeps({ script });
   useEffect(() => {
-    if (!existingFunctionUrl) {
+    if (!existingFunctionId) {
       return;
     }
 
@@ -109,17 +108,17 @@ export const useDeployState = ({ state, script }: { state: Partial<DeployState>;
       fn,
       edgeUrl: client.config.values.runtime?.services?.edge?.url ?? '',
     });
-  }, [existingFunctionUrl, space, fn, script, client.config.values.runtime?.services?.edge?.url]);
+  }, [existingFunctionId, space, fn, script, client.config.values.runtime?.services?.edge?.url]);
 
   useEffect(() => {
     state.deployed = isScriptDeployed({ script, fn });
-  }, [script.changed, existingFunctionUrl, fn, script]);
+  }, [script.changed, existingFunctionId, fn, script]);
 };
 
 export const useDeployDeps = ({ script }: { script: ScriptType }) => {
+  const client = useClient();
   const space = getSpace(script);
   const [fn] = useQuery(space, Query.type(FunctionType, { source: Ref.make(script) }));
-  const client = useClient();
-  const existingFunctionUrl = useMemo(() => fn && getUserFunctionUrlInMetadata(getMeta(fn)), [fn]);
-  return { space, fn, client, existingFunctionUrl };
+  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(getMeta(fn)), [fn]);
+  return { client, space, fn, existingFunctionId };
 };

package/src/hooks/format.ts

@@ -10,7 +10,7 @@ import { type ScriptType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
-import { SCRIPT_PLUGIN } from '../meta';
+import { meta } from '../meta';
 
 export type FormatActionProperties = { type: 'format' };
 
@@ -35,7 +35,7 @@ export const createFormat = (script: ScriptType) => {
       }
     },
     {
-      label: ['format label', { ns: SCRIPT_PLUGIN }],
+      label: ['format label', { ns: meta.id }],
       icon: 'ph--magic-wand--regular',
     },
   );

package/src/hooks/template.ts

@@ -4,16 +4,17 @@
 
 import { Obj } from '@dxos/echo';
 import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
-import { createMenuItemGroup, createMenuAction } from '@dxos/react-ui-menu';
+import { createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
 
-import { SCRIPT_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { templates } from '../templates';
 
 export type TemplateActionProperties = { type: 'template'; value: string };
 
 const createTemplateSelectGroup = () => {
+  // TODO(burdon): This should not be in the toolbar (move to create Object dialog).
   return createMenuItemGroup('template-select', {
-    label: ['template select group label', { ns: SCRIPT_PLUGIN }],
+    label: ['template select group label', { ns: meta.id }],
     variant: 'dropdownMenu',
   });
 };

package/src/hooks/useCreateAndDeployScriptTemplates.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { pipe } from 'effect/Function';
+import * as Function from 'effect/Function';
 import { useCallback, useState } from 'react';
 
 import { chain, createIntent, useIntentDispatcher } from '@dxos/app-framework';
@@ -40,8 +40,8 @@ export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scri
     const deploymentResults = await Promise.all(
       scriptTemplates.map(async (template) => {
         const result = await dispatch(
-          pipe(
-            createIntent(ScriptAction.Create, { space, initialTemplateId: template.id }),
+          Function.pipe(
+            createIntent(ScriptAction.CreateScript, { space, initialTemplateId: template.id }),
             chain(SpaceAction.AddObject, { target: space }),
           ),
         );
@@ -55,5 +55,6 @@ export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scri
     setStatus(hasErrors ? 'error' : 'success');
   }, [space, dispatch, client, scriptTemplates]);
 
+  // TODO(burdon): Return onCreateAndDeployScripts.
   return { handleCreateAndDeployScripts, status, error };
 };

package/src/index.ts

@@ -5,5 +5,6 @@
 export { ScriptCapabilities } from './capabilities';
 export * from './components';
 export * from './meta';
+export * from './util';
 
 export * from './ScriptPlugin';

package/src/meta.ts

@@ -4,13 +4,11 @@
 
 import { type PluginMeta } from '@dxos/app-framework';
 
-export const SCRIPT_PLUGIN = 'dxos.org/plugin/script';
-
 export const meta: PluginMeta = {
-  id: SCRIPT_PLUGIN,
+  id: 'dxos.org/plugin/script',
   name: 'Scripts',
   description:
-    'Scripts in Composer allow you to deploy custom functions that run on the edge. These functions can be referenced by your AI agent and called inside of cells in any Sheet. Use scripts to interact with API’s or external data inside of Composer.',
+    'Scripts enable you to deploy custom functions that run on the edge. These functions can be referenced by your AI agent and called inside of cells in any Sheet. Use scripts to interact with API’s or external data inside of Composer.',
   icon: 'ph--code--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-explorer',
   tags: ['labs'],

package/src/notebook/index.ts

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

package/src/notebook/notebook.test.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { createNotebook } from '../testing';
+
+import { ComputeGraph } from './notebook';
+
+// TODO(burdon): Create test where one cell could be a AI prompt that references other cells.
+// TODO(burdon): UI cells: Value, Query, TS Expression, Prompt (show input and output).
+
+describe('notebook', () => {
+  test('parse dependency graph', () => {
+    const notebook = createNotebook();
+    const computer = new ComputeGraph(notebook);
+    const result = computer.parse();
+
+    const getId = (i: number) => notebook.cells[i].id;
+
+    // Check dependencies.
+    expect(result.dependencyGraph).toMatchObject({
+      [getId(0)]: [getId(1), getId(2)],
+      [getId(3)]: [getId(1)],
+      [getId(4)]: [getId(0), getId(3)],
+    });
+
+    // Compute values.
+    const values = computer.evaluate();
+    expect(values).toEqual({
+      [getId(0)]: 300,
+      [getId(2)]: 200,
+      [getId(3)]: 200,
+      [getId(4)]: 500,
+    });
+  });
+});

package/src/notebook/notebook.ts

@@ -0,0 +1,188 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Signal, signal } from '@preact/signals-core';
+
+import { log } from '@dxos/log';
+
+import { type Notebook } from '../types';
+
+import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
+
+/**
+ * Compute graph that evaluates the notebook cells.
+ */
+export class ComputeGraph {
+  private readonly _parser = new VirtualTypeScriptParser();
+
+  private _expressions = signal<Record<string, ParsedExpression>>({});
+  private _values = signal<Record<string, any>>({});
+
+  constructor(private readonly _notebook: Notebook.Notebook) {}
+
+  /**
+   * Parsed expressions by cell ID.
+   */
+  get expressions(): Signal<Record<string, ParsedExpression>> {
+    return this._expressions;
+  }
+
+  /**
+   * Computed values by cell ID.
+   */
+  get values(): Signal<Record<string, any>> {
+    return this._values;
+  }
+
+  /**
+   * Compute values.
+   */
+  evaluate() {
+    // Parse expressions.
+    const { expressions, dependencyGraph } = this.parse();
+    this._values.value = {};
+
+    // Create a map of cell IDs to expressions for easy lookup.
+    const cellExpressions = new Map<string, ParsedExpression>();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      cellExpressions.set(id, expr);
+    });
+
+    // Topological sort to determine evaluation order.
+    const evaluationOrder = this.topologicalSort(Object.keys(expressions), dependencyGraph);
+
+    // Values by reference name.
+    const valuesByName: Record<string, any> = {};
+    const valuesByCellId: Record<string, any> = {};
+
+    // Evaluate cells in dependency order.
+    for (const cellId of evaluationOrder) {
+      const expr = cellExpressions.get(cellId);
+      if (!expr) {
+        log.error('no expression for cell', { cellId });
+        continue;
+      }
+
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script.target?.content;
+      if (!cellSource) {
+        log.error('no source for cell', { cellId });
+        continue;
+      }
+
+      try {
+        // For assignments or declarations, evaluate and store the value.
+        if (expr.name && expr.value !== undefined) {
+          // If the parser extracted a literal value, use it directly.
+          valuesByName[expr.name] = expr.value;
+          valuesByCellId[cellId] = expr.value;
+        } else if (expr.name) {
+          // For non-literal assignments, we need to evaluate the expression.
+          // The parser identifies it's an assignment, so we can extract the RHS.
+          const equalIndex = cellSource.indexOf('=');
+          if (equalIndex !== -1) {
+            // Find the actual assignment operator (not in strings or other contexts).
+            let rhs = cellSource.substring(equalIndex + 1).trim();
+
+            // Handle semicolon at the end.
+            if (rhs.endsWith(';')) {
+              rhs = rhs.slice(0, -1).trim();
+            }
+
+            const result = this.evalScript(rhs, valuesByName);
+            valuesByName[expr.name] = result;
+            if (typeof result !== 'function') {
+              valuesByCellId[cellId] = result;
+            }
+          }
+        } else {
+          // For expressions without assignment, just evaluate.
+          const result = this.evalScript(cellSource, valuesByName);
+          valuesByCellId[cellId] = result;
+        }
+      } catch (error) {
+        log.error('error evaluating cell', { cellId, error });
+      }
+    }
+
+    this._values.value = valuesByCellId;
+    return valuesByCellId;
+  }
+
+  /**
+   * Parse expressions.
+   */
+  parse() {
+    const expressions = this._notebook.cells.reduce<Record<string, ParsedExpression>>((acc, cell) => {
+      const text = cell.script.target?.content.trim();
+      if (text) {
+        const parsed = this._parser.parseExpression(text);
+        acc[cell.id] = parsed;
+      }
+
+      return acc;
+    }, {});
+
+    // Build dependency graph.
+    const dependencyGraph = this.buildDependencyGraph(expressions);
+    this._expressions.value = expressions;
+    return { expressions, dependencyGraph };
+  }
+
+  private topologicalSort(nodes: string[], dependencies: Record<string, string[]>): string[] {
+    const visited = new Set<string>();
+    const result: string[] = [];
+
+    const visit = (node: string) => {
+      if (visited.has(node)) {
+        return;
+      }
+
+      visited.add(node);
+
+      // Visit dependencies first.
+      const deps = dependencies[node] || [];
+      deps.forEach((dep) => visit(dep));
+      result.push(node);
+    };
+
+    // Visit all nodes.
+    nodes.forEach((node) => visit(node));
+    return result;
+  }
+
+  private buildDependencyGraph(expressions: Record<string, ParsedExpression>): Record<string, string[]> {
+    // Create a map of variable names to their cell IDs.
+    const nameToCellId = new Map<string, string>();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.name) {
+        nameToCellId.set(expr.name, id);
+      }
+    });
+
+    // Build the dependency graph using cell IDs.
+    const graph: Record<string, string[]> = {};
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.references && expr.references.length > 0) {
+        // Map variable references to cell IDs.
+        const dependencyCellIds = expr.references
+          .map((ref) => nameToCellId.get(ref))
+          .filter((cellId): cellId is string => cellId !== undefined && cellId !== id);
+
+        if (dependencyCellIds.length > 0) {
+          graph[id] = dependencyCellIds;
+        }
+      }
+    });
+
+    return graph;
+  }
+
+  /**
+   * Evaluate the script (with dependencies as arguments).
+   */
+  private evalScript(code: string, deps: Record<string, any> = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    return new Function(...Object.keys(deps), 'return ' + code)(...Object.values(deps));
+  }
+}

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