@dxos/plugin-kanban 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/src/util/arrangement.test.ts

@@ -0,0 +1,218 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { beforeEach, describe, test } from 'vitest';
+
+import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { type View } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
+import { ViewModel } from '@dxos/schema';
+
+import { Kanban, UNCATEGORIZED_VALUE } from '#types';
+
+import {
+  computeColumnStructure,
+  computeItemArrangement,
+  getOrderByColumnFromArrangement,
+  getOrderFromArrangement,
+} from './arrangement';
+
+const selectOptions = [
+  { id: UNCATEGORIZED_VALUE, title: 'Uncategorized', color: 'neutral' },
+  { id: 'a', title: 'A', color: 'blue' },
+  { id: 'b', title: 'B', color: 'green' },
+];
+
+const MinimalSchema = Schema.Struct({ id: Schema.String }).pipe(
+  Type.object({ typename: 'test/Minimal', version: '0.1.0' }),
+);
+
+describe('arrangement utils', () => {
+  let view: View.View;
+
+  beforeEach(() => {
+    view = ViewModel.make({
+      query: Query.select(Filter.type(MinimalSchema)),
+      jsonSchema: JsonSchema.toJsonSchema(MinimalSchema),
+    });
+  });
+
+  describe('getOrderFromArrangement', () => {
+    test('returns copy of order when present', ({ expect }) => {
+      const arrangement = { order: ['a', 'b'], columns: {} };
+      expect(getOrderFromArrangement(arrangement)).toEqual(['a', 'b']);
+    });
+
+    test('returns copy of order from kanban arrangement', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['b', 'a'], columns: {} },
+      });
+      const order = getOrderFromArrangement(kanban.arrangement);
+      expect(order).toEqual(['b', 'a']);
+      order.push('x');
+      expect(getOrderFromArrangement(kanban.arrangement)).toEqual(['b', 'a']);
+    });
+
+    test('returns empty when arrangement or order missing or empty', ({ expect }) => {
+      expect(getOrderFromArrangement(undefined)).toEqual([]);
+      expect(getOrderFromArrangement({ order: [], columns: {} })).toEqual([]);
+      const kanbanEmptyOrder = Kanban.make({
+        view,
+        arrangement: { order: [], columns: {} },
+      });
+      expect(getOrderFromArrangement(kanbanEmptyOrder.arrangement)).toEqual([]);
+    });
+  });
+
+  describe('getOrderByColumnFromArrangement', () => {
+    test('returns per-column data with mutable id arrays', ({ expect }) => {
+      const arrangement = {
+        order: [],
+        columns: { a: { ids: ['i1'] } },
+      };
+      const byColumn = getOrderByColumnFromArrangement(arrangement);
+      expect(byColumn.a.ids).toEqual(['i1']);
+      byColumn.a.ids.push('i2');
+      expect(getOrderByColumnFromArrangement(arrangement).a.ids).toEqual(['i1']);
+    });
+
+    test('returns per-column ids and preserves hidden from kanban arrangement', ({ expect }) => {
+      const id1 = ObjectId.random();
+      const id2 = ObjectId.random();
+      const id3 = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: {
+          order: [],
+          columns: {
+            a: { ids: [id1, id2], hidden: true },
+            b: { ids: [id3] },
+          },
+        },
+      });
+      const byColumn = getOrderByColumnFromArrangement(kanban.arrangement);
+      expect(byColumn.a).toEqual({ ids: [id1, id2], hidden: true });
+      expect(byColumn.b).toEqual({ ids: [id3] });
+      expect(byColumn.b.hidden).toBeUndefined();
+    });
+
+    test('treats non-array ids as empty (Automerge / corrupt layout)', ({ expect }) => {
+      const arrangement = {
+        order: [],
+        columns: { a: { ids: {} as unknown as string[] }, b: { ids: ['ok'] } },
+      };
+      const byColumn = getOrderByColumnFromArrangement(arrangement);
+      expect(byColumn.a.ids).toEqual([]);
+      expect(byColumn.b.ids).toEqual(['ok']);
+    });
+
+    test('returns mutable copies', ({ expect }) => {
+      const idX = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: [], columns: { a: { ids: [idX] } } },
+      });
+      const byColumn = getOrderByColumnFromArrangement(kanban.arrangement);
+      byColumn.a.ids.push(ObjectId.random());
+      expect(getOrderByColumnFromArrangement(kanban.arrangement).a.ids).toEqual([idX]);
+    });
+
+    test('returns empty object when arrangement or columns missing', ({ expect }) => {
+      expect(getOrderByColumnFromArrangement(undefined)).toEqual({});
+      expect(getOrderByColumnFromArrangement({ order: [], columns: {} })).toEqual({});
+      const kanbanEmpty = Kanban.make({
+        view,
+        arrangement: { order: [], columns: {} },
+      });
+      expect(getOrderByColumnFromArrangement(kanbanEmpty.arrangement)).toEqual({});
+    });
+  });
+
+  describe('computeColumnStructure', () => {
+    test('uncategorized first, then effectiveOrder, then missing selectOptions', ({ expect }) => {
+      const effectiveOrder = ['b'];
+      const effectiveByColumn = { [UNCATEGORIZED_VALUE]: { ids: ['x'] }, b: { ids: ['y'] } };
+      const result = computeColumnStructure(effectiveOrder, effectiveByColumn, selectOptions);
+      expect(result.map((col) => col.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'b', 'a']);
+      expect(result[0].ids).toEqual(['x']);
+      expect(result[1].ids).toEqual(['y']);
+      expect(result[2].ids).toEqual([]);
+    });
+
+    test('does not duplicate uncategorized when already in effectiveOrder', ({ expect }) => {
+      const effectiveOrder = [UNCATEGORIZED_VALUE, 'a'];
+      const effectiveByColumn = {};
+      const result = computeColumnStructure(effectiveOrder, effectiveByColumn, selectOptions);
+      expect(result.map((col) => col.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'a', 'b']);
+    });
+  });
+
+  describe('computeItemArrangement', () => {
+    test('distributes items by pivotPath and preserves saved order within column', ({ expect }) => {
+      const idUc1 = ObjectId.random();
+      const idA1 = ObjectId.random();
+      const idA2 = ObjectId.random();
+      const idA3 = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: {
+          order: ['a', 'b'],
+          columns: {
+            [UNCATEGORIZED_VALUE]: { ids: [idUc1] },
+            a: { ids: [idA2, idA1] },
+            b: { ids: [] },
+          },
+        },
+      });
+      const items = [{ id: idA1, status: 'a' }, { id: idA2, status: 'a' }, { id: idA3, status: 'a' }, { id: idUc1 }];
+      const result = computeItemArrangement({
+        object: kanban,
+        items,
+        pivotPath: 'status',
+        selectOptions,
+      });
+      const colUncat = result.find((c) => c.columnValue === UNCATEGORIZED_VALUE);
+      const colA = result.find((c) => c.columnValue === 'a');
+      const colB = result.find((c) => c.columnValue === 'b');
+      expect(colUncat?.cards.map((c) => c.id)).toEqual([idUc1]);
+      expect(colA?.cards.map((c) => c.id)).toEqual([idA2, idA1, idA3]);
+      expect(colB?.cards.map((c) => c.id)).toEqual([]);
+    });
+
+    test('when pivotPath undefined all items go to uncategorized', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['a', 'b'], columns: { a: { ids: [] }, b: { ids: [] } } },
+      });
+      const items = [
+        { id: '1', status: 'a' },
+        { id: '2', status: 'b' },
+      ];
+      const result = computeItemArrangement({
+        object: kanban,
+        items,
+        selectOptions,
+      });
+      const colUncat = result.find((c) => c.columnValue === UNCATEGORIZED_VALUE);
+      const colA = result.find((c) => c.columnValue === 'a');
+      expect(colUncat?.cards.length).toBe(2);
+      expect(colA?.cards.length).toBe(0);
+    });
+
+    test('column order is uncategorized then selectOptions', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['a', 'b'], columns: {} },
+      });
+      const result = computeItemArrangement({
+        object: kanban,
+        items: [],
+        selectOptions,
+      });
+      expect(result.map((c) => c.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'a', 'b']);
+    });
+  });
+});

