@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/search/SearchFilterChain.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Search Filter Chain
+ *
+ * Centralizes filter logic for all search implementations to eliminate
+ * duplicate filtering code across BasicSearch, BooleanSearch, FuzzySearch,
+ * and RankedSearch.
+ *
+ * @module search/SearchFilterChain
+ */
+import type { Entity } from '../types/index.js';
+import { type ValidatedPagination } from '../utils/index.js';
+/**
+ * Search filter configuration options.
+ * All filters are optional - entities pass if filter is not specified.
+ */
+export interface SearchFilters {
+    /** Tags to filter by (any match) */
+    tags?: string[];
+    /** Minimum importance (0-10, inclusive) */
+    minImportance?: number;
+    /** Maximum importance (0-10, inclusive) */
+    maxImportance?: number;
+    /** Entity type to filter by (exact match) */
+    entityType?: string;
+    /** Created after date (ISO 8601, inclusive) */
+    createdAfter?: string;
+    /** Created before date (ISO 8601, inclusive) */
+    createdBefore?: string;
+    /** Modified after date (ISO 8601, inclusive) */
+    modifiedAfter?: string;
+    /** Modified before date (ISO 8601, inclusive) */
+    modifiedBefore?: string;
+}
+/**
+ * Centralized filter chain for all search implementations.
+ * Ensures consistent filtering behavior across search types.
+ *
+ * @example
+ * ```typescript
+ * const filters: SearchFilters = { tags: ['important'], minImportance: 5 };
+ * const filtered = SearchFilterChain.applyFilters(entities, filters);
+ * const pagination = SearchFilterChain.validatePagination(0, 50);
+ * const result = SearchFilterChain.paginate(filtered, pagination);
+ * ```
+ */
+export declare class SearchFilterChain {
+    /**
+     * Applies all filters to an array of entities.
+     * Entities must pass ALL specified filters to be included.
+     *
+     * @param entities - Entities to filter
+     * @param filters - Filter criteria to apply
+     * @returns Filtered entities array
+     */
+    static applyFilters(entities: readonly Entity[], filters: SearchFilters): Entity[];
+    /**
+     * Checks if an entity passes all active filters.
+     * Short-circuits on first failing filter for performance.
+     *
+     * @param entity - Entity to check
+     * @param filters - Filter criteria
+     * @param normalizedSearchTags - Pre-normalized search tags (for efficiency)
+     * @returns true if entity passes all filters
+     */
+    static entityPassesFilters(entity: Entity, filters: SearchFilters, normalizedSearchTags?: string[]): boolean;
+    /**
+     * Checks if any filters are actually specified.
+     * Used for early return optimization.
+     *
+     * @param filters - Filter criteria to check
+     * @returns true if at least one filter is active
+     */
+    static hasActiveFilters(filters: SearchFilters): boolean;
+    /**
+     * Validates and returns pagination parameters.
+     * Delegates to paginationUtils.validatePagination.
+     *
+     * @param offset - Starting position
+     * @param limit - Maximum results
+     * @returns Validated pagination object
+     */
+    static validatePagination(offset?: number, limit?: number): ValidatedPagination;
+    /**
+     * Applies pagination to a filtered result set.
+     *
+     * @param entities - Entities to paginate
+     * @param pagination - Validated pagination parameters
+     * @returns Paginated slice of entities
+     */
+    static paginate(entities: Entity[], pagination: ValidatedPagination): Entity[];
+    /**
+     * Convenience method to apply both filters and pagination in one call.
+     *
+     * @param entities - Entities to process
+     * @param filters - Filter criteria
+     * @param offset - Pagination offset
+     * @param limit - Pagination limit
+     * @returns Filtered and paginated entities
+     */
+    static filterAndPaginate(entities: Entity[], filters: SearchFilters, offset?: number, limit?: number): Entity[];
+    /**
+     * Applies tag filter only. Useful when other filters are handled separately.
+     *
+     * @param entities - Entities to filter
+     * @param tags - Tags to filter by
+     * @returns Filtered entities
+     */
+    static filterByTags(entities: Entity[], tags?: string[]): Entity[];
+    /**
+     * Applies importance filter only. Useful when other filters are handled separately.
+     *
+     * @param entities - Entities to filter
+     * @param minImportance - Minimum importance
+     * @param maxImportance - Maximum importance
+     * @returns Filtered entities
+     */
+    static filterByImportance(entities: Entity[], minImportance?: number, maxImportance?: number): Entity[];
+}
+export type { ValidatedPagination };
+//# sourceMappingURL=SearchFilterChain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchFilterChain.d.ts","sourceRoot":"","sources":["../../src/search/SearchFilterChain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,EAAE;IAgBlF;;;;;;;;OAQG;IACH,MAAM,CAAC,mBAAmB,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAC9B,OAAO;IAsDV;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAaxD;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAIlF;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,mBAAmB,GAAG,MAAM,EAAE;IAI9E;;;;;;;;OAQG;IACH,MAAM,CAAC,iBAAiB,CACtB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,aAAa,EACtB,MAAM,GAAE,MAAU,EAClB,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,EAAE;IAMX;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAclE;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,MAAM,EAAE,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,EAAE;CASZ;AAGD,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/search/SearchFilterChain.js

