Merge pull request #125 from biggraph/darabos-code-files

biome.json

@@ -1,4 +1,7 @@
 {
+  "files": {
+    "ignore": ["**/*.lynxkite.json"]
+  },
   "formatter": {
     "ignore": ["**/node_modules/**", "**/dist/**"],
     "lineWidth": 100,
@@ -21,6 +24,7 @@
         "useKeyWithClickEvents": "off",
         "useValidAnchor": "off",
         "useButtonType": "off",
+        "noAutofocus": "off",
         "noNoninteractiveTabindex": "off"
       }
     }

examples/fake_data.py

@@ -0,0 +1,16 @@
+from lynxkite.core.ops import op
+from faker import Faker
+import pandas as pd
+
+faker = Faker()
+
+
+@op("LynxKite Graph Analytics", "Fake data")
+def fake(*, n=10):
+    df = pd.DataFrame(
+        {
+            "name": [faker.name() for _ in range(n)],
+            "address": [faker.address() for _ in range(n)],
+        }
+    )
+    return df

examples/requirements.txt

@@ -0,0 +1 @@
+Faker

examples/word2vec.py

@@ -0,0 +1,26 @@
+from lynxkite.core.ops import op
+import staticvectors
+import pandas as pd
+
+ENV = "LynxKite Graph Analytics"
+
+
+@op(ENV, "Word2vec for the top 1000 words", slow=True)
+def word2vec_1000():
+    model = staticvectors.StaticVectors("neuml/word2vec-quantized")
+    df = pd.read_csv(
+        "https://gist.githubusercontent.com/deekayen/4148741/raw/98d35708fa344717d8eee15d11987de6c8e26d7d/1-1000.txt",
+        names=["word"],
+    )
+    df["embedding"] = model.embeddings(df.word.tolist()).tolist()
+    return df
+
+
+@op(ENV, "Take first N")
+def first_n(df: pd.DataFrame, *, n=10):
+    return df.head(n)
+
+
+@op(ENV, "Sample N")
+def sample_n(df: pd.DataFrame, *, n=10):
+    return df.sample(n)

lynxkite-app/src/lynxkite_app/crdt.py

@@ -26,11 +26,11 @@ def ws_exception_handler(exception, log):
     return True
 
 
-class WebsocketServer(pycrdt_websocket.WebsocketServer):
+class WorkspaceWebsocketServer(pycrdt_websocket.WebsocketServer):
     async def init_room(self, name: str) -> pycrdt_websocket.YRoom:
         """Initialize a room for the workspace with the given name.
 
-        The workspace is loaded from "crdt_data" if it exists there, or from "data", or a new workspace is created.
+        The workspace is loaded from ".crdt" if it exists there, or from a JSON file, or a new workspace is created.
         """
         crdt_path = pathlib.Path(".crdt")
         path = crdt_path / f"{name}.crdt"
@@ -82,6 +82,37 @@ class WebsocketServer(pycrdt_websocket.WebsocketServer):
         return room
 
 
+class CodeWebsocketServer(WorkspaceWebsocketServer):
+    async def init_room(self, name: str) -> pycrdt_websocket.YRoom:
+        """Initialize a room for a text document with the given name."""
+        crdt_path = pathlib.Path(".crdt")
+        path = crdt_path / f"{name}.crdt"
+        assert path.is_relative_to(crdt_path)
+        ystore = pycrdt_websocket.ystore.FileYStore(path)
+        ydoc = pycrdt.Doc()
+        ydoc["text"] = text = pycrdt.Text()
+        # Replay updates from the store.
+        try:
+            for update, timestamp in [(item[0], item[-1]) async for item in ystore.read()]:
+                ydoc.apply_update(update)
+        except pycrdt_websocket.ystore.YDocNotFound:
+            pass
+        if len(text) == 0:
+            if os.path.exists(name):
+                with open(name) as f:
+                    text += f.read()
+        room = pycrdt_websocket.YRoom(
+            ystore=ystore, ydoc=ydoc, exception_handler=ws_exception_handler
+        )
+        room.text = text
+
+        def on_change(changes):
+            asyncio.create_task(code_changed(name, changes, text))
+
+        text.observe(on_change)
+        return room
+
+
 last_ws_input = None
 
 
