@dxos/plugin-chess 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/blueprints/functions/create.ts

@@ -1,38 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { Database } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-
-import { Chess } from '../../types';
-
-export default defineFunction({
-  key: 'dxos.org/function/chess/create',
-  name: 'Create Chess',
-  description: 'Creates a new chess game.',
-  inputSchema: Schema.Struct({
-    name: Schema.optional(
-      Schema.String.annotations({
-        description: 'Name of the game.',
-      }),
-    ),
-    pgn: Schema.optional(
-      Schema.String.annotations({
-        description: 'Portable Game Notation.',
-      }),
-    ),
-    fen: Schema.optional(
-      Schema.String.annotations({
-        description: 'Forsyth-Edwards Notation.',
-      }),
-    ),
-  }),
-  outputSchema: Chess.Game,
-  handler: Effect.fn(function* ({ data: { name, pgn, fen } }) {
-    return yield* Database.add(Chess.make({ name, pgn, fen }));
-  }),
-});

package/src/blueprints/functions/index.ts

@@ -1,17 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import Create from './create';
-import Move from './move';
-import Play from './play';
-import Print from './print';
-
-export { Create, Move, Play, Print };
-
-export const ChessFunctions = {
-  Create,
-  Move,
-  Play,
-  Print,
-};

package/src/blueprints/functions/move.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Chess as ChessJS } from 'chess.js';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { Database, Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-
-import { Chess } from '../../types';
-
-export default defineFunction({
-  key: 'dxos.org/function/chess/move',
-  name: 'Move',
-  description: 'Makes a move in the given chess game.',
-  inputSchema: Schema.Struct({
-    game: Ref.Ref(Chess.Game).annotations({
-      description: 'The ID of the chess object.',
-    }),
-    move: Schema.String.annotations({
-      description: 'The move to make in the chess game.',
-      examples: ['e4', 'Bf3'],
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    pgn: Schema.String.annotations({
-      description: 'The PGN of the game after the move was played.',
-    }),
-  }),
-  handler: Effect.fn(function* ({ data: { game, move } }) {
-    const obj = yield* Database.load(game);
-    const chess = new ChessJS();
-    if (obj.pgn) {
-      chess.loadPgn(obj.pgn);
-    } else if (obj.fen) {
-      chess.load(obj.fen);
-    }
-
-    chess.move(move, { strict: false });
-    const pgn = chess.pgn();
-    Obj.change(obj, (obj) => {
-      obj.pgn = pgn;
-    });
-    return { pgn };
-  }),
-});

package/src/blueprints/functions/play.ts

@@ -1,58 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Chess as ChessJS } from 'chess.js';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { Database, Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-
-import { Chess } from '../../types';
-
-export default defineFunction({
-  key: 'dxos.org/function/chess/play',
-  name: 'Play',
-  description: 'Uses the chess engine to play the next move.',
-  inputSchema: Schema.Struct({
-    game: Ref.Ref(Chess.Game).annotations({
-      description: 'The ID of the chess object.',
-    }),
-    side: Schema.optional(Schema.Literal('white', 'black', 'any')).annotations({
-      description: 'The side to play.',
-      defaultValue: 'any',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    pgn: Schema.String.annotations({
-      description: 'The PGN of the game after the move was played.',
-    }),
-    move: Schema.optional(Schema.String).annotations({
-      description: 'The move that was played.',
-    }),
-  }),
-  handler: Effect.fn(function* ({ data: { game, side = 'any' } }) {
-    const object = yield* Database.load(game);
-    const chess = new ChessJS();
-    if (object.pgn) {
-      chess.loadPgn(object.pgn);
-    } else if (object.fen) {
-      chess.load(object.fen);
-    }
-
-    if (!(side === 'any' || (chess.turn() === 'w' && side === 'white') || (chess.turn() === 'b' && side === 'black'))) {
-      return { move: undefined, pgn: object.pgn! };
-    }
-
-    const moves = chess.moves();
-    const move = moves[Math.floor(Math.random() * moves.length)];
-
-    chess.move(move, { strict: false });
-    const pgn = chess.pgn();
-    Obj.change(object, (o) => {
-      o.pgn = pgn;
-    });
-    return { move, pgn };
-  }),
-});

package/src/blueprints/functions/print.ts

@@ -1,42 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Chess as ChessJS } from 'chess.js';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { defineFunction } from '@dxos/functions';
-
-export default defineFunction({
-  key: 'dxos.org/function/chess/print',
-  name: 'Print game',
-  description: 'Prints the chess game to ASCII.',
-  inputSchema: Schema.Struct({
-    pgn: Schema.optional(
-      Schema.String.annotations({
-        description: 'Portable Game Notation.',
-      }),
-    ),
-    fen: Schema.optional(
-      Schema.String.annotations({
-        description: 'Forsyth-Edwards Notation.',
-      }),
-    ),
-  }),
-  outputSchema: Schema.Struct({
-    ascii: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { pgn, fen } }) {
-    try {
-      const chess = new ChessJS(fen);
-      if (pgn) {
-        chess.loadPgn(pgn);
-      }
-      return { ascii: chess.ascii() };
-    } catch {
-      // TODO(burdon): Error handling?
-      return { ascii: '' };
-    }
-  }),
-});

package/src/capabilities/artifact-definition/artifact-definition.ts

@@ -1,135 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// ISSUE(burdon): defineArtifact
-// @ts-nocheck
-
-import { Chess as ChessJS } from 'chess.js';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, Capability, type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { ArtifactId, VersionPin, createArtifactElement } from '@dxos/assistant';
-import { defineArtifact } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { SpaceOperation } from '@dxos/plugin-space/types';
-import { Filter, type Space } from '@dxos/react-client/echo';
-import { trim } from '@dxos/util';
-
-import { meta } from '../../meta';
-import { Chess } from '../../types';
-
-// TODO(burdon): Factor out.
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
-
-export default Capability.makeModule(() =>
-  Effect.sync(() => {
-    const definition = defineArtifact({
-      id: `artifact:${meta.id}`,
-      name: meta.name,
-      description: 'Provides a simple chess engine.',
-      instructions: trim`
-      - If the user's message relates to a chess game, you must return the chess game inside the artifact tag as a valid FEN string with no additional text.
-      - Always inspect the chess game at the start of every prompt realting to a chess game, as it might have changed since the interaction.
-   `,
-      schema: Chess.Game,
-      tools: [
-        createTool(meta.id, {
-          name: 'create',
-          description: 'Create a new chess game. Returns the artifact definition for the game.',
-          caption: 'Creating chess game...',
-          schema: Schema.Struct({
-            pgn: Schema.String.annotations({ description: 'The state of the chess game in the PGN format.' }),
-          }),
-          execute: async ({ pgn }, { extensions }) => {
-            invariant(extensions?.space, 'No space');
-            invariant(extensions?.invoke, 'No operation invoker');
-
-            const game = Chess.make({ pgn });
-
-            const { data, error } = await extensions.invoke(SpaceOperation.AddObject, {
-              target: extensions.space,
-              object: game,
-            });
-            if (error) {
-              return ToolResult.Error(error?.message ?? 'Failed to add chess game to space');
-            }
-
-            return ToolResult.Success(createArtifactElement(game.id), [
-              VersionPin.createBlock(VersionPin.fromObject(game)),
-            ]);
-          },
-        }),
-        createTool(meta.id, {
-          name: 'list',
-          description: 'Query all active chess games.',
-          caption: 'Getting games...',
-          schema: Schema.Struct({}),
-          execute: async (_, { extensions }) => {
-            invariant(extensions?.space, 'No space');
-            const { objects: games } = await extensions.space.db.query(Filter.type(Chess.Game)).run();
-            invariant(games.length > 0, 'No chess games found');
-
-            return ToolResult.Success(games);
-          },
-        }),
-        createTool(meta.id, {
-          name: 'inspect',
-          description: 'Get the current state of the chess game.',
-          caption: 'Inspecting game...',
-          schema: Schema.Struct({ id: ArtifactId }),
-          execute: async ({ id }, { extensions }) => {
-            invariant(extensions?.space, 'No space');
-            const game = await extensions.space.db
-              .query(Filter.id(ArtifactId.toDXN(id, extensions.space.id).toString()))
-              .first();
-            invariant(Obj.instanceOf(Chess.Game, game));
-
-            return ToolResult.Success(game.pgn);
-          },
-        }),
-        createTool(meta.id, {
-          name: 'move',
-          description: 'Make a move in the chess game.',
-          caption: 'Making chess move...',
-          schema: Schema.Struct({
-            id: ArtifactId,
-            move: Schema.String.annotations({
-              description: 'The move to make in the chess game.',
-              examples: ['e4', 'Bf3'],
-            }),
-          }),
-          execute: async ({ id, move }, { extensions }) => {
-            invariant(extensions?.space, 'No space');
-            const game = await extensions.space.db
-              .query(Filter.id(ArtifactId.toDXN(id, extensions.space.id).toString()))
-              .first();
-            invariant(Obj.instanceOf(Chess.Game, game));
-
-            const chess = new ChessJS(game.pgn);
-            try {
-              chess.move(move);
-            } catch (error: any) {
-              return ToolResult.Error(error.message);
-            }
-
-            Obj.change(game, (g) => {
-              g.pgn = chess.pgn();
-            });
-            return ToolResult.Success(game.pgn);
-          },
-        }),
-      ],
-    });
-
-    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
-  }),
-);

package/src/capabilities/artifact-definition/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ArtifactDefinition = Capability.lazy('ArtifactDefinition', () => import('./artifact-definition'));

package/src/capabilities/blueprint-definition/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/react-surface/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import React from 'react';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { Surface } from '@dxos/app-framework/ui';
-import { Obj } from '@dxos/echo';
-
-import { ChessArticle, ChessCard } from '../../containers';
-import { meta } from '../../meta';
-import { Chess } from '../../types';
-
-export default Capability.makeModule(() =>
-  Effect.succeed(
-    Capability.contributes(Capabilities.ReactSurface, [
-      Surface.create({
-        id: meta.id,
-        role: ['article', 'section'],
-        filter: (data): data is { subject: Chess.Game } => Obj.instanceOf(Chess.Game, data.subject),
-        component: ({ data, role }) => <ChessArticle role={role} subject={data.subject} />,
-      }),
-      Surface.create({
-        id: meta.id,
-        role: ['card--content'],
-        filter: (data): data is { subject: Chess.Game } => Obj.instanceOf(Chess.Game, data.subject),
-        component: ({ data, role }) => <ChessCard role={role} subject={data.subject} />,
-      }),
-    ]),
-  ),
-);

package/src/cli/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './plugin';

package/src/cli/plugin.ts

@@ -1,27 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Plugin } from '@dxos/app-framework';
-import { AppPlugin } from '@dxos/app-toolkit';
-import { type CreateObject } from '@dxos/plugin-space/types';
-
-import { meta } from '../meta';
-import { Chess } from '../types';
-
-// TODO(wittjosiah): Factor out shared modules.
-export const ChessPlugin = Plugin.define(meta).pipe(
-  AppPlugin.addMetadataModule({
-    metadata: {
-      id: Chess.Game.typename,
-      metadata: {
-        createObject: ((props) => Effect.sync(() => Chess.make(props))) satisfies CreateObject,
-        addToCollectionOnCreate: true,
-      },
-    },
-  }),
-  AppPlugin.addSchemaModule({ schema: [Chess.Game] }),
-  Plugin.make,
-);