@danielsimonjr/memory-mcp 9.8.3 → 9.9.0

package/dist/search/ReflectionManager.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Reflection Manager
+ *
+ * Phase 11: Implements reflection-based iterative retrieval
+ * that refines results until adequate.
+ *
+ * @module search/ReflectionManager
+ */
+import type { ReadonlyKnowledgeGraph, HybridSearchResult, HybridSearchOptions } from '../types/index.js';
+import type { HybridSearchManager } from './HybridSearchManager.js';
+import type { QueryAnalyzer } from './QueryAnalyzer.js';
+/**
+ * Options for reflection-based retrieval.
+ */
+export interface ReflectionOptions {
+    /** Maximum number of reflection iterations (default: 3) */
+    maxIterations?: number;
+    /** Adequacy threshold 0-1 (default: 0.7) */
+    adequacyThreshold?: number;
+    /** Minimum results required (default: 3) */
+    minResults?: number;
+    /** Hybrid search options */
+    searchOptions?: Partial<HybridSearchOptions>;
+}
+/**
+ * Result of reflection-based retrieval.
+ */
+export interface ReflectionResult {
+    results: HybridSearchResult[];
+    iterations: number;
+    adequate: boolean;
+    refinements: string[];
+    adequacyScore: number;
+}
+/**
+ * Reflection Manager for iterative retrieval refinement.
+ *
+ * Implements the SimpleMem-inspired reflection loop:
+ * 1. Execute initial search
+ * 2. Check result adequacy
+ * 3. If inadequate, refine query and repeat
+ * 4. Combine results from all iterations
+ *
+ * @example
+ * ```typescript
+ * const reflection = new ReflectionManager(hybridSearch, analyzer);
+ * const result = await reflection.retrieveWithReflection(
+ *   graph,
+ *   'What projects did Alice work on?',
+ *   { maxIterations: 3 }
+ * );
+ * ```
+ */
+export declare class ReflectionManager {
+    private hybridSearch;
+    private analyzer;
+    constructor(hybridSearch: HybridSearchManager, analyzer: QueryAnalyzer);
+    /**
+     * Perform retrieval with reflection-based refinement.
+     */
+    retrieveWithReflection(graph: ReadonlyKnowledgeGraph, query: string, options?: ReflectionOptions): Promise<ReflectionResult>;
+    /**
+     * Calculate result adequacy score.
+     */
+    private calculateAdequacy;
+    /**
+     * Refine query based on current results and analysis.
+     */
+    private refineQuery;
+}
+//# sourceMappingURL=ReflectionManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReflectionManager.d.ts","sourceRoot":"","sources":["../../src/search/ReflectionManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,sBAAsB,EAEtB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ;gBADR,YAAY,EAAE,mBAAmB,EACjC,QAAQ,EAAE,aAAa;IAGjC;;OAEG;IACG,sBAAsB,CAC1B,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC;IA2D5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;OAEG;IACH,OAAO,CAAC,WAAW;CA6BpB"}

package/dist/search/ReflectionManager.js

