@dxos/plugin-script 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/dist/lib/{browser/NotebookContainer-LVGRPFY3.mjs → neutral/NotebookArticle-NV4AHOOS.mjs}

@@ -1,30 +1,34 @@
-import {
-  NotebookMenu,
-  NotebookStack
-} from "./chunk-75LH4EUR.mjs";
-import "./chunk-N6M34EUC.mjs";
-import {
-  meta
-} from "./chunk-EZVXV6DA.mjs";
+import "./chunk-J5LGTIGS.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";
+// src/containers/NotebookArticle/NotebookArticle.tsx
+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 { useSpaceCallback } from "@dxos/app-framework/ui";
+import { AgentPrompt } from "@dxos/assistant-toolkit";
+import { Blueprint, Routine } from "@dxos/compute";
+import { Operation } from "@dxos/compute";
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+import { QueryBuilder } from "@dxos/echo-query";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { Assistant } from "@dxos/plugin-assistant";
-import { getSpace } from "@dxos/react-client/echo";
-import { DropdownMenu, IconButton, Toolbar, useTranslation } from "@dxos/react-ui";
-import { StackItem } from "@dxos/react-ui-stack";
-import { DataType } from "@dxos/schema";
+import { log as log2 } from "@dxos/log";
+import { Graph } from "@dxos/plugin-explorer";
+import { DropdownMenu, IconButton, Panel, Toolbar, useTranslation } from "@dxos/react-ui";
+import { useAttention } from "@dxos/react-ui-attention";
+import { Text, ViewModel } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
+import { NotebookMenu, NotebookStack } from "#components";
+import { meta } from "#meta";
 
-// 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.
@@ -56,11 +60,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.
@@ -102,19 +106,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 = [
   {
@@ -123,19 +114,22 @@ var systemFiles = [
   }
 ];
 var VirtualTypeScriptParser = class {
+  compilerOptions = {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    forceConsistentCasingInfilenames: true,
+    jsx: ts.JsxEmit.React,
+    noLib: true
+  };
   /**
   * Parse a single expression or statement.
   */
   parseExpression(input) {
-    invariant(input.trim() !== "", "input must not be empty", {
-      F: __dxlog_file,
-      L: 57,
-      S: this,
-      A: [
-        "input.trim() !== ''",
-        "'input must not be empty'"
-      ]
-    });
+    invariant(input.trim() !== "", "input must not be empty", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 34, S: this, A: ["input.trim() !== ''", "'input must not be empty'"] });
     const files = [
       {
         filename: "/temp.ts",
@@ -175,7 +169,9 @@ var VirtualTypeScriptParser = class {
     const typeChecker = env.languageService.getProgram()?.getTypeChecker();
     files.forEach((file) => {
       const sourceFile = env.getSourceFile(file.filename);
-      if (!sourceFile || !typeChecker) return;
+      if (!sourceFile || !typeChecker) {
+        return;
+      }
       const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
       results.push(...fileResults);
     });
@@ -259,7 +255,9 @@ var VirtualTypeScriptParser = class {
   * Extract parameter information from a signature.
   */
   extractParameters(signature, typeChecker) {
-    if (!signature) return [];
+    if (!signature) {
+      return [];
+    }
     return signature.parameters.map((param) => ({
       name: param.getName(),
       type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(param, param.valueDeclaration))
@@ -371,54 +369,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;
+  }
+  /**
+  * Get current expressions by cell ID.
+  */
+  getExpressions() {
+    return this._registry.get(this._expressionsAtom);
   }
   /**
-  * Computed values by cell ID.
+  * 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);
@@ -431,24 +445,14 @@ var ComputeGraph = class {
       if (!expr) {
         log.error("no expression for cell", {
           cellId
-        }, {
-          F: __dxlog_file2,
-          L: 64,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 78, S: this });
         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,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 85, S: this });
         continue;
       }
       try {
@@ -462,37 +466,36 @@ 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) {
         log.error("error evaluating cell", {
           cellId,
           error
-        }, {
-          F: __dxlog_file2,
-          L: 105,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 120, S: this });
       }
     }
-    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;
@@ -500,7 +503,7 @@ var ComputeGraph = class {
       return acc;
     }, {});
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return {
       expressions,
       dependencyGraph
@@ -539,145 +542,222 @@ 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);
+// src/containers/NotebookArticle/NotebookArticle.tsx
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/containers/NotebookArticle/NotebookArticle.tsx";
+var INCLUDE_BLUEPRINTS = [
+  "org.dxos.blueprint.assistant",
+  "org.dxos.blueprint.database",
+  "org.dxos.blueprint.markdown"
+];
+var NotebookArticle = ({ role, subject: notebook, attendableId, env }) => {
+  const { t } = useTranslation(meta.id);
+  const registry = useContext(RegistryContext);
+  const db = Obj.getDatabase(notebook);
+  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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 43, 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 ViewModel.makeFromDatabase({
+                db
+              });
+              const newGraph = Graph.make({
+                query: {
+                  ast
+                },
+                view
+              });
+              Obj.update(notebook, (obj) => {
+                const c = obj.cells.find((c2) => c2.id === cell.id);
+                if (c) {
+                  c.graph = Ref.make(newGraph);
+                  c.name = name;
+                }
+              });
+            } else {
+              Obj.update(graph2, (graph3) => {
+                graph3.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 = useSpaceCallback(db?.spaceId, [], Effect.fnUntraced(function* () {
+    invariant2(graph, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 96, 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.uri]: 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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 128, 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.update(notebook, (notebook2) => {
+        const cell = notebook2.cells.splice(from, 1)[0];
+        if (cell) {
+          notebook2.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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 143, 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) => {
+            const key = Obj.getMeta(blueprint).key;
+            return key !== void 0 && INCLUDE_BLUEPRINTS.includes(key);
+          }).map((blueprint) => Ref.make(blueprint));
+          cell.prompt = Ref.make(Routine.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.update(notebook, (notebook2) => {
+      notebook2.cells.splice(idx, 0, cell);
+    });
+  }, [
+    db,
+    notebook
+  ]);
+  const handleCellDelete = useCallback((id) => {
+    invariant2(notebook, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 181, S: void 0, A: ["notebook", ""] });
+    const idx = notebook.cells.findIndex((cell) => cell.id === id);
+    if (idx !== -1) {
+      Obj.update(notebook, (notebook2) => {
+        notebook2.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(Panel.Root, {
+    role,
+    className: "dx-document"
+  }, /* @__PURE__ */ React.createElement(Panel.Toolbar, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+    disabled: !hasAttention
+  }, /* @__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-success-text",
+    onClick: handleCompute
+  }))), /* @__PURE__ */ React.createElement(Panel.Content, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(NotebookStack, {
+    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 result = yield* Operation.invoke(AgentPrompt, inputData).pipe(Effect.orDie, Effect.exit);
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log2.error(error.message, error.cause ?? error.stack, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 236, S: this });
+      onResult(error.message);
+    },
+    onSuccess: (result2) => {
+      onResult(result2.note);
+    }
+  });
+});
 export {
-  NotebookContainer,
-  NotebookContainer_default as default
+  NotebookArticle as default
 };
-//# sourceMappingURL=NotebookContainer-LVGRPFY3.mjs.map
+//# sourceMappingURL=NotebookArticle-NV4AHOOS.mjs.map