c0de-agent 1.6.0 → 1.8.0

package/dist/core/loop.js

@@ -1,4 +1,5 @@
 import { chatStream as llmChatStream } from '../llm/provider.js';
+import { createKanbanStore } from '../kanban/index.js';
 import { isContextOverflowFailure } from '../llm/provider-error.js';
 import { resolveRoute } from '../llm/registry.js';
 import { isLLMError } from '../llm/schema/errors.js';
@@ -607,6 +608,11 @@ async function* persistAssistantAndTools(state, deps, collectedText, validCalls)
                     state.todoPhases = phases;
                 },
             },
+            // kanban 工具通过 dependency-reversal 注入：per-project 的 db-backed store。
+            // 仅当 session 有 projectId 时启用（子 session 无 project 时不可用）。
+            ...(state.session.projectId
+                ? { kanbanStore: createKanbanStore(deps.db, state.session.projectId) }
+                : {}),
         }, validCalls, deps.hookRunner);
         const toolLatency = Date.now() - toolExecStart;
         const metricsEnabled = deps.config.toolMetrics.enabled;

package/dist/db/schema.d.ts

@@ -950,6 +950,301 @@ export declare const toolMetrics: import("drizzle-orm/pg-core").PgTableWithColum
     };
     dialect: "pg";
 }>;
