@danielsimonjr/memory-mcp 9.8.3 → 9.9.0

package/dist/core/ManagerContext.d.ts

@@ -14,6 +14,7 @@ import { ObservationManager } from './ObservationManager.js';
 import { HierarchyManager } from './HierarchyManager.js';
 import { GraphTraversal } from './GraphTraversal.js';
 import { SearchManager } from '../search/SearchManager.js';
+import { RankedSearch } from '../search/RankedSearch.js';
 import { SemanticSearch } from '../search/index.js';
 import { IOManager } from '../features/IOManager.js';
 import { TagManager } from '../features/TagManager.js';
@@ -35,6 +36,7 @@ export declare class ManagerContext {
     private _graphTraversal?;
     private _searchManager?;
     private _semanticSearch?;
+    private _rankedSearch?;
     private _ioManager?;
     private _tagManager?;
     private _analyticsManager?;
@@ -58,6 +60,8 @@ export declare class ManagerContext {
      * Returns null if no embedding provider is configured.
      */
     get semanticSearch(): SemanticSearch | null;
+    /** RankedSearch - Phase 11: TF-IDF/BM25 ranked search for hybrid search */
+    get rankedSearch(): RankedSearch;
     /** IOManager - Import, export, and backup operations */
     get ioManager(): IOManager;
     /** TagManager - Tag alias management */

package/dist/core/ManagerContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ManagerContext.d.ts","sourceRoot":"","sources":["../../src/core/ManagerContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAA6C,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D;;;GAGG;AACH,qBAAa,cAAc;IAGzB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAG5C,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,mBAAmB,CAAC,CAAqB;IACjD,OAAO,CAAC,iBAAiB,CAAC,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,eAAe,CAAC,CAAwB;IAChD,OAAO,CAAC,UAAU,CAAC,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,iBAAiB,CAAC,CAAmB;IAC7C,OAAO,CAAC,mBAAmB,CAAC,CAAqB;IACjD,OAAO,CAAC,eAAe,CAAC,CAAiB;gBAE7B,cAAc,EAAE,MAAM;IAclC,qDAAqD;IACrD,IAAI,aAAa,IAAI,aAAa,CAEjC;IAED,sCAAsC;IACtC,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,4CAA4C;IAC5C,IAAI,kBAAkB,IAAI,kBAAkB,CAE3C;IAED,qDAAqD;IACrD,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,sEAAsE;IACtE,IAAI,cAAc,IAAI,cAAc,CAEnC;IAED,4CAA4C;IAC5C,IAAI,aAAa,IAAI,aAAa,CAEjC;IAED;;;OAGG;IACH,IAAI,cAAc,IAAI,cAAc,GAAG,IAAI,CAa1C;IAED,wDAAwD;IACxD,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,wCAAwC;IACxC,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED,yDAAyD;IACzD,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,kEAAkE;IAClE,IAAI,kBAAkB,IAAI,kBAAkB,CAE3C;IAED,kDAAkD;IAClD,IAAI,cAAc,IAAI,cAAc,CAEnC;CACF"}
+{"version":3,"file":"ManagerContext.d.ts","sourceRoot":"","sources":["../../src/core/ManagerContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAA6C,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D;;;GAGG;AACH,qBAAa,cAAc;IAGzB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAG5C,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,mBAAmB,CAAC,CAAqB;IACjD,OAAO,CAAC,iBAAiB,CAAC,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,eAAe,CAAC,CAAwB;IAChD,OAAO,CAAC,aAAa,CAAC,CAAe;IACrC,OAAO,CAAC,UAAU,CAAC,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,iBAAiB,CAAC,CAAmB;IAC7C,OAAO,CAAC,mBAAmB,CAAC,CAAqB;IACjD,OAAO,CAAC,eAAe,CAAC,CAAiB;gBAE7B,cAAc,EAAE,MAAM;IAclC,qDAAqD;IACrD,IAAI,aAAa,IAAI,aAAa,CAEjC;IAED,sCAAsC;IACtC,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,4CAA4C;IAC5C,IAAI,kBAAkB,IAAI,kBAAkB,CAE3C;IAED,qDAAqD;IACrD,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,sEAAsE;IACtE,IAAI,cAAc,IAAI,cAAc,CAEnC;IAED,4CAA4C;IAC5C,IAAI,aAAa,IAAI,aAAa,CAEjC;IAED;;;OAGG;IACH,IAAI,cAAc,IAAI,cAAc,GAAG,IAAI,CAa1C;IAED,2EAA2E;IAC3E,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED,wDAAwD;IACxD,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,wCAAwC;IACxC,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED,yDAAyD;IACzD,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,kEAAkE;IAClE,IAAI,kBAAkB,IAAI,kBAAkB,CAE3C;IAED,kDAAkD;IAClD,IAAI,cAAc,IAAI,cAAc,CAEnC;CACF"}

package/dist/core/ManagerContext.js

@@ -15,6 +15,7 @@ import { ObservationManager } from './ObservationManager.js';
 import { HierarchyManager } from './HierarchyManager.js';
 import { GraphTraversal } from './GraphTraversal.js';
 import { SearchManager } from '../search/SearchManager.js';
+import { RankedSearch } from '../search/RankedSearch.js';
 import { SemanticSearch, createEmbeddingService, createVectorStore } from '../search/index.js';
 import { IOManager } from '../features/IOManager.js';
 import { TagManager } from '../features/TagManager.js';
@@ -40,6 +41,7 @@ export class ManagerContext {
     _graphTraversal;
     _searchManager;
     _semanticSearch;
+    _rankedSearch;
     _ioManager;
     _tagManager;
     _analyticsManager;
@@ -99,6 +101,10 @@ export class ManagerContext {
         }
         return this._semanticSearch;
     }
+    /** RankedSearch - Phase 11: TF-IDF/BM25 ranked search for hybrid search */
+    get rankedSearch() {
+        return (this._rankedSearch ??= new RankedSearch(this.storage));
+    }
     /** IOManager - Import, export, and backup operations */
     get ioManager() {
         return (this._ioManager ??= new IOManager(this.storage));

package/dist/features/KeywordExtractor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Keyword Extractor
+ *
+ * Phase 11: Extracts and scores keywords from text
+ * for lexical search enhancement.
+ *
+ * @module features/KeywordExtractor
+ */
+/**
+ * A keyword with importance score.
+ */
+export interface ScoredKeyword {
+    keyword: string;
+    score: number;
+    positions: number[];
+}
+/**
+ * Keyword Extractor extracts and scores keywords from text.
+ *
+ * Features:
+ * - Position-based scoring (earlier = more important)
+ * - Domain-specific keyword boosting
+ * - Length-based scoring (longer words often more specific)
+ * - Stopword filtering
+ *
+ * @example
+ * ```typescript
+ * const extractor = new KeywordExtractor();
+ * const keywords = extractor.extract('The software project was completed on time');
+ * // Returns scored keywords sorted by importance
+ * ```
+ */
+export declare class KeywordExtractor {
+    private stopwords;
+    private domainBoosts;
+    constructor();
+    /**
+     * Extract keywords with scores from text.
+     */
+    extract(text: string): ScoredKeyword[];
+    private tokenize;
+    private isKeyword;
+    private calculateScore;
+    /**
+     * Extract top N keywords.
+     */
+    extractTop(text: string, n: number): string[];
+    /**
+     * Add custom domain boost for a keyword.
+     */
+    addDomainBoost(keyword: string, boost: number): void;
+    /**
+     * Remove a domain boost.
+     */
+    removeDomainBoost(keyword: string): boolean;
+    /**
+     * Get all domain boosts.
+     */
+    getDomainBoosts(): Map<string, number>;
+}
+//# sourceMappingURL=KeywordExtractor.d.ts.map

package/dist/features/KeywordExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeywordExtractor.d.ts","sourceRoot":"","sources":["../../src/features/KeywordExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,YAAY,CAAsB;;IA2B1C;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE;IAyBtC,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,cAAc;IAiBtB;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAM7C;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIpD;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI3C;;OAEG;IACH,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAGvC"}

package/dist/features/KeywordExtractor.js

@@ -0,0 +1,126 @@
+/**
+ * Keyword Extractor
+ *
+ * Phase 11: Extracts and scores keywords from text
+ * for lexical search enhancement.
+ *
+ * @module features/KeywordExtractor
+ */
+/**
+ * Keyword Extractor extracts and scores keywords from text.
+ *
+ * Features:
+ * - Position-based scoring (earlier = more important)
+ * - Domain-specific keyword boosting
+ * - Length-based scoring (longer words often more specific)
+ * - Stopword filtering
+ *
+ * @example
+ * ```typescript
+ * const extractor = new KeywordExtractor();
+ * const keywords = extractor.extract('The software project was completed on time');
+ * // Returns scored keywords sorted by importance
+ * ```
+ */
+export class KeywordExtractor {
+    stopwords;
+    domainBoosts;
+    constructor() {
+        this.stopwords = new Set([
+            'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+            'could', 'should', 'can', 'to', 'of', 'in', 'for', 'on',
+            'with', 'at', 'by', 'from', 'as', 'and', 'or', 'but',
+        ]);
+        this.domainBoosts = new Map([
+            ['project', 1.5],
+            ['task', 1.5],
+            ['meeting', 1.3],
+            ['deadline', 1.4],
+            ['completed', 1.2],
+            ['started', 1.2],
+            ['person', 1.3],
+            ['company', 1.3],
+            ['team', 1.3],
+            ['release', 1.4],
+            ['feature', 1.3],
+            ['bug', 1.2],
+            ['issue', 1.2],
+            ['milestone', 1.4],
+        ]);
+    }
+    /**
+     * Extract keywords with scores from text.
+     */
+    extract(text) {
+        const words = this.tokenize(text);
+        const keywordMap = new Map();
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i].toLowerCase();
+            if (this.isKeyword(word)) {
+                const existing = keywordMap.get(word);
+                if (existing) {
+                    existing.positions.push(i);
+                    existing.score += this.calculateScore(word, i, words.length);
+                }
+                else {
+                    keywordMap.set(word, {
+                        keyword: word,
+                        score: this.calculateScore(word, i, words.length),
+                        positions: [i],
+                    });
+                }
+            }
+        }
+        return Array.from(keywordMap.values())
+            .sort((a, b) => b.score - a.score);
+    }
+    tokenize(text) {
+        return text
+            .replace(/[^a-zA-Z0-9\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 0);
+    }
+    isKeyword(word) {
+        return word.length > 2 && !this.stopwords.has(word);
+    }
+    calculateScore(word, position, totalWords) {
+        let score = 1.0;
+        // Position boost (earlier = more important)
+        const positionFactor = 1 - (position / totalWords) * 0.3;
+        score *= positionFactor;
+        // Domain boost
+        const boost = this.domainBoosts.get(word) ?? 1.0;
+        score *= boost;
+        // Length boost (longer words often more specific)
+        if (word.length > 6)
+            score *= 1.1;
+        return score;
+    }
+    /**
+     * Extract top N keywords.
+     */
+    extractTop(text, n) {
+        return this.extract(text)
+            .slice(0, n)
+            .map(k => k.keyword);
+    }
+    /**
+     * Add custom domain boost for a keyword.
+     */
+    addDomainBoost(keyword, boost) {
+        this.domainBoosts.set(keyword.toLowerCase(), boost);
+    }
+    /**
+     * Remove a domain boost.
+     */
+    removeDomainBoost(keyword) {
+        return this.domainBoosts.delete(keyword.toLowerCase());
+    }
+    /**
+     * Get all domain boosts.
+     */
+    getDomainBoosts() {
+        return new Map(this.domainBoosts);
+    }
+}

package/dist/features/ObservationNormalizer.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Observation Normalizer
+ *
+ * Phase 11: Transforms observations to be self-contained facts
+ * through coreference resolution and temporal anchoring.
+ *
+ * @module features/ObservationNormalizer
+ */
+import type { Entity } from '../types/index.js';
+/**
+ * Options for observation normalization.
+ */
+export interface NormalizationOptions {
+    /** Resolve pronouns to entity names */
+    resolveCoreferences?: boolean;
+    /** Convert relative dates to absolute dates */
+    anchorTimestamps?: boolean;
+    /** Extract and tag keywords */
+    extractKeywords?: boolean;
+    /** Reference date for relative date conversion (default: now) */
+    referenceDate?: Date;
+}
+/**
+ * Result of normalizing an observation.
+ */
+export interface NormalizationResult {
+    original: string;
+    normalized: string;
+    changes: string[];
+    keywords?: string[];
+}
+/**
+ * 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 declare class ObservationNormalizer {
+    private pronounPatterns;
+    private relativeTimePatterns;
+    /**
+     * Normalize an observation for an entity.
+     */
+    normalize(observation: string, entity: Entity, options?: NormalizationOptions): NormalizationResult;
+    /**
+     * Resolve pronouns to entity name.
+     */
+    resolveCoreferences(text: string, entity: Entity): {
+        text: string;
+        changed: boolean;
+    };
+    private guessMasculine;
+    private guessFeminine;
+    /**
+     * Convert relative timestamps to absolute dates.
+     */
+    anchorTimestamps(text: string, referenceDate: Date): {
+        text: string;
+        changed: boolean;
+        replacements: string[];
+    };
+    private addDays;
+    private addMonths;
+    private formatDate;
+    private formatMonth;
+    /**
+     * Extract important keywords from text.
+     */
+    extractKeywords(text: string): string[];
+    /**
+     * Normalize all observations for an entity.
+     */
+    normalizeEntity(entity: Entity, options?: NormalizationOptions): {
+        entity: Entity;
+        results: NormalizationResult[];
+    };
+}
+//# sourceMappingURL=ObservationNormalizer.d.ts.map

package/dist/features/ObservationNormalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservationNormalizer.d.ts","sourceRoot":"","sources":["../../src/features/ObservationNormalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,uCAAuC;IACvC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,+CAA+C;IAC/C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,+BAA+B;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iEAAiE;IACjE,aAAa,CAAC,EAAE,IAAI,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,eAAe,CAIrB;IAEF,OAAO,CAAC,oBAAoB,CAU1B;IAEF;;OAEG;IACH,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,oBAAyB,GACjC,mBAAmB;IAuCtB;;OAEG;IACH,mBAAmB,CACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IAsCrC,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,aAAa;IAKrB;;OAEG;IACH,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,IAAI,GAClB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE;IAoB7D,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAwBvC;;OAEG;IACH,eAAe,CACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,oBAAyB,GACjC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,mBAAmB,EAAE,CAAA;KAAE;CAatD"}

package/dist/features/ObservationNormalizer.js

@@ -0,0 +1,193 @@
+/**
+ * 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/features/index.d.ts

@@ -9,4 +9,6 @@ export { AnalyticsManager } from './AnalyticsManager.js';
 export { CompressionManager } from './CompressionManager.js';
 export { ArchiveManager, type ArchiveCriteria, type ArchiveOptions, type ArchiveResult, } from './ArchiveManager.js';
 export { StreamingExporter, type StreamResult } from './StreamingExporter.js';
+export { ObservationNormalizer, type NormalizationOptions, type NormalizationResult, } from './ObservationNormalizer.js';
+export { KeywordExtractor, type ScoredKeyword, } from './KeywordExtractor.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/features/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/features/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/features/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG9E,OAAO,EACL,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,uBAAuB,CAAC"}

package/dist/features/index.js

@@ -9,3 +9,6 @@ export { AnalyticsManager } from './AnalyticsManager.js';
 export { CompressionManager } from './CompressionManager.js';
 export { ArchiveManager, } from './ArchiveManager.js';
 export { StreamingExporter } from './StreamingExporter.js';
+// Phase 11 Sprint 5: Semantic Compression
+export { ObservationNormalizer, } from './ObservationNormalizer.js';
+export { KeywordExtractor, } from './KeywordExtractor.js';

package/dist/search/HybridSearchManager.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Hybrid Search Manager
+ *
+ * Phase 11: Orchestrates three-layer hybrid search combining
+ * semantic, lexical, and symbolic signals.
+ *
+ * @module search/HybridSearchManager
+ */
+import type { HybridSearchOptions, HybridSearchResult, ReadonlyKnowledgeGraph } from '../types/index.js';
+import type { SemanticSearch } from './SemanticSearch.js';
+import type { RankedSearch } from './RankedSearch.js';
+import { SymbolicSearch } from './SymbolicSearch.js';
+/**
+ * Default weights for hybrid search layers.
+ */
+export declare const DEFAULT_HYBRID_WEIGHTS: {
+    semantic: number;
+    lexical: number;
+    symbolic: number;
+};
+/**
+ * Hybrid Search Manager
+ *
+ * Combines three search layers:
+ * 1. Semantic: Vector similarity via embeddings
+ * 2. Lexical: Keyword matching via TF-IDF/BM25
+ * 3. Symbolic: Structured metadata filtering
+ *
+ * @example
+ * ```typescript
+ * const hybrid = new HybridSearchManager(semanticSearch, rankedSearch);
+ * const results = await hybrid.search(graph, 'machine learning', {
+ *   semanticWeight: 0.5,
+ *   lexicalWeight: 0.3,
+ *   symbolicWeight: 0.2,
+ *   symbolic: { tags: ['ai'] }
+ * });
+ * ```
+ */
+export declare class HybridSearchManager {
+    private semanticSearch;
+    private rankedSearch;
+    private symbolicSearch;
+    constructor(semanticSearch: SemanticSearch | null, rankedSearch: RankedSearch);
+    /**
+     * Perform hybrid search combining all three layers.
+     *
+     * @param graph - Knowledge graph to search
+     * @param query - Search query text
+     * @param options - Hybrid search options with weights
+     * @returns Combined and ranked results
+     */
+    search(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
+    /**
+     * Execute semantic search layer.
+     */
+    private executeSemanticSearch;
+    /**
+     * Execute lexical search layer (TF-IDF/BM25).
+     */
+    private executeLexicalSearch;
+    /**
+     * Execute symbolic search layer.
+     */
+    private executeSymbolicSearch;
+    /**
+     * Merge results from all three layers.
+     */
+    private mergeResults;
+    /**
+     * Search with full entity resolution.
+     * Alias for search() since we now always resolve entities.
+     */
+    searchWithEntities(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
+    /**
+     * Get the symbolic search instance for direct access.
+     */
+    getSymbolicSearch(): SymbolicSearch;
+}
+//# sourceMappingURL=HybridSearchManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HybridSearchManager.d.ts","sourceRoot":"","sources":["../../src/search/HybridSearchManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAEV,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,YAAY;IAJtB,OAAO,CAAC,cAAc,CAAiB;gBAG7B,cAAc,EAAE,cAAc,GAAG,IAAI,EACrC,YAAY,EAAE,YAAY;IAKpC;;;;;;;OAOG;IACG,MAAM,CACV,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACzC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAuChC;;OAEG;YACW,qBAAqB;IA8BnC;;OAEG;YACW,oBAAoB;IA4BlC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAkDpB;;;OAGG;IACG,kBAAkB,CACtB,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACzC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhC;;OAEG;IACH,iBAAiB,IAAI,cAAc;CAGpC"}