clawvault 3.1.0 → 3.2.1

package/dist/commands/project.cjs

@@ -1,1341 +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/project.ts
-var project_exports = {};
-__export(project_exports, {
-  buildProjectBoardLanes: () => buildProjectBoardLanes,
-  formatProjectDetails: () => formatProjectDetails,
-  formatProjectList: () => formatProjectList,
-  generateProjectBoardMarkdown: () => generateProjectBoardMarkdown,
-  projectAdd: () => projectAdd,
-  projectArchive: () => projectArchive,
-  projectCommand: () => projectCommand,
-  projectList: () => projectList,
-  projectUpdate: () => projectUpdate,
-  syncProjectBoard: () => syncProjectBoard
-});
-module.exports = __toCommonJS(project_exports);
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-
-// src/lib/project-utils.ts
-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/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 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();
-}
-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 getStatusIcon(status) {
-  switch (status) {
-    case "in-progress":
-      return "\u25CF";
-    case "blocked":
-      return "\u25A0";
-    case "open":
-      return "\u25CB";
-    case "done":
-      return "\u2713";
-    default:
-      return "\u25CB";
-  }
-}
-function getStatusDisplay(status) {
-  switch (status) {
-    case "in-progress":
-      return "active";
-    case "blocked":
-      return "blocked";
-    case "open":
-      return "open";
-    case "done":
-      return "done";
-    default:
-      return status;
-  }
-}
-
-// src/lib/project-utils.ts
-function extractTitle2(content) {
-  const match = content.match(/^#\s+(.+)$/m);
-  return match ? match[1].trim() : "";
-}
-function isDateSlug(slug) {
-  return /^\d{4}-\d{2}-\d{2}$/.test(slug);
-}
-function normalizeStringArray(value) {
-  return value.map((item) => item.trim()).filter(Boolean);
-}
-function getProjectsDir(vaultPath) {
-  return path3.join(path3.resolve(vaultPath), "projects");
-}
-function ensureProjectsDir(vaultPath) {
-  const projectsDir = getProjectsDir(vaultPath);
-  if (!fs3.existsSync(projectsDir)) {
-    fs3.mkdirSync(projectsDir, { recursive: true });
-  }
-}
-function getProjectPath(vaultPath, slug) {
-  return path3.join(getProjectsDir(vaultPath), `${slug}.md`);
-}
-function parseProjectDateValue(filePath) {
-  const filename = path3.basename(filePath, ".md");
-  if (/^\d{4}-\d{2}-\d{2}$/.test(filename)) {
-    const dateTs = Date.parse(`${filename}T00:00:00.000Z`);
-    if (!Number.isNaN(dateTs)) {
-      return dateTs;
-    }
-  }
-  return fs3.statSync(filePath).mtime.getTime();
-}
-function parseSortableTimestamp(value) {
-  if (!value) return 0;
-  const timestamp = Date.parse(value);
-  return Number.isNaN(timestamp) ? 0 : timestamp;
-}
-function normalizeProjectStatus(value) {
-  if (value === "active" || value === "paused" || value === "completed" || value === "archived") {
-    return value;
-  }
-  return "active";
-}
-function buildProjectFrontmatterFallback(now, options) {
-  const frontmatter = {
-    type: "project",
-    status: options.status ?? "active",
-    created: now,
-    updated: now
-  };
-  if (options.owner) frontmatter.owner = options.owner;
-  if (options.team && options.team.length > 0) {
-    const team = normalizeStringArray(options.team);
-    if (team.length > 0) frontmatter.team = team;
-  }
-  if (options.client) frontmatter.client = options.client;
-  if (options.tags && options.tags.length > 0) {
-    const tags = normalizeStringArray(options.tags);
-    if (tags.length > 0) frontmatter.tags = tags;
-  }
-  if (options.description) frontmatter.description = options.description;
-  if (options.started) frontmatter.started = options.started;
-  if (options.deadline) frontmatter.deadline = options.deadline;
-  if (options.repo) frontmatter.repo = options.repo;
-  if (options.url) frontmatter.url = options.url;
-  if (options.completed) frontmatter.completed = options.completed;
-  if (options.reason) frontmatter.reason = options.reason;
-  return frontmatter;
-}
-function buildProjectContentFallback(title, options) {
-  let content = `# ${title}
-`;
-  const wikiLinks = /* @__PURE__ */ new Set();
-  if (options.owner) wikiLinks.add(options.owner);
-  if (options.client) wikiLinks.add(options.client);
-  for (const member of options.team || []) {
-    const trimmed = member.trim();
-    if (trimmed) wikiLinks.add(trimmed);
-  }
-  if (wikiLinks.size > 0) {
-    content += `
-${Array.from(wikiLinks).map((link) => `[[${link}]]`).join(" | ")}
-`;
-  }
-  if (options.content) {
-    content += `
-${options.content}
-`;
-  }
-  return content;
-}
-function buildProjectTemplateOverrides(options) {
-  const overrides = {};
-  if (options.status) overrides.status = options.status;
-  if (options.owner) overrides.owner = options.owner;
-  if (options.team && options.team.length > 0) {
-    const team = normalizeStringArray(options.team);
-    if (team.length > 0) overrides.team = team;
-  }
-  if (options.client) overrides.client = options.client;
-  if (options.tags && options.tags.length > 0) {
-    const tags = normalizeStringArray(options.tags);
-    if (tags.length > 0) overrides.tags = tags;
-  }
-  if (options.description) overrides.description = options.description;
-  if (options.started) overrides.started = options.started;
-  if (options.deadline) overrides.deadline = options.deadline;
-  if (options.repo) overrides.repo = options.repo;
-  if (options.url) overrides.url = options.url;
-  if (options.completed) overrides.completed = options.completed;
-  if (options.reason) overrides.reason = options.reason;
-  return overrides;
-}
-function buildProjectTemplateVariables(title, slug, options) {
-  const ownerLink = options.owner ? `[[${options.owner}]]` : "";
-  const clientLink = options.client ? `[[${options.client}]]` : "";
-  const teamLinks = (options.team || []).map((member) => member.trim()).filter(Boolean).map((member) => `[[${member}]]`);
-  const linksLine = [ownerLink, clientLink, ...teamLinks].filter(Boolean).join(" | ");
-  return {
-    title,
-    slug,
-    status: options.status ?? "",
-    owner: options.owner ?? "",
-    client: options.client ?? "",
-    team_csv: (options.team || []).join(", "),
-    tags_csv: (options.tags || []).join(", "),
-    description: options.description ?? "",
-    started: options.started ?? "",
-    deadline: options.deadline ?? "",
-    repo: options.repo ?? "",
-    url: options.url ?? "",
-    completed: options.completed ?? "",
-    reason: options.reason ?? "",
-    content: options.content ?? "",
-    owner_link: ownerLink,
-    client_link: clientLink,
-    team_links_line: teamLinks.join(" | "),
-    links_line: linksLine
-  };
-}
-function normalizeProjectFrontmatter(frontmatter) {
-  const normalizedCreated = typeof frontmatter.created === "string" && frontmatter.created ? frontmatter.created : (/* @__PURE__ */ new Date(0)).toISOString();
-  const normalizedUpdated = typeof frontmatter.updated === "string" && frontmatter.updated ? frontmatter.updated : normalizedCreated;
-  const normalized = {
-    ...frontmatter,
-    type: "project",
-    status: normalizeProjectStatus(frontmatter.status),
-    created: normalizedCreated,
-    updated: normalizedUpdated
-  };
-  if (normalized.team) {
-    const team = normalizeStringArray(normalized.team);
-    if (team.length === 0) {
-      delete normalized.team;
-    } else {
-      normalized.team = team;
-    }
-  }
-  if (normalized.tags) {
-    const tags = normalizeStringArray(normalized.tags);
-    if (tags.length === 0) {
-      delete normalized.tags;
-    } else {
-      normalized.tags = tags;
-    }
-  }
-  return normalized;
-}
-function listProjects(vaultPath, filters) {
-  const projectsDir = getProjectsDir(vaultPath);
-  if (!fs3.existsSync(projectsDir)) {
-    return [];
-  }
-  const projects = [];
-  const entries = fs3.readdirSync(projectsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      continue;
-    }
-    const slug = entry.name.replace(/\.md$/, "");
-    if (isDateSlug(slug)) {
-      continue;
-    }
-    const project = readProject(vaultPath, slug);
-    if (!project) continue;
-    if (filters) {
-      if (filters.status && project.frontmatter.status !== filters.status) continue;
-      if (filters.owner && project.frontmatter.owner !== filters.owner) continue;
-      if (filters.client && project.frontmatter.client !== filters.client) continue;
-      if (filters.tag) {
-        const tags = project.frontmatter.tags || [];
-        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
-        if (!hasTag) continue;
-      }
-    }
-    projects.push(project);
-  }
-  return projects.sort((left, right) => {
-    const rightTime = parseSortableTimestamp(right.frontmatter.updated || right.frontmatter.created);
-    const leftTime = parseSortableTimestamp(left.frontmatter.updated || left.frontmatter.created);
-    return rightTime - leftTime;
-  });
-}
-function readProject(vaultPath, slug) {
-  if (!slug || isDateSlug(slug) || slug.includes(path3.sep)) {
-    return null;
-  }
-  const projectPath = getProjectPath(vaultPath, slug);
-  if (!fs3.existsSync(projectPath)) {
-    return null;
-  }
-  try {
-    const raw = fs3.readFileSync(projectPath, "utf-8");
-    const { data, content } = (0, import_gray_matter3.default)(raw);
-    if (data.type !== "project") {
-      return null;
-    }
-    const frontmatter = normalizeProjectFrontmatter(data);
-    const title = extractTitle2(content) || slug;
-    return {
-      slug,
-      title,
-      content,
-      frontmatter
-    };
-  } catch {
-    return null;
-  }
-}
-function createProject(vaultPath, title, options = {}) {
-  ensureProjectsDir(vaultPath);
-  const slug = slugify(title);
-  const projectPath = getProjectPath(vaultPath, slug);
-  if (fs3.existsSync(projectPath)) {
-    throw new Error(`Project already exists: ${slug}`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const template = loadSchemaTemplateDefinition("project", {
-    vaultPath: path3.resolve(vaultPath)
-  });
-  let frontmatter;
-  let content;
-  if (template) {
-    const rendered = renderDocumentFromTemplate(template, {
-      title,
-      type: "project",
-      now: new Date(now),
-      variables: buildProjectTemplateVariables(title, slug, options),
-      overrides: buildProjectTemplateOverrides(options),
-      frontmatter: { pruneEmpty: true }
-    });
-    const templateFrontmatter = rendered.frontmatter;
-    frontmatter = normalizeProjectFrontmatter({
-      ...templateFrontmatter,
-      type: "project",
-      status: normalizeProjectStatus(templateFrontmatter.status),
-      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 = buildProjectFrontmatterFallback(now, options);
-    content = buildProjectContentFallback(title, options);
-  }
-  const fileContent = import_gray_matter3.default.stringify(content, frontmatter);
-  fs3.writeFileSync(projectPath, fileContent);
-  return {
-    slug,
-    title,
-    content,
-    frontmatter
-  };
-}
-function updateProject(vaultPath, slug, updates) {
-  const project = readProject(vaultPath, slug);
-  if (!project) {
-    throw new Error(`Project not found: ${slug}`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const nextFrontmatter = {
-    ...project.frontmatter,
-    type: "project",
-    updated: now
-  };
-  if (updates.status !== void 0) {
-    nextFrontmatter.status = updates.status;
-    if (updates.status === "completed" && !updates.completed && !nextFrontmatter.completed) {
-      nextFrontmatter.completed = now;
-    }
-  }
-  if (updates.owner !== void 0) {
-    if (updates.owner === null || updates.owner.trim() === "") {
-      delete nextFrontmatter.owner;
-    } else {
-      nextFrontmatter.owner = updates.owner;
-    }
-  }
-  if (updates.team !== void 0) {
-    if (updates.team === null) {
-      delete nextFrontmatter.team;
-    } else {
-      const team = normalizeStringArray(updates.team);
-      if (team.length === 0) {
-        delete nextFrontmatter.team;
-      } else {
-        nextFrontmatter.team = team;
-      }
-    }
-  }
-  if (updates.client !== void 0) {
-    if (updates.client === null || updates.client.trim() === "") {
-      delete nextFrontmatter.client;
-    } else {
-      nextFrontmatter.client = updates.client;
-    }
-  }
-  if (updates.tags !== void 0) {
-    if (updates.tags === null) {
-      delete nextFrontmatter.tags;
-    } else {
-      const tags = normalizeStringArray(updates.tags);
-      if (tags.length === 0) {
-        delete nextFrontmatter.tags;
-      } else {
-        nextFrontmatter.tags = tags;
-      }
-    }
-  }
-  if (updates.description !== void 0) {
-    if (updates.description === null || updates.description.trim() === "") {
-      delete nextFrontmatter.description;
-    } else {
-      nextFrontmatter.description = updates.description;
-    }
-  }
-  if (updates.started !== void 0) {
-    if (updates.started === null || updates.started.trim() === "") {
-      delete nextFrontmatter.started;
-    } else {
-      nextFrontmatter.started = updates.started;
-    }
-  }
-  if (updates.deadline !== void 0) {
-    if (updates.deadline === null || updates.deadline.trim() === "") {
-      delete nextFrontmatter.deadline;
-    } else {
-      nextFrontmatter.deadline = updates.deadline;
-    }
-  }
-  if (updates.repo !== void 0) {
-    if (updates.repo === null || updates.repo.trim() === "") {
-      delete nextFrontmatter.repo;
-    } else {
-      nextFrontmatter.repo = updates.repo;
-    }
-  }
-  if (updates.url !== void 0) {
-    if (updates.url === null || updates.url.trim() === "") {
-      delete nextFrontmatter.url;
-    } else {
-      nextFrontmatter.url = updates.url;
-    }
-  }
-  if (updates.completed !== void 0) {
-    if (updates.completed === null || updates.completed.trim() === "") {
-      delete nextFrontmatter.completed;
-    } else {
-      nextFrontmatter.completed = updates.completed;
-    }
-  }
-  if (updates.reason !== void 0) {
-    if (updates.reason === null || updates.reason.trim() === "") {
-      delete nextFrontmatter.reason;
-    } else {
-      nextFrontmatter.reason = updates.reason;
-    }
-  }
-  const projectPath = getProjectPath(vaultPath, slug);
-  fs3.writeFileSync(projectPath, import_gray_matter3.default.stringify(project.content, nextFrontmatter));
-  return {
-    ...project,
-    frontmatter: nextFrontmatter
-  };
-}
-function archiveProject(vaultPath, slug, reason) {
-  return updateProject(vaultPath, slug, {
-    status: "archived",
-    reason: reason ?? null,
-    completed: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function getProjectTasks(vaultPath, slug) {
-  return listTasks(vaultPath, { project: slug });
-}
-function getProjectActivity(vaultPath, slug) {
-  const projectActivityDir = path3.join(getProjectsDir(vaultPath), slug);
-  if (!fs3.existsSync(projectActivityDir) || !fs3.statSync(projectActivityDir).isDirectory()) {
-    return [];
-  }
-  const entries = fs3.readdirSync(projectActivityDir, { withFileTypes: true });
-  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path3.join(projectActivityDir, entry.name));
-  return files.sort((left, right) => parseProjectDateValue(right) - parseProjectDateValue(left));
-}
-
-// src/commands/task.ts
-function taskList(vaultPath, options = {}) {
-  const filters = {};
-  if (options.status) filters.status = options.status;
-  if (options.owner) filters.owner = options.owner;
-  if (options.project) filters.project = options.project;
-  if (options.priority) filters.priority = options.priority;
-  if (options.due) filters.due = true;
-  if (options.tag) filters.tag = options.tag;
-  if (options.overdue) filters.overdue = true;
-  const listed = listTasks(vaultPath, filters);
-  if (!options.status && !options.overdue) {
-    return listed.filter((t) => t.frontmatter.status !== "done");
-  }
-  return listed;
-}
-function formatTaskList(tasks) {
-  if (tasks.length === 0) {
-    return "No tasks found.\n";
-  }
-  const headers = ["STATUS", "OWNER", "PRIORITY", "PROJECT", "META", "TITLE"];
-  const widths = [10, 12, 8, 14, 64, 32];
-  const truncate = (value, width) => {
-    if (value.length <= width) return value;
-    return value.slice(0, width - 3) + "...";
-  };
-  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
-  for (const task of tasks) {
-    const icon = getStatusIcon(task.frontmatter.status);
-    const statusDisplay = getStatusDisplay(task.frontmatter.status);
-    const status = `${icon} ${statusDisplay}`;
-    const owner = task.frontmatter.owner || "-";
-    const priority = task.frontmatter.priority || "low";
-    const project = task.frontmatter.project || "-";
-    const metaParts = [];
-    if (task.frontmatter.due) metaParts.push(`due:${task.frontmatter.due.split("T")[0]}`);
-    if (task.frontmatter.tags?.length) metaParts.push(task.frontmatter.tags.map((tag) => `#${tag}`).join(","));
-    if (task.frontmatter.parent) metaParts.push(`parent:${task.frontmatter.parent}`);
-    if (task.frontmatter.depends_on?.length) {
-      metaParts.push(`deps:${task.frontmatter.depends_on.join("|")}`);
-    }
-    const meta = metaParts.length > 0 ? metaParts.join(" ") : "-";
-    const title = truncate(task.title, widths[5]);
-    const row = [
-      status.padEnd(widths[0]),
-      owner.padEnd(widths[1]),
-      priority.padEnd(widths[2]),
-      project.padEnd(widths[3]),
-      truncate(meta, widths[4]).padEnd(widths[4]),
-      title
-    ];
-    output += row.join("  ") + "\n";
-  }
-  return output;
-}
-
-// src/commands/project.ts
-function toDateStr(value) {
-  if (!value) return "-";
-  return value.includes("T") ? value.split("T")[0] : value;
-}
-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 normalizeBoardGroupBy(value) {
-  const normalized = String(value || "status").trim().toLowerCase();
-  if (normalized === "status" || normalized === "owner" || normalized === "client") {
-    return normalized;
-  }
-  throw new Error(`Unsupported project board group field: ${normalized}`);
-}
-function resolveBoardPath(vaultPath, output) {
-  const resolvedVaultPath = path4.resolve(vaultPath);
-  if (!output) {
-    return path4.join(resolvedVaultPath, "Projects-Board.md");
-  }
-  if (path4.isAbsolute(output)) {
-    return output;
-  }
-  return path4.join(resolvedVaultPath, output);
-}
-function parseDeadlineTimestamp(project) {
-  if (!project.frontmatter.deadline) return Number.POSITIVE_INFINITY;
-  const timestamp = Date.parse(project.frontmatter.deadline);
-  return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
-}
-function sortProjectsForCards(projects) {
-  return [...projects].sort((left, right) => {
-    const deadlineDiff = parseDeadlineTimestamp(left) - parseDeadlineTimestamp(right);
-    if (deadlineDiff !== 0) return deadlineDiff;
-    return new Date(right.frontmatter.updated).getTime() - new Date(left.frontmatter.updated).getTime();
-  });
-}
-function laneNameForStatus(status) {
-  switch (status) {
-    case "active":
-      return "Active";
-    case "paused":
-      return "Paused";
-    case "completed":
-      return "Completed";
-    case "archived":
-      return "Archived";
-    default:
-      return "Active";
-  }
-}
-function laneNameForProject(project, groupBy) {
-  switch (groupBy) {
-    case "status":
-      return laneNameForStatus(project.frontmatter.status);
-    case "owner":
-      return project.frontmatter.owner?.trim() || "Unassigned";
-    case "client":
-      return project.frontmatter.client?.trim() || "No Client";
-    default:
-      return laneNameForStatus(project.frontmatter.status);
-  }
-}
-function defaultLaneOrder(groupBy, projects) {
-  if (groupBy === "status") {
-    return ["Active", "Paused", "Completed", "Archived"];
-  }
-  const fallback = groupBy === "owner" ? "Unassigned" : "No Client";
-  const names = /* @__PURE__ */ new Set();
-  for (const project of projects) {
-    names.add(laneNameForProject(project, groupBy));
-  }
-  if (names.size === 0) {
-    return [fallback];
-  }
-  const sorted = Array.from(names).sort((left, right) => left.localeCompare(right));
-  if (sorted.includes(fallback)) {
-    return [...sorted.filter((name) => name !== fallback), fallback];
-  }
-  return sorted;
-}
-function formatProjectCard(project) {
-  const checkbox = project.frontmatter.status === "completed" || project.frontmatter.status === "archived" ? "x" : " ";
-  const parts = [`[[projects/${project.slug}|${project.title}]]`];
-  if (project.frontmatter.owner) {
-    const mention = toMention(project.frontmatter.owner);
-    if (mention) parts.push(`@${mention}`);
-  }
-  if (project.frontmatter.client) {
-    const clientTag = toHashTag(project.frontmatter.client);
-    if (clientTag) parts.push(`#client/${clientTag}`);
-  }
-  if (project.frontmatter.tags && project.frontmatter.tags.length > 0) {
-    for (const tag of project.frontmatter.tags) {
-      const normalizedTag = toHashTag(tag);
-      if (normalizedTag) parts.push(`#${normalizedTag}`);
-    }
-  }
-  if (project.frontmatter.deadline) {
-    parts.push(`\u{1F4C5} ${toDateStr(project.frontmatter.deadline)}`);
-  }
-  if (project.frontmatter.description) {
-    parts.push(`\u2014 ${project.frontmatter.description}`);
-  }
-  return `- [${checkbox}] ${parts.join(" ")}`;
-}
-function buildProjectBoardLanes(projects, groupBy) {
-  const laneOrder = defaultLaneOrder(groupBy, projects);
-  const lanes = /* @__PURE__ */ new Map();
-  for (const laneName of laneOrder) {
-    lanes.set(laneName, []);
-  }
-  for (const project of sortProjectsForCards(projects)) {
-    const laneName = laneNameForProject(project, groupBy);
-    if (!lanes.has(laneName)) {
-      lanes.set(laneName, []);
-    }
-    lanes.get(laneName)?.push(formatProjectCard(project));
-  }
-  return Array.from(lanes.entries()).map(([name, cards]) => ({ name, cards }));
-}
-function generateProjectBoardMarkdown(projects, options = {}) {
-  const groupBy = normalizeBoardGroupBy(options.groupBy);
-  const syncedAt = (options.now || /* @__PURE__ */ new Date()).toISOString();
-  const lanes = buildProjectBoardLanes(projects, 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":["Completed","Archived"],"show-checkboxes":true}',
-    "%%",
-    ""
-  ].join("\n");
-}
-function syncProjectBoard(vaultPath, options = {}) {
-  const groupBy = normalizeBoardGroupBy(options.groupBy);
-  const outputPath = resolveBoardPath(vaultPath, options.output);
-  const projects = listProjects(vaultPath);
-  const markdown = generateProjectBoardMarkdown(projects, { groupBy, now: options.now });
-  fs4.writeFileSync(outputPath, markdown);
-  return {
-    outputPath,
-    groupBy,
-    markdown,
-    lanes: buildProjectBoardLanes(projects, groupBy),
-    projectCount: projects.length
-  };
-}
-function projectAdd(vaultPath, title, options = {}) {
-  return createProject(vaultPath, title, {
-    status: options.status,
-    owner: options.owner,
-    team: options.team,
-    client: options.client,
-    tags: options.tags,
-    description: options.description,
-    deadline: options.deadline,
-    repo: options.repo,
-    url: options.url,
-    content: options.content
-  });
-}
-function projectUpdate(vaultPath, slug, options) {
-  return updateProject(vaultPath, slug, {
-    status: options.status,
-    owner: options.owner,
-    team: options.team,
-    client: options.client,
-    tags: options.tags,
-    description: options.description,
-    deadline: options.deadline,
-    repo: options.repo,
-    url: options.url
-  });
-}
-function projectArchive(vaultPath, slug, options = {}) {
-  return archiveProject(vaultPath, slug, options.reason);
-}
-function projectList(vaultPath, options = {}) {
-  const projects = listProjects(vaultPath, {
-    status: options.status,
-    owner: options.owner,
-    client: options.client,
-    tag: options.tag
-  });
-  if (!options.status) {
-    return projects.filter((project) => project.frontmatter.status !== "archived");
-  }
-  return projects;
-}
-function formatProjectList(projects) {
-  if (projects.length === 0) {
-    return "No projects found.\n";
-  }
-  const headers = ["STATUS", "OWNER", "DEADLINE", "TITLE"];
-  const widths = [10, 12, 12, 40];
-  const truncate = (value, width) => {
-    if (value.length <= width) return value;
-    return value.slice(0, width - 3) + "...";
-  };
-  let output = headers.map((header, index) => header.padEnd(widths[index])).join("  ") + "\n";
-  for (const project of projects) {
-    const row = [
-      project.frontmatter.status.padEnd(widths[0]),
-      (project.frontmatter.owner || "-").padEnd(widths[1]),
-      toDateStr(project.frontmatter.deadline).padEnd(widths[2]),
-      truncate(project.title, widths[3])
-    ];
-    output += row.join("  ") + "\n";
-  }
-  return output;
-}
-function formatFieldValue(value) {
-  if (Array.isArray(value)) {
-    return value.join(", ");
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value === null || value === void 0) {
-    return "-";
-  }
-  return String(value);
-}
-function countTasksByStatus(projectSlug, vaultPath) {
-  const tasks = getProjectTasks(vaultPath, projectSlug);
-  return {
-    open: tasks.filter((task) => task.frontmatter.status === "open").length,
-    inProgress: tasks.filter((task) => task.frontmatter.status === "in-progress").length,
-    done: tasks.filter((task) => task.frontmatter.status === "done").length
-  };
-}
-function formatProjectDetails(vaultPath, project, options = {}) {
-  const lines = [];
-  const taskSummary = countTasksByStatus(project.slug, vaultPath);
-  const activity = getProjectActivity(vaultPath, project.slug).slice(0, options.activityLimit ?? 5);
-  lines.push(`# ${project.title}`);
-  lines.push("-".repeat(40));
-  const orderedFields = [
-    "type",
-    "status",
-    "owner",
-    "team",
-    "client",
-    "tags",
-    "description",
-    "started",
-    "deadline",
-    "repo",
-    "url",
-    "created",
-    "updated",
-    "completed",
-    "reason"
-  ];
-  for (const field of orderedFields) {
-    const value = project.frontmatter[field];
-    if (value === void 0) continue;
-    lines.push(`${field}: ${formatFieldValue(value)}`);
-  }
-  lines.push("");
-  lines.push(`Linked tasks: ${taskSummary.open} open, ${taskSummary.inProgress} in-progress, ${taskSummary.done} done`);
-  if (project.frontmatter.team && project.frontmatter.team.length > 0) {
-    lines.push("Team members:");
-    for (const member of project.frontmatter.team) {
-      lines.push(`- ${member}`);
-    }
-  }
-  lines.push("");
-  lines.push("Recent activity:");
-  if (activity.length === 0) {
-    lines.push("- none");
-  } else {
-    for (const filePath of activity) {
-      lines.push(`- ${path4.basename(filePath)}`);
-    }
-  }
-  return lines.join("\n");
-}
-async function projectCommand(vaultPath, action, args) {
-  const options = args.options || {};
-  switch (action) {
-    case "add": {
-      if (!args.title) {
-        throw new Error("Title is required for project add");
-      }
-      const project = projectAdd(vaultPath, args.title, options);
-      console.log(`\u2713 Created project: ${project.slug}`);
-      console.log(`  Path: ${path4.join(path4.resolve(vaultPath), "projects", `${project.slug}.md`)}`);
-      break;
-    }
-    case "update": {
-      if (!args.slug) {
-        throw new Error("Project slug is required for update");
-      }
-      const project = projectUpdate(vaultPath, args.slug, options);
-      console.log(`\u2713 Updated project: ${project.slug}`);
-      break;
-    }
-    case "archive": {
-      if (!args.slug) {
-        throw new Error("Project slug is required for archive");
-      }
-      const project = projectArchive(vaultPath, args.slug, options);
-      console.log(`\u2713 Archived project: ${project.slug}`);
-      break;
-    }
-    case "list": {
-      const projects = projectList(vaultPath, options);
-      if (options.json) {
-        console.log(JSON.stringify(projects, null, 2));
-      } else {
-        console.log(formatProjectList(projects));
-      }
-      break;
-    }
-    case "show": {
-      if (!args.slug) {
-        throw new Error("Project slug is required for show");
-      }
-      const project = readProject(vaultPath, args.slug);
-      if (!project) {
-        throw new Error(`Project not found: ${args.slug}`);
-      }
-      const taskSummary = countTasksByStatus(project.slug, vaultPath);
-      const recentActivity = getProjectActivity(vaultPath, project.slug).slice(0, 5);
-      if (options.json) {
-        console.log(
-          JSON.stringify(
-            {
-              project,
-              taskSummary,
-              team: project.frontmatter.team || [],
-              recentActivity
-            },
-            null,
-            2
-          )
-        );
-      } else {
-        console.log(formatProjectDetails(vaultPath, project, { activityLimit: 5 }));
-      }
-      break;
-    }
-    case "tasks": {
-      if (!args.slug) {
-        throw new Error("Project slug is required for tasks");
-      }
-      const tasks = taskList(vaultPath, { project: args.slug });
-      if (options.json) {
-        console.log(JSON.stringify(tasks, null, 2));
-      } else {
-        console.log(formatTaskList(tasks));
-      }
-      break;
-    }
-    case "board": {
-      const result = syncProjectBoard(vaultPath, options);
-      console.log(`\u2713 Synced project board: ${result.outputPath}`);
-      console.log(`  Grouped by: ${result.groupBy}`);
-      console.log(`  Projects included: ${result.projectCount}`);
-      break;
-    }
-    default:
-      throw new Error(`Unknown project action: ${action}`);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildProjectBoardLanes,
-  formatProjectDetails,
-  formatProjectList,
-  generateProjectBoardMarkdown,
-  projectAdd,
-  projectArchive,
-  projectCommand,
-  projectList,
-  projectUpdate,
-  syncProjectBoard
-});