@dxos/plugin-kanban 0.8.3 → 0.8.4-main.1068cf700f

package/src/capabilities/artifact-definition.ts

@@ -1,136 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema, pipe } from 'effect';
-
-import { createTool, ToolResult } from '@dxos/ai';
-import { Capabilities, chain, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { defineArtifact } from '@dxos/artifact';
-import { createArtifactElement } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, fullyQualifiedId, type Space } from '@dxos/react-client/echo';
-import { KanbanType } from '@dxos/react-ui-kanban';
-
-import { meta } from '../meta';
-import { KanbanAction } from '../types';
-
-const QualifiedId = Schema.String.annotations({
-  description: 'The fully qualified ID of the kanban `spaceID:objectID`',
-});
-
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
-
-export default () => {
-  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: KanbanType,
-    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 typename of the schema 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 = pipe(
-            createIntent(KanbanAction.Create, {
-              space: extensions.space,
-              typename,
-              initialPivotColumn: pivotColumn,
-            }),
-            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: boards } = await space.db.query(Filter.type(KanbanType)).run();
-
-          const boardInfo = await Promise.all(
-            boards.map(async (board: KanbanType) => {
-              const view = await board.cardView?.load();
-              return {
-                id: fullyQualifiedId(board),
-                typename: view?.query.typename,
-              };
-            }),
-          );
-
-          return ToolResult.Success(boardInfo);
-        },
-      }),
-      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 { objects: boards } = await space.db.query(Filter.type(KanbanType)).run();
-          const board = boards.find((board: KanbanType) => fullyQualifiedId(board) === id);
-          invariant(Obj.instanceOf(KanbanType, board));
-
-          const view = await board.cardView?.load();
-          invariant(view);
-
-          const typename = view.query.typename;
-          const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
-          invariant(schema);
-
-          return ToolResult.Success({
-            schema,
-            columnField: board.columnFieldId,
-            viewFields: view.fields,
-          });
-        },
-      }),
-    ],
-  });
-
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};

package/src/capabilities/intent-resolver.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes, Capabilities, createResolver, type PluginContext } from '@dxos/app-framework';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { getSpace } from '@dxos/react-client/echo';
-import { ViewProjection } from '@dxos/schema';
-
-import { KANBAN_PLUGIN } from '../meta';
-import { initializeKanban } from '../testing';
-import { KanbanAction } from '../types';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: KanbanAction.Create,
-      resolve: async ({ space, name, typename, initialPivotColumn }) => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        const { kanban } = await initializeKanban({ client, space, name, typename, initialPivotColumn });
-        return { data: { object: kanban } };
-      },
-    }),
-    createResolver({
-      intent: KanbanAction.DeleteCardField,
-      resolve: ({ kanban, fieldId, deletionData }, undo) => {
-        invariant(kanban.cardView);
-        invariant(kanban.cardView.target?.query.typename);
-
-        const schema =
-          kanban.cardView.target &&
-          getSpace(kanban)?.db.schemaRegistry.getSchema(kanban.cardView.target.query.typename);
-        invariant(schema);
-        invariant(kanban.cardView.target);
-        const projection = new ViewProjection(schema.jsonSchema, kanban.cardView.target);
-
-        if (!undo) {
-          const { deleted, index } = projection.deleteFieldProjection(fieldId);
-          return {
-            undoable: {
-              message: ['card field deleted label', { ns: KANBAN_PLUGIN }],
-              data: { deletionData: { ...deleted, index } },
-            },
-          };
-        } else if (undo && deletionData) {
-          const { field, props, index } = deletionData;
-          projection.setFieldProjection({ field, props }, index);
-        }
-      },
-    }),
-    createResolver({
-      intent: KanbanAction.DeleteCard,
-      resolve: ({ card }, undo) => {
-        const space = getSpace(card);
-        invariant(space);
-
-        if (!undo) {
-          space.db.remove(card);
-          return {
-            undoable: {
-              message: ['card deleted label', { ns: KANBAN_PLUGIN }],
-              data: { card },
-            },
-          };
-        } else {
-          space.db.add(card);
-        }
-      },
-    }),
-  ]);

package/src/capabilities/react-surface.tsx

