@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/features/ObservationNormalizer.js

@@ -1,193 +0,0 @@
-/**
- * Observation Normalizer
- *
- * Phase 11: Transforms observations to be self-contained facts
- * through coreference resolution and temporal anchoring.
- *
- * @module features/ObservationNormalizer
- */
-/**
- * Observation Normalizer transforms observations to self-contained facts.
- *
- * Applies transformations:
- * 1. Coreference resolution: 'He works' -> 'Alice works'
- * 2. Temporal anchoring: 'yesterday' -> '2026-01-07'
- * 3. Keyword extraction: Identifies important terms
- *
- * @example
- * ```typescript
- * const normalizer = new ObservationNormalizer();
- * const result = normalizer.normalize(
- *   'He started the project yesterday',
- *   { name: 'Bob', entityType: 'person', observations: [] }
- * );
- * // result.normalized = 'Bob started the project on 2026-01-07'
- * ```
- */
-export class ObservationNormalizer {
-    pronounPatterns = {
-        masculine: /\b(he|him|his)\b/gi,
-        feminine: /\b(she|her|hers)\b/gi,
-        neutral: /\b(they|them|their|theirs)\b/gi,
-    };
-    relativeTimePatterns = [
-        [/\byesterday\b/i, (ref) => this.formatDate(this.addDays(ref, -1))],
-        [/\btoday\b/i, (ref) => this.formatDate(ref)],
-        [/\btomorrow\b/i, (ref) => this.formatDate(this.addDays(ref, 1))],
-        [/\blast week\b/i, (ref) => `week of ${this.formatDate(this.addDays(ref, -7))}`],
-        [/\blast month\b/i, (ref) => this.formatMonth(this.addMonths(ref, -1))],
-        [/\blast year\b/i, (ref) => `${ref.getFullYear() - 1}`],
-        [/\bthis week\b/i, (ref) => `week of ${this.formatDate(ref)}`],
-        [/\bthis month\b/i, (ref) => this.formatMonth(ref)],
-        [/\bthis year\b/i, (ref) => `${ref.getFullYear()}`],
-    ];
-    /**
-     * Normalize an observation for an entity.
-     */
-    normalize(observation, entity, options = {}) {
-        const { resolveCoreferences = true, anchorTimestamps = true, extractKeywords = false, referenceDate = new Date(), } = options;
-        let normalized = observation;
-        const changes = [];
-        if (resolveCoreferences) {
-            const corefResult = this.resolveCoreferences(normalized, entity);
-            if (corefResult.changed) {
-                normalized = corefResult.text;
-                changes.push(`Resolved pronouns to '${entity.name}'`);
-            }
-        }
-        if (anchorTimestamps) {
-            const timeResult = this.anchorTimestamps(normalized, referenceDate);
-            if (timeResult.changed) {
-                normalized = timeResult.text;
-                changes.push(...timeResult.replacements);
-            }
-        }
-        const keywords = extractKeywords
-            ? this.extractKeywords(normalized)
-            : undefined;
-        return {
-            original: observation,
-            normalized,
-            changes,
-            keywords,
-        };
-    }
-    /**
-     * Resolve pronouns to entity name.
-     */
-    resolveCoreferences(text, entity) {
-        let result = text;
-        let changed = false;
-        // Determine gender hint from entity type or name patterns
-        const isMasculine = this.guessMasculine(entity);
-        const isFeminine = this.guessFeminine(entity);
-        // Replace pronouns based on detected gender
-        if (isMasculine) {
-            const newText = result
-                .replace(this.pronounPatterns.masculine, entity.name);
-            if (newText !== result) {
-                result = newText;
-                changed = true;
-            }
-        }
-        else if (isFeminine) {
-            const newText = result
-                .replace(this.pronounPatterns.feminine, entity.name);
-            if (newText !== result) {
-                result = newText;
-                changed = true;
-            }
-        }
-        // Always try neutral pronouns for non-person entities
-        if (entity.entityType.toLowerCase() !== 'person') {
-            const newText = result
-                .replace(this.pronounPatterns.neutral, entity.name);
-            if (newText !== result) {
-                result = newText;
-                changed = true;
-            }
-        }
-        return { text: result, changed };
-    }
-    guessMasculine(entity) {
-        const masculineNames = ['john', 'james', 'bob', 'mike', 'david', 'alex'];
-        return masculineNames.some(n => entity.name.toLowerCase().includes(n));
-    }
-    guessFeminine(entity) {
-        const feminineNames = ['alice', 'jane', 'sarah', 'mary', 'emma', 'lisa'];
-        return feminineNames.some(n => entity.name.toLowerCase().includes(n));
-    }
-    /**
-     * Convert relative timestamps to absolute dates.
-     */
-    anchorTimestamps(text, referenceDate) {
-        let result = text;
-        const replacements = [];
-        for (const [pattern, resolver] of this.relativeTimePatterns) {
-            const match = result.match(pattern);
-            if (match) {
-                const replacement = resolver(referenceDate);
-                result = result.replace(pattern, replacement);
-                replacements.push(`'${match[0]}' -> '${replacement}'`);
-            }
-        }
-        return {
-            text: result,
-            changed: replacements.length > 0,
-            replacements,
-        };
-    }
-    addDays(date, days) {
-        const result = new Date(date);
-        result.setDate(result.getDate() + days);
-        return result;
-    }
-    addMonths(date, months) {
-        const result = new Date(date);
-        result.setMonth(result.getMonth() + months);
-        return result;
-    }
-    formatDate(date) {
-        return date.toISOString().split('T')[0];
-    }
-    formatMonth(date) {
-        return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
-    }
-    /**
-     * Extract important keywords from text.
-     */
-    extractKeywords(text) {
-        const stopwords = new Set([
-            'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
-            'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will',
-            'would', 'could', 'should', 'may', 'might', 'must', 'shall',
-            'can', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by',
-            'from', 'as', 'into', 'through', 'during', 'before', 'after',
-            'above', 'below', 'between', 'under', 'again', 'further',
-            'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how',
-            'all', 'each', 'few', 'more', 'most', 'other', 'some', 'such',
-            'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too',
-            'very', 's', 't', 'just', 'don', 'now', 'and', 'but', 'or',
-        ]);
-        const words = text
-            .toLowerCase()
-            .replace(/[^a-z0-9\s]/g, '')
-            .split(/\s+/)
-            .filter(w => w.length > 2 && !stopwords.has(w));
-        // Return unique keywords
-        return [...new Set(words)];
-    }
-    /**
-     * Normalize all observations for an entity.
-     */
-    normalizeEntity(entity, options = {}) {
-        const results = entity.observations.map(obs => this.normalize(obs, entity, options));
-        return {
-            entity: {
-                ...entity,
-                observations: results.map(r => r.normalized),
-            },
-            results,
-        };
-    }
-}

