@danielsimonjr/memory-mcp 0.41.0 → 0.48.0

package/dist/search/BasicSearch.js

@@ -8,6 +8,7 @@
 import { isWithinDateRange } from '../utils/dateUtils.js';
 import { SEARCH_LIMITS } from '../utils/constants.js';
 import { searchCaches } from '../utils/searchCache.js';
+import { SearchFilterChain } from './SearchFilterChain.js';
 /**
  * Performs basic text search with optional filters and caching.
  */
@@ -41,37 +42,19 @@ export class BasicSearch {
             }
         }
         const graph = await this.storage.loadGraph();
-        const normalizedTags = tags?.map(tag => tag.toLowerCase());
-        // Validate pagination parameters
-        const validatedOffset = Math.max(0, offset);
-        const validatedLimit = Math.min(Math.max(SEARCH_LIMITS.MIN, limit), SEARCH_LIMITS.MAX);
-        const filteredEntities = graph.entities.filter(e => {
-            // Text search
-            const matchesQuery = e.name.toLowerCase().includes(query.toLowerCase()) ||
-                e.entityType.toLowerCase().includes(query.toLowerCase()) ||
-                e.observations.some(o => o.toLowerCase().includes(query.toLowerCase()));
-            if (!matchesQuery)
-                return false;
-            // Tag filter
-            if (normalizedTags && normalizedTags.length > 0) {
-                if (!e.tags || e.tags.length === 0)
-                    return false;
-                const entityTags = e.tags.map(tag => tag.toLowerCase());
-                const hasMatchingTag = normalizedTags.some(tag => entityTags.includes(tag));
-                if (!hasMatchingTag)
-                    return false;
-            }
-            // Importance filter
-            if (minImportance !== undefined && (e.importance === undefined || e.importance < minImportance)) {
-                return false;
-            }
-            if (maxImportance !== undefined && (e.importance === undefined || e.importance > maxImportance)) {
-                return false;
-            }
-            return true;
+        const queryLower = query.toLowerCase();
+        // First filter by text match (search-specific)
+        const textMatched = graph.entities.filter(e => {
+            return (e.name.toLowerCase().includes(queryLower) ||
+                e.entityType.toLowerCase().includes(queryLower) ||
+                e.observations.some(o => o.toLowerCase().includes(queryLower)));
         });
-        // Apply pagination
-        const paginatedEntities = filteredEntities.slice(validatedOffset, validatedOffset + validatedLimit);
+        // 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 };
@@ -116,33 +99,20 @@ export class BasicSearch {
             }
         }
         const graph = await this.storage.loadGraph();
-        const normalizedTags = tags?.map(tag => tag.toLowerCase());
-        // Validate pagination parameters
-        const validatedOffset = Math.max(0, offset);
-        const validatedLimit = Math.min(Math.max(SEARCH_LIMITS.MIN, limit), SEARCH_LIMITS.MAX);
-        const filteredEntities = graph.entities.filter(e => {
-            // Date filter (use createdAt or lastModified)
+        // 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;
             }
-            // Entity type filter
-            if (entityType && e.entityType !== entityType) {
-                return false;
-            }
-            // Tags filter
-            if (normalizedTags && normalizedTags.length > 0) {
-                if (!e.tags || e.tags.length === 0)
-                    return false;
-                const entityTags = e.tags.map(tag => tag.toLowerCase());
-                const hasMatchingTag = normalizedTags.some(tag => entityTags.includes(tag));
-                if (!hasMatchingTag)
-                    return false;
-            }
             return true;
         });
-        // Apply pagination
-        const paginatedEntities = filteredEntities.slice(validatedOffset, validatedOffset + validatedLimit);
+        // 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;

package/dist/search/BooleanSearch.js

@@ -7,6 +7,7 @@
  */
 import { SEARCH_LIMITS, QUERY_LIMITS } from '../utils/constants.js';
 import { ValidationError } from '../utils/errors.js';