@@ -233,6 +264,7 @@ async def execute(name: str, ws_crdt: pycrdt.Map, ws_pyd: workspace.Workspace, d
     assert path.is_relative_to(cwd), "Provided workspace path is invalid"
     # Save user changes before executing, in case the execution fails.
     workspace.save(ws_pyd, path)
+    ops.load_user_scripts(name)
     ws_pyd._crdt = ws_crdt
     with ws_crdt.doc.transaction():
         for nc, np in zip(ws_crdt["nodes"], ws_pyd.nodes):
@@ -246,14 +278,21 @@ async def execute(name: str, ws_crdt: pycrdt.Map, ws_pyd: workspace.Workspace, d
     print(f"Finished running {name} in {ws_pyd.env}.")
 
 
+async def code_changed(name: str, changes: pycrdt.TextEvent, text: pycrdt.Text):
+    # TODO: Make this more fancy?
+    with open(name, "w") as f:
+        f.write(str(text).strip() + "\n")
+
+
 @contextlib.asynccontextmanager
 async def lifespan(app):
-    global websocket_server
-    websocket_server = WebsocketServer(
-        auto_clean_rooms=False,
-    )
-    async with websocket_server:
-        yield
+    global ws_websocket_server
+    global code_websocket_server
+    ws_websocket_server = WorkspaceWebsocketServer(auto_clean_rooms=False)
+    code_websocket_server = CodeWebsocketServer(auto_clean_rooms=False)
+    async with ws_websocket_server:
+        async with code_websocket_server:
+            yield
     print("closing websocket server")
 
 
@@ -264,5 +303,12 @@ def sanitize_path(path):
 @router.websocket("/ws/crdt/{room_name}")
 async def crdt_websocket(websocket: fastapi.WebSocket, room_name: str):
     room_name = sanitize_path(room_name)
-    server = pycrdt_websocket.ASGIServer(websocket_server)
+    server = pycrdt_websocket.ASGIServer(ws_websocket_server)
+    await server({"path": room_name}, websocket._receive, websocket._send)
+
+
+@router.websocket("/ws/code/crdt/{room_name}")
+async def code_crdt_websocket(websocket: fastapi.WebSocket, room_name: str):
+    room_name = sanitize_path(room_name)
+    server = pycrdt_websocket.ASGIServer(code_websocket_server)
     await server({"path": room_name}, websocket._receive, websocket._send)

lynxkite-app/src/lynxkite_app/main.py

@@ -26,6 +26,7 @@ def detect_plugins():
 
 
 lynxkite_plugins = detect_plugins()
+ops.save_catalogs("plugins loaded")
 
 app = fastapi.FastAPI(lifespan=crdt.lifespan)
 app.include_router(crdt.router)
@@ -33,7 +34,8 @@ app.add_middleware(GZipMiddleware)
 
 
 @app.get("/api/catalog")
-def get_catalog():
+def get_catalog(workspace: str):
+    ops.load_user_scripts(workspace)
     return {k: {op.name: op.model_dump() for op in v.values()} for k, v in ops.CATALOGS.items()}
 
 
@@ -82,6 +84,15 @@ class DirectoryEntry(pydantic.BaseModel):
     type: str
 
 
+def _get_path_type(path: pathlib.Path) -> str:
+    if path.is_dir():
+        return "directory"
+    elif path.suffixes[-2:] == [".lynxkite", ".json"]:
+        return "workspace"
+    else:
+        return "file"
+
+
 @app.get("/api/dir/list")
 def list_dir(path: str):
     path = data_path / path
@@ -90,7 +101,7 @@ def list_dir(path: str):
         [
             DirectoryEntry(
                 name=str(p.relative_to(data_path)),
-                type="directory" if p.is_dir() else "workspace",
+                type=_get_path_type(p),
             )
             for p in path.iterdir()
             if not p.name.startswith(".")

lynxkite-app/tests/test_main.py

@@ -22,7 +22,7 @@ def test_detect_plugins_with_plugins():
 
 
 def test_get_catalog():
-    response = client.get("/api/catalog")
+    response = client.get("/api/catalog?workspace=test")
     assert response.status_code == 200
 
 
@@ -59,15 +59,22 @@ def test_save_and_load():
 def test_list_dir():
     test_dir = pathlib.Path() / str(uuid.uuid4())
     test_dir.mkdir(parents=True, exist_ok=True)
-    test_file = test_dir / "test_file.txt"
-    test_file.touch()
+    dir = test_dir / "test_dir"
+    dir.mkdir(exist_ok=True)
+    file = test_dir / "test_file.txt"
+    file.touch()
+    ws = test_dir / "test_workspace.lynxkite.json"
+    ws.touch()
     response = client.get(f"/api/dir/list?path={str(test_dir)}")
     assert response.status_code == 200
-    assert len(response.json()) == 1
-    assert response.json()[0]["name"] == f"{test_dir}/test_file.txt"
-    assert response.json()[0]["type"] == "workspace"
-    test_file.unlink()
-    test_dir.rmdir()
+    assert response.json() == [
+        {"name": f"{test_dir}/test_dir", "type": "directory"},
+        {"name": f"{test_dir}/test_file.txt", "type": "file"},
+        {"name": f"{test_dir}/test_workspace.lynxkite.json", "type": "workspace"},
+    ]
+    file.unlink()
+    ws.unlink()
+    dir.rmdir()
 
 
 def test_make_dir():

lynxkite-app/web/index.html

@@ -4,7 +4,6 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/src/assets/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>LynxKite 2025</title>
   </head>
   <body>
     <div id="root"></div>

lynxkite-app/web/package-lock.json

@@ -10,6 +10,7 @@
       "dependencies": {
         "@esbuild/linux-x64": "^0.25.0",
         "@iconify-json/tabler": "^1.2.10",
+        "@monaco-editor/react": "^4.7.0",
         "@svgr/core": "^8.1.0",
         "@svgr/plugin-jsx": "^8.1.0",
         "@swc/core": "^1.10.1",
@@ -28,6 +29,7 @@
         "react-router-dom": "^7.0.2",
         "swr": "^2.2.5",
         "unplugin-icons": "^0.21.0",
+        "y-monaco": "^0.1.6",
         "y-websocket": "^2.0.4",
         "yjs": "^13.6.20"
       },
@@ -1105,6 +1107,29 @@
       "integrity": "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg==",
       "license": "MIT"
     },
+    "node_modules/@monaco-editor/loader": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/loader/-/loader-1.5.0.tgz",
+      "integrity": "sha512-hKoGSM+7aAc7eRTRjpqAZucPmoNOC4UUbknb/VNoTkEIkCPhqV8LfbsgM1webRM7S/z21eHEx9Fkwx8Z/C/+Xw==",
+      "license": "MIT",
+      "dependencies": {
+        "state-local": "^1.0.6"
+      }
+    },
+    "node_modules/@monaco-editor/react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/react/-/react-4.7.0.tgz",
+      "integrity": "sha512-cyzXQCtO47ydzxpQtCGSQGOC8Gk3ZUeBXFAxD+CWXYFo5OqZyZUonFl0DwUlTyAfRHntBfw2p3w4s9R6oe1eCA==",
+      "license": "MIT",
+      "dependencies": {
+        "@monaco-editor/loader": "^1.5.0"
+      },
+      "peerDependencies": {
+        "monaco-editor": ">= 0.25.0 < 1",
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -5436,6 +5461,13 @@
         "ufo": "^1.5.4"
       }
     },