package/src/util/arrangement.ts

@@ -0,0 +1,177 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type SelectOption } from '@dxos/echo/internal';
+
+import {
+  type ArrangedCards,
+  type BaseKanbanItem,
+  type ColumnStructure,
+  type Kanban,
+  UNCATEGORIZED_VALUE,
+} from '#types';
+
+/**
+ * Column order from a raw arrangement object (e.g. when working with arrangement only).
+ *
+ * @param arrangement - Optional arrangement; reads order.
+ * @returns Mutable copy of order array, or empty if arrangement/order missing or empty.
+ */
+export const getOrderFromArrangement = (arrangement?: Kanban.Arrangement): string[] => {
+  const order = arrangement?.order;
+  if (order != null && Array.isArray(order) && order.length > 0) {
+    return [...order];
+  }
+
+  return [];
+};
+
+/**
+ * Per-column card id order and optional hidden flag from a raw arrangement object.
+ *
+ * Returns mutable copies so schema readonly does not leak to callers.
+ *
+ * @param arrangement - Optional arrangement; reads columns.
+ * @returns Map of column value → { ids, hidden? }; empty object if not set.
+ */
+export const getOrderByColumnFromArrangement = (
+  arrangement?: Kanban.Arrangement,
+): Record<string, { ids: string[]; hidden?: boolean }> => {
+  const columns = arrangement?.columns;
+  if (columns != null && Object.keys(columns).length > 0) {
+    return Object.fromEntries(
+      Object.entries(columns).map(([key, entry]) => {
+        const rawIds = entry.ids;
+        const ids = Array.isArray(rawIds) ? [...rawIds] : [];
+        return [key, { ids, ...(entry.hidden !== undefined && { hidden: entry.hidden }) }];
+      }),
+    );
+  }
+
+  return {};
+};
+
+/**
+ * Builds the ordered list of columns (value + ids) for the board model.
+ *
+ * Column order: uncategorized first, then effectiveOrder, then any
+ * selectOption ids not yet in order. Each entry gets the ids from
+ * effectiveByColumn for that column (or empty). Columns whose entry has
+ * `hidden: true` are dropped from the result — currently only the
+ * "Uncategorized" column is toggleable from settings, but the filter is
+ * generic so any column can be hidden via the same flag.
+ *
+ * @param effectiveOrder - Column order from arrangement (or previous merge).
+ * @param effectiveByColumn - Per-column card id order + hidden flag from arrangement.
+ * @param selectOptions - Defines valid column ids; any missing from order are appended.
+ * @returns ColumnStructure array in display order.
+ */
+export const computeColumnStructure = (
+  effectiveOrder: string[],
+  effectiveByColumn: Record<string, { ids: string[]; hidden?: boolean }>,
+  selectOptions: SelectOption[],
+): ColumnStructure[] => {
+  const order = [...effectiveOrder];
+  if (!order.includes(UNCATEGORIZED_VALUE)) {
+    order.unshift(UNCATEGORIZED_VALUE);
+  }
+
+  for (const opt of selectOptions) {
+    if (opt.id !== UNCATEGORIZED_VALUE && !order.includes(opt.id)) {
+      order.push(opt.id);
+    }
+  }
+
+  return order
+    .filter((columnValue) => effectiveByColumn[columnValue]?.hidden !== true)
+    .map((columnValue) => ({
+      columnValue,
+      ids: effectiveByColumn[columnValue]?.ids ?? [],
+    }));
+};
+
+/**
+ * Orders items for a single column: partition by saved order vs new, sort by orderMap, concatenate.
+ * Uses explicit null/undefined check for itemColumn so empty string is handled consistently.
+ *
+ * @param items - All items to filter.
+ * @param ids - Saved id order for this column.
+ * @param columnValue - Column id (e.g. UNCATEGORIZED_VALUE or option id).
+ * @param pivotPath - Item property key for column value (undefined = no pivot).
+ * @param validColumnValues - Set of valid option ids.
+ * @returns Items belonging to this column in display order.
+ */
+export const orderItemsInColumn = <T extends BaseKanbanItem>(
+  items: T[],
+  ids: string[],
+  columnValue: string,
+  pivotPath: string | undefined,
+  validColumnValues: Set<string>,
+): T[] => {
+  const orderMap = new Map(ids.map((id, index) => [id, index]));
+  const cardsWithExistingOrder: T[] = [];
+  const newCards: T[] = [];
+
+  for (const item of items) {
+    const itemColumn = pivotPath !== undefined ? (item[pivotPath as keyof T] as string | undefined) : undefined;
+    const isValidColumn = itemColumn != null && validColumnValues.has(itemColumn);
+    const belongsInColumn = columnValue === UNCATEGORIZED_VALUE ? !isValidColumn : itemColumn === columnValue;
+
+    if (belongsInColumn) {
+      (orderMap.has(item.id) ? cardsWithExistingOrder : newCards).push(item);
+    }
+  }
+
+  cardsWithExistingOrder.sort((a, b) => {
+    const indexA = orderMap.get(a.id) ?? Infinity;
+    const indexB = orderMap.get(b.id) ?? Infinity;
+    return indexA - indexB;
+  });
+
+  return [...cardsWithExistingOrder, ...newCards];
+};
+
+/**
+ * Computes the full item arrangement for the board: one entry per column with items in display order.
+ *
+ * Columns follow selectOptions order (uncategorized first, then each option). Within each column,
+ * cards that appear in the kanban's saved arrangement keep that order; any other cards in that
+ * column are appended after them.
+ *
+ * @param object - Kanban object whose arrangement holds per-column id order.
+ * @param items - All items to distribute into columns.
+ * @param pivotPath - Optional item property key whose value is the column id (e.g. status, priority).
+ * @param selectOptions - Defines valid column ids and their display order.
+ * @returns Array of { columnValue, cards } in column order, with cards ordered as above.
+ */
+export const computeItemArrangement = <T extends BaseKanbanItem = BaseKanbanItem>({
+  object,
+  items,
+  pivotPath,
+  selectOptions,
+}: {
+  object: Kanban.Kanban;
+  items: T[];
+  pivotPath?: string;
+  selectOptions: SelectOption[];
+}): ArrangedCards<T> => {
+  const validColumnValues = new Set(selectOptions.map((opt) => opt.id));
+  const byColumn = getOrderByColumnFromArrangement(object?.arrangement);
+
+  // Column order: uncategorized first, then each select option (skip
+  // uncategorized if duplicated). Columns whose arrangement entry has
+  // `hidden: true` are dropped — same generic hide-by-column flag used
+  // by `computeColumnStructure`.
+  const columnEntries = [
+    { columnValue: UNCATEGORIZED_VALUE, ids: byColumn[UNCATEGORIZED_VALUE]?.ids ?? [] },
+    ...selectOptions
+      .filter((opt) => opt.id !== UNCATEGORIZED_VALUE)
+      .map((opt) => ({ columnValue: opt.id, ids: byColumn[opt.id]?.ids ?? [] })),
+  ].filter((entry) => byColumn[entry.columnValue]?.hidden !== true);
+
+  return columnEntries.map(({ columnValue, ids }) => ({
+    columnValue,
+    cards: orderItemsInColumn(items, ids, columnValue, pivotPath, validColumnValues),
+  }));
+};

