clawvault 2.5.4 → 2.6.1

package/dist/{chunk-2YDBJS7M.js → chunk-3BTHWPMB.js}

@@ -1,6 +1,6 @@
 import {
   runReflection
-} from "./chunk-YOSEUUNB.js";
+} from "./chunk-T76H47ZS.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

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-GSD4ALSI.js → chunk-4VRIMU4O.js}

@@ -1,7 +1,7 @@
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-K3CDT7IH.js";
+} from "./chunk-HIHOUSXS.js";
 import {
   listConfig
 } from "./chunk-ITPEXLHA.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-K3CDT7IH.js → chunk-HIHOUSXS.js}

@@ -96,10 +96,10 @@ async function callGemini(options, provider) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const model = options.model ?? DEFAULT_MODELS[provider];
   const response = await fetchImpl(
-    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
     {
       method: "POST",
-      headers: { "content-type": "application/json" },
+      headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
       body: JSON.stringify({
         contents: [{ parts: [{ text: options.prompt }] }],
         generationConfig: {

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-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";