@plur-ai/core 0.8.0 → 0.8.2

package/dist/chunk-GRDNBUIJ.js

@@ -0,0 +1,452 @@
+import {
+  atomicWrite
+} from "./chunk-MY4XVDCE.js";
+
+// src/logger.ts
+var level = process.env.PLUR_LOG_LEVEL || "warning";
+var levels = { debug: 0, info: 1, warning: 2, error: 3 };
+var threshold = levels[level] ?? 2;
+var logger = {
+  debug: (...args) => {
+    if (threshold <= 0) console.error("[plur:debug]", ...args);
+  },
+  info: (...args) => {
+    if (threshold <= 1) console.error("[plur:info]", ...args);
+  },
+  warning: (...args) => {
+    if (threshold <= 2) console.error("[plur:warning]", ...args);
+  },
+  error: (...args) => {
+    if (threshold <= 3) console.error("[plur:error]", ...args);
+  }
+};
+
+// src/engrams.ts
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+
+// src/schemas/engram.ts
+import { z } from "zod";
+var ActivationSchema = z.object({
+  retrieval_strength: z.number().min(0).max(1),
+  storage_strength: z.number().min(0).max(1),
+  frequency: z.number().int().min(0),
+  last_accessed: z.string()
+});
+var KnowledgeTypeSchema = z.object({
+  memory_class: z.enum(["semantic", "episodic", "procedural", "metacognitive"]),
+  cognitive_level: z.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
+});
+var KnowledgeAnchorSchema = z.object({
+  path: z.string(),
+  relevance: z.enum(["primary", "supporting", "example"]).default("supporting"),
+  snippet: z.string().max(200).optional(),
+  snippet_extracted_at: z.string().optional()
+});
+var AssociationSchema = z.object({
+  target_type: z.enum(["engram", "document"]),
+  target: z.string(),
+  strength: z.number().min(0).max(0.95),
+  type: z.enum(["semantic", "temporal", "causal", "co_accessed"]),
+  updated_at: z.string().optional()
+});
+var DualCodingSchema = z.object({
+  example: z.string().optional(),
+  analogy: z.string().optional()
+}).refine(
+  (d) => d.example || d.analogy,
+  "At least one of example or analogy must be provided"
+);
+var RelationsSchema = z.object({
+  broader: z.array(z.string()).default([]),
+  narrower: z.array(z.string()).default([]),
+  related: z.array(z.string()).default([]),
+  conflicts: z.array(z.string()).default([])
+});
+var ProvenanceSchema = z.object({
+  origin: z.string(),
+  chain: z.array(z.string()).default([]),
+  signature: z.string().nullable().default(null),
+  license: z.string().default("cc-by-sa-4.0")
+});
+var FeedbackSignalsSchema = z.object({
+  positive: z.number().int().default(0),
+  negative: z.number().int().default(0),
+  neutral: z.number().int().default(0)
+});
+var EntityRefSchema = z.object({
+  name: z.string(),
+  type: z.enum([
+    "person",
+    "organization",
+    "technology",
+    "concept",
+    "project",
+    "tool",
+    "place",
+    "event",
+    "standard",
+    "other"
+  ]),
+  uri: z.string().url().optional()
+});
+var TemporalSchema = z.object({
+  learned_at: z.string(),
+  valid_from: z.string().optional(),
+  valid_until: z.string().optional(),
+  ingested_at: z.string().optional()
+});
+var UsageStatsSchema = z.object({
+  injections: z.number().int().default(0),
+  hits: z.number().int().default(0),
+  misses: z.number().int().default(0),
+  last_hit_at: z.string().optional()
+});
+var EpisodicFieldsSchema = z.object({
+  emotional_weight: z.number().int().min(1).max(10).default(5),
+  confidence: z.number().int().min(1).max(10).default(5),
+  trigger_context: z.string().optional(),
+  journal_ref: z.string().optional()
+});
+var PreviousVersionRefSchema = z.object({
+  event_id: z.string(),
+  changed_at: z.string()
+});
+var ExchangeMetadataSchema = z.object({
+  fitness_score: z.number().min(0).max(1).optional(),
+  environmental_diversity: z.number().int().default(0),
+  adoption_count: z.number().int().default(0),
+  contradiction_rate: z.number().min(0).max(1).default(0)
+});
+var EngramSchema = z.object({
+  // Identity
+  id: z.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
+  version: z.number().int().min(1).default(2),
+  status: z.enum(["active", "dormant", "retired", "candidate"]),
+  consolidated: z.boolean().default(false),
+  type: z.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  scope: z.string(),
+  visibility: z.enum(["private", "public", "template"]).default("private"),
+  // Content
+  statement: z.string().min(1),
+  rationale: z.string().optional(),
+  contraindications: z.array(z.string()).optional(),
+  // Lineage
+  source: z.string().optional(),
+  source_patterns: z.array(z.string()).optional(),
+  derivation_count: z.number().int().min(0).default(1),
+  pack: z.string().nullable().default(null),
+  abstract: z.string().nullable().default(null),
+  derived_from: z.string().nullable().default(null),
+  // Classification
+  knowledge_type: KnowledgeTypeSchema.optional(),
+  domain: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  // Activation (ACT-R model)
+  activation: ActivationSchema.default({
+    retrieval_strength: 0.7,
+    storage_strength: 1,
+    frequency: 0,
+    last_accessed: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  }),
+  // Relations & grounding
+  relations: RelationsSchema.optional(),
+  associations: z.array(AssociationSchema).default([]),
+  knowledge_anchors: z.array(KnowledgeAnchorSchema).default([]),
+  dual_coding: DualCodingSchema.optional(),
+  // Provenance
+  provenance: ProvenanceSchema.optional(),
+  // Feedback
+  feedback_signals: FeedbackSignalsSchema.default({ positive: 0, negative: 0, neutral: 0 }),
+  // === NEW OPTIONAL FIELDS (v2.1) ===
+  /** Typed entity references extracted from statement. Enables graph queries. */
+  entities: z.array(EntityRefSchema).optional(),
+  /** Temporal validity window. When is this knowledge true? */
+  temporal: TemporalSchema.optional(),
+  /** Automatic usage tracking. Injections, hits, misses. */
+  usage: UsageStatsSchema.optional(),
+  /** Episodic context: emotional weight, confidence, trigger. */
+  episodic: EpisodicFieldsSchema.optional(),
+  /** Exchange marketplace metadata: fitness, adoption, diversity. */
+  exchange: ExchangeMetadataSchema.optional(),
+  /** Extensible key-value data for domain-specific fields. */
+  structured_data: z.record(z.string(), z.unknown()).optional(),
+  /** Polarity classification: 'do' for directives, 'dont' for prohibitions, null for unclassified. */
+  polarity: z.enum(["do", "dont"]).nullable().default(null),
+  // === SP1: Memory Intelligence fields ===
+  content_hash: z.string().optional(),
+  commitment: z.enum(["exploring", "leaning", "decided", "locked"]).optional(),
+  locked_at: z.string().optional(),
+  locked_reason: z.string().optional(),
+  // === SP2: History & Evolution fields ===
+  engram_version: z.number().int().min(1).default(1),
+  previous_version_ref: PreviousVersionRefSchema.optional(),
+  episode_ids: z.array(z.string()).default([]),
+  // === SP3: Retrieval & Injection fields ===
+  summary: z.string().max(80).optional()
+});
+var EngramSchemaPassthrough = EngramSchema.passthrough();
+
+// src/schemas/pack.ts
+import { z as z2 } from "zod";
+var PackManifestSchema = z2.object({
+  name: z2.string(),
+  version: z2.string(),
+  description: z2.string().optional(),
+  creator: z2.string().optional(),
+  license: z2.string().default("cc-by-sa-4.0"),
+  tags: z2.array(z2.string()).default([]),
+  metadata: z2.object({
+    id: z2.string().optional(),
+    injection_policy: z2.enum(["on_match", "on_request", "always"]).default("on_match"),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().optional()
+  }).optional(),
+  "x-datacore": z2.object({
+    id: z2.string(),
+    injection_policy: z2.enum(["on_match", "on_request"]),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().int().min(0)
+  }).optional()
+});
+
+// src/engrams.ts
+function loadEngrams(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const raw = yaml.load(fs.readFileSync(filePath, "utf8"));
+    if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
+    const valid = [];
+    let skipped = 0;
+    for (const entry of raw.engrams) {
+      const result = EngramSchemaPassthrough.safeParse(entry);
+      if (result.success) valid.push(result.data);
+      else skipped++;
+    }
+    if (skipped > 0) logger.warning(`Skipped ${skipped} invalid engram(s) in ${filePath}`);
+    return valid;
+  } catch (err) {
+    logger.error(`Failed to parse engrams file ${filePath}: ${err}`);
+    return [];
+  }
+}
+function saveEngrams(filePath, engrams) {
+  const content = yaml.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  atomicWrite(filePath, content);
+}
+function parseSkillMdFrontmatter(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) throw new Error(`No frontmatter found in ${filePath}`);
+  return yaml.load(match[1]);
+}
+function loadPack(packDir) {
+  const skillMdPath = `${packDir}/SKILL.md`;
+  const manifestYamlPath = `${packDir}/manifest.yaml`;
+  const engramsPath = `${packDir}/engrams.yaml`;
+  let rawManifest;
+  if (fs.existsSync(skillMdPath)) {
+    rawManifest = parseSkillMdFrontmatter(skillMdPath);
+  } else if (fs.existsSync(manifestYamlPath)) {
+    rawManifest = yaml.load(fs.readFileSync(manifestYamlPath, "utf8"));
+  } else {
+    throw new Error(`No SKILL.md or manifest.yaml found in ${packDir}`);
+  }
+  const manifest = PackManifestSchema.parse(rawManifest);
+  const engrams = loadEngrams(engramsPath);
+  return { manifest, engrams };
+}
+function loadAllPacks(packsDir) {
+  if (!fs.existsSync(packsDir)) return [];
+  const packs = [];
+  for (const entry of fs.readdirSync(packsDir)) {
+    const packDir = `${packsDir}/${entry}`;
+    if (!fs.statSync(packDir).isDirectory()) continue;
+    if (!fs.existsSync(`${packDir}/SKILL.md`) && !fs.existsSync(`${packDir}/manifest.yaml`)) continue;
+    try {
+      packs.push(loadPack(packDir));
+    } catch (err) {
+      logger.warning(`Failed to load pack ${entry}: ${err}`);
+    }
+  }
+  return packs;
+}
+function storePrefix(scope) {
+  const parts = scope.split(/[:\-_./]/).filter(Boolean);
+  if (parts.length >= 2) {
+    const p2 = parts[1];
+    return (parts[0][0] + p2[0] + (p2[1] || p2[0])).toUpperCase();
+  }
+  const w = parts[0] || scope;
+  if (w.length >= 3) return (w[0] + w[Math.floor(w.length / 2)] + w[w.length - 1]).toUpperCase();
+  return (w[0] + (w[1] || w[0]) + (w[2] || w[0])).toUpperCase();
+}
+function generateEngramId(existing) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const prefix = `ENG-${date.slice(0, 4)}-${date.slice(4)}-`;
+  const existingNums = existing.filter((e) => e.id.startsWith(prefix)).map((e) => parseInt(e.id.slice(prefix.length), 10)).filter((n) => !isNaN(n));
+  const next = existingNums.length > 0 ? Math.max(...existingNums) + 1 : 1;
+  return `${prefix}${String(next).padStart(3, "0")}`;
+}
+
+// src/history.ts
+import * as fs2 from "fs";
+import { join } from "path";
+function appendHistory(root, event) {
+  const historyDir = join(root, "history");
+  if (!fs2.existsSync(historyDir)) {
+    fs2.mkdirSync(historyDir, { recursive: true });
+  }
+  const date = event.timestamp.slice(0, 7);
+  const filePath = join(historyDir, `${date}.jsonl`);
+  const line = JSON.stringify(event) + "\n";
+  fs2.appendFileSync(filePath, line, "utf8");
+}
+function readHistory(root, yearMonth) {
+  const filePath = join(root, "history", `${yearMonth}.jsonl`);
+  if (!fs2.existsSync(filePath)) return [];
+  const content = fs2.readFileSync(filePath, "utf8");
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+function listHistoryMonths(root) {
+  const historyDir = join(root, "history");
+  if (!fs2.existsSync(historyDir)) return [];
+  return fs2.readdirSync(historyDir).filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", "")).sort();
+}
+function readHistoryForEngram(root, engramId) {
+  const months = listHistoryMonths(root);
+  const events = [];
+  for (const month of months) {
+    const monthEvents = readHistory(root, month);
+    for (const event of monthEvents) {
+      if (event.engram_id === engramId) {
+        events.push(event);
+      }
+    }
+  }
+  return events;
+}
+function generateEventId() {
+  const ts = Date.now();
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `EVT-${ts}-${rand}`;
+}
+
+// src/content-hash.ts
+import { createHash } from "crypto";
+function normalizeStatement(statement) {
+  return statement.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function computeContentHash(statement) {
+  const normalized = normalizeStatement(statement);
+  return createHash("sha256").update(normalized).digest("hex");
+}
+
+// src/dedup.ts
+function buildDedupPrompt(newStatement, candidates) {
+  const candidateList = candidates.map(
+    (c, i) => `${i + 1}. [${c.id}] (${c.type}${c.domain ? ", domain: " + c.domain : ""})
+   "${c.statement}"`
+  ).join("\n");
+  return `You are a memory deduplication system. Compare a new memory statement against existing ones.
+
+NEW STATEMENT:
+"${newStatement}"
+
+EXISTING ENGRAMS:
+${candidateList}
+
+For each existing engram, answer:
+1. RELATIONSHIP: Is the new statement a DUPLICATE (same meaning), EVOLUTION (updated version of same knowledge), COMPLEMENTARY (related but different angle), CONTRADICTORY (opposing), or UNRELATED?
+2. RICHNESS: Does the new statement contain more specific, actionable information than the existing one? (yes/no)
+
+Then give your OVERALL DECISION (exactly one):
+- NOOP: New statement is an exact duplicate of an existing engram. Return the ID.
+- UPDATE: New statement is an evolution with MORE information. Return the ID to update.
+- MERGE: New statement and an existing one are complementary \u2014 combining them preserves both. Return the ID to merge with.
+- ADD: New statement is genuinely new knowledge.
+
+Also check: Does the new statement CONTRADICT any existing engram? If yes, list the conflicting IDs.
+
+Respond in this exact format:
+DECISION: <ADD|UPDATE|MERGE|NOOP>
+TARGET: <engram ID if UPDATE/MERGE/NOOP, or "none" if ADD>
+CONFLICTS: <comma-separated IDs, or "none">
+REASON: <one sentence explanation>`;
+}
+function buildBatchDedupPrompt(statements, existingEngrams) {
+  const stmtList = statements.map((s, i) => `${i + 1}. "${s}"`).join("\n");
+  const engramList = existingEngrams.map(
+    (e, i) => `${i + 1}. [${e.id}] (${e.type}${e.domain ? ", domain: " + e.domain : ""})
+   "${e.statement}"`
+  ).join("\n");
+  return `You are a memory deduplication system. Compare NEW statements against existing engrams.
+
+NEW STATEMENTS:
+${stmtList}
+
+EXISTING ENGRAMS:
+${engramList}
+
+For each NEW statement, decide:
+- NOOP: Exact duplicate of an existing engram.
+- UPDATE: Evolution with more info than existing.
+- MERGE: Complementary with existing \u2014 combine.
+- ADD: Genuinely new knowledge.
+
+Also flag any CONTRADICTIONS.
+
+Respond with one block per new statement:
+STATEMENT_1:
+DECISION: <ADD|UPDATE|MERGE|NOOP>
+TARGET: <engram ID or "none">
+CONFLICTS: <comma-separated IDs or "none">
+
+STATEMENT_2:
+...`;
+}
+function parseDedupResponse(response) {
+  const decisionMatch = response.match(/DECISION:\s*(ADD|UPDATE|MERGE|NOOP)/i);
+  const targetMatch = response.match(/TARGET:\s*([^\n]+)/i);
+  const conflictsMatch = response.match(/CONFLICTS:\s*([^\n]+)/i);
+  const reasonMatch = response.match(/REASON:\s*([^\n]+)/i);
+  const decision = decisionMatch?.[1]?.toUpperCase() ?? "ADD";
+  const targetRaw = targetMatch?.[1]?.trim() ?? "none";
+  const target_id = targetRaw === "none" ? null : targetRaw.replace(/[^A-Za-z0-9-]/g, "");
+  const conflictsRaw = conflictsMatch?.[1]?.trim() ?? "none";
+  const conflicts = conflictsRaw === "none" ? [] : conflictsRaw.split(",").map((s) => s.trim().replace(/[^A-Za-z0-9-]/g, "")).filter(Boolean);
+  const reason = reasonMatch?.[1]?.trim() ?? "";
+  return { decision, target_id, conflicts, reason };
+}
+
+export {
+  EngramSchemaPassthrough,
+  logger,
+  loadEngrams,
+  saveEngrams,
+  loadPack,
+  loadAllPacks,
+  storePrefix,
+  generateEngramId,
+  appendHistory,
+  readHistory,
+  listHistoryMonths,
+  readHistoryForEngram,
+  generateEventId,
+  normalizeStatement,
+  computeContentHash,
+  buildDedupPrompt,
+  buildBatchDedupPrompt,
+  parseDedupResponse
+};

package/dist/{chunk-KMVQYBNP.js → chunk-MY4XVDCE.js}

@@ -1,110 +1,3 @@
-// src/fts.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "and",
-  "for",
-  "that",
-  "this",
-  "with",
-  "from",
-  "are",
-  "was",
-  "were",
-  "been",
-  "have",
-  "has",
-  "not",
-  "but",
-  "its",
-  "you",
-  "your",
-  "can",
-  "will",
-  "should",
-  "would",
-  "could",
-  "may",
-  "might"
-]);
-function ftsTokenize(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).filter((w) => !STOP_WORDS.has(w));
-}
-function engramSearchText(engram) {
-  const parts = [engram.statement];
-  if (engram.domain) parts.push(engram.domain.replace(/\./g, " "));
-  if (engram.tags.length > 0) parts.push(engram.tags.join(" "));
-  if (engram.entities) {
-    for (const e of engram.entities) {
-      parts.push(e.name);
-      if (e.type !== "other") parts.push(e.type);
-    }
-  }
-  if (engram.temporal) {
-    if (engram.temporal.valid_from) parts.push(engram.temporal.valid_from);
-    if (engram.temporal.valid_until) parts.push(engram.temporal.valid_until);
-  }
-  if (engram.rationale) parts.push(engram.rationale);
-  return parts.join(" ");
-}
-function computeIdf(engrams, queryTokens) {
-  const N = engrams.length;
-  if (N === 0) return /* @__PURE__ */ new Map();
-  const engramTermSets = engrams.map((e) => new Set(ftsTokenize(engramSearchText(e))));
-  const idf = /* @__PURE__ */ new Map();
-  for (const qt of queryTokens) {
-    let df = 0;
-    for (const termSet of engramTermSets) {
-      if (termSet.has(qt) || Array.from(termSet).some((t) => t.includes(qt) || qt.includes(t))) {
-        df++;
-      }
-    }
-    idf.set(qt, Math.max(0, Math.log(N / (1 + df))));
-  }
-  return idf;
-}
-var BM25_K1 = 1.2;
-var BM25_B = 0.75;
-function ftsScore(engram, queryTokens, idfWeights, avgDocLength) {
-  const allTerms = ftsTokenize(engramSearchText(engram));
-  if (queryTokens.length === 0) return 0;
-  const docLen = allTerms.length;
-  const avgdl = avgDocLength && avgDocLength > 0 ? avgDocLength : docLen;
-  const hasNonZeroIdf = idfWeights && Array.from(idfWeights.values()).some((v) => v > 0);
-  let score = 0;
-  for (const qt of queryTokens) {
-    let effectiveIdf;
-    if (!idfWeights) {
-      effectiveIdf = 1;
-    } else if (hasNonZeroIdf) {
-      effectiveIdf = idfWeights.get(qt) ?? 0;
-      if (effectiveIdf === 0) continue;
-    } else {
-      effectiveIdf = 1;
-    }
-    let tf = 0;
-    for (const t of allTerms) {
-      if (t.includes(qt) || qt.includes(t)) tf++;
-    }
-    if (tf === 0) continue;
-    const numerator = tf * (BM25_K1 + 1);
-    const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * docLen / avgdl);
-    score += effectiveIdf * (numerator / denominator);
-  }
-  return score;
-}
-function searchEngrams(engrams, query, limit = 20) {
-  const queryTokens = ftsTokenize(query);
-  if (queryTokens.length === 0) return [];
-  const idfWeights = computeIdf(engrams, queryTokens);
-  const avgDocLength = engrams.length > 0 ? engrams.reduce((sum, e) => sum + ftsTokenize(engramSearchText(e)).length, 0) / engrams.length : 0;
-  return engrams.map((e) => ({ engram: e, score: ftsScore(e, queryTokens, idfWeights, avgDocLength) })).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((r) => r.engram);
-}
-
-// src/embeddings.ts
-import { existsSync as existsSync2, readFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
-import { createHash } from "crypto";
-
 // src/sync.ts
 import { execFileSync } from "child_process";
 import { existsSync, writeFileSync, renameSync, mkdirSync, unlinkSync, statSync } from "fs";
@@ -305,93 +198,9 @@ function atomicWrite(filePath, content) {
   renameSync(tmp, filePath);
 }
 
-// src/embeddings.ts
-var embedPipeline = null;
-var transformersUnavailable = false;
-async function getEmbedder() {
-  if (transformersUnavailable) return null;
-  if (!embedPipeline) {
-    try {
-      const { pipeline } = await import("./transformers.node-PH5YK5EA.js");
-      embedPipeline = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", {
-        dtype: "fp32"
-      });
-    } catch {
-      transformersUnavailable = true;
-      return null;
-    }
-  }
-  return embedPipeline;
-}
-async function embed(text) {
-  const embedder = await getEmbedder();
-  if (!embedder) return null;
-  const result = await embedder(text, { pooling: "cls", normalize: true });
-  return new Float32Array(result.data);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
-  return dot;
-}
-function loadCache(cachePath) {
-  if (!existsSync2(cachePath)) return {};
-  try {
-    return JSON.parse(readFileSync(cachePath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCache(cachePath, cache) {
-  const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-  atomicWrite(cachePath, JSON.stringify(cache));
-}
-function hashStatement(statement) {
-  return createHash("sha256").update(statement).digest("hex").slice(0, 16);
-}
-async function embeddingSearch(engrams, query, limit, storagePath) {
-  if (engrams.length === 0) return [];
-  const cachePath = storagePath ? join2(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
-  const cache = loadCache(cachePath);
-  const queryEmbedding = await embed(query);
-  if (!queryEmbedding) {
-    return [];
-  }
-  const similarities = [];
-  for (const engram of engrams) {
-    const searchText = engramSearchText(engram);
-    const hash = hashStatement(searchText);
-    let engramEmbedding;
-    if (cache[engram.id]?.hash === hash) {
-      engramEmbedding = new Float32Array(cache[engram.id].embedding);
-    } else {
-      const emb = await embed(searchText);
-      if (!emb) return [];
-      engramEmbedding = emb;
-      cache[engram.id] = {
-        hash,
-        embedding: Array.from(engramEmbedding)
-      };
-    }
-    const score = cosineSimilarity(queryEmbedding, engramEmbedding);
-    similarities.push({ engram, score });
-  }
-  saveCache(cachePath, cache);
-  similarities.sort((a, b) => b.score - a.score);
-  return similarities.slice(0, limit).map((s) => s.engram);
-}
-
 export {
   getSyncStatus,
   sync,
   withLock,
-  atomicWrite,
-  ftsTokenize,
-  engramSearchText,
-  ftsScore,
-  searchEngrams,
-  embed,
-  cosineSimilarity,
-  embeddingSearch
+  atomicWrite
 };