+/**
+ * Kanban boards — one per project (unique projectId). Stores column/label
+ * configuration as JSON; cards live in kanban_cards.
+ */
+export declare const kanbanBoards: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "kanban_boards";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "kanban_boards";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "kanban_boards";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        columns: import("drizzle-orm/pg-core").PgColumn<{
+            name: "columns";
+            tableName: "kanban_boards";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        labels: import("drizzle-orm/pg-core").PgColumn<{
+            name: "labels";
+            tableName: "kanban_boards";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "kanban_boards";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "kanban_boards";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Kanban cards — tasks on a board. position is a real for fractional indexing
+ * (insert between two cards without rewriting all positions). columnId
+ * references a column id in the parent board's columns JSON.
+ */
+export declare const kanbanCards: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "kanban_cards";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        boardId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "board_id";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        title: import("drizzle-orm/pg-core").PgColumn<{
+            name: "title";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        columnId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "column_id";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priority: import("drizzle-orm/pg-core").PgColumn<{
+            name: "priority";
+            tableName: "kanban_cards";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "kanban_cards";
+            dataType: "number";
+            columnType: "PgReal";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        labels: import("drizzle-orm/pg-core").PgColumn<{
+            name: "labels";
+            tableName: "kanban_cards";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "kanban_cards";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "kanban_cards";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 /** Type exports for insert/select operations. */
 export type ProjectRow = typeof projects.$inferSelect;
 export type ProjectInsert = typeof projects.$inferInsert;
@@ -963,3 +1258,7 @@ export type FileSnapshotRow = typeof fileSnapshots.$inferSelect;
 export type FileSnapshotInsert = typeof fileSnapshots.$inferInsert;
 export type ToolMetricRow = typeof toolMetrics.$inferSelect;
 export type ToolMetricInsert = typeof toolMetrics.$inferInsert;
+export type KanbanBoardRow = typeof kanbanBoards.$inferSelect;
+export type KanbanBoardInsert = typeof kanbanBoards.$inferInsert;
+export type KanbanCardRow = typeof kanbanCards.$inferSelect;
+export type KanbanCardInsert = typeof kanbanCards.$inferInsert;

package/dist/db/schema.js

@@ -110,3 +110,39 @@ export const toolMetrics = pgTable('tool_metrics', {
 }, (table) => [
     uniqueIndex('uq_tool_metrics_model_tool_mode').on(table.model, table.tool, table.mode),
 ]);
+/**
+ * Kanban boards — one per project (unique projectId). Stores column/label
+ * configuration as JSON; cards live in kanban_cards.
+ */
+export const kanbanBoards = pgTable('kanban_boards', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: text('project_id')
+        .notNull()
+        .references(() => projects.id, { onDelete: 'cascade' }),
+    /** Column definitions: [{ id, name }] */
+    columns: jsonb('columns').notNull(),
+    /** Label definitions: [{ id, name, color }] */
+    labels: jsonb('labels').notNull().default([]),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [uniqueIndex('uq_kanban_boards_project').on(table.projectId)]);
+/**
+ * Kanban cards — tasks on a board. position is a real for fractional indexing
+ * (insert between two cards without rewriting all positions). columnId
+ * references a column id in the parent board's columns JSON.
+ */
+export const kanbanCards = pgTable('kanban_cards', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    boardId: uuid('board_id')
+        .notNull()
+        .references(() => kanbanBoards.id, { onDelete: 'cascade' }),
+    title: text('title').notNull(),
+    description: text('description'),
+    columnId: text('column_id').notNull(),
+    priority: text('priority').notNull().default('medium'),
+    position: real('position').notNull().default(0),
+    /** Label ids referencing board.labels[].id */
+    labels: jsonb('labels').notNull().default([]),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [index('idx_kanban_cards_board').on(table.boardId, table.columnId, table.position)]);

package/dist/kanban/index.d.ts

@@ -0,0 +1 @@
+export { createKanbanStore } from './store.js';

package/dist/kanban/index.js

@@ -0,0 +1 @@
+export { createKanbanStore } from './store.js';

package/dist/kanban/store.d.ts

@@ -0,0 +1,8 @@
+import type { DB } from '../db/client.js';
+import type { KanbanStore } from '../shared/types/kanban.js';
+/**
+ * Create a project-scoped KanbanStore backed by the given db handle.
+ * The board is created on first access (lazy) with the default 5 columns.
+ */
+declare function createKanbanStore(handle: DB, projectId: string): KanbanStore;
+export { createKanbanStore };

package/dist/kanban/store.js

@@ -0,0 +1,158 @@
+import { and, asc, eq, max } from 'drizzle-orm';
+import { kanbanBoards, kanbanCards } from '../db/schema.js';
+import { DEFAULT_KANBAN_COLUMNS } from '../shared/types/kanban.js';
+/** Default column when none is specified. */
+const DEFAULT_COLUMN_ID = 'todo';
+/** Position increment — large gap avoids frequent re-indexing on reorder. */
+const POSITION_GAP = 1000;
+// ── Row → API mappers ──────────────────────────────────────
+function rowToBoard(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        columns: row.columns,
+        labels: row.labels,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+    };
+}
+function rowToCard(row) {
+    return {
+        id: row.id,
+        boardId: row.boardId,
+        title: row.title,
+        description: row.description,
+        columnId: row.columnId,
+        priority: row.priority,
+        position: row.position,
+        labels: row.labels,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+    };
+}
+// ── Factory ────────────────────────────────────────────────
+/**
+ * Create a project-scoped KanbanStore backed by the given db handle.
+ * The board is created on first access (lazy) with the default 5 columns.
+ */
+function createKanbanStore(handle, projectId) {
+    const db = handle.db;
+    /** Insert a default board if none exists (idempotent via unique projectId). */
+    async function getOrCreateBoardId() {
+        await db
+            .insert(kanbanBoards)
+            .values({
+            projectId,
+            columns: [...DEFAULT_KANBAN_COLUMNS],
+            labels: [],
+        })
+            .onConflictDoNothing({ target: kanbanBoards.projectId });
+        const [row] = await db
+            .select({ id: kanbanBoards.id })
+            .from(kanbanBoards)
+            .where(eq(kanbanBoards.projectId, projectId))
+            .limit(1);
+        // 行一定存在：上面 insert + onConflictDoNothing 保证了 projectId 对应的行已创建
+        return row.id;
+    }
+    /** Max position in a column (0 if empty). */
+    async function maxPos(boardId, columnId) {
+        const [row] = await db
+            .select({ m: max(kanbanCards.position) })
+            .from(kanbanCards)
+            .where(and(eq(kanbanCards.boardId, boardId), eq(kanbanCards.columnId, columnId)));
+        return row?.m ?? 0;
+    }
+    return {
+        async getBoard() {
+            const boardId = await getOrCreateBoardId();
+            const [boardRow] = await db
+                .select()
+                .from(kanbanBoards)
+                .where(eq(kanbanBoards.id, boardId))
+                .limit(1);
+            const board = boardRow;
+            const cards = await db
+                .select()
+                .from(kanbanCards)
+                .where(eq(kanbanCards.boardId, boardId))
+                .orderBy(asc(kanbanCards.columnId), asc(kanbanCards.position));
+            return { ...rowToBoard(board), cards: cards.map(rowToCard) };
+        },
+        async addCard(input) {
+            const boardId = await getOrCreateBoardId();
+            const columnId = input.columnId ?? DEFAULT_COLUMN_ID;
+            const position = (await maxPos(boardId, columnId)) + POSITION_GAP;
+            const [cardRow] = await db
+                .insert(kanbanCards)
+                .values({
+                boardId,
+                title: input.title,
+                description: input.description ?? null,
+                columnId,
+                priority: input.priority ?? 'medium',
+                position,
+                labels: input.labels ?? [],
+            })
+                .returning();
+            const row = cardRow;
+            return rowToCard(row);
+        },
+        async updateCard(id, patch) {
+            const [row] = await db
+                .update(kanbanCards)
+                .set({
+                ...(patch.title !== undefined && { title: patch.title }),
+                ...(patch.description !== undefined && { description: patch.description }),
+                ...(patch.priority !== undefined && { priority: patch.priority }),
+                ...(patch.labels !== undefined && { labels: patch.labels }),
+                updatedAt: new Date(),
+            })
+                .where(eq(kanbanCards.id, id))
+                .returning();
+            if (!row)
+                throw new Error(`Kanban card not found: ${id}`);
+            return rowToCard(row);
+        },
+        async moveCard(id, columnId, position) {
+            // If no explicit position, append to end of target column.
+            let newPos = position;
+            if (newPos === undefined) {
+                const [card] = await db
+                    .select({ boardId: kanbanCards.boardId })
+                    .from(kanbanCards)
+                    .where(eq(kanbanCards.id, id))
+                    .limit(1);
+                if (!card)
+                    throw new Error(`Kanban card not found: ${id}`);
+                newPos = (await maxPos(card.boardId, columnId)) + POSITION_GAP;
+            }
+            const [row] = await db
+                .update(kanbanCards)
+                .set({ columnId, position: newPos, updatedAt: new Date() })
+                .where(eq(kanbanCards.id, id))
+                .returning();
+            if (!row)
+                throw new Error(`Kanban card not found: ${id}`);
+            return rowToCard(row);
+        },
+        async deleteCard(id) {
+            await db.delete(kanbanCards).where(eq(kanbanCards.id, id));
+        },
+        async updateBoard(patch) {
+            await getOrCreateBoardId();
+            const [boardRow] = await db
+                .update(kanbanBoards)
+                .set({
+                ...(patch.columns !== undefined && { columns: patch.columns }),
+                ...(patch.labels !== undefined && { labels: patch.labels }),
+                updatedAt: new Date(),
+            })
+                .where(eq(kanbanBoards.projectId, projectId))
+                .returning();
+            const row = boardRow;
+            return rowToBoard(row);
+        },
+    };
+}
+export { createKanbanStore };

package/dist/server/app.js

@@ -14,6 +14,7 @@ import { createConfigRoute } from './routes/config.js';
 import { createFilesRoute } from './routes/files.js';
 import { createFilesystemRoute } from './routes/filesystem.js';
 import { createHealthRoute } from './routes/health.js';
+import { createKanbanRoute } from './routes/kanban.js';
 import { createPermissionsRoute } from './routes/permissions.js';
 import { createProjectRoute } from './routes/project.js';
 import { createProviderRoute } from './routes/provider.js';
@@ -44,6 +45,7 @@ function createApp(ctx) {
     app.route('/api/commands', createCommandsRoute(ctx));
     app.route('/api/tools', createToolRoute(ctx));
     app.route('/api/todo', createTodoRoute(ctx));
+    app.route('/api/kanban', createKanbanRoute(ctx));
     app.route('/api/update', createUpdateRoute(ctx));
     app.route('/api/config', createConfigRoute(ctx));
     app.route('/api/permissions', createPermissionsRoute(ctx));
@@ -66,6 +68,7 @@ function createApp(ctx) {
             '/api/commands',
             '/api/tools',
             '/api/todo',
+            '/api/kanban',
             '/api/update',
             '/api/config',
             '/api/permissions',

package/dist/server/routes/kanban.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+declare function createKanbanRoute(ctx: ServerContext): Hono;
+export { createKanbanRoute };

package/dist/server/routes/kanban.js

@@ -0,0 +1,74 @@
+// REST routes for the kanban board — frontend UI uses these for drag-and-drop
+// card operations, board config, and initial load.
+import { Hono } from 'hono';
+import { createKanbanStore } from '../../kanban/index.js';
+import { apiError } from '../middleware/error.js';
+function createKanbanRoute(ctx) {
+    const app = new Hono();
+    // GET /:projectId — full board with cards
+    app.get('/:projectId', async (c) => {
+        const projectId = c.req.param('projectId');
+        const store = createKanbanStore(ctx.db, projectId);
+        const board = await store.getBoard();
+        return c.json(board);
+    });
+    // PATCH /:projectId — update board columns/labels config
+    app.patch('/:projectId', async (c) => {
+        const projectId = c.req.param('projectId');
+        const body = await c.req.json().catch(() => ({}));
+        const store = createKanbanStore(ctx.db, projectId);
+        const board = await store.updateBoard({
+            ...(body.columns !== undefined && { columns: body.columns }),
+            ...(body.labels !== undefined && { labels: body.labels }),
+        });
+        return c.json(board);
+    });
+    // POST /:projectId/cards — add a card
+    app.post('/:projectId/cards', async (c) => {
+        const projectId = c.req.param('projectId');
+        const body = await c.req.json().catch(() => ({}));
+        const title = body.title?.trim();
+        if (!title)
+            return apiError(c, 400, 'INVALID_INPUT', 'title is required');
+        const store = createKanbanStore(ctx.db, projectId);
+        const card = await store.addCard({
+            title,
+            description: body.description ?? null,
+            columnId: body.columnId,
+            priority: body.priority,
+            labels: body.labels,
+        });
+        return c.json(card, 201);
+    });
+    // PATCH /:projectId/cards/:cardId — update card fields or move
+    app.patch('/:projectId/cards/:cardId', async (c) => {
+        const projectId = c.req.param('projectId');
+        const cardId = c.req.param('cardId');
+        const body = await c.req.json().catch(() => ({}));
+        const store = createKanbanStore(ctx.db, projectId);
+        // columnId + position → moveCard; otherwise field update.
+        if (body.columnId !== undefined) {
+            const card = await store.moveCard(cardId, body.columnId, body.position);
+            return c.json(card);
+        }
+        const card = await store.updateCard(cardId, {
+            ...(body.title !== undefined && { title: body.title }),
+            ...(body.description !== undefined && {
+                description: body.description,
+            }),
+            ...(body.priority !== undefined && { priority: body.priority }),
+            ...(body.labels !== undefined && { labels: body.labels }),
+        });
+        return c.json(card);
+    });
+    // DELETE /:projectId/cards/:cardId — delete a card
+    app.delete('/:projectId/cards/:cardId', async (c) => {
+        const projectId = c.req.param('projectId');
+        const cardId = c.req.param('cardId');
+        const store = createKanbanStore(ctx.db, projectId);
+        await store.deleteCard(cardId);
+        return c.json({ ok: true });
+    });
+    return app;
+}
+export { createKanbanRoute };

package/dist/shared/types/index.d.ts

@@ -1,6 +1,7 @@
 export type * from './agent.js';
 export type * from './base.js';
 export type * from './config.js';
+export type * from './kanban.js';
 export type * from './llm.js';
 export type * from './message.js';
 export type * from './tool.js';