@@ -1,81 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Schema } from 'effect';
-import React, { useMemo } from 'react';
-
-import { Capabilities, contributes, createSurface, useCapabilities } from '@dxos/app-framework';
-import { Type } from '@dxos/echo';
-import { findAnnotation } from '@dxos/effect';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { getSpace, isSpace, type Space } from '@dxos/react-client/echo';
-import { type InputProps, SelectInput, useFormValues } from '@dxos/react-ui-form';
-import { type KanbanType } from '@dxos/react-ui-kanban';
-import { type DataType } from '@dxos/schema';
-
-import { KanbanContainer, KanbanViewEditor } from '../components';
-import { KANBAN_PLUGIN } from '../meta';
-import { isKanban, PivotColumnAnnotationId } from '../types';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${KANBAN_PLUGIN}/kanban`,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: KanbanType } => isKanban(data.subject),
-      component: ({ data, role }) => <KanbanContainer kanban={data.subject} role={role} />,
-    }),
-    createSurface({
-      id: `${KANBAN_PLUGIN}/object-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: KanbanType } => isKanban(data.subject),
-      component: ({ data }) => <KanbanViewEditor kanban={data.subject} />,
-    }),
-    createSurface({
-      id: `${KANBAN_PLUGIN}/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();
-
-        const singleSelectColumns = useMemo(() => {
-          const properties = staticSchema
-            ? Type.toJsonSchema(staticSchema).properties
-            : selectedSchema?.jsonSchema?.properties;
-          if (!properties) {
-            return [];
-          }
-
-          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?.jsonSchema, staticSchema]);
-
-        if (!typename) {
-          return null;
-        }
-
-        return <SelectInput {...props} options={singleSelectColumns.map((column) => ({ value: column }))} />;
-      },
-    }),
-  ]);

package/src/testing/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export * from './kanban-manager';
-export * from './initialize-kanban';

package/src/testing/initialize-kanban.ts

@@ -1,128 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Obj, Ref, Type } from '@dxos/echo';
-import { TypedObject, FormatEnum, TypeEnum, type JsonProp } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { type Client, PublicKey } from '@dxos/react-client';
-import { type Space } from '@dxos/react-client/echo';
-import { KanbanType } from '@dxos/react-ui-kanban';
-import { createView, ViewProjection, createFieldId, getSchemaProperties } from '@dxos/schema';
-import { capitalize } from '@dxos/util';
-
-// TODO(wittjosiah): UI package shouldn't depend on client.
-
-type InitializeKanbanProps = {
-  client: Client;
-  space: Space;
-  name?: string;
-  typename?: string;
-  initialPivotColumn?: string;
-};
-
-const createDefaultTaskSchema = () => {
-  const stateOptions = [
-    { id: PublicKey.random().truncate(), title: 'Draft', color: 'indigo' },
-    { id: PublicKey.random().truncate(), title: 'Active', color: 'cyan' },
-    { id: PublicKey.random().truncate(), title: 'Completed', color: 'emerald' },
-  ];
-
-  const schema = TypedObject({
-    typename: `example.com/type/${PublicKey.random().truncate()}`,
-    version: '0.1.0',
-  })({
-    title: Schema.optional(Schema.String).annotations({ title: 'Title' }),
-    description: Schema.optional(Schema.String).annotations({ title: 'Description' }),
-    state: Schema.optional(Schema.String),
-  });
-
-  return { schema, stateOptions };
-};
-
-export const initializeKanban = async ({
-  client,
-  space,
-  name,
-  typename,
-  initialPivotColumn,
-}: InitializeKanbanProps): Promise<{ kanban: KanbanType; schema?: Type.Schema }> => {
-  if (typename) {
-    const staticSchema = client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename);
-    const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
-
-    const ast = staticSchema?.ast ?? schema?.ast;
-    const jsonSchema = staticSchema ? Type.toJsonSchema(staticSchema) : schema?.jsonSchema;
-    invariant(ast, `Schema not found: ${typename}`);
-    invariant(jsonSchema, `Schema not found: ${typename}`);
-
-    const fields = getSchemaProperties(ast)
-      .filter((prop) => prop.type !== 'object' || prop.format === FormatEnum.Ref)
-      .map((prop) => prop.name);
-
-    const view = createView({
-      name: "Kanban's card view",
-      typename,
-      jsonSchema,
-      fields,
-    });
-
-    const kanban = Obj.make(KanbanType, { cardView: Ref.make(view), columnFieldId: undefined, name });
-    if (initialPivotColumn) {
-      const viewProjection = new ViewProjection(jsonSchema, view);
-      const fieldId = viewProjection.getFieldId(initialPivotColumn);
-      if (fieldId) {
-        kanban.columnFieldId = fieldId;
-      }
-    }
-    return { kanban, schema };
-  } else {
-    const { schema: taskSchema, stateOptions } = createDefaultTaskSchema();
-    const [schema] = await space.db.schemaRegistry.register([taskSchema]);
-
-    const view = createView({
-      name: "Kanban's card view",
-      typename: schema.typename,
-      jsonSchema: schema.jsonSchema,
-      fields: ['title', 'description'],
-    });
-
-    const viewProjection = new ViewProjection(schema.jsonSchema, view);
-
-    // Set description field to Markdown format.
-    const descriptionFieldId = viewProjection.getFieldId('description');
-    if (descriptionFieldId) {
-      const fieldProjection = viewProjection.getFieldProjection(descriptionFieldId);
-      if (fieldProjection) {
-        viewProjection.setFieldProjection({
-          ...fieldProjection,
-          props: { ...fieldProjection.props, format: FormatEnum.Markdown },
-        });
-      }
-    }
-
-    const initialPivotField = 'state';
-    viewProjection.setFieldProjection({
-      field: {
-        id: createFieldId(),
-        path: initialPivotField as JsonProp,
-        size: 150,
-      },
-      props: {
-        property: initialPivotField as JsonProp,
-        type: TypeEnum.String,
-        format: FormatEnum.SingleSelect,
-        title: capitalize(initialPivotField),
-        options: stateOptions,
-      },
-    });
-
-    const fieldId = viewProjection.getFieldId(initialPivotField);
-    invariant(fieldId);
-
-    const kanban = Obj.make(KanbanType, { cardView: Ref.make(view), columnFieldId: fieldId });
-    return { kanban, schema };
-  }
-};

package/src/testing/kanban-manager.ts

@@ -1,13 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import type { Locator, Page } from '@playwright/test';
-
-export class KanbanManager {
-  private readonly _page: Page;
-
-  constructor(readonly locator: Locator) {
-    this._page = locator.page();
-  }
-}

package/src/testing/playwright/playwright.config.cts

@@ -1,18 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { nxE2EPreset } from '@nx/playwright/preset';
-import { defineConfig } from '@playwright/test';
-
-import { e2ePreset } from '@dxos/test-utils/playwright';
-
-export default defineConfig({
-  ...nxE2EPreset(__filename, { testDir: __dirname }),
-  ...e2ePreset(__dirname),
-  webServer: {
-    command: 'pnpm -w nx storybook-e2e stories',
-    port: 9009,
-    reuseExistingServer: !process.env.CI,
-  },
-});

package/src/testing/playwright/smoke.spec.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import { test } from '@playwright/test';
-
-test.describe('Kanban', () => {});

package/src/types.ts

@@ -1,95 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { SpaceSchema } from '@dxos/react-client/echo';
-import { KanbanType } from '@dxos/react-ui-kanban';
-import { FieldSchema, TypenameAnnotationId } from '@dxos/schema';
-
-import { KANBAN_PLUGIN } from './meta';
-
-/**
- * Kanban data model.
- * A Kanban board is a collection of columns, each of which contains a collection of items.
- * The layout of columns and items is controlled by models.
- * The underlying data model may be represented by direct object relationships
- * (e.g., a column object containing an array of ordered items) or projections constructed
- * by the model (e.g., a query of items based on metadata within a column object).
- */
-
-// TODO(wittjosiah): Factor out?
-export const PivotColumnAnnotationId = Symbol.for('@dxos/plugin-kanban/annotation/PivotColumn');
-
-export const CreateKanbanSchema = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  typename: Schema.optional(
-    Schema.String.annotations({
-      [TypenameAnnotationId]: ['limited-static', 'dynamic'],
-      title: 'Select card schema (leave empty to start fresh)',
-    }),
-  ),
-  initialPivotColumn: Schema.optional(
-    Schema.String.annotations({
-      [PivotColumnAnnotationId]: true,
-      title: 'Pivot column',
-    }),
-  ),
-});
-
-export type CreateKanbanType = Schema.Schema.Type<typeof CreateKanbanSchema>;
-
-export namespace KanbanAction {
-  const KANBAN_ACTION = `${KANBAN_PLUGIN}/action`;
-
-  export class Create extends Schema.TaggedClass<Create>()(`${KANBAN_ACTION}/create`, {
-    input: Schema.extend(Schema.Struct({ space: SpaceSchema }), CreateKanbanSchema),
-    output: Schema.Struct({
-      object: KanbanType,
-    }),
-  }) {}
-
-  export class DeleteCardField extends Schema.TaggedClass<DeleteCardField>()(`${KANBAN_ACTION}/delete-card-field`, {
-    input: Schema.Struct({
-      kanban: KanbanType,
-      fieldId: Schema.String,
-      // TODO(wittjosiah): Separate fields for undo data?
-      deletionData: Schema.optional(
-        Schema.Struct({
-          field: FieldSchema,
-          // TODO(wittjosiah): This creates a type error.
-          // props: PropertySchema,
-          props: Schema.Any,
-          index: Schema.Number,
-        }),
-      ),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class DeleteCard extends Schema.TaggedClass<DeleteCard>()(`${KANBAN_ACTION}/delete-card`, {
-    input: Schema.Struct({
-      card: Schema.Any, // The card object to delete
-    }),
-    output: Schema.Void,
-  }) {}
-}
-
-// TODO(burdon): Undo?
-// TODO(burdon): Typescript types (replace proto with annotations?)
-// TODO(burdon): Should pure components depend on ECHO? Relationship between ECHO object/array and Observable.
-// TODO(burdon): Can the plugin configure the object based on the data? E.g., how are the models constructed?
-// TODO(burdon): Create models. Simple first based on actual data.
-//  Model is always a projection since the dragging state is tentative.
-
-// TODO(burdon): Extend model for moving items (in and across columns).
-export interface KanbanModel {
-  root: KanbanType;
-}
-
-export type Location = {
-  idx?: number;
-};
-
-export const isKanban = (object: unknown): object is KanbanType => object != null && object instanceof KanbanType;