clawvault 2.6.3 → 2.6.5

package/dist/chunk-GNJL4YGR.js

@@ -0,0 +1,79 @@
+// src/lib/config.ts
+import * as fs from "fs";
+import * as path from "path";
+function getVaultPath() {
+  const vaultPath = process.env.CLAWVAULT_PATH;
+  if (!vaultPath) {
+    throw new Error("CLAWVAULT_PATH environment variable not set");
+  }
+  return path.resolve(vaultPath);
+}
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function validateVaultPath(vaultPath) {
+  if (!vaultPath || typeof vaultPath !== "string") return null;
+  const resolved = path.resolve(vaultPath);
+  if (!path.isAbsolute(resolved)) return null;
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  const configPath = path.join(resolved, ".clawvault.json");
+  if (!fs.existsSync(configPath)) return null;
+  return resolved;
+}
+function resolveAgentVaultPath(agentVaults, agentId) {
+  if (!agentId || typeof agentId !== "string") return null;
+  if (!agentVaults || typeof agentVaults !== "object" || Array.isArray(agentVaults)) {
+    return null;
+  }
+  const agentPath = agentVaults[agentId];
+  if (!agentPath || typeof agentPath !== "string") return null;
+  return validateVaultPath(agentPath);
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path.resolve(options.explicitPath);
+  }
+  if (options.agentId && options.pluginConfig?.agentVaults) {
+    const agentVaultPath = resolveAgentVaultPath(
+      options.pluginConfig.agentVaults,
+      options.agentId
+    );
+    if (agentVaultPath) {
+      return agentVaultPath;
+    }
+  }
+  if (options.pluginConfig?.vaultPath) {
+    const validated = validateVaultPath(options.pluginConfig.vaultPath);
+    if (validated) return validated;
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.resolve(process.env.CLAWVAULT_PATH);
+  }
+  const discovered = findNearestVaultPath(options.cwd ?? process.cwd());
+  if (discovered) {
+    return discovered;
+  }
+  throw new Error("No vault path found. Set CLAWVAULT_PATH, use --vault, or run inside a vault.");
+}
+
+export {
+  getVaultPath,
+  findNearestVaultPath,
+  resolveAgentVaultPath,
+  resolveVaultPath
+};

package/dist/{chunk-42MXU7A6.js → chunk-K4GFGKFD.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 });
   }
@@ -28,8 +28,42 @@ function findProtectedRanges(content) {
   }
   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 +82,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 +113,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-PBEE567J.js → chunk-KSZROBFH.js}

@@ -1,9 +1,9 @@
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-FUSLEY6L.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   getLegacyObservationPath,
   getObservationPath,

package/dist/chunk-L4HSSQ6T.js

@@ -0,0 +1,152 @@
+import {
+  getType,
+  loadRegistry
+} from "./chunk-MM6QGW3P.js";
+import {
+  append
+} from "./chunk-4BQTQMJP.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
+};