+import { SearchFilterChain } from './SearchFilterChain.js';
 /**
  * Performs boolean search with query parsing and AST evaluation.
  */
@@ -48,36 +49,14 @@ export class BooleanSearch {
         }
         // Validate query complexity
         this.validateQueryComplexity(queryAst);
-        const normalizedTags = tags?.map(tag => tag.toLowerCase());
-        // Validate pagination parameters
-        const validatedOffset = Math.max(0, offset);
-        const validatedLimit = Math.min(Math.max(SEARCH_LIMITS.MIN, limit), SEARCH_LIMITS.MAX);
-        // Filter entities
-        const filteredEntities = graph.entities.filter(e => {
-            // Evaluate boolean query
-            if (!this.evaluateBooleanQuery(queryAst, e)) {
-                return false;
-            }
-            // Apply tag filter
-            if (normalizedTags && normalizedTags.length > 0) {
-                if (!e.tags || e.tags.length === 0)
-                    return false;
-                const entityTags = e.tags.map(tag => tag.toLowerCase());
-                const hasMatchingTag = normalizedTags.some(tag => entityTags.includes(tag));
-                if (!hasMatchingTag)
-                    return false;
-            }
-            // Apply importance filter
-            if (minImportance !== undefined && (e.importance === undefined || e.importance < minImportance)) {
-                return false;
-            }
-            if (maxImportance !== undefined && (e.importance === undefined || e.importance > maxImportance)) {
-                return false;
-            }
-            return true;
-        });
-        // Apply pagination
-        const paginatedEntities = filteredEntities.slice(validatedOffset, validatedOffset + validatedLimit);
+        // First filter by boolean query evaluation (search-specific)
+        const booleanMatched = graph.entities.filter(e => this.evaluateBooleanQuery(queryAst, e));
+        // Apply tag and importance filters using SearchFilterChain
+        const filters = { tags, minImportance, maxImportance };
+        const filteredEntities = SearchFilterChain.applyFilters(booleanMatched, 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));
         return { entities: paginatedEntities, relations: filteredRelations };

package/dist/search/FuzzySearch.js

@@ -7,6 +7,7 @@
  */
 import { levenshteinDistance } from '../utils/levenshtein.js';
 import { SEARCH_LIMITS } from '../utils/constants.js';