@@ -0,0 +1,124 @@
+/**
+ * Reflection Manager
+ *
+ * Phase 11: Implements reflection-based iterative retrieval
+ * that refines results until adequate.
+ *
+ * @module search/ReflectionManager
+ */
+/**
+ * Reflection Manager for iterative retrieval refinement.
+ *
+ * Implements the SimpleMem-inspired reflection loop:
+ * 1. Execute initial search
+ * 2. Check result adequacy
+ * 3. If inadequate, refine query and repeat
+ * 4. Combine results from all iterations
+ *
+ * @example
+ * ```typescript
+ * const reflection = new ReflectionManager(hybridSearch, analyzer);
+ * const result = await reflection.retrieveWithReflection(
+ *   graph,
+ *   'What projects did Alice work on?',
+ *   { maxIterations: 3 }
+ * );
+ * ```
+ */
+export class ReflectionManager {
+    hybridSearch;
+    analyzer;
+    constructor(hybridSearch, analyzer) {
+        this.hybridSearch = hybridSearch;
+        this.analyzer = analyzer;
+    }
+    /**
+     * Perform retrieval with reflection-based refinement.
+     */
+    async retrieveWithReflection(graph, query, options = {}) {
+        const { maxIterations = 3, adequacyThreshold = 0.7, minResults = 3, searchOptions = {}, } = options;
+        const allResults = [];
+        const refinements = [];
+        let currentQuery = query;
+        let iteration = 0;
+        let adequacyScore = 0;
+        while (iteration < maxIterations) {
+            iteration++;
+            // Execute search
+            const results = await this.hybridSearch.searchWithEntities(graph, currentQuery, searchOptions);
+            // Add new results (deduplicated)
+            for (const result of results) {
+                if (!allResults.some(r => r.entity.name === result.entity.name)) {
+                    allResults.push(result);
+                }
+            }
+            // Check adequacy
+            const analysis = this.analyzer.analyze(query);
+            adequacyScore = this.calculateAdequacy(allResults, analysis, minResults);
+            if (adequacyScore >= adequacyThreshold) {
+                break;
+            }
+            // Refine query if not adequate
+            const refinedQuery = this.refineQuery(currentQuery, allResults, analysis);
+            if (refinedQuery === currentQuery) {
+                // No refinement possible
+                break;
+            }
+            refinements.push(refinedQuery);
+            currentQuery = refinedQuery;
+        }
+        return {
+            results: allResults.sort((a, b) => b.scores.combined - a.scores.combined),
+            iterations: iteration,
+            adequate: adequacyScore >= adequacyThreshold,
+            refinements,
+            adequacyScore,
+        };
+    }
+    /**
+     * Calculate result adequacy score.
+     */
+    calculateAdequacy(results, analysis, minResults) {
+        let score = 0;
+        const weights = { quantity: 0.4, diversity: 0.3, relevance: 0.3 };
+        // Quantity: Do we have enough results?
+        const quantityScore = Math.min(results.length / minResults, 1);
+        score += quantityScore * weights.quantity;
+        // Diversity: Do results cover different entity types?
+        const types = new Set(results.map(r => r.entity.entityType));
+        const diversityScore = Math.min(types.size / 3, 1);
+        score += diversityScore * weights.diversity;
+        // Relevance: Average combined score
+        const avgScore = results.length > 0
+            ? results.reduce((sum, r) => sum + r.scores.combined, 0) / results.length
+            : 0;
+        score += avgScore * weights.relevance;
+        // Suppress unused parameter warning - analysis reserved for future enhancements
+        void analysis;
+        return score;
+    }
+    /**
+     * Refine query based on current results and analysis.
+     */
+    refineQuery(query, results, analysis) {
+        // Check what information types are missing
+        const coveredTypes = new Set();
+        for (const result of results) {
+            coveredTypes.add(result.entity.entityType.toLowerCase());
+        }
+        // If looking for persons but no person results, refine
+        if (analysis.requiredInfoTypes.includes('person') && !coveredTypes.has('person')) {
+            return `${query} person people`;
+        }
+        // If temporal query but no temporal context, add time hint
+        if (analysis.temporalRange && results.length < 3) {
+            return `${query} recent history timeline`;
+        }
+        // Broaden query by removing constraints
+        const broader = query.replace(/\b(only|just|exactly|specific)\b/gi, '');
+        if (broader !== query) {
+            return broader.trim();
+        }
+        return query;
+    }
+}

package/dist/search/SymbolicSearch.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Symbolic Search Layer
+ *
+ * Phase 11: Provides metadata-based filtering using structured predicates.
+ * Part of the three-layer hybrid search architecture.
+ *
+ * @module search/SymbolicSearch
+ */
+import type { Entity, SymbolicFilters } from '../types/index.js';
+/**
+ * Result from symbolic search with match score.
+ */
+export interface SymbolicResult {
+    entity: Entity;
+    score: number;
+    matchedFilters: string[];
+}
+/**
+ * Symbolic Search provides metadata-based filtering.
+ *
+ * Filters entities using structured predicates on tags, types,
+ * dates, importance, and hierarchy.
+ *
+ * @example
+ * ```typescript
+ * const symbolic = new SymbolicSearch();
+ * const results = symbolic.search(entities, {
+ *   tags: ['important'],
+ *   entityTypes: ['person'],
+ *   importance: { min: 5 }
+ * });
+ * ```
+ */
+export declare class SymbolicSearch {
+    /**
+     * Filter entities using structured metadata predicates.
+     * All filters are AND-combined.
+     *
+     * @param entities - Entities to filter
+     * @param filters - Symbolic filter criteria
+     * @returns Filtered entities with match scores
+     */
+    search(entities: readonly Entity[], filters: SymbolicFilters): SymbolicResult[];
+    /**
+     * Evaluate all filters against an entity.
+     */
+    private evaluateFilters;
+    /**
+     * Get entities matching a specific tag.
+     */
+    byTag(entities: readonly Entity[], tag: string): Entity[];
+    /**
+     * Get entities of a specific type.
+     */
+    byType(entities: readonly Entity[], entityType: string): Entity[];
+    /**
+     * Get entities within importance range.
+     */
+    byImportance(entities: readonly Entity[], min: number, max: number): Entity[];
+}
+//# sourceMappingURL=SymbolicSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolicSearch.d.ts","sourceRoot":"","sources":["../../src/search/SymbolicSearch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,EAAE;IAc/E;;OAEG;IACH,OAAO,CAAC,eAAe;IAyGvB;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAMzD;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAMjE;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;CAM9E"}

