@kaban-board/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,787 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/add.ts
+import { KabanError } from "@kaban-board/core";
+import { Command } from "commander";
+
+// src/lib/context.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { BoardService, createDb, TaskService } from "@kaban-board/core";
+function getContext() {
+  const kabanDir = join(process.cwd(), ".kaban");
+  const dbPath = join(kabanDir, "board.db");
+  const configPath = join(kabanDir, "config.json");
+  if (!existsSync(dbPath)) {
+    console.error("Error: No board found. Run 'kaban init' first");
+    process.exit(1);
+  }
+  const db = createDb(dbPath);
+  const config = JSON.parse(readFileSync(configPath, "utf-8"));
+  const boardService = new BoardService(db);
+  const taskService = new TaskService(db, boardService);
+  return { db, config, boardService, taskService };
+}
+function getKabanPaths() {
+  const kabanDir = join(process.cwd(), ".kaban");
+  return {
+    kabanDir,
+    dbPath: join(kabanDir, "board.db"),
+    configPath: join(kabanDir, "config.json")
+  };
+}
+function getAgent() {
+  return process.env.KABAN_AGENT ?? "user";
+}
+
+// src/lib/json-output.ts
+function success(data) {
+  return { success: true, data };
+}
+function error(code, message) {
+  return { success: false, error: { code, message } };
+}
+function output(response) {
+  console.log(JSON.stringify(response, null, 2));
+}
+function outputSuccess(data) {
+  output(success(data));
+}
+function outputError(code, message) {
+  output(error(code, message));
+  process.exit(code);
+}
+
+// src/commands/add.ts
+var addCommand = new Command("add").description("Add a new task").argument("<title>", "Task title").option("-c, --column <column>", "Column to add task to").option("-a, --agent <agent>", "Agent creating the task").option("-D, --description <text>", "Task description").option("-d, --depends-on <ids>", "Comma-separated task IDs this depends on").option("-j, --json", "Output as JSON").action(async (title, options) => {
+  const json = options.json;
+  try {
+    const { taskService, config } = getContext();
+    const agent = options.agent ?? getAgent();
+    const columnId = options.column ?? config.defaults.column;
+    const dependsOn = options.dependsOn ? options.dependsOn.split(",").map((s) => s.trim()) : [];
+    const task = await taskService.addTask({
+      title,
+      description: options.description,
+      columnId,
+      agent,
+      dependsOn
+    });
+    if (json) {
+      outputSuccess(task);
+      return;
+    }
+    console.log(`Created task [${task.id.slice(0, 8)}] "${task.title}"`);
+    console.log(`  Column: ${task.columnId}`);
+    console.log(`  Agent: ${task.createdBy}`);
+  } catch (error2) {
+    if (error2 instanceof KabanError) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/done.ts
+import { KabanError as KabanError2 } from "@kaban-board/core";
+import { Command as Command2 } from "commander";
+var doneCommand = new Command2("done").description("Mark a task as done").argument("<id>", "Task ID (can be partial)").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = getContext();
+    const tasks = await taskService.listTasks();
+    const task = tasks.find((t) => t.id.startsWith(id));
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    const terminal = await boardService.getTerminalColumn();
+    if (!terminal) {
+      if (json)
+        outputError(1, "No terminal column configured");
+      console.error("Error: No terminal column configured");
+      process.exit(1);
+    }
+    const moved = await taskService.moveTask(task.id, terminal.id);
+    if (json) {
+      outputSuccess(moved);
+      return;
+    }
+    console.log(`Completed [${moved.id.slice(0, 8)}] "${moved.title}"`);
+  } catch (error2) {
+    if (error2 instanceof KabanError2) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/init.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
+import { BoardService as BoardService2, createDb as createDb2, DEFAULT_CONFIG, initializeSchema } from "@kaban-board/core";
+import { Command as Command3 } from "commander";
+var initCommand = new Command3("init").description("Initialize a new Kaban board in the current directory").option("-n, --name <name>", "Board name", "Kaban Board").action(async (options) => {
+  const { kabanDir, dbPath, configPath } = getKabanPaths();
+  if (existsSync2(dbPath)) {
+    console.error("Error: Board already exists in this directory");
+    process.exit(1);
+  }
+  mkdirSync(kabanDir, { recursive: true });
+  const config = {
+    ...DEFAULT_CONFIG,
+    board: { name: options.name }
+  };
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  const db = createDb2(dbPath);
+  await initializeSchema(db);
+  const boardService = new BoardService2(db);
+  await boardService.initializeBoard(config);
+  console.log(`Initialized Kaban board: ${options.name}`);
+  console.log(`  Database: ${dbPath}`);
+  console.log(`  Config: ${configPath}`);
+});
+
+// src/commands/list.ts
+import { KabanError as KabanError3 } from "@kaban-board/core";
+import { Command as Command4 } from "commander";
+function sortTasks(tasks, sortBy, reverse) {
+  const sorted = [...tasks].sort((a, b) => {
+    switch (sortBy) {
+      case "name":
+        return a.title.localeCompare(b.title);
+      case "date":
+        return a.createdAt.getTime() - b.createdAt.getTime();
+      case "updated":
+        return a.updatedAt.getTime() - b.updatedAt.getTime();
+      default:
+        return 0;
+    }
+  });
+  return reverse ? sorted.reverse() : sorted;
+}
+var listCommand = new Command4("list").description("List tasks").option("-c, --column <column>", "Filter by column").option("-a, --agent <agent>", "Filter by creator agent").option("-u, --assignee <assignee>", "Filter by assigned agent").option("-b, --blocked", "Show only blocked tasks").option("-s, --sort <field>", "Sort by: name, date, updated").option("-r, --reverse", "Reverse sort order").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = getContext();
+    let tasks = await taskService.listTasks({
+      columnId: options.column,
+      agent: options.agent,
+      assignee: options.assignee,
+      blocked: options.blocked
+    });
+    if (options.sort) {
+      const validSorts = ["name", "date", "updated"];
+      if (!validSorts.includes(options.sort)) {
+        console.error(`Invalid sort field: ${options.sort}. Use: ${validSorts.join(", ")}`);
+        process.exit(1);
+      }
+      tasks = sortTasks(tasks, options.sort, options.reverse ?? false);
+    }
+    if (json) {
+      outputSuccess(tasks);
+      return;
+    }
+    if (tasks.length === 0) {
+      console.log("No tasks found");
+      return;
+    }
+    const columns = await boardService.getColumns();
+    const columnMap = new Map(columns.map((c) => [c.id, c]));
+    for (const task of tasks) {
+      const column = columnMap.get(task.columnId);
+      const blocked = task.blockedReason ? " [blocked]" : "";
+      const agent = task.createdBy !== "user" ? ` @${task.createdBy}` : "";
+      const assignee = task.assignedTo ? ` → ${task.assignedTo}` : "";
+      console.log(`[${task.id.slice(0, 8)}] ${task.title}${agent}${assignee}${blocked}`);
+      console.log(`         ${column?.name ?? task.columnId}`);
+      if (task.description) {
+        const truncated = task.description.length > 60 ? `${task.description.slice(0, 60)}...` : task.description;
+        console.log(`         ${truncated}`);
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof KabanError3) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/mcp.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import {
+  BoardService as BoardService3,
+  createDb as createDb3,
+  DEFAULT_CONFIG as DEFAULT_CONFIG2,
+  initializeSchema as initializeSchema2,
+  TaskService as TaskService2
+} from "@kaban-board/core";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Command as Command5 } from "commander";
+function getKabanPaths2(basePath) {
+  const base = basePath ?? process.cwd();
+  const kabanDir = join2(base, ".kaban");
+  return {
+    kabanDir,
+    dbPath: join2(kabanDir, "board.db"),
+    configPath: join2(kabanDir, "config.json")
+  };
+}
+function createContext(basePath) {
+  const { dbPath, configPath } = getKabanPaths2(basePath);
+  if (!existsSync3(dbPath)) {
+    throw new Error("No board found. Run 'kaban init' first");
+  }
+  const db = createDb3(dbPath);
+  const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+  const boardService = new BoardService3(db);
+  const taskService = new TaskService2(db, boardService);
+  return { db, config, boardService, taskService };
+}
+async function startMcpServer(workingDirectory) {
+  const server = new Server({ name: "kaban-mcp", version: "0.1.0" }, { capabilities: { tools: {}, resources: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "kaban_init",
+        description: "Initialize a new Kaban board in the specified or current directory",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Board name (default: 'Kaban Board')" },
+            path: { type: "string", description: "Directory path (default: KABAN_PATH or cwd)" }
+          }
+        }
+      },
+      {
+        name: "kaban_add_task",
+        description: "Add a new task to the Kaban board",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Task title (1-200 chars)" },
+            description: { type: "string", description: "Task description" },
+            columnId: { type: "string", description: "Column ID (default: todo)" },
+            agent: { type: "string", description: "Agent name creating the task" },
+            dependsOn: {
+              type: "array",
+              items: { type: "string" },
+              description: "Task IDs this depends on"
+            },
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Associated file paths"
+            },
+            labels: { type: "array", items: { type: "string" }, description: "Task labels" }
+          },
+          required: ["title"]
+        }
+      },
+      {
+        name: "kaban_get_task",
+        description: "Get a task by its ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Task ID (ULID)" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "kaban_list_tasks",
+        description: "List tasks with optional filters",
+        inputSchema: {
+          type: "object",
+          properties: {
+            columnId: { type: "string", description: "Filter by column ID" },
+            agent: { type: "string", description: "Filter by agent name" },
+            blocked: { type: "boolean", description: "Show only blocked tasks" }
+          }
+        }
+      },
+      {
+        name: "kaban_move_task",
+        description: "Move a task to a different column",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID (ULID)" },
+            columnId: { type: "string", description: "Target column ID" },
+            force: { type: "boolean", description: "Force move even if WIP limit exceeded" }
+          },
+          required: ["id", "columnId"]
+        }
+      },
+      {
+        name: "kaban_update_task",
+        description: "Update a task's properties",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID (ULID)" },
+            title: { type: "string", description: "New task title" },
+            description: { type: ["string", "null"], description: "New task description" },
+            assignedTo: { type: ["string", "null"], description: "Assigned agent name" },
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Associated file paths"
+            },
+            labels: { type: "array", items: { type: "string" }, description: "Task labels" },
+            expectedVersion: {
+              type: "number",
+              description: "Expected version for optimistic locking"
+            }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "kaban_delete_task",
+        description: "Delete a task",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Task ID (ULID)" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "kaban_complete_task",
+        description: "Mark a task as completed (move to terminal column)",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Task ID (ULID) or partial ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "kaban_status",
+        description: "Get board status summary",
+        inputSchema: { type: "object", properties: {} }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      if (name === "kaban_init") {
+        const { name: boardName = "Kaban Board", path: basePath } = args ?? {};
+        const targetPath = basePath ?? workingDirectory;
+        const { kabanDir, dbPath, configPath } = getKabanPaths2(targetPath);
+        if (existsSync3(dbPath)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: "Board already exists in this directory" })
+              }
+            ],
+            isError: true
+          };
+        }
+        mkdirSync2(kabanDir, { recursive: true });
+        const config = {
+          ...DEFAULT_CONFIG2,
+          board: { name: boardName }
+        };
+        writeFileSync2(configPath, JSON.stringify(config, null, 2));
+        const db = createDb3(dbPath);
+        await initializeSchema2(db);
+        const boardService2 = new BoardService3(db);
+        await boardService2.initializeBoard(config);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                board: boardName,
+                paths: { database: dbPath, config: configPath }
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      const { taskService, boardService } = createContext(workingDirectory);
+      switch (name) {
+        case "kaban_add_task": {
+          const task = await taskService.addTask(args);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "kaban_get_task": {
+          const task = await taskService.getTask(args.id);
+          if (!task)
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "Task not found" }) }]
+            };
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "kaban_list_tasks": {
+          const tasks = await taskService.listTasks(args);
+          return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+        }
+        case "kaban_move_task": {
+          const { id, columnId, force } = args;
+          const task = await taskService.moveTask(id, columnId, { force });
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "kaban_update_task": {
+          const { id, expectedVersion, ...updates } = args;
+          const task = await taskService.updateTask(id, updates, expectedVersion);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "kaban_delete_task": {
+          await taskService.deleteTask(args.id);
+          return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+        }
+        case "kaban_complete_task": {
+          const { id } = args;
+          const tasks = await taskService.listTasks();
+          const task = tasks.find((t) => t.id.startsWith(id));
+          if (!task)
+            return {
+              content: [
+                { type: "text", text: JSON.stringify({ error: `Task '${id}' not found` }) }
+              ]
+            };
+          const terminal = await boardService.getTerminalColumn();
+          if (!terminal)
+            return {
+              content: [
+                { type: "text", text: JSON.stringify({ error: "No terminal column configured" }) }
+              ]
+            };
+          const completed = await taskService.moveTask(task.id, terminal.id);
+          return { content: [{ type: "text", text: JSON.stringify(completed, null, 2) }] };
+        }
+        case "kaban_status": {
+          const board = await boardService.getBoard();
+          const columns = await boardService.getColumns();
+          const tasks = await taskService.listTasks();
+          const columnStats = columns.map((column) => ({
+            id: column.id,
+            name: column.name,
+            count: tasks.filter((t) => t.columnId === column.id).length,
+            wipLimit: column.wipLimit,
+            isTerminal: column.isTerminal
+          }));
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  board: { name: board?.name ?? "Kaban Board" },
+                  columns: columnStats,
+                  blockedCount: tasks.filter((t) => t.blockedReason).length,
+                  totalTasks: tasks.length
+                }, null, 2)
+              }
+            ]
+          };
+        }
+        default:
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+            isError: true
+          };
+      }
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+        isError: true
+      };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+      {
+        uri: "kaban://board/status",
+        name: "Board Status",
+        description: "Current Kaban board status and task summary",
+        mimeType: "application/json"
+      },
+      {
+        uri: "kaban://board/columns",
+        name: "Board Columns",
+        description: "Available columns on the Kaban board",
+        mimeType: "application/json"
+      }
+    ]
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    try {
+      const { taskService, boardService } = createContext(workingDirectory);
+      if (uri === "kaban://board/status") {
+        const board = await boardService.getBoard();
+        const columns = await boardService.getColumns();
+        const tasks = await taskService.listTasks();
+        const columnStats = columns.map((column) => ({
+          id: column.id,
+          name: column.name,
+          count: tasks.filter((t) => t.columnId === column.id).length,
+          wipLimit: column.wipLimit,
+          isTerminal: column.isTerminal,
+          tasks: tasks.filter((t) => t.columnId === column.id).map((t) => ({
+            id: t.id,
+            title: t.title,
+            createdBy: t.createdBy,
+            blocked: !!t.blockedReason
+          }))
+        }));
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                board: { name: board?.name ?? "Kaban Board" },
+                columns: columnStats,
+                blockedCount: tasks.filter((t) => t.blockedReason).length,
+                totalTasks: tasks.length
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      if (uri === "kaban://board/columns") {
+        const columns = await boardService.getColumns();
+        return {
+          contents: [{ uri, mimeType: "application/json", text: JSON.stringify(columns, null, 2) }]
+        };
+      }
+      if (uri.startsWith("kaban://tasks/")) {
+        const columnId = uri.replace("kaban://tasks/", "");
+        const tasks = await taskService.listTasks({ columnId });
+        return {
+          contents: [{ uri, mimeType: "application/json", text: JSON.stringify(tasks, null, 2) }]
+        };
+      }
+      if (uri.startsWith("kaban://task/")) {
+        const id = uri.replace("kaban://task/", "");
+        const task = await taskService.getTask(id);
+        if (!task)
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({ error: "Task not found" })
+              }
+            ]
+          };
+        return {
+          contents: [{ uri, mimeType: "application/json", text: JSON.stringify(task, null, 2) }]
+        };
+      }
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify({ error: "Resource not found" })
+          }
+        ]
+      };
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ error: message }) }]
+      };
+    }
+  });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  console.error("Kaban MCP server running on stdio");
+}
+var mcpCommand = new Command5("mcp").description("Start MCP server for AI agent integration").option("-p, --path <path>", "Working directory for Kaban board").action(async (options) => {
+  const workingDirectory = options.path ?? process.env.KABAN_PATH ?? process.cwd();
+  await startMcpServer(workingDirectory);
+});
+
+// src/commands/move.ts
+import { KabanError as KabanError4 } from "@kaban-board/core";
+import { Command as Command6 } from "commander";
+var moveCommand = new Command6("move").description("Move a task to a different column").argument("<id>", "Task ID (can be partial)").argument("[column]", "Target column").option("-n, --next", "Move to next column").option("-f, --force", "Force move even if WIP limit exceeded").option("-j, --json", "Output as JSON").action(async (id, column, options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = getContext();
+    const tasks = await taskService.listTasks();
+    const task = tasks.find((t) => t.id.startsWith(id));
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    let targetColumn = column;
+    if (options.next) {
+      const columns = await boardService.getColumns();
+      const currentIdx = columns.findIndex((c) => c.id === task.columnId);
+      if (currentIdx < columns.length - 1) {
+        targetColumn = columns[currentIdx + 1].id;
+      } else {
+        if (json)
+          outputError(4, "Task is already in the last column");
+        console.error("Error: Task is already in the last column");
+        process.exit(4);
+      }
+    }
+    if (!targetColumn) {
+      if (json)
+        outputError(4, "Specify a column or use --next");
+      console.error("Error: Specify a column or use --next");
+      process.exit(4);
+    }
+    const moved = await taskService.moveTask(task.id, targetColumn, {
+      force: options.force
+    });
+    if (json) {
+      outputSuccess(moved);
+      return;
+    }
+    const col = await boardService.getColumn(moved.columnId);
+    console.log(`Moved [${moved.id.slice(0, 8)}] to ${col?.name}`);
+  } catch (error2) {
+    if (error2 instanceof KabanError4) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/schema.ts
+import { jsonSchemas } from "@kaban-board/core";
+import { Command as Command7 } from "commander";
+var availableSchemas = Object.keys(jsonSchemas);
+var schemaCommand = new Command7("schema").description("Output JSON schemas for AI agents").argument("[name]", "Schema name (omit to list available)").action((name) => {
+  if (!name) {
+    console.log("Available schemas:");
+    for (const schemaName of availableSchemas) {
+      console.log(`  - ${schemaName}`);
+    }
+    console.log(`
+Usage: kaban schema <name>`);
+    return;
+  }
+  const schema = jsonSchemas[name];
+  if (!schema) {
+    console.error(`Error: Unknown schema '${name}'`);
+    console.error(`Available: ${availableSchemas.join(", ")}`);
+    process.exit(1);
+  }
+  console.log(JSON.stringify(schema, null, 2));
+});
+
+// src/commands/status.ts
+import { KabanError as KabanError5 } from "@kaban-board/core";
+import { Command as Command8 } from "commander";
+var statusCommand = new Command8("status").description("Show board status summary").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = getContext();
+    const board = await boardService.getBoard();
+    const columns = await boardService.getColumns();
+    const tasks = await taskService.listTasks();
+    if (json) {
+      const columnStats = columns.map((column) => {
+        const columnTasks = tasks.filter((t) => t.columnId === column.id);
+        return {
+          id: column.id,
+          name: column.name,
+          count: columnTasks.length,
+          wipLimit: column.wipLimit,
+          isTerminal: column.isTerminal
+        };
+      });
+      outputSuccess({
+        board: { name: board?.name ?? "Kaban Board" },
+        columns: columnStats,
+        blockedCount: tasks.filter((t) => t.blockedReason).length,
+        totalTasks: tasks.length
+      });
+      return;
+    }
+    console.log(`
+  ${board?.name ?? "Kaban Board"}
+`);
+    for (const column of columns) {
+      const columnTasks = tasks.filter((t) => t.columnId === column.id);
+      const count = columnTasks.length;
+      const limit = column.wipLimit ? `/${column.wipLimit}` : "";
+      const terminal = column.isTerminal ? " [done]" : "";
+      console.log(`  ${column.name}: ${count}${limit}${terminal}`);
+    }
+    const blocked = tasks.filter((t) => t.blockedReason).length;
+    if (blocked > 0) {
+      console.log(`
+  ${blocked} blocked task(s)`);
+    }
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError5) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/tui.ts
+import { spawn } from "node:child_process";
+import { dirname, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command as Command9 } from "commander";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var tuiCommand = new Command9("tui").description("Start interactive Terminal UI").action(async () => {
+  const tuiEntry = join3(__dirname2, "../../../tui/src/index.ts");
+  const child = spawn("bun", ["run", tuiEntry], {
+    stdio: "inherit",
+    cwd: process.cwd()
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+});
+
+// src/index.ts
+var program = new Command10;
+program.name("kaban").description("Terminal Kanban for AI Code Agents").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(listCommand);
+program.addCommand(moveCommand);
+program.addCommand(doneCommand);
+program.addCommand(statusCommand);
+program.addCommand(schemaCommand);
+program.addCommand(mcpCommand);
+program.addCommand(tuiCommand);
+program.parse();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kaban-board/cli",
+  "version": "0.1.0",
+  "description": "Terminal Kanban for AI Code Agents - CLI and MCP server",
+  "type": "module",
+  "bin": {
+    "kaban": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external && chmod +x ./dist/index.js",
+    "dev": "bun run ./src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@kaban-board/core": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beshkenadze/kaban.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://beshkenadze.github.io/kaban",
+  "bugs": {
+    "url": "https://github.com/beshkenadze/kaban/issues"
+  },
+  "license": "MIT",
+  "keywords": [
+    "kanban",
+    "ai",
+    "agents",
+    "mcp",
+    "claude",
+    "terminal",
+    "cli",
+    "tui",
+    "task-management"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}