+import { SearchFilterChain } from './SearchFilterChain.js';
 /**
  * Default fuzzy search similarity threshold (70% match required).
  * Lower values are more permissive (more typos tolerated).
@@ -38,14 +39,9 @@ export class FuzzySearch {
      */
     async fuzzySearch(query, threshold = DEFAULT_FUZZY_THRESHOLD, tags, minImportance, maxImportance, offset = 0, limit = SEARCH_LIMITS.DEFAULT) {
         const graph = await this.storage.loadGraph();
-        const normalizedTags = tags?.map(tag => tag.toLowerCase());
-        // Validate pagination parameters
-        const validatedOffset = Math.max(0, offset);
-        const validatedLimit = Math.min(Math.max(SEARCH_LIMITS.MIN, limit), SEARCH_LIMITS.MAX);
-        // Filter entities using fuzzy matching
-        const filteredEntities = graph.entities.filter(e => {
-            // Fuzzy text search
-            const matchesQuery = this.isFuzzyMatch(e.name, query, threshold) ||
+        // First filter by fuzzy text match (search-specific)
+        const fuzzyMatched = graph.entities.filter(e => {
+            return (this.isFuzzyMatch(e.name, query, threshold) ||
                 this.isFuzzyMatch(e.entityType, query, threshold) ||
                 e.observations.some(o => 
                 // For observations, split into words and check each word
@@ -54,29 +50,14 @@ export class FuzzySearch {
                     .split(/\s+/)
                     .some(word => this.isFuzzyMatch(word, query, threshold)) ||
                     // Also check if the observation contains the query
-                    this.isFuzzyMatch(o, query, threshold));
-            if (!matchesQuery)
-                return false;
-            // Tag filter
-            if (normalizedTags && normalizedTags.length > 0) {
-                if (!e.tags || e.tags.length === 0)
-                    return false;
-                const entityTags = e.tags.map(tag => tag.toLowerCase());
-                const hasMatchingTag = normalizedTags.some(tag => entityTags.includes(tag));
-                if (!hasMatchingTag)
-                    return false;
-            }
-            // Importance filter
-            if (minImportance !== undefined && (e.importance === undefined || e.importance < minImportance)) {
-                return false;
-            }
-            if (maxImportance !== undefined && (e.importance === undefined || e.importance > maxImportance)) {
-                return false;
-            }
-            return true;
+                    this.isFuzzyMatch(o, query, threshold)));
         });
-        // Apply pagination
-        const paginatedEntities = filteredEntities.slice(validatedOffset, validatedOffset + validatedLimit);
+        // Apply tag and importance filters using SearchFilterChain
+        const filters = { tags, minImportance, maxImportance };
+        const filteredEntities = SearchFilterChain.applyFilters(fuzzyMatched, 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));
         return {

package/dist/search/RankedSearch.js

@@ -8,6 +8,7 @@
 import { calculateTFIDF, tokenize } from '../utils/tfidf.js';
 import { SEARCH_LIMITS } from '../utils/constants.js';
 import { TFIDFIndexManager } from './TFIDFIndexManager.js';
+import { SearchFilterChain } from './SearchFilterChain.js';
 /**
  * Performs TF-IDF ranked search with optional pre-calculated indexes.
  */
@@ -78,26 +79,9 @@ export class RankedSearch {
         // Enforce maximum search limit
         const effectiveLimit = Math.min(limit, SEARCH_LIMITS.MAX);
         const graph = await this.storage.loadGraph();
-        const normalizedTags = tags?.map(tag => tag.toLowerCase());
-        // Filter entities by tags and importance
-        const filteredEntities = graph.entities.filter(e => {
-            // Tag filter
-            if (normalizedTags && normalizedTags.length > 0) {
-                if (!e.tags || e.tags.length === 0)
-                    return false;
-                const entityTags = e.tags.map(tag => tag.toLowerCase());
-                if (!normalizedTags.some(tag => entityTags.includes(tag)))
-                    return false;
-            }
-            // Importance filter
-            if (minImportance !== undefined && (e.importance === undefined || e.importance < minImportance)) {
-                return false;
-            }
-            if (maxImportance !== undefined && (e.importance === undefined || e.importance > maxImportance)) {
-                return false;
-            }
-            return true;
-        });
+        // Apply tag and importance filters using SearchFilterChain
+        const filters = { tags, minImportance, maxImportance };
+        const filteredEntities = SearchFilterChain.applyFilters(graph.entities, filters);
         // Try to use pre-calculated index
         const index = await this.ensureIndexLoaded();
         const queryTerms = tokenize(query);

package/dist/search/SearchFilterChain.js

@@ -0,0 +1,187 @@
+/**
+ * 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 { normalizeTags, hasMatchingTag } from '../utils/tagUtils.js';
+import { isWithinImportanceRange } from '../utils/filterUtils.js';
+import { validatePagination, applyPagination } from '../utils/paginationUtils.js';
+/**
+ * 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 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, filters) {
+        // Early return if no filters are active
+        if (!this.hasActiveFilters(filters)) {
+            return entities;
+        }
+        // Pre-normalize tags once for efficiency
+        const normalizedSearchTags = filters.tags?.length
+            ? normalizeTags(filters.tags)
+            : undefined;
+        return entities.filter(entity => this.entityPassesFilters(entity, filters, normalizedSearchTags));
+    }
+    /**
+     * 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, filters, normalizedSearchTags) {
+        // Tag filter - check if entity has any matching tag
+        if (normalizedSearchTags && normalizedSearchTags.length > 0) {
+            if (!entity.tags || entity.tags.length === 0) {
+                return false;
+            }
+            const entityTags = normalizeTags(entity.tags);
+            const hasMatch = normalizedSearchTags.some(tag => entityTags.includes(tag));
+            if (!hasMatch) {
+                return false;
+            }
+        }
+        // Importance filter
+        if (!isWithinImportanceRange(entity.importance, filters.minImportance, filters.maxImportance)) {
+            return false;
+        }
+        // Entity type filter
+        if (filters.entityType && entity.entityType !== filters.entityType) {
+            return false;
+        }
+        // Created date filter
+        if (filters.createdAfter || filters.createdBefore) {
+            if (!entity.createdAt) {
+                return false;
+            }
+            const createdAt = new Date(entity.createdAt);
+            if (filters.createdAfter && createdAt < new Date(filters.createdAfter)) {
+                return false;
+            }
+            if (filters.createdBefore && createdAt > new Date(filters.createdBefore)) {
+                return false;
+            }
+        }
+        // Modified date filter
+        if (filters.modifiedAfter || filters.modifiedBefore) {
+            if (!entity.lastModified) {
+                return false;
+            }
+            const modifiedAt = new Date(entity.lastModified);
+            if (filters.modifiedAfter && modifiedAt < new Date(filters.modifiedAfter)) {
+                return false;
+            }
+            if (filters.modifiedBefore && modifiedAt > new Date(filters.modifiedBefore)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 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) {
+        return !!((filters.tags && filters.tags.length > 0) ||
+            filters.minImportance !== undefined ||
+            filters.maxImportance !== undefined ||
+            filters.entityType ||
+            filters.createdAfter ||
+            filters.createdBefore ||
+            filters.modifiedAfter ||
+            filters.modifiedBefore);
+    }
+    /**
+     * Validates and returns pagination parameters.
+     * Delegates to paginationUtils.validatePagination.
+     *
+     * @param offset - Starting position
+     * @param limit - Maximum results
+     * @returns Validated pagination object
+     */
+    static validatePagination(offset = 0, limit) {
+        return validatePagination(offset, limit);
+    }
+    /**
+     * 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, pagination) {
+        return applyPagination(entities, pagination);
+    }
+    /**
+     * 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, filters, offset = 0, limit) {
+        const filtered = this.applyFilters(entities, filters);
+        const pagination = this.validatePagination(offset, limit);
+        return this.paginate(filtered, pagination);
+    }
+    /**
+     * 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, tags) {
+        if (!tags || tags.length === 0) {
+            return entities;
+        }
+        const normalizedTags = normalizeTags(tags);
+        return entities.filter(entity => {
+            if (!entity.tags || entity.tags.length === 0) {
+                return false;
+            }
+            return hasMatchingTag(entity.tags, normalizedTags);
+        });
+    }
+    /**
+     * 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, minImportance, maxImportance) {
+        if (minImportance === undefined && maxImportance === undefined) {
+            return entities;
+        }
+        return entities.filter(entity => isWithinImportanceRange(entity.importance, minImportance, maxImportance));
+    }
+}

package/dist/search/index.js

@@ -1,5 +1,7 @@
 /**
  * Search Module Barrel Export
+ *
+ * Sprint 2: Added SearchFilterChain for centralized filter logic
  */
 export { BasicSearch } from './BasicSearch.js';
 export { RankedSearch } from './RankedSearch.js';
@@ -8,3 +10,5 @@ export { FuzzySearch } from './FuzzySearch.js';
 export { SearchSuggestions } from './SearchSuggestions.js';
 export { SavedSearchManager } from './SavedSearchManager.js';
 export { SearchManager } from './SearchManager.js';
+// Sprint 2: Search Filter Chain utilities
+export { SearchFilterChain } from './SearchFilterChain.js';