@dxos/plugin-script 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/templates/commentary.ts

@@ -0,0 +1,243 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as A from '@automerge/automerge';
+import { Chess as ChessJS } from 'chess.js';
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
+import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { AiSession, GenerationObserver } from '@dxos/assistant';
+import { ArtifactId } from '@dxos/assistant';
+import { Database, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { FunctionInvocationService, TracingService } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { Chess } from '@dxos/plugin-chess/types';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Text } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+const Commentary = Operation.make({
+  meta: {
+    key: 'org.dxos.function.chess.commentary',
+    name: 'Commentary',
+    description: 'Adds commentary about the most recent move to a markdown document associated with the chess game.',
+  },
+  input: Schema.Struct({
+    game: Ref.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+  }),
+  output: Schema.Union(
+    Schema.Struct({
+      documentId: ArtifactId.annotations({
+        description: 'The ID of the markdown document that was updated or created.',
+      }),
+      commentary: Schema.String.annotations({
+        description: 'The commentary that was added.',
+      }),
+    }),
+    Schema.Void.annotations({
+      description: 'Function did not find anything to comment on.',
+    }),
+  ),
+  types: [Chess.Game, Markdown.Document, Text.Text, HasSubject.HasSubject, Collection.Collection],
+  services: [AiService.AiService, Database.Service],
+});
+
+export default Commentary.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ game: gameRef }) {
+        // Load the chess game
+        log.info('load game', { gameRef });
+        const chessGame = yield* Database.load(gameRef);
+
+        // Load the chess position from PGN or FEN
+        const chess = new ChessJS();
+        if (chessGame.pgn) {
+          chess.loadPgn(chessGame.pgn);
+        } else if (chessGame.fen) {
+          chess.load(chessGame.fen);
+        } else {
+          log.info('Early return: no pgn or fen');
+          return;
+        }
+
+        // Get the most recent move
+        const history = chess.history({ verbose: true });
+        if (history.length === 0) {
+          throw new Error('No moves have been played yet');
+        }
+        const lastMove = history[history.length - 1];
+        const moveNumber = Math.ceil(history.length / 2);
+        const isWhiteMove = history.length % 2 === 1;
+        const player = isWhiteMove ? 'White' : 'Black';
+        const moveNotation = lastMove.san;
+
+        // Generate AI commentary about the move
+        const result = yield* new AiSession({
+          observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'chess-commentary' })),
+        }).run({
+          prompt:
+            `Comment on this chess move as if you're commentating a live match for an audience:\n\n` +
+            `Move ${moveNumber}: ${player} plays ${moveNotation} (${lastMove.from} to ${lastMove.to})${lastMove.captured ? `, capturing ${lastMove.captured}` : ''}\n` +
+            `Current position: ${chess.fen()}\n` +
+            `${chess.isCheck() ? 'The king is in check! ' : ''}` +
+            `${chess.isCheckmate() ? 'CHECKMATE! ' : ''}` +
+            `${chess.isStalemate() ? 'STALEMATE! ' : ''}` +
+            `\nGame so far:\n${chess.pgn()}`,
+          system: COMMENTARY_SYSTEM_PROMPT,
+          history: [],
+        });
+
+        const commentaryText = Function.pipe(
+          result,
+          Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
+          Option.flatMap((msg) =>
+            Function.pipe(
+              msg.blocks,
+              Array.findLast((block) => block._tag === 'text'),
+              Option.map((block) => block.text),
+            ),
+          ),
+          Option.getOrThrowWith(() => new Error('No commentary generated')),
+        );
+
+        const commentary = `## Move ${moveNumber}: ${player} plays ${moveNotation}\n\n${commentaryText}\n\n`;
+        log.info('commentary', { commentary });
+
+        // TODO(wittjosiah): Functions currently don't support traversals.
+        // const docs = yield* Database.runQuery(
+        //   Query.select(Filter.id(chessGame.id)).targetOf(HasSubject.HasSubject).source(),
+        // ).pipe(Effect.map((objects) => objects.filter((object) => Obj.instanceOf(Markdown.Document, object))));
+        const docs = yield* Database.runQuery(Filter.type(HasSubject.HasSubject)).pipe(
+          Effect.map((relations) =>
+            relations.filter((relation) => {
+              // TODO(wittjosiah): This is a workaround for getTarget not handling deleted objects.
+              try {
+                log.info('relation', {
+                  source: Obj.getDXN(Relation.getTarget(relation)).toString(),
+                  game: Obj.getDXN(chessGame).toString(),
+                });
+                return Obj.getDXN(Relation.getTarget(relation)).toString() === Obj.getDXN(chessGame).toString();
+              } catch {
+                return false;
+              }
+            }),
+          ),
+          Effect.map((relations) =>
+            relations
+              .map((relation) => {
+                // TODO(wittjosiah): This is a workaround for getSource not handling deleted objects.
+                try {
+                  return Relation.getSource(relation);
+                } catch {
+                  return undefined;
+                }
+              })
+              .filter((source) => source !== undefined),
+          ),
+          Effect.map((sources) => {
+            const docs = sources.filter((source) => Obj.instanceOf(Markdown.Document, source));
+            log.info('docs', { sources, docs });
+            return docs;
+          }),
+        );
+        log.info('docs', { count: docs.length });
+
+        let document: Markdown.Document;
+        if (docs.length === 0) {
+          // TODO(wittjosiah): Deploy fails if `SpaceProperties` schema is imported because its from `client-protocol`.
+          const [properties] = yield* Database.runQuery(Filter.typename('org.dxos.type.space-properties'));
+          const rootCollection = yield* Database.load<Collection.Collection>(
+            properties[Collection.Collection.typename],
+          );
+
+          log.info('rootCollection', { rootCollection });
+
+          // Create a new markdown document
+          const gameName = chessGame.name || 'Chess Game';
+          document = yield* Database.add(
+            Markdown.make({
+              name: `${gameName} Commentary`,
+              content: `# ${gameName} Commentary\n\n${commentary}`,
+            }),
+          );
+
+          const documentRef = Ref.make(document);
+          Obj.change(rootCollection, (obj) => {
+            obj.objects.push(documentRef);
+          });
+
+          // Create the HasSubject relation
+          yield* Database.add(
+            Relation.make(HasSubject.HasSubject, {
+              [Relation.Source]: document,
+              [Relation.Target]: chessGame,
+              completedAt: new Date().toISOString(),
+            }),
+          );
+        } else {
+          document = docs[0];
+
+          // Load the text content and append the commentary
+          const text = yield* Database.load(document.content);
+          const accessor = createDocAccessor(text, ['content']);
+          accessor.handle.change((doc: A.Doc<Text.Text>) => {
+            A.splice(doc, accessor.path.slice(), text.content.length, 0, commentary);
+          });
+        }
+
+        log.info('result', { documentId: Obj.getDXN(document).toString(), commentary });
+
+        yield* Database.flush();
+
+        return {
+          documentId: Obj.getDXN(document).toString(),
+          commentary,
+        };
+      },
+      Effect.provide(
+        Layer.mergeAll(
+          AiService.model('@anthropic/claude-haiku-4-5'),
+          ToolResolverService.layerEmpty,
+          ToolExecutionService.layerEmpty,
+          TracingService.layerNoop,
+          FunctionInvocationService.layerNotAvailable,
+        ),
+      ),
+    ),
+  ),
+);
+
+const COMMENTARY_SYSTEM_PROMPT = trim`
+  You are a professional chess commentator providing live commentary for a chess match.
+
+  # Style
+  - Write in an engaging, enthusiastic style as if commentating for a live audience
+  - Be concise but informative (2-4 sentences)
+  - Explain the strategic implications of the move
+  - Note any tactical elements (captures, threats, checks)
+  - Comment on the position and what it means for the game
+
+  # Format
+  - Write in plain text (no markdown formatting in the commentary itself)
+  - Be natural and conversational
+  - Use chess terminology appropriately but keep it accessible
+
+  # Special Situations
+  - If it's checkmate, express excitement about the conclusion
+  - If it's check, note the pressure on the king
+  - If a piece is captured, mention the material exchange
+  - Comment on the development of pieces and control of key squares when relevant
+`;

