@kaban-board/cli 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
 import { createRequire } from "node:module";
+import { Command as Command12 } from "commander";
 
 // src/commands/add.ts
 import { KabanError } from "@kaban-board/core";
@@ -128,19 +128,575 @@ var doneCommand = new Command2("done").description("Mark a task as done").argume
   }
 });
 
-// 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";
+// src/commands/hook.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3, realpathSync } from "node:fs";
+import { chmod, copyFile as copyFile2, mkdir, readFile as readFile2, stat, unlink } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
 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) => {
+
+// src/hook/settings-manager.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/hook/schemas.ts
+import { z } from "zod";
+var TodoStatusSchema = z.enum(["pending", "in_progress", "completed", "cancelled"]);
+var TodoPrioritySchema = z.enum(["high", "medium", "low"]);
+var TodoItemSchema = z.object({
+  id: z.string().min(1),
+  content: z.string().min(1).max(500),
+  status: TodoStatusSchema,
+  priority: TodoPrioritySchema
+});
+var TodoWriteInputSchema = z.object({
+  todos: z.array(TodoItemSchema)
+});
+var HookInputSchema = z.object({
+  session_id: z.string(),
+  transcript_path: z.string(),
+  cwd: z.string(),
+  permission_mode: z.string(),
+  hook_event_name: z.literal("PostToolUse"),
+  tool_name: z.string(),
+  tool_input: z.unknown(),
+  tool_response: z.unknown().optional(),
+  tool_use_id: z.string()
+});
+var TodoWriteHookInputSchema = HookInputSchema.extend({
+  tool_name: z.literal("TodoWrite"),
+  tool_input: TodoWriteInputSchema
+});
+var HookCommandSchema = z.object({
+  type: z.literal("command"),
+  command: z.string(),
+  timeout: z.number().optional()
+});
+var HookEntrySchema = z.object({
+  matcher: z.string(),
+  hooks: z.array(HookCommandSchema),
+  description: z.string().optional()
+});
+var HooksConfigSchema = z.object({
+  PostToolUse: z.array(HookEntrySchema).optional(),
+  PreToolUse: z.array(HookEntrySchema).optional(),
+  Notification: z.array(HookEntrySchema).optional(),
+  Stop: z.array(HookEntrySchema).optional()
+});
+var ClaudeSettingsSchema = z.object({
+  hooks: HooksConfigSchema.optional()
+}).passthrough();
+var TODOWRITE_HOOK_ENTRY = {
+  matcher: "TodoWrite",
+  hooks: [
+    {
+      type: "command",
+      command: "~/.claude/hooks/kaban-hook",
+      timeout: 10
+    }
+  ],
+  description: "Auto-sync TodoWrite changes to Kaban board"
+};
+var SyncConfigSchema = z.object({
+  conflictStrategy: z.enum(["todowrite_wins", "status_priority", "kaban_wins"]).default("status_priority"),
+  deletionPolicy: z.enum(["preserve", "archive", "delete"]).default("preserve"),
+  cancelledPolicy: z.enum(["skip", "backlog"]).default("skip"),
+  syncCooldownMs: z.number().min(0).max(5000).default(200),
+  maxTitleLength: z.number().min(50).max(1000).default(200),
+  logEnabled: z.boolean().default(true),
+  logPath: z.string().default("~/.claude/hooks/sync.log")
+});
+var DEFAULT_CONFIG = {
+  conflictStrategy: "status_priority",
+  deletionPolicy: "preserve",
+  cancelledPolicy: "skip",
+  syncCooldownMs: 200,
+  maxTitleLength: 200,
+  logEnabled: true,
+  logPath: "~/.claude/hooks/sync.log"
+};
+
+// src/hook/settings-manager.ts
+var SETTINGS_PATH = join2(homedir(), ".claude", "settings.json");
+
+class SettingsManager {
+  settingsPath;
+  constructor(settingsPath = SETTINGS_PATH) {
+    this.settingsPath = settingsPath;
+  }
+  async read() {
+    if (!existsSync2(this.settingsPath)) {
+      return {};
+    }
+    const content = await readFile(this.settingsPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return ClaudeSettingsSchema.parse(parsed);
+  }
+  async write(settings) {
+    const content = JSON.stringify(settings, null, 2);
+    await writeFile(this.settingsPath, `${content}
+`);
+  }
+  async backup() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const backupPath = `${this.settingsPath}.backup-${timestamp}`;
+    await copyFile(this.settingsPath, backupPath);
+    return backupPath;
+  }
+  async addHook() {
+    const settings = await this.read();
+    if (this.hasHook(settings)) {
+      return { added: false };
+    }
+    let backupPath;
+    if (existsSync2(this.settingsPath)) {
+      backupPath = await this.backup();
+    }
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    if (!settings.hooks.PostToolUse) {
+      settings.hooks.PostToolUse = [];
+    }
+    settings.hooks.PostToolUse.push(TODOWRITE_HOOK_ENTRY);
+    await this.write(settings);
+    return { added: true, backupPath };
+  }
+  async removeHook() {
+    const settings = await this.read();
+    if (!this.hasHook(settings)) {
+      return { removed: false };
+    }
+    const hooks = settings.hooks;
+    if (hooks?.PostToolUse) {
+      hooks.PostToolUse = hooks.PostToolUse.filter((hook) => !this.isTodoWriteHook(hook));
+      if (hooks.PostToolUse.length === 0) {
+        delete hooks.PostToolUse;
+      }
+      if (Object.keys(hooks).length === 0) {
+        delete settings.hooks;
+      }
+    }
+    await this.write(settings);
+    return { removed: true };
+  }
+  hasHook(settings) {
+    const postToolUseHooks = settings.hooks?.PostToolUse;
+    if (!postToolUseHooks)
+      return false;
+    return postToolUseHooks.some((hook) => this.isTodoWriteHook(hook));
+  }
+  isTodoWriteHook(hook) {
+    return hook.matcher === "TodoWrite" && hook.hooks.some((h) => h.command.includes("kaban-hook"));
+  }
+}
+
+// src/commands/hook.ts
+var HOOKS_DIR = join3(homedir2(), ".claude", "hooks");
+var HOOK_BINARY_NAME = "kaban-hook";
+var LOG_FILE = "sync.log";
+async function checkKabanCli() {
+  return new Promise((resolve2) => {
+    try {
+      const proc = spawn("kaban", ["--version"]);
+      let stdout = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve2({ ok: true, message: stdout.trim() });
+        } else {
+          resolve2({ ok: false, message: "not working" });
+        }
+      });
+      proc.on("error", () => {
+        resolve2({ ok: false, message: "not found in PATH" });
+      });
+    } catch {
+      resolve2({ ok: false, message: "not found in PATH" });
+    }
+  });
+}
+async function checkDependencies() {
+  const results = [];
+  const isBun = typeof Bun !== "undefined";
+  results.push({
+    name: "Runtime",
+    ok: true,
+    message: isBun ? `Bun v${Bun.version}` : `Node ${process.version}`
+  });
+  const claudeDir = join3(homedir2(), ".claude");
+  if (existsSync3(claudeDir)) {
+    results.push({
+      name: "Claude Code",
+      ok: true,
+      message: "~/.claude/ exists"
+    });
+  } else {
+    results.push({
+      name: "Claude Code",
+      ok: false,
+      message: "~/.claude/ not found - run Claude Code first"
+    });
+  }
+  const settingsPath = join3(claudeDir, "settings.json");
+  if (existsSync3(settingsPath)) {
+    try {
+      const content = await readFile2(settingsPath, "utf-8");
+      JSON.parse(content);
+      results.push({
+        name: "Settings",
+        ok: true,
+        message: "settings.json valid"
+      });
+    } catch {
+      results.push({
+        name: "Settings",
+        ok: false,
+        message: "settings.json is not valid JSON"
+      });
+    }
+  } else {
+    results.push({
+      name: "Settings",
+      ok: true,
+      message: "settings.json will be created"
+    });
+  }
+  const kabanInstalled = await checkKabanCli();
+  results.push({
+    name: "Kaban CLI",
+    ok: kabanInstalled.ok,
+    message: kabanInstalled.message
+  });
+  const allOk = results.every((r) => r.ok);
+  return { ok: allOk, results };
+}
+function formatCheckResults(results) {
+  const maxNameLen = Math.max(...results.map((r) => r.name.length));
+  return results.map((r) => {
+    const icon = r.ok ? chalk.green("✓") : chalk.red("✗");
+    const name = r.name.padEnd(maxNameLen);
+    const msg = r.ok ? chalk.dim(r.message) : chalk.red(r.message);
+    return `  ${icon} ${name}  ${msg}`;
+  }).join(`
+`);
+}
+async function installHook(spinner2) {
+  spinner2.message("Creating hooks directory...");
+  if (!existsSync3(HOOKS_DIR)) {
+    await mkdir(HOOKS_DIR, { recursive: true });
+  }
+  spinner2.message("Installing hook binary...");
+  const scriptPath = realpathSync(process.argv[1]);
+  const scriptDir = dirname(scriptPath);
+  const isDevMode = scriptPath.includes("/src/");
+  const distDir = isDevMode ? join3(scriptDir, "..", "dist") : scriptDir;
+  const sourceBinary = join3(distDir, HOOK_BINARY_NAME);
+  const targetBinary = join3(HOOKS_DIR, HOOK_BINARY_NAME);
+  if (!existsSync3(sourceBinary)) {
+    throw new Error(`Binary not found at ${sourceBinary}. Run 'bun run build' first.`);
+  }
+  await copyFile2(sourceBinary, targetBinary);
+  await chmod(targetBinary, 493);
+  spinner2.message("Configuring Claude Code settings...");
+  const settingsManager = new SettingsManager;
+  const result = await settingsManager.addHook();
+  const installResult = {
+    hookInstalled: true,
+    hookConfigured: result.added
+  };
+  if (result.backupPath) {
+    installResult.backupPath = result.backupPath;
+  }
+  return installResult;
+}
+async function uninstallHook(cleanLogs) {
+  const result = {
+    hookRemoved: false,
+    binaryRemoved: false,
+    logRemoved: false
+  };
+  const settingsManager = new SettingsManager;
+  const hookResult = await settingsManager.removeHook();
+  result.hookRemoved = hookResult.removed;
+  const binaryPath = join3(HOOKS_DIR, HOOK_BINARY_NAME);
+  if (existsSync3(binaryPath)) {
+    await unlink(binaryPath);
+    result.binaryRemoved = true;
+  }
+  const logPath = join3(HOOKS_DIR, LOG_FILE);
+  if (existsSync3(logPath) && cleanLogs) {
+    await unlink(logPath);
+    result.logRemoved = true;
+  }
+  return result;
+}
+async function getRecentActivity() {
+  const logPath = join3(HOOKS_DIR, LOG_FILE);
+  if (!existsSync3(logPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile2(logPath, "utf-8");
+    const lines = content.trim().split(`
+`).filter(Boolean);
+    const entries = lines.map((line) => JSON.parse(line));
+    const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const recentEntries = entries.filter((e) => new Date(e.timestamp) > oneDayAgo);
+    const stats = recentEntries.reduce((acc, e) => ({
+      syncs: acc.syncs + 1,
+      created: acc.created + e.created,
+      moved: acc.moved + e.moved,
+      errors: acc.errors + e.errors.length
+    }), { syncs: 0, created: 0, moved: 0, errors: 0 });
+    const lastEntry = entries.at(-1);
+    const logStats = await stat(logPath);
+    const result = { ...stats };
+    if (lastEntry) {
+      result.lastSync = new Date(lastEntry.timestamp);
+    }
+    if (logStats.size > 0) {
+      result.logSize = logStats.size;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function formatTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+  if (seconds < 60)
+    return `${seconds} sec ago`;
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)} min ago`;
+  if (seconds < 86400)
+    return `${Math.floor(seconds / 3600)} hours ago`;
+  return `${Math.floor(seconds / 86400)} days ago`;
+}
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  return `${Math.round(bytes / 1024)} KB`;
+}
+var installCommand = new Command3("install").description("Install TodoWrite sync hook for Claude Code").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  p.intro(chalk.bgCyan.black(" kaban hook install "));
+  const s = p.spinner();
+  s.start("Checking dependencies...");
+  const { ok, results } = await checkDependencies();
+  s.stop("Dependencies checked");
+  p.note(formatCheckResults(results), "Environment");
+  if (!ok) {
+    p.cancel("Dependency check failed. Please fix the issues above.");
+    process.exit(1);
+  }
+  if (!options.yes) {
+    const proceed = await p.confirm({
+      message: "Install TodoWrite-Kaban sync hook?",
+      initialValue: true
+    });
+    if (p.isCancel(proceed) || !proceed) {
+      p.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+  }
+  s.start("Installing...");
+  try {
+    const installResult = await installHook(s);
+    s.stop("Installation complete");
+    const summaryLines = [
+      "",
+      `  ${chalk.cyan("Hook Binary")}`,
+      `    ${chalk.dim("Path:")} ~/.claude/hooks/${HOOK_BINARY_NAME}`,
+      "",
+      `  ${chalk.cyan("Hook Configuration")}`,
+      `    ${chalk.dim("Event:")} PostToolUse`,
+      `    ${chalk.dim("Matcher:")} TodoWrite`,
+      `    ${chalk.dim("Timeout:")} 10s`,
+      ""
+    ];
+    if (installResult.backupPath) {
+      summaryLines.push(`  ${chalk.cyan("Backup")}`);
+      summaryLines.push(`    ${chalk.dim(installResult.backupPath)}`);
+      summaryLines.push("");
+    }
+    if (!installResult.hookConfigured) {
+      summaryLines.push(`  ${chalk.yellow("⚠")} Hook was already configured`);
+      summaryLines.push("");
+    }
+    p.note(summaryLines.join(`
+`), "Installation Summary");
+    p.log.success("TodoWrite changes will now auto-sync to Kaban board!");
+    p.note([
+      `  ${chalk.cyan("Verify:")}  kaban hook status`,
+      `  ${chalk.cyan("Logs:")}    ~/.claude/hooks/sync.log`,
+      `  ${chalk.cyan("Remove:")}  kaban hook uninstall`
+    ].join(`
+`), "Next Steps");
+    p.outro(chalk.green("Done!"));
+  } catch (error2) {
+    s.stop("Installation failed");
+    p.cancel(error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite sync hook").option("-y, --yes", "Skip confirmation").option("--clean", "Also remove sync logs").action(async (options) => {
+  p.intro(chalk.bgRed.white(" kaban hook uninstall "));
+  const binaryExists = existsSync3(join3(HOOKS_DIR, HOOK_BINARY_NAME));
+  const logExists = existsSync3(join3(HOOKS_DIR, LOG_FILE));
+  const settingsManager = new SettingsManager;
+  let hookExists = false;
+  try {
+    const settings = await settingsManager.read();
+    hookExists = settingsManager.hasHook(settings);
+  } catch {
+    hookExists = false;
+  }
+  if (!binaryExists && !hookExists) {
+    p.log.warn("TodoWrite-Kaban sync hook is not installed.");
+    p.outro("Nothing to uninstall.");
+    process.exit(0);
+  }
+  const formatStatusLine = (exists, label) => {
+    const icon = exists ? chalk.green("✓") : chalk.dim("○");
+    const text = exists ? "" : chalk.dim(" (not found)");
+    return `  ${icon} ${label}${text}`;
+  };
+  const formatLogStatus = () => {
+    if (!logExists)
+      return formatStatusLine(false, "Sync log");
+    const suffix = options.clean ? chalk.yellow(" (will be removed)") : chalk.dim(" (will be preserved)");
+    return `  ${chalk.yellow("○")} Sync log${suffix}`;
+  };
+  const statusLines = [
+    formatStatusLine(binaryExists, "Hook binary"),
+    formatStatusLine(hookExists, "Settings configuration"),
+    formatLogStatus()
+  ];
+  p.note(statusLines.join(`
+`), "Current Installation");
+  if (!options.yes) {
+    const confirmed = await p.confirm({
+      message: "Remove TodoWrite-Kaban sync?",
+      initialValue: false
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("Uninstallation cancelled.");
+      process.exit(0);
+    }
+  }
+  const s = p.spinner();
+  s.start("Removing...");
+  try {
+    const result = await uninstallHook(options.clean);
+    s.stop("Removal complete");
+    const summaryLines = [];
+    if (result.hookRemoved)
+      summaryLines.push(`  ${chalk.green("✓")} Removed hook from settings.json`);
+    if (result.binaryRemoved)
+      summaryLines.push(`  ${chalk.green("✓")} Removed ${HOOK_BINARY_NAME}`);
+    if (result.logRemoved)
+      summaryLines.push(`  ${chalk.green("✓")} Removed ${LOG_FILE}`);
+    if (logExists && !options.clean)
+      summaryLines.push(`  ${chalk.yellow("○")} Preserved ${LOG_FILE} (use --clean to remove)`);
+    if (summaryLines.length > 0) {
+      p.note(summaryLines.join(`
+`), "Removed");
+    }
+    p.outro(chalk.green("Done!"));
+  } catch (error2) {
+    s.stop("Removal failed");
+    p.cancel(error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var statusCommand = new Command3("status").description("Check hook installation status").action(async () => {
+  p.intro(chalk.bgBlue.white(" kaban hook status "));
+  const s = p.spinner();
+  s.start("Checking status...");
+  const binaryPath = join3(HOOKS_DIR, HOOK_BINARY_NAME);
+  const binaryExists = existsSync3(binaryPath);
+  const settingsManager = new SettingsManager;
+  let hookConfigured = false;
+  try {
+    const settings = await settingsManager.read();
+    hookConfigured = settingsManager.hasHook(settings);
+  } catch {
+    hookConfigured = false;
+  }
+  const kabanCheck = await checkKabanCli();
+  const activity = await getRecentActivity();
+  s.stop("Status checked");
+  const results = [
+    {
+      name: "Hook Binary",
+      ok: binaryExists,
+      detail: binaryExists ? binaryPath : "Not found"
+    },
+    {
+      name: "Settings Config",
+      ok: hookConfigured,
+      detail: hookConfigured ? "PostToolUse[TodoWrite] active" : "Hook not configured"
+    },
+    {
+      name: "Kaban CLI",
+      ok: kabanCheck.ok,
+      detail: kabanCheck.ok ? kabanCheck.message : "Not found in PATH"
+    }
+  ];
+  const maxNameLen = Math.max(...results.map((r) => r.name.length));
+  const statusLines = results.map((r) => {
+    const icon = r.ok ? chalk.green("✓") : chalk.red("✗");
+    const name = r.name.padEnd(maxNameLen);
+    const detail = r.ok ? chalk.dim(r.detail) : chalk.red(r.detail);
+    return `  ${icon} ${name}  ${detail}`;
+  });
+  p.note(statusLines.join(`
+`), "Installation Status");
+  if (activity) {
+    const activityLines = [
+      `  ${chalk.cyan("Syncs (24h):")}     ${activity.syncs}`,
+      `  ${chalk.cyan("Tasks created:")}  ${activity.created}`,
+      `  ${chalk.cyan("Tasks moved:")}    ${activity.moved}`,
+      `  ${chalk.cyan("Errors:")}         ${activity.errors > 0 ? chalk.red(activity.errors.toString()) : chalk.green("0")}`,
+      "",
+      activity.lastSync ? `  ${chalk.dim("Last sync:")}      ${formatTimeAgo(activity.lastSync)}` : "",
+      activity.logSize ? `  ${chalk.dim("Log size:")}       ${formatSize(activity.logSize)}` : ""
+    ].filter(Boolean);
+    p.note(activityLines.join(`
+`), "Recent Activity");
+  } else {
+    p.log.info("No sync activity logged yet.");
+  }
+  const allOk = results.every((r) => r.ok);
+  if (allOk) {
+    p.outro(chalk.green("All systems operational!"));
+  } else {
+    p.outro(chalk.yellow("Some checks failed. Run 'kaban hook install' to fix."));
+    process.exit(1);
+  }
+});
+var hookCommand = new Command3("hook").description("Manage TodoWrite sync hook for Claude Code").addCommand(installCommand).addCommand(uninstallCommand).addCommand(statusCommand);
+
+// src/commands/init.ts
+import { existsSync as existsSync4, mkdirSync, writeFileSync } from "node:fs";
+import { BoardService as BoardService2, createDb as createDb2, DEFAULT_CONFIG as DEFAULT_CONFIG2, initializeSchema } from "@kaban-board/core";
+import { Command as Command4 } from "commander";
+var initCommand = new Command4("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)) {
+  if (existsSync4(dbPath)) {
     console.error("Error: Board already exists in this directory");
     process.exit(1);
   }
   mkdirSync(kabanDir, { recursive: true });
   const config = {
-    ...DEFAULT_CONFIG,
+    ...DEFAULT_CONFIG2,
     board: { name: options.name }
   };
   writeFileSync(configPath, JSON.stringify(config, null, 2));
@@ -155,7 +711,7 @@ var initCommand = new Command3("init").description("Initialize a new Kaban board
 
 // src/commands/list.ts
 import { KabanError as KabanError3 } from "@kaban-board/core";
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 function sortTasks(tasks, sortBy, reverse) {
   const sorted = [...tasks].sort((a, b) => {
     switch (sortBy) {
@@ -171,7 +727,7 @@ function sortTasks(tasks, sortBy, reverse) {
   });
   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) => {
+var listCommand = new Command5("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();
@@ -223,12 +779,12 @@ var listCommand = new Command4("list").description("List tasks").option("-c, --c
 });
 
 // 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 { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
 import {
   BoardService as BoardService3,
   createDb as createDb3,
-  DEFAULT_CONFIG as DEFAULT_CONFIG2,
+  DEFAULT_CONFIG as DEFAULT_CONFIG3,
   initializeSchema as initializeSchema2,
   TaskService as TaskService2
 } from "@kaban-board/core";
@@ -240,19 +796,19 @@ import {
   ListToolsRequestSchema,
   ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 function getKabanPaths2(basePath) {
   const base = basePath ?? process.cwd();
-  const kabanDir = join2(base, ".kaban");
+  const kabanDir = join4(base, ".kaban");
   return {
     kabanDir,
-    dbPath: join2(kabanDir, "board.db"),
-    configPath: join2(kabanDir, "config.json")
+    dbPath: join4(kabanDir, "board.db"),
+    configPath: join4(kabanDir, "config.json")
   };
 }
 function createContext(basePath) {
   const { dbPath, configPath } = getKabanPaths2(basePath);
-  if (!existsSync3(dbPath)) {
+  if (!existsSync5(dbPath)) {
     throw new Error("No board found. Run 'kaban init' first");
   }
   const db = createDb3(dbPath);
@@ -391,7 +947,7 @@ async function startMcpServer(workingDirectory) {
         const { name: boardName = "Kaban Board", path: basePath } = args ?? {};
         const targetPath = basePath ?? workingDirectory;
         const { kabanDir, dbPath, configPath } = getKabanPaths2(targetPath);
-        if (existsSync3(dbPath)) {
+        if (existsSync5(dbPath)) {
           return {
             content: [
               {
@@ -404,7 +960,7 @@ async function startMcpServer(workingDirectory) {
         }
         mkdirSync2(kabanDir, { recursive: true });
         const config = {
-          ...DEFAULT_CONFIG2,
+          ...DEFAULT_CONFIG3,
           board: { name: boardName }
         };
         writeFileSync2(configPath, JSON.stringify(config, null, 2));
@@ -618,15 +1174,15 @@ async function startMcpServer(workingDirectory) {
   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) => {
+var mcpCommand = new Command6("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) => {
+import { Command as Command7 } from "commander";
+var moveCommand = new Command7("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();
@@ -679,9 +1235,9 @@ var moveCommand = new Command6("move").description("Move a task to a different c
 
 // src/commands/schema.ts
 import { jsonSchemas } from "@kaban-board/core";
-import { Command as Command7 } from "commander";
+import { Command as Command8 } 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) => {
+var schemaCommand = new Command8("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) {
@@ -702,8 +1258,8 @@ Usage: kaban schema <name>`);
 
 // 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) => {
+import { Command as Command9 } from "commander";
+var statusCommand2 = new Command9("status").description("Show board status summary").option("-j, --json", "Output as JSON").action(async (options) => {
   const json = options.json;
   try {
     const { taskService, boardService } = getContext();
@@ -756,15 +1312,398 @@ var statusCommand = new Command8("status").description("Show board status summar
   }
 });
 
+// src/commands/sync.ts
+import { Command as Command10 } from "commander";
+
+// src/hook/constants.ts
+var STATUS_PRIORITY = {
+  completed: 3,
+  in_progress: 2,
+  pending: 1,
+  cancelled: 0
+};
+var STATUS_TO_COLUMN = {
+  pending: "todo",
+  in_progress: "in_progress",
+  completed: "done",
+  cancelled: "backlog"
+};
+var COLUMN_TO_STATUS = {
+  backlog: "pending",
+  todo: "pending",
+  in_progress: "in_progress",
+  review: "in_progress",
+  done: "completed"
+};
+
+// src/hook/conflict-resolver.ts
+class ConflictResolver {
+  strategy;
+  constructor(strategy) {
+    this.strategy = strategy;
+  }
+  resolve(todo, kabanTask) {
+    const kabanStatus = this.columnToStatus(kabanTask.columnId);
+    const todoColumn = STATUS_TO_COLUMN[todo.status];
+    if (this.strategy === "todowrite_wins") {
+      return {
+        winner: "todo",
+        targetColumn: todoColumn,
+        reason: "todowrite_wins strategy"
+      };
+    }
+    if (this.strategy === "kaban_wins") {
+      return {
+        winner: "kaban",
+        targetColumn: kabanTask.columnId,
+        reason: "kaban_wins strategy"
+      };
+    }
+    if (todo.status === "completed") {
+      return {
+        winner: "todo",
+        targetColumn: "done",
+        reason: "completed status always wins (terminal state)"
+      };
+    }
+    if (kabanTask.columnId === "done") {
+      return {
+        winner: "kaban",
+        targetColumn: "done",
+        reason: "kaban task already completed (terminal state)"
+      };
+    }
+    const todoPriority = STATUS_PRIORITY[todo.status];
+    const kabanPriority = STATUS_PRIORITY[kabanStatus];
+    if (todoPriority > kabanPriority) {
+      return {
+        winner: "todo",
+        targetColumn: todoColumn,
+        reason: `todo status priority (${todoPriority}) > kaban (${kabanPriority})`
+      };
+    }
+    if (kabanPriority > todoPriority) {
+      return {
+        winner: "kaban",
+        targetColumn: kabanTask.columnId,
+        reason: `kaban status priority (${kabanPriority}) > todo (${todoPriority})`
+      };
+    }
+    return {
+      winner: "todo",
+      targetColumn: todoColumn,
+      reason: "equal priority, todo wins (most recent)"
+    };
+  }
+  shouldSync(todo, cancelledPolicy) {
+    if (todo.status === "cancelled") {
+      return cancelledPolicy === "backlog";
+    }
+    return true;
+  }
+  columnToStatus(columnId) {
+    return COLUMN_TO_STATUS[columnId] ?? "pending";
+  }
+}
+
+// src/hook/kaban-client.ts
+import { spawn as spawn2 } from "node:child_process";
+
+class KabanClient {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async boardExists() {
+    try {
+      const result = await this.exec(["kaban", "status", "--json"]);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  async listTasks(columnId) {
+    const args = ["kaban", "list", "--json"];
+    if (columnId) {
+      args.push("--column", columnId);
+    }
+    const result = await this.exec(args);
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    try {
+      const tasks = JSON.parse(result.stdout);
+      return tasks.map((t) => ({
+        id: t.id,
+        title: t.title,
+        columnId: t.columnId,
+        description: t.description,
+        labels: t.labels
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getTaskById(id) {
+    const result = await this.exec(["kaban", "get", id, "--json"]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    try {
+      const task = JSON.parse(result.stdout);
+      return {
+        id: task.id,
+        title: task.title,
+        columnId: task.columnId,
+        description: task.description,
+        labels: task.labels
+      };
+    } catch {
+      return null;
+    }
+  }
+  async findTaskByTitle(title) {
+    const tasks = await this.listTasks();
+    return tasks.find((t) => t.title === title) ?? null;
+  }
+  async addTask(title, columnId = "todo") {
+    const result = await this.exec(["kaban", "add", title, "--column", columnId, "--json"]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    try {
+      const response = JSON.parse(result.stdout);
+      return response.data?.id ?? response.id ?? null;
+    } catch {
+      const match = result.stdout.match(/id[":]*\s*["']?([A-Z0-9]+)/i);
+      return match?.[1] ?? null;
+    }
+  }
+  async moveTask(id, columnId) {
+    const result = await this.exec(["kaban", "move", id, "--column", columnId]);
+    return result.exitCode === 0;
+  }
+  async completeTask(id) {
+    const result = await this.exec(["kaban", "done", id]);
+    return result.exitCode === 0;
+  }
+  async getStatus() {
+    const result = await this.exec(["kaban", "status", "--json"]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      return null;
+    }
+  }
+  exec(args) {
+    return new Promise((resolve2) => {
+      const [cmd, ...cmdArgs] = args;
+      const proc = spawn2(cmd, cmdArgs, { cwd: this.cwd });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        resolve2({ exitCode: code ?? 1, stdout, stderr });
+      });
+      proc.on("error", () => {
+        resolve2({ exitCode: 1, stdout: "", stderr: "spawn error" });
+      });
+    });
+  }
+}
+
+// src/hook/sync-engine.ts
+class SyncEngine {
+  kaban;
+  resolver;
+  config;
+  constructor(cwd, config) {
+    this.kaban = new KabanClient(cwd);
+    this.resolver = new ConflictResolver(config.conflictStrategy);
+    this.config = config;
+  }
+  async sync(todos) {
+    const result = {
+      success: true,
+      created: 0,
+      moved: 0,
+      skipped: 0,
+      errors: []
+    };
+    if (!await this.kaban.boardExists()) {
+      result.skipped = todos.length;
+      return result;
+    }
+    if (todos.length === 0) {
+      return result;
+    }
+    const kabanTasks = await this.kaban.listTasks();
+    const tasksByTitle = new Map(kabanTasks.map((t) => [t.title, t]));
+    const tasksById = new Map(kabanTasks.map((t) => [t.id, t]));
+    for (const todo of todos) {
+      if (!this.resolver.shouldSync(todo, this.config.cancelledPolicy)) {
+        result.skipped++;
+        continue;
+      }
+      try {
+        const syncResult = await this.syncTodo(todo, tasksByTitle, tasksById);
+        if (syncResult === "created")
+          result.created++;
+        else if (syncResult === "moved")
+          result.moved++;
+        else
+          result.skipped++;
+      } catch (error2) {
+        const errorMsg = error2 instanceof Error ? error2.message : String(error2);
+        result.errors.push(`${this.truncateTitle(todo.content)}: ${errorMsg}`);
+        result.success = false;
+      }
+    }
+    return result;
+  }
+  async syncTodo(todo, tasksByTitle, tasksById) {
+    const normalizedTitle = this.truncateTitle(todo.content);
+    const existing = tasksById.get(todo.id) ?? tasksByTitle.get(normalizedTitle) ?? tasksByTitle.get(todo.content);
+    if (existing) {
+      return this.handleExisting(todo, existing);
+    }
+    return this.handleNew(todo);
+  }
+  async handleExisting(todo, existing) {
+    const resolution = this.resolver.resolve(todo, existing);
+    if (resolution.winner === "kaban" || existing.columnId === resolution.targetColumn) {
+      return "skipped";
+    }
+    if (resolution.targetColumn === "done") {
+      const success2 = await this.kaban.completeTask(existing.id);
+      if (!success2)
+        throw new Error("failed to complete task");
+    } else {
+      const success2 = await this.kaban.moveTask(existing.id, resolution.targetColumn);
+      if (!success2)
+        throw new Error(`failed to move task to ${resolution.targetColumn}`);
+    }
+    return "moved";
+  }
+  async handleNew(todo) {
+    const column = todo.status === "cancelled" ? "backlog" : STATUS_TO_COLUMN[todo.status];
+    const title = this.truncateTitle(todo.content);
+    const taskId = await this.kaban.addTask(title, column);
+    if (!taskId) {
+      throw new Error("failed to create task");
+    }
+    return "created";
+  }
+  truncateTitle(title) {
+    if (title.length <= this.config.maxTitleLength)
+      return title;
+    return `${title.slice(0, this.config.maxTitleLength - 3)}...`;
+  }
+}
+
+// src/hook/sync-logger.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2 } from "node:path";
+
+class SyncLogger {
+  logPath;
+  constructor(logPath) {
+    this.logPath = this.expandPath(logPath);
+  }
+  async log(todosCount, result, durationMs) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      todosCount,
+      created: result.created,
+      moved: result.moved,
+      skipped: result.skipped,
+      errors: result.errors,
+      durationMs
+    };
+    await this.ensureDir();
+    await appendFile(this.logPath, `${JSON.stringify(entry)}
+`);
+  }
+  async ensureDir() {
+    const dir = dirname2(this.logPath);
+    if (!existsSync6(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+  }
+  expandPath(path) {
+    if (path.startsWith("~/")) {
+      return path.replace("~", homedir3());
+    }
+    return path;
+  }
+}
+
+// src/commands/sync.ts
+var syncCommand = new Command10("sync").description("Sync TodoWrite input to Kaban board (reads from stdin)").option("--no-log", "Disable sync logging").action(async (options) => {
+  const startTime = performance.now();
+  let input;
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    input = Buffer.concat(chunks).toString("utf-8");
+  } catch {
+    process.exit(0);
+  }
+  if (!input.trim()) {
+    process.exit(0);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+  const validation = TodoWriteHookInputSchema.safeParse(parsed);
+  if (!validation.success) {
+    process.exit(0);
+  }
+  const hookInput = validation.data;
+  const { cwd, tool_input } = hookInput;
+  const { todos } = tool_input;
+  if (todos.length === 0) {
+    process.exit(0);
+  }
+  const config = { ...DEFAULT_CONFIG, logEnabled: options.log !== false };
+  const engine = new SyncEngine(cwd, config);
+  const logger = new SyncLogger(config.logPath);
+  try {
+    const result = await engine.sync(todos);
+    const durationMs = Math.round(performance.now() - startTime);
+    if (config.logEnabled) {
+      await logger.log(todos.length, result, durationMs);
+    }
+    process.exit(result.success ? 0 : 1);
+  } catch {
+    process.exit(1);
+  }
+});
+
 // src/commands/tui.ts
-import { spawn } from "node:child_process";
-import { dirname, join as join3 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { dirname as dirname3, join as join5 } 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], {
+import { Command as Command11 } from "commander";
+var __dirname2 = dirname3(fileURLToPath(import.meta.url));
+var tuiCommand = new Command11("tui").description("Start interactive Terminal UI").action(async () => {
+  const tuiEntry = join5(__dirname2, "../../../tui/src/index.ts");
+  const child = spawn3("bun", ["run", tuiEntry], {
     stdio: "inherit",
     cwd: process.cwd()
   });
@@ -776,15 +1715,17 @@ var tuiCommand = new Command9("tui").description("Start interactive Terminal UI"
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
-var program = new Command10;
+var program = new Command12;
 program.name("kaban").description("Terminal Kanban for AI Code Agents").version(pkg.version);
 program.addCommand(initCommand);
 program.addCommand(addCommand);
 program.addCommand(listCommand);
 program.addCommand(moveCommand);
 program.addCommand(doneCommand);
-program.addCommand(statusCommand);
+program.addCommand(statusCommand2);
 program.addCommand(schemaCommand);
 program.addCommand(mcpCommand);
 program.addCommand(tuiCommand);
+program.addCommand(hookCommand);
+program.addCommand(syncCommand);
 program.parse();

package/dist/kaban-hook

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+// src/hook-entry.ts
+import { spawn } from "node:child_process";
+var kaban = spawn("kaban", ["sync"], {
+  stdio: ["pipe", "inherit", "inherit"]
+});
+process.stdin.pipe(kaban.stdin);
+kaban.on("close", (code) => {
+  process.exit(code ?? 0);
+});
+kaban.on("error", () => {
+  process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaban-board/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Terminal Kanban for AI Code Agents - CLI and MCP server",
   "type": "module",
   "bin": {
@@ -10,16 +10,19 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external && chmod +x ./dist/index.js",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external && bun build ./src/hook-entry.ts --outfile ./dist/kaban-hook --target node && chmod +x ./dist/index.js ./dist/kaban-hook",
     "dev": "bun run ./src/index.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@kaban-board/core": "0.1.3",
+    "@clack/prompts": "^0.11.0",
+    "@kaban-board/core": "0.2.0",
     "@modelcontextprotocol/sdk": "^1.25.2",
-    "commander": "^12.0.0"
+    "chalk": "^5.6.2",
+    "commander": "^12.0.0",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bun": "latest",