clawvault 2.5.3 → 2.6.0

package/dist/{chunk-J5EMBUPK.js → chunk-4OXMU5S2.js}

@@ -2,7 +2,7 @@ import {
   listTasks,
   readTask,
   updateTask
-} from "./chunk-IOALNTAN.js";
+} from "./chunk-QWQ3TIKS.js";
 
 // src/commands/kanban.ts
 import * as fs from "fs";

package/dist/{chunk-3FP5BJ42.js → chunk-4QYGFWRM.js}

@@ -2,7 +2,7 @@ import {
   QmdUnavailableError,
   hasQmd,
   qmdEmbed
-} from "./chunk-O7XHXF7F.js";
+} from "./chunk-MAKNAHAW.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-4IV3R2F5.js → chunk-4TE4JMLA.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-YOSEUUNB.js";
 import {
   Observer
-} from "./chunk-S2IG7VNM.js";
+} from "./chunk-Q2J5YTUF.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-5GZFTAL7.js → chunk-AZYOKJYC.js}

@@ -1,7 +1,11 @@
 import {
   listTasks,
   slugify
-} from "./chunk-IOALNTAN.js";
+} from "./chunk-QWQ3TIKS.js";
+import {
+  loadSchemaTemplateDefinition,
+  renderDocumentFromTemplate
+} from "./chunk-MFAWT5O5.js";
 
 // src/lib/project-utils.ts
 import * as fs from "fs";