package/dist/memory.jsonl

@@ -1 +0,0 @@
-{"type":"entity","name":"Test Project","entityType":"project","observations":["Phase 1-4 testing"],"createdAt":"2025-11-11T01:02:31.337Z","lastModified":"2025-11-11T01:02:33.329Z","tags":["testing","phase3"],"importance":8}

package/dist/search/BM25Search.d.ts

@@ -1,148 +0,0 @@
-/**
- * BM25 Search
- *
- * BM25 (Best Matching 25) relevance scoring algorithm for lexical search.
- * Provides improved ranking over TF-IDF by incorporating document length normalization.
- *
- * Phase 12 Sprint 3: Search Algorithm Optimization
- *
- * @module search/BM25Search
- */
-import type { SearchResult } from '../types/index.js';
-import type { GraphStorage } from '../core/GraphStorage.js';
-/**
- * Common English stopwords to filter from queries and documents.
- * These words are too common to provide meaningful ranking signal.
- */
-export declare const STOPWORDS: Set<string>;
-/**
- * BM25 index entry for a single document.
- */
-export interface BM25DocumentEntry {
-    /** Entity name */
-    entityName: string;
-    /** Term frequencies in this document */
-    termFreqs: Map<string, number>;
-    /** Total number of tokens in document */
-    docLength: number;
-}
-/**
- * BM25 index structure.
- */
-export interface BM25Index {
-    /** Document entries keyed by entity name */
-    documents: Map<string, BM25DocumentEntry>;
-    /** Document frequency for each term (number of docs containing term) */
-    documentFrequency: Map<string, number>;
-    /** Average document length */
-    avgDocLength: number;
-    /** Total number of documents */
-    totalDocs: number;
-}
-/**
- * BM25 configuration parameters.
- */
-export interface BM25Config {
-    /** Term frequency saturation parameter (default: 1.2) */
-    k1: number;
-    /** Length normalization parameter (default: 0.75) */
-    b: number;
-}
-/**
- * Default BM25 parameters based on research recommendations.
- */
-export declare const DEFAULT_BM25_CONFIG: BM25Config;
-/**
- * BM25 Search implementation.
- *
- * BM25 improves over TF-IDF by:
- * 1. Saturating term frequency - prevents long documents from dominating
- * 2. Document length normalization - accounts for varying document sizes
- *
- * Formula:
- * score(D,Q) = sum_i( IDF(qi) * (f(qi,D) * (k1 + 1)) / (f(qi,D) + k1 * (1 - b + b * |D|/avgdl)) )
- *
- * Where:
- * - f(qi,D) is the term frequency of qi in document D
- * - |D| is the length of document D
- * - avgdl is the average document length
- * - k1 and b are free parameters
- *
- * @example
- * ```typescript
- * const bm25 = new BM25Search(storage);
- * await bm25.buildIndex();
- * const results = await bm25.search('machine learning');
- * ```
- */
-export declare class BM25Search {
-    private storage;
-    private index;
-    private config;
-    constructor(storage: GraphStorage, config?: Partial<BM25Config>);
-    /**
-     * Get the current configuration.
-     */
-    getConfig(): BM25Config;
-    /**
-     * Update configuration parameters.
-     *
-     * @param config - New configuration values
-     */
-    setConfig(config: Partial<BM25Config>): void;
-    /**
-     * Tokenize text into lowercase terms with stopword filtering.
-     *
-     * @param text - Text to tokenize
-     * @param filterStopwords - Whether to filter stopwords (default: true)
-     * @returns Array of lowercase tokens
-     */
-    tokenize(text: string, filterStopwords?: boolean): string[];
-    /**
-     * Build the BM25 index from the current graph.
-     *
-     * Should be called after significant graph changes.
-     */
-    buildIndex(): Promise<void>;
-    /**
-     * Search using the BM25 algorithm.
-     *
-     * @param query - Search query
-     * @param limit - Maximum results to return
-     * @returns Array of search results sorted by BM25 score
-     */
-    search(query: string, limit?: number): Promise<SearchResult[]>;
-    /**
-     * Update the index for changed entities.
-     *
-     * @param changedEntityNames - Names of entities that changed
-     */
-    update(changedEntityNames: Set<string>): Promise<void>;
-    /**
-     * Remove an entity from the index.
-     *
-     * @param entityName - Name of entity to remove
-     */
-    remove(entityName: string): boolean;
-    /**
-     * Clear the index.
-     */
-    clearIndex(): void;
-    /**
-     * Check if the index is built.
-     */
-    isIndexed(): boolean;
-    /**
-     * Get index statistics.
-     */
-    getIndexStats(): {
-        documents: number;
-        terms: number;
-        avgDocLength: number;
-    } | null;
-    /**
-     * Convert an entity to searchable text.
-     */
-    private entityToText;
-}
-//# sourceMappingURL=BM25Search.d.ts.map

