nemoris 0.1.0

package/src/memory/file-index.js

@@ -0,0 +1,177 @@
+function tokenize(text) {
+  return String(text || "")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/i)
+    .filter(Boolean);
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function duplicateSignature(record, fields) {
+  return fields.map((field) => String(record?.[field] || "")).join("::");
+}
+
+function normalizeEntry(record, source) {
+  const searchableText = [record.title, record.content, record.summary, record.reason, record.category].join(" ");
+  return {
+    id: source.id,
+    source: source.kind,
+    sourceFile: source.file || null,
+    type: record.type,
+    category: record.category || null,
+    title: record.title || null,
+    content: record.content || null,
+    summary: record.summary || null,
+    reason: record.reason || null,
+    timestamp: record.timestamp || null,
+    salience: record.salience ?? null,
+    accessCount: record.accessCount ?? 0,
+    expiresAt: record.expiresAt || null,
+    sourceKind: record.sourceKind || null,
+    dedupeKey: record.dedupeKey || null,
+    tokens: unique(tokenize(searchableText))
+  };
+}
+
+function emptyIndex() {
+  return {
+    version: 1,
+    entries: [],
+    duplicate: {
+      events: {},
+      facts: {},
+      summaries: {}
+    },
+    tokens: {},
+    meta: {
+      updatedAt: null
+    }
+  };
+}
+
+function addTokenMappings(tokenMap, entry) {
+  for (const token of entry.tokens || []) {
+    tokenMap[token] = unique([...(tokenMap[token] || []), entry.id]);
+  }
+}
+
+function removeTokenMappings(tokenMap, entry) {
+  for (const token of entry.tokens || []) {
+    const next = (tokenMap[token] || []).filter((id) => id !== entry.id);
+    if (next.length) tokenMap[token] = next;
+    else delete tokenMap[token];
+  }
+}
+
+function addDuplicateMappings(index, entry) {
+  if (entry.dedupeKey) {
+    index.duplicate.events[entry.dedupeKey] = true;
+  }
+  if (entry.type === "summary") {
+    index.duplicate.summaries[duplicateSignature(entry, ["title", "category", "summary", "content"])] = true;
+  }
+  if (entry.type === "fact") {
+    index.duplicate.facts[duplicateSignature(entry, ["title", "category", "content", "reason"])] = true;
+  }
+}
+
+function removeDuplicateMappings(index, entry) {
+  if (entry.dedupeKey) {
+    delete index.duplicate.events[entry.dedupeKey];
+  }
+  if (entry.type === "summary") {
+    delete index.duplicate.summaries[duplicateSignature(entry, ["title", "category", "summary", "content"])];
+  }
+  if (entry.type === "fact") {
+    delete index.duplicate.facts[duplicateSignature(entry, ["title", "category", "content", "reason"])];
+  }
+}
+
+export function createIndex() {
+  return emptyIndex();
+}
+
+export function indexFromRecords(records) {
+  const index = emptyIndex();
+  for (const { record, source } of records) {
+    const entry = normalizeEntry(record, source);
+    index.entries.push(entry);
+    addDuplicateMappings(index, entry);
+    addTokenMappings(index.tokens, entry);
+  }
+  index.meta.updatedAt = new Date().toISOString();
+  return index;
+}
+
+export function appendIndexEntry(index, record, source) {
+  const entry = normalizeEntry(record, source);
+  index.entries.push(entry);
+  addDuplicateMappings(index, entry);
+  addTokenMappings(index.tokens, entry);
+  index.meta.updatedAt = new Date().toISOString();
+  return entry;
+}
+
+export function replaceIndexEntry(index, entryId, record, source) {
+  const existing = index.entries.find((entry) => entry.id === entryId);
+  if (existing) {
+    removeTokenMappings(index.tokens, existing);
+    removeDuplicateMappings(index, existing);
+    index.entries = index.entries.filter((entry) => entry.id !== entryId);
+  }
+  return appendIndexEntry(index, record, source);
+}
+
+export function removeIndexEntry(index, entryId) {
+  const existing = index.entries.find((entry) => entry.id === entryId);
+  if (!existing) return false;
+  removeTokenMappings(index.tokens, existing);
+  removeDuplicateMappings(index, existing);
+  index.entries = index.entries.filter((entry) => entry.id !== entryId);
+  index.meta.updatedAt = new Date().toISOString();
+  return true;
+}
+
+export function hasIndexedDuplicate(index, record, kind) {
+  if (kind === "event" && record.dedupeKey) {
+    return Boolean(index.duplicate.events[record.dedupeKey]);
+  }
+  if (kind === "summary") {
+    return Boolean(index.duplicate.summaries[duplicateSignature(record, ["title", "category", "summary", "content"])]);
+  }
+  if (kind === "fact") {
+    return Boolean(index.duplicate.facts[duplicateSignature(record, ["title", "category", "content", "reason"])]);
+  }
+  return false;
+}
+
+export function queryIndexEntries(index, query, limit = 32) {
+  const queryTokens = unique(tokenize(query));
+  if (queryTokens.length === 0) {
+    return index.entries.slice(-limit);
+  }
+
+  const candidateIds = new Set();
+  for (const token of queryTokens) {
+    for (const id of index.tokens[token] || []) {
+      candidateIds.add(id);
+    }
+  }
+
+  if (candidateIds.size === 0) {
+    return index.entries.slice(-limit);
+  }
+
+  const directMatches = index.entries.filter((entry) => candidateIds.has(entry.id));
+  if (directMatches.length >= limit) {
+    return directMatches;
+  }
+
+  const recentFallback = index.entries
+    .slice(-limit)
+    .filter((entry) => !candidateIds.has(entry.id));
+
+  return [...directMatches, ...recentFallback].slice(0, limit);
+}

package/src/memory/memory-signature.js

@@ -0,0 +1,5 @@
+export function buildResultSignature(item) {
+  return [item.type, item.category, item.title, item.summary, item.content, item.reason]
+    .map((part) => String(part || ""))
+    .join("::");
+}