@dxos/plugin-kanban 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/src/capabilities/artifact-definition.ts

@@ -1,148 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// ISSUE(burdon): defineArtifact
-// @ts-nocheck
-
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
-
-import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, type PromiseIntentDispatcher, chain, contributes, createIntent } from '@dxos/app-framework';
-import { createArtifactElement } from '@dxos/assistant';
-import { defineArtifact } from '@dxos/blueprints';
-import { Obj, Query } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, type Space } from '@dxos/react-client/echo';
-import { KanbanView } from '@dxos/react-ui-kanban';
-import { View } from '@dxos/schema';
-import { isNonNullable } from '@dxos/util';
-
-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: KanbanView,
-    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,
-            }),
-            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(View.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: 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.ids(id))))
-            .first()) as View.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);
-};

package/src/capabilities/blueprint-definition.ts

@@ -1,30 +0,0 @@
-//
-// 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';
-
-const functions: FunctionDefinition[] = [];
-const tools: string[] = [];
-
-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.
-          `,
-        }),
-      }),
-    ),
-  ];
-};

package/src/capabilities/intent-resolver.ts

@@ -1,66 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, type PluginContext, contributes, createResolver } from '@dxos/app-framework';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { getSpace } from '@dxos/react-client/echo';
-import { Kanban } from '@dxos/react-ui-kanban/types';
-import { ProjectionModel, View, getTypenameFromQuery } from '@dxos/schema';
-
-import { meta } from '../meta';
-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 { view } = await View.makeFromSpace({ client, space, typename, pivotFieldName: initialPivotColumn });
-        const kanban = Kanban.make({ name, view });
-        return { data: { object: kanban } };
-      },
-    }),
-    createResolver({
-      intent: KanbanAction.DeleteCardField,
-      resolve: async ({ view, fieldId, deletionData }, undo) => {
-        const schema = getSpace(view)?.db.schemaRegistry.getSchema(getTypenameFromQuery(view.query.ast)!);
-        invariant(schema);
-        const projection = new ProjectionModel(schema.jsonSchema, view.projection);
-
-        if (!undo) {
-          const { deleted, index } = projection.deleteFieldProjection(fieldId);
-          return {
-            undoable: {
-              message: ['card field deleted label', { ns: meta.id }],
-              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: meta.id }],
-              data: { card },
-            },
-          };
-        } else {
-          space.db.add(card);
-        }
-      },
-    }),
-  ]);

package/src/capabilities/react-surface.tsx

@@ -1,83 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type * as Schema from 'effect/Schema';
-import React, { useMemo } from 'react';
-
-import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { Obj, Type } from '@dxos/echo';
-import { findAnnotation } from '@dxos/effect';
-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 { type Collection } from '@dxos/schema';
-
-import { KanbanContainer, KanbanViewEditor } from '../components';
-import { meta } from '../meta';
-import { PivotColumnAnnotationId } from '../types';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: meta.id,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: Kanban.Kanban } => Obj.instanceOf(Kanban.Kanban, data.subject),
-      component: ({ data, role }) => <KanbanContainer object={data.subject} role={role} />,
-    }),
-    createSurface({
-      id: `${meta.id}/object-settings`,
-      role: 'object-settings',
-      position: 'hoist',
-      filter: (data): data is { subject: Kanban.Kanban } => Obj.instanceOf(Kanban.Kanban, data.subject),
-      component: ({ data }) => <KanbanViewEditor object={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 | Collection.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();
-        const [selectedSchema] = useMemo(
-          () => space?.db.schemaRegistry.query({ location: ['database', 'runtime'], typename }).runSync(),
-          [space, typename],
-        );
-        const singleSelectColumns = useMemo(() => {
-          const properties = Type.toJsonSchema(selectedSchema).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]);
-
-        if (!typename) {
-          return null;
-        }
-
-        return <SelectInput {...props} options={singleSelectColumns.map((column) => ({ value: column }))} />;
-      },
-    }),
-  ]);