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

package/src/components/DeploymentDialog/DeploymentDialog.tsx

@@ -10,10 +10,10 @@ import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
 import { type DataType } from '@dxos/schema';
 
 import { useCreateAndDeployScriptTemplates } from '../../hooks/useCreateAndDeployScriptTemplates';
-import { SCRIPT_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
 import { type Template } from '../../templates';
 
-export const DEPLOYMENT_DIALOG = `${SCRIPT_PLUGIN}/deployment/dialog`;
+export const DEPLOYMENT_DIALOG = `${meta.id}/deployment/dialog`;
 
 // TODO(ZaymonFC):
 //  - Show activity and feedback to the user.
@@ -26,7 +26,7 @@ export type DeploymentDialogProps = {
 };
 
 export const DeploymentDialog = ({ accessToken, scriptTemplates }: DeploymentDialogProps) => {
-  const { t } = useTranslation(SCRIPT_PLUGIN);
+  const { t } = useTranslation(meta.id);
   const space = useMemo(() => getSpace(accessToken), [accessToken]);
 
   // TODO(ZaymonFC): Thinking further. All of this should get moved to intents to run async in the background.
@@ -41,12 +41,12 @@ export const DeploymentDialog = ({ accessToken, scriptTemplates }: DeploymentDia
         createIntent(LayoutAction.AddToast, {
           part: 'toast',
           subject: {
-            id: `${SCRIPT_PLUGIN}/deployment-success`,
+            id: `${meta.id}/deployment-success`,
             icon: 'ph--check--regular',
             duration: Infinity,
-            title: ['script deployment toast label', { ns: SCRIPT_PLUGIN, count: scriptTemplates.length }],
-            description: ['script deployment toast description', { ns: SCRIPT_PLUGIN, count: scriptTemplates.length }],
-            closeLabel: ['script deployment toast close label', { ns: SCRIPT_PLUGIN, count: scriptTemplates.length }],
+            title: ['script deployment toast label', { ns: meta.id, count: scriptTemplates.length }],
+            description: ['script deployment toast description', { ns: meta.id, count: scriptTemplates.length }],
+            closeLabel: ['script deployment toast close label', { ns: meta.id, count: scriptTemplates.length }],
           },
         }),
       );
@@ -58,18 +58,12 @@ export const DeploymentDialog = ({ accessToken, scriptTemplates }: DeploymentDia
         createIntent(LayoutAction.AddToast, {
           part: 'toast',
           subject: {
-            id: `${SCRIPT_PLUGIN}/deployment-error`,
+            id: `${meta.id}/deployment-error`,
             icon: 'ph--warning--regular',
             duration: Infinity,
-            title: ['script deployment error toast label', { ns: SCRIPT_PLUGIN, count: scriptTemplates.length }],
-            description: [
-              'script deployment error toast description',
-              { ns: SCRIPT_PLUGIN, count: scriptTemplates.length },
-            ],
-            closeLabel: [
-              'script deployment error toast close label',
-              { ns: SCRIPT_PLUGIN, count: scriptTemplates.length },
-            ],
+            title: ['script deployment error toast label', { ns: meta.id, count: scriptTemplates.length }],
+            description: ['script deployment error toast description', { ns: meta.id, count: scriptTemplates.length }],
+            closeLabel: ['script deployment error toast close label', { ns: meta.id, count: scriptTemplates.length }],
           },
         }),
       );

package/src/components/NotebookContainer.stories.tsx

@@ -0,0 +1,83 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Agent } from '@dxos/assistant-toolkit';
+import { Filter } from '@dxos/echo';
+import { Function, serializeFunction } from '@dxos/functions';
+import { AssistantPlugin } from '@dxos/plugin-assistant';
+import { AutomationPlugin } from '@dxos/plugin-automation';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { ExplorerPlugin } from '@dxos/plugin-explorer';
+import { Markdown, MarkdownPlugin } from '@dxos/plugin-markdown';
+import { SpacePlugin } from '@dxos/plugin-space';
+import { Config, useClient } from '@dxos/react-client';
+import { useQuery } from '@dxos/react-client/echo';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { DataTypes } from '@dxos/schema';
+
+import { createNotebook } from '../testing';
+import { translations } from '../translations';
+import { Notebook } from '../types';
+
+import { NotebookContainer } from './NotebookContainer';
+
+const meta = {
+  title: 'plugins/plugin-script/NotebookContainer',
+  component: NotebookContainer,
+  render: (args) => {
+    const client = useClient();
+    const space = client.spaces.default;
+    const notebooks = useQuery(space?.db, Filter.type(Notebook.Notebook));
+    return <NotebookContainer {...args} notebook={notebooks[0]} />;
+  },
+  decorators: [
+    withTheme,
+    withLayout({ container: 'column', classNames: 'is-prose' }),
+    withPluginManager({
+      plugins: [
+        ClientPlugin({
+          // TODO(wittjosiah): ComputeRuntime requires edge to be configured or it will throw.
+          config: new Config({
+            runtime: {
+              services: SERVICES_CONFIG.REMOTE,
+            },
+          }),
+          types: [...DataTypes, Notebook.Notebook, Function.Function, Markdown.Document],
+          onClientInitialized: async ({ client }) => {
+            await client.halo.createIdentity();
+            await client.spaces.waitUntilReady();
+            const space = client.spaces.default;
+            await space.waitUntilReady();
+
+            space.db.add(createNotebook());
+            space.db.add(Markdown.makeDocument({ content: '# Hello World' }));
+            space.db.add(serializeFunction(Agent.prompt));
+          },
+        }),
+        SpacePlugin({}),
+        SettingsPlugin(),
+        IntentPlugin(),
+        AssistantPlugin(),
+        AutomationPlugin(),
+        ExplorerPlugin(),
+        MarkdownPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    translations,
+  },
+} satisfies Meta<typeof NotebookContainer>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/NotebookContainer.tsx

@@ -0,0 +1,263 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Layer from 'effect/Layer';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { Agent } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Filter, Obj, Query, Ref } from '@dxos/echo';
+import { QueryBuilder } from '@dxos/echo-query';
+import {
+  ComputeEventLogger,
+  type FunctionDefinition,
+  FunctionInvocationService,
+  InvocationTracer,
+  TracingService,
+} from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { useComputeRuntimeCallback } from '@dxos/plugin-automation';
+import { Graph } from '@dxos/plugin-explorer/types';
+import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { getSpace } from '@dxos/react-client/echo';
+import { DropdownMenu, IconButton, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+import { StackItem } from '@dxos/react-ui-stack';
+import { DataType } from '@dxos/schema';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '../meta';
+import { ComputeGraph } from '../notebook';
+import { type Notebook } from '../types';
+
+import { NotebookMenu, NotebookStack, type NotebookStackProps } from './NotebookStack';
+import { type TypescriptEditorProps } from './TypescriptEditor';
+
+const INCLUDE_BLUEPRINTS = ['dxos.org/blueprint/assistant', 'dxos.org/blueprint/markdown'];
+
+// TODO(burdon): Support calling named deployed functions (as with sheet).
+
+export type NotebookContainerProps = {
+  role?: string;
+  notebook?: Notebook.Notebook;
+} & Pick<TypescriptEditorProps, 'env'>;
+
+export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) => {
+  const { t } = useTranslation(meta.id);
+  const space = getSpace(notebook);
+  const attendableId = fullyQualifiedId(notebook);
+  const { hasAttention } = useAttention(attendableId);
+
+  // TODO(burdon): Consolidate execution and state (with graph).
+  //  Generalize ComputeGraph evaluation function (using effects).
+  const graph = useMemo(() => notebook && new ComputeGraph(notebook), [notebook]);
+
+  const [queryValues, setQueryValues] = useState<Record<string, any>>({});
+  const handleExecQueries = useCallback(async () => {
+    invariant(space);
+
+    const builder = new QueryBuilder();
+    for (const cell of notebook?.cells ?? []) {
+      if (cell.type === 'query') {
+        if (cell.source?.target) {
+          const source = cell.source.target.content;
+          const { name, filter } = builder.build(source);
+          if (filter) {
+            const ast = Query.select(filter).ast;
+            const view = cell.view?.target;
+            if (!view) {
+              const graph = Graph.make({ query: { ast } });
+              const { view } = await Graph.makeView({ space, presentation: graph });
+              cell.view = Ref.make(view);
+              cell.name = name;
+            } else {
+              view.query.ast = ast;
+            }
+          }
+        }
+
+        if (cell.name && cell.view?.target) {
+          const view = Obj.getSnapshot(cell.view?.target);
+          const query = Query.fromAst(view.query.ast);
+          const result = await space?.db.query(query).run();
+          const objectIds = result?.objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({ ...prev, [cell.name!]: objectIds }));
+        }
+      }
+    }
+  }, [space, notebook, graph]);
+
+  const [promptResults, setPromptResults] = useState<Record<string, string>>({});
+  const handleExecPrompts = useComputeRuntimeCallback(
+    space,
+    Effect.fnUntraced(function* () {
+      invariant(graph);
+
+      const prompts =
+        notebook?.cells
+          .filter((cell) => cell.type === 'prompt')
+          .map((cell) => cell.prompt)
+          .filter(isNonNullable) ?? [];
+
+      for (const prompt of prompts) {
+        yield* runPrompt({
+          prompt,
+          input: { ...queryValues, ...graph.valuesByName.value },
+          onResult: (result) => setPromptResults((prev) => ({ ...prev, [prompt.dxn.toString()]: result })),
+        });
+      }
+    }),
+    [notebook, graph, queryValues],
+  );
+
+  // TODO(burdon): Cache values in context (preserve when switched).
+  const handleCompute = useCallback(async () => {
+    // TODO(burdon): Generalize executors (dependencies).
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [graph, handleExecQueries, handleExecPrompts]);
+
+  const handleRearrange = useCallback<NonNullable<NotebookStackProps['onRearrange']>>(
+    (source, target) => {
+      invariant(notebook);
+      const from = notebook.cells.findIndex((cell) => cell.id === source.id);
+      const to = notebook.cells.findIndex((cell) => cell.id === target.id);
+      if (from != null && to != null) {
+        const cell = notebook.cells.splice(from, 1)[0];
+        if (cell) {
+          notebook.cells.splice(to, 0, cell);
+        }
+      }
+    },
+    [notebook],
+  );
+
+  const handleCellInsert = useCallback<NonNullable<NotebookStackProps['onCellInsert']>>(
+    async (type, after) => {
+      invariant(notebook);
+      const cell: Notebook.Cell = { id: crypto.randomUUID(), type };
+      switch (type) {
+        case 'markdown':
+        case 'script':
+        case 'query': {
+          cell.source = Ref.make(DataType.makeText());
+          break;
+        }
+
+        case 'prompt': {
+          if (space) {
+            const result = await space.db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+            const blueprints = result.objects
+              .filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key))
+              .map((blueprint) => Ref.make(blueprint));
+            cell.prompt = Ref.make(Prompt.make({ instructions: '', blueprints }));
+          }
+          break;
+        }
+      }
+
+      const idx = after ? notebook.cells.findIndex((cell) => cell.id === after) : notebook.cells.length;
+      notebook.cells.splice(idx, 0, cell);
+    },
+    [space, notebook],
+  );
+
+  const handleCellDelete = useCallback<NonNullable<NotebookStackProps['onCellDelete']>>(
+    (id) => {
+      invariant(notebook);
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        notebook.cells.splice(idx, 1);
+      }
+    },
+    [notebook],
+  );
+
+  return (
+    <StackItem.Content toolbar>
+      <Toolbar.Root disabled={!hasAttention} textBlockWidth>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger asChild>
+            <IconButton icon='ph--plus--regular' iconOnly label={t('notebook cell insert label')} />
+          </DropdownMenu.Trigger>
+          <NotebookMenu onCellInsert={handleCellInsert} />
+        </DropdownMenu.Root>
+        <Toolbar.IconButton
+          icon='ph--play--fill'
+          iconOnly
+          label={t('compute label')}
+          classNames='text-green-500'
+          onClick={handleCompute}
+        />
+      </Toolbar.Root>
+      <div role='none' className='flex bs-full overflow-hidden -mis-[1px] -mie-[1px]'>
+        <NotebookStack
+          classNames='container-max-width border-l border-r border-subduedSeparator'
+          space={space}
+          notebook={notebook}
+          graph={graph}
+          env={env}
+          promptResults={promptResults}
+          onRearrange={handleRearrange}
+          onCellInsert={handleCellInsert}
+          onCellDelete={handleCellDelete}
+        />
+      </div>
+    </StackItem.Content>
+  );
+};
+
+export default NotebookContainer;
+
+// TODO(wittjosiah): Factor out. Copied from PromptContainer in stories-assistant.
+const runPrompt = Effect.fn(function* ({
+  prompt,
+  input,
+  onResult,
+}: {
+  prompt: Ref.Ref<Prompt.Prompt>;
+  input: Record<string, any>;
+  onResult: (result: string) => void;
+}) {
+  const inputData: FunctionDefinition.Input<typeof Agent.prompt> = { prompt, input };
+  const tracer = yield* InvocationTracer;
+  const trace = yield* tracer.traceInvocationStart({
+    target: undefined,
+    payload: {
+      data: {},
+    },
+  });
+
+  // Invoke the function.
+  const result = yield* FunctionInvocationService.invokeFunction(Agent.prompt, inputData).pipe(
+    Effect.provide(
+      ComputeEventLogger.layerFromTracing.pipe(
+        Layer.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)),
+      ),
+    ),
+    Effect.exit,
+  );
+
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+      onResult(error.message);
+    },
+    onSuccess: (result: any) => {
+      onResult(result.note);
+    },
+  });
+
+  yield* tracer.traceInvocationEnd({
+    trace,
+    // TODO(dmaretskyi): Might miss errors.
+    exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
+  });
+});

