kanban-lite 1.0.4

package/dist/mcp-server.js

@@ -0,0 +1,1327 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/mcp-server/index.ts
+var path6 = __toESM(require("path"));
+var fs5 = __toESM(require("fs/promises"));
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+
+// src/sdk/KanbanSDK.ts
+var fs3 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
+
+// node_modules/fractional-indexing/src/index.js
+var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function midpoint(a, b, digits) {
+  const zero = digits[0];
+  if (b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
+    throw new Error("trailing zero");
+  }
+  if (b) {
+    let n = 0;
+    while ((a[n] || zero) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+    }
+  }
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  } else {
+    if (b && b.length > 1) {
+      return b.slice(0, 1);
+    } else {
+      return digits[digitA] + midpoint(a.slice(1), null, digits);
+    }
+  }
+}
+function validateInteger(int) {
+  if (int.length !== getIntegerLength(int[0])) {
+    throw new Error("invalid integer part of order key: " + int);
+  }
+}
+function getIntegerLength(head) {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+  } else {
+    throw new Error("invalid order key head: " + head);
+  }
+}
+function getIntegerPart(key) {
+  const integerPartLength = getIntegerLength(key[0]);
+  if (integerPartLength > key.length) {
+    throw new Error("invalid order key: " + key);
+  }
+  return key.slice(0, integerPartLength);
+}
+function validateOrderKey(key, digits) {
+  if (key === "A" + digits[0].repeat(26)) {
+    throw new Error("invalid order key: " + key);
+  }
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === digits[0]) {
+    throw new Error("invalid order key: " + key);
+  }
+}
+function incrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1; carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = digits[0];
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return "a" + digits[0];
+    }
+    if (head === "z") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(digits[0]);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function decrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1; borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return "Z" + digits.slice(-1);
+    }
+    if (head === "A") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
+  if (a != null) {
+    validateOrderKey(a, digits);
+  }
+  if (b != null) {
+    validateOrderKey(b, digits);
+  }
+  if (a != null && b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a == null) {
+    if (b == null) {
+      return "a" + digits[0];
+    }
+    const ib2 = getIntegerPart(b);
+    const fb2 = b.slice(ib2.length);
+    if (ib2 === "A" + digits[0].repeat(26)) {
+      return ib2 + midpoint("", fb2, digits);
+    }
+    if (ib2 < b) {
+      return ib2;
+    }
+    const res = decrementInteger(ib2, digits);
+    if (res == null) {
+      throw new Error("cannot decrement any more");
+    }
+    return res;
+  }
+  if (b == null) {
+    const ia2 = getIntegerPart(a);
+    const fa2 = a.slice(ia2.length);
+    const i2 = incrementInteger(ia2, digits);
+    return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
+  }
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb, digits);
+  }
+  const i = incrementInteger(ia, digits);
+  if (i == null) {
+    throw new Error("cannot increment any more");
+  }
+  if (i < b) {
+    return i;
+  }
+  return ia + midpoint(fa, null, digits);
+}
+
+// src/shared/types.ts
+function getTitleFromContent(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match)
+    return match[1].trim();
+  const firstLine = content.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+  return firstLine || "Untitled";
+}
+function generateSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "feature";
+}
+function generateFeatureFilename(id, title) {
+  const slug = generateSlug(title);
+  return `${id}-${slug}`;
+}
+function extractNumericId(filenameOrId) {
+  const match = filenameOrId.match(/^(\d+)(?:-|$)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+var DEFAULT_COLUMNS = [
+  { id: "backlog", name: "Backlog", color: "#6b7280" },
+  { id: "todo", name: "To Do", color: "#3b82f6" },
+  { id: "in-progress", name: "In Progress", color: "#f59e0b" },
+  { id: "review", name: "Review", color: "#8b5cf6" },
+  { id: "done", name: "Done", color: "#22c55e" }
+];
+
+// src/shared/config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var DEFAULT_CONFIG = {
+  featuresDirectory: ".kanban",
+  defaultPriority: "medium",
+  defaultStatus: "backlog",
+  columns: [
+    { id: "backlog", name: "Backlog", color: "#6b7280" },
+    { id: "todo", name: "To Do", color: "#3b82f6" },
+    { id: "in-progress", name: "In Progress", color: "#f59e0b" },
+    { id: "review", name: "Review", color: "#8b5cf6" },
+    { id: "done", name: "Done", color: "#22c55e" }
+  ],
+  aiAgent: "claude",
+  nextCardId: 1,
+  showPriorityBadges: true,
+  showAssignee: true,
+  showDueDate: true,
+  showLabels: true,
+  showBuildWithAI: true,
+  showFileName: false,
+  compactMode: false,
+  markdownEditorMode: false
+};
+var CONFIG_FILENAME = ".kanban.json";
+function configPath(workspaceRoot) {
+  return path.join(workspaceRoot, CONFIG_FILENAME);
+}
+function readConfig(workspaceRoot) {
+  const filePath = configPath(workspaceRoot);
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return { ...DEFAULT_CONFIG, ...raw };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(workspaceRoot, config) {
+  const filePath = configPath(workspaceRoot);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function allocateCardId(workspaceRoot) {
+  const config = readConfig(workspaceRoot);
+  const id = config.nextCardId;
+  writeConfig(workspaceRoot, { ...config, nextCardId: id + 1 });
+  return id;
+}
+function syncCardIdCounter(workspaceRoot, existingIds) {
+  if (existingIds.length === 0)
+    return;
+  const maxId = Math.max(...existingIds);
+  const config = readConfig(workspaceRoot);
+  if (config.nextCardId <= maxId) {
+    writeConfig(workspaceRoot, { ...config, nextCardId: maxId + 1 });
+  }
+}
+function configToSettings(config) {
+  return {
+    showPriorityBadges: config.showPriorityBadges,
+    showAssignee: config.showAssignee,
+    showDueDate: config.showDueDate,
+    showLabels: config.showLabels,
+    showBuildWithAI: config.showBuildWithAI,
+    showFileName: config.showFileName,
+    compactMode: config.compactMode,
+    markdownEditorMode: config.markdownEditorMode,
+    defaultPriority: config.defaultPriority,
+    defaultStatus: config.defaultStatus
+  };
+}
+function settingsToConfig(config, settings) {
+  return {
+    ...config,
+    showPriorityBadges: settings.showPriorityBadges,
+    showAssignee: settings.showAssignee,
+    showDueDate: settings.showDueDate,
+    showLabels: settings.showLabels,
+    showFileName: settings.showFileName,
+    compactMode: settings.compactMode,
+    defaultPriority: settings.defaultPriority,
+    defaultStatus: settings.defaultStatus
+  };
+}
+
+// src/sdk/parser.ts
+var path2 = __toESM(require("path"));
+function extractIdFromFilename(filePath) {
+  const basename4 = path2.basename(filePath, ".md");
+  const numericMatch = basename4.match(/^(\d+)-/);
+  if (numericMatch)
+    return numericMatch[1];
+  return basename4;
+}
+function parseFeatureFile(content, filePath) {
+  content = content.replace(/\r\n/g, "\n");
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!frontmatterMatch)
+    return null;
+  const frontmatter = frontmatterMatch[1];
+  const body = frontmatterMatch[2] || "";
+  const getValue = (key) => {
+    const match = frontmatter.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+    if (!match)
+      return "";
+    const value = match[1].trim().replace(/^["']|["']$/g, "");
+    return value === "null" ? "" : value;
+  };
+  const getArrayValue = (key) => {
+    const match = frontmatter.match(new RegExp(`^${key}:\\s*\\[([^\\]]*)\\]`, "m"));
+    if (!match)
+      return [];
+    return match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+  };
+  return {
+    id: getValue("id") || extractIdFromFilename(filePath),
+    status: getValue("status") || "backlog",
+    priority: getValue("priority") || "medium",
+    assignee: getValue("assignee") || null,
+    dueDate: getValue("dueDate") || null,
+    created: getValue("created") || (/* @__PURE__ */ new Date()).toISOString(),
+    modified: getValue("modified") || (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: getValue("completedAt") || null,
+    labels: getArrayValue("labels"),
+    attachments: getArrayValue("attachments"),
+    order: getValue("order") || "a0",
+    content: body.trim(),
+    filePath
+  };
+}
+function serializeFeature(feature) {
+  const frontmatter = [
+    "---",
+    `id: "${feature.id}"`,
+    `status: "${feature.status}"`,
+    `priority: "${feature.priority}"`,
+    `assignee: ${feature.assignee ? `"${feature.assignee}"` : "null"}`,
+    `dueDate: ${feature.dueDate ? `"${feature.dueDate}"` : "null"}`,
+    `created: "${feature.created}"`,
+    `modified: "${feature.modified}"`,
+    `completedAt: ${feature.completedAt ? `"${feature.completedAt}"` : "null"}`,
+    `labels: [${feature.labels.map((l) => `"${l}"`).join(", ")}]`,
+    `attachments: [${(feature.attachments || []).map((a) => `"${a}"`).join(", ")}]`,
+    `order: "${feature.order}"`,
+    "---",
+    ""
+  ].join("\n");
+  return frontmatter + feature.content;
+}
+
+// src/sdk/fileUtils.ts
+var path3 = __toESM(require("path"));
+var fs2 = __toESM(require("fs/promises"));
+function getFeatureFilePath(featuresDir, status, filename) {
+  return path3.join(featuresDir, status, `${filename}.md`);
+}
+async function ensureDirectories(featuresDir) {
+  await fs2.mkdir(featuresDir, { recursive: true });
+}
+async function moveFeatureFile(currentPath, featuresDir, newStatus, attachments) {
+  const filename = path3.basename(currentPath);
+  const targetDir = path3.join(featuresDir, newStatus);
+  let targetPath = path3.join(targetDir, filename);
+  if (currentPath === targetPath)
+    return currentPath;
+  const ext = path3.extname(filename);
+  const base = path3.basename(filename, ext);
+  let counter = 1;
+  while (await fileExists(targetPath)) {
+    targetPath = path3.join(targetDir, `${base}-${counter}${ext}`);
+    counter++;
+  }
+  await fs2.mkdir(targetDir, { recursive: true });
+  await fs2.rename(currentPath, targetPath);
+  if (attachments && attachments.length > 0) {
+    const sourceDir = path3.dirname(currentPath);
+    for (const attachment of attachments) {
+      const srcAttach = path3.join(sourceDir, attachment);
+      const destAttach = path3.join(targetDir, attachment);
+      try {
+        await fs2.access(srcAttach);
+        await fs2.rename(srcAttach, destAttach);
+      } catch {
+      }
+    }
+  }
+  return targetPath;
+}
+async function renameFeatureFile(currentPath, newFilename) {
+  const dir = path3.dirname(currentPath);
+  const newPath = path3.join(dir, `${newFilename}.md`);
+  if (currentPath === newPath)
+    return currentPath;
+  await fs2.rename(currentPath, newPath);
+  return newPath;
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/sdk/KanbanSDK.ts
+var BOARD_CONFIG_FILE = "board.json";
+var KanbanSDK = class {
+  constructor(featuresDir) {
+    this.featuresDir = featuresDir;
+  }
+  async init() {
+    await ensureDirectories(this.featuresDir);
+  }
+  // --- Card CRUD ---
+  async listCards() {
+    await ensureDirectories(this.featuresDir);
+    const cards = [];
+    const entries = await fs3.readdir(this.featuresDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("."))
+        continue;
+      const subdir = path4.join(this.featuresDir, entry.name);
+      try {
+        const mdFiles = await this._readMdFiles(subdir);
+        for (const filePath of mdFiles) {
+          const card = await this._loadCard(filePath);
+          if (card)
+            cards.push(card);
+        }
+      } catch {
+      }
+    }
+    try {
+      const rootFiles = await this._readMdFiles(this.featuresDir);
+      for (const filePath of rootFiles) {
+        const card = await this._loadCard(filePath);
+        if (card)
+          cards.push(card);
+      }
+    } catch {
+    }
+    const numericIds = cards.map((c) => parseInt(c.id, 10)).filter((n) => !Number.isNaN(n));
+    if (numericIds.length > 0) {
+      syncCardIdCounter(path4.dirname(this.featuresDir), numericIds);
+    }
+    return cards.sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+  }
+  async getCard(cardId) {
+    const cards = await this.listCards();
+    return cards.find((c) => c.id === cardId) || null;
+  }
+  async createCard(data) {
+    await ensureDirectories(this.featuresDir);
+    const status = data.status || "backlog";
+    const priority = data.priority || "medium";
+    const title = getTitleFromContent(data.content);
+    const workspaceRoot = path4.dirname(this.featuresDir);
+    const numericId = allocateCardId(workspaceRoot);
+    const filename = generateFeatureFilename(numericId, title);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const cards = await this.listCards();
+    const cardsInStatus = cards.filter((c) => c.status === status).sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+    const lastOrder = cardsInStatus.length > 0 ? cardsInStatus[cardsInStatus.length - 1].order : null;
+    const card = {
+      id: String(numericId),
+      status,
+      priority,
+      assignee: data.assignee ?? null,
+      dueDate: data.dueDate ?? null,
+      created: now,
+      modified: now,
+      completedAt: status === "done" ? now : null,
+      labels: data.labels || [],
+      attachments: data.attachments || [],
+      order: generateKeyBetween(lastOrder, null),
+      content: data.content,
+      filePath: getFeatureFilePath(this.featuresDir, status, filename)
+    };
+    await fs3.mkdir(path4.dirname(card.filePath), { recursive: true });
+    await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async updateCard(cardId, updates) {
+    const card = await this.getCard(cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const oldStatus = card.status;
+    const oldTitle = getTitleFromContent(card.content);
+    const { filePath: _fp, id: _id, ...safeUpdates } = updates;
+    Object.assign(card, safeUpdates);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    if (oldStatus !== card.status) {
+      card.completedAt = card.status === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    }
+    await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    const newTitle = getTitleFromContent(card.content);
+    const numericId = extractNumericId(card.id);
+    if (numericId !== null && newTitle !== oldTitle) {
+      const newFilename = generateFeatureFilename(numericId, newTitle);
+      card.filePath = await renameFeatureFile(card.filePath, newFilename);
+    }
+    if (oldStatus !== card.status) {
+      const newPath = await moveFeatureFile(card.filePath, this.featuresDir, card.status, card.attachments);
+      card.filePath = newPath;
+    }
+    return card;
+  }
+  async moveCard(cardId, newStatus, position) {
+    const cards = await this.listCards();
+    const card = cards.find((c) => c.id === cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const oldStatus = card.status;
+    card.status = newStatus;
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    if (oldStatus !== newStatus) {
+      card.completedAt = newStatus === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    }
+    const targetColumnCards = cards.filter((c) => c.status === newStatus && c.id !== cardId).sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+    const pos = position !== void 0 ? Math.max(0, Math.min(position, targetColumnCards.length)) : targetColumnCards.length;
+    const before = pos > 0 ? targetColumnCards[pos - 1].order : null;
+    const after = pos < targetColumnCards.length ? targetColumnCards[pos].order : null;
+    card.order = generateKeyBetween(before, after);
+    await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    if (oldStatus !== newStatus) {
+      const newPath = await moveFeatureFile(card.filePath, this.featuresDir, newStatus, card.attachments);
+      card.filePath = newPath;
+    }
+    return card;
+  }
+  async deleteCard(cardId) {
+    const card = await this.getCard(cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    await fs3.unlink(card.filePath);
+  }
+  async getCardsByStatus(status) {
+    const cards = await this.listCards();
+    return cards.filter((c) => c.status === status);
+  }
+  async getUniqueAssignees() {
+    const cards = await this.listCards();
+    const assignees = /* @__PURE__ */ new Set();
+    for (const c of cards) {
+      if (c.assignee)
+        assignees.add(c.assignee);
+    }
+    return [...assignees].sort();
+  }
+  async getUniqueLabels() {
+    const cards = await this.listCards();
+    const labels = /* @__PURE__ */ new Set();
+    for (const c of cards) {
+      for (const l of c.labels)
+        labels.add(l);
+    }
+    return [...labels].sort();
+  }
+  // --- Attachment management ---
+  async addAttachment(cardId, sourcePath) {
+    const card = await this.getCard(cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const fileName = path4.basename(sourcePath);
+    const cardDir = path4.dirname(card.filePath);
+    const destPath = path4.join(cardDir, fileName);
+    const sourceDir = path4.dirname(path4.resolve(sourcePath));
+    if (sourceDir !== cardDir) {
+      await fs3.copyFile(path4.resolve(sourcePath), destPath);
+    }
+    if (!card.attachments.includes(fileName)) {
+      card.attachments.push(fileName);
+    }
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async removeAttachment(cardId, attachment) {
+    const card = await this.getCard(cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    card.attachments = card.attachments.filter((a) => a !== attachment);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async listAttachments(cardId) {
+    const card = await this.getCard(cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    return card.attachments;
+  }
+  // --- Column management ---
+  async listColumns() {
+    const config = await this._readBoardConfig();
+    return config.columns;
+  }
+  async addColumn(column) {
+    const config = await this._readBoardConfig();
+    if (config.columns.some((c) => c.id === column.id)) {
+      throw new Error(`Column already exists: ${column.id}`);
+    }
+    config.columns.push(column);
+    await this._writeBoardConfig(config);
+    return config.columns;
+  }
+  async updateColumn(columnId, updates) {
+    const config = await this._readBoardConfig();
+    const col = config.columns.find((c) => c.id === columnId);
+    if (!col)
+      throw new Error(`Column not found: ${columnId}`);
+    if (updates.name !== void 0)
+      col.name = updates.name;
+    if (updates.color !== void 0)
+      col.color = updates.color;
+    await this._writeBoardConfig(config);
+    return config.columns;
+  }
+  async removeColumn(columnId) {
+    const config = await this._readBoardConfig();
+    const idx = config.columns.findIndex((c) => c.id === columnId);
+    if (idx === -1)
+      throw new Error(`Column not found: ${columnId}`);
+    const cards = await this.listCards();
+    const cardsInColumn = cards.filter((c) => c.status === columnId);
+    if (cardsInColumn.length > 0) {
+      throw new Error(`Cannot remove column "${columnId}": ${cardsInColumn.length} card(s) still in this column`);
+    }
+    config.columns.splice(idx, 1);
+    await this._writeBoardConfig(config);
+    return config.columns;
+  }
+  async reorderColumns(columnIds) {
+    const config = await this._readBoardConfig();
+    const colMap = new Map(config.columns.map((c) => [c.id, c]));
+    for (const id of columnIds) {
+      if (!colMap.has(id))
+        throw new Error(`Column not found: ${id}`);
+    }
+    if (columnIds.length !== config.columns.length) {
+      throw new Error("Must include all column IDs when reordering");
+    }
+    config.columns = columnIds.map((id) => colMap.get(id));
+    await this._writeBoardConfig(config);
+    return config.columns;
+  }
+  // --- Private helpers ---
+  async _readMdFiles(dir) {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path4.join(dir, e.name));
+  }
+  async _loadCard(filePath) {
+    const content = await fs3.readFile(filePath, "utf-8");
+    return parseFeatureFile(content, filePath);
+  }
+  _boardConfigPath() {
+    return path4.join(this.featuresDir, BOARD_CONFIG_FILE);
+  }
+  async _readBoardConfig() {
+    try {
+      const raw = await fs3.readFile(this._boardConfigPath(), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { columns: [...DEFAULT_COLUMNS] };
+    }
+  }
+  async _writeBoardConfig(config) {
+    await ensureDirectories(this.featuresDir);
+    await fs3.writeFile(this._boardConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+  }
+};
+
+// src/standalone/webhooks.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var WEBHOOKS_FILENAME = ".kanban-webhooks.json";
+function webhooksPath(workspaceRoot) {
+  return path5.join(workspaceRoot, WEBHOOKS_FILENAME);
+}
+function loadWebhooks(workspaceRoot) {
+  try {
+    const raw = fs4.readFileSync(webhooksPath(workspaceRoot), "utf-8");
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+function saveWebhooks(workspaceRoot, webhooks) {
+  fs4.writeFileSync(webhooksPath(workspaceRoot), JSON.stringify(webhooks, null, 2) + "\n", "utf-8");
+}
+function createWebhook(workspaceRoot, config) {
+  const webhooks = loadWebhooks(workspaceRoot);
+  const webhook = {
+    id: "wh_" + crypto.randomBytes(8).toString("hex"),
+    url: config.url,
+    events: config.events,
+    secret: config.secret,
+    active: true
+  };
+  webhooks.push(webhook);
+  saveWebhooks(workspaceRoot, webhooks);
+  return webhook;
+}
+function deleteWebhook(workspaceRoot, id) {
+  const webhooks = loadWebhooks(workspaceRoot);
+  const filtered = webhooks.filter((w) => w.id !== id);
+  if (filtered.length === webhooks.length)
+    return false;
+  saveWebhooks(workspaceRoot, filtered);
+  return true;
+}
+
+// src/mcp-server/index.ts
+async function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    try {
+      await fs5.access(path6.join(dir, ".git"));
+      return dir;
+    } catch {
+    }
+    try {
+      await fs5.access(path6.join(dir, "package.json"));
+      return dir;
+    } catch {
+    }
+    const parent = path6.dirname(dir);
+    if (parent === dir)
+      return startDir;
+    dir = parent;
+  }
+}
+async function resolveFeaturesDir() {
+  const dirIndex = process.argv.indexOf("--dir");
+  if (dirIndex !== -1 && process.argv[dirIndex + 1]) {
+    return path6.resolve(process.argv[dirIndex + 1]);
+  }
+  if (process.env.KANBAN_FEATURES_DIR) {
+    return path6.resolve(process.env.KANBAN_FEATURES_DIR);
+  }
+  const root = await findWorkspaceRoot(process.cwd());
+  return path6.join(root, ".devtool", "features");
+}
+function getTitleFromContent2(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match)
+    return match[1].trim();
+  const firstLine = content.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+  return firstLine || "Untitled";
+}
+async function main() {
+  const featuresDir = await resolveFeaturesDir();
+  const sdk = new KanbanSDK(featuresDir);
+  const server = new import_mcp.McpServer({
+    name: "kanban-lite",
+    version: "1.0.0"
+  });
+  server.tool(
+    "list_cards",
+    "List all kanban cards. Optionally filter by status, priority, assignee, or label.",
+    {
+      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Filter by status"),
+      priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Filter by priority"),
+      assignee: import_zod.z.string().optional().describe("Filter by assignee name"),
+      label: import_zod.z.string().optional().describe("Filter by label")
+    },
+    async ({ status, priority, assignee, label }) => {
+      let cards = await sdk.listCards();
+      if (status)
+        cards = cards.filter((c) => c.status === status);
+      if (priority)
+        cards = cards.filter((c) => c.priority === priority);
+      if (assignee)
+        cards = cards.filter((c) => c.assignee === assignee);
+      if (label)
+        cards = cards.filter((c) => c.labels.includes(label));
+      const summary = cards.map((c) => ({
+        id: c.id,
+        title: getTitleFromContent2(c.content),
+        status: c.status,
+        priority: c.priority,
+        assignee: c.assignee,
+        labels: c.labels,
+        dueDate: c.dueDate
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(summary, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "get_card",
+    "Get full details of a specific kanban card by ID. Supports partial ID matching.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)")
+    },
+    async ({ cardId }) => {
+      let card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          card = matches[0];
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(card, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "create_card",
+    "Create a new kanban card. Returns the created card.",
+    {
+      title: import_zod.z.string().describe("Card title"),
+      body: import_zod.z.string().optional().describe("Card body/description (markdown)"),
+      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Initial status (default: backlog)"),
+      priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Priority level (default: medium)"),
+      assignee: import_zod.z.string().optional().describe("Assignee name"),
+      dueDate: import_zod.z.string().optional().describe("Due date (ISO format or YYYY-MM-DD)"),
+      labels: import_zod.z.array(import_zod.z.string()).optional().describe("Labels/tags")
+    },
+    async ({ title, body, status, priority, assignee, dueDate, labels }) => {
+      const content = `# ${title}${body ? "\n\n" + body : ""}`;
+      const card = await sdk.createCard({
+        content,
+        status,
+        priority,
+        assignee: assignee || null,
+        dueDate: dueDate || null,
+        labels: labels || []
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(card, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "update_card",
+    "Update fields of an existing kanban card. Only specified fields are changed.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
+      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("New status"),
+      priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("New priority"),
+      assignee: import_zod.z.string().optional().describe("New assignee"),
+      dueDate: import_zod.z.string().optional().describe("New due date"),
+      labels: import_zod.z.array(import_zod.z.string()).optional().describe("New labels (replaces existing)"),
+      content: import_zod.z.string().optional().describe("New markdown content (replaces existing body)")
+    },
+    async ({ cardId, status, priority, assignee, dueDate, labels, content }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      const updates = {};
+      if (status)
+        updates.status = status;
+      if (priority)
+        updates.priority = priority;
+      if (assignee !== void 0)
+        updates.assignee = assignee || null;
+      if (dueDate !== void 0)
+        updates.dueDate = dueDate || null;
+      if (labels)
+        updates.labels = labels;
+      if (content !== void 0)
+        updates.content = content;
+      const updated = await sdk.updateCard(resolvedId, updates);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(updated, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "move_card",
+    "Move a kanban card to a different status column.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
+      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).describe("Target status column")
+    },
+    async ({ cardId, status }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      const updated = await sdk.moveCard(resolvedId, status);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ id: updated.id, status: updated.status, order: updated.order }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "delete_card",
+    "Permanently delete a kanban card.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)")
+    },
+    async ({ cardId }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      await sdk.deleteCard(resolvedId);
+      return {
+        content: [{
+          type: "text",
+          text: `Deleted card: ${resolvedId}`
+        }]
+      };
+    }
+  );
+  server.tool(
+    "list_attachments",
+    "List all attachments on a kanban card.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)")
+    },
+    async ({ cardId }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      const attachments = await sdk.listAttachments(resolvedId);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(attachments, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "add_attachment",
+    "Add a file attachment to a kanban card. Copies the file to the card directory.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
+      filePath: import_zod.z.string().describe("Absolute path to the file to attach")
+    },
+    async ({ cardId, filePath }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      const updated = await sdk.addAttachment(resolvedId, filePath);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ id: updated.id, attachments: updated.attachments }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "remove_attachment",
+    "Remove an attachment from a kanban card. Only removes the reference, not the file.",
+    {
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
+      attachment: import_zod.z.string().describe("Attachment filename to remove")
+    },
+    async ({ cardId, attachment }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId);
+      if (!card) {
+        const all = await sdk.listCards();
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      const updated = await sdk.removeAttachment(resolvedId, attachment);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ id: updated.id, attachments: updated.attachments }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "list_columns",
+    "List all kanban board columns.",
+    {},
+    async () => {
+      const columns = await sdk.listColumns();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(columns, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "add_column",
+    "Add a new column to the kanban board.",
+    {
+      id: import_zod.z.string().describe("Unique column ID (used in card status field)"),
+      name: import_zod.z.string().describe("Display name for the column"),
+      color: import_zod.z.string().describe('Column color (hex format, e.g. "#3b82f6")')
+    },
+    async ({ id, name, color }) => {
+      const columns = await sdk.addColumn({ id, name, color });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(columns, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "update_column",
+    "Update an existing kanban board column.",
+    {
+      columnId: import_zod.z.string().describe("Column ID to update"),
+      name: import_zod.z.string().optional().describe("New display name"),
+      color: import_zod.z.string().optional().describe("New color (hex format)")
+    },
+    async ({ columnId, name, color }) => {
+      const updates = {};
+      if (name)
+        updates.name = name;
+      if (color)
+        updates.color = color;
+      const columns = await sdk.updateColumn(columnId, updates);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(columns, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "remove_column",
+    "Remove a column from the kanban board. Fails if any cards are in the column.",
+    {
+      columnId: import_zod.z.string().describe("Column ID to remove")
+    },
+    async ({ columnId }) => {
+      const columns = await sdk.removeColumn(columnId);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(columns, null, 2)
+        }]
+      };
+    }
+  );
+  const workspaceRoot = path6.dirname(featuresDir);
+  server.tool(
+    "get_settings",
+    "Get the current kanban board display settings.",
+    {},
+    async () => {
+      const config = readConfig(workspaceRoot);
+      const settings = configToSettings(config);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(settings, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "update_settings",
+    "Update kanban board display settings. Only specified fields are changed.",
+    {
+      showPriorityBadges: import_zod.z.boolean().optional().describe("Show priority badges on cards"),
+      showAssignee: import_zod.z.boolean().optional().describe("Show assignee on cards"),
+      showDueDate: import_zod.z.boolean().optional().describe("Show due date on cards"),
+      showLabels: import_zod.z.boolean().optional().describe("Show labels on cards"),
+      showFileName: import_zod.z.boolean().optional().describe("Show file name on cards"),
+      compactMode: import_zod.z.boolean().optional().describe("Enable compact card display"),
+      defaultPriority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Default priority for new cards"),
+      defaultStatus: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Default status for new cards")
+    },
+    async (updates) => {
+      const config = readConfig(workspaceRoot);
+      const settings = configToSettings(config);
+      const merged = { ...settings };
+      for (const [key, value] of Object.entries(updates)) {
+        if (value !== void 0) {
+          merged[key] = value;
+        }
+      }
+      writeConfig(workspaceRoot, settingsToConfig(config, merged));
+      const updated = configToSettings(readConfig(workspaceRoot));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(updated, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "list_webhooks",
+    "List all registered webhooks.",
+    {},
+    async () => {
+      const webhooks = loadWebhooks(workspaceRoot);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(webhooks, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "add_webhook",
+    "Register a new webhook to receive event notifications.",
+    {
+      url: import_zod.z.string().describe("Webhook target URL (HTTP/HTTPS)"),
+      events: import_zod.z.array(import_zod.z.string()).optional().describe('Events to subscribe to (e.g. ["task.created", "task.updated"]). Default: ["*"] for all.'),
+      secret: import_zod.z.string().optional().describe("Optional HMAC-SHA256 signing secret")
+    },
+    async ({ url, events, secret }) => {
+      const webhook = createWebhook(workspaceRoot, {
+        url,
+        events: events || ["*"],
+        secret
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(webhook, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "remove_webhook",
+    "Remove a registered webhook by ID.",
+    {
+      webhookId: import_zod.z.string().describe('Webhook ID (e.g. "wh_abc123")')
+    },
+    async ({ webhookId }) => {
+      const removed = deleteWebhook(workspaceRoot, webhookId);
+      if (!removed) {
+        return {
+          content: [{ type: "text", text: `Webhook not found: ${webhookId}` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Deleted webhook: ${webhookId}`
+        }]
+      };
+    }
+  );
+  server.tool(
+    "get_workspace_info",
+    "Get the workspace root path and features directory.",
+    {},
+    async () => {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ workspaceRoot, featuresDir }, null, 2)
+        }]
+      };
+    }
+  );
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error(`MCP Server error: ${err.message}`);
+  process.exit(1);
+});