package/src/templates/data-generator.ts

@@ -8,7 +8,7 @@ import { Expando, S, create, defineFunction } from 'dxos:functions';
 import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1?bundle=false';
 
 export default defineFunction({
-  key: 'dxos.org/script/data-generator',
+  key: 'org.dxos.script.data-generator',
   name: 'Data Generator',
   inputSchema: S.Struct({
     documentAmount: S.optional(S.Number),
@@ -23,7 +23,7 @@ export default defineFunction({
     data: { documentAmount = 1, textSize = 10, mutationAmount = 0, waitAfterCreation = 10_000 },
     context: { space },
   }: any) => {
-    await space.db.graph.schemaRegistry.addSchema([Expando]);
+    await space.db.graph.schemaRegistry.register([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 

package/src/templates/discord.ts

@@ -29,7 +29,7 @@ const MessageSchema = S.Struct({
   content: S.String,
 }).pipe(
   EchoObject({
-    typename: 'example.com/type/Message',
+    typename: 'com.example.type.message',
     version: '0.1.0',
   }),
 );
@@ -42,7 +42,7 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
-  key: 'dxos.org/script/discord',
+  key: 'org.dxos.script.discord',
   name: 'Discord',
   inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
@@ -60,7 +60,7 @@ export default defineFunction({
   handler: ({ data: { channelId, queueId, after = DEFAULT_AFTER, pageSize = 5 }, context: { space } }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
-        try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'discord.com' })).first(),
+        try: () => space.db.query(Filter.typename('org.dxos.type.access-token', { source: 'discord.com' })).first(),
         catch: (e: any) => e,
       });
       const { objects } = yield* Effect.tryPromise({

package/src/templates/forex-effect.ts

@@ -2,41 +2,47 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
-// @ts-ignore
-import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
-// @ts-ignore
-import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
 
-export default defineFunction({
-  key: 'dxos.org/script/forex-effect',
-  name: 'Forex Effect',
-  description: 'Returns the exchange rate between two currencies.',
+import { Operation } from '@dxos/operation';
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+const ForexEffect = Operation.make({
+  meta: {
+    key: 'org.dxos.script.forex-effect',
+    name: 'Forex Effect',
+    description: 'Returns the exchange rate between two currencies.',
+  },
+  input: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
+  output: Schema.Any,
+});
 
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
-
-  handler: async ({ data: { from, to } }: any) =>
-    Effect.gen(function* () {
-      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+export default ForexEffect.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ from: rawFrom, to: rawTo }) {
+      const from = rawFrom.toUpperCase();
+      const to = rawTo.toUpperCase();
+      const json: any = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
         HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
+        Effect.flatMap((response) => response.json),
+        Effect.timeout('5 seconds'),
         Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
         Effect.scoped,
       );
 
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
-});
+      const rate = json?.data?.rates?.[to];
+      if (rate == null) {
+        return yield* Effect.fail(new Error(`No rate found for ${from} -> ${to}`));
+      }
+
+      return rate.toString();
+    }, Effect.provide(FetchHttpClient.layer)),
+  ),
+);

package/src/templates/forex.ts

@@ -2,25 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-export default defineFunction({
-  key: 'dxos.org/script/forex',
-  name: 'Forex',
-  description: 'Returns the exchange rate between two currencies.',
+import { Operation } from '@dxos/operation';
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+const Forex = Operation.make({
+  meta: {
+    key: 'org.dxos.script.forex',
+    name: 'Forex',
+    description: 'Returns the exchange rate between two currencies.',
+  },
+  input: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
+  output: Schema.Any,
+});
 
-  handler: async ({ data: { from, to } }: any) => {
-    const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
-    const {
-      data: { rates },
-    } = await res.json();
+export default Forex.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ from: rawFrom, to: rawTo }) {
+      const from = rawFrom.toUpperCase();
+      const to = rawTo.toUpperCase();
+      const res = yield* Effect.promise(() => fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`));
+      const {
+        data: { rates },
+      } = yield* Effect.promise(() => res.json());
 
-    return rates[to].toString();
-  },
-});
+      return rates[to].toString();
+    }),
+  ),
+);

package/src/templates/gmail.ts

@@ -27,7 +27,7 @@ import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
 import * as Stream from 'https://esm.sh/effect@3.17.0/Stream?bundle=false';
 
 export default defineFunction({
-  key: 'dxos.org/script/gmail',
+  key: 'org.dxos.script.gmail',
   name: 'Gmail',
   inputSchema: S.Struct({
     mailboxId: S.String,
@@ -47,7 +47,7 @@ export default defineFunction({
   handler: ({ context: { space }, data: { mailboxId, userId, after, pageSize } }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
-        try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'gmail.com' })).first(),
+        try: () => space.db.query(Filter.typename('org.dxos.type.access-token', { source: 'gmail.com' })).first(),
         catch: (e: any) => e,
       });
 
@@ -216,8 +216,8 @@ const MessageType = S.Struct({
   ),
 }).pipe(
   EchoObject({
-    typename: 'dxos.org/type/Message',
-    version: '0.2.0',
+    typename: 'org.dxos.type.message',
+    version: '0.1.0',
   }),
 );
 type MessageType = S.Schema.Type<typeof MessageType>;

package/src/templates/index.ts

@@ -2,8 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import anthropic from './anthropic.ts?raw';
 import chat from './chat.ts?raw';
-import chess from './chess.ts?raw';
+import chessBot from './chess-bot.ts?raw';
+import commentary from './commentary.ts?raw';
 import dataGenerator from './data-generator.ts?raw';
 import discord from './discord.ts?raw';
 import email from './email.ts?raw';
@@ -25,54 +27,65 @@ export type Template = {
 
 export const templates = [
   {
-    id: 'dxos.org/script/ping',
+    id: 'org.dxos.script.ping',
     name: 'Ping',
     source: removeHeader(ping),
   },
   {
-    id: 'dxos.org/script/forex',
+    id: 'org.dxos.script.forex',
     name: 'Forex',
     source: removeHeader(forex),
   },
   {
-    id: 'dxos.org/script/forex-effect',
+    id: 'org.dxos.script.forex-effect',
     name: 'Forex (Effect)',
     source: removeHeader(forexEffect),
   },
   {
-    id: 'dxos.org/script/gpt',
+    id: 'org.dxos.script.gpt',
     name: 'Gpt',
     source: removeHeader(chat),
-    presetId: 'dxos.org/function/gpt',
+    presetId: 'org.dxos.function.gpt',
   },
   {
-    id: 'dxos.org/script/chess',
-    name: 'Chess',
-    source: removeHeader(chess),
-    presetId: 'dxos.org/function/chess',
+    id: 'org.dxos.script.chess-bot',
+    name: 'Chess Bot',
+    source: removeHeader(chessBot),
+    presetId: 'org.dxos.function.chess-bot',
   },
   {
-    id: 'dxos.org/script/email',
+    id: 'org.dxos.script.email',
     name: 'Email',
     source: removeHeader(email),
-    presetId: 'dxos.org/function/email',
+    presetId: 'org.dxos.function.email',
   },
   {
-    id: 'dxos.org/script/discord',
+    id: 'org.dxos.script.discord',
     name: 'Discord',
     source: removeHeader(discord),
-    presetId: 'dxos.org/function/discord',
+    presetId: 'org.dxos.function.discord',
   },
   {
-    id: 'dxos.org/script/gmail',
+    id: 'org.dxos.script.gmail',
     name: 'Gmail',
     source: removeHeader(gmail),
-    presetId: 'dxos.org/function/gmail',
+    presetId: 'org.dxos.function.gmail',
   },
   {
-    id: 'dxos.org/script/data-generator',
+    id: 'org.dxos.script.data-generator',
     name: 'Data Generator',
     source: removeHeader(dataGenerator),
-    presetId: 'dxos.org/function/data-generator',
+    presetId: 'org.dxos.function.data-generator',
+  },
+  {
+    id: 'org.dxos.script.anthropic',
+    name: 'Anthropic',
+    source: removeHeader(anthropic),
+  },
+  {
+    id: 'org.dxos.script.commentary',
+    name: 'Commentary',
+    source: removeHeader(commentary),
+    presetId: 'org.dxos.function.chess.commentary',
   },
 ] as const;

package/src/templates/ping.ts

@@ -1,8 +1,25 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-/**
- * Echos the request data.
- */
-export default async ({ data }: any) => data;
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/operation';
+
+const Ping = Operation.make({
+  meta: {
+    key: 'org.dxos.script.ping',
+    name: 'Ping',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+});
+
+export default Ping.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (data) {
+      return data;
+    }),
+  ),
+);

package/src/testing/simulator.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import * as Record from 'effect/Record';
+import { describe, expect, test } from 'vitest';
+
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionWorker } from '@dxos/functions-simulator-cloudflare';
+import { ErrorCodec } from '@dxos/protocols';
+
+// Requires downloading assets from R2
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Run script in sumulator', () => {
+  test('forex-effect', { timeout: 120_000 }, async () => {
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+
+    const worker = new FunctionWorker({
+      mainModule: buildResult.entryPoint,
+      modules: Record.map(buildResult.assets, (contents, filename) => ({
+        contents: contents as Uint8Array<ArrayBuffer>,
+        contentType: filename.endsWith('.wasm') ? 'application/wasm' : 'application/javascript',
+      })),
+    });
+
+    const result = await worker.invoke({ from: 'USD', to: 'EUR' });
+    console.log(result);
+    if (result._kind === 'error') {
+      throw ErrorCodec.decode(result.error);
+    }
+    expect(Number(result.result)).toBeGreaterThan(0);
+  });
+});

package/src/translations.ts

@@ -17,8 +17,10 @@ export const translations = [
         'typename label_one': 'Script',
         'typename label_other': 'Scripts',
         'object name placeholder': 'New script',
+        'add object label': 'Add script',
         'rename object label': 'Rename script',
         'delete object label': 'Delete script',
+        'object deleted label': 'Script deleted',
       },
       [Notebook.Notebook.typename]: {
         'typename label': 'Notebook',
@@ -26,8 +28,10 @@ export const translations = [
         'typename label_one': 'Notebook',
         'typename label_other': 'Notebooks',
         'object name placeholder': 'New notebook',
+        'add object label': 'Add notebook',
         'rename object label': 'Rename notebook',
         'delete object label': 'Delete notebook',
+        'object deleted label': 'Notebook deleted',
       },
       [meta.id]: {
         'plugin name': 'Scripts',