clawvault 3.0.0 → 3.2.0

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

@@ -0,0 +1,183 @@
+// src/lib/canvas-layout.ts
+import * as crypto from "crypto";
+var CANVAS_COLORS = {
+  RED: "1",
+  // Critical, blocked
+  ORANGE: "2",
+  // High priority
+  YELLOW: "3",
+  // Medium priority
+  GREEN: "4",
+  // Done, success
+  CYAN: "5",
+  // Stats
+  PURPLE: "6"
+  // Knowledge graph
+};
+var LAYOUT = {
+  LEFT_COLUMN_X: 0,
+  LEFT_COLUMN_WIDTH: 500,
+  RIGHT_COLUMN_X: 550,
+  RIGHT_COLUMN_WIDTH: 450,
+  GROUP_PADDING: 20,
+  NODE_SPACING: 15,
+  GROUP_SPACING: 50,
+  DEFAULT_NODE_WIDTH: 280,
+  DEFAULT_NODE_HEIGHT: 80,
+  FILE_NODE_HEIGHT: 60,
+  SMALL_NODE_HEIGHT: 50,
+  GROUP_HEADER_HEIGHT: 40
+};
+function generateId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+function createTextNode(x, y, width, height, text, color) {
+  const node = {
+    id: generateId(),
+    type: "text",
+    x,
+    y,
+    width,
+    height,
+    text
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createFileNode(x, y, width, height, file, color) {
+  const node = {
+    id: generateId(),
+    type: "file",
+    x,
+    y,
+    width,
+    height,
+    file
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createGroupNode(x, y, width, height, label, color) {
+  const node = {
+    id: generateId(),
+    type: "group",
+    x,
+    y,
+    width,
+    height,
+    label
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createEdge(fromNode, fromSide, toNode, toSide, label, color) {
+  const edge = {
+    id: generateId(),
+    fromNode,
+    fromSide,
+    toNode,
+    toSide
+  };
+  if (label) edge.label = label;
+  if (color) edge.color = color;
+  return edge;
+}
+function stackNodesVertically(nodes, startX, startY, spacing = LAYOUT.NODE_SPACING) {
+  let currentY = startY;
+  const positionedNodes = [];
+  for (const node of nodes) {
+    positionedNodes.push({
+      ...node,
+      x: startX,
+      y: currentY
+    });
+    currentY += node.height + spacing;
+  }
+  return {
+    nodes: positionedNodes,
+    totalHeight: currentY - startY - spacing
+  };
+}
+function createGroupWithNodes(groupX, groupY, groupWidth, label, childNodes, color) {
+  const padding = LAYOUT.GROUP_PADDING;
+  const headerHeight = LAYOUT.GROUP_HEADER_HEIGHT;
+  const stacked = stackNodesVertically(
+    childNodes,
+    groupX + padding,
+    groupY + headerHeight + padding
+  );
+  const groupHeight = headerHeight + padding * 2 + stacked.totalHeight + LAYOUT.NODE_SPACING;
+  const group = createGroupNode(groupX, groupY, groupWidth, groupHeight, label, color);
+  return {
+    group,
+    nodes: stacked.nodes
+  };
+}
+function getPriorityColor(priority) {
+  switch (priority) {
+    case "critical":
+      return CANVAS_COLORS.RED;
+    case "high":
+      return CANVAS_COLORS.ORANGE;
+    case "medium":
+      return CANVAS_COLORS.YELLOW;
+    default:
+      return void 0;
+  }
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - 3) + "...";
+}
+function formatCanvasText(lines) {
+  return lines.join("\n");
+}
+function calculateColumnHeight(groups) {
+  let height = 0;
+  for (let i = 0; i < groups.length; i++) {
+    height += groups[i].group.height;
+    if (i < groups.length - 1) {
+      height += LAYOUT.GROUP_SPACING;
+    }
+  }
+  return height;
+}
+function positionGroupsVertically(groups, startY = 0) {
+  let currentY = startY;
+  const positioned = [];
+  for (const { group, nodes } of groups) {
+    const yOffset = currentY - group.y;
+    positioned.push({
+      group: { ...group, y: currentY },
+      nodes: nodes.map((n) => ({ ...n, y: n.y + yOffset }))
+    });
+    currentY += group.height + LAYOUT.GROUP_SPACING;
+  }
+  return positioned;
+}
+function flattenGroups(groups) {
+  const nodes = [];
+  for (const { group, nodes: childNodes } of groups) {
+    nodes.push(group);
+    nodes.push(...childNodes);
+  }
+  return nodes;
+}
+
+export {
+  CANVAS_COLORS,
+  LAYOUT,
+  generateId,
+  createTextNode,
+  createFileNode,
+  createGroupNode,
+  createEdge,
+  stackNodesVertically,
+  createGroupWithNodes,
+  getPriorityColor,
+  truncateText,
+  formatCanvasText,
+  calculateColumnHeight,
+  positionGroupsVertically,
+  flattenGroups
+};

package/dist/{chunk-LYHGEHXG.js → chunk-MFAWT5O5.js}

@@ -295,7 +295,6 @@ export {
   normalizeTemplateName,
   buildTemplateIndex,
   parseTemplateDefinition,
-  loadTemplateDefinition,
   loadSchemaTemplateDefinition,
   listTemplateDefinitions,
   renderDocumentFromTemplate

package/dist/chunk-MM6QGW3P.js

@@ -0,0 +1,207 @@
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  defineType: () => defineType,
+  extendType: () => extendType,
+  getType: () => getType,
+  listTypes: () => listTypes,
+  loadRegistry: () => loadRegistry,
+  registryPath: () => registryPath,
+  saveRegistry: () => saveRegistry
+});
+import fs from "fs";
+import path from "path";
+var REGISTRY_FILE = ".clawvault/registry.json";
+var CURRENT_VERSION = 1;
+var BUILT_IN_TYPES = [
+  {
+    name: "thread",
+    description: "A unit of coordinated work. The core workgraph node.",
+    directory: "threads",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true, description: "What this thread is about" },
+      goal: { type: "string", required: true, description: "What success looks like" },
+      status: { type: "string", required: true, default: "open", description: "open | active | blocked | done | cancelled" },
+      owner: { type: "string", description: "Agent that claimed this thread" },
+      priority: { type: "string", default: "medium", description: "urgent | high | medium | low" },
+      deps: { type: "list", default: [], description: "Wiki-link refs to threads this depends on" },
+      parent: { type: "ref", description: "Parent thread (if decomposed from a larger thread)" },
+      context_refs: { type: "list", default: [], description: "Wiki-link refs to vault docs that inform this work" },
+      tags: { type: "list", default: [], description: "Freeform tags" },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true }
+    }
+  },
+  {
+    name: "space",
+    description: "A workspace boundary that groups related threads and sets context.",
+    directory: "spaces",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true, description: "Space name" },
+      description: { type: "string", description: "What this space is for" },
+      members: { type: "list", default: [], description: "Agent names that participate" },
+      thread_refs: { type: "list", default: [], description: "Wiki-link refs to threads in this space" },
+      tags: { type: "list", default: [], description: "Freeform tags" },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true }
+    }
+  },
+  {
+    name: "decision",
+    description: "A recorded decision with reasoning and context.",
+    directory: "decisions",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true },
+      date: { type: "date", required: true },
+      status: { type: "string", default: "active", description: "active | superseded | reverted" },
+      context_refs: { type: "list", default: [], description: "What informed this decision" },
+      tags: { type: "list", default: [] }
+    }
+  },
+  {
+    name: "lesson",
+    description: "A captured insight or pattern learned from experience.",
+    directory: "lessons",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true },
+      date: { type: "date", required: true },
+      confidence: { type: "string", default: "medium", description: "high | medium | low" },
+      context_refs: { type: "list", default: [] },
+      tags: { type: "list", default: [] }
+    }
+  },
+  {
+    name: "fact",
+    description: "A structured piece of knowledge with optional temporal validity.",
+    directory: "facts",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      subject: { type: "string", required: true },
+      predicate: { type: "string", required: true },
+      object: { type: "string", required: true },
+      confidence: { type: "number", default: 1 },
+      valid_from: { type: "date" },
+      valid_until: { type: "date" },
+      source: { type: "ref", description: "Where this fact came from" }
+    }
+  },
+  {
+    name: "agent",
+    description: "A registered participant in the workgraph.",
+    directory: "agents",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      name: { type: "string", required: true },
+      role: { type: "string", description: "What this agent specializes in" },
+      capabilities: { type: "list", default: [], description: "What this agent can do" },
+      active_threads: { type: "list", default: [], description: "Threads currently claimed" },
+      last_seen: { type: "date" }
+    }
+  }
+];
+function registryPath(vaultPath) {
+  return path.join(vaultPath, REGISTRY_FILE);
+}
+function loadRegistry(vaultPath) {
+  const rPath = registryPath(vaultPath);
+  if (fs.existsSync(rPath)) {
+    const raw = fs.readFileSync(rPath, "utf-8");
+    const registry = JSON.parse(raw);
+    return ensureBuiltIns(registry);
+  }
+  return seedRegistry();
+}
+function saveRegistry(vaultPath, registry) {
+  const rPath = registryPath(vaultPath);
+  const dir = path.dirname(rPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(rPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+function defineType(vaultPath, name, description, fields, actor, directory) {
+  const registry = loadRegistry(vaultPath);
+  const safeName = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  if (registry.types[safeName]?.builtIn) {
+    throw new Error(`Cannot redefine built-in type "${safeName}". You can extend it with new fields instead.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const typeDef = {
+    name: safeName,
+    description,
+    fields: {
+      title: { type: "string", required: true },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true },
+      tags: { type: "list", default: [] },
+      ...fields
+    },
+    directory: directory ?? `${safeName}s`,
+    builtIn: false,
+    createdAt: now,
+    createdBy: actor
+  };
+  registry.types[safeName] = typeDef;
+  saveRegistry(vaultPath, registry);
+  return typeDef;
+}
+function getType(vaultPath, name) {
+  const registry = loadRegistry(vaultPath);
+  return registry.types[name];
+}
+function listTypes(vaultPath) {
+  const registry = loadRegistry(vaultPath);
+  return Object.values(registry.types);
+}
+function extendType(vaultPath, name, newFields, actor) {
+  const registry = loadRegistry(vaultPath);
+  const existing = registry.types[name];
+  if (!existing) throw new Error(`Type "${name}" not found in registry.`);
+  existing.fields = { ...existing.fields, ...newFields };
+  saveRegistry(vaultPath, registry);
+  return existing;
+}
+function seedRegistry() {
+  const types = {};
+  for (const t of BUILT_IN_TYPES) {
+    types[t.name] = t;
+  }
+  return { version: CURRENT_VERSION, types };
+}
+function ensureBuiltIns(registry) {
+  for (const t of BUILT_IN_TYPES) {
+    if (!registry.types[t.name]) {
+      registry.types[t.name] = t;
+    }
+  }
+  return registry;
+}
+
+export {
+  registryPath,
+  loadRegistry,
+  saveRegistry,
+  defineType,
+  getType,
+  listTypes,
+  extendType,
+  registry_exports
+};

package/dist/{chunk-P5EPF6MB.js → chunk-MW5C6ZQA.js}

@@ -4,12 +4,100 @@ import * as path from "path";
 var JSONL_SAMPLE_LIMIT = 20;
 var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
 var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
+var BASE64_DATA_URI_RE = /\bdata:[^;\s]+;base64,[A-Za-z0-9+/=]{24,}\b/gi;
+var LONG_BASE64_TOKEN_RE = /\b[A-Za-z0-9+/]{80,}={0,2}\b/g;
+var STRUCTURED_NOISE_MARKER_RE = /\b(?:tool[_-]?result|tool[_-]?use|toolcallid|tooluseid|function[_-]?(?:call|result)|stdout|stderr|exitcode|recordedat|trace(?:_|-)?id|parent(?:_|-)?id|session(?:_|-)?id|metadata|base64|mime(?:type)?)\b/i;
+var NOISY_PREFIX_RE = /^(?:metadata|system metadata|session metadata)\s*:/i;
+function normalizeToken(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
 function normalizeText(value) {
   return value.replace(/\s+/g, " ").trim();
 }
+function shouldDropRole(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "system" || normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isConversationRolePrefix(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "user" || normalized === "assistant" || normalized === "system") {
+    return true;
+  }
+  if (normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isNoisyBlockType(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = normalizeToken(value);
+  if (!normalized || normalized === "text" || normalized === "markdown") {
+    return false;
+  }
+  return normalized.includes("tool") || normalized.includes("functioncall") || normalized.includes("functionresult") || normalized.includes("thinking") || normalized.includes("reason") || normalized.includes("metadata");
+}
+function stripNoisyData(value) {
+  return normalizeText(
+    value.replace(BASE64_DATA_URI_RE, " ").replace(LONG_BASE64_TOKEN_RE, " ")
+  );
+}
+function isLikelyStructuredNoise(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (NOISY_PREFIX_RE.test(trimmed)) {
+    return true;
+  }
+  const looksStructured = trimmed.startsWith("{") || trimmed.startsWith("[");
+  if (looksStructured && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+    return true;
+  }
+  return false;
+}
+function sanitizeExtractedText(value) {
+  const stripped = stripNoisyData(value);
+  if (!stripped) {
+    return "";
+  }
+  if (isLikelyStructuredNoise(stripped)) {
+    return "";
+  }
+  return stripped;
+}
+function sanitizeParsedMessage(message) {
+  const normalized = normalizeText(message);
+  if (!normalized) {
+    return "";
+  }
+  const roleMatch = /^([a-z][a-z0-9_-]{1,31})\s*:\s*(.+)$/i.exec(normalized);
+  if (roleMatch && isConversationRolePrefix(roleMatch[1])) {
+    const role = normalizeRole(roleMatch[1]);
+    if (shouldDropRole(role)) {
+      return "";
+    }
+    const content = sanitizeExtractedText(roleMatch[2]);
+    if (!content) {
+      return "";
+    }
+    return role ? `${role}: ${content}` : content;
+  }
+  return sanitizeExtractedText(normalized);
+}
 function extractText(value) {
   if (typeof value === "string") {
-    return normalizeText(value);
+    return sanitizeExtractedText(value);
   }
   if (Array.isArray(value)) {
     const parts = [];
@@ -25,11 +113,17 @@ function extractText(value) {
     return "";
   }
   const record = value;
+  if (isNoisyBlockType(record.type)) {
+    return "";
+  }
   if (typeof record.text === "string") {
-    return normalizeText(record.text);
+    return sanitizeExtractedText(record.text);
   }
   if (typeof record.content === "string") {
-    return normalizeText(record.content);
+    return sanitizeExtractedText(record.content);
+  }
+  if (record.content !== void 0) {
+    return extractText(record.content);
   }
   return "";
 }
@@ -69,16 +163,18 @@ function parseJsonLine(line) {
   const entry = parsed;
   if ("role" in entry && "content" in entry) {
     const role = normalizeRole(entry.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(entry.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message;
     const role = normalizeRole(message.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(message.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   return "";
 }
@@ -119,17 +215,21 @@ function parseMarkdown(raw) {
     if (roleMatch) {
       const role = normalizeRole(roleMatch[1]);
       const content = normalizeText(roleMatch[2]);
-      if (content) {
-        messages.push(`${role}: ${content}`);
+      const parsed2 = sanitizeParsedMessage(`${role}: ${content}`);
+      if (parsed2) {
+        messages.push(parsed2);
       }
       continue;
     }
-    messages.push(joined);
+    const parsed = sanitizeParsedMessage(joined);
+    if (parsed) {
+      messages.push(parsed);
+    }
   }
   return messages;
 }
 function parsePlainText(raw) {
-  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
+  return raw.split(/\r?\n/).map((line) => sanitizeParsedMessage(line)).filter(Boolean);
 }
 function detectSessionFormat(raw, filePath) {
   const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -163,10 +263,7 @@ function parseSessionFile(filePath) {
   const raw = fs.readFileSync(resolved, "utf-8");
   const format = detectSessionFormat(raw, resolved);
   if (format === "jsonl") {
-    const parsed = parseJsonLines(raw);
-    if (parsed.length > 0) {
-      return parsed;
-    }
+    return parseJsonLines(raw);
   }
   if (format === "markdown") {
     const parsed = parseMarkdown(raw);