package/src/components/NotebookStack/NotebookCell.tsx

@@ -0,0 +1,208 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { TemplateEditor } from '@dxos/plugin-assistant';
+import { createDocAccessor } from '@dxos/react-client/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { useThemeContext, useTranslation } from '@dxos/react-ui';
+import { QueryEditor, type QueryEditorProps } from '@dxos/react-ui-components';
+import {
+  type BasicExtensionsOptions,
+  Editor,
+  type EditorProps,
+  createBasicExtensions,
+  createDataExtensions,
+  createMarkdownExtensions,
+  createThemeExtensions,
+  decorateMarkdown,
+} from '@dxos/react-ui-editor';
+import { mx } from '@dxos/react-ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '../../meta';
+import { type ComputeGraph } from '../../notebook';
+import { type Notebook } from '../../types';
+import { TypescriptEditor, type TypescriptEditorProps } from '../TypescriptEditor';
+
+import { type NotebookMenuProps } from './NotebookMenu';
+
+const editorStyles = 'p-2 pis-3';
+const valueStyles = 'p-1 pis-3';
+
+export type NotebookCellProps = {
+  space?: Space;
+  graph?: ComputeGraph;
+  dragging?: boolean;
+  cell: Notebook.Cell;
+  promptResults?: Record<string, string>;
+} & (Pick<NotebookMenuProps, 'onCellInsert' | 'onCellDelete'> & Pick<TypescriptEditorProps, 'env'>);
+
+// TODO(burdon): Show evaluation errors.
+export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env }: NotebookCellProps) => {
+  const { t } = useTranslation(meta.id);
+
+  const extensions = useMemo(() => {
+    return cell.source?.target
+      ? [createDataExtensions({ id: cell.id, text: createDocAccessor(cell.source.target, ['content']) })].filter(
+          isNonNullable,
+        )
+      : [];
+  }, [cell.source?.target]);
+
+  const view = cell.view?.target;
+
+  const handleQueryChange = useCallback<NonNullable<QueryEditorProps['onChange']>>(
+    (value: string) => {
+      invariant(cell.source?.target);
+      cell.source.target.content = value;
+    },
+    [cell],
+  );
+
+  switch (cell.type) {
+    case 'markdown':
+      if (!cell.source?.target) {
+        return null;
+      }
+
+      return (
+        <NotebookTextEditor
+          id={cell.id}
+          classNames={editorStyles}
+          initialValue={cell.source.target.content}
+          extensions={extensions}
+        />
+      );
+
+    case 'script':
+      if (!cell.source?.target) {
+        return null;
+      }
+
+      return (
+        <>
+          <TypescriptEditor
+            id={cell.id}
+            role='section'
+            classNames={editorStyles}
+            initialValue={cell.source.target.content}
+            extensions={extensions}
+            env={env}
+            options={{
+              placeholder: t('notebook cell placeholder'),
+              highlightActiveLine: false,
+              lineNumbers: false,
+            }}
+          />
+          <NotebookCellValue cell={cell} graph={graph} />
+        </>
+      );
+
+    case 'query':
+      if (!cell.source?.target) {
+        return null;
+      }
+
+      // TODO(burdon): Remove app-framework deps (via render prop).
+      return (
+        <div className={mx('bs-full overflow-hidden grid', view && !dragging && 'grid-rows-[min-content_1fr]')}>
+          <QueryEditor
+            id={cell.id}
+            classNames={[editorStyles, 'border-b border-subduedSeparator']}
+            db={space?.db}
+            value={cell.source.target.content}
+            onChange={handleQueryChange}
+          />
+          {view && !dragging && <Surface role='section' limit={1} data={{ subject: view }} />}
+        </div>
+      );
+
+    // TODO(burdon): Use streaming response from Chat.
+    case 'prompt':
+      if (!cell.prompt?.target) {
+        return null;
+      }
+
+      return (
+        <>
+          <TemplateEditor
+            id={cell.id}
+            template={cell.prompt.target.instructions}
+            lineNumbers={false}
+            classNames={editorStyles}
+          />
+          <NotebookPromptResult cell={cell} promptResults={promptResults} />
+        </>
+      );
+
+    default:
+      return null;
+  }
+};
+
+const NotebookCellValue = ({ cell, graph }: NotebookCellProps) => {
+  const name = graph?.expressions.value[cell.id]?.name;
+  const value = graph?.getValue(cell.id);
+  if (value == null) {
+    return null;
+  }
+
+  return (
+    <div
+      className={mx(
+        'flex is-full bg-groupSurface border-t border-subduedSeparator text-description font-mono',
+        valueStyles,
+      )}
+    >
+      {name && (
+        <>
+          <span className='text-successText'>{name}</span>
+          <span className='text-description'>&nbsp;=&nbsp;</span>
+        </>
+      )}
+      <span>{value}</span>
+    </div>
+  );
+};
+
+const NotebookPromptResult = ({ cell, promptResults }: NotebookCellProps) => {
+  if (!cell.prompt) {
+    return null;
+  }
+
+  const value = promptResults?.[cell.prompt.dxn.toString()];
+  if (value == null) {
+    return null;
+  }
+
+  return (
+    <div className={mx('flex is-full bg-groupSurface text-description border-t border-subduedSeparator', valueStyles)}>
+      <NotebookTextEditor readOnly value={value} />
+    </div>
+  );
+};
+
+const NotebookTextEditor = ({
+  extensions: extensionsParam,
+  readOnly,
+  ...props
+}: EditorProps & Pick<BasicExtensionsOptions, 'readOnly'>) => {
+  const { t } = useTranslation(meta.id);
+  const { themeMode } = useThemeContext();
+  const extensions = useMemo(() => {
+    return [
+      createBasicExtensions({ placeholder: t('notebook markdown placeholder'), readOnly }),
+      createThemeExtensions({ themeMode, syntaxHighlighting: true }),
+      createMarkdownExtensions(),
+      decorateMarkdown(),
+      extensionsParam,
+    ].filter(isNonNullable);
+  }, [extensionsParam]);
+
+  return <Editor {...props} extensions={extensions} moveToEnd />;
+};

