clawvault 3.1.0 → 3.2.1

package/dist/commands/backlog.cjs

@@ -1,721 +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/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
-});