clawvault 3.1.0 → 3.2.0

package/dist/chunk-NCKFNBHJ.js

@@ -0,0 +1,257 @@
+// src/lib/llm-provider.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_MODELS = {
+  anthropic: "claude-3-5-haiku-latest",
+  openai: "gpt-4o-mini",
+  gemini: "gemini-2.0-flash",
+  xai: "grok-2-latest",
+  openclaw: "gpt-4o-mini"
+};
+var XAI_BASE_URL = "https://api.x.ai/v1";
+function resolveOpenClawHome() {
+  return process.env.OPENCLAW_HOME?.trim() || path.join(os.homedir(), ".openclaw");
+}
+function resolveOpenClawGatewayProvider() {
+  try {
+    const configPath = path.join(resolveOpenClawHome(), "openclaw.json");
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const enabled = raw.gateway?.http?.endpoints?.chatCompletions?.enabled === true;
+    const apiKey = raw.gateway?.auth?.token?.trim();
+    const port = raw.gateway?.port;
+    if (!enabled || !apiKey || typeof port !== "number" || !Number.isFinite(port) || port <= 0) {
+      return null;
+    }
+    const defaultModel = raw.agents?.defaults?.model?.trim() || DEFAULT_MODELS.openclaw;
+    const host = raw.gateway?.bind === "loopback" ? "127.0.0.1" : "127.0.0.1";
+    return {
+      baseUrl: `http://${host}:${port}/v1`,
+      apiKey,
+      api: "openai-completions",
+      defaultModel
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveOpenClawProvider() {
+  const gatewayProvider = resolveOpenClawGatewayProvider();
+  if (gatewayProvider) {
+    return gatewayProvider;
+  }
+  try {
+    const modelsPath = path.join(resolveOpenClawHome(), "agents", "main", "agent", "models.json");
+    if (!fs.existsSync(modelsPath)) {
+      return null;
+    }
+    const raw = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+    if (!raw.providers || typeof raw.providers !== "object") {
+      return null;
+    }
+    for (const [, provider] of Object.entries(raw.providers)) {
+      if (provider.baseUrl && provider.apiKey) {
+        const defaultModel = provider.models?.[0]?.id ?? "gpt-4o-mini";
+        return {
+          baseUrl: provider.baseUrl.replace(/\/+$/, ""),
+          apiKey: provider.apiKey,
+          api: provider.api ?? "openai-completions",
+          defaultModel
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveLlmProvider() {
+  if (process.env.CLAWVAULT_NO_LLM) {
+    return null;
+  }
+  if (resolveOpenClawProvider()) {
+    return "openclaw";
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return "anthropic";
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return "openai";
+  }
+  if (process.env.GEMINI_API_KEY) {
+    return "gemini";
+  }
+  if (process.env.XAI_API_KEY) {
+    return "xai";
+  }
+  return null;
+}
+async function requestLlmCompletion(options) {
+  const provider = options.provider ?? resolveLlmProvider();
+  if (!provider) {
+    return "";
+  }
+  if (provider === "openclaw") {
+    return callOpenClaw(options);
+  }
+  if (provider === "anthropic") {
+    return callAnthropic(options, provider);
+  }
+  if (provider === "gemini") {
+    return callGemini(options, provider);
+  }
+  if (provider === "xai") {
+    return callXAI(options, provider);
+  }
+  return callOpenAI(options, provider);
+}
+async function callAnthropic(options, provider) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    return "";
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const response = await fetchImpl("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: options.model ?? DEFAULT_MODELS[provider],
+      temperature: options.temperature ?? 0.1,
+      max_tokens: options.maxTokens ?? 1200,
+      messages: [{ role: "user", content: options.prompt }]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Anthropic request failed (${response.status})`);
+  }
+  const payload = await response.json();
+  return payload.content?.filter((entry) => entry.type === "text" && entry.text).map((entry) => entry.text).join("\n").trim() ?? "";
+}
+async function callOpenAI(options, provider) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return "";
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const messages = [];
+  if (options.systemPrompt?.trim()) {
+    messages.push({ role: "system", content: options.systemPrompt.trim() });
+  }
+  messages.push({ role: "user", content: options.prompt });
+  const response = await fetchImpl("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: options.model ?? DEFAULT_MODELS[provider],
+      temperature: options.temperature ?? 0.1,
+      max_tokens: options.maxTokens ?? 1200,
+      messages
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI request failed (${response.status})`);
+  }
+  const payload = await response.json();
+  return payload.choices?.[0]?.message?.content?.trim() ?? "";
+}
+async function callXAI(options, provider) {
+  const apiKey = process.env.XAI_API_KEY;
+  if (!apiKey) {
+    return "";
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const messages = [];
+  if (options.systemPrompt?.trim()) {
+    messages.push({ role: "system", content: options.systemPrompt.trim() });
+  }
+  messages.push({ role: "user", content: options.prompt });
+  const response = await fetchImpl(`${XAI_BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: options.model ?? DEFAULT_MODELS[provider],
+      temperature: options.temperature ?? 0.1,
+      max_tokens: options.maxTokens ?? 1200,
+      messages
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`xAI request failed (${response.status})`);
+  }
+  const payload = await response.json();
+  return payload.choices?.[0]?.message?.content?.trim() ?? "";
+}
+async function callGemini(options, provider) {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    return "";
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const model = options.model ?? DEFAULT_MODELS[provider];
+  const response = await fetchImpl(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: options.prompt }] }],
+        generationConfig: {
+          temperature: options.temperature ?? 0.1,
+          maxOutputTokens: options.maxTokens ?? 1200
+        }
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Gemini request failed (${response.status})`);
+  }
+  const payload = await response.json();
+  return payload.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+}
+async function callOpenClaw(options) {
+  const config = resolveOpenClawProvider();
+  if (!config) {
+    return "";
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const messages = [];
+  if (options.systemPrompt?.trim()) {
+    messages.push({ role: "system", content: options.systemPrompt.trim() });
+  }
+  messages.push({ role: "user", content: options.prompt });
+  const response = await fetchImpl(`${config.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: options.model ?? config.defaultModel,
+      temperature: options.temperature ?? 0.1,
+      max_tokens: options.maxTokens ?? 1200,
+      messages
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OpenClaw provider request failed (${response.status})`);
+  }
+  const payload = await response.json();
+  return payload.choices?.[0]?.message?.content?.trim() ?? "";
+}
+
+export {
+  resolveLlmProvider,
+  requestLlmCompletion
+};

package/dist/{chunk-QBLMXKF2.js → chunk-OIWVQYQF.js}

@@ -4,7 +4,7 @@ import {
 import {
   checkDirtyDeath,
   clearDirtyFlag
-} from "./chunk-WAZ3NLWL.js";
+} from "./chunk-F55HGNU4.js";
 
 // src/commands/recover.ts
 import * as fs from "fs";

package/dist/{chunk-42MXU7A6.js → chunk-P62WHA27.js}

@@ -14,7 +14,7 @@ function findProtectedRanges(content) {
   while ((match = codeBlockRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
-  const inlineCodeRegex = /`[^`]+`/g;
+  const inlineCodeRegex = /(?<!`)`[^`\n]+`(?!`)/g;
   while ((match = inlineCodeRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
@@ -26,10 +26,51 @@ function findProtectedRanges(content) {
   while ((match = urlRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
+  const filePathRegex = /(?:^|[\s([{"'])((?:~|\/)[^\s`<>\])}"']+|[A-Za-z]:\\[^\s`<>\])}"']+)/g;
+  while ((match = filePathRegex.exec(content)) !== null) {
+    const fullMatch = match[0];
+    const pathValue = match[1];
+    const start = match.index + fullMatch.indexOf(pathValue);
+    ranges.push({ start, end: start + pathValue.length });
+  }
   return ranges;
 }
-function isProtected(pos, ranges) {
-  return ranges.some((r) => pos >= r.start && pos < r.end);
+function isProtectedRange(start, end, ranges) {
+  return ranges.some((range) => start < range.end && end > range.start);
+}
+function createAliasRegex(alias) {
+  const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escapedAlias}\\b`, "gi");
+}
+function formatWikiLink(path, originalText) {
+  return originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
+}
+function planLinks(content, index, protectedRanges) {
+  const sortedAliases = getSortedAliases(index);
+  const linkedEntities = /* @__PURE__ */ new Set();
+  const claimedRanges = [];
+  const plannedLinks = [];
+  for (const { alias, path } of sortedAliases) {
+    if (linkedEntities.has(path)) continue;
+    const regex = createAliasRegex(alias);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
+      if (isProtectedRange(start, end, claimedRanges)) continue;
+      plannedLinks.push({
+        start,
+        end,
+        originalText: match[0],
+        path
+      });
+      claimedRanges.push({ start, end });
+      linkedEntities.add(path);
+      break;
+    }
+  }
+  return plannedLinks;
 }
 function createLineLookup(content) {
   const lines = content.split("\n");
@@ -48,56 +89,24 @@ function createLineLookup(content) {
 }
 function autoLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
+  const plannedLinks = planLinks(content, index, protectedRanges);
   let result = content;
-  let offset = 0;
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const originalPos = match.index;
-      const adjustedPos = originalPos + offset;
-      if (isProtected(originalPos, protectedRanges)) continue;
-      const beforeMatch = result.substring(0, adjustedPos);
-      const openBrackets = (beforeMatch.match(/\[\[/g) || []).length;
-      const closeBrackets = (beforeMatch.match(/\]\]/g) || []).length;
-      if (openBrackets > closeBrackets) continue;
-      const originalText = match[0];
-      const replacement = originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
-      result = result.substring(0, adjustedPos) + replacement + result.substring(adjustedPos + originalText.length);
-      offset += replacement.length - originalText.length;
-      linkedEntities.add(path);
-      break;
-    }
+  const sortedByPosition = plannedLinks.slice().sort((a, b) => b.start - a.start);
+  for (const planned of sortedByPosition) {
+    const replacement = formatWikiLink(planned.path, planned.originalText);
+    result = result.substring(0, planned.start) + replacement + result.substring(planned.end);
   }
   return result;
 }
 function dryRunLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
-  const matches = [];
+  const plannedLinks = planLinks(content, index, protectedRanges);
   const getLineNumber = createLineLookup(content);
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
-      matches.push({
-        alias: match[0],
-        path,
-        line: getLineNumber(match.index)
-      });
-      linkedEntities.add(path);
-      break;
-    }
-  }
-  return matches;
+  return plannedLinks.map((planned) => ({
+    alias: planned.originalText,
+    path: planned.path,
+    line: getLineNumber(planned.start)
+  }));
 }
 function findUnlinkedMentions(content, index) {
   const protectedRanges = findProtectedRanges(content);
@@ -111,7 +120,9 @@ function findUnlinkedMentions(content, index) {
     const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
     let match;
     while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
       matches.push({
         alias: match[0],
         path,

package/dist/chunk-PBACDKKP.js

@@ -0,0 +1,66 @@
+import {
+  loadVaultQmdConfig,
+  recoverQmdEmbeddingIfNeeded,
+  runCrashSafeQmdEmbed
+} from "./chunk-6FH3IULF.js";
+import {
+  QmdUnavailableError,
+  hasQmd
+} from "./chunk-EK6S23ZB.js";
+import {
+  resolveVaultPath
+} from "./chunk-GNJL4YGR.js";
+
+// src/commands/embed.ts
+async function embedCommand(options = {}) {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const qmdConfig = loadVaultQmdConfig(vaultPath);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const recovery = recoverQmdEmbeddingIfNeeded({
+    vaultPath,
+    collection: qmdConfig.qmdCollection,
+    rootPath: qmdConfig.qmdRoot,
+    mode: "marker-or-empty",
+    onLog: options.quiet ? void 0 : (message) => console.log(message)
+  });
+  if (!options.quiet && recovery.recovered) {
+    const reasonLabel = recovery.reason === "interrupted_wal" ? "interrupted run" : "empty vector state";
+    console.log(`\u2713 Automatic qmd recovery completed (${reasonLabel}).`);
+  }
+  if (!options.quiet) {
+    console.log(
+      `Embedding pending documents for collection "${qmdConfig.qmdCollection}" (root: ${qmdConfig.qmdRoot})...`
+    );
+  }
+  runCrashSafeQmdEmbed({
+    vaultPath,
+    collection: qmdConfig.qmdCollection,
+    rootPath: qmdConfig.qmdRoot
+  });
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!options.quiet) {
+    console.log(`\u2713 Embedding complete for "${qmdConfig.qmdCollection}"`);
+  }
+  return {
+    vaultPath,
+    qmdCollection: qmdConfig.qmdCollection,
+    qmdRoot: qmdConfig.qmdRoot,
+    startedAt,
+    finishedAt
+  };
+}
+function registerEmbedCommand(program) {
+  program.command("embed").description("Run qmd embedding for pending vault documents").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await embedCommand({
+      vaultPath: rawOptions.vault
+    });
+  });
+}
+
+export {
+  embedCommand,
+  registerEmbedCommand
+};

package/dist/{chunk-VGLOTGAS.js → chunk-QSHD36LH.js}

@@ -1,9 +1,9 @@
 import {
   Observer
-} from "./chunk-3NSBOUT3.js";
+} from "./chunk-77Q5CSPJ.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   getLegacyObservationPath,
   getObservationPath,

package/dist/{chunk-OZ7RIXTO.js → chunk-QSRRMEYM.js}

@@ -1,10 +1,10 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   buildOrUpdateMemoryGraphIndex,
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/commands/graph.ts
 function formatGraphSummary(summary) {

package/dist/chunk-QVEERJSP.js

@@ -0,0 +1,152 @@
+import {
+  append
+} from "./chunk-4BQTQMJP.js";
+import {
+  getType,
+  loadRegistry
+} from "./chunk-MM6QGW3P.js";
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/store.ts
+var store_exports = {};
+__export(store_exports, {
+  activeThreads: () => activeThreads,
+  blockedThreads: () => blockedThreads,
+  create: () => create,
+  findByField: () => findByField,
+  list: () => list,
+  openThreads: () => openThreads,
+  read: () => read,
+  remove: () => remove,
+  update: () => update
+});
+import fs from "fs";
+import path from "path";
+import matter from "gray-matter";
+function create(vaultPath, typeName, fields, body, actor) {
+  const typeDef = getType(vaultPath, typeName);
+  if (!typeDef) {
+    throw new Error(`Unknown primitive type "${typeName}". Run \`clawvault primitive list\` to see available types, or \`clawvault primitive define\` to create one.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const merged = applyDefaults(typeDef, {
+    ...fields,
+    created: fields.created ?? now,
+    updated: now
+  });
+  const slug = slugify(String(merged.title ?? merged.name ?? typeName));
+  const relDir = typeDef.directory;
+  const relPath = `${relDir}/${slug}.md`;
+  const absDir = path.join(vaultPath, relDir);
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absDir)) fs.mkdirSync(absDir, { recursive: true });
+  if (fs.existsSync(absPath)) {
+    throw new Error(`File already exists: ${relPath}. Use update instead.`);
+  }
+  const content = matter.stringify(body, stripUndefined(merged));
+  fs.writeFileSync(absPath, content, "utf-8");
+  append(vaultPath, actor, "create", relPath, typeName, {
+    title: merged.title ?? slug
+  });
+  return { path: relPath, type: typeName, fields: merged, body };
+}
+function read(vaultPath, relPath) {
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absPath)) return null;
+  const raw = fs.readFileSync(absPath, "utf-8");
+  const { data, content } = matter(raw);
+  const typeName = inferType(vaultPath, relPath);
+  return { path: relPath, type: typeName, fields: data, body: content.trim() };
+}
+function list(vaultPath, typeName) {
+  const typeDef = getType(vaultPath, typeName);
+  if (!typeDef) return [];
+  const dir = path.join(vaultPath, typeDef.directory);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  const instances = [];
+  for (const file of files) {
+    const relPath = `${typeDef.directory}/${file}`;
+    const inst = read(vaultPath, relPath);
+    if (inst) instances.push(inst);
+  }
+  return instances;
+}
+function update(vaultPath, relPath, fieldUpdates, bodyUpdate, actor) {
+  const existing = read(vaultPath, relPath);
+  if (!existing) throw new Error(`Not found: ${relPath}`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newFields = { ...existing.fields, ...fieldUpdates, updated: now };
+  const newBody = bodyUpdate ?? existing.body;
+  const absPath = path.join(vaultPath, relPath);
+  const content = matter.stringify(newBody, stripUndefined(newFields));
+  fs.writeFileSync(absPath, content, "utf-8");
+  append(vaultPath, actor, "update", relPath, existing.type, {
+    changed: Object.keys(fieldUpdates)
+  });
+  return { path: relPath, type: existing.type, fields: newFields, body: newBody };
+}
+function remove(vaultPath, relPath, actor) {
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absPath)) throw new Error(`Not found: ${relPath}`);
+  const archiveDir = path.join(vaultPath, ".clawvault", "archive");
+  if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+  const archivePath = path.join(archiveDir, path.basename(relPath));
+  fs.renameSync(absPath, archivePath);
+  const typeName = inferType(vaultPath, relPath);
+  append(vaultPath, actor, "delete", relPath, typeName);
+}
+function findByField(vaultPath, typeName, field, value) {
+  return list(vaultPath, typeName).filter((inst) => inst.fields[field] === value);
+}
+function openThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "open");
+}
+function activeThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "active");
+}
+function blockedThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "blocked");
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+}
+function applyDefaults(typeDef, fields) {
+  const result = { ...fields };
+  for (const [key, def] of Object.entries(typeDef.fields)) {
+    if (result[key] === void 0 && def.default !== void 0) {
+      result[key] = def.default;
+    }
+  }
+  return result;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) result[k] = v;
+  }
+  return result;
+}
+function inferType(vaultPath, relPath) {
+  const registry = loadRegistry(vaultPath);
+  const dir = relPath.split("/")[0];
+  for (const typeDef of Object.values(registry.types)) {
+    if (typeDef.directory === dir) return typeDef.name;
+  }
+  return "unknown";
+}
+
+export {
+  create,
+  read,
+  list,
+  update,
+  remove,
+  findByField,
+  openThreads,
+  activeThreads,
+  blockedThreads,
+  store_exports
+};

package/dist/{chunk-N2AXRYLC.js → chunk-QWQ3TIKS.js}

@@ -1,7 +1,7 @@
 import {
   loadSchemaTemplateDefinition,
   renderDocumentFromTemplate
-} from "./chunk-LYHGEHXG.js";
+} from "./chunk-MFAWT5O5.js";
 
 // src/lib/task-utils.ts
 import * as fs2 from "fs";

package/dist/{chunk-3DHXQHYG.js → chunk-R2MIW5G7.js}

@@ -8,7 +8,7 @@ import {
   queryTransitions,
   readTask,
   updateTask
-} from "./chunk-N2AXRYLC.js";
+} from "./chunk-QWQ3TIKS.js";
 
 // src/commands/task.ts
 function taskAdd(vaultPath, title, options = {}) {

package/dist/{chunk-SJSFRIYS.js → chunk-SLXOR3CC.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-H34S76MB.js";
+} from "./chunk-ESVS6K2B.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/reflect.ts
 function parsePositiveInteger(raw, label) {