@hiveai/embeddings 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hAIve 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/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { HaivePaths } from '@hiveai/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>;
+
+export { DEFAULT_DIMENSION, DEFAULT_MODEL, Embedder, type EmbedderLike, type EmbeddingEntry, type EmbeddingIndex, type IndexUpdateReport, type SemanticHit, buildEntryText, cacheDir, cosine, emptyIndex, hashContent, indexPath, indexStat, loadIndex, rebuildIndex, saveIndex, semanticSearch };

package/dist/index.js

@@ -0,0 +1,198 @@
+// src/embedder.ts
+var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+var DEFAULT_DIMENSION = 384;
+var cachedPipeline = null;
+var cachedModel = null;
+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 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;
+    return new _Embedder(pipe, model, dim);
+  }
+  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 "@hiveai/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 \`haive 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 };
+}
+export {
+  DEFAULT_DIMENSION,
+  DEFAULT_MODEL,
+  Embedder,
+  buildEntryText,
+  cacheDir,
+  cosine,
+  emptyIndex,
+  hashContent,
+  indexPath,
+  indexStat,
+  loadIndex,
+  rebuildIndex,
+  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"],"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;\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    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    return new Embedder(pipe, model, dim);\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 \"@hiveai/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 \"@hiveai/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 \"@hiveai/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 \\`haive 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"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@hiveai/embeddings",
+  "version": "0.1.0",
+  "description": "hAIve embeddings — local sentence embeddings via Transformers.js for semantic memory search",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Doucs91/hAIve.git",
+    "directory": "packages/embeddings"
+  },
+  "bugs": "https://github.com/Doucs91/hAIve/issues",
+  "homepage": "https://github.com/Doucs91/hAIve#readme",
+  "keywords": [
+    "ai",
+    "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",
+    "@hiveai/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .tsbuildinfo"
+  }
+}