package/src/util/index.ts

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

package/dist/lib/browser/artifact-definition-H5MOHOV5.mjs

@@ -1,178 +0,0 @@
-import {
-  KanbanAction,
-  meta
-} from "./chunk-76UNDUHS.mjs";
-
-// src/capabilities/artifact-definition.ts
-import { Schema, pipe } from "effect";
-import { createTool, ToolResult } from "@dxos/ai";
-import { Capabilities, chain, contributes, createIntent } 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 } from "@dxos/react-client/echo";
-import { KanbanType } from "@dxos/react-ui-kanban";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-kanban/src/capabilities/artifact-definition.ts";
-var QualifiedId = Schema.String.annotations({
-  description: "The fully qualified ID of the kanban `spaceID:objectID`"
-});
-var artifact_definition_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", {
-            F: __dxlog_file,
-            L: 57,
-            S: void 0,
-            A: [
-              "extensions?.space",
-              "'No space'"
-            ]
-          });
-          invariant(extensions?.dispatch, "No intent dispatcher", {
-            F: __dxlog_file,
-            L: 58,
-            S: void 0,
-            A: [
-              "extensions?.dispatch",
-              "'No intent dispatcher'"
-            ]
-          });
-          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", {
-            F: __dxlog_file,
-            L: 89,
-            S: void 0,
-            A: [
-              "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) => {
-            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", {
-            F: __dxlog_file,
-            L: 112,
-            S: void 0,
-            A: [
-              "extensions?.space",
-              "'No space'"
-            ]
-          });
-          const space = extensions.space;
-          const { objects: boards } = await space.db.query(Filter.type(KanbanType)).run();
-          const board = boards.find((board2) => fullyQualifiedId(board2) === id);
-          invariant(Obj.instanceOf(KanbanType, board), void 0, {
-            F: __dxlog_file,
-            L: 116,
-            S: void 0,
-            A: [
-              "Obj.instanceOf(KanbanType, board)",
-              ""
-            ]
-          });
-          const view = await board.cardView?.load();
-          invariant(view, void 0, {
-            F: __dxlog_file,
-            L: 119,
-            S: void 0,
-            A: [
-              "view",
-              ""
-            ]
-          });
-          const typename = view.query.typename;
-          const schema = await space.db.schemaRegistry.query({
-            typename
-          }).firstOrUndefined();
-          invariant(schema, void 0, {
-            F: __dxlog_file,
-            L: 123,
-            S: void 0,
-            A: [
-              "schema",
-              ""
-            ]
-          });
-          return ToolResult.Success({
-            schema,
-            columnField: board.columnFieldId,
-            viewFields: view.fields
-          });
-        }
-      })
-    ]
-  });
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
-export {
-  artifact_definition_default as default
-};
-//# sourceMappingURL=artifact-definition-H5MOHOV5.mjs.map

