kanban-lite 1.0.9 → 1.0.13

package/dist/sdk/index.mjs

@@ -0,0 +1,1168 @@
+// src/sdk/KanbanSDK.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+
+// node_modules/.pnpm/fractional-indexing@3.2.0/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);
+}
+function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [generateKeyBetween(a, b, digits)];
+  }
+  if (b == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0; i < n - 1; i++) {
+      c2 = generateKeyBetween(c2, b, digits);
+      result.push(c2);
+    }
+    return result;
+  }
+  if (a == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0; i < n - 1; i++) {
+      c2 = generateKeyBetween(a, c2, digits);
+      result.push(c2);
+    }
+    result.reverse();
+    return result;
+  }
+  const mid = Math.floor(n / 2);
+  const c = generateKeyBetween(a, b, digits);
+  return [
+    ...generateNKeysBetween(a, c, mid, digits),
+    c,
+    ...generateNKeysBetween(c, b, n - mid - 1, 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
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_BOARD_CONFIG = {
+  name: "Default",
+  columns: [...DEFAULT_COLUMNS],
+  nextCardId: 1,
+  defaultStatus: "backlog",
+  defaultPriority: "medium"
+};
+var DEFAULT_CONFIG = {
+  version: 2,
+  boards: {
+    default: { ...DEFAULT_BOARD_CONFIG, columns: [...DEFAULT_COLUMNS] }
+  },
+  defaultBoard: "default",
+  featuresDirectory: ".kanban",
+  aiAgent: "claude",
+  defaultPriority: "medium",
+  defaultStatus: "backlog",
+  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 migrateConfigV1ToV2(raw) {
+  const v1Defaults = {
+    featuresDirectory: ".kanban",
+    defaultPriority: "medium",
+    defaultStatus: "backlog",
+    columns: [...DEFAULT_COLUMNS],
+    aiAgent: "claude",
+    nextCardId: 1,
+    showPriorityBadges: true,
+    showAssignee: true,
+    showDueDate: true,
+    showLabels: true,
+    showBuildWithAI: true,
+    showFileName: false,
+    compactMode: false,
+    markdownEditorMode: false
+  };
+  const v1 = { ...v1Defaults, ...raw };
+  return {
+    version: 2,
+    boards: {
+      default: {
+        name: "Default",
+        columns: v1.columns,
+        nextCardId: v1.nextCardId,
+        defaultStatus: v1.defaultStatus,
+        defaultPriority: v1.defaultPriority
+      }
+    },
+    defaultBoard: "default",
+    featuresDirectory: v1.featuresDirectory,
+    aiAgent: v1.aiAgent,
+    defaultPriority: v1.defaultPriority,
+    defaultStatus: v1.defaultStatus,
+    showPriorityBadges: v1.showPriorityBadges,
+    showAssignee: v1.showAssignee,
+    showDueDate: v1.showDueDate,
+    showLabels: v1.showLabels,
+    showBuildWithAI: v1.showBuildWithAI,
+    showFileName: v1.showFileName,
+    compactMode: v1.compactMode,
+    markdownEditorMode: v1.markdownEditorMode
+  };
+}
+function readConfig(workspaceRoot) {
+  const filePath = configPath(workspaceRoot);
+  const defaults = { ...DEFAULT_CONFIG, boards: { default: { ...DEFAULT_BOARD_CONFIG, columns: [...DEFAULT_COLUMNS] } } };
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!raw.version || raw.version === 1) {
+      const v2 = migrateConfigV1ToV2(raw);
+      writeConfig(workspaceRoot, v2);
+      return v2;
+    }
+    const config = { ...defaults, ...raw };
+    if (!config.boards || Object.keys(config.boards).length === 0) {
+      config.boards = defaults.boards;
+    }
+    return config;
+  } catch {
+    return defaults;
+  }
+}
+function writeConfig(workspaceRoot, config) {
+  const filePath = configPath(workspaceRoot);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getDefaultBoardId(workspaceRoot) {
+  const config = readConfig(workspaceRoot);
+  return config.defaultBoard;
+}
+function getBoardConfig(workspaceRoot, boardId) {
+  const config = readConfig(workspaceRoot);
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board) {
+    throw new Error(`Board '${resolvedId}' not found`);
+  }
+  return board;
+}
+function allocateCardId(workspaceRoot, boardId) {
+  const config = readConfig(workspaceRoot);
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board) {
+    throw new Error(`Board '${resolvedId}' not found`);
+  }
+  const id = board.nextCardId;
+  board.nextCardId = id + 1;
+  writeConfig(workspaceRoot, config);
+  return id;
+}
+function syncCardIdCounter(workspaceRoot, boardId, existingIds) {
+  if (existingIds.length === 0)
+    return;
+  const maxId = Math.max(...existingIds);
+  const config = readConfig(workspaceRoot);
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board)
+    return;
+  if (board.nextCardId <= maxId) {
+    board.nextCardId = maxId + 1;
+    writeConfig(workspaceRoot, config);
+  }
+}
+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
+import * as path2 from "path";
+function extractIdFromFilename(filePath) {
+  const basename4 = path2.basename(filePath, ".md");
+  const numericMatch = basename4.match(/^(\d+)-/);
+  if (numericMatch)
+    return numericMatch[1];
+  return basename4;
+}
+function parseCommentBlock(header, body) {
+  const getValue = (key) => {
+    const match = header.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+    if (!match)
+      return "";
+    return match[1].trim().replace(/^["']|["']$/g, "");
+  };
+  if (getValue("comment") !== "true")
+    return null;
+  const id = getValue("id");
+  const author = getValue("author");
+  const created = getValue("created");
+  if (!id)
+    return null;
+  return { id, author, created, content: body.trim() };
+}
+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 rest = 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);
+  };
+  const sections = rest.split(/\n---\n/);
+  let body = sections[0] || "";
+  const comments = [];
+  for (let i = 1; i < sections.length; i += 2) {
+    const header = sections[i];
+    const commentBody = sections[i + 1] || "";
+    if (header?.includes("comment:")) {
+      const comment = parseCommentBlock(header, commentBody);
+      if (comment)
+        comments.push(comment);
+    } else {
+      body += `
+---
+${header}`;
+      if (sections[i + 1] !== void 0) {
+        body += `
+---
+${sections[i + 1]}`;
+        i++;
+      }
+    }
+  }
+  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"),
+    comments,
+    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");
+  let result = frontmatter + feature.content;
+  const comments = feature.comments || [];
+  for (const comment of comments) {
+    result += "\n\n---\n";
+    result += `comment: true
+`;
+    result += `id: "${comment.id}"
+`;
+    result += `author: "${comment.author}"
+`;
+    result += `created: "${comment.created}"
+`;
+    result += "---\n";
+    result += comment.content;
+  }
+  return result;
+}
+
+// src/sdk/fileUtils.ts
+import * as path3 from "path";
+import * as fs2 from "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 ensureStatusSubfolders(featuresDir, statuses) {
+  for (const status of statuses) {
+    await fs2.mkdir(path3.join(featuresDir, status), { 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;
+}
+function getStatusFromPath(filePath, featuresDir) {
+  const relative2 = path3.relative(featuresDir, filePath);
+  const parts = relative2.split(path3.sep);
+  if (parts.length === 2) {
+    return parts[0];
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/sdk/migration.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+async function migrateFileSystemToMultiBoard(featuresDir) {
+  const boardsDir = path4.join(featuresDir, "boards");
+  const defaultBoardDir = path4.join(boardsDir, "default");
+  try {
+    await fs3.access(boardsDir);
+    return;
+  } catch {
+  }
+  await fs3.mkdir(defaultBoardDir, { recursive: true });
+  let entries;
+  try {
+    entries = await fs3.readdir(featuresDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "boards" || entry.name.startsWith("."))
+      continue;
+    const src = path4.join(featuresDir, entry.name);
+    const dest = path4.join(defaultBoardDir, entry.name);
+    await fs3.rename(src, dest);
+  }
+  const rootMdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md"));
+  if (rootMdFiles.length > 0) {
+    const backlogDir = path4.join(defaultBoardDir, "backlog");
+    await fs3.mkdir(backlogDir, { recursive: true });
+    for (const file of rootMdFiles) {
+      await fs3.rename(
+        path4.join(featuresDir, file.name),
+        path4.join(backlogDir, file.name)
+      );
+    }
+  }
+}
+
+// src/sdk/KanbanSDK.ts
+var KanbanSDK = class {
+  constructor(featuresDir) {
+    this.featuresDir = featuresDir;
+    this._migrated = false;
+  }
+  get workspaceRoot() {
+    return path5.dirname(this.featuresDir);
+  }
+  // --- Board resolution helpers ---
+  _resolveBoardId(boardId) {
+    const config = readConfig(this.workspaceRoot);
+    return boardId || config.defaultBoard;
+  }
+  _boardDir(boardId) {
+    const resolvedId = this._resolveBoardId(boardId);
+    return path5.join(this.featuresDir, "boards", resolvedId);
+  }
+  _isCompletedStatus(status, boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    if (!board || board.columns.length === 0)
+      return status === "done";
+    return board.columns[board.columns.length - 1].id === status;
+  }
+  async _ensureMigrated() {
+    if (this._migrated)
+      return;
+    await migrateFileSystemToMultiBoard(this.featuresDir);
+    this._migrated = true;
+  }
+  async init() {
+    await this._ensureMigrated();
+    const boardDir = this._boardDir();
+    await ensureDirectories(boardDir);
+  }
+  // --- Board management ---
+  listBoards() {
+    const config = readConfig(this.workspaceRoot);
+    return Object.entries(config.boards).map(([id, board]) => ({
+      id,
+      name: board.name,
+      description: board.description
+    }));
+  }
+  createBoard(id, name, options) {
+    const config = readConfig(this.workspaceRoot);
+    if (config.boards[id]) {
+      throw new Error(`Board already exists: ${id}`);
+    }
+    const columns = options?.columns || [...config.boards[config.defaultBoard]?.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" }
+    ]];
+    config.boards[id] = {
+      name,
+      description: options?.description,
+      columns,
+      nextCardId: 1,
+      defaultStatus: options?.defaultStatus || columns[0]?.id || "backlog",
+      defaultPriority: options?.defaultPriority || config.defaultPriority
+    };
+    writeConfig(this.workspaceRoot, config);
+    return { id, name, description: options?.description };
+  }
+  async deleteBoard(boardId) {
+    const config = readConfig(this.workspaceRoot);
+    if (!config.boards[boardId]) {
+      throw new Error(`Board not found: ${boardId}`);
+    }
+    if (config.defaultBoard === boardId) {
+      throw new Error(`Cannot delete the default board: ${boardId}`);
+    }
+    const cards = await this.listCards(void 0, boardId);
+    if (cards.length > 0) {
+      throw new Error(`Cannot delete board "${boardId}": ${cards.length} card(s) still exist`);
+    }
+    const boardDir = this._boardDir(boardId);
+    try {
+      await fs4.rm(boardDir, { recursive: true });
+    } catch {
+    }
+    delete config.boards[boardId];
+    writeConfig(this.workspaceRoot, config);
+  }
+  getBoard(boardId) {
+    return getBoardConfig(this.workspaceRoot, boardId);
+  }
+  updateBoard(boardId, updates) {
+    const config = readConfig(this.workspaceRoot);
+    const board = config.boards[boardId];
+    if (!board) {
+      throw new Error(`Board not found: ${boardId}`);
+    }
+    if (updates.name !== void 0)
+      board.name = updates.name;
+    if (updates.description !== void 0)
+      board.description = updates.description;
+    if (updates.columns !== void 0)
+      board.columns = updates.columns;
+    if (updates.defaultStatus !== void 0)
+      board.defaultStatus = updates.defaultStatus;
+    if (updates.defaultPriority !== void 0)
+      board.defaultPriority = updates.defaultPriority;
+    writeConfig(this.workspaceRoot, config);
+    return board;
+  }
+  async transferCard(cardId, fromBoardId, toBoardId, targetStatus) {
+    const toBoardDir = this._boardDir(toBoardId);
+    const config = readConfig(this.workspaceRoot);
+    if (!config.boards[fromBoardId])
+      throw new Error(`Board not found: ${fromBoardId}`);
+    if (!config.boards[toBoardId])
+      throw new Error(`Board not found: ${toBoardId}`);
+    const card = await this.getCard(cardId, fromBoardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId} in board ${fromBoardId}`);
+    const toBoard = config.boards[toBoardId];
+    const newStatus = targetStatus || toBoard.defaultStatus || toBoard.columns[0]?.id || "backlog";
+    const targetDir = path5.join(toBoardDir, newStatus);
+    await fs4.mkdir(targetDir, { recursive: true });
+    const oldPath = card.filePath;
+    const filename = path5.basename(oldPath);
+    const newPath = path5.join(targetDir, filename);
+    await fs4.rename(oldPath, newPath);
+    card.status = newStatus;
+    card.boardId = toBoardId;
+    card.filePath = newPath;
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    card.completedAt = this._isCompletedStatus(newStatus, toBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    const targetCards = await this.listCards(void 0, toBoardId);
+    const cardsInStatus = targetCards.filter((c) => c.status === newStatus && c.id !== cardId).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;
+    card.order = generateKeyBetween(lastOrder, null);
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  // --- Card CRUD ---
+  async listCards(columns, boardId) {
+    await this._ensureMigrated();
+    const boardDir = this._boardDir(boardId);
+    const resolvedBoardId = this._resolveBoardId(boardId);
+    await ensureDirectories(boardDir);
+    if (columns) {
+      await ensureStatusSubfolders(boardDir, columns);
+    }
+    try {
+      const rootFiles = await this._readMdFiles(boardDir);
+      for (const filePath of rootFiles) {
+        try {
+          const card = await this._loadCard(filePath);
+          if (card) {
+            await moveFeatureFile(filePath, boardDir, card.status, card.attachments);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    const cards = [];
+    let entries;
+    try {
+      entries = await fs4.readdir(boardDir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("."))
+        continue;
+      const subdir = path5.join(boardDir, entry.name);
+      try {
+        const mdFiles = await this._readMdFiles(subdir);
+        for (const filePath of mdFiles) {
+          const card = await this._loadCard(filePath);
+          if (card) {
+            card.boardId = resolvedBoardId;
+            cards.push(card);
+          }
+        }
+      } catch {
+      }
+    }
+    for (const card of cards) {
+      const pathStatus = getStatusFromPath(card.filePath, boardDir);
+      if (pathStatus !== null && pathStatus !== card.status) {
+        try {
+          card.filePath = await moveFeatureFile(card.filePath, boardDir, card.status, card.attachments);
+        } catch {
+        }
+      }
+    }
+    const hasLegacyOrder = cards.some((c) => /^\d+$/.test(c.order));
+    if (hasLegacyOrder) {
+      const byStatus = /* @__PURE__ */ new Map();
+      for (const c of cards) {
+        const list = byStatus.get(c.status) || [];
+        list.push(c);
+        byStatus.set(c.status, list);
+      }
+      for (const columnCards of byStatus.values()) {
+        columnCards.sort((a, b) => parseInt(a.order) - parseInt(b.order));
+        const keys = generateNKeysBetween(null, null, columnCards.length);
+        for (let i = 0; i < columnCards.length; i++) {
+          columnCards[i].order = keys[i];
+          await fs4.writeFile(columnCards[i].filePath, serializeFeature(columnCards[i]), "utf-8");
+        }
+      }
+    }
+    const numericIds = cards.map((c) => parseInt(c.id, 10)).filter((n) => !Number.isNaN(n));
+    if (numericIds.length > 0) {
+      syncCardIdCounter(this.workspaceRoot, resolvedBoardId, numericIds);
+    }
+    return cards.sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+  }
+  async getCard(cardId, boardId) {
+    const cards = await this.listCards(void 0, boardId);
+    return cards.find((c) => c.id === cardId) || null;
+  }
+  async createCard(data) {
+    await this._ensureMigrated();
+    const resolvedBoardId = this._resolveBoardId(data.boardId);
+    const boardDir = this._boardDir(resolvedBoardId);
+    await ensureDirectories(boardDir);
+    const config = readConfig(this.workspaceRoot);
+    const board = config.boards[resolvedBoardId];
+    const status = data.status || board?.defaultStatus || config.defaultStatus || "backlog";
+    const priority = data.priority || board?.defaultPriority || config.defaultPriority || "medium";
+    const title = getTitleFromContent(data.content);
+    const numericId = allocateCardId(this.workspaceRoot, resolvedBoardId);
+    const filename = generateFeatureFilename(numericId, title);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const cards = await this.listCards(void 0, resolvedBoardId);
+    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),
+      boardId: resolvedBoardId,
+      status,
+      priority,
+      assignee: data.assignee ?? null,
+      dueDate: data.dueDate ?? null,
+      created: now,
+      modified: now,
+      completedAt: this._isCompletedStatus(status, resolvedBoardId) ? now : null,
+      labels: data.labels || [],
+      attachments: data.attachments || [],
+      comments: [],
+      order: generateKeyBetween(lastOrder, null),
+      content: data.content,
+      filePath: getFeatureFilePath(boardDir, status, filename)
+    };
+    await fs4.mkdir(path5.dirname(card.filePath), { recursive: true });
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async updateCard(cardId, updates, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const resolvedBoardId = card.boardId || this._resolveBoardId(boardId);
+    const boardDir = this._boardDir(resolvedBoardId);
+    const oldStatus = card.status;
+    const oldTitle = getTitleFromContent(card.content);
+    const { filePath: _fp, id: _id, boardId: _bid, ...safeUpdates } = updates;
+    Object.assign(card, safeUpdates);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    if (oldStatus !== card.status) {
+      card.completedAt = this._isCompletedStatus(card.status, resolvedBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    }
+    await fs4.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, boardDir, card.status, card.attachments);
+      card.filePath = newPath;
+    }
+    return card;
+  }
+  async moveCard(cardId, newStatus, position, boardId) {
+    const cards = await this.listCards(void 0, boardId);
+    const card = cards.find((c) => c.id === cardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const resolvedBoardId = card.boardId || this._resolveBoardId(boardId);
+    const boardDir = this._boardDir(resolvedBoardId);
+    const oldStatus = card.status;
+    card.status = newStatus;
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    if (oldStatus !== newStatus) {
+      card.completedAt = this._isCompletedStatus(newStatus, resolvedBoardId) ? (/* @__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 fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    if (oldStatus !== newStatus) {
+      const newPath = await moveFeatureFile(card.filePath, boardDir, newStatus, card.attachments);
+      card.filePath = newPath;
+    }
+    return card;
+  }
+  async deleteCard(cardId, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    await fs4.unlink(card.filePath);
+  }
+  async getCardsByStatus(status, boardId) {
+    const cards = await this.listCards(void 0, boardId);
+    return cards.filter((c) => c.status === status);
+  }
+  async getUniqueAssignees(boardId) {
+    const cards = await this.listCards(void 0, boardId);
+    const assignees = /* @__PURE__ */ new Set();
+    for (const c of cards) {
+      if (c.assignee)
+        assignees.add(c.assignee);
+    }
+    return [...assignees].sort();
+  }
+  async getUniqueLabels(boardId) {
+    const cards = await this.listCards(void 0, boardId);
+    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, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const fileName = path5.basename(sourcePath);
+    const cardDir = path5.dirname(card.filePath);
+    const destPath = path5.join(cardDir, fileName);
+    const sourceDir = path5.dirname(path5.resolve(sourcePath));
+    if (sourceDir !== cardDir) {
+      await fs4.copyFile(path5.resolve(sourcePath), destPath);
+    }
+    if (!card.attachments.includes(fileName)) {
+      card.attachments.push(fileName);
+    }
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async removeAttachment(cardId, attachment, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    card.attachments = card.attachments.filter((a) => a !== attachment);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async listAttachments(cardId, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    return card.attachments;
+  }
+  // --- Comment management ---
+  async listComments(cardId, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    return card.comments || [];
+  }
+  async addComment(cardId, author, content, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    if (!card.comments)
+      card.comments = [];
+    const maxId = card.comments.reduce((max, c) => {
+      const num = parseInt(c.id.replace("c", ""), 10);
+      return Number.isNaN(num) ? max : Math.max(max, num);
+    }, 0);
+    const comment = {
+      id: `c${maxId + 1}`,
+      author,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      content
+    };
+    card.comments.push(comment);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async updateComment(cardId, commentId, content, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    const comment = (card.comments || []).find((c) => c.id === commentId);
+    if (!comment)
+      throw new Error(`Comment not found: ${commentId}`);
+    comment.content = content;
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  async deleteComment(cardId, commentId, boardId) {
+    const card = await this.getCard(cardId, boardId);
+    if (!card)
+      throw new Error(`Card not found: ${cardId}`);
+    card.comments = (card.comments || []).filter((c) => c.id !== commentId);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+    return card;
+  }
+  // --- Column management (board-scoped) ---
+  listColumns(boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    return board?.columns || [];
+  }
+  addColumn(column, boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    if (!board)
+      throw new Error(`Board not found: ${resolvedId}`);
+    if (board.columns.some((c) => c.id === column.id)) {
+      throw new Error(`Column already exists: ${column.id}`);
+    }
+    board.columns.push(column);
+    writeConfig(this.workspaceRoot, config);
+    return board.columns;
+  }
+  updateColumn(columnId, updates, boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    if (!board)
+      throw new Error(`Board not found: ${resolvedId}`);
+    const col = board.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;
+    writeConfig(this.workspaceRoot, config);
+    return board.columns;
+  }
+  async removeColumn(columnId, boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    if (!board)
+      throw new Error(`Board not found: ${resolvedId}`);
+    const idx = board.columns.findIndex((c) => c.id === columnId);
+    if (idx === -1)
+      throw new Error(`Column not found: ${columnId}`);
+    const cards = await this.listCards(void 0, resolvedId);
+    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`);
+    }
+    board.columns.splice(idx, 1);
+    writeConfig(this.workspaceRoot, config);
+    return board.columns;
+  }
+  reorderColumns(columnIds, boardId) {
+    const config = readConfig(this.workspaceRoot);
+    const resolvedId = boardId || config.defaultBoard;
+    const board = config.boards[resolvedId];
+    if (!board)
+      throw new Error(`Board not found: ${resolvedId}`);
+    const colMap = new Map(board.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 !== board.columns.length) {
+      throw new Error("Must include all column IDs when reordering");
+    }
+    board.columns = columnIds.map((id) => colMap.get(id));
+    writeConfig(this.workspaceRoot, config);
+    return board.columns;
+  }
+  // --- Settings management (global) ---
+  getSettings() {
+    return configToSettings(readConfig(this.workspaceRoot));
+  }
+  updateSettings(settings) {
+    const config = readConfig(this.workspaceRoot);
+    writeConfig(this.workspaceRoot, settingsToConfig(config, settings));
+  }
+  // --- Private helpers ---
+  async _readMdFiles(dir) {
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path5.join(dir, e.name));
+  }
+  async _loadCard(filePath) {
+    const content = await fs4.readFile(filePath, "utf-8");
+    return parseFeatureFile(content, filePath);
+  }
+};
+export {
+  DEFAULT_COLUMNS,
+  KanbanSDK,
+  configToSettings,
+  ensureDirectories,
+  ensureStatusSubfolders,
+  generateFeatureFilename,
+  getBoardConfig,
+  getDefaultBoardId,
+  getFeatureFilePath,
+  getStatusFromPath,
+  getTitleFromContent,
+  migrateFileSystemToMultiBoard,
+  moveFeatureFile,
+  parseFeatureFile,
+  readConfig,
+  renameFeatureFile,
+  serializeFeature,
+  settingsToConfig,
+  writeConfig
+};