package/src/components/NotebookStack/NotebookMenu.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { DropdownMenu, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '../../meta';
+import { type Notebook } from '../../types';
+
+export type NotebookMenuProps = {
+  cell?: Notebook.Cell;
+  onCellInsert?: (type: Notebook.CellType, after: string | undefined) => void;
+  onCellDelete?: (id: string) => void;
+};
+
+// TODO(burdon): Better way to organize menu?
+export const NotebookMenu = ({ cell, onCellInsert, onCellDelete }: NotebookMenuProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <DropdownMenu.Portal>
+      <DropdownMenu.Content>
+        <DropdownMenu.Viewport>
+          <DropdownMenu.Item onClick={() => onCellInsert?.('script', cell?.id)}>
+            {t('notebook cell insert script label')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Item onClick={() => onCellInsert?.('prompt', cell?.id)}>
+            {t('notebook cell insert prompt label')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Item onClick={() => onCellInsert?.('query', cell?.id)}>
+            {t('notebook cell insert query label')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Item onClick={() => onCellInsert?.('markdown', cell?.id)}>
+            {t('notebook cell insert markdown label')}
+          </DropdownMenu.Item>
+          {cell && onCellDelete && (
+            <DropdownMenu.Item onClick={() => onCellDelete?.(cell.id)}>
+              {t('notebook cell delete label')}
+            </DropdownMenu.Item>
+          )}
+        </DropdownMenu.Viewport>
+        <DropdownMenu.Arrow />
+      </DropdownMenu.Content>
+    </DropdownMenu.Portal>
+  );
+};