mem-os-python 1.6.27__py3-none-any.whl

memos/_js/entity-extraction.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Entity extraction for fused retrieval scoring.
+ *
+ * The third retrieval signal alongside keyword (FTS5) and semantic
+ * (embedding) legs: memories whose stored entities overlap the query's
+ * entities get a post-fusion boost. This mirrors the 2026 fused
+ * multi-signal retrieval consensus (semantic + BM25 + entity match).
+ *
+ * The extractor is deliberately lightweight and dependency-free —
+ * capitalized multi-word sequences, acronyms, quoted strings, and
+ * code-identifier shapes. It runs on every hybrid search, so it must
+ * stay in the sub-millisecond class. Entities for a memory are captured
+ * at write time into `metadata.entities` (see `MemOS.store`), so the
+ * per-candidate overlap check is a set intersection, not a rescan.
+ *
+ * @module @mem-os/entity-extraction
+ */
+/**
+ * Extract candidate entities from free text.
+ *
+ * Returns lowercase-normalized entities so overlap checks are
+ * case-insensitive. Order is stable (first appearance), duplicates are
+ * removed. Sentence-initial capitalization is ignored (it's grammatical,
+ * not a name), which keeps "Fix the parser" from yielding "fix".
+ */
+export declare function extractQueryEntities(text: string): string[];
+/**
+ * Overlap between query entities and a memory's stored entities
+ * (`metadata.entities`) and tags, in [0, 1]. Jaccard-style: shared
+ * count over the smaller set, so a single match on a 1-entity query
+ * counts fully.
+ */
+export declare function entityOverlap(queryEntities: readonly string[], node: {
+    tags?: readonly string[];
+    metadata?: {
+        entities?: unknown;
+    };
+}): number;
+/**
+ * Built-in alias table mapping surface forms to a canonical entity.
+ * Lexical extraction alone yields "Postgres", "PostgreSQL", and "pg" as
+ * three different entities; canonicalizing through this map (plus any
+ * deployment-specific `MemOSConfig.entityAliases`) collapses them so the
+ * overlap signal fires across phrasings.
+ */
+export declare const BUILTIN_ENTITY_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Canonicalize extracted entities through the built-in alias table plus
+ * any deployment-specific aliases (from `MemOSConfig.entityAliases`,
+ * which wins over built-ins). Deduplicates after mapping, preserving
+ * first-appearance order.
+ */
+export declare function canonicalizeEntities(entities: readonly string[], extraAliases?: Readonly<Record<string, string>>): string[];
+//# sourceMappingURL=entity-extraction.d.ts.map

memos/_js/entity-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-extraction.d.ts","sourceRoot":"","sources":["../src/entity-extraction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAwHH;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA0E3D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,GACpE,MAAM,CA+BR;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAuCnE,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC9C,MAAM,EAAE,CAeV"}

memos/_js/entity-extraction.js

