clawvault 3.2.1 → 3.4.0

package/dist/chunk-HR4KN6S2.js

@@ -1,152 +0,0 @@
-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-IJBFGPCS.js

@@ -1,33 +0,0 @@
-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
-};

package/dist/chunk-K7PNYS45.js

@@ -1,93 +0,0 @@
-import {
-  __export
-} from "./chunk-U67V476Y.js";
-
-// src/workgraph/ledger.ts
-var ledger_exports = {};
-__export(ledger_exports, {
-  activityOf: () => activityOf,
-  allClaims: () => allClaims,
-  append: () => append,
-  currentOwner: () => currentOwner,
-  historyOf: () => historyOf,
-  isClaimed: () => isClaimed,
-  ledgerPath: () => ledgerPath,
-  readAll: () => readAll,
-  readSince: () => readSince,
-  recent: () => recent
-});
-import fs from "fs";
-import path from "path";
-var LEDGER_FILE = ".clawvault/ledger.jsonl";
-function ledgerPath(vaultPath) {
-  return path.join(vaultPath, LEDGER_FILE);
-}
-function append(vaultPath, actor, op, target, type, data) {
-  const entry = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    actor,
-    op,
-    target,
-    ...type ? { type } : {},
-    ...data && Object.keys(data).length > 0 ? { data } : {}
-  };
-  const lPath = ledgerPath(vaultPath);
-  const dir = path.dirname(lPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(lPath, JSON.stringify(entry) + "\n", "utf-8");
-  return entry;
-}
-function readAll(vaultPath) {
-  const lPath = ledgerPath(vaultPath);
-  if (!fs.existsSync(lPath)) return [];
-  const lines = fs.readFileSync(lPath, "utf-8").split("\n").filter(Boolean);
-  return lines.map((line) => JSON.parse(line));
-}
-function readSince(vaultPath, since) {
-  return readAll(vaultPath).filter((e) => e.ts >= since);
-}
-function currentOwner(vaultPath, target) {
-  const entries = readAll(vaultPath).filter((e) => e.target === target);
-  let owner = null;
-  for (const e of entries) {
-    if (e.op === "claim") owner = e.actor;
-    if (e.op === "release" || e.op === "done" || e.op === "cancel") owner = null;
-  }
-  return owner;
-}
-function isClaimed(vaultPath, target) {
-  return currentOwner(vaultPath, target) !== null;
-}
-function historyOf(vaultPath, target) {
-  return readAll(vaultPath).filter((e) => e.target === target);
-}
-function activityOf(vaultPath, actor) {
-  return readAll(vaultPath).filter((e) => e.actor === actor);
-}
-function allClaims(vaultPath) {
-  const claims = /* @__PURE__ */ new Map();
-  const entries = readAll(vaultPath);
-  for (const e of entries) {
-    if (e.op === "claim") claims.set(e.target, e.actor);
-    if (e.op === "release" || e.op === "done" || e.op === "cancel") claims.delete(e.target);
-  }
-  return claims;
-}
-function recent(vaultPath, count = 20) {
-  const all = readAll(vaultPath);
-  return all.slice(-count);
-}
-
-export {
-  ledgerPath,
-  append,
-  readAll,
-  readSince,
-  currentOwner,
-  isClaimed,
-  historyOf,
-  activityOf,
-  allClaims,
-  recent,
-  ledger_exports
-};

package/dist/chunk-NTOPJI7W.js

@@ -1,207 +0,0 @@
-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-PG56HX5T.js

@@ -1,154 +0,0 @@
-// 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
-};