@anchrd/colab-sdk 0.1.10 → 0.1.12

package/dist/boards/boards.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
+import { CardKind, CardKindsInput, TaskFields, TaskFieldsInput, TaskKind, TaskKindInput, } from "../card-kinds/card-kinds.js";
 import { ColumnId, ColumnType, TaskColumn } from "../columns/columns.js";
-import { Schedule } from "../dashboards/dashboards.js";
 import { idSchema } from "../ids/ids.js";
+import { Flag } from "../list-input.js";
 import { BoardShownKind, BoardSystem, NodeId, NodePerson } from "../nodes/nodes.js";
 import { IdempotencyKey, Rev } from "../primitives/primitives.js";
-import { TicketMove, TicketSubject, TicketSubjectRef } from "../validation/validation.js";
+import { Schedule } from "../schedule/schedule.js";
+import { TicketSubject, TicketSubjectRef } from "../validation/validation.js";
+import { TaskMove } from "../versions/versions.js";
 // Boards, their columns and labels, and tasks (#42, Nodes › Board, Nodes › Aufgabe, E38, E40, E41,
 // E43, E44, E67, E70): the inputs of `intelligence_board_create`, `_get`, `_update`,
 // `intelligence_board_task_list`, `_create`, `intelligence_task_get`, `_update`, and the answers. A
@@ -28,6 +31,8 @@ export const BoardKind = z
     .enum(boardKinds)
     .describe("board: a board people work on. process: a template whose runs the Operator works through, each a copy of its columns and tasks; it needs a machine (an Operator) with write on it, a first column of type backlog, and every task of the template in that first column.");
 const Name = z.string().max(200);