@@ -0,0 +1,325 @@
+/**
+ * Entity extraction for fused retrieval scoring.
+ *
+ * The third retrieval signal alongside keyword (FTS5) and semantic
+ * (embedding) legs: memories whose stored entities overlap the query's
+ * entities get a post-fusion boost. This mirrors the 2026 fused
+ * multi-signal retrieval consensus (semantic + BM25 + entity match).
+ *
+ * The extractor is deliberately lightweight and dependency-free —
+ * capitalized multi-word sequences, acronyms, quoted strings, and
+ * code-identifier shapes. It runs on every hybrid search, so it must
+ * stay in the sub-millisecond class. Entities for a memory are captured
+ * at write time into `metadata.entities` (see `MemOS.store`), so the
+ * per-candidate overlap check is a set intersection, not a rescan.
+ *
+ * @module @mem-os/entity-extraction
+ */
+/** Minimum length for a single-word entity (filters noise like "I", "A"). */
+const MIN_WORD_LENGTH = 3;
+/** Words that are capitalized mid-sentence but are not entities. */
+const STOPWORDS = new Set([
+    "the",
+    "this",
+    "that",
+    "these",
+    "those",
+    "there",
+    "then",
+    "than",
+    "when",
+    "while",
+    "where",
+    "which",
+    "who",
+    "how",
+    "why",
+    "what",
+    "and",
+    "but",
+    "for",
+    "not",
+    "with",
+    "from",
+    "into",
+    "onto",
+    "over",
+    "after",
+    "before",
+    "because",
+    "if",
+    "it",
+    "its",
+    "we",
+    "our",
+    "you",
+    "your",
+    "they",
+    "their",
+    "she",
+    "his",
+    "her",
+    "him",
+    "us",
+    "them",
+    "please",
+    "also",
+    "just",
+    "very",
+    "can",
+    "could",
+    "should",
+    "would",
+    "will",
+    "shall",
+    "may",
+    "might",
+    "must",
+    "do",
+    "does",
+    "did",
+    "done",
+    "have",
+    "has",
+    "had",
+    "was",
+    "were",
+    "are",
+    "is",
+    "am",
+    "be",
+    "been",
+    "being",
+    "add",
+    "use",
+    "using",
+    "used",
+    "make",
+    "made",
+    "run",
+    "runs",
+    "new",
+    "old",
+    "get",
+    "got",
+    "set",
+    "let",
+    "put",
+    "try",
+    "tried",
+    "i'd",
+    "i'm",
+    "i've",
+    "don't",
+    "doesn't",
+    "didn't",
+    "won't",
+    "can't",
+]);
+/** Terms that never count as entities regardless of casing. */
+const NON_ENTITY_TOKEN = /^[0-9_]+$/;
+function isCodeIdentifier(token) {
+    // snake_case, kebab-case, dotted paths, or CamelCase with an internal
+    // uppercase — the shapes that show up when agents store technical memory.
+    return /[_\-.]/.test(token) || /^[a-z]+[A-Z]/.test(token);
+}
+function isAcronym(token) {
+    return (token.length >= 2 && token === token.toUpperCase() && /[A-Z]/.test(token));
+}
+/**
+ * Extract candidate entities from free text.
+ *
+ * Returns lowercase-normalized entities so overlap checks are
+ * case-insensitive. Order is stable (first appearance), duplicates are
+ * removed. Sentence-initial capitalization is ignored (it's grammatical,
+ * not a name), which keeps "Fix the parser" from yielding "fix".
+ */
+export function extractQueryEntities(text) {
+    if (!text)
+        return [];
+    const entities = [];
+    const seen = new Set();
+    const push = (raw, minLen = MIN_WORD_LENGTH) => {
+        const normalized = raw.toLowerCase().trim();
+        if (normalized.length < minLen)
+            return;
+        if (NON_ENTITY_TOKEN.test(normalized))
+            return;
+        if (STOPWORDS.has(normalized))
+            return;
+        if (seen.has(normalized))
+            return;
+        seen.add(normalized);
+        entities.push(normalized);
+    };
+    // 1. Quoted strings and backticked code spans are always entities.
+    // Single-character delimiters with lazy content (no `+` quantifiers
+    // adjacent to the negated class): nothing can be matched two ways, so
+    // the scan stays linear on adversarial, quote-heavy input — a
+    // polynomial-backtracking hazard with the previous `["'`]+` form.
+    for (const match of text.matchAll(/["'`]([^"'`\n]{3,60}?)["'`]/g)) {
+        push(match[1]);
+    }
+    // 2. Code identifiers (snake_case / kebab-case / dotted / camelCase).
+    for (const token of text.split(/[^A-Za-z0-9_\-.]+/)) {
+        if (token.length >= MIN_WORD_LENGTH &&
+            isCodeIdentifier(token) &&
+            !STOPWORDS.has(token.toLowerCase())) {
+            push(token);
+        }
+    }
+    // 3. Capitalized sequences (proper nouns), skipping sentence starts.
+    // A token is "sentence-initial" when the previous non-space char is
+    // nothing, `.`, `!`, `?`, or a newline.
+    const tokens = [...text.matchAll(/[A-Za-z][A-Za-z0-9'_-]*/g)];
+    for (let i = 0; i < tokens.length; i += 1) {
+        const match = tokens[i];
+        const token = match[0];
+        const prevChar = match.index && match.index > 0 ? text[match.index - 1] : "";
+        const sentenceInitial = match.index === 0 || /[.!?\n]/.test(prevChar) || prevChar === "\n";
+        if (isAcronym(token)) {
+            // Acronyms are high-signal at any length (CI, KV, DB) — the
+            // general minimum length only guards prose words.
+            push(token, 2);
+            continue;
+        }
+        if (sentenceInitial)
+            continue;
+        if (!/^[A-Z]/.test(token))
+            continue;
+        if (STOPWORDS.has(token.toLowerCase()))
+            continue;
+        // Extend across adjacent capitalized words ("Postgres Connection
+        // Pool") into one entity.
+        let phrase = token;
+        let lastIndex = match.index + token.length;
+        for (let j = i + 1; j < tokens.length; j += 1) {
+            const next = tokens[j];
+            const between = text.slice(lastIndex, next.index);
+            if (between !== " ")
+                break;
+            if (!/^[A-Z]/.test(next[0]) || STOPWORDS.has(next[0].toLowerCase()))
+                break;
+            phrase += ` ${next[0]}`;
+            lastIndex = next.index + next[0].length;
+        }
+        push(phrase);
+    }
+    return entities;
+}
+/**
+ * Overlap between query entities and a memory's stored entities
+ * (`metadata.entities`) and tags, in [0, 1]. Jaccard-style: shared
+ * count over the smaller set, so a single match on a 1-entity query
+ * counts fully.
+ */
+export function entityOverlap(queryEntities, node) {
+    if (queryEntities.length === 0)
+        return 0;
+    const stored = new Set();
+    for (const tag of node.tags ?? []) {
+        stored.add(String(tag).toLowerCase());
+    }
+    const metaEntities = node.metadata?.entities;
+    if (Array.isArray(metaEntities)) {
+        for (const entity of metaEntities) {
+            stored.add(String(entity).toLowerCase());
+        }
+    }
+    if (stored.size === 0)
+        return 0;
+    let shared = 0;
+    for (const entity of queryEntities) {
+        // Substring match both ways so "postgres connection pool" matches a
+        // memory tagged "postgres" and vice versa.
+        for (const candidate of stored) {
+            if (candidate === entity ||
+                candidate.includes(entity) ||
+                entity.includes(candidate)) {
+                shared += 1;
+                break;
+            }
+        }
+    }
+    return shared / Math.min(queryEntities.length, stored.size);
+}
+// ---------------------------------------------------------------------------
+// Entity resolution (aliasing)
+// ---------------------------------------------------------------------------
+/**
+ * Built-in alias table mapping surface forms to a canonical entity.
+ * Lexical extraction alone yields "Postgres", "PostgreSQL", and "pg" as
+ * three different entities; canonicalizing through this map (plus any
+ * deployment-specific `MemOSConfig.entityAliases`) collapses them so the
+ * overlap signal fires across phrasings.
+ */
+export const BUILTIN_ENTITY_ALIASES = {
+    pg: "postgres",
+    postgres: "postgres",
+    postgresql: "postgres",
+    pgsql: "postgres",
+    js: "javascript",
+    nodejs: "node",
+    "node.js": "node",
+    ts: "typescript",
+    k8s: "kubernetes",
+    ks: "kubernetes",
+    py: "python",
+    pip: "python",
+    yarn: "npm",
+    npm: "npm",
+    docker: "docker",
+    containerd: "docker",
+    rust: "rust",
+    go: "golang",
+    golang: "golang",
+    rails: "rails",
+    react: "react",
+    nextjs: "next",
+    "next.js": "next",
+    vue: "vue",
+    s3: "aws",
+    aws: "aws",
+    gcp: "gcp",
+    gh: "github",
+    github: "github",
+    gha: "github-actions",
+    llm: "llm",
+    agent: "agent",
+    agents: "agent",
+    db: "database",
+    database: "database",
+    redis: "redis",
+    sqlite: "sqlite",
+    graphql: "graphql",
+};
+/**
+ * Canonicalize extracted entities through the built-in alias table plus
+ * any deployment-specific aliases (from `MemOSConfig.entityAliases`,
+ * which wins over built-ins). Deduplicates after mapping, preserving
+ * first-appearance order.
+ */
+export function canonicalizeEntities(entities, extraAliases) {
+    const aliases = extraAliases
+        ? { ...BUILTIN_ENTITY_ALIASES, ...lowerKeys(extraAliases) }
+        : BUILTIN_ENTITY_ALIASES;
+    const out = [];
+    const seen = new Set();
+    for (const entity of entities) {
+        const key = entity.toLowerCase();
+        const canonical = (aliases[key] ?? key).toLowerCase();
+        if (seen.has(canonical))
+            continue;
+        seen.add(canonical);
+        out.push(canonical);
+    }
+    return out;
+}
+function lowerKeys(record) {
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        out[key.toLowerCase()] = value.toLowerCase();
+    }
+    return out;
+}
+//# sourceMappingURL=entity-extraction.js.map

memos/_js/entity-extraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-extraction.js","sourceRoot":"","sources":["../src/entity-extraction.ts"],"names":[],"mappings":"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"}

memos/_js/entity-index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * First-class entity index: an entity → memories inverted table in SQLite.
+ *
+ * MemOS already had an entity *signal* — the post-fusion entity-overlap
+ * boost in `fuseResults` (`src/retrieval.ts`) — but it could only re-score
+ * candidates the keyword (FTS5) and semantic legs had already retrieved.
+ * Memories that share entities with the query yet were missed by both
+ * legs never entered the candidate pool at all. This module closes that
+ * recall gap: every node's canonical entities are mirrored into the
+ * `entity_index` table at write time (following the `node_tags` join-table
+ * pattern), and `searchByEntities` turns query entities into a ranked
+ * candidate list that `MemOS.hybridSearch` fuses as a third RRF leg.
+ *
+ * This is the local, no-LLM analogue of the entity channel behind mem0
+ * v3's reported +20/+26 point jump and HippoRAG's entity-node gains: the
+ * extractor is the existing dependency-free lexical one
+ * (`src/entity-extraction.ts`), and the index is a plain B-tree — no
+ * embedding or graph traversal on the hot path.
+ *
+ * @module @mem-os/entity-index
+ */
+import type Database from "better-sqlite3";
+/** One ranked hit from {@link searchByEntities}. */
+export interface EntityIndexMatch {
+    /** The matched node's id. */
+    nodeId: string;
+    /** How many of the query entities this node matched. */
+    matches: number;
+}
+/**
+ * Create the `entity_index` inverted table and its lookup index when
+ * missing. Migration-safe (`IF NOT EXISTS`): pre-existing databases gain
+ * the table on the next `init()` with no schema-version bump, and
+ * {@link backfillEntityIndex} populates it from existing rows.
+ *
+ * Node deletions cascade (`ON DELETE CASCADE` + `PRAGMA foreign_keys =
+ * ON`), so no explicit cleanup is needed on the delete path.
+ */
+export declare function ensureEntityIndexTable(db: Database.Database): void;
+/**
+ * Extract + canonicalize entities from free text (lowercase-normalized,
+ * deduped, first-appearance order). Used when no pre-canonicalized entity
+ * list is on hand — legacy rows in the backfill, or rows written straight
+ * through storage bypassing `MemOS.store`. `extraAliases` mirrors
+ * `MemOSConfig.entityAliases` (storage itself has no config, so the
+ * write/backfill paths pass none and get the built-in table).
+ */
+export declare function extractContentEntities(content: string, extraAliases?: Readonly<Record<string, string>>): string[];
+/**
+ * Normalize raw entity strings for index storage: lowercase + trim +
+ * dedupe, preserving first-appearance order. The index is always
+ * lowercase, so lookups are case-insensitive by construction.
+ */
+export declare function normalizeEntities(entities: readonly unknown[]): string[];
+/**
+ * Full re-sync of one node's entity rows: deletes stale rows, then
+ * inserts the normalized set (`INSERT OR IGNORE` keeps it idempotent).
+ * Runs inside the caller's transaction — call from `saveNode` /
+ * `updateNode` next to their `node_tags` mirrors.
+ */
+export declare function writeEntityIndexRows(db: Database.Database, nodeId: string, entities: readonly unknown[]): void;
+/**
+ * Index one node's entities from its content: extracts with
+ * `extractQueryEntities` + `canonicalizeEntities` and stores
+ * lowercase-normalized rows. Prefer passing the write-time canonicalized
+ * `metadata.entities` via {@link writeEntityIndexRows} when available
+ * (it was canonicalized with the deployment's `entityAliases`); this
+ * content-based variant is the fallback for rows that lack it.
+ */
+export declare function indexNodeEntities(db: Database.Database, nodeId: string, content: string, extraAliases?: Readonly<Record<string, string>>): void;
+/**
+ * Remove every index row for a node. Node deletes are normally handled by
+ * the `ON DELETE CASCADE` foreign key — this is for explicit re-syncs.
+ */
+export declare function removeNodeEntities(db: Database.Database, nodeId: string): void;
+/**
+ * Ranked entity-leg lookup: node ids whose indexed entities intersect
+ * `entities`, ordered by matched-entity count (desc) with node id as the
+ * deterministic tiebreak. Returns `{ nodeId, matches }` pairs, best
+ * first — the caller (hybrid search) resolves ids to nodes and fuses the
+ * list as the third RRF leg.
+ */
+export declare function searchByEntities(db: Database.Database, entities: readonly string[], limit: number): EntityIndexMatch[];
+/**
+ * One-time backfill for rows that predate the `entity_index` table (or
+ * lost their rows out-of-band). For each node missing from the index,
+ * prefers the stored `metadata.entities` — already canonicalized with the
+ * deployment's aliases at write time — and falls back to extracting from
+ * content. Idempotent: nodes already present in the index are skipped and
+ * inserts use `INSERT OR IGNORE`, so re-running is a no-op.
+ */
+export declare function backfillEntityIndex(db: Database.Database): void;
+//# sourceMappingURL=entity-index.d.ts.map

memos/_js/entity-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-index.d.ts","sourceRoot":"","sources":["../src/entity-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAM3C,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAUlE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC9C,MAAM,EAAE,CAEV;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,EAAE,CAUxE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,IAAI,CAUN;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC9C,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB,EAAE,CAkBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAuC/D"}

memos/_js/entity-index.js

@@ -0,0 +1,165 @@
+/**
+ * First-class entity index: an entity → memories inverted table in SQLite.
+ *
+ * MemOS already had an entity *signal* — the post-fusion entity-overlap
+ * boost in `fuseResults` (`src/retrieval.ts`) — but it could only re-score
+ * candidates the keyword (FTS5) and semantic legs had already retrieved.
+ * Memories that share entities with the query yet were missed by both
+ * legs never entered the candidate pool at all. This module closes that
+ * recall gap: every node's canonical entities are mirrored into the
+ * `entity_index` table at write time (following the `node_tags` join-table
+ * pattern), and `searchByEntities` turns query entities into a ranked
+ * candidate list that `MemOS.hybridSearch` fuses as a third RRF leg.
+ *
+ * This is the local, no-LLM analogue of the entity channel behind mem0
+ * v3's reported +20/+26 point jump and HippoRAG's entity-node gains: the
+ * extractor is the existing dependency-free lexical one
+ * (`src/entity-extraction.ts`), and the index is a plain B-tree — no
+ * embedding or graph traversal on the hot path.
+ *
+ * @module @mem-os/entity-index
+ */
+import { canonicalizeEntities, extractQueryEntities, } from "./entity-extraction.js";
+/**
+ * Create the `entity_index` inverted table and its lookup index when
+ * missing. Migration-safe (`IF NOT EXISTS`): pre-existing databases gain
+ * the table on the next `init()` with no schema-version bump, and
+ * {@link backfillEntityIndex} populates it from existing rows.
+ *
+ * Node deletions cascade (`ON DELETE CASCADE` + `PRAGMA foreign_keys =
+ * ON`), so no explicit cleanup is needed on the delete path.
+ */
+export function ensureEntityIndexTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS entity_index (
+      entity  TEXT NOT NULL,
+      node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+      PRIMARY KEY (entity, node_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_entity_index_entity
+      ON entity_index(entity);
+  `);
+}
+/**
+ * Extract + canonicalize entities from free text (lowercase-normalized,
+ * deduped, first-appearance order). Used when no pre-canonicalized entity
+ * list is on hand — legacy rows in the backfill, or rows written straight
+ * through storage bypassing `MemOS.store`. `extraAliases` mirrors
+ * `MemOSConfig.entityAliases` (storage itself has no config, so the
+ * write/backfill paths pass none and get the built-in table).
+ */
+export function extractContentEntities(content, extraAliases) {
+    return canonicalizeEntities(extractQueryEntities(content), extraAliases);
+}
+/**
+ * Normalize raw entity strings for index storage: lowercase + trim +
+ * dedupe, preserving first-appearance order. The index is always
+ * lowercase, so lookups are case-insensitive by construction.
+ */
+export function normalizeEntities(entities) {
+    const out = [];
+    const seen = new Set();
+    for (const entity of entities) {
+        const normalized = String(entity).toLowerCase().trim();
+        if (normalized.length === 0 || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Full re-sync of one node's entity rows: deletes stale rows, then
+ * inserts the normalized set (`INSERT OR IGNORE` keeps it idempotent).
+ * Runs inside the caller's transaction — call from `saveNode` /
+ * `updateNode` next to their `node_tags` mirrors.
+ */
+export function writeEntityIndexRows(db, nodeId, entities) {
+    const normalized = normalizeEntities(entities);
+    db.prepare("DELETE FROM entity_index WHERE node_id = ?").run(nodeId);
+    if (normalized.length === 0)
+        return;
+    const insert = db.prepare("INSERT OR IGNORE INTO entity_index (entity, node_id) VALUES (?, ?)");
+    for (const entity of normalized) {
+        insert.run(entity, nodeId);
+    }
+}
+/**
+ * Index one node's entities from its content: extracts with
+ * `extractQueryEntities` + `canonicalizeEntities` and stores
+ * lowercase-normalized rows. Prefer passing the write-time canonicalized
+ * `metadata.entities` via {@link writeEntityIndexRows} when available
+ * (it was canonicalized with the deployment's `entityAliases`); this
+ * content-based variant is the fallback for rows that lack it.
+ */
+export function indexNodeEntities(db, nodeId, content, extraAliases) {
+    writeEntityIndexRows(db, nodeId, extractContentEntities(content, extraAliases));
+}
+/**
+ * Remove every index row for a node. Node deletes are normally handled by
+ * the `ON DELETE CASCADE` foreign key — this is for explicit re-syncs.
+ */
+export function removeNodeEntities(db, nodeId) {
+    db.prepare("DELETE FROM entity_index WHERE node_id = ?").run(nodeId);
+}
+/**
+ * Ranked entity-leg lookup: node ids whose indexed entities intersect
+ * `entities`, ordered by matched-entity count (desc) with node id as the
+ * deterministic tiebreak. Returns `{ nodeId, matches }` pairs, best
+ * first — the caller (hybrid search) resolves ids to nodes and fuses the
+ * list as the third RRF leg.
+ */
+export function searchByEntities(db, entities, limit) {
+    const normalized = normalizeEntities(entities);
+    if (normalized.length === 0 || limit <= 0)
+        return [];
+    const placeholders = normalized.map(() => "?").join(", ");
+    const rows = db
+        .prepare(`SELECT node_id AS nodeId, COUNT(*) AS matches
+       FROM entity_index
+       WHERE entity IN (${placeholders})
+       GROUP BY node_id
+       ORDER BY matches DESC, node_id ASC
+       LIMIT ?`)
+        .all(...normalized, limit);
+    return rows.map((row) => ({
+        nodeId: String(row.nodeId),
+        matches: Number(row.matches),
+    }));
+}
+/**
+ * One-time backfill for rows that predate the `entity_index` table (or
+ * lost their rows out-of-band). For each node missing from the index,
+ * prefers the stored `metadata.entities` — already canonicalized with the
+ * deployment's aliases at write time — and falls back to extracting from
+ * content. Idempotent: nodes already present in the index are skipped and
+ * inserts use `INSERT OR IGNORE`, so re-running is a no-op.
+ */
+export function backfillEntityIndex(db) {
+    const indexed = new Set(db.prepare("SELECT node_id FROM entity_index").all().map((row) => row.node_id));
+    const rows = db
+        .prepare("SELECT id, content, metadata FROM nodes")
+        .all();
+    if (rows.length === 0)
+        return;
+    const tx = db.transaction(() => {
+        for (const row of rows) {
+            if (indexed.has(row.id))
+                continue;
+            let entities = null;
+            try {
+                const metadata = JSON.parse(row.metadata);
+                if (Array.isArray(metadata?.entities)) {
+                    entities = metadata.entities;
+                }
+            }
+            catch {
+                // Corrupt metadata JSON: fall through to content extraction.
+            }
+            writeEntityIndexRows(db, row.id, entities ?? extractContentEntities(row.content));
+            indexed.add(row.id);
+        }
+    });
+    tx();
+}
+//# sourceMappingURL=entity-index.js.map

memos/_js/entity-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-index.js","sourceRoot":"","sources":["../src/entity-index.ts"],"names":[],"mappings":"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"}