@dxos/plugin-kanban 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/capabilities/artifact-definition.ts

@@ -5,23 +5,22 @@
 // ISSUE(burdon): defineArtifact
 // @ts-nocheck
 
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, type PromiseIntentDispatcher, chain, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability, type PromiseIntentDispatcher } from '@dxos/app-framework';
 import { createArtifactElement } from '@dxos/assistant';
-import { defineArtifact } from '@dxos/blueprints';
-import { Obj, Query } from '@dxos/echo';
+import { defineArtifact } from '@dxos/compute';
+import { Filter, Obj, Query, View } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, type Space, fullyQualifiedId } from '@dxos/react-client/echo';
-import { KanbanView } from '@dxos/react-ui-kanban';
-import { DataType } from '@dxos/schema';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { type Space } from '@dxos/react-client/echo';
+import { ViewModel } from '@dxos/schema';
 import { isNonNullable } from '@dxos/util';
 
-import { meta } from '../meta';
-import { KanbanAction } from '../types';
+import { meta } from '#meta';
+import { Kanban } from '#types';
 
 const QualifiedId = Schema.String.annotations({
   description: 'The fully qualified ID of the kanban `spaceID:objectID`',
@@ -34,115 +33,118 @@ declare global {
   }
 }
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`,
-    name: meta.name,
-    instructions: `
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const definition = defineArtifact({
+      id: `artifact:${meta.id}`,
+      name: meta.name,
+      instructions: `
       - Before adding items to a kanban board, inspect the board to see its schema
       - When adding items, you must not include the 'id' field -- it is automatically generated
       - BEFORE adding items, always make sure the board has been shown to the user!
     `,
-    schema: KanbanView,
-    tools: [
-      createTool(meta.id, {
-        name: 'create',
-        description: `
+      schema: Kanban.Kanban,
+      tools: [
+        createTool(meta.id, {
+          name: 'create',
+          description: `
             Create a new kanban board using an existing schema.
             Use schema_create first to create a schema, or schema_list to choose an existing one.`,
-        caption: 'Creating kanban board...',
-        schema: Schema.Struct({
-          typename: Schema.String.annotations({
-            description: 'The fully qualified name of the record type to use for the kanban cards.',
-          }),
-          pivotColumn: Schema.optional(Schema.String).annotations({
-            description: 'Optional field name to use as the column pivot.',
-          }),
-        }),
-        execute: async ({ typename, pivotColumn }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          invariant(extensions?.dispatch, 'No intent dispatcher');
-
-          // Validate schema exists first
-          const schema = await extensions.space.db.schemaRegistry.query({ typename }).firstOrUndefined();
-          if (!schema) {
-            return ToolResult.Error(`Schema not found: ${typename}`);
-          }
-
-          const intent = Function.pipe(
-            createIntent(KanbanAction.Create, {
-              space: extensions.space,
-              typename,
-              initialPivotColumn: pivotColumn,
+          caption: 'Creating kanban board...',
+          schema: Schema.Struct({
+            typename: Schema.String.annotations({
+              description: 'The fully qualified name of the record type to use for the kanban cards.',
             }),
-            chain(SpaceAction.AddObject, { target: extensions.space }),
-          );
-
-          const { data, error } = await extensions.dispatch(intent);
-          if (!data || error) {
-            return ToolResult.Error(error?.message ?? 'Failed to create kanban board');
-          }
-
-          return ToolResult.Success(createArtifactElement(data.id));
-        },
-      }),
-      createTool(meta.id, {
-        name: 'list',
-        description: 'List all kanban boards in the current space.',
-        caption: 'Listing kanban boards...',
-        schema: Schema.Struct({}),
-        execute: async (_input, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const space = extensions.space;
-          const { objects } = await space.db.query(Filter.type(DataType.View)).run();
-
-          const boardInfo = await Promise.all(
-            objects.map(async (view) => {
-              const kanban = await view.presentation.load();
-              if (!Obj.instanceOf(KanbanView, kanban)) {
-                return null;
-              }
-
-              return {
-                id: fullyQualifiedId(view),
-                name: view.name ?? 'Unnamed Kanban',
-                typename: view.query.typename,
-              };
+            pivotColumn: Schema.optional(Schema.String).annotations({
+              description: 'Optional field name to use as the column pivot.',
             }),
-          );
-
-          return ToolResult.Success(boardInfo.filter(isNonNullable));
-        },
-      }),
-      createTool(meta.id, {
-        name: 'inspect',
-        description: 'Get details about a specific kanban board.',
-        caption: 'Inspecting kanban board...',
-        schema: Schema.Struct({ id: QualifiedId }),
-        execute: async ({ id }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const space = extensions.space;
-          const view = (await space.db
-            // TODO(wittjosiah): Filter.and should aggregate type
-            .query(Query.select(Filter.and(Filter.type(DataType.View), Filter.ids(id))))
-            .first()) as DataType.View;
-
-          const kanban = await view.presentation.load();
-          invariant(Obj.instanceOf(KanbanView, kanban));
-
-          const typename = view.query.typename;
-          const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
-          invariant(schema);
-
-          return ToolResult.Success({
-            schema,
-            columnField: kanban.columnFieldId,
-            viewFields: view.projection.fields,
-          });
-        },
-      }),
-    ],
-  });
-
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
+          }),
+          execute: async ({ typename, pivotColumn }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.invoke, 'No operation invoker');
+
+            // Validate schema exists first
+            const schema = await extensions.space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+            if (!schema) {
+              return ToolResult.Error(`Schema not found: ${typename}`);
+            }
+
+            const { view } = await ViewModel.makeFromDatabase({
+              db: extensions.space.db,
+              typename,
+              pivotFieldName: pivotColumn,
+            });
+            const kanban = Kanban.make({ view });
+
+            const { error } = await extensions.invoke(SpaceOperation.AddObject, {
+              target: extensions.space,
+              object: kanban,
+            });
+            if (error) {
+              return ToolResult.Error(error?.message ?? 'Failed to add kanban board to space');
+            }
+
+            return ToolResult.Success(createArtifactElement(kanban.id));
+          },
+        }),
+        createTool(meta.id, {
+          name: 'list',
+          description: 'List all kanban boards in the current space.',
+          caption: 'Listing kanban boards...',
+          schema: Schema.Struct({}),
+          execute: async (_input, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const space = extensions.space;
+            const { objects } = await space.db.query(Filter.type(View.View)).run();
+
+            const boardInfo = await Promise.all(
+              objects.map(async (view) => {
+                const kanban = await view.presentation.load();
+                if (!Obj.instanceOf(Kanban.Kanban, kanban)) {
+                  return null;
+                }
+
+                return {
+                  id: Obj.getDXN(view).toString(),
+                  name: view.name ?? 'Unnamed Kanban',
+                  typename: view.query.typename,
+                };
+              }),
+            );
+
+            return ToolResult.Success(boardInfo.filter(isNonNullable));
+          },
+        }),
+        createTool(meta.id, {
+          name: 'inspect',
+          description: 'Get details about a specific kanban board.',
+          caption: 'Inspecting kanban board...',
+          schema: Schema.Struct({ id: QualifiedId }),
+          execute: async ({ id }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const space = extensions.space;
+            const view = (await space.db
+              // TODO(wittjosiah): Filter.and should aggregate type
+              .query(Query.select(Filter.and(Filter.type(View.View), Filter.id(id))))
+              .first()) as View.View;
+
+            const kanban = await view.presentation.load();
+            invariant(Obj.instanceOf(Kanban.Kanban, kanban));
+
+            const typename = view.query.typename;
+            const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+            invariant(schema);
+
+            return ToolResult.Success({
+              schema,
+              columnField: view.projection.pivotFieldId,
+              viewFields: view.projection.fields,
+            });
+          },
+        }),
+      ],
+    });
+
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -2,29 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import * as Effect from 'effect/Effect';
 
-const functions: FunctionDefinition[] = [];
-const tools: string[] = [];
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
-export default () => {
-  return [
-    contributes(Capabilities.Functions, functions),
-    contributes(
-      Capabilities.BlueprintDefinition,
-      Blueprint.make({
-        key: 'dxos.org/blueprint/kanban',
-        name: 'Kanban',
-        tools: Blueprint.toolDefinitions({ functions, tools }),
-        instructions: Template.make({
-          source: trim`
-            You can create and update kanban boards to show data in sorted columns defined by schema.
-          `,
-        }),
-      }),
-    ),
-  ];
-};
+import { KanbanBlueprint } from '#blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, KanbanBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/create-object.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { SpaceCapabilities } from '@dxos/plugin-space';
+import { ViewModel } from '@dxos/schema';
+
+import { CreateKanbanSchema, Kanban } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Type.getTypename(Kanban.Kanban),
+      inputSchema: CreateKanbanSchema,
+      createObject: (props, options) =>
+        Effect.gen(function* () {
+          const object = yield* Effect.promise(async () => {
+            const { view } = await ViewModel.makeFromDatabase({
+              db: options.db,
+              typename: props.typename,
+              pivotFieldName: props.initialPivotColumn,
+            });
+            return Kanban.make({ name: props.name, view });
+          });
+          return yield* Operation.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId,
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,8 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, OperationHandlerSet } from '@dxos/compute';
 
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const Migrations = Capability.lazy('Migrations', () => import('./migrations'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/migrations.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Migration } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { Kanban } from '#types';
+
+/**
+ * v0.1.0 → v0.2.0: nests the existing `view` ref under a `spec: { kind: 'view', view }`
+ * discriminated union. v0.2.0 introduced an items-variant for externally-synced kanbans;
+ * pre-migration objects were all view-based by construction.
+ */
+const migrations = [
+  Migration.define({
+    from: Kanban.KanbanV1,
+    to: Kanban.Kanban,
+    transform: async (from) => ({
+      name: from.name,
+      arrangement: from.arrangement,
+      spec: { kind: 'view' as const, view: from.view },
+    }),
+    onMigration: async () => {},
+  }),
+];
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(ClientCapabilities.Migration, migrations);
+  }),
+);

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,14 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { KanbanOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, KanbanOperationHandlerSet);
+  }),
+);

package/src/capabilities/react-surface.tsx

@@ -2,83 +2,93 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import React, { useMemo } from 'react';
 
-import { Capabilities, contributes, createSurface, useCapabilities } from '@dxos/app-framework';
-import { Obj, Type } from '@dxos/echo';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { type Collection, Database, JsonSchema, Obj } from '@dxos/echo';
 import { findAnnotation } from '@dxos/effect';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { type Space, getSpace, isSpace } from '@dxos/react-client/echo';
-import { type InputProps, SelectInput, useFormValues } from '@dxos/react-ui-form';
-import { Kanban } from '@dxos/react-ui-kanban/types';
-import { DataType } from '@dxos/schema';
+import { type FormFieldComponentProps, SelectField, useFormValues } from '@dxos/react-ui-form';
 
-import { KanbanContainer, KanbanViewEditor } from '../components';
-import { meta } from '../meta';
-import { PivotColumnAnnotationId } from '../types';
+import { KanbanArticle, KanbanSettings } from '#containers';
+import { Kanban, PivotColumnAnnotationId } from '#types';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: meta.id,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: DataType.View } =>
-        Obj.instanceOf(DataType.View, data.subject) && Obj.instanceOf(Kanban.Kanban, data.subject.presentation.target),
-      component: ({ data, role }) => <KanbanContainer view={data.subject} role={role} />,
-    }),
-    createSurface({
-      id: `${meta.id}/object-settings`,
-      role: 'object-settings',
-      position: 'hoist',
-      filter: (data): data is { subject: DataType.View } =>
-        Obj.instanceOf(DataType.View, data.subject) && Obj.instanceOf(Kanban.Kanban, data.subject.presentation.target),
-      component: ({ data }) => <KanbanViewEditor view={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/create-initial-schema-form-[pivot-column]`,
-      role: 'form-input',
-      filter: (
-        data,
-      ): data is { prop: string; schema: Schema.Schema<any>; target: Space | DataType.Collection | undefined } => {
-        const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, PivotColumnAnnotationId);
-        return !!annotation;
-      },
-      component: ({ data: { target }, ...inputProps }) => {
-        const props = inputProps as any as InputProps;
-        const space = isSpace(target) ? target : getSpace(target);
-        if (!space) {
-          return null;
-        }
-        const { typename } = useFormValues();
-        // TODO(wittjosiah): Unify this schema lookup.
-        const schemaWhitelists = useCapabilities(ClientCapabilities.SchemaWhiteList);
-        const staticSchema = schemaWhitelists.flat().find((schema) => Type.getTypename(schema) === typename);
-        const [selectedSchema] = space?.db.schemaRegistry.query({ typename }).runSync();
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'root',
+        // TODO(wittjosiah): Split into multiple surfaces if this filter proves too strict for non-article roles.
+        filter: AppSurface.oneOf(
+          AppSurface.object(AppSurface.Article, Kanban.Kanban),
+          AppSurface.object(AppSurface.Section, Kanban.Kanban),
+        ),
+        component: ({ data, role }) => <KanbanArticle role={role} subject={data.subject} />,
+      }),
+      Surface.create({
+        id: 'object-properties',
+        position: 'hoist',
+        filter: AppSurface.object(AppSurface.ObjectProperties, Kanban.Kanban),
+        component: ({ data }) => <KanbanSettings subject={data.subject} />,
+      }),
+      Surface.create({
+        id: 'create-initial-schema-form-[pivot-column]',
+        role: 'form-input',
+        filter: (
+          data,
+        ): data is {
+          prop: string;
+          schema: Schema.Schema<any>;
+          target: Database.Database | Collection.Collection | undefined;
+          fieldPropertyAst?: SchemaAST.AST;
+        } => {
+          const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, PivotColumnAnnotationId);
+          return !!annotation;
+        },
+        component: ({ data: { target, fieldPropertyAst }, ...inputProps }) => {
+          const ast = fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
 
-        const singleSelectColumns = useMemo(() => {
-          const properties = staticSchema
-            ? Type.toJsonSchema(staticSchema).properties
-            : selectedSchema?.jsonSchema?.properties;
-          if (!properties) {
-            return [];
+          const props = { ...inputProps, type: ast } as any as FormFieldComponentProps;
+          const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
+          if (!db) {
+            return null;
           }
 
-          const columns = Object.entries(properties).reduce<string[]>((acc, [key, value]) => {
-            if (typeof value === 'object' && value?.format === 'single-select') {
-              acc.push(key);
+          const { typename } = useFormValues('KanbanForm');
+          const [selectedSchema] = useMemo(
+            () => db.schemaRegistry.query({ location: ['database', 'runtime'], typename }).runSync(),
+            [db, typename],
+          );
+          const singleSelectColumns = useMemo(() => {
+            const properties = JsonSchema.toJsonSchema(selectedSchema).properties;
+            if (!properties) {
+              return [];
             }
-            return acc;
-          }, []);
 
-          return columns;
-        }, [selectedSchema?.jsonSchema, staticSchema]);
+            const columns = Object.entries(properties).reduce<string[]>((acc, [key, value]) => {
+              if (typeof value === 'object' && value?.format === 'single-select') {
+                acc.push(key);
+              }
+              return acc;
+            }, []);
+
+            return columns;
+          }, [selectedSchema]);
 
-        if (!typename) {
-          return null;
-        }
+          if (!typename) {
+            return null;
+          }
 
-        return <SelectInput {...props} options={singleSelectColumns.map((column) => ({ value: column }))} />;
-      },
-    }),
-  ]);
+          return <SelectField {...props} options={singleSelectColumns.map((column) => ({ value: column }))} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,34 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+
+import { meta } from '#meta';
+import { KanbanOperation } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.UndoMapping, [
+      UndoMapping.make({
+        operation: KanbanOperation.DeleteCardField,
+        inverse: KanbanOperation.RestoreCardField,
+        deriveContext: (input, output) => ({
+          view: input.view,
+          field: output.field,
+          props: output.props,
+          index: output.index,
+        }),
+        message: ['card-field-deleted.label', { ns: meta.id }],
+      }),
+      UndoMapping.make({
+        operation: KanbanOperation.DeleteCard,
+        inverse: KanbanOperation.RestoreCard,
+        deriveContext: (_input, output) => ({
+          card: output.card,
+        }),
+        message: ['card-deleted.label', { ns: meta.id }],
+      }),
+    ]),
+  ),
+);