clawvault 3.2.0 → 3.3.0

package/dist/chunk-H3JZIB5O.js

@@ -0,0 +1,322 @@
+// src/lib/embedding-store.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var CACHE_DIR = ".clawvault";
+var CACHE_FILE = "embeddings.bin.json";
+var LEGACY_BIN_FILE = "embeddings.bin";
+var EmbeddingStore = class {
+  vaultPath;
+  provider = "none";
+  model = "";
+  vectors = /* @__PURE__ */ new Map();
+  dirty = false;
+  constructor(vaultPath) {
+    this.vaultPath = path.resolve(vaultPath);
+  }
+  setVaultPath(vaultPath) {
+    this.vaultPath = path.resolve(vaultPath);
+  }
+  setSignature(provider, model) {
+    if (this.provider !== provider || this.model !== model) {
+      this.provider = provider;
+      this.model = model;
+      this.dirty = true;
+    }
+  }
+  getSignature() {
+    return { provider: this.provider, model: this.model };
+  }
+  isCompatible(provider, model) {
+    if (this.provider === "none" || !this.model) {
+      return this.vectors.size === 0;
+    }
+    return this.provider === provider && this.model === model;
+  }
+  load() {
+    this.vectors.clear();
+    const cachePath = this.getCachePath();
+    if (!fs.existsSync(cachePath)) {
+      return;
+    }
+    try {
+      const raw = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+      if ("version" in raw && "vectors" in raw) {
+        this.provider = typeof raw.provider === "string" ? raw.provider : "none";
+        this.model = typeof raw.model === "string" ? raw.model : "";
+        for (const [docId, value] of Object.entries(raw.vectors)) {
+          if (Array.isArray(value)) {
+            this.vectors.set(docId, {
+              hash: "",
+              embedding: new Float32Array(value)
+            });
+            continue;
+          }
+          if (!value || !Array.isArray(value.embedding)) {
+            continue;
+          }
+          this.vectors.set(docId, {
+            hash: typeof value.hash === "string" ? value.hash : "",
+            embedding: new Float32Array(value.embedding)
+          });
+        }
+      } else {
+        this.provider = "none";
+        this.model = "";
+        for (const [docId, embedding] of Object.entries(raw)) {
+          if (Array.isArray(embedding)) {
+            this.vectors.set(docId, {
+              hash: "",
+              embedding: new Float32Array(embedding)
+            });
+          }
+        }
+      }
+      this.dirty = false;
+    } catch {
+      this.provider = "none";
+      this.model = "";
+      this.vectors.clear();
+      this.dirty = false;
+    }
+  }
+  save() {
+    if (!this.dirty) return;
+    const cacheDir = path.dirname(this.getCachePath());
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const vectors = {};
+    for (const [docId, entry] of this.vectors.entries()) {
+      vectors[docId] = {
+        hash: entry.hash,
+        embedding: Array.from(entry.embedding)
+      };
+    }
+    const payload = {
+      version: 2,
+      provider: this.provider,
+      model: this.model,
+      vectors
+    };
+    fs.writeFileSync(this.getCachePath(), JSON.stringify(payload));
+    const legacyBinPath = path.join(cacheDir, LEGACY_BIN_FILE);
+    if (!fs.existsSync(legacyBinPath)) {
+      fs.writeFileSync(legacyBinPath, "");
+    }
+    this.dirty = false;
+  }
+  get(docId) {
+    return this.vectors.get(docId)?.embedding;
+  }
+  getHash(docId) {
+    return this.vectors.get(docId)?.hash;
+  }
+  set(docId, hash, embedding) {
+    this.vectors.set(docId, { hash, embedding });
+    this.dirty = true;
+  }
+  has(docId) {
+    return this.vectors.has(docId);
+  }
+  delete(docId) {
+    if (this.vectors.delete(docId)) {
+      this.dirty = true;
+    }
+  }
+  prune(validDocIds) {
+    let removedAny = false;
+    for (const key of this.vectors.keys()) {
+      if (!validDocIds.has(key)) {
+        this.vectors.delete(key);
+        removedAny = true;
+      }
+    }
+    if (removedAny) {
+      this.dirty = true;
+    }
+  }
+  entries() {
+    const pairs = Array.from(this.vectors.entries()).map(([id, entry]) => [id, entry.embedding]);
+    return pairs[Symbol.iterator]();
+  }
+  get size() {
+    return this.vectors.size;
+  }
+  clear() {
+    if (this.vectors.size === 0) return;
+    this.vectors.clear();
+    this.dirty = true;
+  }
+  getCachePath() {
+    return path.join(this.vaultPath, CACHE_DIR, CACHE_FILE);
+  }
+};
+function computeEmbeddingHash(text) {
+  return crypto.createHash("sha1").update(text).digest("hex");
+}
+
+// src/lib/hosted-embeddings.ts
+var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
+var DEFAULT_GEMINI_MODEL = "text-embedding-004";
+var DEFAULT_OLLAMA_MODEL = "nomic-embed-text";
+function normalizeBaseUrl(url) {
+  return url.replace(/\/+$/, "");
+}
+function toFloat32(values) {
+  if (!Array.isArray(values)) {
+    throw new Error("Embedding response did not contain a numeric vector.");
+  }
+  return new Float32Array(values.map((value) => Number(value)));
+}
+function resolveApiKey(provider, configuredApiKey) {
+  if (configuredApiKey?.trim()) return configuredApiKey.trim();
+  if (provider === "openai") return process.env.OPENAI_API_KEY?.trim();
+  if (provider === "gemini") return process.env.GEMINI_API_KEY?.trim() || process.env.GOOGLE_API_KEY?.trim();
+  return void 0;
+}
+function resolveEmbeddingConfig(searchConfig) {
+  const provider = searchConfig?.embeddings?.provider ?? "none";
+  if (provider === "none") {
+    return null;
+  }
+  if (provider === "openai") {
+    return {
+      provider,
+      model: searchConfig?.embeddings?.model?.trim() || DEFAULT_OPENAI_MODEL,
+      baseUrl: normalizeBaseUrl(searchConfig?.embeddings?.baseUrl?.trim() || "https://api.openai.com/v1"),
+      apiKey: resolveApiKey(provider, searchConfig?.embeddings?.apiKey)
+    };
+  }
+  if (provider === "gemini") {
+    return {
+      provider,
+      model: searchConfig?.embeddings?.model?.trim() || DEFAULT_GEMINI_MODEL,
+      baseUrl: normalizeBaseUrl(searchConfig?.embeddings?.baseUrl?.trim() || "https://generativelanguage.googleapis.com/v1beta"),
+      apiKey: resolveApiKey(provider, searchConfig?.embeddings?.apiKey)
+    };
+  }
+  return {
+    provider,
+    model: searchConfig?.embeddings?.model?.trim() || DEFAULT_OLLAMA_MODEL,
+    baseUrl: normalizeBaseUrl(searchConfig?.embeddings?.baseUrl?.trim() || "http://127.0.0.1:11434")
+  };
+}
+async function openAiEmbed(text, config) {
+  if (!config.apiKey) {
+    throw new Error("OpenAI embeddings require an API key (search.embeddings.apiKey or OPENAI_API_KEY).");
+  }
+  const response = await fetch(`${config.baseUrl}/embeddings`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      input: text
+    }),
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI embedding request failed with status ${response.status}.`);
+  }
+  const payload = await response.json();
+  return toFloat32(payload.data?.[0]?.embedding);
+}
+function geminiModelPath(model) {
+  return model.startsWith("models/") ? model : `models/${model}`;
+}
+async function geminiEmbed(text, config, isQuery) {
+  if (!config.apiKey) {
+    throw new Error("Gemini embeddings require an API key (search.embeddings.apiKey, GEMINI_API_KEY, or GOOGLE_API_KEY).");
+  }
+  const response = await fetch(`${config.baseUrl}/${geminiModelPath(config.model)}:embedContent`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-goog-api-key": config.apiKey
+    },
+    body: JSON.stringify({
+      content: {
+        parts: [{ text }]
+      },
+      taskType: isQuery ? "RETRIEVAL_QUERY" : "RETRIEVAL_DOCUMENT"
+    }),
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (!response.ok) {
+    throw new Error(`Gemini embedding request failed with status ${response.status}.`);
+  }
+  const payload = await response.json();
+  const values = payload.embedding?.values ?? payload.embeddings?.[0]?.values;
+  return toFloat32(values);
+}
+async function ollamaEmbed(text, config) {
+  const primary = await fetch(`${config.baseUrl}/api/embed`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: config.model,
+      input: text
+    }),
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (primary.ok) {
+    const payload2 = await primary.json();
+    return toFloat32(payload2.embeddings?.[0]);
+  }
+  const fallback = await fetch(`${config.baseUrl}/api/embeddings`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: config.model,
+      prompt: text
+    }),
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (!fallback.ok) {
+    throw new Error(`Ollama embedding request failed with status ${fallback.status}.`);
+  }
+  const payload = await fallback.json();
+  return toFloat32(payload.embedding);
+}
+async function embedText(text, config, options = {}) {
+  const normalized = text.trim();
+  if (!normalized) {
+    throw new Error("Cannot embed empty text.");
+  }
+  const truncated = normalized.slice(0, 12e3);
+  if (config.provider === "openai") {
+    return openAiEmbed(truncated, config);
+  }
+  if (config.provider === "gemini") {
+    return geminiEmbed(truncated, config, options.isQuery ?? false);
+  }
+  return ollamaEmbed(truncated, config);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) {
+    return 0;
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    const av = a[index];
+    const bv = b[index];
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA === 0 || normB === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+export {
+  EmbeddingStore,
+  computeEmbeddingHash,
+  resolveEmbeddingConfig,
+  embedText,
+  cosineSimilarity
+};

package/dist/chunk-HEHO7SMV.js

@@ -0,0 +1,51 @@
+import {
+  addInboxItem
+} from "./chunk-2PKBIKDH.js";
+import {
+  resolveVaultPath
+} from "./chunk-GJO3CFUN.js";
+
+// src/commands/inbox.ts
+import * as fs from "fs";
+function resolveInboxContent(options) {
+  const inline = options.content?.trim();
+  if (inline) {
+    return inline;
+  }
+  if (options.stdin) {
+    const reader = options.readStdin ?? (() => fs.readFileSync(0, "utf-8"));
+    const stdinContent = reader().trim();
+    if (stdinContent) {
+      return stdinContent;
+    }
+  }
+  throw new Error("Inbox content is required. Provide <content> or pipe stdin.");
+}
+async function inboxAddCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const content = resolveInboxContent(options);
+  const result = addInboxItem(vaultPath, content, {
+    title: options.title,
+    source: options.source
+  });
+  console.log(`\u2713 Added inbox capture: ${result.id}`);
+  console.log(`  Path: ${result.path}`);
+  return result;
+}
+function registerInboxCommand(program) {
+  const inbox = program.command("inbox").description("Manage raw captures in the vault inbox");
+  inbox.command("add [content]").description("Add content to inbox (or pipe stdin)").option("-t, --title <title>", "Optional capture title").option("--source <source>", "Source label (email, transcript, note, export, etc.)").option("--stdin", "Read content from stdin").option("-v, --vault <path>", "Vault path").action(async (content, rawOptions) => {
+    await inboxAddCommand({
+      vaultPath: rawOptions.vault,
+      content,
+      title: rawOptions.title,
+      source: rawOptions.source,
+      stdin: rawOptions.stdin || !process.stdin.isTTY
+    });
+  });
+}
+
+export {
+  inboxAddCommand,
+  registerInboxCommand
+};

package/dist/{chunk-STCQGCEQ.js → chunk-HGDDW24U.js}

@@ -1,12 +1,12 @@
 import {
   runReflection
-} from "./chunk-ESVS6K2B.js";
+} from "./chunk-TWMI3SNN.js";
 import {
   Observer
-} from "./chunk-77Q5CSPJ.js";
+} from "./chunk-7SWP5FKU.js";
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 
 // src/commands/replay.ts
 import * as fs from "fs";