clawvault 3.1.0 → 3.2.0

package/dist/commands/kanban.cjs

@@ -1,884 +0,0 @@
-"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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/commands/kanban.ts
-var kanban_exports = {};
-__export(kanban_exports, {
-  buildKanbanLanes: () => buildKanbanLanes,
-  extractCardSlug: () => extractCardSlug,
-  formatKanbanCard: () => formatKanbanCard,
-  generateKanbanMarkdown: () => generateKanbanMarkdown,
-  importKanbanBoard: () => importKanbanBoard,
-  kanbanCommand: () => kanbanCommand,
-  parseKanbanMarkdown: () => parseKanbanMarkdown,
-  syncKanbanBoard: () => syncKanbanBoard
-});
-module.exports = __toCommonJS(kanban_exports);
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_gray_matter3 = __toESM(require("gray-matter"), 1);
-
-// src/lib/task-utils.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-
-// src/lib/transition-ledger.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var REGRESSION_PAIRS = [
-  ["done", "open"],
-  ["done", "blocked"],
-  ["in-progress", "blocked"]
-];
-function isRegression(from, to) {
-  return REGRESSION_PAIRS.some(([f, t]) => f === from && t === to);
-}
-function getLedgerDir(vaultPath) {
-  return path.join(path.resolve(vaultPath), "ledger", "transitions");
-}
-function getTodayLedgerPath(vaultPath) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return path.join(getLedgerDir(vaultPath), `${date}.jsonl`);
-}
-var RETRYABLE_APPEND_CODES = /* @__PURE__ */ new Set(["ENOENT", "EAGAIN", "EBUSY"]);
-var MAX_APPEND_RETRIES = 2;
-function asErrno(error) {
-  if (!error || typeof error !== "object") {
-    return null;
-  }
-  return error;
-}
-function formatLedgerWriteError(filePath, error) {
-  const errno = asErrno(error);
-  const message = error instanceof Error ? error.message : String(error);
-  if (errno?.code === "ENOSPC") {
-    return new Error(`Failed to write transition ledger at ${filePath}: no space left on device.`);
-  }
-  if (errno?.code === "EACCES" || errno?.code === "EPERM") {
-    return new Error(`Failed to write transition ledger at ${filePath}: permission denied.`);
-  }
-  return new Error(`Failed to write transition ledger at ${filePath}: ${message}`);
-}
-function appendTransition(vaultPath, event) {
-  const ledgerDir = getLedgerDir(vaultPath);
-  try {
-    fs.mkdirSync(ledgerDir, { recursive: true });
-  } catch (error) {
-    throw formatLedgerWriteError(ledgerDir, error);
-  }
-  const filePath = getTodayLedgerPath(vaultPath);
-  const payload = JSON.stringify(event) + "\n";
-  for (let attempt = 0; attempt <= MAX_APPEND_RETRIES; attempt += 1) {
-    try {
-      fs.appendFileSync(filePath, payload);
-      return;
-    } catch (error) {
-      const errno = asErrno(error);
-      const code = errno?.code;
-      if (code === "ENOENT") {
-        try {
-          fs.mkdirSync(ledgerDir, { recursive: true });
-        } catch (mkdirError) {
-          throw formatLedgerWriteError(filePath, mkdirError);
-        }
-      }
-      if (code && RETRYABLE_APPEND_CODES.has(code) && attempt < MAX_APPEND_RETRIES) {
-        continue;
-      }
-      throw formatLedgerWriteError(filePath, error);
-    }
-  }
-}
-function buildTransitionEvent(taskId, fromStatus, toStatus, options = {}) {
-  const agentId = process.env.OPENCLAW_AGENT_ID || "manual";
-  const costTokensRaw = process.env.OPENCLAW_TOKEN_ESTIMATE;
-  const costTokens = costTokensRaw ? parseInt(costTokensRaw, 10) : null;
-  return {
-    task_id: taskId,
-    agent_id: agentId,
-    from_status: fromStatus,
-    to_status: toStatus,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    confidence: options.confidence ?? (agentId === "manual" ? 1 : 1),
-    cost_tokens: costTokens !== null && !isNaN(costTokens) ? costTokens : null,
-    reason: options.reason || null
-  };
-}
-function readAllTransitions(vaultPath) {
-  const ledgerDir = getLedgerDir(vaultPath);
-  if (!fs.existsSync(ledgerDir)) return [];
-  let files = [];
-  try {
-    files = fs.readdirSync(ledgerDir).filter((f) => f.endsWith(".jsonl")).sort();
-  } catch {
-    return [];
-  }
-  const events = [];
-  for (const file of files) {
-    let lines = [];
-    try {
-      lines = fs.readFileSync(path.join(ledgerDir, file), "utf-8").split("\n").filter((l) => l.trim());
-    } catch {
-      continue;
-    }
-    for (const line of lines) {
-      try {
-        events.push(JSON.parse(line));
-      } catch {
-      }
-    }
-  }
-  return events;
-}
-function countBlockedTransitions(vaultPath, taskId) {
-  const events = readAllTransitions(vaultPath);
-  return events.filter((e) => e.task_id === taskId && e.to_status === "blocked").length;
-}
-
-// src/lib/primitive-templates.ts
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-
-// src/lib/task-utils.ts
-function getTasksDir(vaultPath) {
-  return path2.join(path2.resolve(vaultPath), "tasks");
-}
-function getTaskPath(vaultPath, slug) {
-  return path2.join(getTasksDir(vaultPath), `${slug}.md`);
-}
-function extractTitle(content) {
-  const match = content.match(/^#\s+(.+)$/m);
-  return match ? match[1].trim() : "";
-}
-function parseDueDate(value) {
-  if (!value) return null;
-  const timestamp = Date.parse(value);
-  if (Number.isNaN(timestamp)) return null;
-  return timestamp;
-}
-function startOfToday() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
-}
-var VALID_TASK_STATUSES = /* @__PURE__ */ new Set([
-  "open",
-  "in-progress",
-  "blocked",
-  "done"
-]);
-function isTaskStatus(value) {
-  return typeof value === "string" && VALID_TASK_STATUSES.has(value);
-}
-function persistTaskFrontmatter(task, frontmatter) {
-  fs2.writeFileSync(task.path, import_gray_matter2.default.stringify(task.content, frontmatter));
-}
-function resolveStatusTransition(previousStatus, nextStatus) {
-  if (!isTaskStatus(previousStatus) || !isTaskStatus(nextStatus)) {
-    return null;
-  }
-  if (previousStatus === nextStatus) {
-    return null;
-  }
-  return { fromStatus: previousStatus, toStatus: nextStatus };
-}
-function logStatusTransition({
-  vaultPath,
-  task,
-  fromStatus,
-  toStatus,
-  frontmatter,
-  options
-}) {
-  const normalizedReason = typeof options.reason === "string" ? options.reason.trim() : "";
-  const reason = normalizedReason || (isRegression(fromStatus, toStatus) ? `regression: ${fromStatus} -> ${toStatus}` : void 0);
-  const event = buildTransitionEvent(task.slug, fromStatus, toStatus, {
-    confidence: options.confidence,
-    reason
-  });
-  try {
-    appendTransition(vaultPath, event);
-  } catch {
-    return frontmatter;
-  }
-  if (toStatus !== "blocked" || frontmatter.escalation) {
-    return frontmatter;
-  }
-  let blockedCount = 0;
-  try {
-    blockedCount = countBlockedTransitions(vaultPath, task.slug);
-  } catch {
-    return frontmatter;
-  }
-  if (blockedCount < 3) {
-    return frontmatter;
-  }
-  const escalatedFrontmatter = {
-    ...frontmatter,
-    escalation: true
-  };
-  try {
-    persistTaskFrontmatter(task, escalatedFrontmatter);
-    return escalatedFrontmatter;
-  } catch {
-    return frontmatter;
-  }
-}
-function readTask(vaultPath, slug) {
-  const taskPath = getTaskPath(vaultPath, slug);
-  if (!fs2.existsSync(taskPath)) {
-    return null;
-  }
-  try {
-    const raw = fs2.readFileSync(taskPath, "utf-8");
-    const { data, content } = (0, import_gray_matter2.default)(raw);
-    const title = extractTitle(content) || slug;
-    return {
-      slug,
-      title,
-      content,
-      frontmatter: data,
-      path: taskPath
-    };
-  } catch {
-    return null;
-  }
-}
-function listTasks(vaultPath, filters) {
-  const tasksDir = getTasksDir(vaultPath);
-  if (!fs2.existsSync(tasksDir)) {
-    return [];
-  }
-  const tasks = [];
-  const entries = fs2.readdirSync(tasksDir, { withFileTypes: true });
-  const today = startOfToday();
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      continue;
-    }
-    const slug = entry.name.replace(/\.md$/, "");
-    const task = readTask(vaultPath, slug);
-    if (!task) continue;
-    if (filters) {
-      if (filters.status && task.frontmatter.status !== filters.status) continue;
-      if (filters.owner && task.frontmatter.owner !== filters.owner) continue;
-      if (filters.project && task.frontmatter.project !== filters.project) continue;
-      if (filters.priority && task.frontmatter.priority !== filters.priority) continue;
-      if (filters.due && !task.frontmatter.due) continue;
-      if (filters.tag) {
-        const tags = task.frontmatter.tags || [];
-        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
-        if (!hasTag) continue;
-      }
-      if (filters.overdue) {
-        const dueTime = parseDueDate(task.frontmatter.due);
-        if (task.frontmatter.status === "done" || dueTime === null || dueTime >= today) continue;
-      }
-    }
-    tasks.push(task);
-  }
-  const priorityOrder = {
-    critical: 0,
-    high: 1,
-    medium: 2,
-    low: 3
-  };
-  if (filters?.due || filters?.overdue) {
-    return tasks.sort((a, b) => {
-      const aDue = parseDueDate(a.frontmatter.due);
-      const bDue = parseDueDate(b.frontmatter.due);
-      if (aDue !== null && bDue !== null && aDue !== bDue) {
-        return aDue - bDue;
-      }
-      if (aDue !== null && bDue === null) return -1;
-      if (aDue === null && bDue !== null) return 1;
-      return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
-    });
-  }
-  return tasks.sort((a, b) => {
-    const aPriority = priorityOrder[a.frontmatter.priority || "low"];
-    const bPriority = priorityOrder[b.frontmatter.priority || "low"];
-    if (aPriority !== bPriority) {
-      return aPriority - bPriority;
-    }
-    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
-  });
-}
-function updateTask(vaultPath, slug, updates, options = {}) {
-  const task = readTask(vaultPath, slug);
-  if (!task) {
-    throw new Error(`Task not found: ${slug}`);
-  }
-  if (updates.status !== void 0 && !isTaskStatus(updates.status)) {
-    throw new Error(`Invalid task status: ${String(updates.status)}`);
-  }
-  const previousStatus = task.frontmatter.status;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let newFrontmatter = {
-    ...task.frontmatter,
-    updated: now
-  };
-  if (updates.status !== void 0) {
-    newFrontmatter.status = updates.status;
-    if (updates.status === "done" && !newFrontmatter.completed) {
-      newFrontmatter.completed = now;
-    }
-    if (updates.status !== "done") {
-      delete newFrontmatter.completed;
-    }
-  }
-  if (updates.source !== void 0) {
-    if (updates.source === null || updates.source.trim() === "") {
-      delete newFrontmatter.source;
-    } else {
-      newFrontmatter.source = updates.source;
-    }
-  }
-  if (updates.owner !== void 0) {
-    if (updates.owner === null || updates.owner.trim() === "") {
-      delete newFrontmatter.owner;
-    } else {
-      newFrontmatter.owner = updates.owner;
-    }
-  }
-  if (updates.project !== void 0) {
-    if (updates.project === null || updates.project.trim() === "") {
-      delete newFrontmatter.project;
-    } else {
-      newFrontmatter.project = updates.project;
-    }
-  }
-  if (updates.priority !== void 0) {
-    if (updates.priority === null) {
-      delete newFrontmatter.priority;
-    } else {
-      newFrontmatter.priority = updates.priority;
-    }
-  }
-  if (updates.due !== void 0) {
-    if (updates.due === null || updates.due.trim() === "") {
-      delete newFrontmatter.due;
-    } else {
-      newFrontmatter.due = updates.due;
-    }
-  }
-  if (updates.tags !== void 0) {
-    if (updates.tags === null) {
-      delete newFrontmatter.tags;
-    } else {
-      const normalizedTags = updates.tags.map((tag) => tag.trim()).filter(Boolean);
-      if (normalizedTags.length === 0) {
-        delete newFrontmatter.tags;
-      } else {
-        newFrontmatter.tags = normalizedTags;
-      }
-    }
-  }
-  if (updates.completed !== void 0) {
-    if (updates.completed === null || updates.completed.trim() === "") {
-      delete newFrontmatter.completed;
-    } else {
-      newFrontmatter.completed = updates.completed;
-    }
-  }
-  if (updates.escalation !== void 0) {
-    if (updates.escalation === null) {
-      delete newFrontmatter.escalation;
-    } else {
-      newFrontmatter.escalation = updates.escalation;
-    }
-  }
-  if (updates.confidence !== void 0) {
-    if (updates.confidence === null) {
-      delete newFrontmatter.confidence;
-    } else {
-      newFrontmatter.confidence = updates.confidence;
-    }
-  }
-  if (updates.reason !== void 0) {
-    if (updates.reason === null || updates.reason.trim() === "") {
-      delete newFrontmatter.reason;
-    } else {
-      newFrontmatter.reason = updates.reason;
-    }
-  }
-  if (updates.description !== void 0) {
-    if (updates.description === null || updates.description.trim() === "") {
-      delete newFrontmatter.description;
-    } else {
-      newFrontmatter.description = updates.description;
-    }
-  }
-  if (updates.estimate !== void 0) {
-    if (updates.estimate === null || updates.estimate.trim() === "") {
-      delete newFrontmatter.estimate;
-    } else {
-      newFrontmatter.estimate = updates.estimate;
-    }
-  }
-  if (updates.parent !== void 0) {
-    if (updates.parent === null || updates.parent.trim() === "") {
-      delete newFrontmatter.parent;
-    } else {
-      newFrontmatter.parent = updates.parent;
-    }
-  }
-  if (updates.depends_on !== void 0) {
-    if (updates.depends_on === null) {
-      delete newFrontmatter.depends_on;
-    } else {
-      const normalizedDeps = updates.depends_on.map((dep) => dep.trim()).filter(Boolean);
-      if (normalizedDeps.length === 0) {
-        delete newFrontmatter.depends_on;
-      } else {
-        newFrontmatter.depends_on = normalizedDeps;
-      }
-    }
-  }
-  if (updates.blocked_by !== void 0) {
-    if (updates.blocked_by === null || updates.blocked_by.trim() === "") {
-      delete newFrontmatter.blocked_by;
-    } else {
-      newFrontmatter.blocked_by = updates.blocked_by;
-    }
-  } else if (updates.status !== void 0 && updates.status !== "blocked") {
-    delete newFrontmatter.blocked_by;
-  }
-  persistTaskFrontmatter(task, newFrontmatter);
-  const transition = options.skipTransition ? null : resolveStatusTransition(previousStatus, newFrontmatter.status);
-  if (transition) {
-    const confidence = options.confidence ?? (typeof updates.confidence === "number" ? updates.confidence : void 0);
-    const reason = options.reason ?? updates.reason ?? null;
-    newFrontmatter = logStatusTransition({
-      vaultPath,
-      task,
-      fromStatus: transition.fromStatus,
-      toStatus: transition.toStatus,
-      frontmatter: newFrontmatter,
-      options: {
-        confidence,
-        reason
-      }
-    });
-  }
-  return {
-    ...task,
-    frontmatter: newFrontmatter
-  };
-}
-
-// src/commands/kanban.ts
-var STATUS_LANES = [
-  { status: "open", name: "Open" },
-  { status: "in-progress", name: "In Progress" },
-  { status: "blocked", name: "Blocked" },
-  { status: "done", name: "Done" }
-];
-var PRIORITY_LANES = [
-  { priority: "critical", name: "\u{1F525} Critical" },
-  { priority: "high", name: "\u{1F534} High" },
-  { priority: "medium", name: "\u{1F7E1} Medium" },
-  { priority: "low", name: "\u{1F7E2} Low" },
-  { priority: null, name: "\u26AA Unset" }
-];
-var PRIORITY_EMOJI = {
-  critical: "\u{1F525}",
-  high: "\u{1F534}",
-  medium: "\u{1F7E1}",
-  low: "\u{1F7E2}"
-};
-function normalizeGroupBy(value) {
-  const normalized = String(value || "status").trim().toLowerCase();
-  if (normalized === "status" || normalized === "priority" || normalized === "project" || normalized === "owner") {
-    return normalized;
-  }
-  throw new Error(`Unsupported kanban group field: ${normalized}`);
-}
-function resolveBoardPath(vaultPath, output) {
-  const resolvedVaultPath = path3.resolve(vaultPath);
-  if (!output) {
-    return path3.join(resolvedVaultPath, "Board.md");
-  }
-  if (path3.isAbsolute(output)) {
-    return output;
-  }
-  return path3.join(resolvedVaultPath, output);
-}
-function toHashTag(value) {
-  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9/_-]/g, "");
-}
-function toMention(value) {
-  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9._-]/g, "");
-}
-function dateOnly(value) {
-  return value.includes("T") ? value.split("T")[0] : value;
-}
-function dueTimestamp(task) {
-  if (!task.frontmatter.due) return Number.POSITIVE_INFINITY;
-  const timestamp = Date.parse(task.frontmatter.due);
-  return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
-}
-function sortTasksForCards(tasks) {
-  return [...tasks].sort((left, right) => {
-    const dueDiff = dueTimestamp(left) - dueTimestamp(right);
-    if (dueDiff !== 0) return dueDiff;
-    return new Date(right.frontmatter.created).getTime() - new Date(left.frontmatter.created).getTime();
-  });
-}
-function statusLaneName(status) {
-  const lane = STATUS_LANES.find((entry) => entry.status === status);
-  return lane ? lane.name : "Open";
-}
-function priorityLaneName(priority) {
-  const lane = PRIORITY_LANES.find((entry) => entry.priority === (priority ?? null));
-  return lane ? lane.name : "\u26AA Unset";
-}
-function laneNameForTask(task, groupBy) {
-  switch (groupBy) {
-    case "status":
-      return statusLaneName(task.frontmatter.status);
-    case "priority":
-      return priorityLaneName(task.frontmatter.priority);
-    case "project":
-      return task.frontmatter.project?.trim() || "No Project";
-    case "owner":
-      return task.frontmatter.owner?.trim() || "Unassigned";
-    default:
-      return statusLaneName(task.frontmatter.status);
-  }
-}
-function defaultLaneOrder(groupBy, tasks) {
-  if (groupBy === "status") {
-    return STATUS_LANES.map((entry) => entry.name);
-  }
-  if (groupBy === "priority") {
-    return PRIORITY_LANES.map((entry) => entry.name);
-  }
-  const fallback = groupBy === "project" ? "No Project" : "Unassigned";
-  const values = /* @__PURE__ */ new Set();
-  for (const task of tasks) {
-    values.add(laneNameForTask(task, groupBy));
-  }
-  if (values.size === 0) {
-    return [fallback];
-  }
-  const sorted = Array.from(values).sort((left, right) => left.localeCompare(right));
-  if (sorted.includes(fallback)) {
-    return [...sorted.filter((value) => value !== fallback), fallback];
-  }
-  return sorted;
-}
-function formatKanbanCard(task) {
-  const checkbox = task.frontmatter.status === "done" ? "x" : " ";
-  const parts = [];
-  if (task.frontmatter.priority) {
-    parts.push(PRIORITY_EMOJI[task.frontmatter.priority]);
-  }
-  parts.push(`[[${task.slug}|${task.title}]]`);
-  if (task.frontmatter.project) {
-    const projectTag = toHashTag(task.frontmatter.project);
-    if (projectTag) parts.push(`#${projectTag}`);
-  }
-  if (task.frontmatter.owner) {
-    const mention = toMention(task.frontmatter.owner);
-    if (mention) parts.push(`@${mention}`);
-  }
-  if (task.frontmatter.tags && task.frontmatter.tags.length > 0) {
-    for (const tag of task.frontmatter.tags) {
-      const normalizedTag = toHashTag(tag);
-      if (normalizedTag) parts.push(`#${normalizedTag}`);
-    }
-  }
-  if (task.frontmatter.due) {
-    parts.push(`\u{1F4C5} ${dateOnly(task.frontmatter.due)}`);
-  }
-  if (task.frontmatter.status === "blocked" || task.frontmatter.blocked_by) {
-    parts.push("\u26D4");
-  }
-  return `- [${checkbox}] ${parts.join(" ")}`;
-}
-function buildKanbanLanes(tasks, groupBy) {
-  const laneOrder = defaultLaneOrder(groupBy, tasks);
-  const lanes = /* @__PURE__ */ new Map();
-  for (const laneName of laneOrder) {
-    lanes.set(laneName, []);
-  }
-  for (const task of sortTasksForCards(tasks)) {
-    const laneName = laneNameForTask(task, groupBy);
-    if (!lanes.has(laneName)) {
-      lanes.set(laneName, []);
-    }
-    lanes.get(laneName)?.push(formatKanbanCard(task));
-  }
-  return Array.from(lanes.entries()).map(([name, cards]) => ({ name, cards }));
-}
-function generateKanbanMarkdown(tasks, options = {}) {
-  const groupBy = normalizeGroupBy(options.groupBy);
-  const syncedAt = (options.now || /* @__PURE__ */ new Date()).toISOString();
-  const lanes = buildKanbanLanes(tasks, groupBy);
-  const sections = lanes.map((lane) => {
-    const cardsBlock = lane.cards.length > 0 ? lane.cards.join("\n") : "";
-    return `## ${lane.name}
-
-${cardsBlock}`.trimEnd();
-  }).join("\n\n");
-  return [
-    "---",
-    "kanban-plugin: basic",
-    `clawvault-group-by: ${groupBy}`,
-    `clawvault-last-sync: '${syncedAt}'`,
-    "---",
-    "",
-    sections,
-    "",
-    "%% kanban:settings",
-    '{"kanban-plugin":"basic","list-collapse":["Done"],"show-checkboxes":true}',
-    "%%",
-    ""
-  ].join("\n");
-}
-function syncKanbanBoard(vaultPath, options = {}) {
-  const groupBy = normalizeGroupBy(options.groupBy);
-  const outputPath = resolveBoardPath(vaultPath, options.output);
-  let tasks = listTasks(vaultPath);
-  if (options.filterProject) {
-    tasks = tasks.filter((task) => task.frontmatter.project === options.filterProject);
-  }
-  if (options.filterOwner) {
-    tasks = tasks.filter((task) => task.frontmatter.owner === options.filterOwner);
-  }
-  if (!options.includeDone) {
-    tasks = tasks.filter((task) => task.frontmatter.status !== "done");
-  }
-  const markdown = generateKanbanMarkdown(tasks, {
-    groupBy,
-    now: options.now
-  });
-  fs3.writeFileSync(outputPath, markdown);
-  return {
-    outputPath,
-    groupBy,
-    markdown,
-    lanes: buildKanbanLanes(tasks, groupBy),
-    taskCount: tasks.length
-  };
-}
-function normalizeLaneKey(laneName) {
-  return laneName.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim();
-}
-function statusFromLaneName(laneName) {
-  const key = normalizeLaneKey(laneName);
-  if (key.includes("in progress") || key.includes("in-progress") || key === "active") return "in-progress";
-  if (key.includes("blocked")) return "blocked";
-  if (key.includes("done") || key.includes("complete")) return "done";
-  if (key.includes("open")) return "open";
-  return null;
-}
-function priorityFromLaneName(laneName) {
-  const key = normalizeLaneKey(laneName);
-  if (key.includes("critical")) return "critical";
-  if (key.includes("high")) return "high";
-  if (key.includes("medium")) return "medium";
-  if (key.includes("low")) return "low";
-  if (key.includes("unset") || key.includes("none") || key.includes("no priority")) return null;
-  return void 0;
-}
-function isProjectFallbackLane(laneName) {
-  const key = normalizeLaneKey(laneName);
-  return key === "no project" || key === "none";
-}
-function isOwnerFallbackLane(laneName) {
-  const key = normalizeLaneKey(laneName);
-  return key === "unassigned" || key === "none";
-}
-function extractCardSlug(line) {
-  const wikiMatch = line.match(/\[\[([^\]]+)\]\]/);
-  if (!wikiMatch) return null;
-  let target = wikiMatch[1].split("|")[0].trim();
-  if (!target) return null;
-  target = target.split("#")[0].trim();
-  const filePart = target.split("/").pop() || target;
-  const slug = filePart.replace(/\.md$/i, "").trim();
-  return slug || null;
-}
-function parseKanbanMarkdown(markdown) {
-  const parsed = (0, import_gray_matter3.default)(markdown);
-  const groupBy = normalizeGroupBy(
-    typeof parsed.data["clawvault-group-by"] === "string" ? parsed.data["clawvault-group-by"] : void 0
-  );
-  const lanes = [];
-  const laneByName = /* @__PURE__ */ new Map();
-  let currentLane = null;
-  const lines = parsed.content.split(/\r?\n/);
-  for (const line of lines) {
-    const headerMatch = line.match(/^##\s+(.+?)\s*$/);
-    if (headerMatch) {
-      const laneName = headerMatch[1].trim();
-      if (!laneByName.has(laneName)) {
-        const lane = { name: laneName, slugs: [] };
-        laneByName.set(laneName, lane);
-        lanes.push(lane);
-      }
-      currentLane = laneByName.get(laneName) || null;
-      continue;
-    }
-    if (!currentLane || !/^\s*-\s*\[[ xX]\]\s+/.test(line)) {
-      continue;
-    }
-    const slug = extractCardSlug(line);
-    if (slug) {
-      currentLane.slugs.push(slug);
-    }
-  }
-  return { groupBy, lanes };
-}
-function hasUpdates(updates) {
-  return Object.keys(updates).length > 0;
-}
-function importKanbanBoard(vaultPath, options = {}) {
-  const outputPath = resolveBoardPath(vaultPath, options.output);
-  if (!fs3.existsSync(outputPath)) {
-    throw new Error(`Kanban board not found: ${outputPath}`);
-  }
-  const markdown = fs3.readFileSync(outputPath, "utf-8");
-  const parsed = parseKanbanMarkdown(markdown);
-  const changes = [];
-  const missingSlugs = [];
-  const seenSlugs = /* @__PURE__ */ new Set();
-  for (const lane of parsed.lanes) {
-    for (const slug of lane.slugs) {
-      if (seenSlugs.has(slug)) continue;
-      seenSlugs.add(slug);
-      const task = readTask(vaultPath, slug);
-      if (!task) {
-        missingSlugs.push(slug);
-        continue;
-      }
-      const updates = {};
-      if (parsed.groupBy === "status") {
-        const desiredStatus = statusFromLaneName(lane.name);
-        if (desiredStatus && task.frontmatter.status !== desiredStatus) {
-          updates.status = desiredStatus;
-          changes.push({
-            slug,
-            field: "status",
-            from: task.frontmatter.status,
-            to: desiredStatus
-          });
-        }
-      } else if (parsed.groupBy === "priority") {
-        const desiredPriority = priorityFromLaneName(lane.name);
-        if (desiredPriority !== void 0) {
-          const currentPriority = task.frontmatter.priority ?? null;
-          if (currentPriority !== desiredPriority) {
-            updates.priority = desiredPriority;
-            changes.push({
-              slug,
-              field: "priority",
-              from: currentPriority,
-              to: desiredPriority
-            });
-          }
-        }
-      } else if (parsed.groupBy === "project") {
-        const desiredProject = isProjectFallbackLane(lane.name) ? null : lane.name.trim();
-        const currentProject = task.frontmatter.project ?? null;
-        if (currentProject !== desiredProject) {
-          updates.project = desiredProject;
-          changes.push({
-            slug,
-            field: "project",
-            from: currentProject,
-            to: desiredProject
-          });
-        }
-      } else if (parsed.groupBy === "owner") {
-        const desiredOwner = isOwnerFallbackLane(lane.name) ? null : lane.name.trim();
-        const currentOwner = task.frontmatter.owner ?? null;
-        if (currentOwner !== desiredOwner) {
-          updates.owner = desiredOwner;
-          changes.push({
-            slug,
-            field: "owner",
-            from: currentOwner,
-            to: desiredOwner
-          });
-        }
-      }
-      if (hasUpdates(updates)) {
-        updateTask(vaultPath, slug, updates);
-      }
-    }
-  }
-  return {
-    outputPath,
-    groupBy: parsed.groupBy,
-    changes,
-    missingSlugs
-  };
-}
-async function kanbanCommand(vaultPath, action, options = {}) {
-  if (action === "sync") {
-    const result = syncKanbanBoard(vaultPath, options);
-    console.log(`\u2713 Synced kanban board: ${result.outputPath}`);
-    console.log(`  Grouped by: ${result.groupBy}`);
-    console.log(`  Tasks included: ${result.taskCount}`);
-    return;
-  }
-  if (action === "import") {
-    const result = importKanbanBoard(vaultPath, options);
-    console.log(`\u2713 Imported kanban board: ${result.outputPath}`);
-    console.log(`  Grouped by: ${result.groupBy}`);
-    if (result.changes.length === 0) {
-      console.log("  No task updates required.");
-    } else {
-      console.log(`  Updated ${result.changes.length} task field(s):`);
-      for (const change of result.changes) {
-        const from = change.from ?? "(unset)";
-        const to = change.to ?? "(unset)";
-        console.log(`  - ${change.slug}: ${change.field} ${from} -> ${to}`);
-      }
-    }
-    if (result.missingSlugs.length > 0) {
-      console.log(`  Missing tasks (${result.missingSlugs.length}): ${result.missingSlugs.join(", ")}`);
-    }
-    return;
-  }
-  throw new Error(`Unknown kanban action: ${action}`);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildKanbanLanes,
-  extractCardSlug,
-  formatKanbanCard,
-  generateKanbanMarkdown,
-  importKanbanBoard,
-  kanbanCommand,
-  parseKanbanMarkdown,
-  syncKanbanBoard
-});