package/dist/lib/browser/artifact-definition-H5MOHOV5.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/capabilities/artifact-definition.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Schema, pipe } from 'effect';\n\nimport { createTool, ToolResult } from '@dxos/ai';\nimport { Capabilities, chain, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';\nimport { defineArtifact } from '@dxos/artifact';\nimport { createArtifactElement } from '@dxos/assistant';\nimport { Obj } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\nimport { SpaceAction } from '@dxos/plugin-space/types';\nimport { Filter, fullyQualifiedId, type Space } from '@dxos/react-client/echo';\nimport { KanbanType } from '@dxos/react-ui-kanban';\n\nimport { meta } from '../meta';\nimport { KanbanAction } from '../types';\n\nconst QualifiedId = Schema.String.annotations({\n  description: 'The fully qualified ID of the kanban `spaceID:objectID`',\n});\n\ndeclare global {\n  interface ToolContextExtensions {\n    space?: Space;\n    dispatch?: PromiseIntentDispatcher;\n  }\n}\n\nexport default () => {\n  const definition = defineArtifact({\n    id: `artifact:${meta.id}`,\n    name: meta.name,\n    instructions: `\n      - Before adding items to a kanban board, inspect the board to see its schema\n      - When adding items, you must not include the 'id' field -- it is automatically generated\n      - BEFORE adding items, always make sure the board has been shown to the user!\n    `,\n    schema: KanbanType,\n    tools: [\n      createTool(meta.id, {\n        name: 'create',\n        description: `\n            Create a new kanban board using an existing schema.\n            Use schema_create first to create a schema, or schema_list to choose an existing one.`,\n        caption: 'Creating kanban board...',\n        schema: Schema.Struct({\n          typename: Schema.String.annotations({\n            description: 'The fully qualified typename of the schema to use for the kanban cards.',\n          }),\n          pivotColumn: Schema.optional(Schema.String).annotations({\n            description: 'Optional field name to use as the column pivot.',\n          }),\n        }),\n        execute: async ({ typename, pivotColumn }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          invariant(extensions?.dispatch, 'No intent dispatcher');\n\n          // Validate schema exists first\n          const schema = await extensions.space.db.schemaRegistry.query({ typename }).firstOrUndefined();\n          if (!schema) {\n            return ToolResult.Error(`Schema not found: ${typename}`);\n          }\n\n          const intent = pipe(\n            createIntent(KanbanAction.Create, {\n              space: extensions.space,\n              typename,\n              initialPivotColumn: pivotColumn,\n            }),\n            chain(SpaceAction.AddObject, { target: extensions.space }),\n          );\n\n          const { data, error } = await extensions.dispatch(intent);\n          if (!data || error) {\n            return ToolResult.Error(error?.message ?? 'Failed to create kanban board');\n          }\n\n          return ToolResult.Success(createArtifactElement(data.id));\n        },\n      }),\n      createTool(meta.id, {\n        name: 'list',\n        description: 'List all kanban boards in the current space.',\n        caption: 'Listing kanban boards...',\n        schema: Schema.Struct({}),\n        execute: async (_input, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          const space = extensions.space;\n          const { objects: boards } = await space.db.query(Filter.type(KanbanType)).run();\n\n          const boardInfo = await Promise.all(\n            boards.map(async (board: KanbanType) => {\n              const view = await board.cardView?.load();\n              return {\n                id: fullyQualifiedId(board),\n                typename: view?.query.typename,\n              };\n            }),\n          );\n\n          return ToolResult.Success(boardInfo);\n        },\n      }),\n      createTool(meta.id, {\n        name: 'inspect',\n        description: 'Get details about a specific kanban board.',\n        caption: 'Inspecting kanban board...',\n        schema: Schema.Struct({ id: QualifiedId }),\n        execute: async ({ id }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          const space = extensions.space;\n          const { objects: boards } = await space.db.query(Filter.type(KanbanType)).run();\n          const board = boards.find((board: KanbanType) => fullyQualifiedId(board) === id);\n          invariant(Obj.instanceOf(KanbanType, board));\n\n          const view = await board.cardView?.load();\n          invariant(view);\n\n          const typename = view.query.typename;\n          const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();\n          invariant(schema);\n\n          return ToolResult.Success({\n            schema,\n            columnField: board.columnFieldId,\n            viewFields: view.fields,\n          });\n        },\n      }),\n    ],\n  });\n\n  return contributes(Capabilities.ArtifactDefinition, definition);\n};\n"],
-  "mappings": "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",
-  "names": ["Schema", "pipe", "createTool", "ToolResult", "Capabilities", "chain", "contributes", "createIntent", "defineArtifact", "createArtifactElement", "Obj", "invariant", "SpaceAction", "Filter", "fullyQualifiedId", "KanbanType", "QualifiedId", "Schema", "String", "annotations", "description", "definition", "defineArtifact", "id", "meta", "name", "instructions", "schema", "KanbanType", "tools", "createTool", "caption", "Struct", "typename", "pivotColumn", "optional", "execute", "extensions", "invariant", "space", "dispatch", "db", "schemaRegistry", "query", "firstOrUndefined", "ToolResult", "Error", "intent", "pipe", "createIntent", "KanbanAction", "Create", "initialPivotColumn", "chain", "SpaceAction", "AddObject", "target", "data", "error", "message", "Success", "createArtifactElement", "_input", "objects", "boards", "Filter", "type", "run", "boardInfo", "Promise", "all", "map", "board", "view", "cardView", "load", "fullyQualifiedId", "find", "Obj", "instanceOf", "columnField", "columnFieldId", "viewFields", "fields", "contributes", "Capabilities", "ArtifactDefinition"]
-}