clawvault 3.1.0 → 3.2.1

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-H34S76MB.js → chunk-MNPUYCHQ.js}

@@ -1,14 +1,14 @@
+import {
+  normalizeObservationContent,
+  parseObservationMarkdown
+} from "./chunk-FHFUXL6G.js";
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-E7MFQB6D.js";
+} from "./chunk-YXQCA6B7.js";
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";
-import {
-  normalizeObservationContent,
-  parseObservationMarkdown
-} from "./chunk-QK3UCXWL.js";
 import {
   formatIsoWeekKey,
   getIsoWeek,
@@ -213,7 +213,7 @@ function promoteWeekRecords(records) {
   return promoted;
 }
 async function maybeGenerateLlmReflection(weekKey, sections) {
-  const provider = await resolveLlmProvider();
+  const provider = resolveLlmProvider();
   if (!provider) {
     return null;
   }

package/dist/chunk-NTOPJI7W.js

@@ -0,0 +1,207 @@
+import {
+  __export
+} from "./chunk-U67V476Y.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-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-PG56HX5T.js

@@ -0,0 +1,154 @@
+// src/lib/hybrid-search.ts
+import * as fs from "fs";
+import * as path from "path";
+var embeddingPipeline = null;
+var pipelineLoading = null;
+async function getEmbeddingPipeline() {
+  if (embeddingPipeline) return embeddingPipeline;
+  if (pipelineLoading) return pipelineLoading;
+  pipelineLoading = (async () => {
+    const { pipeline } = await import("@huggingface/transformers");
+    embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+      dtype: "fp32"
+    });
+    return embeddingPipeline;
+  })();
+  return pipelineLoading;
+}
+async function embed(text) {
+  const pipe = await getEmbeddingPipeline();
+  const result = await pipe(text, { pooling: "mean", normalize: true });
+  return new Float32Array(result.data);
+}
+async function embedBatch(texts) {
+  const pipe = await getEmbeddingPipeline();
+  const results = [];
+  const batchSize = 32;
+  for (let i = 0; i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    for (const text of batch) {
+      const result = await pipe(text, { pooling: "mean", normalize: true });
+      results.push(new Float32Array(result.data));
+    }
+  }
+  return results;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+var EmbeddingCache = class {
+  cachePath;
+  cache = /* @__PURE__ */ new Map();
+  dirty = false;
+  constructor(vaultPath) {
+    this.cachePath = path.join(vaultPath, ".clawvault", "embeddings.bin");
+  }
+  /**
+   * Load cache from disk
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.cachePath)) return;
+      const data = JSON.parse(fs.readFileSync(this.cachePath + ".json", "utf-8"));
+      for (const [key, arr] of Object.entries(data)) {
+        this.cache.set(key, new Float32Array(arr));
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save cache to disk
+   */
+  save() {
+    if (!this.dirty) return;
+    const dir = path.dirname(this.cachePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const data = {};
+    for (const [key, arr] of this.cache.entries()) {
+      data[key] = Array.from(arr);
+    }
+    fs.writeFileSync(this.cachePath + ".json", JSON.stringify(data));
+    this.dirty = false;
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, embedding) {
+    this.cache.set(key, embedding);
+    this.dirty = true;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+function reciprocalRankFusion(list1, list2, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let rank = 0; rank < list1.length; rank++) {
+    const { id } = list1[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  for (let rank = 0; rank < list2.length; rank++) {
+    const { id } = list2[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  return Array.from(scores.entries()).map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
+}
+async function semanticSearch(query, cache, topK = 20) {
+  const queryEmb = await embed(query);
+  const results = [];
+  for (const [id, docEmb] of cache.entries()) {
+    results.push({ id, score: cosineSimilarity(queryEmb, docEmb) });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+async function hybridSearch(query, bm25Results, cache, options = {}) {
+  const { topK = 20, rrfK = 60 } = options;
+  const bm25Ranked = bm25Results.map((r) => ({ id: r.document.path || r.document.id, score: r.score }));
+  const semanticRanked = await semanticSearch(query, cache, topK);
+  const fused = reciprocalRankFusion(bm25Ranked, semanticRanked, rrfK);
+  const bm25Map = new Map(bm25Results.map((r) => [r.document.path || r.document.id, r]));
+  return fused.slice(0, topK).map(({ id, score }) => {
+    const existing = bm25Map.get(id);
+    if (existing) {
+      return { ...existing, score };
+    }
+    const minimalDoc = {
+      id: id.replace(/\.md$/, ""),
+      path: id.endsWith(".md") ? id : id + ".md",
+      title: (id.split("/").pop() || id).replace(/\.md$/, ""),
+      content: "",
+      category: id.split("/")[0] || "root",
+      frontmatter: {},
+      links: [],
+      tags: [],
+      modified: /* @__PURE__ */ new Date()
+    };
+    return {
+      document: minimalDoc,
+      score,
+      snippet: "",
+      matchedTerms: []
+    };
+  });
+}
+
+export {
+  embed,
+  embedBatch,
+  cosineSimilarity,
+  EmbeddingCache,
+  reciprocalRankFusion,
+  semanticSearch,
+  hybridSearch
+};