@danielsimonjr/memory-mcp 12.5.2 → 12.7.0

package/dist/search/BasicSearch.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Basic Search
+ *
+ * Simple text-based search with tag, importance, and date filters with result caching.
+ *
+ * @module search/BasicSearch
+ */
+import type { KnowledgeGraph } from '../types/index.js';
+import type { GraphStorage } from '../core/GraphStorage.js';
+/**
+ * Performs basic text search with optional filters and caching.
+ */
+export declare class BasicSearch {
+    private storage;
+    private enableCache;
+    constructor(storage: GraphStorage, enableCache?: boolean);
+    /**
+     * Search nodes by text query with optional filters and pagination.
+     *
+     * Searches across entity names, types, and observations.
+     *
+     * @param query - Text to search for (case-insensitive)
+     * @param tags - Optional tags to filter by
+     * @param minImportance - Optional minimum importance (0-10)
+     * @param maxImportance - Optional maximum importance (0-10)
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: 50, max: 200)
+     * @returns Filtered knowledge graph with pagination applied
+     */
+    searchNodes(query: string, tags?: string[], minImportance?: number, maxImportance?: number, offset?: number, limit?: number): Promise<KnowledgeGraph>;
+    /**
+     * Open specific nodes by name.
+     *
+     * @param names - Array of entity names to retrieve
+     * @returns Knowledge graph with specified entities and their relations
+     */
+    openNodes(names: string[]): Promise<KnowledgeGraph>;
+    /**
+     * Search by date range with optional filters and pagination.
+     *
+     * @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
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: 50, max: 200)
+     * @returns Filtered knowledge graph with pagination applied
+     */
+    searchByDateRange(startDate?: string, endDate?: string, entityType?: string, tags?: string[], offset?: number, limit?: number): Promise<KnowledgeGraph>;
+}
+//# sourceMappingURL=BasicSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BasicSearch.d.ts","sourceRoot":"","sources":["../../src/search/BasicSearch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D;;GAEG;AACH,qBAAa,WAAW;IAEpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;gBADX,OAAO,EAAE,YAAY,EACrB,WAAW,GAAE,OAAc;IAGrC;;;;;;;;;;;;OAYG;IACG,WAAW,CACf,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,MAAU,EAClB,KAAK,GAAE,MAA8B,GACpC,OAAO,CAAC,cAAc,CAAC;IAwD1B;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAYzD;;;;;;;;;;OAUG;IACG,iBAAiB,CACrB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,MAAM,GAAE,MAAU,EAClB,KAAK,GAAE,MAA8B,GACpC,OAAO,CAAC,cAAc,CAAC;CAiD3B"}

package/dist/search/BasicSearch.js