package/dist/search/SymbolicSearch.js

@@ -0,0 +1,163 @@
+/**
+ * Symbolic Search Layer
+ *
+ * Phase 11: Provides metadata-based filtering using structured predicates.
+ * Part of the three-layer hybrid search architecture.
+ *
+ * @module search/SymbolicSearch
+ */
+/**
+ * Symbolic Search provides metadata-based filtering.
+ *
+ * Filters entities using structured predicates on tags, types,
+ * dates, importance, and hierarchy.
+ *
+ * @example
+ * ```typescript
+ * const symbolic = new SymbolicSearch();
+ * const results = symbolic.search(entities, {
+ *   tags: ['important'],
+ *   entityTypes: ['person'],
+ *   importance: { min: 5 }
+ * });
+ * ```
+ */
+export class SymbolicSearch {
+    /**
+     * Filter entities using structured metadata predicates.
+     * All filters are AND-combined.
+     *
+     * @param entities - Entities to filter
+     * @param filters - Symbolic filter criteria
+     * @returns Filtered entities with match scores
+     */
+    search(entities, filters) {
+        const results = [];
+        for (const entity of entities) {
+            const { matches, score, matchedFilters } = this.evaluateFilters(entity, filters);
+            if (matches) {
+                results.push({ entity, score, matchedFilters });
+            }
+        }
+        // Sort by score descending
+        return results.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Evaluate all filters against an entity.
+     */
+    evaluateFilters(entity, filters) {
+        const matchedFilters = [];
+        let totalFilters = 0;
+        let matchedCount = 0;
+        // Tag filter
+        if (filters.tags && filters.tags.length > 0) {
+            totalFilters++;
+            const entityTags = entity.tags ?? [];
+            const matchingTags = filters.tags.filter((t) => entityTags.some((et) => et.toLowerCase() === t.toLowerCase()));
+            if (matchingTags.length > 0) {
+                matchedCount++;
+                matchedFilters.push(`tags:${matchingTags.join(',')}`);
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // Entity type filter
+        if (filters.entityTypes && filters.entityTypes.length > 0) {
+            totalFilters++;
+            if (filters.entityTypes.some((t) => t.toLowerCase() === entity.entityType.toLowerCase())) {
+                matchedCount++;
+                matchedFilters.push(`type:${entity.entityType}`);
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // Date range filter
+        if (filters.dateRange) {
+            totalFilters++;
+            const entityDate = entity.createdAt || entity.lastModified;
+            if (!entityDate) {
+                // Entities without dates are excluded when date filter is applied
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+            const date = new Date(entityDate);
+            const start = filters.dateRange.start ? new Date(filters.dateRange.start) : null;
+            const end = filters.dateRange.end ? new Date(filters.dateRange.end) : null;
+            const inRange = (!start || date >= start) && (!end || date <= end);
+            if (inRange) {
+                matchedCount++;
+                matchedFilters.push('dateRange');
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // Importance filter
+        if (filters.importance) {
+            totalFilters++;
+            const importance = entity.importance ?? 5;
+            const { min, max } = filters.importance;
+            const inRange = (min === undefined || importance >= min) &&
+                (max === undefined || importance <= max);
+            if (inRange) {
+                matchedCount++;
+                matchedFilters.push(`importance:${importance}`);
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // Parent filter
+        if (filters.parentId !== undefined) {
+            totalFilters++;
+            if (entity.parentId === filters.parentId) {
+                matchedCount++;
+                matchedFilters.push(`parent:${filters.parentId}`);
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // Has observations filter
+        if (filters.hasObservations !== undefined) {
+            totalFilters++;
+            const hasObs = entity.observations.length > 0;
+            if (hasObs === filters.hasObservations) {
+                matchedCount++;
+                matchedFilters.push('hasObservations');
+            }
+            else {
+                return { matches: false, score: 0, matchedFilters: [] };
+            }
+        }
+        // If no filters specified, match all with base score
+        if (totalFilters === 0) {
+            return { matches: true, score: 0.5, matchedFilters: [] };
+        }
+        // Score based on proportion of filters matched
+        const score = matchedCount / totalFilters;
+        return { matches: true, score, matchedFilters };
+    }
+    /**
+     * Get entities matching a specific tag.
+     */
+    byTag(entities, tag) {
+        return entities.filter(e => e.tags?.some(t => t.toLowerCase() === tag.toLowerCase()));
+    }
+    /**
+     * Get entities of a specific type.
+     */
+    byType(entities, entityType) {
+        return entities.filter(e => e.entityType.toLowerCase() === entityType.toLowerCase());
+    }
+    /**
+     * Get entities within importance range.
+     */
+    byImportance(entities, min, max) {
+        return entities.filter(e => {
+            const imp = e.importance ?? 5;
+            return imp >= min && imp <= max;
+        });
+    }
+}

package/dist/search/index.d.ts

@@ -18,4 +18,9 @@ export { SemanticSearch, entityToText, } from './SemanticSearch.js';
 export { TFIDFIndexManager } from './TFIDFIndexManager.js';
 export { TFIDFEventSync } from './TFIDFEventSync.js';
 export { QueryCostEstimator } from './QueryCostEstimator.js';
+export { SymbolicSearch, type SymbolicResult } from './SymbolicSearch.js';
+export { HybridSearchManager, DEFAULT_HYBRID_WEIGHTS } from './HybridSearchManager.js';
+export { QueryAnalyzer } from './QueryAnalyzer.js';
+export { QueryPlanner } from './QueryPlanner.js';
+export { ReflectionManager, type ReflectionOptions, type ReflectionResult, } from './ReflectionManager.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAGzG,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,2BAA2B,GACjC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,cAAc,EACd,YAAY,GACb,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAGzG,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,2BAA2B,GACjC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,cAAc,EACd,YAAY,GACb,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvF,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,EACL,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,wBAAwB,CAAC"}

package/dist/search/index.js

@@ -24,3 +24,11 @@ export { TFIDFIndexManager } from './TFIDFIndexManager.js';
 export { TFIDFEventSync } from './TFIDFEventSync.js';
 // Phase 10 Sprint 4: Query Cost Estimation
 export { QueryCostEstimator } from './QueryCostEstimator.js';
+// Phase 11 Sprint 1: Hybrid Search
+export { SymbolicSearch } from './SymbolicSearch.js';
+export { HybridSearchManager, DEFAULT_HYBRID_WEIGHTS } from './HybridSearchManager.js';
+// Phase 11 Sprint 3: Query Analysis
+export { QueryAnalyzer } from './QueryAnalyzer.js';
+export { QueryPlanner } from './QueryPlanner.js';
+// Phase 11 Sprint 4: Reflection-based Retrieval
+export { ReflectionManager, } from './ReflectionManager.js';

package/dist/server/toolDefinitions.d.ts

@@ -2,7 +2,7 @@
  * MCP Tool Definitions
  *
  * Extracted from MCPServer.ts to reduce file size and improve maintainability.
- * Contains all 47 tool schemas for the Knowledge Graph MCP Server.
+ * Contains all 59 tool schemas for the Knowledge Graph MCP Server.
  *
  * @module server/toolDefinitions
  */

package/dist/server/toolDefinitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolDefinitions.d.ts","sourceRoot":"","sources":["../../src/server/toolDefinitions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,EA03B3C,CAAC"}
+{"version":3,"file":"toolDefinitions.d.ts","sourceRoot":"","sources":["../../src/server/toolDefinitions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,EAygC3C,CAAC"}

package/dist/server/toolDefinitions.js

@@ -2,7 +2,7 @@
  * MCP Tool Definitions
  *
  * Extracted from MCPServer.ts to reduce file size and improve maintainability.
- * Contains all 47 tool schemas for the Knowledge Graph MCP Server.
+ * Contains all 59 tool schemas for the Knowledge Graph MCP Server.
  *
  * @module server/toolDefinitions
  */
@@ -186,6 +186,34 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 11 Sprint 5: Observation Normalization
+    {
+        name: 'normalize_observations',
+        description: 'Normalize entity observations by resolving pronouns and anchoring relative dates. Improves search matching quality.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: {
+                    type: 'string',
+                    description: 'Entity name to normalize (omit for all entities)',
+                },
+                options: {
+                    type: 'object',
+                    properties: {
+                        resolveCoreferences: { type: 'boolean', default: true },
+                        anchorTimestamps: { type: 'boolean', default: true },
+                        extractKeywords: { type: 'boolean', default: false },
+                    },
+                },
+                persist: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Save normalized observations to storage',
+                },
+            },
+            additionalProperties: false,
+        },
+    },
     // ==================== SEARCH TOOLS ====================
     {
         name: 'search_nodes',
@@ -298,6 +326,118 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 11 Sprint 2: Hybrid Search
+    {
+        name: 'hybrid_search',
+        description: 'Search using combined semantic, lexical, and metadata signals. Provides better recall than single-signal search by fusing multiple relevance signals.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query text',
+                },
+                weights: {
+                    type: 'object',
+                    description: 'Layer weights (automatically normalized to sum to 1.0)',
+                    properties: {
+                        semantic: {
+                            type: 'number',
+                            description: 'Weight for semantic/embedding similarity (default: 0.5)',
+                        },
+                        lexical: {
+                            type: 'number',
+                            description: 'Weight for keyword/TF-IDF matching (default: 0.3)',
+                        },
+                        symbolic: {
+                            type: 'number',
+                            description: 'Weight for metadata filtering (default: 0.2)',
+                        },
+                    },
+                },
+                filters: {
+                    type: 'object',
+                    description: 'Symbolic/metadata filters',
+                    properties: {
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by tags',
+                        },
+                        entityTypes: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by entity types',
+                        },
+                        dateRange: {
+                            type: 'object',
+                            properties: {
+                                start: { type: 'string', description: 'Start date (ISO 8601)' },
+                                end: { type: 'string', description: 'End date (ISO 8601)' },
+                            },
+                        },
+                        minImportance: { type: 'number', description: 'Minimum importance score (0-10)' },
+                        maxImportance: { type: 'number', description: 'Maximum importance score (0-10)' },
+                    },
+                },
+                limit: { type: 'number', description: 'Maximum results to return (default: 10)' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    // Phase 11 Sprint 3: Query Analysis
+    {
+        name: 'analyze_query',
+        description: 'Analyze a search query to extract entities, temporal references, question type, and complexity. Useful for understanding query structure before searching.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The query to analyze',
+                },
+                includePlan: {
+                    type: 'boolean',
+                    description: 'Include execution plan in response (default: false)',
+                },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    // Phase 11 Sprint 4: Smart Search
+    {
+        name: 'smart_search',
+        description: 'Intelligent search with automatic query planning and reflection-based refinement. Iteratively improves results until adequate.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query text',
+                },
+                maxIterations: {
+                    type: 'number',
+                    description: 'Maximum reflection iterations (default: 3)',
+                },
+                adequacyThreshold: {
+                    type: 'number',
+                    description: 'Adequacy threshold 0-1 (default: 0.7)',
+                },
+                includePlan: {
+                    type: 'boolean',
+                    description: 'Include execution plan in response (default: true)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 10)',
+                },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
     // ==================== SAVED SEARCH TOOLS ====================
     {
         name: 'save_search',

package/dist/server/toolHandlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolHandlers.d.ts","sourceRoot":"","sources":["../../src/server/toolHandlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,kBAAkB,EAmBnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAIhE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,YAAY,CAAC,CAAC;AAyC3B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAuhBpD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,YAAY,CAAC,CAMvB"}
+{"version":3,"file":"toolHandlers.d.ts","sourceRoot":"","sources":["../../src/server/toolHandlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,kBAAkB,EAmBnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,YAAY,CAAC,CAAC;AAyC3B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CA0tBpD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,YAAY,CAAC,CAMvB"}