c0de-agent 1.5.0 → 1.7.0

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/project/resolve.d.ts

@@ -5,4 +5,79 @@ export type ResolvedProject = {
     gitRemote: string | null;
     gitBranch: string | null;
 };
+/** 文件 git 状态分类（用于文件树高亮）。按「最值得注意」优先级排列。 */
+export type GitStatusCode = 'modified' | 'staged' | 'untracked' | 'conflict' | 'deleted' | 'ignored';
+/** 目录聚合时的优先级（越大越优先展示）。ignored 最低：被忽略目录下若有真实变更仍显示变更态。 */
+export declare const GIT_STATUS_PRIORITY: Record<GitStatusCode, number>;
+export declare function getGitStatus(cwd: string): Record<string, GitStatusCode> | null;
+/** 检查给定路径中哪些被 gitignore 规则覆盖。
+ *
+ * 用 git check-ignore 只查询传入的路径（不递归），返回被忽略路径的集合。
+ * 只检查当前展开目录的直接子项（通常 10-50 个），不递归进 node_modules 等。
+ * 非 git 仓库或无忽略文件时返回空集。
+ *
+ * 注意：git check-ignore 在「无路径被忽略」或「非 git 仓库」时退出码为 1，
+ * 这两种情况都返回空集。 */
+export declare function checkIgnored(cwd: string, paths: string[]): Set<string>;
+/** 追加条目到 .gitignore（去重，文件不存在则创建）。 */
+export declare function appendToGitignore(cwd: string, patterns: string[]): void;
+/**
+ * 取当前分支名（非 git 仓库返回 null）。
+ */
+export declare function getGitBranch(cwd: string): string | null;
+/** 最后一次提交摘要（供分支名 hover tooltip）。 */
+export interface GitLastCommit {
+    subject: string;
+    hash: string;
+    author: string;
+    date: string;
+}
+/**
+ * 取最后一次提交信息（subject/hash/author/相对时间）。
+ * 非 git 仓库或无提交（如全新仓库）返回 null。
+ */
+export declare function getGitLastCommit(cwd: string): GitLastCommit | null;
+/**
+ * 取工作区变更摘要（供 LLM 生成 commit message）。
+ * 包含 staged + unstaged diff（相对 HEAD）和 untracked 文件名列表。
+ * 非 git 仓库或无变更返回 null。
+ */
+export declare function getGitDiffSummary(cwd: string): {
+    diff: string;
+    fileCount: number;
+} | null;
+/**
+ * 执行 git add -A + git commit。成功返回 commit 短 hash，失败返回 error 信息。
+ */
+export declare function performGitCommit(cwd: string, message: string): {
+    hash: string;
+} | {
+    error: string;
+};
+/** 分支信息。 */
+export interface GitBranchInfo {
+    name: string;
+    current: boolean;
+    lastSubject: string | null;
+}
+/**
+ * 列出本地分支及当前分支标记（非 git 仓库返回 null）。
+ */
+export declare function listGitBranches(cwd: string): GitBranchInfo[] | null;
+/**
+ * 切换到指定分支（git checkout）。成功返回分支名，失败返回 error。
+ */
+export declare function checkoutGitBranch(cwd: string, branch: string): {
+    branch: string;
+} | {
+    error: string;
+};
+/**
+ * 创建并切换到新分支。成功返回分支名，失败返回 error。
+ */
+export declare function createGitBranch(cwd: string, name: string): {
+    branch: string;
+} | {
+    error: string;
+};
 export declare function resolveProject(directory: string): ResolvedProject;