@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/dist/lib/node-esm/{NotebookContainer-QY5NJGJI.mjs → NotebookContainer-DQGZ6QHI.mjs}

@@ -2,30 +2,41 @@ import { createRequire } from 'node:module';const require = createRequire(import
 import {
   NotebookMenu,
   NotebookStack
-} from "./chunk-67OVZHI3.mjs";
-import "./chunk-VRSDE4CI.mjs";
+} from "./chunk-3QBXN6QC.mjs";
+import "./chunk-SLU3KRV3.mjs";
 import {
   meta
-} from "./chunk-OG2SIKHE.mjs";
+} from "./chunk-5HSJPAK7.mjs";
+import "./chunk-HSLMI22Q.mjs";
 
 // src/components/NotebookContainer.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import React, { useCallback, useMemo } from "react";
-import { Ref } from "@dxos/echo";
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import React, { useCallback, useContext, 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 { FunctionInvocationService, TracingService } from "@dxos/functions";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { Assistant } from "@dxos/plugin-assistant";
-import { getSpace } from "@dxos/react-client/echo";
+import { log as log2 } from "@dxos/log";
+import { useComputeRuntimeCallback } from "@dxos/plugin-automation";
+import { Graph } from "@dxos/plugin-explorer/types";
 import { DropdownMenu, IconButton, Toolbar, useTranslation } from "@dxos/react-ui";
-import { StackItem } from "@dxos/react-ui-stack";
-import { DataType } from "@dxos/schema";
+import { Layout } from "@dxos/react-ui";
+import { useAttention } from "@dxos/react-ui-attention";
+import { Text, View } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
 
-// src/notebook/notebook.ts
-import { signal } from "@preact/signals-core";
+// src/notebook/compute-graph.ts
+import { Atom } from "@effect-atom/atom-react";
 import { log } from "@dxos/log";
 
 // src/notebook/eval.ts
 import { trim } from "@dxos/util";
-var evalScript = (code, deps = {}) => {
+var evalScript = async (code, deps = {}) => {
   const sandbox = {
     ...deps,
     // Block access to global objects.
@@ -57,11 +68,11 @@ var evalScript = (code, deps = {}) => {
   };
   const sandboxKeys = Object.keys(sandbox);
   const sandboxValues = Object.values(sandbox);
-  const fn = new Function(...sandboxKeys, trim`
+  const fn2 = new Function(...sandboxKeys, trim`
       'use strict';
       return ${code};
     `);
-  return fn(...sandboxValues);
+  return fn2(...sandboxValues);
 };
 var builtIns = /* @__PURE__ */ new Set([
   // Types.
@@ -103,19 +114,6 @@ var systemDefinitions = trim`
 import { createSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
 import ts from "typescript";
 import { invariant } from "@dxos/invariant";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/vfs-parser.ts";
 var systemFiles = [
   {
@@ -124,6 +122,16 @@ var systemFiles = [
   }
 ];
 var VirtualTypeScriptParser = class {
+  compilerOptions = {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    forceConsistentCasingInfilenames: true,
+    jsx: ts.JsxEmit.React,
+    noLib: true
+  };
   /**
   * Parse a single expression or statement.
   */
@@ -372,54 +380,70 @@ var VirtualTypeScriptParser = class {
     const system = createSystem(fileMap);
     return createVirtualTypeScriptEnvironment(system, allFiles.map(({ filename }) => filename), ts, this.compilerOptions);
   }
-  constructor() {
-    _define_property(this, "compilerOptions", {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.ESNext,
-      strict: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      forceConsistentCasingInfilenames: true,
-      jsx: ts.JsxEmit.React,
-      noLib: true
-    });
-  }
 };
 
-// src/notebook/notebook.ts
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/notebook.ts";
+// src/notebook/compute-graph.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/compute-graph.ts";
 var ComputeGraph = class {
+  _notebook;
+  _registry;
+  _parser = new VirtualTypeScriptParser();
+  _expressionsAtom = Atom.make({});
+  _valuesByCellIdAtom = Atom.make({});
+  _valuesByNameAtom = Atom.make({});
+  constructor(_notebook, _registry) {
+    this._notebook = _notebook;
+    this._registry = _registry;
+  }
   /**
-  * Parsed expressions by cell ID.
+  * Atom for parsed expressions by cell ID.
   */
   get expressions() {
-    return this._expressions;
+    return this._expressionsAtom;
   }
   /**
-  * Computed values by cell ID.
+  * Get current expressions by cell ID.
+  */
+  getExpressions() {
+    return this._registry.get(this._expressionsAtom);
+  }
+  /**
+  * Atom for computed values by cell ID.
   */
   get values() {
-    return this._values;
+    return this._valuesByCellIdAtom;
+  }
+  /**
+  * Get computed values by cell ID.
+  */
+  getValues() {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+  /**
+  * Atom for computed values by name.
+  */
+  get valuesByName() {
+    return this._valuesByNameAtom;
+  }
+  /**
+  * Get current values by name.
+  */
+  getValuesByName() {
+    return this._registry.get(this._valuesByNameAtom);
+  }
+  /**
+  * Get computed value by cell ID.
+  */
+  getValue(cellId) {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
   /**
   * Compute values.
   */
-  evaluate() {
+  async evaluate() {
     const { expressions, dependencyGraph } = this.parse();
-    this._values.value = {};
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
     const cellExpressions = /* @__PURE__ */ new Map();
     Object.entries(expressions).forEach(([id, expr]) => {
       cellExpressions.set(id, expr);
@@ -434,19 +458,19 @@ var ComputeGraph = class {
           cellId
         }, {
           F: __dxlog_file2,
-          L: 64,
+          L: 105,
           S: this,
           C: (f, a) => f(...a)
         });
         continue;
       }
-      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script?.target?.content;
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
       if (!cellSource) {
         log.error("no source for cell", {
           cellId
         }, {
           F: __dxlog_file2,
-          L: 70,
+          L: 111,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -463,14 +487,14 @@ var ComputeGraph = class {
             if (rhs.endsWith(";")) {
               rhs = rhs.slice(0, -1).trim();
             }
-            const result = evalScript(rhs, valuesByName);
+            const result = await this.eval(rhs, valuesByName);
             valuesByName[expr.name] = result;
             if (typeof result !== "function") {
               valuesByCellId[cellId] = result;
             }
           }
         } else {
-          const result = evalScript(cellSource, valuesByName);
+          const result = await this.eval(cellSource, valuesByName);
           valuesByCellId[cellId] = result;
         }
       } catch (error) {
@@ -479,21 +503,25 @@ var ComputeGraph = class {
           error
         }, {
           F: __dxlog_file2,
-          L: 105,
+          L: 147,
           S: this,
           C: (f, a) => f(...a)
         });
       }
     }
-    this._values.value = valuesByCellId;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
+  async eval(source, values) {
+    return evalScript(source, values);
+  }
   /**
   * Parse expressions.
   */
   parse() {
     const expressions = this._notebook.cells.filter((cell) => cell.type === "script").reduce((acc, cell) => {
-      const text = cell.script?.target?.content.trim();
+      const text = cell.source?.target?.content.trim();
       if (text) {
         const parsed = this._parser.parseExpression(text);
         acc[cell.id] = parsed;
@@ -501,7 +529,7 @@ var ComputeGraph = class {
       return acc;
     }, {});
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return {
       expressions,
       dependencyGraph
@@ -540,145 +568,279 @@ var ComputeGraph = class {
     });
     return graph;
   }
-  constructor(_notebook) {
-    _define_property2(this, "_notebook", void 0);
-    _define_property2(this, "_parser", void 0);
-    _define_property2(this, "_expressions", void 0);
-    _define_property2(this, "_values", void 0);
-    this._notebook = _notebook;
-    this._parser = new VirtualTypeScriptParser();
-    this._expressions = signal({});
-    this._values = signal({});
-  }
 };
 
 // src/components/NotebookContainer.tsx
 var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/NotebookContainer.tsx";
-var NotebookContainer = ({ notebook, env }) => {
-  var _effect = _useSignals();
-  try {
-    const { t } = useTranslation(meta.id);
-    const space = getSpace(notebook);
-    const graph = useMemo(() => notebook && new ComputeGraph(notebook), [
-      notebook
-    ]);
-    const handleCompute = useCallback(() => {
-      graph?.evaluate();
-    }, [
-      graph
-    ]);
-    const handleRearrange = useCallback((source, target) => {
-      invariant2(notebook, void 0, {
-        F: __dxlog_file3,
-        L: 41,
-        S: void 0,
-        A: [
-          "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);
+var INCLUDE_BLUEPRINTS = [
+  "dxos.org/blueprint/assistant",
+  "dxos.org/blueprint/markdown"
+];
+var NotebookContainer = ({ role, subject: notebook, env }) => {
+  const { t } = useTranslation(meta.id);
+  const registry = useContext(RegistryContext);
+  const db = notebook && Obj.getDatabase(notebook);
+  const attendableId = notebook ? Obj.getDXN(notebook).toString() : "";
+  const { hasAttention } = useAttention(attendableId);
+  const graph = useMemo(() => notebook && new ComputeGraph(notebook, registry), [
+    notebook,
+    registry
+  ]);
+  const [queryValues, setQueryValues] = useState({});
+  const handleExecQueries = useCallback(async () => {
+    invariant2(db, void 0, {
+      F: __dxlog_file3,
+      L: 54,
+      S: void 0,
+      A: [
+        "db",
+        ""
+      ]
+    });
+    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 graph2 = cell.graph?.target;
+            if (!graph2) {
+              const { view } = await View.makeFromDatabase({
+                db
+              });
+              const newGraph = Graph.make({
+                query: {
+                  ast
+                },
+                view
+              });
+              Obj.change(notebook, (n) => {
+                const c = n.cells.find((c2) => c2.id === cell.id);
+                if (c) {
+                  c.graph = Ref.make(newGraph);
+                  c.name = name;
+                }
+              });
+            } else {
+              Obj.change(graph2, (g) => {
+                g.query.ast = ast;
+              });
+            }
+          }
+        }
+        if (cell.name && cell.graph?.target) {
+          const graph2 = Obj.getSnapshot(cell.graph?.target);
+          const query = Query.fromAst(graph2.query.ast);
+          const objects = await db.query(query).run();
+          const objectIds = objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({
+            ...prev,
+            [cell.name]: objectIds
+          }));
         }
       }
-    }, [
-      notebook
-    ]);
-    const handleCellInsert = useCallback((type, after) => {
-      invariant2(notebook, void 0, {
-        F: __dxlog_file3,
-        L: 56,
-        S: void 0,
-        A: [
-          "notebook",
-          ""
-        ]
+    }
+  }, [
+    db,
+    notebook,
+    graph
+  ]);
+  const [promptResults, setPromptResults] = useState({});
+  const handleExecPrompts = useComputeRuntimeCallback(db?.spaceId, Effect.fnUntraced(function* () {
+    invariant2(graph, void 0, {
+      F: __dxlog_file3,
+      L: 98,
+      S: this,
+      A: [
+        "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.getValuesByName()
+        },
+        onResult: (result) => setPromptResults((prev) => ({
+          ...prev,
+          [prompt.dxn.toString()]: result
+        }))
       });
-      const cell = {
-        id: crypto.randomUUID(),
-        type
-      };
-      switch (type) {
-        case "markdown":
-        case "script":
-        case "query": {
-          cell.script = Ref.make(DataType.makeText());
-          break;
+    }
+  }), [
+    notebook,
+    graph,
+    queryValues
+  ]);
+  const handleCompute = useCallback(async () => {
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [
+    graph,
+    handleExecQueries,
+    handleExecPrompts
+  ]);
+  const handleRearrange = useCallback((source, target) => {
+    invariant2(notebook, void 0, {
+      F: __dxlog_file3,
+      L: 131,
+      S: void 0,
+      A: [
+        "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) {
+      Obj.change(notebook, (n) => {
+        const cell = n.cells.splice(from, 1)[0];
+        if (cell) {
+          n.cells.splice(to, 0, cell);
         }
-        case "prompt": {
-          if (space) {
-            cell.chat = Ref.make(Assistant.makeChat({
-              queue: space.queues.create()
-            }));
-          }
-          break;
+      });
+    }
+  }, [
+    notebook
+  ]);
+  const handleCellInsert = useCallback(async (type, after) => {
+    invariant2(notebook, void 0, {
+      F: __dxlog_file3,
+      L: 148,
+      S: void 0,
+      A: [
+        "notebook",
+        ""
+      ]
+    });
+    const cell = {
+      id: crypto.randomUUID(),
+      type
+    };
+    switch (type) {
+      case "markdown":
+      case "script":
+      case "query": {
+        cell.source = Ref.make(Text.make());
+        break;
+      }
+      case "prompt": {
+        if (db) {
+          const objects = await db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+          const blueprints = 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((cell2) => cell2.id === after) : notebook.cells.length;
-      notebook.cells.splice(idx, 0, cell);
-    }, [
-      space,
-      notebook
-    ]);
-    const handleCellDelete = useCallback((id) => {
-      invariant2(notebook, void 0, {
-        F: __dxlog_file3,
-        L: 82,
-        S: void 0,
-        A: [
-          "notebook",
-          ""
-        ]
+    }
+    const idx = after ? notebook.cells.findIndex((cell2) => cell2.id === after) : notebook.cells.length;
+    Obj.change(notebook, (n) => {
+      n.cells.splice(idx, 0, cell);
+    });
+  }, [
+    db,
+    notebook
+  ]);
+  const handleCellDelete = useCallback((id) => {
+    invariant2(notebook, void 0, {
+      F: __dxlog_file3,
+      L: 180,
+      S: void 0,
+      A: [
+        "notebook",
+        ""
+      ]
+    });
+    const idx = notebook.cells.findIndex((cell) => cell.id === id);
+    if (idx !== -1) {
+      Obj.change(notebook, (n) => {
+        n.cells.splice(idx, 1);
       });
-      const idx = notebook.cells.findIndex((cell) => cell.id === id);
-      if (idx !== -1) {
-        notebook.cells.splice(idx, 1);
-      }
-    }, [
-      notebook
-    ]);
-    return /* @__PURE__ */ React.createElement(StackItem.Content, {
-      toolbar: true
-    }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
-      textBlockWidth: true
-    }, /* @__PURE__ */ React.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React.createElement(DropdownMenu.Trigger, {
-      asChild: true
-    }, /* @__PURE__ */ React.createElement(IconButton, {
-      icon: "ph--plus--regular",
-      iconOnly: true,
-      label: t("notebook cell insert label")
-    })), /* @__PURE__ */ React.createElement(NotebookMenu, {
-      onCellInsert: handleCellInsert
-    })), /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
-      icon: "ph--play--fill",
-      iconOnly: true,
-      label: t("compute label"),
-      classNames: "text-green-500",
-      onClick: handleCompute
-    })), /* @__PURE__ */ React.createElement("div", {
-      role: "none",
-      className: "flex bs-full overflow-hidden -mis-[1px] -mie-[1px]"
-    }, /* @__PURE__ */ React.createElement(NotebookStack, {
-      classNames: "container-max-width border-l border-r border-subduedSeparator",
-      space,
-      notebook,
-      graph,
-      env,
-      onRearrange: handleRearrange,
-      onCellInsert: handleCellInsert,
-      onCellDelete: handleCellDelete
-    })));
-  } finally {
-    _effect.f();
-  }
+    }
+  }, [
+    notebook
+  ]);
+  return /* @__PURE__ */ React.createElement(Layout.Main, {
+    role,
+    toolbar: true
+  }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+    disabled: !hasAttention,
+    textBlockWidth: true
+  }, /* @__PURE__ */ React.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React.createElement(DropdownMenu.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(IconButton, {
+    icon: "ph--plus--regular",
+    iconOnly: true,
+    label: t("notebook cell insert label")
+  })), /* @__PURE__ */ React.createElement(NotebookMenu, {
+    onCellInsert: handleCellInsert
+  })), /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
+    icon: "ph--play--fill",
+    iconOnly: true,
+    label: t("compute label"),
+    classNames: "text-green-500",
+    onClick: handleCompute
+  })), /* @__PURE__ */ React.createElement("div", {
+    role: "none",
+    className: "flex bs-full overflow-hidden -mis-[1px] -mie-[1px]"
+  }, /* @__PURE__ */ React.createElement(NotebookStack, {
+    classNames: "container-max-width border-l border-r border-subduedSeparator",
+    db,
+    notebook,
+    graph,
+    env,
+    promptResults,
+    onRearrange: handleRearrange,
+    onCellInsert: handleCellInsert,
+    onCellDelete: handleCellDelete
+  })));
 };
 var NotebookContainer_default = NotebookContainer;
+var runPrompt = Effect.fn(function* ({ prompt, input, onResult }) {
+  const inputData = {
+    prompt,
+    input
+  };
+  const tracer = yield* TracingService;
+  const trace = yield* tracer.traceInvocationStart({
+    target: void 0,
+    payload: {
+      data: {}
+    }
+  });
+  const result = yield* FunctionInvocationService.invokeFunction(Agent.prompt, inputData).pipe(Effect.provide(trace.invocationTraceQueue ? TracingService.layerInvocation(trace) : TracingService.layerNoop), Effect.exit);
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log2.error(error.message, error.cause ?? error.stack, {
+        F: __dxlog_file3,
+        L: 258,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      onResult(error.message);
+    },
+    onSuccess: (result2) => {
+      onResult(result2.note);
+    }
+  });
+  yield* tracer.traceInvocationEnd({
+    trace,
+    // TODO(dmaretskyi): Might miss errors.
+    exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : void 0
+  });
+});
 export {
   NotebookContainer,
   NotebookContainer_default as default
 };
-//# sourceMappingURL=NotebookContainer-QY5NJGJI.mjs.map
+//# sourceMappingURL=NotebookContainer-DQGZ6QHI.mjs.map