@hivelore/embeddings 0.30.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hivelore contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+<p align="center">
+  <a href="https://github.com/Doucs91/hivelore">
+    <img src="https://raw.githubusercontent.com/Doucs91/hivelore/main/packages/vscode/media/logo.svg" alt="Hivelore logo" width="96" />
+  </a>
+</p>
+
+# @hivelore/embeddings
+
+> **Optional add-on for Hivelore** — local semantic ranking for Hivelore briefings and memory search. No data leaves your machine.
+
+When installed alongside `@hivelore/cli`, this package helps Hivelore surface the right policy context even when the agent's task wording does not match your memories exactly. It improves `get_briefing`, `mem_relevant_to`, and `mem_search`; it is not required for enforcement.
+
+---
+
+## Why optional?
+
+This package pulls in heavy ML dependencies (`@xenova/transformers`, `onnxruntime-node`, `sharp`) and downloads a ~110MB model on first use. It is **not installed by default** so that the core Hivelore experience stays lightweight.
+
+Install it explicitly when you want semantic search:
+
+```bash
+npm install -g @hivelore/embeddings
+# or alongside the CLI:
+npm install -g @hivelore/cli @hivelore/embeddings
+```
+
+---
+
+## Quick start
+
+```bash
+# Build (or refresh) the index. First run downloads the model (~110MB, cached locally).
+hivelore embeddings index
+
+# Check index status
+hivelore embeddings status
+
+# Run a semantic search from the terminal
+hivelore embeddings query "how do we handle retries on payment failures"
+```
+
+From an MCP client, pass `semantic: true` to `mem_search` or `get_briefing`:
+
+```json
+{ "task": "add a mobile payment provider", "semantic": true }
+```
+
+---
+
+## Commands
+
+### `hivelore embeddings index`
+
+Build or refresh the embeddings index for all memories.
+
+```bash
+hivelore embeddings index              # Index all memories in the current project
+hivelore embeddings index --dir /path  # Specify project root
+hivelore embeddings index --force      # Force full rebuild (ignore content hashes)
+```
+
+The index is stored at `.ai/.cache/embeddings/embeddings-index.json`. Each entry is keyed by content hash, so only changed memories are re-embedded on subsequent runs.
+
+### `hivelore embeddings status`
+
+Show the current state of the embeddings index.
+
+```bash
+hivelore embeddings status
+# Output:
+# Index: .ai/.cache/embeddings/embeddings-index.json
+# Entries: 24
+# Model: Xenova/bge-small-en-v1.5 (384 dimensions)
+# Last updated: 2025-01-20T14:32:00Z
+```
+
+### `hivelore embeddings query`
+
+Run a semantic query against the local index.
+
+```bash
+hivelore embeddings query "payment retry logic"
+hivelore embeddings query "JWT expiration handling" --limit 5
+hivelore embeddings query "database migration" --dir /path/to/project
+```
+
+---
+
+## How it works
+
+1. **Model**: [`Xenova/bge-small-en-v1.5`](https://huggingface.co/BAAI/bge-small-en-v1.5) — a 33M-parameter sentence embedding model, 384 dimensions, optimized for retrieval tasks. Downloaded once and cached in `~/.cache/huggingface/` (or `TRANSFORMERS_CACHE`).
+
+2. **Indexing**: Each memory's body is converted to a 384-dimensional vector and stored alongside its id and content hash.
+
+3. **Search**: At query time, the query text is embedded and cosine similarity is computed against all indexed memories. The top-k results are returned ranked by score.
+
+4. **Integration**: When `@hivelore/embeddings` is installed and the index exists, `get_briefing` and `mem_search` automatically use semantic ranking. If the package is missing or the index is empty, they fall back to literal (keyword) search transparently.
+
+---
+
+## Auto-rebuild on sync
+
+Add `--embed` to `hivelore sync` to automatically rebuild the index after every sync:
+
+```bash
+hivelore sync --embed
+
+# Or in your git hook / CI:
+hivelore sync --quiet --embed
+```
+
+---
+
+## Programmatic API
+
+```typescript
+import { rebuildIndex, semanticSearch } from "@hivelore/embeddings";
+import { resolveHaivePaths, findProjectRoot } from "@hivelore/core";
+
+const paths = resolveHaivePaths(findProjectRoot());
+
+// Rebuild the full index
+const report = await rebuildIndex(paths);
+// report.added, report.updated, report.removed, report.skipped
+
+// Search
+const result = await semanticSearch(paths, "payment retry logic", { limit: 5 });
+if (result) {
+  for (const hit of result.hits) {
+    console.log(hit.id, hit.score); // score: 0.0–1.0
+  }
+}
+
+// Custom embedder (for testing or alternative models)
+import { Embedder, type EmbedderLike } from "@hivelore/embeddings";
+
+const embedder: EmbedderLike = {
+  model: "Xenova/bge-small-en-v1.5",
+  dimension: 384,
+  encode: async (texts) => { /* ... */ return [[0.1, 0.2, ...]]; },
+};
+```
+
+---
+
+## Privacy
+
+- The model runs **entirely locally** via [Transformers.js](https://huggingface.co/docs/transformers.js) + ONNX Runtime.
+- No API keys required.
+- No network calls during search or indexing (only on first model download).
+- Memory content never leaves your machine.
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { HaivePaths } from '@hivelore/core';
+
+declare const DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+declare const DEFAULT_DIMENSION = 384;
+interface EmbedderLike {
+    readonly model: string;
+    readonly dimension: number;
+    encode(text: string): Promise<Float32Array>;
+}
+declare class Embedder implements EmbedderLike {
+    private readonly pipe;
+    readonly model: string;
+    readonly dimension: number;
+    private constructor();
+    static create(model?: string): Promise<Embedder>;
+    encode(text: string): Promise<Float32Array>;
+    encodeMany(texts: string[]): Promise<Float32Array[]>;
+}
+declare function cosine(a: Float32Array | number[], b: Float32Array | number[]): number;
+
+interface EmbeddingEntry {
+    id: string;
+    file_path: string;
+    hash: string;
+    vector: number[];
+}
+interface EmbeddingIndex {
+    model: string;
+    dimension: number;
+    updated_at: string;
+    entries: EmbeddingEntry[];
+}
+declare function cacheDir(paths: HaivePaths): string;
+declare function indexPath(paths: HaivePaths): string;
+declare function hashContent(text: string): string;
+declare function emptyIndex(model?: string, dimension?: number): EmbeddingIndex;
+declare function loadIndex(paths: HaivePaths): Promise<EmbeddingIndex | null>;
+declare function saveIndex(paths: HaivePaths, index: EmbeddingIndex): Promise<void>;
+declare function indexStat(paths: HaivePaths): Promise<{
+    exists: boolean;
+    count: number;
+    model: string | null;
+    updatedAt: string | null;
+    sizeBytes: number;
+}>;
+declare function buildEntryText(id: string, tags: string[], body: string): string;
+
+interface IndexUpdateReport {
+    total: number;
+    added: number;
+    updated: number;
+    unchanged: number;
+    removed: number;
+}
+declare function rebuildIndex(paths: HaivePaths, embedder: EmbedderLike): Promise<{
+    index: EmbeddingIndex;
+    report: IndexUpdateReport;
+}>;
+
+interface SemanticHit {
+    id: string;
+    file_path: string;
+    score: number;
+}
+declare function semanticSearch(paths: HaivePaths, query: string, options?: {
+    limit?: number;
+    minScore?: number;
+    embedder?: EmbedderLike;
+    index?: EmbeddingIndex;
+}): Promise<{
+    hits: SemanticHit[];
+    index: EmbeddingIndex;
+} | null>;
+
+interface CodeEmbeddingEntry {
+    /** stable id: `${file}#${name}` */
+    id: string;
+    file: string;
+    name: string;
+    kind: string;
+    line: number;
+    description?: string;
+    hash: string;
+    vector: number[];
+}
+interface CodeEmbeddingIndex {
+    model: string;
+    dimension: number;
+    updated_at: string;
+    source_generated_at: string;
+    entries: CodeEmbeddingEntry[];
+}
+declare function codeIndexPath(paths: HaivePaths): string;
+/**
+ * Is the code-search embeddings index stale relative to the current code-map?
+ * The indexer stamps `source_generated_at` with the code-map's `generated_at` it was built from,
+ * so a mismatch means the code-map was rebuilt afterwards and the index may miss or mislocate symbols.
+ * Unknown timestamps (empty strings) are treated as not-stale to avoid false alarms.
+ */
+declare function isCodeIndexStale(indexSourceGeneratedAt: string, codeMapGeneratedAt: string): boolean;
+declare function emptyCodeIndex(model?: string, dimension?: number, sourceGeneratedAt?: string): CodeEmbeddingIndex;
+declare function loadCodeIndex(paths: HaivePaths): Promise<CodeEmbeddingIndex | null>;
+declare function saveCodeIndex(paths: HaivePaths, index: CodeEmbeddingIndex): Promise<void>;
+declare function buildCodeEntryText(file: string, name: string, kind: string, description?: string): string;
+
+interface CodeIndexUpdateReport {
+    total: number;
+    added: number;
+    updated: number;
+    unchanged: number;
+    removed: number;
+}
+/**
+ * Build (or refresh) the code semantic-search index from the code-map.
+ * Each exported symbol becomes one embedding entry — granularity stays at the
+ * symbol level so search returns a precise file:line:name target.
+ *
+ * Re-uses entries whose embedded text is unchanged (hash check) so subsequent
+ * builds only embed the diff.
+ */
+declare function rebuildCodeIndex(paths: HaivePaths, embedder: EmbedderLike): Promise<{
+    index: CodeEmbeddingIndex;
+    report: CodeIndexUpdateReport;
+}>;
+
+interface CodeSearchHit {
+    file: string;
+    name: string;
+    kind: string;
+    line: number;
+    description?: string;
+    score: number;
+}
+declare function codeSemanticSearch(paths: HaivePaths, query: string, options?: {
+    limit?: number;
+    minScore?: number;
+    embedder?: EmbedderLike;
+    index?: CodeEmbeddingIndex;
+}): Promise<{
+    hits: CodeSearchHit[];
+    index: CodeEmbeddingIndex;
+} | null>;
+
+export { type CodeEmbeddingEntry, type CodeEmbeddingIndex, type CodeIndexUpdateReport, type CodeSearchHit, DEFAULT_DIMENSION, DEFAULT_MODEL, Embedder, type EmbedderLike, type EmbeddingEntry, type EmbeddingIndex, type IndexUpdateReport, type SemanticHit, buildCodeEntryText, buildEntryText, cacheDir, codeIndexPath, codeSemanticSearch, cosine, emptyCodeIndex, emptyIndex, hashContent, indexPath, indexStat, isCodeIndexStale, loadCodeIndex, loadIndex, rebuildCodeIndex, rebuildIndex, saveCodeIndex, saveIndex, semanticSearch };

package/dist/index.js

@@ -0,0 +1,366 @@
+// src/embedder.ts
+var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+var DEFAULT_DIMENSION = 384;
+var cachedPipeline = null;
+var cachedModel = null;
+var cachedEmbedders = /* @__PURE__ */ new Map();
+async function loadPipeline(model) {
+  if (cachedPipeline && cachedModel === model) return cachedPipeline;
+  const { pipeline, env } = await import("@xenova/transformers");
+  env.allowLocalModels = true;
+  env.allowRemoteModels = true;
+  const pipe = await pipeline("feature-extraction", model);
+  cachedPipeline = pipe;
+  cachedModel = model;
+  return pipe;
+}
+var Embedder = class _Embedder {
+  constructor(pipe, model, dimension) {
+    this.pipe = pipe;
+    this.model = model;
+    this.dimension = dimension;
+  }
+  pipe;
+  model;
+  dimension;
+  static async create(model = DEFAULT_MODEL) {
+    const cached = cachedEmbedders.get(model);
+    if (cached) return cached;
+    const pipe = await loadPipeline(model);
+    const probe = await pipe("dimension probe", { pooling: "mean", normalize: true });
+    const dim = probe.data instanceof Float32Array ? probe.data.length : probe.data.length;
+    const embedder = new _Embedder(pipe, model, dim);
+    cachedEmbedders.set(model, embedder);
+    return embedder;
+  }
+  async encode(text) {
+    const result = await this.pipe(text, { pooling: "mean", normalize: true });
+    return result.data instanceof Float32Array ? result.data : Float32Array.from(result.data);
+  }
+  async encodeMany(texts) {
+    const out = [];
+    for (const t of texts) {
+      out.push(await this.encode(t));
+    }
+    return out;
+  }
+};
+function cosine(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const av = a[i];
+    const bv = b[i];
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+// src/index-cache.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+var INDEX_FILE = "embeddings-index.json";
+function cacheDir(paths) {
+  return path.join(paths.haiveDir, ".cache", "embeddings");
+}
+function indexPath(paths) {
+  return path.join(cacheDir(paths), INDEX_FILE);
+}
+function hashContent(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function emptyIndex(model = DEFAULT_MODEL, dimension = DEFAULT_DIMENSION) {
+  return {
+    model,
+    dimension,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: []
+  };
+}
+async function loadIndex(paths) {
+  const file = indexPath(paths);
+  if (!existsSync(file)) return null;
+  const raw = await readFile(file, "utf8");
+  return JSON.parse(raw);
+}
+async function saveIndex(paths, index) {
+  const dir = cacheDir(paths);
+  await mkdir(dir, { recursive: true });
+  index.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(indexPath(paths), JSON.stringify(index, null, 2), "utf8");
+}
+async function indexStat(paths) {
+  const file = indexPath(paths);
+  if (!existsSync(file)) {
+    return { exists: false, count: 0, model: null, updatedAt: null, sizeBytes: 0 };
+  }
+  const idx = await loadIndex(paths);
+  const st = await stat(file);
+  return {
+    exists: true,
+    count: idx?.entries.length ?? 0,
+    model: idx?.model ?? null,
+    updatedAt: idx?.updated_at ?? null,
+    sizeBytes: st.size
+  };
+}
+function buildEntryText(id, tags, body) {
+  const tagPart = tags.length ? `${tags.join(" ")} ${tags.join(" ")} ` : "";
+  return `${id} ${tagPart}${body}`;
+}
+
+// src/indexer.ts
+import { loadMemoriesFromDir } from "@hivelore/core";
+async function rebuildIndex(paths, embedder) {
+  const existing = await loadIndex(paths) ?? emptyIndex(embedder.model, embedder.dimension);
+  if (existing.model !== embedder.model || existing.dimension !== embedder.dimension) {
+    existing.entries = [];
+    existing.model = embedder.model;
+    existing.dimension = embedder.dimension;
+  }
+  const memories = await loadMemoriesFromDir(paths.memoriesDir);
+  const byId = new Map(existing.entries.map((e) => [e.id, e]));
+  const seenIds = /* @__PURE__ */ new Set();
+  let added = 0;
+  let updated = 0;
+  let unchanged = 0;
+  const nextEntries = [];
+  for (const { memory, filePath } of memories) {
+    const id = memory.frontmatter.id;
+    seenIds.add(id);
+    const text = buildEntryText(id, memory.frontmatter.tags, memory.body);
+    const hash = hashContent(text);
+    const prior = byId.get(id);
+    if (prior && prior.hash === hash) {
+      nextEntries.push({ ...prior, file_path: filePath });
+      unchanged++;
+      continue;
+    }
+    const vector = Array.from(await embedder.encode(text));
+    nextEntries.push({ id, file_path: filePath, hash, vector });
+    if (prior) {
+      updated++;
+    } else {
+      added++;
+    }
+  }
+  const removed = existing.entries.filter((e) => !seenIds.has(e.id)).length;
+  existing.entries = nextEntries;
+  await saveIndex(paths, existing);
+  return {
+    index: existing,
+    report: {
+      total: nextEntries.length,
+      added,
+      updated,
+      unchanged,
+      removed
+    }
+  };
+}
+
+// src/search.ts
+async function semanticSearch(paths, query, options = {}) {
+  const index = options.index ?? await loadIndex(paths);
+  if (!index || index.entries.length === 0) return null;
+  const embedder = options.embedder ?? await Embedder.create(index.model);
+  if (embedder.dimension !== index.dimension) {
+    throw new Error(
+      `Embedder dimension (${embedder.dimension}) differs from index (${index.dimension}). Re-run \`hivelore embeddings index\`.`
+    );
+  }
+  const queryVec = await embedder.encode(query);
+  const minScore = options.minScore ?? 0;
+  const limit = options.limit ?? 10;
+  const scored = index.entries.map((e) => ({ id: e.id, file_path: e.file_path, score: cosine(queryVec, e.vector) })).filter((h) => h.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  return { hits: scored, index };
+}
+
+// src/code-index-cache.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+var CODE_INDEX_FILE = "code-embeddings-index.json";
+function codeIndexPath(paths) {
+  return path2.join(cacheDir(paths), CODE_INDEX_FILE);
+}
+function isCodeIndexStale(indexSourceGeneratedAt, codeMapGeneratedAt) {
+  if (!indexSourceGeneratedAt || !codeMapGeneratedAt) return false;
+  return indexSourceGeneratedAt !== codeMapGeneratedAt;
+}
+function emptyCodeIndex(model = DEFAULT_MODEL, dimension = DEFAULT_DIMENSION, sourceGeneratedAt = "") {
+  return {
+    model,
+    dimension,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    source_generated_at: sourceGeneratedAt,
+    entries: []
+  };
+}
+async function loadCodeIndex(paths) {
+  const file = codeIndexPath(paths);
+  if (!existsSync2(file)) return null;
+  return JSON.parse(await readFile2(file, "utf8"));
+}
+async function saveCodeIndex(paths, index) {
+  const dir = cacheDir(paths);
+  await mkdir2(dir, { recursive: true });
+  index.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile2(codeIndexPath(paths), JSON.stringify(index, null, 2), "utf8");
+}
+function buildCodeEntryText(file, name, kind, description) {
+  const filenameHints = file.split("/").pop()?.replace(/\.[^.]+$/, "").replace(/[._-]+/g, " ") ?? "";
+  return `${name} ${kind} ${filenameHints} ${description ?? ""}`.trim();
+}
+
+// src/code-indexer.ts
+import { loadCodeMap } from "@hivelore/core";
+import { createHash as createHash2 } from "crypto";
+function hashEntry(text) {
+  return createHash2("sha256").update(text).digest("hex").slice(0, 32);
+}
+async function rebuildCodeIndex(paths, embedder) {
+  const codeMap = await loadCodeMap(paths);
+  if (!codeMap) {
+    throw new Error(
+      "No code-map found. Run `hivelore index code` to generate `.ai/code-map.json` first."
+    );
+  }
+  const existing = await loadCodeIndex(paths) ?? emptyCodeIndex(embedder.model, embedder.dimension, codeMap.generated_at);
+  if (existing.model !== embedder.model || existing.dimension !== embedder.dimension) {
+    existing.entries = [];
+    existing.model = embedder.model;
+    existing.dimension = embedder.dimension;
+  }
+  const byId = new Map(existing.entries.map((e) => [e.id, e]));
+  const nextEntries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  let added = 0;
+  let updated = 0;
+  let unchanged = 0;
+  for (const [filePath, fileEntry] of Object.entries(codeMap.files)) {
+    for (const exp of fileEntry.exports) {
+      const id = `${filePath}#${exp.name}`;
+      seenIds.add(id);
+      const text = buildCodeEntryText(filePath, exp.name, exp.kind, exp.description);
+      const hash = hashEntry(text);
+      const prior = byId.get(id);
+      if (prior && prior.hash === hash && prior.line === exp.line) {
+        nextEntries.push({ ...prior, file: filePath, name: exp.name, kind: exp.kind, line: exp.line, ...exp.description ? { description: exp.description } : {} });
+        unchanged++;
+        continue;
+      }
+      const vector = Array.from(await embedder.encode(text));
+      nextEntries.push({
+        id,
+        file: filePath,
+        name: exp.name,
+        kind: exp.kind,
+        line: exp.line,
+        ...exp.description ? { description: exp.description } : {},
+        hash,
+        vector
+      });
+      if (prior) updated++;
+      else added++;
+    }
+  }
+  const removed = existing.entries.filter((e) => !seenIds.has(e.id)).length;
+  existing.entries = nextEntries;
+  existing.source_generated_at = codeMap.generated_at;
+  await saveCodeIndex(paths, existing);
+  return {
+    index: existing,
+    report: {
+      total: nextEntries.length,
+      added,
+      updated,
+      unchanged,
+      removed
+    }
+  };
+}
+
+// src/code-search.ts
+async function codeSemanticSearch(paths, query, options = {}) {
+  const index = options.index ?? await loadCodeIndex(paths);
+  if (!index || index.entries.length === 0) return null;
+  const embedder = options.embedder ?? await Embedder.create(index.model);
+  if (embedder.dimension !== index.dimension) {
+    throw new Error(
+      `Embedder dimension (${embedder.dimension}) differs from code index (${index.dimension}). Re-run \`hivelore index code-search\`.`
+    );
+  }
+  const queryVec = await embedder.encode(query);
+  const minScore = options.minScore ?? 0;
+  const limit = options.limit ?? 5;
+  const queryTokens = tokenize(query);
+  const normalizedQuery = query.trim().toLowerCase();
+  const scored = index.entries.map((e) => {
+    const semantic = cosine(queryVec, e.vector);
+    const boost = lexicalBoost(queryTokens, normalizedQuery, e.name, e.file);
+    return {
+      file: e.file,
+      name: e.name,
+      kind: e.kind,
+      line: e.line,
+      ...e.description ? { description: e.description } : {},
+      // Hybrid score: semantic cosine is the base, a small deterministic lexical bonus
+      // promotes exact/partial symbol-name and filename matches above merely-similar neighbours.
+      score: Math.min(1, semantic + boost),
+      semantic
+    };
+  }).filter((h) => h.semantic >= minScore).sort((a, b) => b.score - a.score || b.semantic - a.semantic || a.file.localeCompare(b.file) || a.line - b.line).slice(0, limit).map(({ semantic: _semantic, ...hit }) => hit);
+  return { hits: scored, index };
+}
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((t) => t.toLowerCase()).filter((t) => t.length >= 2);
+}
+function lexicalBoost(queryTokens, normalizedQuery, name, file) {
+  if (queryTokens.length === 0) return 0;
+  let nameComponent;
+  if (normalizedQuery === name.toLowerCase()) {
+    nameComponent = 0.3;
+  } else {
+    const nameTokens = new Set(tokenize(name));
+    const matched = queryTokens.filter((t) => nameTokens.has(t)).length;
+    nameComponent = matched / queryTokens.length * 0.2;
+  }
+  const fileTokens = new Set(tokenize(file.split("/").pop() ?? ""));
+  const pathComponent = queryTokens.some((t) => fileTokens.has(t)) ? 0.05 : 0;
+  return Math.min(0.3, nameComponent + pathComponent);
+}
+export {
+  DEFAULT_DIMENSION,
+  DEFAULT_MODEL,
+  Embedder,
+  buildCodeEntryText,
+  buildEntryText,
+  cacheDir,
+  codeIndexPath,
+  codeSemanticSearch,
+  cosine,
+  emptyCodeIndex,
+  emptyIndex,
+  hashContent,
+  indexPath,
+  indexStat,
+  isCodeIndexStale,
+  loadCodeIndex,
+  loadIndex,
+  rebuildCodeIndex,
+  rebuildIndex,
+  saveCodeIndex,
+  saveIndex,
+  semanticSearch
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/embedder.ts","../src/index-cache.ts","../src/indexer.ts","../src/search.ts","../src/code-index-cache.ts","../src/code-indexer.ts","../src/code-search.ts"],"sourcesContent":["export const DEFAULT_MODEL = \"Xenova/bge-small-en-v1.5\";\nexport const DEFAULT_DIMENSION = 384;\n\nexport interface EmbedderLike {\n  readonly model: string;\n  readonly dimension: number;\n  encode(text: string): Promise<Float32Array>;\n}\n\ninterface FeatureExtractionPipeline {\n  (text: string | string[], options: { pooling: \"mean\"; normalize: boolean }): Promise<{\n    data: Float32Array | number[];\n    dims: number[];\n  }>;\n}\n\nlet cachedPipeline: FeatureExtractionPipeline | null = null;\nlet cachedModel: string | null = null;\nconst cachedEmbedders = new Map<string, Embedder>();\n\nasync function loadPipeline(model: string): Promise<FeatureExtractionPipeline> {\n  if (cachedPipeline && cachedModel === model) return cachedPipeline;\n  const { pipeline, env } = await import(\"@xenova/transformers\");\n  // Allow remote model download by default; users can pre-cache for offline use.\n  env.allowLocalModels = true;\n  env.allowRemoteModels = true;\n  const pipe = (await pipeline(\"feature-extraction\", model)) as unknown as FeatureExtractionPipeline;\n  cachedPipeline = pipe;\n  cachedModel = model;\n  return pipe;\n}\n\nexport class Embedder implements EmbedderLike {\n  private constructor(\n    private readonly pipe: FeatureExtractionPipeline,\n    public readonly model: string,\n    public readonly dimension: number,\n  ) {}\n\n  static async create(model: string = DEFAULT_MODEL): Promise<Embedder> {\n    // Reuse the fully-initialized embedder per model: the pipeline is already cached, but each\n    // create() otherwise runs a \"dimension probe\" inference — wasteful when an agent issues several\n    // code_search / semantic-search calls in one session. Caching the instance makes calls 2..N free.\n    const cached = cachedEmbedders.get(model);\n    if (cached) return cached;\n    const pipe = await loadPipeline(model);\n    const probe = await pipe(\"dimension probe\", { pooling: \"mean\", normalize: true });\n    const dim = probe.data instanceof Float32Array ? probe.data.length : probe.data.length;\n    const embedder = new Embedder(pipe, model, dim);\n    cachedEmbedders.set(model, embedder);\n    return embedder;\n  }\n\n  async encode(text: string): Promise<Float32Array> {\n    const result = await this.pipe(text, { pooling: \"mean\", normalize: true });\n    return result.data instanceof Float32Array\n      ? result.data\n      : Float32Array.from(result.data);\n  }\n\n  async encodeMany(texts: string[]): Promise<Float32Array[]> {\n    const out: Float32Array[] = [];\n    for (const t of texts) {\n      out.push(await this.encode(t));\n    }\n    return out;\n  }\n}\n\nexport function cosine(a: Float32Array | number[], b: Float32Array | number[]): number {\n  if (a.length !== b.length) {\n    throw new Error(`vector dimension mismatch: ${a.length} vs ${b.length}`);\n  }\n  let dot = 0;\n  let na = 0;\n  let nb = 0;\n  for (let i = 0; i < a.length; i++) {\n    const av = a[i] as number;\n    const bv = b[i] as number;\n    dot += av * bv;\n    na += av * av;\n    nb += bv * bv;\n  }\n  if (na === 0 || nb === 0) return 0;\n  return dot / (Math.sqrt(na) * Math.sqrt(nb));\n}\n","import { createHash } from \"node:crypto\";\nimport { mkdir, readFile, stat, writeFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type { HaivePaths } from \"@hivelore/core\";\nimport { DEFAULT_DIMENSION, DEFAULT_MODEL } from \"./embedder.js\";\n\nexport const INDEX_FILE = \"embeddings-index.json\";\n\nexport interface EmbeddingEntry {\n  id: string;\n  file_path: string;\n  hash: string;\n  vector: number[];\n}\n\nexport interface EmbeddingIndex {\n  model: string;\n  dimension: number;\n  updated_at: string;\n  entries: EmbeddingEntry[];\n}\n\nexport function cacheDir(paths: HaivePaths): string {\n  return path.join(paths.haiveDir, \".cache\", \"embeddings\");\n}\n\nexport function indexPath(paths: HaivePaths): string {\n  return path.join(cacheDir(paths), INDEX_FILE);\n}\n\nexport function hashContent(text: string): string {\n  return createHash(\"sha256\").update(text).digest(\"hex\");\n}\n\nexport function emptyIndex(model = DEFAULT_MODEL, dimension = DEFAULT_DIMENSION): EmbeddingIndex {\n  return {\n    model,\n    dimension,\n    updated_at: new Date().toISOString(),\n    entries: [],\n  };\n}\n\nexport async function loadIndex(paths: HaivePaths): Promise<EmbeddingIndex | null> {\n  const file = indexPath(paths);\n  if (!existsSync(file)) return null;\n  const raw = await readFile(file, \"utf8\");\n  return JSON.parse(raw) as EmbeddingIndex;\n}\n\nexport async function saveIndex(paths: HaivePaths, index: EmbeddingIndex): Promise<void> {\n  const dir = cacheDir(paths);\n  await mkdir(dir, { recursive: true });\n  index.updated_at = new Date().toISOString();\n  await writeFile(indexPath(paths), JSON.stringify(index, null, 2), \"utf8\");\n}\n\nexport async function indexStat(paths: HaivePaths): Promise<{\n  exists: boolean;\n  count: number;\n  model: string | null;\n  updatedAt: string | null;\n  sizeBytes: number;\n}> {\n  const file = indexPath(paths);\n  if (!existsSync(file)) {\n    return { exists: false, count: 0, model: null, updatedAt: null, sizeBytes: 0 };\n  }\n  const idx = await loadIndex(paths);\n  const st = await stat(file);\n  return {\n    exists: true,\n    count: idx?.entries.length ?? 0,\n    model: idx?.model ?? null,\n    updatedAt: idx?.updated_at ?? null,\n    sizeBytes: st.size,\n  };\n}\n\nexport function buildEntryText(id: string, tags: string[], body: string): string {\n  // Concatenate id + tags + body so search works on metadata too.\n  // Tags are weighted by repetition so they contribute more to the embedding.\n  const tagPart = tags.length ? `${tags.join(\" \")} ${tags.join(\" \")} ` : \"\";\n  return `${id} ${tagPart}${body}`;\n}\n","import { loadMemoriesFromDir, type HaivePaths } from \"@hivelore/core\";\nimport type { EmbedderLike } from \"./embedder.js\";\nimport {\n  buildEntryText,\n  emptyIndex,\n  hashContent,\n  loadIndex,\n  saveIndex,\n  type EmbeddingEntry,\n  type EmbeddingIndex,\n} from \"./index-cache.js\";\n\nexport interface IndexUpdateReport {\n  total: number;\n  added: number;\n  updated: number;\n  unchanged: number;\n  removed: number;\n}\n\nexport async function rebuildIndex(\n  paths: HaivePaths,\n  embedder: EmbedderLike,\n): Promise<{ index: EmbeddingIndex; report: IndexUpdateReport }> {\n  const existing = (await loadIndex(paths)) ?? emptyIndex(embedder.model, embedder.dimension);\n  // If model changed, reset.\n  if (existing.model !== embedder.model || existing.dimension !== embedder.dimension) {\n    existing.entries = [];\n    existing.model = embedder.model;\n    existing.dimension = embedder.dimension;\n  }\n\n  const memories = await loadMemoriesFromDir(paths.memoriesDir);\n  const byId = new Map(existing.entries.map((e) => [e.id, e]));\n  const seenIds = new Set<string>();\n\n  let added = 0;\n  let updated = 0;\n  let unchanged = 0;\n\n  const nextEntries: EmbeddingEntry[] = [];\n\n  for (const { memory, filePath } of memories) {\n    const id = memory.frontmatter.id;\n    seenIds.add(id);\n    const text = buildEntryText(id, memory.frontmatter.tags, memory.body);\n    const hash = hashContent(text);\n    const prior = byId.get(id);\n\n    if (prior && prior.hash === hash) {\n      nextEntries.push({ ...prior, file_path: filePath });\n      unchanged++;\n      continue;\n    }\n\n    const vector = Array.from(await embedder.encode(text));\n    nextEntries.push({ id, file_path: filePath, hash, vector });\n    if (prior) {\n      updated++;\n    } else {\n      added++;\n    }\n  }\n\n  const removed = existing.entries.filter((e) => !seenIds.has(e.id)).length;\n  existing.entries = nextEntries;\n  await saveIndex(paths, existing);\n\n  return {\n    index: existing,\n    report: {\n      total: nextEntries.length,\n      added,\n      updated,\n      unchanged,\n      removed,\n    },\n  };\n}\n","import type { HaivePaths } from \"@hivelore/core\";\nimport { cosine, Embedder, type EmbedderLike } from \"./embedder.js\";\nimport { loadIndex, type EmbeddingIndex } from \"./index-cache.js\";\n\nexport interface SemanticHit {\n  id: string;\n  file_path: string;\n  score: number;\n}\n\nexport async function semanticSearch(\n  paths: HaivePaths,\n  query: string,\n  options: {\n    limit?: number;\n    minScore?: number;\n    embedder?: EmbedderLike;\n    index?: EmbeddingIndex;\n  } = {},\n): Promise<{ hits: SemanticHit[]; index: EmbeddingIndex } | null> {\n  const index = options.index ?? (await loadIndex(paths));\n  if (!index || index.entries.length === 0) return null;\n\n  const embedder = options.embedder ?? (await Embedder.create(index.model));\n  if (embedder.dimension !== index.dimension) {\n    throw new Error(\n      `Embedder dimension (${embedder.dimension}) differs from index (${index.dimension}). Re-run \\`hivelore embeddings index\\`.`,\n    );\n  }\n\n  const queryVec = await embedder.encode(query);\n  const minScore = options.minScore ?? 0;\n  const limit = options.limit ?? 10;\n\n  const scored = index.entries\n    .map((e) => ({ id: e.id, file_path: e.file_path, score: cosine(queryVec, e.vector) }))\n    .filter((h) => h.score >= minScore)\n    .sort((a, b) => b.score - a.score)\n    .slice(0, limit);\n\n  return { hits: scored, index };\n}\n","import { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type { HaivePaths } from \"@hivelore/core\";\nimport { DEFAULT_DIMENSION, DEFAULT_MODEL } from \"./embedder.js\";\nimport { cacheDir } from \"./index-cache.js\";\n\nexport const CODE_INDEX_FILE = \"code-embeddings-index.json\";\n\nexport interface CodeEmbeddingEntry {\n  /** stable id: `${file}#${name}` */\n  id: string;\n  file: string;\n  name: string;\n  kind: string;\n  line: number;\n  description?: string;\n  hash: string;\n  vector: number[];\n}\n\nexport interface CodeEmbeddingIndex {\n  model: string;\n  dimension: number;\n  updated_at: string;\n  source_generated_at: string;\n  entries: CodeEmbeddingEntry[];\n}\n\nexport function codeIndexPath(paths: HaivePaths): string {\n  return path.join(cacheDir(paths), CODE_INDEX_FILE);\n}\n\n/**\n * Is the code-search embeddings index stale relative to the current code-map?\n * The indexer stamps `source_generated_at` with the code-map's `generated_at` it was built from,\n * so a mismatch means the code-map was rebuilt afterwards and the index may miss or mislocate symbols.\n * Unknown timestamps (empty strings) are treated as not-stale to avoid false alarms.\n */\nexport function isCodeIndexStale(indexSourceGeneratedAt: string, codeMapGeneratedAt: string): boolean {\n  if (!indexSourceGeneratedAt || !codeMapGeneratedAt) return false;\n  return indexSourceGeneratedAt !== codeMapGeneratedAt;\n}\n\nexport function emptyCodeIndex(\n  model = DEFAULT_MODEL,\n  dimension = DEFAULT_DIMENSION,\n  sourceGeneratedAt = \"\",\n): CodeEmbeddingIndex {\n  return {\n    model,\n    dimension,\n    updated_at: new Date().toISOString(),\n    source_generated_at: sourceGeneratedAt,\n    entries: [],\n  };\n}\n\nexport async function loadCodeIndex(paths: HaivePaths): Promise<CodeEmbeddingIndex | null> {\n  const file = codeIndexPath(paths);\n  if (!existsSync(file)) return null;\n  return JSON.parse(await readFile(file, \"utf8\")) as CodeEmbeddingIndex;\n}\n\nexport async function saveCodeIndex(paths: HaivePaths, index: CodeEmbeddingIndex): Promise<void> {\n  const dir = cacheDir(paths);\n  await mkdir(dir, { recursive: true });\n  index.updated_at = new Date().toISOString();\n  await writeFile(codeIndexPath(paths), JSON.stringify(index, null, 2), \"utf8\");\n}\n\nexport function buildCodeEntryText(file: string, name: string, kind: string, description?: string): string {\n  // The embedded text is what we search against — keep it tight and signal-dense.\n  // Filename tokens often carry intent (e.g. \"auth.controller.ts\" → \"auth controller\").\n  const filenameHints = file\n    .split(\"/\")\n    .pop()\n    ?.replace(/\\.[^.]+$/, \"\")\n    .replace(/[._-]+/g, \" \") ?? \"\";\n  return `${name} ${kind} ${filenameHints} ${description ?? \"\"}`.trim();\n}\n","import { loadCodeMap, type HaivePaths } from \"@hivelore/core\";\nimport { createHash } from \"node:crypto\";\nimport type { EmbedderLike } from \"./embedder.js\";\nimport {\n  buildCodeEntryText,\n  emptyCodeIndex,\n  loadCodeIndex,\n  saveCodeIndex,\n  type CodeEmbeddingEntry,\n  type CodeEmbeddingIndex,\n} from \"./code-index-cache.js\";\n\nexport interface CodeIndexUpdateReport {\n  total: number;\n  added: number;\n  updated: number;\n  unchanged: number;\n  removed: number;\n}\n\nfunction hashEntry(text: string): string {\n  return createHash(\"sha256\").update(text).digest(\"hex\").slice(0, 32);\n}\n\n/**\n * Build (or refresh) the code semantic-search index from the code-map.\n * Each exported symbol becomes one embedding entry — granularity stays at the\n * symbol level so search returns a precise file:line:name target.\n *\n * Re-uses entries whose embedded text is unchanged (hash check) so subsequent\n * builds only embed the diff.\n */\nexport async function rebuildCodeIndex(\n  paths: HaivePaths,\n  embedder: EmbedderLike,\n): Promise<{ index: CodeEmbeddingIndex; report: CodeIndexUpdateReport }> {\n  const codeMap = await loadCodeMap(paths);\n  if (!codeMap) {\n    throw new Error(\n      \"No code-map found. Run `hivelore index code` to generate `.ai/code-map.json` first.\",\n    );\n  }\n\n  const existing =\n    (await loadCodeIndex(paths)) ??\n    emptyCodeIndex(embedder.model, embedder.dimension, codeMap.generated_at);\n\n  if (existing.model !== embedder.model || existing.dimension !== embedder.dimension) {\n    existing.entries = [];\n    existing.model = embedder.model;\n    existing.dimension = embedder.dimension;\n  }\n\n  const byId = new Map(existing.entries.map((e) => [e.id, e]));\n  const nextEntries: CodeEmbeddingEntry[] = [];\n  const seenIds = new Set<string>();\n  let added = 0;\n  let updated = 0;\n  let unchanged = 0;\n\n  for (const [filePath, fileEntry] of Object.entries(codeMap.files)) {\n    for (const exp of fileEntry.exports) {\n      const id = `${filePath}#${exp.name}`;\n      seenIds.add(id);\n      const text = buildCodeEntryText(filePath, exp.name, exp.kind, exp.description);\n      const hash = hashEntry(text);\n      const prior = byId.get(id);\n\n      if (prior && prior.hash === hash && prior.line === exp.line) {\n        nextEntries.push({ ...prior, file: filePath, name: exp.name, kind: exp.kind, line: exp.line, ...(exp.description ? { description: exp.description } : {}) });\n        unchanged++;\n        continue;\n      }\n\n      const vector = Array.from(await embedder.encode(text));\n      nextEntries.push({\n        id,\n        file: filePath,\n        name: exp.name,\n        kind: exp.kind,\n        line: exp.line,\n        ...(exp.description ? { description: exp.description } : {}),\n        hash,\n        vector,\n      });\n      if (prior) updated++;\n      else added++;\n    }\n  }\n\n  const removed = existing.entries.filter((e) => !seenIds.has(e.id)).length;\n  existing.entries = nextEntries;\n  existing.source_generated_at = codeMap.generated_at;\n  await saveCodeIndex(paths, existing);\n\n  return {\n    index: existing,\n    report: {\n      total: nextEntries.length,\n      added,\n      updated,\n      unchanged,\n      removed,\n    },\n  };\n}\n","import type { HaivePaths } from \"@hivelore/core\";\nimport { cosine, Embedder, type EmbedderLike } from \"./embedder.js\";\nimport { loadCodeIndex, type CodeEmbeddingIndex } from \"./code-index-cache.js\";\n\nexport interface CodeSearchHit {\n  file: string;\n  name: string;\n  kind: string;\n  line: number;\n  description?: string;\n  score: number;\n}\n\nexport async function codeSemanticSearch(\n  paths: HaivePaths,\n  query: string,\n  options: {\n    limit?: number;\n    minScore?: number;\n    embedder?: EmbedderLike;\n    index?: CodeEmbeddingIndex;\n  } = {},\n): Promise<{ hits: CodeSearchHit[]; index: CodeEmbeddingIndex } | null> {\n  const index = options.index ?? (await loadCodeIndex(paths));\n  if (!index || index.entries.length === 0) return null;\n\n  const embedder = options.embedder ?? (await Embedder.create(index.model));\n  if (embedder.dimension !== index.dimension) {\n    throw new Error(\n      `Embedder dimension (${embedder.dimension}) differs from code index (${index.dimension}). Re-run \\`hivelore index code-search\\`.`,\n    );\n  }\n\n  const queryVec = await embedder.encode(query);\n  const minScore = options.minScore ?? 0;\n  const limit = options.limit ?? 5;\n\n  const queryTokens = tokenize(query);\n  const normalizedQuery = query.trim().toLowerCase();\n\n  const scored = index.entries\n    .map((e) => {\n      const semantic = cosine(queryVec, e.vector);\n      const boost = lexicalBoost(queryTokens, normalizedQuery, e.name, e.file);\n      return {\n        file: e.file,\n        name: e.name,\n        kind: e.kind,\n        line: e.line,\n        ...(e.description ? { description: e.description } : {}),\n        // Hybrid score: semantic cosine is the base, a small deterministic lexical bonus\n        // promotes exact/partial symbol-name and filename matches above merely-similar neighbours.\n        score: Math.min(1, semantic + boost),\n        semantic,\n      };\n    })\n    // Keep min_score a pure-semantic noise floor (its documented meaning) so the lexical bonus\n    // re-ranks the relevant set without letting incidental filename tokens leak noise past the gate.\n    .filter((h) => h.semantic >= minScore)\n    .sort((a, b) => b.score - a.score || b.semantic - a.semantic || a.file.localeCompare(b.file) || a.line - b.line)\n    .slice(0, limit)\n    .map(({ semantic: _semantic, ...hit }) => hit);\n\n  return { hits: scored, index };\n}\n\n/** Split a query or symbol name into lowercase tokens, breaking on camelCase and any non-alphanumeric run. */\nfunction tokenize(text: string): string[] {\n  return text\n    .replace(/([a-z0-9])([A-Z])/g, \"$1 $2\")\n    .split(/[^a-zA-Z0-9]+/)\n    .map((t) => t.toLowerCase())\n    .filter((t) => t.length >= 2);\n}\n\n/**\n * Small additive bonus (≤ 0.30) layered on top of the semantic cosine so that exact symbol-name\n * matches outrank distant-but-similar code. Reuses only data already in the index entry — no new\n * index, model, or dependency.\n */\nfunction lexicalBoost(queryTokens: string[], normalizedQuery: string, name: string, file: string): number {\n  if (queryTokens.length === 0) return 0;\n\n  let nameComponent: number;\n  if (normalizedQuery === name.toLowerCase()) {\n    nameComponent = 0.3; // exact symbol name typed verbatim\n  } else {\n    const nameTokens = new Set(tokenize(name));\n    const matched = queryTokens.filter((t) => nameTokens.has(t)).length;\n    nameComponent = (matched / queryTokens.length) * 0.2; // proportional partial-name match\n  }\n\n  const fileTokens = new Set(tokenize(file.split(\"/\").pop() ?? \"\"));\n  const pathComponent = queryTokens.some((t) => fileTokens.has(t)) ? 0.05 : 0;\n\n  return Math.min(0.3, nameComponent + pathComponent);\n}\n"],"mappings":"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","names":["mkdir","readFile","writeFile","existsSync","path","path","existsSync","readFile","mkdir","writeFile","createHash","createHash"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@hivelore/embeddings",
+  "version": "0.30.0",
+  "description": "Hivelore embeddings - local semantic ranking for agent briefings and code search",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Doucs91/hivelore.git",
+    "directory": "packages/embeddings"
+  },
+  "bugs": "https://github.com/Doucs91/hivelore/issues",
+  "homepage": "https://github.com/Doucs91/hivelore#readme",
+  "keywords": [
+    "ai",
+    "enforcement",
+    "context",
+    "breadcrumbs",
+    "memory",
+    "embeddings",
+    "transformers",
+    "semantic-search",
+    "haive"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@xenova/transformers": "^2.17.2",
+    "@hivelore/core": "0.30.0"
+  },
+  "overrides": {
+    "protobufjs": "^7.5.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "node ../../scripts/ensure-workspace-dists.mjs @hivelore/core && tsc --noEmit",
+    "clean": "rm -rf dist .tsbuildinfo"
+  }
+}