clawvault 2.6.0 → 3.0.0

package/dist/commands/backlog.cjs

@@ -0,0 +1,721 @@
+"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/backlog.ts
+var backlog_exports = {};
+__export(backlog_exports, {
+  backlogAdd: () => backlogAdd,
+  backlogCommand: () => backlogCommand,
+  backlogList: () => backlogList,
+  backlogPromote: () => backlogPromote,
+  formatBacklogDetails: () => formatBacklogDetails,
+  formatBacklogList: () => formatBacklogList
+});
+module.exports = __toCommonJS(backlog_exports);
+
+// 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/primitive-templates.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/lib/template-engine.ts
+function buildTemplateVariables(input = {}, now = /* @__PURE__ */ new Date()) {
+  const datetime = input.datetime ?? now.toISOString();
+  const date = input.date ?? datetime.split("T")[0];
+  return {
+    title: input.title ?? "",
+    type: input.type ?? "",
+    date,
+    datetime
+  };
+}
+function renderTemplate(template, variables) {
+  return template.replace(/\{\{\s*([a-zA-Z0-9_-]+)\s*\}\}/g, (match, key) => {
+    const value = variables[key];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+
+// src/lib/primitive-templates.ts
+var import_meta = {};
+var TEMPLATE_EXTENSION = ".md";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeTemplateName(name) {
+  const base = path.basename(name, path.extname(name));
+  return base.trim();
+}
+function resolveBuiltinTemplatesDir(override) {
+  if (override) {
+    const resolved = path.resolve(override);
+    return fs.existsSync(resolved) && fs.statSync(resolved).isDirectory() ? resolved : null;
+  }
+  const moduleDir = path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  const candidates = [
+    path.resolve(moduleDir, "../templates"),
+    path.resolve(moduleDir, "../../templates")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function listTemplateFiles(dir, ignore) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!fs.existsSync(dir)) return entries;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(TEMPLATE_EXTENSION)) continue;
+    const name = normalizeTemplateName(entry.name);
+    if (!name) continue;
+    if (ignore?.has(name)) continue;
+    entries.set(name, path.join(dir, entry.name));
+  }
+  return entries;
+}
+function buildTemplateIndex(options = {}) {
+  const index = /* @__PURE__ */ new Map();
+  const builtinDir = resolveBuiltinTemplatesDir(options.builtinDir);
+  if (builtinDir) {
+    for (const [name, filePath] of listTemplateFiles(builtinDir, options.ignoreBuiltinNames)) {
+      index.set(name, filePath);
+    }
+  }
+  if (options.vaultPath) {
+    const vaultTemplatesDir = path.join(path.resolve(options.vaultPath), "templates");
+    for (const [name, filePath] of listTemplateFiles(vaultTemplatesDir)) {
+      index.set(name, filePath);
+    }
+  }
+  return index;
+}
+function inferFieldType(defaultValue) {
+  if (Array.isArray(defaultValue)) {
+    const uniqueItemTypes = [...new Set(defaultValue.map((value) => typeof value))];
+    if (uniqueItemTypes.length === 1 && uniqueItemTypes[0] === "string") {
+      return "string[]";
+    }
+    return "array";
+  }
+  switch (typeof defaultValue) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      if (defaultValue === null) return "string";
+      return "object";
+    default:
+      return "string";
+  }
+}
+function normalizeFieldDefinition(rawField) {
+  if (!isRecord(rawField)) {
+    return {
+      type: inferFieldType(rawField),
+      default: rawField
+    };
+  }
+  const rawType = typeof rawField.type === "string" ? rawField.type.trim() : "";
+  const normalized = {
+    type: rawType || inferFieldType(rawField.default)
+  };
+  if (typeof rawField.description === "string" && rawField.description.trim()) {
+    normalized.description = rawField.description.trim();
+  }
+  if (typeof rawField.required === "boolean") {
+    normalized.required = rawField.required;
+  }
+  if (Object.prototype.hasOwnProperty.call(rawField, "default")) {
+    normalized.default = rawField.default;
+  }
+  if (Array.isArray(rawField.enum)) {
+    normalized.enum = rawField.enum;
+  }
+  return normalized;
+}
+function normalizeFieldDefinitions(rawFields) {
+  const normalized = {};
+  for (const [fieldName, rawField] of Object.entries(rawFields)) {
+    const normalizedName = String(fieldName).trim();
+    if (!normalizedName) continue;
+    normalized[normalizedName] = normalizeFieldDefinition(rawField);
+  }
+  return normalized;
+}
+function extractSchemaDefinition(frontmatter) {
+  const primitive = typeof frontmatter.primitive === "string" ? frontmatter.primitive.trim() : "";
+  const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0;
+  if (primitive && isRecord(frontmatter.fields)) {
+    return {
+      primitive,
+      description,
+      fields: frontmatter.fields
+    };
+  }
+  const containerCandidates = [frontmatter.schema, frontmatter.template];
+  for (const candidate of containerCandidates) {
+    if (!isRecord(candidate)) continue;
+    const nestedPrimitive = typeof candidate.primitive === "string" ? candidate.primitive.trim() : primitive;
+    if (!nestedPrimitive || !isRecord(candidate.fields)) continue;
+    const nestedDescription = typeof candidate.description === "string" ? candidate.description.trim() : description;
+    return {
+      primitive: nestedPrimitive,
+      description: nestedDescription,
+      fields: candidate.fields
+    };
+  }
+  return null;
+}
+function inferLegacyFieldDefinitions(frontmatter) {
+  const normalized = {};
+  const ignoredKeys = /* @__PURE__ */ new Set(["primitive", "fields", "schema", "template"]);
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (ignoredKeys.has(key)) continue;
+    normalized[key] = {
+      type: inferFieldType(value),
+      default: value
+    };
+  }
+  return normalized;
+}
+function parseTemplateDefinition(rawTemplate, templateName, sourcePath) {
+  const normalizedName = normalizeTemplateName(templateName);
+  const { data, content } = (0, import_gray_matter.default)(rawTemplate);
+  const frontmatter = isRecord(data) ? data : {};
+  const extractedSchema = extractSchemaDefinition(frontmatter);
+  if (extractedSchema) {
+    return {
+      name: normalizedName,
+      primitive: extractedSchema.primitive,
+      description: extractedSchema.description,
+      fields: normalizeFieldDefinitions(extractedSchema.fields),
+      body: content,
+      format: "schema",
+      sourcePath
+    };
+  }
+  return {
+    name: normalizedName,
+    primitive: normalizedName,
+    description: typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0,
+    fields: inferLegacyFieldDefinitions(frontmatter),
+    body: content,
+    format: "legacy",
+    sourcePath
+  };
+}
+function readTemplateDefinitionFromPath(filePath, templateName) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return parseTemplateDefinition(raw, templateName, filePath);
+  } catch {
+    return null;
+  }
+}
+function loadTemplateDefinition(templateName, options = {}) {
+  const normalizedName = normalizeTemplateName(templateName);
+  if (!normalizedName) return null;
+  const index = buildTemplateIndex(options);
+  const filePath = index.get(normalizedName);
+  if (!filePath) return null;
+  return readTemplateDefinitionFromPath(filePath, normalizedName);
+}
+function loadSchemaTemplateDefinition(templateName, options = {}) {
+  const definition = loadTemplateDefinition(templateName, options);
+  if (!definition || definition.format !== "schema") {
+    return null;
+  }
+  return definition;
+}
+function resolveInterpolatedValue(value, variables) {
+  if (typeof value === "string") {
+    return renderTemplate(value, variables);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveInterpolatedValue(item, variables));
+  }
+  if (isRecord(value)) {
+    const resolved = {};
+    for (const [key, nested] of Object.entries(value)) {
+      resolved[key] = resolveInterpolatedValue(nested, variables);
+    }
+    return resolved;
+  }
+  return value;
+}
+function pruneFrontmatter(frontmatter, options) {
+  const dropEmptyStrings = options.dropEmptyStrings ?? true;
+  const dropEmptyArrays = options.dropEmptyArrays ?? true;
+  const pruned = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) continue;
+    if (dropEmptyStrings && typeof value === "string" && value.trim() === "") continue;
+    if (dropEmptyArrays && Array.isArray(value) && value.length === 0) continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+function buildFrontmatterFromTemplate(definition, variables, overrides = {}, options = {}) {
+  const frontmatter = {};
+  for (const [fieldName, schema] of Object.entries(definition.fields)) {
+    if (!Object.prototype.hasOwnProperty.call(schema, "default")) continue;
+    frontmatter[fieldName] = resolveInterpolatedValue(schema.default, variables);
+  }
+  for (const [fieldName, value] of Object.entries(overrides)) {
+    if (value === void 0) continue;
+    if (value === null) {
+      delete frontmatter[fieldName];
+      continue;
+    }
+    frontmatter[fieldName] = value;
+  }
+  if (!options.pruneEmpty) {
+    return frontmatter;
+  }
+  return pruneFrontmatter(frontmatter, options);
+}
+function renderDocumentFromTemplate(definition, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const variables = {
+    ...buildTemplateVariables(
+      {
+        title: options.title ?? "",
+        type: options.type ?? definition.primitive
+      },
+      now
+    ),
+    ...options.variables ?? {}
+  };
+  const frontmatter = buildFrontmatterFromTemplate(
+    definition,
+    variables,
+    options.overrides,
+    options.frontmatter
+  );
+  const content = renderTemplate(definition.body, variables);
+  const markdown = import_gray_matter.default.stringify(content, frontmatter);
+  return {
+    frontmatter,
+    content,
+    markdown,
+    variables
+  };
+}
+
+// src/lib/task-utils.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+}
+function getTasksDir(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "tasks");
+}
+function getBacklogDir(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "backlog");
+}
+function ensureTasksDir(vaultPath) {
+  const tasksDir = getTasksDir(vaultPath);
+  if (!fs2.existsSync(tasksDir)) {
+    fs2.mkdirSync(tasksDir, { recursive: true });
+  }
+}
+function ensureBacklogDir(vaultPath) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs2.existsSync(backlogDir)) {
+    fs2.mkdirSync(backlogDir, { recursive: true });
+  }
+}
+function getTaskPath(vaultPath, slug) {
+  return path2.join(getTasksDir(vaultPath), `${slug}.md`);
+}
+function getBacklogPath(vaultPath, slug) {
+  return path2.join(getBacklogDir(vaultPath), `${slug}.md`);
+}
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function buildTaskFrontmatterFallback(now, options) {
+  const frontmatter = {
+    status: "open",
+    created: now,
+    updated: now
+  };
+  if (options.source) frontmatter.source = options.source;
+  if (options.owner) frontmatter.owner = options.owner;
+  if (options.project) frontmatter.project = options.project;
+  if (options.priority) frontmatter.priority = options.priority;
+  if (options.due) frontmatter.due = options.due;
+  if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
+  if (options.description) frontmatter.description = options.description;
+  if (options.estimate) frontmatter.estimate = options.estimate;
+  if (options.parent) frontmatter.parent = options.parent;
+  if (options.depends_on && options.depends_on.length > 0) frontmatter.depends_on = options.depends_on;
+  return frontmatter;
+}
+function buildTaskContentFallback(title, options) {
+  let content = `# ${title}
+`;
+  const links = [];
+  if (options.owner) links.push(`[[${options.owner}]]`);
+  if (options.project) links.push(`[[${options.project}]]`);
+  if (links.length > 0) {
+    content += `
+${links.join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  return content;
+}
+function buildTaskTemplateOverrides(options) {
+  const overrides = {};
+  if (options.source) overrides.source = options.source;
+  if (options.owner) overrides.owner = options.owner;
+  if (options.project) overrides.project = options.project;
+  if (options.priority) overrides.priority = options.priority;
+  if (options.due) overrides.due = options.due;
+  if (options.tags && options.tags.length > 0) overrides.tags = options.tags;
+  if (options.description) overrides.description = options.description;
+  if (options.estimate) overrides.estimate = options.estimate;
+  if (options.parent) overrides.parent = options.parent;
+  if (options.depends_on && options.depends_on.length > 0) overrides.depends_on = options.depends_on;
+  return overrides;
+}
+function buildTaskTemplateVariables(title, slug, options) {
+  const ownerLink = options.owner ? `[[${options.owner}]]` : "";
+  const projectLink = options.project ? `[[${options.project}]]` : "";
+  const linksLine = [ownerLink, projectLink].filter(Boolean).join(" | ");
+  return {
+    title,
+    slug,
+    source: options.source ?? "",
+    owner: options.owner ?? "",
+    project: options.project ?? "",
+    priority: options.priority ?? "",
+    due: options.due ?? "",
+    tags_csv: (options.tags || []).join(", "),
+    description: options.description ?? "",
+    estimate: options.estimate ?? "",
+    parent: options.parent ?? "",
+    depends_on_csv: (options.depends_on || []).join(", "),
+    content: options.content ?? "",
+    owner_link: ownerLink,
+    project_link: projectLink,
+    links_line: linksLine
+  };
+}
+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 readBacklogItem(vaultPath, slug) {
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (!fs2.existsSync(backlogPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(backlogPath, "utf-8");
+    const { data, content } = (0, import_gray_matter2.default)(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: backlogPath
+    };
+  } catch {
+    return null;
+  }
+}
+function listBacklogItems(vaultPath, filters) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs2.existsSync(backlogDir)) {
+    return [];
+  }
+  const items = [];
+  const entries = fs2.readdirSync(backlogDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const item = readBacklogItem(vaultPath, slug);
+    if (!item) continue;
+    if (filters) {
+      if (filters.project && item.frontmatter.project !== filters.project) continue;
+      if (filters.source && item.frontmatter.source !== filters.source) continue;
+    }
+    items.push(item);
+  }
+  return items.sort((a, b) => {
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function createTask(vaultPath, title, options = {}) {
+  ensureTasksDir(vaultPath);
+  const slug = slugify(title);
+  const taskPath = getTaskPath(vaultPath, slug);
+  if (fs2.existsSync(taskPath)) {
+    throw new Error(`Task already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const template = loadSchemaTemplateDefinition("task", {
+    vaultPath: path2.resolve(vaultPath)
+  });
+  let frontmatter;
+  let content;
+  if (template) {
+    const rendered = renderDocumentFromTemplate(template, {
+      title,
+      type: "task",
+      now: new Date(now),
+      variables: buildTaskTemplateVariables(title, slug, options),
+      overrides: buildTaskTemplateOverrides(options),
+      frontmatter: { pruneEmpty: true }
+    });
+    const templateFrontmatter = rendered.frontmatter;
+    frontmatter = {
+      ...templateFrontmatter,
+      status: isTaskStatus(templateFrontmatter.status) ? templateFrontmatter.status : "open",
+      created: typeof templateFrontmatter.created === "string" && templateFrontmatter.created ? templateFrontmatter.created : now,
+      updated: typeof templateFrontmatter.updated === "string" && templateFrontmatter.updated ? templateFrontmatter.updated : now
+    };
+    content = rendered.content;
+  } else {
+    frontmatter = buildTaskFrontmatterFallback(now, options);
+    content = buildTaskContentFallback(title, options);
+  }
+  const fileContent = import_gray_matter2.default.stringify(content, frontmatter);
+  fs2.writeFileSync(taskPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter,
+    path: taskPath
+  };
+}
+function createBacklogItem(vaultPath, title, options = {}) {
+  ensureBacklogDir(vaultPath);
+  const slug = slugify(title);
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (fs2.existsSync(backlogPath)) {
+    throw new Error(`Backlog item already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    created: now
+  };
+  if (options.source) frontmatter.source = options.source;
+  if (options.project) frontmatter.project = options.project;
+  if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
+  let content = `# ${title}
+`;
+  const links = [];
+  if (options.source) links.push(`[[${options.source}]]`);
+  if (options.project) links.push(`[[${options.project}]]`);
+  if (links.length > 0) {
+    content += `
+${links.join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = import_gray_matter2.default.stringify(content, frontmatter);
+  fs2.writeFileSync(backlogPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter,
+    path: backlogPath
+  };
+}
+function promoteBacklogItem(vaultPath, slug, options = {}) {
+  const backlogItem = readBacklogItem(vaultPath, slug);
+  if (!backlogItem) {
+    throw new Error(`Backlog item not found: ${slug}`);
+  }
+  const task = createTask(vaultPath, backlogItem.title, {
+    owner: options.owner,
+    project: backlogItem.frontmatter.project,
+    priority: options.priority,
+    due: options.due,
+    content: backlogItem.content.replace(/^#\s+.+\n/, "").trim(),
+    // Remove title from content
+    tags: backlogItem.frontmatter.tags
+  });
+  fs2.unlinkSync(backlogItem.path);
+  return task;
+}
+
+// src/commands/backlog.ts
+function toDateStr(val) {
+  if (!val) return "unknown";
+  if (val instanceof Date) return val.toISOString().split("T")[0];
+  const s = String(val);
+  if (s.includes("T")) return s.split("T")[0];
+  return s;
+}
+function backlogAdd(vaultPath, title, options = {}) {
+  return createBacklogItem(vaultPath, title, {
+    source: options.source,
+    project: options.project,
+    content: options.content,
+    tags: options.tags
+  });
+}
+function backlogList(vaultPath, options = {}) {
+  const filters = {};
+  if (options.project) filters.project = options.project;
+  return listBacklogItems(vaultPath, filters);
+}
+function backlogPromote(vaultPath, slug, options = {}) {
+  return promoteBacklogItem(vaultPath, slug, {
+    owner: options.owner,
+    priority: options.priority,
+    due: options.due
+  });
+}
+function formatBacklogList(items) {
+  if (items.length === 0) {
+    return "No backlog items found.\n";
+  }
+  const headers = ["SOURCE", "PROJECT", "CREATED", "TITLE"];
+  const widths = [12, 16, 12, 40];
+  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
+  for (const item of items) {
+    const source = item.frontmatter.source || "-";
+    const project = item.frontmatter.project || "-";
+    const created = toDateStr(item.frontmatter.created);
+    const title = item.title.length > widths[3] ? item.title.slice(0, widths[3] - 3) + "..." : item.title;
+    const row = [
+      source.padEnd(widths[0]),
+      project.padEnd(widths[1]),
+      created.padEnd(widths[2]),
+      title
+    ];
+    output += row.join("  ") + "\n";
+  }
+  return output;
+}
+function formatBacklogDetails(item) {
+  let output = "";
+  output += `# ${item.title}
+`;
+  output += "-".repeat(40) + "\n";
+  if (item.frontmatter.source) {
+    output += `Source: ${item.frontmatter.source}
+`;
+  }
+  if (item.frontmatter.project) {
+    output += `Project: ${item.frontmatter.project}
+`;
+  }
+  if (item.frontmatter.tags && item.frontmatter.tags.length > 0) {
+    output += `Tags: ${item.frontmatter.tags.join(", ")}
+`;
+  }
+  output += `Created: ${item.frontmatter.created}
+`;
+  output += `File: ${item.path}
+`;
+  output += "-".repeat(40) + "\n";
+  const contentWithoutTitle = item.content.replace(/^#\s+.+\n/, "").trim();
+  if (contentWithoutTitle) {
+    output += "\n" + contentWithoutTitle + "\n";
+  }
+  return output;
+}
+async function backlogCommand(vaultPath, action, args) {
+  const options = args.options || {};
+  switch (action) {
+    case "add": {
+      if (!args.title) {
+        throw new Error("Title is required for backlog add");
+      }
+      const item = backlogAdd(vaultPath, args.title, options);
+      console.log(`\u2713 Added to backlog: ${item.slug}`);
+      console.log(`  Path: ${item.path}`);
+      break;
+    }
+    case "list": {
+      const items = backlogList(vaultPath, options);
+      if (options.json) {
+        console.log(JSON.stringify(items, null, 2));
+      } else {
+        console.log(formatBacklogList(items));
+      }
+      break;
+    }
+    case "promote": {
+      if (!args.slug) {
+        throw new Error("Backlog item slug is required for promote");
+      }
+      const task = backlogPromote(vaultPath, args.slug, options);
+      console.log(`\u2713 Promoted to task: ${task.slug}`);
+      console.log(`  Path: ${task.path}`);
+      break;
+    }
+    default:
+      throw new Error(`Unknown backlog action: ${action}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backlogAdd,
+  backlogCommand,
+  backlogList,
+  backlogPromote,
+  formatBacklogDetails,
+  formatBacklogList
+});