clawvault 3.1.0 → 3.2.1

package/dist/{chunk-WAZ3NLWL.js → chunk-F55HGNU4.js}

@@ -7,8 +7,6 @@ var CHECKPOINT_FILE = "last-checkpoint.json";
 var SESSION_STATE_FILE = "session-state.json";
 var DIRTY_DEATH_FLAG = "dirty-death.flag";
 var CHECKPOINT_HISTORY_DIR = "checkpoints";
-var CHECKPOINT_RETENTION_MAX_COUNT = 50;
-var CHECKPOINT_RETENTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var pendingCheckpoint = null;
 var pendingData = null;
 function ensureClawvaultDir(vaultPath) {
@@ -18,50 +16,6 @@ function ensureClawvaultDir(vaultPath) {
   }
   return dir;
 }
-function readCheckpointHistoryEntries(historyDir) {
-  const entries = [];
-  const files = fs.readdirSync(historyDir).filter((entry) => entry.endsWith(".json"));
-  for (const fileName of files) {
-    const filePath = path.join(historyDir, fileName);
-    try {
-      const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        continue;
-      }
-      const timestamp = typeof parsed.timestamp === "string" ? parsed.timestamp : "";
-      const timestampMs = Date.parse(timestamp);
-      if (Number.isNaN(timestampMs)) {
-        continue;
-      }
-      entries.push({ filePath, timestampMs });
-    } catch {
-    }
-  }
-  return entries.sort((left, right) => {
-    if (right.timestampMs !== left.timestampMs) {
-      return right.timestampMs - left.timestampMs;
-    }
-    return right.filePath.localeCompare(left.filePath);
-  });
-}
-function pruneCheckpointHistory(historyDir, nowMs) {
-  if (!fs.existsSync(historyDir)) {
-    return;
-  }
-  const entries = readCheckpointHistoryEntries(historyDir);
-  if (entries.length <= CHECKPOINT_RETENTION_MAX_COUNT) {
-    return;
-  }
-  for (let index = CHECKPOINT_RETENTION_MAX_COUNT; index < entries.length; index += 1) {
-    const ageMs = nowMs - entries[index].timestampMs;
-    if (ageMs > CHECKPOINT_RETENTION_MAX_AGE_MS) {
-      try {
-        fs.unlinkSync(entries[index].filePath);
-      } catch {
-      }
-    }
-  }
-}
 function writeCheckpointToDisk(dir, data) {
   const checkpointPath = path.join(dir, CHECKPOINT_FILE);
   fs.writeFileSync(checkpointPath, JSON.stringify(data, null, 2));
@@ -70,7 +24,6 @@ function writeCheckpointToDisk(dir, data) {
   const historyFileName = `${data.timestamp.replace(/[:.]/g, "-")}.json`;
   const historyPath = path.join(historyDir, historyFileName);
   fs.writeFileSync(historyPath, JSON.stringify(data, null, 2));
-  pruneCheckpointHistory(historyDir, Date.now());
   const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
   fs.writeFileSync(flagPath, data.timestamp);
 }

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

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

package/dist/{chunk-QK3UCXWL.js → chunk-FHFUXL6G.js}

@@ -3,7 +3,7 @@ var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
 var SCORED_LINE_RE = /^(?:-\s*)?\[(decision|preference|fact|commitment|task|todo|commitment-unresolved|milestone|lesson|relationship|project)\|c=(0(?:\.\d+)?|1(?:\.0+)?)\|i=(0(?:\.\d+)?|1(?:\.0+)?)\]\s+(.+)$/i;
 var EMOJI_LINE_RE = /^(?:-\s*)?(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
 var DECISION_RE = /\b(decis(?:ion|ions)?|decid(?:e|ed|ing)|chose|selected|opted|went with|picked)\b/i;
-var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use|enjoys?|loves?|favou?rite|fan of|interested in|go-to|tend(?:s)? to use|passionate about|hobby|hobbies|(?:I|my|our)\s+(?:own|have|use|got|bought|drive|wear|eat|drink|cook|play|watch|read|listen)|(?:I(?:'m| am))\s+(?:a |an |into |allergic|vegetarian|vegan|gluten|lactose|trying to|learning)|usually|every (?:morning|evening|night|day|week)|routine)\b/i;
+var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use)\b/i;
 var COMMITMENT_RE = /\b(commit(?:ment|ted)?|promised|deadline|due|scheduled|will deliver|agreed to)\b/i;
 var TODO_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
 var COMMITMENT_TASK_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
@@ -33,10 +33,10 @@ function inferObservationType(content) {
   if (DECISION_RE.test(content)) return "decision";
   if (UNRESOLVED_RE.test(content)) return "commitment-unresolved";
   if (TODO_RE.test(content)) return "todo";
-  if (PREFERENCE_RE.test(content)) return "preference";
   if (COMMITMENT_TASK_RE.test(content) || DEADLINE_RE.test(content)) return "task";
   if (COMMITMENT_RE.test(content)) return "commitment";
   if (MILESTONE_RE.test(content)) return "milestone";
+  if (PREFERENCE_RE.test(content)) return "preference";
   if (LESSON_RE.test(content)) return "lesson";
   if (RELATIONSHIP_RE.test(content)) return "relationship";
   if (PROJECT_RE.test(content)) return "project";

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-HR4KN6S2.js

@@ -0,0 +1,152 @@
+import {
+  append
+} from "./chunk-K7PNYS45.js";
+import {
+  getType,
+  loadRegistry
+} from "./chunk-NTOPJI7W.js";
+import {
+  __export
+} from "./chunk-U67V476Y.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-OZ7RIXTO.js → chunk-IIOU45CK.js}

@@ -1,6 +1,6 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   buildOrUpdateMemoryGraphIndex,
   loadMemoryGraphIndex

package/dist/chunk-IJBFGPCS.js

@@ -0,0 +1,33 @@
+import {
+  registerTailscaleCommands
+} from "./chunk-Y6VJKXGL.js";
+import {
+  registerObserveCommand
+} from "./chunk-4ITRXIVT.js";
+import {
+  registerReflectCommand
+} from "./chunk-S5OJEGFG.js";
+import {
+  registerContextCommand
+} from "./chunk-WJVWINEM.js";
+import {
+  registerEmbedCommand
+} from "./chunk-ECRZL5XR.js";
+import {
+  registerInjectCommand
+} from "./chunk-YNIPYN4F.js";
+
+// src/cli/index.ts
+function registerCliCommands(program) {
+  registerContextCommand(program);
+  registerInjectCommand(program);
+  registerObserveCommand(program);
+  registerReflectCommand(program);
+  registerEmbedCommand(program);
+  registerTailscaleCommands(program);
+  return program;
+}
+
+export {
+  registerCliCommands
+};