+    "node_modules/monaco-editor": {
+      "version": "0.52.2",
+      "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.52.2.tgz",
+      "integrity": "sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -6437,6 +6469,12 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/state-local": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/state-local/-/state-local-1.0.7.tgz",
+      "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==",
+      "license": "MIT"
+    },
     "node_modules/string_decoder": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -7360,6 +7398,23 @@
         "yjs": "^13.0.0"
       }
     },
+    "node_modules/y-monaco": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/y-monaco/-/y-monaco-0.1.6.tgz",
+      "integrity": "sha512-sYRywMmcylt+Nupl+11AvizD2am06ST8lkVbUXuaEmrtV6Tf+TD4rsEm6u9YGGowYue+Vfg1IJ97SUP2J+PVXg==",
+      "license": "MIT",
+      "dependencies": {
+        "lib0": "^0.2.43"
+      },
+      "engines": {
+        "node": ">=12.0.0",
+        "npm": ">=6.0.0"
+      },
+      "peerDependencies": {
+        "monaco-editor": ">=0.20.0",
+        "yjs": "^13.3.1"
+      }
+    },
     "node_modules/y-protocols": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/y-protocols/-/y-protocols-1.0.6.tgz",

lynxkite-app/web/package.json

@@ -13,6 +13,7 @@
   "dependencies": {
     "@esbuild/linux-x64": "^0.25.0",
     "@iconify-json/tabler": "^1.2.10",
+    "@monaco-editor/react": "^4.7.0",
     "@svgr/core": "^8.1.0",
     "@svgr/plugin-jsx": "^8.1.0",
     "@swc/core": "^1.10.1",
@@ -31,6 +32,7 @@
     "react-router-dom": "^7.0.2",
     "swr": "^2.2.5",
     "unplugin-icons": "^0.21.0",
+    "y-monaco": "^0.1.6",
     "y-websocket": "^2.0.4",
     "yjs": "^13.6.20"
   },

lynxkite-app/web/playwright.config.ts