@@ -7,9 +7,7 @@
  *
  * @module search/SearchFilterChain
  */
-import { normalizeTags, hasMatchingTag } from '../utils/tagUtils.js';
-import { isWithinImportanceRange } from '../utils/filterUtils.js';
-import { validatePagination, applyPagination } from '../utils/paginationUtils.js';
+import { normalizeTags, hasMatchingTag, isWithinImportanceRange, validatePagination, applyPagination, } from '../utils/index.js';
 /**
  * Centralized filter chain for all search implementations.
  * Ensures consistent filtering behavior across search types.
@@ -34,7 +32,7 @@ export class SearchFilterChain {
     static applyFilters(entities, filters) {
         // Early return if no filters are active
         if (!this.hasActiveFilters(filters)) {
-            return entities;
+            return [...entities];
         }
         // Pre-normalize tags once for efficiency
         const normalizedSearchTags = filters.tags?.length

package/dist/search/SearchManager.d.ts

@@ -0,0 +1,326 @@
+/**
+ * Search Manager
+ *
+ * Orchestrates all search types (basic, ranked, boolean, fuzzy).
+ * Focused on search operations only (Phase 4: Consolidate God Objects).
+ *
+ * @module search/SearchManager
+ */
+import type { KnowledgeGraph, SearchResult, SavedSearch, AutoSearchResult } from '../types/index.js';
+import type { GraphStorage } from '../core/GraphStorage.js';
+import { QueryCostEstimator } from './QueryCostEstimator.js';
+/**
+ * Unified search manager providing access to all search types.
+ *
+ * Phase 4 Sprint 5: Manages search caches across all search types.
+ */
+export declare class SearchManager {
+    private basicSearch;
+    private rankedSearch;
+    private booleanSearcher;
+    private fuzzySearcher;
+    private searchSuggestions;
+    private savedSearchManager;
+    private storage;
+    private queryEstimator;
+    constructor(storage: GraphStorage, savedSearchesFilePath: string);
+    /**
+     * Phase 4 Sprint 5: Clear all search caches.
+     *
+     * Clears caches in all search types: fuzzy, boolean, and ranked token cache.
+     * Call this when the graph has been modified to ensure fresh results.
+     */
+    clearAllCaches(): void;
+    /**
+     * Phase 4 Sprint 5: Clear fuzzy search cache.
+     */
+    clearFuzzyCache(): void;
+    /**
+     * Phase 4 Sprint 5: Clear boolean search cache.
+     */
+    clearBooleanCache(): void;
+    /**
+     * Phase 4 Sprint 5: Clear ranked search token cache.
+     */
+    clearRankedCache(): void;
+    /**
+     * Perform a simple text-based search across entity names and observations.
+     *
+     * This is the primary search method that searches through entity names,
+     * observations, and types using case-insensitive substring matching.
+     * Optionally filter by tags and importance range.
+     *
+     * @param query - Text to search for (case-insensitive, searches names/observations/types)
+     * @param tags - Optional array of tags to filter results (lowercase)
+     * @param minImportance - Optional minimum importance value (0-10)
+     * @param maxImportance - Optional maximum importance value (0-10)
+     * @returns KnowledgeGraph containing matching entities and their relations
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Simple text search
+     * const results = await manager.searchNodes('Alice');
+     *
+     * // Search with tag filter
+     * const engineeringResults = await manager.searchNodes('project', ['engineering']);
+     *
+     * // Search with importance range
+     * const importantResults = await manager.searchNodes('critical', undefined, 8, 10);
+     *
+     * // Combined filters
+     * const filtered = await manager.searchNodes('bug', ['backend'], 5, 10);
+     * ```
+     */
+    searchNodes(query: string, tags?: string[], minImportance?: number, maxImportance?: number): Promise<KnowledgeGraph>;
+    /**
+     * Open specific nodes by name.
+     *
+     * @param names - Array of entity names
+     * @returns Knowledge graph with specified entities
+     */
+    openNodes(names: string[]): Promise<KnowledgeGraph>;
+    /**
+     * Search by date range.
+     *
+     * @param startDate - Optional start date (ISO 8601)
+     * @param endDate - Optional end date (ISO 8601)
+     * @param entityType - Optional entity type filter
+     * @param tags - Optional tags filter
+     * @returns Filtered knowledge graph
+     */
+    searchByDateRange(startDate?: string, endDate?: string, entityType?: string, tags?: string[]): Promise<KnowledgeGraph>;
+    /**
+     * Perform TF-IDF ranked search with relevance scoring.
+     *
+     * Uses Term Frequency-Inverse Document Frequency algorithm to rank results
+     * by relevance to the query. Results are sorted by score (highest first).
+     * This is ideal for finding the most relevant entities for a search query.
+     *
+     * @param query - Search query (analyzed for term frequency)
+     * @param tags - Optional array of tags to filter results (lowercase)
+     * @param minImportance - Optional minimum importance value (0-10)
+     * @param maxImportance - Optional maximum importance value (0-10)
+     * @param limit - Maximum number of results to return (default: 50, max: 200)
+     * @returns Array of SearchResult objects sorted by relevance score (descending)
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Basic ranked search
+     * const results = await manager.searchNodesRanked('machine learning algorithms');
+     * results.forEach(r => {
+     *   console.log(`${r.entity.name} (score: ${r.score})`);
+     * });
+     *
+     * // Limit to top 10 most relevant results
+     * const top10 = await manager.searchNodesRanked('database optimization', undefined, undefined, undefined, 10);
+     *
+     * // Ranked search with filters
+     * const relevantImportant = await manager.searchNodesRanked(
+     *   'security vulnerability',
+     *   ['security', 'critical'],
+     *   8,
+     *   10,
+     *   20
+     * );
+     * ```
+     */
+    searchNodesRanked(query: string, tags?: string[], minImportance?: number, maxImportance?: number, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Perform boolean search with AND, OR, NOT operators.
+     *
+     * Supports complex boolean logic for precise search queries.
+     * Use AND/OR/NOT operators (case-insensitive) to combine search terms.
+     * Parentheses are supported for grouping.
+     *
+     * @param query - Boolean query string (e.g., "alice AND bob", "frontend OR backend NOT legacy")
+     * @param tags - Optional array of tags to filter results (lowercase)
+     * @param minImportance - Optional minimum importance value (0-10)
+     * @param maxImportance - Optional maximum importance value (0-10)
+     * @returns KnowledgeGraph containing entities matching the boolean expression
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // AND operator - entities matching all terms
+     * const both = await manager.booleanSearch('database AND performance');
+     *
+     * // OR operator - entities matching any term
+     * const either = await manager.booleanSearch('frontend OR backend');
+     *
+     * // NOT operator - exclude terms
+     * const excluding = await manager.booleanSearch('API NOT deprecated');
+     *
+     * // Complex queries with grouping
+     * const complex = await manager.booleanSearch('(react OR vue) AND (component OR hook) NOT legacy');
+     * ```
+     */
+    booleanSearch(query: string, tags?: string[], minImportance?: number, maxImportance?: number): Promise<KnowledgeGraph>;
+    /**
+     * Perform fuzzy search with typo tolerance.
+     *
+     * Uses Levenshtein distance to find entities that approximately match the query,
+     * making it ideal for handling typos and variations in spelling.
+     * Higher threshold values require closer matches.
+     *
+     * @param query - Search query (will match approximate spellings)
+     * @param threshold - Similarity threshold from 0.0 (very lenient) to 1.0 (exact match). Default: 0.7
+     * @param tags - Optional array of tags to filter results (lowercase)
+     * @param minImportance - Optional minimum importance value (0-10)
+     * @param maxImportance - Optional maximum importance value (0-10)
+     * @returns KnowledgeGraph containing entities with similar names/observations
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Find entities even with typos
+     * const results = await manager.fuzzySearch('databse'); // Will match "database"
+     *
+     * // Adjust threshold for strictness
+     * const strict = await manager.fuzzySearch('optmization', 0.9); // Requires very close match
+     * const lenient = await manager.fuzzySearch('optmization', 0.6); // More tolerant of differences
+     *
+     * // Fuzzy search with filters
+     * const filtered = await manager.fuzzySearch('secrity', 0.7, ['important'], 7, 10);
+     * ```
+     */
+    fuzzySearch(query: string, threshold?: number, tags?: string[], minImportance?: number, maxImportance?: number): Promise<KnowledgeGraph>;
+    /**
+     * Get search suggestions for a query.
+     *
+     * @param query - Search query
+     * @param maxSuggestions - Maximum suggestions to return
+     * @returns Array of suggested terms
+     */
+    getSearchSuggestions(query: string, maxSuggestions?: number): Promise<string[]>;
+    /**
+     * Save a search query for later reuse.
+     *
+     * Saved searches store query parameters and can be re-executed later.
+     * The system tracks usage count and last used timestamp automatically.
+     *
+     * @param search - Search parameters (name, query, and optional filters)
+     * @returns Newly created SavedSearch object with metadata
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Save a simple search
+     * const saved = await manager.saveSearch({
+     *   name: 'High Priority Bugs',
+     *   query: 'bug',
+     *   tags: ['critical'],
+     *   minImportance: 8
+     * });
+     *
+     * // Save a complex search
+     * await manager.saveSearch({
+     *   name: 'Recent Frontend Work',
+     *   query: 'component OR hook',
+     *   tags: ['frontend', 'react'],
+     *   searchType: 'boolean'
+     * });
+     * ```
+     */
+    saveSearch(search: Omit<SavedSearch, 'createdAt' | 'useCount' | 'lastUsed'>): Promise<SavedSearch>;
+    /**
+     * List all saved searches.
+     *
+     * @returns Array of saved searches
+     */
+    listSavedSearches(): Promise<SavedSearch[]>;
+    /**
+     * Get a saved search by name.
+     *
+     * @param name - Search name
+     * @returns Saved search or null
+     */
+    getSavedSearch(name: string): Promise<SavedSearch | null>;
+    /**
+     * Execute a saved search by name.
+     *
+     * Runs a previously saved search with its stored parameters.
+     * Automatically updates the search's useCount and lastUsed timestamp.
+     *
+     * @param name - The unique name of the saved search to execute
+     * @returns KnowledgeGraph containing the search results
+     * @throws Error if saved search not found
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Execute a saved search
+     * const results = await manager.executeSavedSearch('High Priority Bugs');
+     * console.log(`Found ${results.entities.length} high priority bugs`);
+     *
+     * // Handle missing saved search
+     * try {
+     *   await manager.executeSavedSearch('NonExistent');
+     * } catch (error) {
+     *   console.error('Search not found');
+     * }
+     * ```
+     */
+    executeSavedSearch(name: string): Promise<KnowledgeGraph>;
+    /**
+     * Delete a saved search.
+     *
+     * @param name - Search name
+     * @returns True if deleted
+     */
+    deleteSavedSearch(name: string): Promise<boolean>;
+    /**
+     * Update a saved search.
+     *
+     * @param name - Search name
+     * @param updates - Fields to update
+     * @returns Updated saved search
+     */
+    updateSavedSearch(name: string, updates: Partial<Omit<SavedSearch, 'name' | 'createdAt' | 'useCount' | 'lastUsed'>>): Promise<SavedSearch>;
+    /**
+     * Phase 10 Sprint 4: Automatically select and execute the best search method.
+     *
+     * Analyzes the query and graph size to determine the optimal search method,
+     * then executes it and returns both the results and the selection reasoning.
+     *
+     * @param query - The search query
+     * @param limit - Maximum number of results (default: 10)
+     * @returns AutoSearchResult with selected method, results, and estimates
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Let the system choose the best search method
+     * const result = await manager.autoSearch('software engineer skills');
+     *
+     * console.log(`Used ${result.selectedMethod} because: ${result.selectionReason}`);
+     * console.log(`Found ${result.results.length} results in ${result.executionTimeMs}ms`);
+     * ```
+     */
+    autoSearch(query: string, limit?: number): Promise<AutoSearchResult>;
+    /**
+     * Phase 10 Sprint 4: Get cost estimates for all search methods.
+     *
+     * Useful for clients that want to display cost information or
+     * make their own method selection decisions.
+     *
+     * @param query - The search query
+     * @returns Array of cost estimates for all methods
+     */
+    getSearchCostEstimates(query: string): Promise<import('../types/index.js').QueryCostEstimate[]>;
+    /**
+     * Phase 10 Sprint 4: Get the query cost estimator instance.
+     *
+     * @returns The QueryCostEstimator instance
+     */
+    getQueryEstimator(): QueryCostEstimator;
+}
+//# sourceMappingURL=SearchManager.d.ts.map

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

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

package/dist/search/SearchManager.js

@@ -2,6 +2,7 @@
  * Search Manager
  *
  * Orchestrates all search types (basic, ranked, boolean, fuzzy).
+ * Focused on search operations only (Phase 4: Consolidate God Objects).
  *
  * @module search/SearchManager
  */
@@ -11,8 +12,11 @@ import { BooleanSearch } from './BooleanSearch.js';
 import { FuzzySearch } from './FuzzySearch.js';
 import { SearchSuggestions } from './SearchSuggestions.js';
 import { SavedSearchManager } from './SavedSearchManager.js';
+import { QueryCostEstimator } from './QueryCostEstimator.js';
 /**
  * Unified search manager providing access to all search types.
+ *
+ * Phase 4 Sprint 5: Manages search caches across all search types.
  */
 export class SearchManager {
     basicSearch;
@@ -21,13 +25,47 @@ export class SearchManager {
     fuzzySearcher;
     searchSuggestions;
     savedSearchManager;
+    storage;
+    queryEstimator;
     constructor(storage, savedSearchesFilePath) {
+        this.storage = storage;
         this.basicSearch = new BasicSearch(storage);
         this.rankedSearch = new RankedSearch(storage);
         this.booleanSearcher = new BooleanSearch(storage);
         this.fuzzySearcher = new FuzzySearch(storage);
         this.searchSuggestions = new SearchSuggestions(storage);
         this.savedSearchManager = new SavedSearchManager(savedSearchesFilePath, this.basicSearch);
+        this.queryEstimator = new QueryCostEstimator();
+    }
+    // ==================== Cache Management (Phase 4 Sprint 5) ====================
+    /**
+     * Phase 4 Sprint 5: Clear all search caches.
+     *
+     * Clears caches in all search types: fuzzy, boolean, and ranked token cache.
+     * Call this when the graph has been modified to ensure fresh results.
+     */
+    clearAllCaches() {
+        this.fuzzySearcher.clearCache();
+        this.booleanSearcher.clearCache();
+        this.rankedSearch.clearTokenCache();
+    }
+    /**
+     * Phase 4 Sprint 5: Clear fuzzy search cache.
+     */
+    clearFuzzyCache() {
+        this.fuzzySearcher.clearCache();
+    }
+    /**
+     * Phase 4 Sprint 5: Clear boolean search cache.
+     */
+    clearBooleanCache() {
+        this.booleanSearcher.clearCache();
+    }
+    /**
+     * Phase 4 Sprint 5: Clear ranked search token cache.
+     */
+    clearRankedCache() {
+        this.rankedSearch.clearTokenCache();
     }
     // ==================== Basic Search ====================
     /**
@@ -302,4 +340,114 @@ export class SearchManager {
     async updateSavedSearch(name, updates) {
         return this.savedSearchManager.updateSavedSearch(name, updates);
     }
+    // ==================== Phase 10 Sprint 4: Automatic Search ====================
+    /**
+     * Phase 10 Sprint 4: Automatically select and execute the best search method.
+     *
+     * Analyzes the query and graph size to determine the optimal search method,
+     * then executes it and returns both the results and the selection reasoning.
+     *
+     * @param query - The search query
+     * @param limit - Maximum number of results (default: 10)
+     * @returns AutoSearchResult with selected method, results, and estimates
+     *
+     * @example
+     * ```typescript
+     * const manager = new SearchManager(storage, savedSearchesPath);
+     *
+     * // Let the system choose the best search method
+     * const result = await manager.autoSearch('software engineer skills');
+     *
+     * console.log(`Used ${result.selectedMethod} because: ${result.selectionReason}`);
+     * console.log(`Found ${result.results.length} results in ${result.executionTimeMs}ms`);
+     * ```
+     */
+    async autoSearch(query, limit = 10) {
+        const startTime = Date.now();
+        // Get entity count from graph
+        const graph = await this.storage.loadGraph();
+        const entityCount = graph.entities.length;
+        // Get cost estimates for all methods
+        const estimates = this.queryEstimator.estimateAllMethods(query, entityCount);
+        // Get the recommended method
+        const recommendation = this.queryEstimator.recommendMethod(query, entityCount);
+        const selectedMethod = recommendation.method;
+        const selectionReason = recommendation.reason;
+        // Execute the selected search method
+        let results;
+        switch (selectedMethod) {
+            case 'basic': {
+                const basicResult = await this.basicSearch.searchNodes(query);
+                results = basicResult.entities.map((e, idx) => ({
+                    entity: e,
+                    score: 1.0 - idx * 0.01, // Rank by position
+                    matchedFields: { name: true, observations: e.observations },
+                }));
+                break;
+            }
+            case 'ranked': {
+                results = await this.rankedSearch.searchNodesRanked(query, undefined, undefined, undefined, limit);
+                break;
+            }
+            case 'boolean': {
+                const booleanResult = await this.booleanSearcher.booleanSearch(query);
+                results = booleanResult.entities.map((e, idx) => ({
+                    entity: e,
+                    score: 1.0 - idx * 0.01, // Rank by position
+                    matchedFields: { name: true, observations: e.observations },
+                }));
+                break;
+            }
+            case 'fuzzy': {
+                const fuzzyResult = await this.fuzzySearcher.fuzzySearch(query);
+                results = fuzzyResult.entities.map((e, idx) => ({
+                    entity: e,
+                    score: 1.0 - idx * 0.01, // Rank by position
+                    matchedFields: { name: true, observations: e.observations },
+                }));
+                break;
+            }
+            case 'semantic': {
+                // Semantic search not available through SearchManager
+                // Fall back to ranked search
+                results = await this.rankedSearch.searchNodesRanked(query, undefined, undefined, undefined, limit);
+                break;
+            }
+            default: {
+                const _exhaustiveCheck = selectedMethod;
+                throw new Error(`Unknown search method: ${_exhaustiveCheck}`);
+            }
+        }
+        // Limit results
+        const limitedResults = results.slice(0, limit);
+        return {
+            selectedMethod,
+            selectionReason,
+            estimates,
+            results: limitedResults,
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * Phase 10 Sprint 4: Get cost estimates for all search methods.
+     *
+     * Useful for clients that want to display cost information or
+     * make their own method selection decisions.
+     *
+     * @param query - The search query
+     * @returns Array of cost estimates for all methods
+     */
+    async getSearchCostEstimates(query) {
+        const graph = await this.storage.loadGraph();
+        const entityCount = graph.entities.length;
+        return this.queryEstimator.estimateAllMethods(query, entityCount);
+    }
+    /**
+     * Phase 10 Sprint 4: Get the query cost estimator instance.
+     *
+     * @returns The QueryCostEstimator instance
+     */
+    getQueryEstimator() {
+        return this.queryEstimator;
+    }
 }

package/dist/search/SearchSuggestions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Search Suggestions
+ *
+ * Provides "did you mean?" suggestions using Levenshtein distance.
+ *
+ * @module search/SearchSuggestions
+ */
+import type { GraphStorage } from '../core/GraphStorage.js';
+/**
+ * Generates search suggestions based on entity names and types.
+ */
+export declare class SearchSuggestions {
+    private storage;
+    constructor(storage: GraphStorage);
+    /**
+     * Get "did you mean?" suggestions for a query.
+     *
+     * Returns similar entity names and types that might be what the user intended.
+     * Excludes exact matches (similarity < 1.0) and very dissimilar strings (similarity > 0.5).
+     *
+     * @param query - The search query
+     * @param maxSuggestions - Maximum number of suggestions to return (default 5)
+     * @returns Array of suggested entity/type names sorted by similarity
+     */
+    getSearchSuggestions(query: string, maxSuggestions?: number): Promise<string[]>;
+}
+//# sourceMappingURL=SearchSuggestions.d.ts.map