+// A column's description (#624), Markdown for every AI working on the board.
+const ColumnDescription = z.string().max(20_000);
 const ColumnInput = z.strictObject({
     columnId: ColumnId.optional().describe("The column to keep, as intelligence_board_get returned it. Leaving it out makes a new column."),
     name: Name.describe("The column's name as people read it."),
@@ -36,6 +41,7 @@ const ColumnInput = z.strictObject({
         .boolean()
         .optional()
         .describe("Whether the board shows the column. Leaving it out shows it, except the archive column, which is hidden by default."),
+    description: ColumnDescription.optional().describe("What holds for a card in this column and what an AI does or leaves there, Markdown. Every AI working on the board gets it with each read. An empty text removes it; leaving it out keeps it (a new column has none)."),
 });
 const Columns = z
     .array(ColumnInput)
@@ -50,15 +56,16 @@ export const BoardCreateInput = z.strictObject({
     idempotencyKey: IdempotencyKey,
 });
 export const BoardGetInput = z.strictObject({ boardId: BoardId });
-// The instruction of a board or a dashboard (E87, #354), Markdown for every AI working on it.
+// The instruction of a board (E87, #354), Markdown for every AI working on it.
 const BoardInstruction = z.string().max(200_000);
 export const BoardUpdateInput = z.strictObject({
     boardId: BoardId,
     rev: Rev,
     kind: BoardKind.optional().describe("Make the board a process or a board again. Saving a process is refused with conflict while no machine can write on the board, the first column is not of type backlog, or a task of the template stands outside the first column."),
-    schedule: Schedule.optional().describe("When a run of the process or of the validation falls due (Ausführung), as on a dashboard. Leaving it out keeps it; a board made a process without one runs by hand."),
+    schedule: Schedule.optional().describe("When a run of the process or of the validation falls due (Ausführung). Leaving it out keeps it; a board made a process without one runs by hand."),
     instruction: BoardInstruction.optional().describe("The board's instruction, Markdown: what the board is about and how every AI working on it goes about it. It comes along with every read of the board and its tasks over MCP. On the validation board only an admin in admin mode changes it. An empty text removes it; leaving it out keeps it."),
     columns: Columns.optional(),
+    cardKinds: CardKindsInput.optional(),
     labels: z
         .array(z.strictObject({
         labelId: LabelId.optional().describe("The label to keep or rename. Leaving it out makes a new label."),
@@ -73,6 +80,8 @@ export const BoardColumn = z.object({
     name: z.string(),
     type: ColumnType,
     visible: z.boolean(),
+    // Markdown, empty without one (#624).
+    description: z.string(),
 });
 export const BoardLabel = z.object({ labelId: LabelId, name: z.string() });
 // What stands between a board and saving it as a process (#43): the UI shows a box for each, and the
@@ -108,6 +117,8 @@ export const BoardDetail = z.object({
     // for every reader of the validation board; null without one and for every other board.
     validator: NodePerson.nullable(),
     columns: z.array(BoardColumn),
+    // The card kinds with their fields in order (#638, E115); empty on a board of free cards.
+    cardKinds: z.array(CardKind),
     labels: z.array(BoardLabel),
     rights: z.object({ write: z.boolean() }),
     rev: z.number().int(),
@@ -119,7 +130,9 @@ const TaskLimit = z.coerce
     .int()
     .min(1)
     .max(500)
-    .describe("How many tasks one page holds, 1 to 500. Leaving it out gives 200.");
+    .describe("How many tasks one page holds, 1 to 500. Leaving it out gives 200. With content at most 100, and leaving it out gives 100.");
+// The most tasks one call reads by id, creates or changes (#625, E114).
+export const maxBulkTasks = 100;
 export const BoardTaskListInput = z.strictObject({
     boardId: BoardId,
     runId: RunRef.optional().describe("The run of this process whose tasks and columns to list. Leaving it out lists the template, the board itself."),
@@ -128,6 +141,12 @@ export const BoardTaskListInput = z.strictObject({
     assigneeId: idSchema("user").optional().describe("Only the tasks assigned to this person."),
     labelId: LabelId.optional().describe("Only the tasks carrying this label."),
     parentTaskId: TaskId.optional().describe("Only the direct subtasks of this task."),
+    // Over REST one comma-separated value (`?taskIds=node_…,node_…`): a query string carries text.
+    taskIds: z
+        .preprocess((value) => (typeof value === "string" ? value.split(",") : value), z.array(TaskId).min(1).max(maxBulkTasks))
+        .optional()
+        .describe("Only these tasks of the board (of the run, with runId), 1 to 100, also from the archive column: one you cannot read or that is not there is left out without a note."),
+    content: Flag.optional().describe("true: every task also carries its Markdown text as content, beside its rev, so you check a whole board without reading task by task. A page then holds at most 100 tasks."),
     cursor: z
         .string()
         .max(1000)
@@ -157,9 +176,8 @@ const Position = z
     .max(100)
     .describe("The place in the column: a fractional-indexing key between the positions of the neighbours, as intelligence_board_task_list returns them. Leaving it out puts the task at the end of its column.");
 const Assignee = idSchema("user").describe("The one person responsible for the task, someone who can read the board. Leaving it out on create makes it you, on a process the first machine that can write on it.");
-export const BoardTaskCreateInput = z.strictObject({
-    boardId: BoardId,
-    runId: RunRef.optional().describe("Create the task in this running run of the process, in one of the run's columns. Leaving it out creates it in the template. A completed run takes no task."),
+// The fields of one new task, alone or as an entry of `tasks` (#625).
+const newTask = {
     title: Title,
     content: Content.optional(),
     columnId: ColumnId.optional().describe("The column to put the task in. Leaving it out puts it in the board's first column."),
@@ -170,8 +188,42 @@ export const BoardTaskCreateInput = z.strictObject({
     parentTaskId: TaskId.optional().describe("Make it a subtask of this task of the same board; it is still a card of its own."),
     dependsOn: DependsOn.optional(),
     position: Position.optional(),
+    kind: TaskKindInput.optional(),
+    fields: TaskFieldsInput.optional(),
+};
+const Ref = z
+    .string()
+    .min(1)
+    .max(100)
+    .describe("Your own name for this task within the call, unique in it: parentRef and dependsOnRefs of other entries point to it, and the answer names its taskId under it.");
+// One entry of `tasks`: a task like the single create, plus a ref other entries point to.
+const NewTaskEntry = z.strictObject({
+    ref: Ref,
+    ...newTask,
+    parentRef: Ref.optional().describe("Make it a subtask of the entry of this call with this ref. Not together with parentTaskId."),
+    dependsOnRefs: z
+        .array(Ref)
+        .max(maxBulkTasks)
+        .optional()
+        .describe("The entries of this call this task waits for, by their ref; beside dependsOn."),
+});
+export const BoardTaskCreateInput = z.strictObject({
+    boardId: BoardId,
+    runId: RunRef.optional().describe("Create the task in this running run of the process, in one of the run's columns. Leaving it out creates it in the template. A completed run takes no task."),
+    ...newTask,
+    title: Title.optional().describe("The task's title, for one task. To create several, leave it out and send tasks."),
+    tasks: z
+        .array(NewTaskEntry)
+        .min(1)
+        .max(maxBulkTasks)
+        .optional()
+        .describe("Several tasks at once, 1 to 100, instead of the fields of one: a whole structure of tasks, subtasks and waits in one call. All or nothing: if one entry is invalid, none is created and issues names every entry that is. The answer names taskId and rev under each ref. idempotencyKey covers the whole call."),
     idempotencyKey: IdempotencyKey,
 });
+// The answer to `intelligence_board_task_create` with `tasks` (#625): each entry under its ref.
+export const BoardTaskCreated = z.object({
+    tasks: z.array(z.object({ ref: z.string(), taskId: NodeId, rev: z.number().int() })),
+});
 export const TaskGetInput = z.strictObject({ taskId: TaskId });
 export const TaskUpdateInput = z.strictObject({
     taskId: TaskId,
@@ -192,6 +244,8 @@ export const TaskUpdateInput = z.strictObject({
         .describe("Hang the task under this task of the same board; null makes it a task of its own again."),
     dependsOn: DependsOn.optional(),
     position: Position.optional(),
+    kind: TaskKindInput.optional().describe("Only to confirm: a card never changes its kind, so any other kind than its own is invalid."),
+    fields: TaskFieldsInput.optional(),
     waiting: z
         .boolean()
         .optional()
@@ -200,7 +254,28 @@ export const TaskUpdateInput = z.strictObject({
         .string()
         .max(10_000)
         .optional()
-        .describe("Only on a ticket of the validation board, together with columnId: why it moves, kept in the ticket's history. Elsewhere it is invalid."),
+        .describe("Only together with columnId: why the task moves. Kept in the version the move makes; without a move it is invalid."),
+    editSession: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("The editing session the browser keeps while a person stays on the task: its saves go into one version, a move always into its own. Leaving it out makes every change a version of its own, which is right for an AI."),
+});
+// Many tasks of one board or run changed in one call (#625, E114): only by id, each with its rev,
+// all or nothing.
+export const BoardTaskUpdateInput = z.strictObject({
+    boardId: BoardId,
+    runId: RunRef.optional().describe("The running run of the process whose tasks these are. Leaving it out changes tasks of the template, the board itself."),
+    tasks: z
+        .array(TaskUpdateInput)
+        .min(1)
+        .max(maxBulkTasks)
+        .describe("The tasks to change, 1 to 100, each once, with taskId, the rev you read and the fields of intelligence_task_update. All or nothing: if one is invalid or someone saved one in between, nothing changes and issues names every entry concerned."),
+});
+// The answer: each task with the rev its next change sends, in the order given.
+export const BoardTaskUpdated = z.object({
+    tasks: z.array(z.object({ taskId: NodeId, rev: z.number().int() })),
 });
 // An image linked in a task's content: an outside URL, or a file in Colab the caller can read.
 export const TaskImage = z.union([
@@ -223,6 +298,10 @@ export const BoardTaskItem = z.object({
     // Everything it waits for is in a column of type done or discarded (true without any).
     ready: z.boolean(),
     images: z.array(TaskImage),
+    // The card's kind and the values of its fields by name (#638, E115); null and {} on a board
+    // without kinds.
+    kind: TaskKind.nullable(),
+    fields: TaskFields,
     // A ticket of the validation board (#47): the node it validates; null for every other task.
     subject: TicketSubjectRef.nullable(),
     // Whether the caller may change this task, as intelligence_task_update decides it: the board's
@@ -232,6 +311,8 @@ export const BoardTaskItem = z.object({
     position: z.string(),
     rev: z.number().int(),
     updatedAt: z.iso.datetime(),
+    // Only with `content: true` (#625): the task's Markdown text.
+    content: z.string().optional(),
 });
 export const BoardTaskList = z.object({
     items: z.array(BoardTaskItem),
@@ -239,8 +320,17 @@ export const BoardTaskList = z.object({
     // Over MCP only (E87, #354): the board's instruction, a run's copy of it with `runId`; null
     // without one.
     instruction: z.string().nullable().optional(),
+    // Over MCP only (#624): every column of the board (of the run, with `runId`) in order, with its
+    // description, once per page.
+    columns: z.array(BoardColumn).optional(),
+});
+// A subtask or a task waited for; `kind` its card kind (#638), null without one.
+const TaskRef = z.object({
+    taskId: NodeId,
+    title: z.string(),
+    column: TaskColumn,
+    kind: TaskKind.nullable(),
 });
-const TaskRef = z.object({ taskId: NodeId, title: z.string(), column: TaskColumn });
 export const TaskDetail = z.object({
     taskId: NodeId,
     boardId: NodeId,
@@ -270,14 +360,19 @@ export const TaskDetail = z.object({
     dependencies: z.array(TaskRef),
     ready: z.boolean(),
     images: z.array(TaskImage),
+    // The card's kind and the values of its fields by name (#638, E115); null and {} on a board
+    // without kinds.
+    kind: TaskKind.nullable(),
+    fields: TaskFields,
     rights: z.object({ write: z.boolean() }),
     // The task waits (#377, E77): its assignee lacks something, a right above all, and asked in the
     // chat. Shown in place of the column; null while it does not wait.
     waiting: z.object({ since: z.iso.datetime(), by: NodePerson }).nullable(),
-    // A ticket of the validation board (#47): the node it validates with its path, and every move,
-    // newest first. Both null for every other task.
+    // A ticket of the validation board (#47): the node it validates with its path, and its last move
+    // from its versions (E117), null before its first. Both null for every other task; the history of
+    // every task stands in intelligence_node_version_list.
     subject: TicketSubject.nullable(),
-    history: z.array(TicketMove).nullable(),
+    lastMove: TaskMove.nullable(),
     createdBy: NodePerson,
     rev: z.number().int(),
     archivedAt: z.iso.datetime().nullable(),
@@ -286,4 +381,7 @@ export const TaskDetail = z.object({
     // Over MCP only (E87, #354): the instruction of the task's board, of its run for a run's task;
     // null without one.
     instruction: z.string().nullable().optional(),
+    // Over MCP only (#624): every column of the task's board (of its run for a run's task) in order,
+    // with its description; `current` marks the task's own.
+    columns: z.array(BoardColumn.extend({ current: z.boolean() })).optional(),
 });

package/dist/card-kinds/card-kinds.d.ts

@@ -0,0 +1,265 @@
+import { z } from "zod";
+export declare const CardKindId: z.ZodTemplateLiteral<`kind_${string}`>;
+export type CardKindId = z.infer<typeof CardKindId>;
+export declare const CardFieldId: z.ZodTemplateLiteral<`field_${string}`>;
+export type CardFieldId = z.infer<typeof CardFieldId>;
+export declare const CardOptionId: z.ZodTemplateLiteral<`option_${string}`>;
+export type CardOptionId = z.infer<typeof CardOptionId>;
+export declare const cardFieldTypes: readonly ["text", "list", "checklist", "number", "date", "link", "select"];
+export declare const CardFieldType: z.ZodEnum<{
+    number: "number";
+    date: "date";
+    list: "list";
+    link: "link";
+    text: "text";
+    checklist: "checklist";
+    select: "select";
+}>;
+export type CardFieldType = z.infer<typeof CardFieldType>;
+export declare const cardKindIcons: readonly ["flag", "route", "arrow-right", "square-check", "file-text", "bulb", "target", "search", "user", "calendar", "star", "bolt", "bug", "message", "package", "rocket"];
+export declare const CardKindIcon: z.ZodEnum<{
+    message: "message";
+    user: "user";
+    package: "package";
+    search: "search";
+    flag: "flag";
+    route: "route";
+    "arrow-right": "arrow-right";
+    "square-check": "square-check";
+    "file-text": "file-text";
+    bulb: "bulb";
+    target: "target";
+    calendar: "calendar";
+    star: "star";
+    bolt: "bolt";
+    bug: "bug";
+    rocket: "rocket";
+}>;
+export type CardKindIcon = z.infer<typeof CardKindIcon>;
+export declare const CardFieldOptionInput: z.ZodObject<{
+    optionId: z.ZodOptional<z.ZodTemplateLiteral<`option_${string}`>>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export declare const CardFieldInput: z.ZodObject<{
+    fieldId: z.ZodOptional<z.ZodTemplateLiteral<`field_${string}`>>;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        date: "date";
+        list: "list";
+        link: "link";
+        text: "text";
+        checklist: "checklist";
+        select: "select";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        optionId: z.ZodOptional<z.ZodTemplateLiteral<`option_${string}`>>;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CardFieldInput = z.infer<typeof CardFieldInput>;
+export declare const CardKindInput: z.ZodObject<{
+    kindId: z.ZodOptional<z.ZodTemplateLiteral<`kind_${string}`>>;
+    name: z.ZodString;
+    icon: z.ZodOptional<z.ZodEnum<{
+        message: "message";
+        user: "user";
+        package: "package";
+        search: "search";
+        flag: "flag";
+        route: "route";
+        "arrow-right": "arrow-right";
+        "square-check": "square-check";
+        "file-text": "file-text";
+        bulb: "bulb";
+        target: "target";
+        calendar: "calendar";
+        star: "star";
+        bolt: "bolt";
+        bug: "bug";
+        rocket: "rocket";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    standard: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodOptional<z.ZodTemplateLiteral<`field_${string}`>>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            date: "date";
+            list: "list";
+            link: "link";
+            text: "text";
+            checklist: "checklist";
+            select: "select";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            optionId: z.ZodOptional<z.ZodTemplateLiteral<`option_${string}`>>;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CardKindInput = z.infer<typeof CardKindInput>;
+export declare const CardKindsInput: z.ZodArray<z.ZodObject<{
+    kindId: z.ZodOptional<z.ZodTemplateLiteral<`kind_${string}`>>;
+    name: z.ZodString;
+    icon: z.ZodOptional<z.ZodEnum<{
+        message: "message";
+        user: "user";
+        package: "package";
+        search: "search";
+        flag: "flag";
+        route: "route";
+        "arrow-right": "arrow-right";
+        "square-check": "square-check";
+        "file-text": "file-text";
+        bulb: "bulb";
+        target: "target";
+        calendar: "calendar";
+        star: "star";
+        bolt: "bolt";
+        bug: "bug";
+        rocket: "rocket";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    standard: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodOptional<z.ZodTemplateLiteral<`field_${string}`>>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            date: "date";
+            list: "list";
+            link: "link";
+            text: "text";
+            checklist: "checklist";
+            select: "select";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            optionId: z.ZodOptional<z.ZodTemplateLiteral<`option_${string}`>>;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const CardFieldOption: z.ZodObject<{
+    optionId: z.ZodTemplateLiteral<`option_${string}`>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type CardFieldOption = z.infer<typeof CardFieldOption>;
+export declare const CardField: z.ZodObject<{
+    fieldId: z.ZodTemplateLiteral<`field_${string}`>;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        date: "date";
+        list: "list";
+        link: "link";
+        text: "text";
+        checklist: "checklist";
+        select: "select";
+    }>;
+    description: z.ZodString;
+    required: z.ZodBoolean;
+    visible: z.ZodBoolean;
+    options: z.ZodArray<z.ZodObject<{
+        optionId: z.ZodTemplateLiteral<`option_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CardField = z.infer<typeof CardField>;
+export declare const CardKind: z.ZodObject<{
+    kindId: z.ZodTemplateLiteral<`kind_${string}`>;
+    name: z.ZodString;
+    icon: z.ZodEnum<{
+        message: "message";
+        user: "user";
+        package: "package";
+        search: "search";
+        flag: "flag";
+        route: "route";
+        "arrow-right": "arrow-right";
+        "square-check": "square-check";
+        "file-text": "file-text";
+        bulb: "bulb";
+        target: "target";
+        calendar: "calendar";
+        star: "star";
+        bolt: "bolt";
+        bug: "bug";
+        rocket: "rocket";
+    }>;
+    description: z.ZodString;
+    standard: z.ZodBoolean;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodTemplateLiteral<`field_${string}`>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            date: "date";
+            list: "list";
+            link: "link";
+            text: "text";
+            checklist: "checklist";
+            select: "select";
+        }>;
+        description: z.ZodString;
+        required: z.ZodBoolean;
+        visible: z.ZodBoolean;
+        options: z.ZodArray<z.ZodObject<{
+            optionId: z.ZodTemplateLiteral<`option_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CardKind = z.infer<typeof CardKind>;
+export declare const TaskKind: z.ZodObject<{
+    kindId: z.ZodTemplateLiteral<`kind_${string}`>;
+    name: z.ZodString;
+    icon: z.ZodEnum<{
+        message: "message";
+        user: "user";
+        package: "package";
+        search: "search";
+        flag: "flag";
+        route: "route";
+        "arrow-right": "arrow-right";
+        "square-check": "square-check";
+        "file-text": "file-text";
+        bulb: "bulb";
+        target: "target";
+        calendar: "calendar";
+        star: "star";
+        bolt: "bolt";
+        bug: "bug";
+        rocket: "rocket";
+    }>;
+}, z.core.$strip>;
+export type TaskKind = z.infer<typeof TaskKind>;
+export declare const ChecklistItem: z.ZodObject<{
+    text: z.ZodString;
+    done: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChecklistItem = z.infer<typeof ChecklistItem>;
+export declare const CardFieldValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+    done: z.ZodBoolean;
+}, z.core.$strip>>]>;
+export type CardFieldValue = z.infer<typeof CardFieldValue>;
+export declare const TaskFields: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+    done: z.ZodBoolean;
+}, z.core.$strip>>]>>>;
+export type TaskFields = z.infer<typeof TaskFields>;
+export declare const TaskFieldsInput: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type TaskFieldsInput = z.infer<typeof TaskFieldsInput>;
+export declare function emptyValue(value: unknown): boolean;
+export declare const TaskKindInput: z.ZodString;

package/dist/card-kinds/card-kinds.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+// Card kinds and their fields (#638, E115, Nodes › Board › Kartenarten): a board has no card kind
+// (every card is Markdown) or several, and then every card has exactly one. A kind has a name, an
+// icon, a description in Markdown and its fields in a fixed order; a field has a name, a type, a
+// description, "required" and "visible on the card". Colab checks two things only: the type of every
+// value and that no required field is empty.
+//
+// Kinds, fields and options are rows of a board, no words of the grammar and no tools of their own:
+// `intelligence_board_update` takes the kinds as the whole list, like the columns. A task names its
+// values by the field's name (`fields`), so an AI reads and writes them without ids. ⚠️ The values
+// come in as a loose record and the handler checks them, so a wrong type is `invalid` with an issue
+// per field at both doors, not the MCP SDK's own wording.
+const ulid = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/);
+export const CardKindId = z
+    .templateLiteral([z.literal("kind"), z.literal("_"), ulid])
+    .describe("A card kind of this board, `kind_…`, as intelligence_board_get returned it.");
+export const CardFieldId = z
+    .templateLiteral([z.literal("field"), z.literal("_"), ulid])
+    .describe("A field of this card kind, `field_…`, as intelligence_board_get returned it.");
+export const CardOptionId = z
+    .templateLiteral([z.literal("option"), z.literal("_"), ulid])
+    .describe("An option of this select field, `option_…`, as intelligence_board_get returned it.");
+// The seven types of a field and what a value of each is (Nodes › Board › Kartenarten).
+export const cardFieldTypes = [
+    "text",
+    "list",
+    "checklist",
+    "number",
+    "date",
+    "link",
+    "select",
+];
+export const CardFieldType = z
+    .enum(cardFieldTypes)
+    .describe('What a field holds. text: Markdown as a string. list: points, an array of strings, one per line. checklist: points with a tick, an array of { text, done }. number: a number. date: a day, "YYYY-MM-DD". link: a node of Colab by its id `node_…`, or an address starting with http:// or https://. select: one of the field\'s options, by its name.');
+// The icons a card kind may carry, Tabler names (design/system: Tabler Icons).
+export const cardKindIcons = [
+    "flag",
+    "route",
+    "arrow-right",
+    "square-check",
+    "file-text",
+    "bulb",
+    "target",
+    "search",
+    "user",
+    "calendar",
+    "star",
+    "bolt",
+    "bug",
+    "message",
+    "package",
+    "rocket",
+];
+export const CardKindIcon = z
+    .enum(cardKindIcons)
+    .describe("The kind's icon, shown on every card of the kind and in its tab.");
+const Name = z.string().max(200);
+const Description = z.string().max(20_000);
+export const CardFieldOptionInput = z.strictObject({
+    optionId: CardOptionId.optional().describe("The option to keep (and rename). Leaving it out makes a new option."),
+    name: Name.describe("The option's name, unique within the field whatever its case."),
+});
+export const CardFieldInput = z.strictObject({
+    fieldId: CardFieldId.optional().describe("The field to keep, as intelligence_board_get returned it. Leaving it out makes a new field."),
+    name: Name.describe("The field's name, unique within the kind whatever its case; a card names its value by it."),
+    type: CardFieldType.describe("What the field holds. A field's type changes only while no card has a value in it; else the answer is conflict."),
+    description: Description.optional().describe("What belongs into the field, Markdown; the card shows it as the placeholder of an empty field. Leaving it out keeps it (a new field has none)."),
+    required: z
+        .boolean()
+        .optional()
+        .describe("true: a card of the kind is saved only with a value in it. Cards that already stand keep it empty until their next save. Leaving it out keeps it (a new field is not required)."),
+    visible: z
+        .boolean()
+        .optional()
+        .describe("true: the card on the board shows the value under its title. Leaving it out keeps it (a new field is not shown)."),
+    options: z
+        .array(CardFieldOptionInput)
+        .max(50)
+        .optional()
+        .describe("Only for type select: its options, all of them, in their order. An option left out is removed, and a card holding it is empty there."),
+});
+export const CardKindInput = z.strictObject({
+    kindId: CardKindId.optional().describe("The card kind to keep, as intelligence_board_get returned it. Leaving it out makes a new kind."),
+    name: Name.describe("The kind's name, unique on the board whatever its case."),
+    icon: CardKindIcon.optional().describe("The kind's icon. Leaving it out keeps it (a new kind gets square-check)."),
+    description: Description.optional().describe("What a card of this kind is, Markdown. An empty text removes it; leaving it out keeps it."),
+    standard: z
+        .boolean()
+        .optional()
+        .describe("true for the one kind a new card gets when it names none. Without any, the first kind is the standard."),
+    fields: z
+        .array(CardFieldInput)
+        .max(50)
+        .describe("The kind's fields, all of them, in their order: a field with fieldId is kept, one without is made, one left out is removed (its values stay in the versions of the cards)."),
+});
+export const CardKindsInput = z
+    .array(CardKindInput)
+    .max(20)
+    .describe("The board's card kinds, all of them, in their order: a kind with kindId is kept, one without is made, one left out is removed, which only a kind no card has can be. Once a board has kinds, every card has exactly one: the cards that stand get the standard kind when the first kind is made, and a card never changes its kind. Not on the validation board.");
+export const CardFieldOption = z.object({ optionId: CardOptionId, name: z.string() });
+export const CardField = z.object({
+    fieldId: CardFieldId,
+    name: z.string(),
+    type: CardFieldType,
+    // Markdown, empty without one.
+    description: z.string(),
+    required: z.boolean(),
+    visible: z.boolean(),
+    // Only a select field has options; empty for every other type.
+    options: z.array(CardFieldOption),
+});
+export const CardKind = z.object({
+    kindId: CardKindId,
+    name: z.string(),
+    icon: CardKindIcon,
+    // Markdown, empty without one.
+    description: z.string(),
+    standard: z.boolean(),
+    fields: z.array(CardField),
+});
+// A task's kind as its answers name it, null on a board without kinds.
+export const TaskKind = z.object({ kindId: CardKindId, name: z.string(), icon: CardKindIcon });
+export const ChecklistItem = z.object({ text: z.string(), done: z.boolean() });
+// A field's value as an answer carries it: text, date, link and select a string (select by the
+// option's name), a number, a list of strings, or a checklist. Null is empty.
+export const CardFieldValue = z.union([
+    z.string(),
+    z.number(),
+    z.array(z.string()),
+    z.array(ChecklistItem),
+]);
+// Every field of the task's kind in the kind's order, by name; null for an empty one.
+export const TaskFields = z.record(z.string(), CardFieldValue.nullable());
+export const TaskFieldsInput = z
+    .record(z.string().max(200), z.unknown())
+    .describe('The values of the card\'s fields by the field\'s name, as intelligence_board_get names the fields of its kind: only the fields given change, null (or an empty text or list) empties one. A value of the wrong type, a field the kind does not have, or a required field left empty is invalid, and issues names each field. Example: { "Ziel": "…", "Fertig wenn": ["…", "…"], "Abgenommen": [{ "text": "…", "done": false }], "Aufwand": 3, "Fällig": "2026-10-24", "Prüft": "node_…", "Priorität": "hoch" }.');
+// The checks of a value against its field (#638): the same rule in the backend, which refuses, and in
+// the UI, which keeps "Anlegen" closed. `empty` is what a required field may not be.
+export function emptyValue(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === "string")
+        return value.trim() === "";
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
+export const TaskKindInput = z
+    .string()
+    .min(1)
+    .max(200)
+    .describe("The card kind of the new card, by its name or its kindId. Leaving it out gives the board's standard kind; a board without kinds takes none. A card keeps its kind.");