package/dist/search/BM25Search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BM25Search.d.ts","sourceRoot":"","sources":["../../src/search/BM25Search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAU,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D;;;GAGG;AACH,eAAO,MAAM,SAAS,aAWpB,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kBAAkB;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,4CAA4C;IAC5C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC1C,wEAAwE;IACxE,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,8BAA8B;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAGjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;IAKnB,OAAO,CAAC,OAAO;IAJjB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,MAAM,CAAa;gBAGjB,OAAO,EAAE,YAAY,EAC7B,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAKlC;;OAEG;IACH,SAAS,IAAI,UAAU;IAIvB;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI;IAI5C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,GAAE,OAAc,GAAG,MAAM,EAAE;IAajE;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDjC;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAA8B,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA8E3F;;;;OAIG;IACG,MAAM,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkE5D;;;;OAIG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAmCnC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,aAAa,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAWlF;;OAEG;IACH,OAAO,CAAC,YAAY;CAGrB"}

package/dist/search/BM25Search.js

@@ -1,339 +0,0 @@
-/**
- * BM25 Search
- *
- * BM25 (Best Matching 25) relevance scoring algorithm for lexical search.
- * Provides improved ranking over TF-IDF by incorporating document length normalization.
- *
- * Phase 12 Sprint 3: Search Algorithm Optimization
- *
- * @module search/BM25Search
- */
-import { SEARCH_LIMITS } from '../utils/constants.js';
-/**
- * Common English stopwords to filter from queries and documents.
- * These words are too common to provide meaningful ranking signal.
- */
-export const STOPWORDS = new Set([
-    'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from',
-    'has', 'he', 'in', 'is', 'it', 'its', 'of', 'on', 'or', 'that',
-    'the', 'to', 'was', 'were', 'will', 'with', 'you', 'your',
-    'this', 'but', 'they', 'have', 'had', 'what', 'when', 'where',
-    'who', 'which', 'why', 'how', 'all', 'each', 'every', 'both',
-    'few', 'more', 'most', 'other', 'some', 'such', 'no', 'not',
-    'only', 'own', 'same', 'so', 'than', 'too', 'very', 'can',
-    'just', 'should', 'now', 'also', 'being', 'been', 'would',
-    'could', 'into', 'over', 'after', 'before', 'between', 'under',
-    'again', 'then', 'once', 'here', 'there', 'any', 'about',
-]);
-/**
- * Default BM25 parameters based on research recommendations.
- */
-export const DEFAULT_BM25_CONFIG = {
-    k1: 1.2,
-    b: 0.75,
-};
-/**
- * BM25 Search implementation.
- *
- * BM25 improves over TF-IDF by:
- * 1. Saturating term frequency - prevents long documents from dominating
- * 2. Document length normalization - accounts for varying document sizes
- *
- * Formula:
- * score(D,Q) = sum_i( IDF(qi) * (f(qi,D) * (k1 + 1)) / (f(qi,D) + k1 * (1 - b + b * |D|/avgdl)) )
- *
- * Where:
- * - f(qi,D) is the term frequency of qi in document D
- * - |D| is the length of document D
- * - avgdl is the average document length
- * - k1 and b are free parameters
- *
- * @example
- * ```typescript
- * const bm25 = new BM25Search(storage);
- * await bm25.buildIndex();
- * const results = await bm25.search('machine learning');
- * ```
- */
-export class BM25Search {
-    storage;
-    index = null;
-    config;
-    constructor(storage, config = {}) {
-        this.storage = storage;
-        this.config = { ...DEFAULT_BM25_CONFIG, ...config };
-    }
-    /**
-     * Get the current configuration.
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update configuration parameters.
-     *
-     * @param config - New configuration values
-     */
-    setConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-    /**
-     * Tokenize text into lowercase terms with stopword filtering.
-     *
-     * @param text - Text to tokenize
-     * @param filterStopwords - Whether to filter stopwords (default: true)
-     * @returns Array of lowercase tokens
-     */
-    tokenize(text, filterStopwords = true) {
-        const tokens = text
-            .toLowerCase()
-            .replace(/[^\w\s]/g, ' ')
-            .split(/\s+/)
-            .filter(token => token.length > 0);
-        if (filterStopwords) {
-            return tokens.filter(token => !STOPWORDS.has(token));
-        }
-        return tokens;
-    }
-    /**
-     * Build the BM25 index from the current graph.
-     *
-     * Should be called after significant graph changes.
-     */
-    async buildIndex() {
-        const graph = await this.storage.loadGraph();
-        const documents = new Map();
-        const documentFrequency = new Map();
-        const termsSeen = new Set();
-        let totalDocLength = 0;
-        // First pass: tokenize all documents and count term frequencies
-        for (const entity of graph.entities) {
-            const text = this.entityToText(entity);
-            const tokens = this.tokenize(text);
-            const termFreqs = new Map();
-            // Count term frequencies for this document
-            for (const token of tokens) {
-                termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-            }
-            // Track which terms appear in this document (for IDF calculation)
-            termsSeen.clear();
-            for (const token of tokens) {
-                if (!termsSeen.has(token)) {
-                    termsSeen.add(token);
-                    documentFrequency.set(token, (documentFrequency.get(token) || 0) + 1);
-                }
-            }
-            const entry = {
-                entityName: entity.name,
-                termFreqs,
-                docLength: tokens.length,
-            };
-            documents.set(entity.name, entry);
-            totalDocLength += tokens.length;
-        }
-        const totalDocs = documents.size;
-        const avgDocLength = totalDocs > 0 ? totalDocLength / totalDocs : 0;
-        this.index = {
-            documents,
-            documentFrequency,
-            avgDocLength,
-            totalDocs,
-        };
-    }
-    /**
-     * Search using the BM25 algorithm.
-     *
-     * @param query - Search query
-     * @param limit - Maximum results to return
-     * @returns Array of search results sorted by BM25 score
-     */
-    async search(query, limit = SEARCH_LIMITS.DEFAULT) {
-        const effectiveLimit = Math.min(limit, SEARCH_LIMITS.MAX);
-        // Ensure index is built
-        if (!this.index) {
-            await this.buildIndex();
-        }
-        if (!this.index || this.index.documents.size === 0) {
-            return [];
-        }
-        const graph = await this.storage.loadGraph();
-        const entityMap = new Map(graph.entities.map(e => [e.name, e]));
-        // Tokenize query
-        const queryTerms = this.tokenize(query);
-        if (queryTerms.length === 0) {
-            return [];
-        }
-        const { k1, b } = this.config;
-        const { documents, documentFrequency, avgDocLength, totalDocs } = this.index;
-        const results = [];
-        // Calculate BM25 score for each document
-        for (const [entityName, docEntry] of documents) {
-            const entity = entityMap.get(entityName);
-            if (!entity)
-                continue;
-            let score = 0;
-            const matchedFields = {};
-            for (const term of queryTerms) {
-                const tf = docEntry.termFreqs.get(term) || 0;
-                if (tf === 0)
-                    continue;
-                // Calculate IDF
-                const df = documentFrequency.get(term) || 0;
-                const idf = df > 0 ? Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1) : 0;
-                // Calculate BM25 score component
-                const numerator = tf * (k1 + 1);
-                const denominator = tf + k1 * (1 - b + b * (docEntry.docLength / avgDocLength));
-                const termScore = idf * (numerator / denominator);
-                score += termScore;
-                // Track which fields matched
-                if (entity.name.toLowerCase().includes(term)) {
-                    matchedFields.name = true;
-                }
-                if (entity.entityType.toLowerCase().includes(term)) {
-                    matchedFields.entityType = true;
-                }
-                const matchedObs = entity.observations.filter(o => o.toLowerCase().includes(term));
-                if (matchedObs.length > 0) {
-                    matchedFields.observations = matchedObs;
-                }
-            }
-            if (score > 0) {
-                results.push({
-                    entity,
-                    score,
-                    matchedFields,
-                });
-            }
-        }
-        // Sort by score descending and limit
-        return results
-            .sort((a, b) => b.score - a.score)
-            .slice(0, effectiveLimit);
-    }
-    /**
-     * Update the index for changed entities.
-     *
-     * @param changedEntityNames - Names of entities that changed
-     */
-    async update(changedEntityNames) {
-        if (!this.index) {
-            await this.buildIndex();
-            return;
-        }
-        const graph = await this.storage.loadGraph();
-        const entityMap = new Map(graph.entities.map(e => [e.name, e]));
-        // Process each changed entity
-        for (const entityName of changedEntityNames) {
-            const entity = entityMap.get(entityName);
-            const existingEntry = this.index.documents.get(entityName);
-            if (existingEntry) {
-                // Remove old term frequencies from document frequency counts
-                for (const [term] of existingEntry.termFreqs) {
-                    const df = this.index.documentFrequency.get(term) || 0;
-                    if (df <= 1) {
-                        this.index.documentFrequency.delete(term);
-                    }
-                    else {
-                        this.index.documentFrequency.set(term, df - 1);
-                    }
-                }
-                this.index.documents.delete(entityName);
-            }
-            if (entity) {
-                // Add new entry
-                const text = this.entityToText(entity);
-                const tokens = this.tokenize(text);
-                const termFreqs = new Map();
-                const termsSeen = new Set();
-                for (const token of tokens) {
-                    termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-                    if (!termsSeen.has(token)) {
-                        termsSeen.add(token);
-                        this.index.documentFrequency.set(token, (this.index.documentFrequency.get(token) || 0) + 1);
-                    }
-                }
-                const entry = {
-                    entityName: entity.name,
-                    termFreqs,
-                    docLength: tokens.length,
-                };
-                this.index.documents.set(entityName, entry);
-            }
-        }
-        // Recalculate average document length
-        this.index.totalDocs = this.index.documents.size;
-        let totalLength = 0;
-        for (const doc of this.index.documents.values()) {
-            totalLength += doc.docLength;
-        }
-        this.index.avgDocLength = this.index.totalDocs > 0
-            ? totalLength / this.index.totalDocs
-            : 0;
-    }
-    /**
-     * Remove an entity from the index.
-     *
-     * @param entityName - Name of entity to remove
-     */
-    remove(entityName) {
-        if (!this.index) {
-            return false;
-        }
-        const entry = this.index.documents.get(entityName);
-        if (!entry) {
-            return false;
-        }
-        // Update document frequency counts
-        for (const [term] of entry.termFreqs) {
-            const df = this.index.documentFrequency.get(term) || 0;
-            if (df <= 1) {
-                this.index.documentFrequency.delete(term);
-            }
-            else {
-                this.index.documentFrequency.set(term, df - 1);
-            }
-        }
-        this.index.documents.delete(entityName);
-        // Update totals
-        this.index.totalDocs = this.index.documents.size;
-        let totalLength = 0;
-        for (const doc of this.index.documents.values()) {
-            totalLength += doc.docLength;
-        }
-        this.index.avgDocLength = this.index.totalDocs > 0
-            ? totalLength / this.index.totalDocs
-            : 0;
-        return true;
-    }
-    /**
-     * Clear the index.
-     */
-    clearIndex() {
-        this.index = null;
-    }
-    /**
-     * Check if the index is built.
-     */
-    isIndexed() {
-        return this.index !== null;
-    }
-    /**
-     * Get index statistics.
-     */
-    getIndexStats() {
-        if (!this.index) {
-            return null;
-        }
-        return {
-            documents: this.index.documents.size,
-            terms: this.index.documentFrequency.size,
-            avgDocLength: this.index.avgDocLength,
-        };
-    }
-    /**
-     * Convert an entity to searchable text.
-     */
-    entityToText(entity) {
-        return [entity.name, entity.entityType, ...entity.observations].join(' ');
-    }
-}