@@ -50,6 +54,103 @@ function normalizeProjectStatus(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;
@@ -147,47 +248,32 @@ function createProject(vaultPath, title, options = {}) {
     throw new Error(`Project already exists: ${slug}`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  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;
-  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}
-`;
+  const template = loadSchemaTemplateDefinition("project", {
+    vaultPath: path.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 = matter.stringify(content, frontmatter);
   fs.writeFileSync(projectPath, fileContent);

package/dist/{chunk-FG6RJMCN.js → chunk-HA5M6KJB.js}

@@ -1,18 +1,18 @@
 import {
   registerTailscaleCommands
-} from "./chunk-NZ4ZZNSR.js";
+} from "./chunk-THRJVD4L.js";
 import {
   registerObserveCommand
-} from "./chunk-OSMS7QIG.js";
+} from "./chunk-ME37YNW3.js";
 import {
   registerReflectCommand
 } from "./chunk-2YDBJS7M.js";
 import {
   registerContextCommand
-} from "./chunk-GFJ3LIIB.js";
+} from "./chunk-XAVB4GB4.js";
 import {
   registerEmbedCommand
-} from "./chunk-3FP5BJ42.js";
+} from "./chunk-4QYGFWRM.js";
 import {
   registerInjectCommand
 } from "./chunk-GSD4ALSI.js";

package/dist/{chunk-IZEY5S74.js → chunk-IEVLHNLU.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HRLWZGMA.js";
 import {
   Observer
-} from "./chunk-S2IG7VNM.js";
+} from "./chunk-Q2J5YTUF.js";
 
 // src/observer/active-session-observer.ts
 import * as fs from "fs";

package/dist/{chunk-CLE2HHNT.js → chunk-IVRIKYFE.js}

@@ -9,17 +9,24 @@ var BLOCKED_PATHS = [
   "node_modules"
 ];
 var SUPPORTED_METHODS = ["GET", "PUT", "DELETE", "MKCOL", "PROPFIND", "OPTIONS", "HEAD", "MOVE", "COPY"];
+function toRequestSegments(requestPath) {
+  return requestPath.replace(/\\/g, "/").split("/").filter(Boolean);
+}
+function isWithinRoot(fullPath, rootPath) {
+  const resolvedRoot = path.resolve(rootPath);
+  const relative2 = path.relative(resolvedRoot, fullPath);
+  return !(relative2.startsWith("..") || path.isAbsolute(relative2));
+}
 function isPathSafe(requestPath, rootPath) {
-  if (requestPath.includes("..")) {
+  const pathParts = toRequestSegments(requestPath);
+  if (pathParts.includes("..")) {
     return false;
   }
-  const normalizedPath = path.normalize(requestPath).replace(/^\/+/, "");
-  const fullPath = path.resolve(rootPath, normalizedPath);
-  const resolvedRoot = path.resolve(rootPath);
-  if (!fullPath.startsWith(resolvedRoot + path.sep) && fullPath !== resolvedRoot) {
+  const normalizedRelativePath = path.normalize(pathParts.join(path.sep));
+  const fullPath = path.resolve(rootPath, normalizedRelativePath);
+  if (!isWithinRoot(fullPath, rootPath)) {
     return false;
   }
-  const pathParts = normalizedPath.split(path.sep);
   for (const part of pathParts) {
     if (BLOCKED_PATHS.includes(part)) {
       return false;
@@ -28,13 +35,13 @@ function isPathSafe(requestPath, rootPath) {
   return true;
 }
 function resolveWebDAVPath(requestPath, rootPath) {
-  if (requestPath.includes("..")) {
+  const pathParts = toRequestSegments(requestPath);
+  if (pathParts.includes("..")) {
     return null;
   }
-  const normalizedPath = path.normalize(requestPath).replace(/^\/+/, "");
-  const fullPath = path.resolve(rootPath, normalizedPath);
-  const resolvedRoot = path.resolve(rootPath);
-  if (!fullPath.startsWith(resolvedRoot + path.sep) && fullPath !== resolvedRoot) {
+  const normalizedRelativePath = path.normalize(pathParts.join(path.sep));
+  const fullPath = path.resolve(rootPath, normalizedRelativePath);
+  if (!isWithinRoot(fullPath, rootPath)) {
     return null;
   }
   return fullPath;

package/dist/{chunk-AY4PGUVL.js → chunk-KL4NAOMO.js}

@@ -6,7 +6,7 @@ import {
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-O7XHXF7F.js";
+} from "./chunk-MAKNAHAW.js";
 import {
   DEFAULT_CATEGORIES,
   TYPE_TO_CATEGORY

package/dist/{chunk-O7XHXF7F.js → chunk-MAKNAHAW.js}

@@ -235,14 +235,14 @@ var SearchEngine = class {
     for (const qr of qmdResults) {
       const filePath = this.qmdUriToPath(qr.file);
       const relativePath = this.vaultPath ? path.relative(this.vaultPath, filePath) : filePath;
-      const normalizedRelativePath = relativePath.split(path.sep).join("/");
+      const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       if (normalizedRelativePath.startsWith("ledger/archive/") || normalizedRelativePath.includes("/ledger/archive/")) {
         continue;
       }
-      const docId = relativePath.replace(/\.md$/, "");
-      let doc = this.documents.get(docId);
+      const docId = normalizedRelativePath.replace(/\.md$/, "");
+      let doc = this.documents.get(docId) ?? this.documents.get(docId.split("/").join(path.sep));
       const modifiedAt = this.resolveModifiedAt(doc, filePath);
-      const parts = relativePath.split(path.sep);
+      const parts = normalizedRelativePath.split("/");
       const docCategory = parts.length > 1 ? parts[0] : "root";
       if (category && docCategory !== category) continue;
       if (tags && tags.length > 0 && doc) {

package/dist/{chunk-OSMS7QIG.js → chunk-ME37YNW3.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   observeActiveSessions
-} from "./chunk-IZEY5S74.js";
+} from "./chunk-IEVLHNLU.js";
 import {
   Observer
-} from "./chunk-S2IG7VNM.js";
+} from "./chunk-Q2J5YTUF.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/chunk-MFAWT5O5.js

@@ -0,0 +1,301 @@
+import {
+  buildTemplateVariables,
+  renderTemplate
+} from "./chunk-7766SIJP.js";
+
+// src/lib/primitive-templates.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+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(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 } = matter(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 listTemplateDefinitions(options = {}) {
+  const index = buildTemplateIndex(options);
+  const entries = [];
+  for (const [name, filePath] of [...index.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    const definition = readTemplateDefinitionFromPath(filePath, name);
+    if (!definition) continue;
+    entries.push({
+      ...definition,
+      path: filePath
+    });
+  }
+  return entries;
+}
+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 = matter.stringify(content, frontmatter);
+  return {
+    frontmatter,
+    content,
+    markdown,
+    variables
+  };
+}
+
+export {
+  TEMPLATE_EXTENSION,
+  normalizeTemplateName,
+  buildTemplateIndex,
+  parseTemplateDefinition,
+  loadSchemaTemplateDefinition,
+  listTemplateDefinitions,
+  renderDocumentFromTemplate
+};

package/dist/{chunk-TPDH3JPP.js → chunk-PBEE567J.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-S2IG7VNM.js";
+} from "./chunk-Q2J5YTUF.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-S2IG7VNM.js → chunk-Q2J5YTUF.js}

@@ -1,6 +1,6 @@
 import {
   listProjects
-} from "./chunk-5GZFTAL7.js";
+} from "./chunk-AZYOKJYC.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -29,7 +29,7 @@ import {
   listTasks,
   updateBacklogItem,
   updateTask
-} from "./chunk-IOALNTAN.js";
+} from "./chunk-QWQ3TIKS.js";
 
 // src/observer/compressor.ts
 var OPENAI_BASE_URL = "https://api.openai.com/v1";