@@ -0,0 +1,137 @@
+/**
+ * Basic Search
+ *
+ * Simple text-based search with tag, importance, and date filters with result caching.
+ *
+ * @module search/BasicSearch
+ */
+import { isWithinDateRange, SEARCH_LIMITS, searchCaches } from '../utils/index.js';
+import { SearchFilterChain } from './SearchFilterChain.js';
+/**
+ * Performs basic text search with optional filters and caching.
+ */
+export class BasicSearch {
+    storage;
+    enableCache;
+    constructor(storage, enableCache = true) {
+        this.storage = storage;
+        this.enableCache = enableCache;
+    }
+    /**
+     * Search nodes by text query with optional filters and pagination.
+     *
+     * Searches across entity names, types, and observations.
+     *
+     * @param query - Text to search for (case-insensitive)
+     * @param tags - Optional tags to filter by
+     * @param minImportance - Optional minimum importance (0-10)
+     * @param maxImportance - Optional maximum importance (0-10)
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: 50, max: 200)
+     * @returns Filtered knowledge graph with pagination applied
+     */
+    async searchNodes(query, tags, minImportance, maxImportance, offset = 0, limit = SEARCH_LIMITS.DEFAULT) {
+        // Check cache first
+        if (this.enableCache) {
+            const cacheKey = { query, tags, minImportance, maxImportance, offset, limit };
+            const cached = searchCaches.basic.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        const graph = await this.storage.loadGraph();
+        const queryLower = query.toLowerCase();
+        // First filter by text match (search-specific)
+        // OPTIMIZED: Uses pre-computed lowercase cache to avoid repeated toLowerCase() calls
+        const textMatched = graph.entities.filter(e => {
+            const lowercased = this.storage.getLowercased(e.name);
+            if (lowercased) {
+                return (lowercased.name.includes(queryLower) ||
+                    lowercased.entityType.includes(queryLower) ||
+                    lowercased.observations.some(o => o.includes(queryLower)));
+            }
+            // Fallback for entities not in cache (shouldn't happen in normal use)
+            return (e.name.toLowerCase().includes(queryLower) ||
+                e.entityType.toLowerCase().includes(queryLower) ||
+                e.observations.some(o => o.toLowerCase().includes(queryLower)));
+        });
+        // Apply tag and importance filters using SearchFilterChain
+        const filters = { tags, minImportance, maxImportance };
+        const filteredEntities = SearchFilterChain.applyFilters(textMatched, filters);
+        // Apply pagination using SearchFilterChain
+        const pagination = SearchFilterChain.validatePagination(offset, limit);
+        const paginatedEntities = SearchFilterChain.paginate(filteredEntities, pagination);
+        const filteredEntityNames = new Set(paginatedEntities.map(e => e.name));
+        const filteredRelations = graph.relations.filter(r => filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
+        const result = { entities: paginatedEntities, relations: filteredRelations };
+        // Cache the result
+        if (this.enableCache) {
+            const cacheKey = { query, tags, minImportance, maxImportance, offset, limit };
+            searchCaches.basic.set(cacheKey, result);
+        }
+        return result;
+    }
+    /**
+     * Open specific nodes by name.
+     *
+     * @param names - Array of entity names to retrieve
+     * @returns Knowledge graph with specified entities and their relations
+     */
+    async openNodes(names) {
+        const graph = await this.storage.loadGraph();
+        const filteredEntities = graph.entities.filter(e => names.includes(e.name));
+        const filteredEntityNames = new Set(filteredEntities.map(e => e.name));
+        const filteredRelations = graph.relations.filter(r => filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
+        return { entities: filteredEntities, relations: filteredRelations };
+    }
+    /**
+     * Search by date range with optional filters and pagination.
+     *
+     * @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
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: 50, max: 200)
+     * @returns Filtered knowledge graph with pagination applied
+     */
+    async searchByDateRange(startDate, endDate, entityType, tags, offset = 0, limit = SEARCH_LIMITS.DEFAULT) {
+        // Check cache first
+        if (this.enableCache) {
+            const cacheKey = { method: 'dateRange', startDate, endDate, entityType, tags, offset, limit };
+            const cached = searchCaches.basic.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        const graph = await this.storage.loadGraph();
+        // First filter by date range (search-specific - uses createdAt OR lastModified)
+        const dateFiltered = graph.entities.filter(e => {
+            const dateToCheck = e.createdAt || e.lastModified;
+            if (dateToCheck && !isWithinDateRange(dateToCheck, startDate, endDate)) {
+                return false;
+            }
+            return true;
+        });
+        // Apply entity type and tag filters using SearchFilterChain
+        const filters = { tags, entityType };
+        const filteredEntities = SearchFilterChain.applyFilters(dateFiltered, filters);
+        // Apply pagination using SearchFilterChain
+        const pagination = SearchFilterChain.validatePagination(offset, limit);
+        const paginatedEntities = SearchFilterChain.paginate(filteredEntities, pagination);
+        const filteredEntityNames = new Set(paginatedEntities.map(e => e.name));
+        const filteredRelations = graph.relations.filter(r => {
+            const dateToCheck = r.createdAt || r.lastModified;
+            const inDateRange = !dateToCheck || isWithinDateRange(dateToCheck, startDate, endDate);
+            const involvesFilteredEntities = filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to);
+            return inDateRange && involvesFilteredEntities;
+        });
+        const result = { entities: paginatedEntities, relations: filteredRelations };
+        // Cache the result
+        if (this.enableCache) {
+            const cacheKey = { method: 'dateRange', startDate, endDate, entityType, tags, offset, limit };
+            searchCaches.basic.set(cacheKey, result);
+        }
+        return result;
+    }
+}

package/dist/search/BooleanSearch.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Boolean Search
+ *
+ * Advanced search with boolean operators (AND, OR, NOT) and field-specific queries.
+ *
+ * @module search/BooleanSearch
+ */
+import type { KnowledgeGraph } from '../types/index.js';
+import type { GraphStorage } from '../core/GraphStorage.js';
+/**
+ * Performs boolean search with query parsing and AST evaluation.
+ */
+export declare class BooleanSearch {
+    private storage;
+    /**
+     * Phase 4 Sprint 4: AST cache to avoid re-parsing queries.
+     * Maps query string -> parsed AST.
+     */
+    private astCache;
+    /**
+     * Phase 4 Sprint 4: Result cache for boolean search.
+     * Maps cache key -> cached results.
+     */
+    private resultCache;
+    constructor(storage: GraphStorage);
+    /**
+     * Phase 4 Sprint 4: Generate cache key for boolean search.
+     */
+    private generateCacheKey;
+    /**
+     * Phase 4 Sprint 4: Clear all caches.
+     */
+    clearCache(): void;
+    /**
+     * Phase 4 Sprint 4: Cleanup old cache entries.
+     */
+    private cleanupResultCache;
+    /**
+     * Phase 4 Sprint 4: Get or parse AST for a query.
+     */
+    private getOrParseAST;
+    /**
+     * Boolean search with support for AND, OR, NOT operators, field-specific queries, and pagination.
+     *
+     * Phase 4 Sprint 4: Implements AST caching and result caching for repeated queries.
+     *
+     * Query syntax examples:
+     * - "alice AND programming" - Both terms must match
+     * - "type:person OR type:organization" - Either type matches
+     * - "NOT archived" - Exclude archived items
+     * - "name:alice AND (observation:coding OR observation:teaching)"
+     *
+     * @param query - Boolean query string
+     * @param tags - Optional tags filter
+     * @param minImportance - Optional minimum importance
+     * @param maxImportance - Optional maximum importance
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: 50, max: 200)
+     * @returns Filtered knowledge graph matching the boolean query with pagination applied
+     */
+    booleanSearch(query: string, tags?: string[], minImportance?: number, maxImportance?: number, offset?: number, limit?: number): Promise<KnowledgeGraph>;
+    /**
+     * Tokenize a boolean query into tokens.
+     *
+     * Handles quoted strings, parentheses, and operators.
+     */
+    private tokenizeBooleanQuery;
+    /**
+     * Parse a boolean search query into an AST.
+     *
+     * Supports: AND, OR, NOT, parentheses, field-specific queries (field:value)
+     */
+    private parseBooleanQuery;
+    /**
+     * Evaluate a boolean query AST against an entity.
+     */
+    private evaluateBooleanQuery;
+    /**
+     * Check if a search term is simple (no regex or wildcards).
+     * Simple terms can use the O(1) observation index.
+     */
+    private isSimpleTerm;
+    /**
+     * Check if entity matches a search term in any text field.
+     * OPTIMIZED: Uses pre-computed lowercase data when available.
+     */
+    private entityMatchesTerm;
+    /**
+     * Validate query complexity to prevent resource exhaustion.
+     * Checks nesting depth, term count, and operator count against configured limits.
+     */
+    private validateQueryComplexity;
+    /**
+     * Calculate query complexity metrics.
+     */
+    private calculateQueryComplexity;
+}
+//# sourceMappingURL=BooleanSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanSearch.d.ts","sourceRoot":"","sources":["../../src/search/BooleanSearch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAA4B,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAkC5D;;GAEG;AACH,qBAAa,aAAa;IAaZ,OAAO,CAAC,OAAO;IAZ3B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAA4C;IAE5D;;;OAGG;IACH,OAAO,CAAC,WAAW,CAA6C;gBAE5C,OAAO,EAAE,YAAY;IAEzC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwB1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;;;;;;;;;;;;;;;;OAkBG;IACG,aAAa,CACjB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,MAAU,EAClB,KAAK,GAAE,MAA8B,GACpC,OAAO,CAAC,cAAc,CAAC;IA2E1B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IA+C5B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAuFzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA2D5B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAKpB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAoBzB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IA2B/B;;OAEG;IACH,OAAO,CAAC,wBAAwB;CA8BjC"}