@@ -7,6 +7,7 @@ export default defineConfig({
   /* Fail the build on CI if you accidentally left test.only in the source code. */
   forbidOnly: !!process.env.CI,
   retries: process.env.CI ? 1 : 0,
+  maxFailures: 5,
   workers: 1,
   reporter: process.env.CI ? [["github"], ["html"]] : "html",
   use: {

lynxkite-app/web/src/Code.tsx

@@ -0,0 +1,101 @@
+// Full-page editor for code files.
+
+import Editor, { type Monaco } from "@monaco-editor/react";
+import type { editor } from "monaco-editor";
+import { useEffect, useRef } from "react";
+import { useParams } from "react-router";
+import { WebsocketProvider } from "y-websocket";
+import * as Y from "yjs";
+// @ts-ignore
+import Atom from "~icons/tabler/atom.jsx";
+// @ts-ignore
+import Backspace from "~icons/tabler/backspace.jsx";
+// @ts-ignore
+import Close from "~icons/tabler/x.jsx";
+import favicon from "./assets/favicon.ico";
+import theme from "./code-theme.ts";
+
+export default function Code() {
+  const { path } = useParams();
+  const parentDir = path!.split("/").slice(0, -1).join("/");
+  const yDocRef = useRef<any>();
+  const wsProviderRef = useRef<any>();
+  const monacoBindingRef = useRef<any>();
+  const yMonacoRef = useRef<any>();
+  const editorRef = useRef<any>();
+  useEffect(() => {
+    const loadMonaco = async () => {
+      // y-monaco is gigantic. The other Monaco packages are small.
+      yMonacoRef.current = await import("y-monaco");
+      initCRDT();
+    };
+    loadMonaco();
+  }, []);
+  function beforeMount(monaco: Monaco) {
+    monaco.editor.defineTheme("lynxkite", theme);
+  }
+  function onMount(_editor: editor.IStandaloneCodeEditor) {
+    editorRef.current = _editor;
+    initCRDT();
+  }
+  function initCRDT() {
+    if (!yMonacoRef.current || !editorRef.current) return;
+    if (yDocRef.current) return;
+    yDocRef.current = new Y.Doc();
+    const text = yDocRef.current.getText("text");
+    const proto = location.protocol === "https:" ? "wss:" : "ws:";
+    wsProviderRef.current = new WebsocketProvider(
+      `${proto}//${location.host}/ws/code/crdt`,
+      path!,
+      yDocRef.current,
+    );
+    monacoBindingRef.current = new yMonacoRef.current.MonacoBinding(
+      text,
+      editorRef.current.getModel()!,
+      new Set([editorRef.current]),
+      wsProviderRef.current.awareness,
+    );
+  }
+  useEffect(() => {
+    return () => {
+      yDocRef.current?.destroy();
+      wsProviderRef.current?.destroy();
+      monacoBindingRef.current?.destroy();
+    };
+  });
+  return (
+    <div className="workspace">
+      <div className="top-bar bg-neutral">
+        <a className="logo" href="">
+          <img alt="" src={favicon} />
+        </a>
+        <div className="ws-name">{path}</div>
+        <div className="tools text-secondary">
+          <a href="">
+            <Atom />
+          </a>
+          <a href="">
+            <Backspace />
+          </a>
+          <a href={`/dir/${parentDir}`}>
+            <Close />
+          </a>
+        </div>
+      </div>
+      <Editor
+        defaultLanguage="python"
+        theme="lynxkite"
+        path={path}
+        beforeMount={beforeMount}
+        onMount={onMount}
+        loading={null}
+        options={{
+          cursorStyle: "block",
+          cursorBlinking: "solid",
+          minimap: { enabled: false },
+          renderLineHighlight: "none",
+        }}
+      />
+    </div>
+  );
+}

lynxkite-app/web/src/Directory.tsx

@@ -15,9 +15,46 @@ import FolderPlus from "~icons/tabler/folder-plus";
 // @ts-ignore
 import Home from "~icons/tabler/home";
 // @ts-ignore
+import LayoutGrid from "~icons/tabler/layout-grid";
+// @ts-ignore
+import LayoutGridAdd from "~icons/tabler/layout-grid-add";
+// @ts-ignore
 import Trash from "~icons/tabler/trash";
 import logo from "./assets/logo.png";
 
+function EntryCreator(props: {
+  label: string;
+  icon: JSX.Element;
+  onCreate: (name: string) => void;
+}) {
+  const [isCreating, setIsCreating] = useState(false);
+  return (
+    <>
+      {isCreating ? (
+        <form
+          onSubmit={(e) => {
+            e.preventDefault();
+            props.onCreate((e.target as HTMLFormElement).entryName.value.trim());
+          }}
+        >
+          <input
+            className="input input-ghost w-full"
+            autoFocus
+            type="text"
+            name="entryName"
+            onBlur={() => setIsCreating(false)}
+            placeholder={`${props.label} name`}
+          />
+        </form>
+      ) : (
+        <button type="button" onClick={() => setIsCreating(true)}>
+          {props.icon} {props.label}
+        </button>
+      )}
+    </>
+  );
+}
+
 const fetcher = (url: string) => fetch(url).then((res) => res.json());
 
 export default function () {
@@ -27,48 +64,41 @@ export default function () {
     dedupingInterval: 0,
   });
   const navigate = useNavigate();
-  const [isCreatingDir, setIsCreatingDir] = useState(false);
-  const [isCreatingWorkspace, setIsCreatingWorkspace] = useState(false);
 
   function link(item: DirectoryEntry) {
     if (item.type === "directory") {
       return `/dir/${item.name}`;
     }
-    return `/edit/${item.name}`;
+    if (item.type === "workspace") {
+      return `/edit/${item.name}`;
+    }
+    return `/code/${item.name}`;
   }
 
   function shortName(item: DirectoryEntry) {
-    return item.name.split("/").pop();
+    return item.name
+      .split("/")
+      .pop()
+      ?.replace(/[.]lynxkite[.]json$/, "");
   }
 
-  function newName(list: DirectoryEntry[], baseName = "Untitled") {
-    let i = 0;
-    while (true) {
-      const name = `${baseName}${i ? ` ${i}` : ""}`;
-      if (!list.find((item) => item.name === name)) {
-        return name;
-      }
-      i++;
-    }
+  function newWorkspaceIn(path: string, workspaceName: string) {
+    const pathSlash = path ? `${path}/` : "";
+    navigate(`/edit/${pathSlash}${workspaceName}.lynxkite.json`, { replace: true });
   }
-
-  function newWorkspaceIn(path: string, list: DirectoryEntry[], workspaceName?: string) {
+  function newCodeFile(path: string, name: string) {
     const pathSlash = path ? `${path}/` : "";
-    const name = workspaceName || newName(list);
-    navigate(`/edit/${pathSlash}${name}`, { replace: true });
+    navigate(`/code/${pathSlash}${name}`, { replace: true });
   }
-
-  async function newFolderIn(path: string, list: DirectoryEntry[], folderName?: string) {
-    const name = folderName || newName(list, "New Folder");
+  async function newFolderIn(path: string, folderName: string) {
     const pathSlash = path ? `${path}/` : "";
-
     const res = await fetch("/api/dir/mkdir", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: pathSlash + name }),
+      body: JSON.stringify({ path: pathSlash + folderName }),
     });
     if (res.ok) {
-      navigate(`/dir/${pathSlash}${name}`);
+      navigate(`/dir/${pathSlash}${folderName}`);
     } else {
       alert("Failed to create folder.");
     }
@@ -105,84 +135,66 @@ export default function () {
         {list.data && (
           <>
             <div className="actions">
-              <div className="new-workspace">
-                {isCreatingWorkspace && (
-                  // @ts-ignore
-                  <form
-                    onSubmit={(e) => {
-                      e.preventDefault();
-                      newWorkspaceIn(
-                        path || "",
-                        list.data,
-                        (e.target as HTMLFormElement).workspaceName.value.trim(),
-                      );
-                    }}
-                  >
-                    <input
-                      type="text"
-                      name="workspaceName"
-                      defaultValue={newName(list.data)}
-                      placeholder={newName(list.data)}
-                    />
-                  </form>
-                )}
-                <button type="button" onClick={() => setIsCreatingWorkspace(true)}>
-                  <FolderPlus /> New workspace
-                </button>
-              </div>
-
-              <div className="new-folder">
-                {isCreatingDir && (
-                  // @ts-ignore
-                  <form
-                    onSubmit={(e) => {
-                      e.preventDefault();
-                      newFolderIn(
-                        path || "",
-                        list.data,
-                        (e.target as HTMLFormElement).folderName.value.trim(),
-                      );
-                    }}
-                  >
-                    <input
-                      type="text"
-                      name="folderName"
-                      defaultValue={newName(list.data)}
-                      placeholder={newName(list.data)}
-                    />
-                  </form>
-                )}
-                <button type="button" onClick={() => setIsCreatingDir(true)}>
-                  <FolderPlus /> New folder
-                </button>
-              </div>
+              <EntryCreator
+                onCreate={(name) => {
+                  newWorkspaceIn(path || "", name);
+                }}
+                icon={<LayoutGridAdd />}
+                label="New workspace"
+              />
+              <EntryCreator
+                onCreate={(name) => {
+                  newCodeFile(path || "", name);
+                }}
+                icon={<FilePlus />}
+                label="New code file"
+              />
+              <EntryCreator
+                onCreate={(name: string) => {
+                  newFolderIn(path || "", name);
+                }}
+                icon={<FolderPlus />}
+                label="New folder"
+              />
             </div>
 
-            {path && (
+            {path ? (
               <div className="breadcrumbs">
                 <Link to="/dir/">
                   <Home />
                 </Link>{" "}
                 <span className="current-folder">{path}</span>
+                <title>{path}</title>
               </div>
+            ) : (
+              <title>LynxKite 2000:MM</title>
             )}
 
-            {list.data.map((item: DirectoryEntry) => (
-              <div key={item.name} className="entry">
-                <Link key={link(item)} to={link(item)}>
-                  {item.type === "directory" ? <Folder /> : <File />}
-                  {shortName(item)}
-                </Link>
-                <button
-                  type="button"
-                  onClick={() => {
-                    deleteItem(item);
-                  }}
-                >
-                  <Trash />
-                </button>
-              </div>
-            ))}
+            {list.data.map(
+              (item: DirectoryEntry) =>
+                !shortName(item)?.startsWith("__") && (
+                  <div key={item.name} className="entry">
+                    <Link key={link(item)} to={link(item)}>
+                      {item.type === "directory" ? (
+                        <Folder />
+                      ) : item.type === "workspace" ? (
+                        <LayoutGrid />
+                      ) : (
+                        <File />
+                      )}
+                      {shortName(item)}
+                    </Link>
+                    <button
+                      type="button"
+                      onClick={() => {
+                        deleteItem(item);
+                      }}
+                    >
+                      <Trash />
+                    </button>
+                  </div>
+                ),
+            )}
           </>
         )}
       </div>{" "}

lynxkite-app/web/src/code-theme.ts

@@ -0,0 +1,38 @@
+// A simple theme using the LynxKite colors.
+
+import type { editor } from "monaco-editor/esm/vs/editor/editor.api";
+
+const theme: editor.IStandaloneThemeData = {
+  base: "vs-dark",
+  inherit: true,
+  rules: [
+    {
+      foreground: "ff8800",
+      token: "keyword",
+    },
+    {
+      foreground: "0088ff",
+      fontStyle: "italic",
+      token: "comment",
+    },
+    {
+      foreground: "39bcf3",
+      token: "string",
+    },
+    {
+      foreground: "ffc600",
+      token: "",
+    },
+  ],
+  colors: {
+    "editor.foreground": "#FFFFFF",
+    "editor.background": "#002a4c",
+    "editor.selectionBackground": "#0050a4",
+    "editor.lineHighlightBackground": "#1f4662",
+    "editorCursor.foreground": "#ffc600",
+    "editorWhitespace.foreground": "#7f7f7fb2",
+    "editorIndentGuide.background": "#3b5364",
+    "editorIndentGuide.activeBackground": "#ffc600",
+  },
+};
+export default theme;

lynxkite-app/web/src/index.css

@@ -326,7 +326,14 @@ body {
   .actions {
     display: flex;
     justify-content: space-evenly;
+    align-items: center;
+    height: 50px;
     padding: 5px;
+
+    form,
+    button {
+      flex: 1;
+    }
   }
 
   .actions a {
@@ -534,3 +541,25 @@ body {
 .add-relationship-button:hover {
   background-color: #218838;
 }
+
+.yRemoteSelection {
+  background-color: rgb(250, 129, 0, 0.5);
+}
+
+.yRemoteSelectionHead {
+  position: absolute;
+  border-left: #ff8800 solid 2px;
+  border-top: #ff8800 solid 2px;
+  border-bottom: #ff8800 solid 2px;
+  height: 100%;
+  box-sizing: border-box;
+}
+
+.yRemoteSelectionHead::after {
+  position: absolute;
+  content: " ";
+  border: 3px solid #ff8800;
+  border-radius: 4px;
+  left: -4px;
+  top: -5px;
+}

lynxkite-app/web/src/main.tsx

@@ -3,6 +3,7 @@ import { createRoot } from "react-dom/client";
 import "@xyflow/react/dist/style.css";
 import "./index.css";
 import { BrowserRouter, Route, Routes } from "react-router";
+import Code from "./Code.tsx";
 import Directory from "./Directory.tsx";
 import Workspace from "./workspace/Workspace.tsx";
 
@@ -14,6 +15,7 @@ createRoot(document.getElementById("root")!).render(
         <Route path="/dir" element={<Directory />} />
         <Route path="/dir/:path" element={<Directory />} />
         <Route path="/edit/:path" element={<Workspace />} />
+        <Route path="/code/:path" element={<Code />} />
       </Routes>
     </BrowserRouter>
   </StrictMode>,

lynxkite-app/web/src/workspace/Workspace.tsx

@@ -1,3 +1,5 @@
+// The LynxKite workspace editor.
+
 import { getYjsDoc, syncedStore } from "@syncedstore/core";
 import {
   type Connection,
@@ -16,7 +18,6 @@ import {
 } from "@xyflow/react";
 import axios from "axios";
 import { type MouseEvent, useCallback, useEffect, useMemo, useState } from "react";
-// The LynxKite workspace editor.
 import { useParams } from "react-router";
 import useSWR, { type Fetcher } from "swr";
 import { WebsocketProvider } from "y-websocket";
@@ -52,6 +53,10 @@ function LynxKiteFlow() {
   const [nodes, setNodes] = useState([] as Node[]);
   const [edges, setEdges] = useState([] as Edge[]);
   const { path } = useParams();
+  const shortPath = path!
+    .split("/")
+    .pop()!
+    .replace(/[.]lynxkite[.]json$/, "");
   const [state, setState] = useState({ workspace: {} as Workspace });
   const [message, setMessage] = useState(null as string | null);
   useEffect(() => {
@@ -151,7 +156,7 @@ function LynxKiteFlow() {
 
   const fetcher: Fetcher<Catalogs> = (resource: string, init?: RequestInit) =>
     fetch(resource, init).then((res) => res.json());
-  const catalog = useSWR("/api/catalog", fetcher);
+  const catalog = useSWR(`/api/catalog?workspace=${path}`, fetcher);
   const [suppressSearchUntil, setSuppressSearchUntil] = useState(0);
   const [nodeSearchSettings, setNodeSearchSettings] = useState(
     undefined as
@@ -319,7 +324,8 @@ function LynxKiteFlow() {
         <a className="logo" href="">
           <img alt="" src={favicon} />
         </a>
-        <div className="ws-name">{path}</div>
+        <div className="ws-name">{shortPath}</div>
+        <title>{shortPath}</title>
         <EnvironmentSelector
           options={Object.keys(catalog.data || {})}
           value={state.workspace.env!}

lynxkite-app/web/tests/directory.spec.ts

@@ -14,13 +14,6 @@ test.describe("Directory operations", () => {
     splash = await Splash.open(page);
   });
 
-  test("Create workspace with default name", async () => {
-    const workspace = await Workspace.empty(splash.page);
-    // Not checking for exact match, since there may be pre-existing "Untitled" workspaces
-    expect(workspace.name).toContain("Untitled");
-    await workspace.close();
-  });
-
   test("Create & delete workspace", async () => {
     const workspaceName = `TestWorkspace-${Date.now()}`;
     const workspace = await Workspace.empty(splash.page, workspaceName);
@@ -40,11 +33,6 @@ test.describe("Directory operations", () => {
     await splash.deleteEntry(folderName);
     await expect(splash.getEntry(folderName)).not.toBeVisible();
   });
-
-  test("Create folder with default name", async () => {
-    await splash.createFolder();
-    await expect(splash.currentFolder()).toContainText("Untitled");
-  });
 });
 
 test.describe

lynxkite-app/web/tests/lynxkite.ts

@@ -18,7 +18,7 @@ export class Workspace {
   }
 
   // Starts with a brand new workspace.
-  static async empty(page: Page, workspaceName?: string): Promise<Workspace> {
+  static async empty(page: Page, workspaceName: string): Promise<Workspace> {
     const splash = await Splash.open(page);
     return await splash.createWorkspace(workspaceName);
   }
@@ -182,18 +182,12 @@ export class Splash {
     return this.page.locator(".entry").filter({ hasText: name }).first();
   }
 
-  async createWorkspace(name?: string) {
+  async createWorkspace(name: string) {
     await this.page.getByRole("button", { name: "New workspace" }).click();
-    await this.page.locator('input[name="workspaceName"]').click();
-    let workspaceName: string;
-    if (name) {
-      workspaceName = name;
-      await this.page.locator('input[name="workspaceName"]').fill(name);
-    } else {
-      workspaceName = await this.page.locator('input[name="workspaceName"]').inputValue();
-    }
-    await this.page.locator('input[name="workspaceName"]').press("Enter");
-    const ws = new Workspace(this.page, workspaceName);
+    const nameBox = this.page.locator('input[name="entryName"]');
+    await nameBox.fill(name);
+    await nameBox.press("Enter");
+    const ws = new Workspace(this.page, name);
     await ws.setEnv("LynxKite Graph Analytics");
     return ws;
   }
@@ -203,13 +197,11 @@ export class Splash {
     return new Workspace(this.page, name);
   }
 
-  async createFolder(folderName?: string) {
+  async createFolder(folderName: string) {
     await this.page.getByRole("button", { name: "New folder" }).click();
-    await this.page.locator('input[name="folderName"]').click();
-    if (folderName) {
-      await this.page.locator('input[name="folderName"]').fill(folderName);
-    }
-    await this.page.locator('input[name="folderName"]').press("Enter");
+    const nameBox = this.page.locator('input[name="entryName"]');
+    await nameBox.fill(folderName);
+    await nameBox.press("Enter");
   }
 
   async deleteEntry(entryName: string) {

lynxkite-app/web/vite.config.ts

@@ -5,7 +5,7 @@ import { defineConfig } from "vite";
 // https://vite.dev/config/
 export default defineConfig({
   build: {
-    chunkSizeWarningLimit: 2048,
+    chunkSizeWarningLimit: 3000,
   },
   esbuild: {
     supported: {

lynxkite-core/src/lynxkite/core/ops.py

@@ -4,7 +4,12 @@ from __future__ import annotations
 import asyncio
 import enum
 import functools
+import importlib
 import inspect
+import pathlib
+import subprocess
+import traceback
+import joblib
 import types
 import pydantic
 import typing
@@ -14,8 +19,11 @@ from typing_extensions import Annotated
 if typing.TYPE_CHECKING:
     from . import workspace
 
-CATALOGS: dict[str, dict[str, "Op"]] = {}
+Catalog = dict[str, "Op"]
+Catalogs = dict[str, Catalog]
+CATALOGS: Catalogs = {}
 EXECUTORS = {}
+mem = joblib.Memory(".joblib-cache")
 
 typeof = type  # We have some arguments called "type".
 
@@ -189,11 +197,14 @@ class Op(BaseConfig):
         return res
 
 
-def op(env: str, name: str, *, view="basic", outputs=None, params=None):
+def op(env: str, name: str, *, view="basic", outputs=None, params=None, slow=False):
     """Decorator for defining an operation."""
 
     def decorator(func):
         sig = inspect.signature(func)
+        if slow:
+            func = mem.cache(func)
+            func = _global_slow(func)
         # Positional arguments are inputs.
         inputs = {
             name: Input(name=name, type=param.annotation)
@@ -308,3 +319,54 @@ def slow(func):
         return await asyncio.to_thread(func, *args, **kwargs)
 
     return wrapper
+
+
+_global_slow = slow  # For access inside op().
+CATALOGS_SNAPSHOTS: dict[str, Catalogs] = {}
+
+
+def save_catalogs(snapshot_name: str):
+    CATALOGS_SNAPSHOTS[snapshot_name] = {k: dict(v) for k, v in CATALOGS.items()}
+
+
+def load_catalogs(snapshot_name: str):
+    global CATALOGS
+    snap = CATALOGS_SNAPSHOTS[snapshot_name]
+    CATALOGS = {k: dict(v) for k, v in snap.items()}
+
+
+def load_user_scripts(workspace: str):
+    """Reloads the *.py in the workspace's directory and higher-level directories."""
+    if "plugins loaded" in CATALOGS_SNAPSHOTS:
+        load_catalogs("plugins loaded")
+    cwd = pathlib.Path()
+    path = cwd / workspace
+    assert path.is_relative_to(cwd), "Provided workspace path is invalid"
+    for p in path.parents:
+        print("checking user scripts in", p)
+        for f in p.glob("*.py"):
+            try:
+                run_user_script(f)
+            except Exception:
+                traceback.print_exc()
+        req = p / "requirements.txt"
+        if req.exists():
+            try:
+                install_requirements(req)
+            except Exception:
+                traceback.print_exc()
+        if p == cwd:
+            break
+
+
+def install_requirements(req: pathlib.Path):
+    cmd = ["uv", "pip", "install", "-r", str(req)]
+    print(f"Running {' '.join(cmd)}")
+    subprocess.check_call(cmd)
+
+
+def run_user_script(script_path: pathlib.Path):
+    print(f"Running {script_path}...")
+    spec = importlib.util.spec_from_file_location(script_path.stem, str(script_path))
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)