@danielsimonjr/memory-mcp 0.48.0 → 9.8.0

package/dist/features/ImportManager.js

@@ -1,328 +0,0 @@
-/**
- * Import Manager
- *
- * Imports knowledge graphs from various formats (JSON, CSV, GraphML) with merge strategies.
- *
- * @module features/ImportManager
- */
-/**
- * Manages knowledge graph imports from multiple formats.
- */
-export class ImportManager {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    /**
-     * Import graph from formatted data.
-     *
-     * @param format - Import format
-     * @param data - Import data string
-     * @param mergeStrategy - How to handle conflicts
-     * @param dryRun - If true, preview changes without applying
-     * @returns Import result with statistics
-     */
-    async importGraph(format, data, mergeStrategy = 'skip', dryRun = false) {
-        let importedGraph;
-        try {
-            switch (format) {
-                case 'json':
-                    importedGraph = this.parseJsonImport(data);
-                    break;
-                case 'csv':
-                    importedGraph = this.parseCsvImport(data);
-                    break;
-                case 'graphml':
-                    importedGraph = this.parseGraphMLImport(data);
-                    break;
-                default:
-                    throw new Error(`Unsupported import format: ${format}`);
-            }
-        }
-        catch (error) {
-            return {
-                entitiesAdded: 0,
-                entitiesSkipped: 0,
-                entitiesUpdated: 0,
-                relationsAdded: 0,
-                relationsSkipped: 0,
-                errors: [`Failed to parse ${format} data: ${error instanceof Error ? error.message : String(error)}`],
-            };
-        }
-        return await this.mergeImportedGraph(importedGraph, mergeStrategy, dryRun);
-    }
-    /**
-     * Parse JSON format.
-     */
-    parseJsonImport(data) {
-        const parsed = JSON.parse(data);
-        if (!parsed.entities || !Array.isArray(parsed.entities)) {
-            throw new Error('Invalid JSON: missing or invalid entities array');
-        }
-        if (!parsed.relations || !Array.isArray(parsed.relations)) {
-            throw new Error('Invalid JSON: missing or invalid relations array');
-        }
-        return {
-            entities: parsed.entities,
-            relations: parsed.relations,
-        };
-    }
-    /**
-     * Parse CSV format.
-     *
-     * Expects: # ENTITIES section with header, then # RELATIONS section with header
-     */
-    parseCsvImport(data) {
-        const lines = data
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line);
-        const entities = [];
-        const relations = [];
-        let section = null;
-        let headerParsed = false;
-        const parseCsvLine = (line) => {
-            const fields = [];
-            let current = '';
-            let inQuotes = false;
-            for (let i = 0; i < line.length; i++) {
-                const char = line[i];
-                if (char === '"') {
-                    if (inQuotes && line[i + 1] === '"') {
-                        current += '"';
-                        i++;
-                    }
-                    else {
-                        inQuotes = !inQuotes;
-                    }
-                }
-                else if (char === ',' && !inQuotes) {
-                    fields.push(current);
-                    current = '';
-                }
-                else {
-                    current += char;
-                }
-            }
-            fields.push(current);
-            return fields;
-        };
-        for (const line of lines) {
-            if (line.startsWith('# ENTITIES')) {
-                section = 'entities';
-                headerParsed = false;
-                continue;
-            }
-            else if (line.startsWith('# RELATIONS')) {
-                section = 'relations';
-                headerParsed = false;
-                continue;
-            }
-            if (line.startsWith('#'))
-                continue;
-            if (section === 'entities') {
-                if (!headerParsed) {
-                    headerParsed = true;
-                    continue;
-                }
-                const fields = parseCsvLine(line);
-                if (fields.length >= 2) {
-                    const entity = {
-                        name: fields[0],
-                        entityType: fields[1],
-                        observations: fields[2]
-                            ? fields[2]
-                                .split(';')
-                                .map(s => s.trim())
-                                .filter(s => s)
-                            : [],
-                        createdAt: fields[3] || undefined,
-                        lastModified: fields[4] || undefined,
-                        tags: fields[5]
-                            ? fields[5]
-                                .split(';')
-                                .map(s => s.trim().toLowerCase())
-                                .filter(s => s)
-                            : undefined,
-                        importance: fields[6] ? parseFloat(fields[6]) : undefined,
-                    };
-                    entities.push(entity);
-                }
-            }
-            else if (section === 'relations') {
-                if (!headerParsed) {
-                    headerParsed = true;
-                    continue;
-                }
-                const fields = parseCsvLine(line);
-                if (fields.length >= 3) {
-                    const relation = {
-                        from: fields[0],
-                        to: fields[1],
-                        relationType: fields[2],
-                        createdAt: fields[3] || undefined,
-                        lastModified: fields[4] || undefined,
-                    };
-                    relations.push(relation);
-                }
-            }
-        }
-        return { entities, relations };
-    }
-    /**
-     * Parse GraphML format.
-     *
-     * Note: Simplified regex-based parser for basic GraphML structure.
-     */
-    parseGraphMLImport(data) {
-        const entities = [];
-        const relations = [];
-        // Extract nodes
-        const nodeRegex = /<node\s+id="([^"]+)"[^>]*>([\s\S]*?)<\/node>/g;
-        let nodeMatch;
-        while ((nodeMatch = nodeRegex.exec(data)) !== null) {
-            const nodeId = nodeMatch[1];
-            const nodeContent = nodeMatch[2];
-            const getDataValue = (key) => {
-                const dataRegex = new RegExp(`<data\\s+key="${key}">([^<]*)<\/data>`);
-                const match = dataRegex.exec(nodeContent);
-                return match ? match[1] : undefined;
-            };
-            const entity = {
-                name: nodeId,
-                entityType: getDataValue('d0') || getDataValue('entityType') || 'unknown',
-                observations: (getDataValue('d1') || getDataValue('observations') || '')
-                    .split(';')
-                    .map(s => s.trim())
-                    .filter(s => s),
-                createdAt: getDataValue('d2') || getDataValue('createdAt'),
-                lastModified: getDataValue('d3') || getDataValue('lastModified'),
-                tags: (getDataValue('d4') || getDataValue('tags') || '')
-                    .split(';')
-                    .map(s => s.trim().toLowerCase())
-                    .filter(s => s),
-                importance: getDataValue('d5') || getDataValue('importance') ? parseFloat(getDataValue('d5') || getDataValue('importance') || '0') : undefined,
-            };
-            entities.push(entity);
-        }
-        // Extract edges
-        const edgeRegex = /<edge\s+[^>]*source="([^"]+)"\s+target="([^"]+)"[^>]*>([\s\S]*?)<\/edge>/g;
-        let edgeMatch;
-        while ((edgeMatch = edgeRegex.exec(data)) !== null) {
-            const source = edgeMatch[1];
-            const target = edgeMatch[2];
-            const edgeContent = edgeMatch[3];
-            const getDataValue = (key) => {
-                const dataRegex = new RegExp(`<data\\s+key="${key}">([^<]*)<\/data>`);
-                const match = dataRegex.exec(edgeContent);
-                return match ? match[1] : undefined;
-            };
-            const relation = {
-                from: source,
-                to: target,
-                relationType: getDataValue('e0') || getDataValue('relationType') || 'related_to',
-                createdAt: getDataValue('e1') || getDataValue('createdAt'),
-                lastModified: getDataValue('e2') || getDataValue('lastModified'),
-            };
-            relations.push(relation);
-        }
-        return { entities, relations };
-    }
-    /**
-     * Merge imported graph with existing graph.
-     */
-    async mergeImportedGraph(importedGraph, mergeStrategy, dryRun) {
-        const existingGraph = await this.storage.loadGraph();
-        const result = {
-            entitiesAdded: 0,
-            entitiesSkipped: 0,
-            entitiesUpdated: 0,
-            relationsAdded: 0,
-            relationsSkipped: 0,
-            errors: [],
-        };
-        const existingEntitiesMap = new Map();
-        for (const entity of existingGraph.entities) {
-            existingEntitiesMap.set(entity.name, entity);
-        }
-        const existingRelationsSet = new Set();
-        for (const relation of existingGraph.relations) {
-            existingRelationsSet.add(`${relation.from}|${relation.to}|${relation.relationType}`);
-        }
-        // Process entities
-        for (const importedEntity of importedGraph.entities) {
-            const existing = existingEntitiesMap.get(importedEntity.name);
-            if (!existing) {
-                result.entitiesAdded++;
-                if (!dryRun) {
-                    existingGraph.entities.push(importedEntity);
-                    existingEntitiesMap.set(importedEntity.name, importedEntity);
-                }
-            }
-            else {
-                switch (mergeStrategy) {
-                    case 'replace':
-                        result.entitiesUpdated++;
-                        if (!dryRun) {
-                            Object.assign(existing, importedEntity);
-                        }
-                        break;
-                    case 'skip':
-                        result.entitiesSkipped++;
-                        break;
-                    case 'merge':
-                        result.entitiesUpdated++;
-                        if (!dryRun) {
-                            existing.observations = [
-                                ...new Set([...existing.observations, ...importedEntity.observations]),
-                            ];
-                            if (importedEntity.tags) {
-                                existing.tags = existing.tags || [];
-                                existing.tags = [...new Set([...existing.tags, ...importedEntity.tags])];
-                            }
-                            if (importedEntity.importance !== undefined) {
-                                existing.importance = importedEntity.importance;
-                            }
-                            existing.lastModified = new Date().toISOString();
-                        }
-                        break;
-                    case 'fail':
-                        result.errors.push(`Entity "${importedEntity.name}" already exists`);
-                        break;
-                }
-            }
-        }
-        // Process relations
-        for (const importedRelation of importedGraph.relations) {
-            const relationKey = `${importedRelation.from}|${importedRelation.to}|${importedRelation.relationType}`;
-            if (!existingEntitiesMap.has(importedRelation.from)) {
-                result.errors.push(`Relation source entity "${importedRelation.from}" does not exist`);
-                continue;
-            }
-            if (!existingEntitiesMap.has(importedRelation.to)) {
-                result.errors.push(`Relation target entity "${importedRelation.to}" does not exist`);
-                continue;
-            }
-            if (!existingRelationsSet.has(relationKey)) {
-                result.relationsAdded++;
-                if (!dryRun) {
-                    existingGraph.relations.push(importedRelation);
-                    existingRelationsSet.add(relationKey);
-                }
-            }
-            else {
-                if (mergeStrategy === 'fail') {
-                    result.errors.push(`Relation "${relationKey}" already exists`);
-                }
-                else {
-                    result.relationsSkipped++;
-                }
-            }
-        }
-        // Save if not dry run and no blocking errors
-        if (!dryRun && (mergeStrategy !== 'fail' || result.errors.length === 0)) {
-            await this.storage.saveGraph(existingGraph);
-        }
-        return result;
-    }
-}

package/dist/types/analytics.types.js

@@ -1,6 +0,0 @@
-/**
- * Analytics Types
- *
- * Type definitions for graph statistics, validation reports, and analytics data.
- */
-export {};

package/dist/types/entity.types.js

@@ -1,7 +0,0 @@
-/**
- * Entity Types
- *
- * Core type definitions for entities, relations, and the knowledge graph structure.
- * These types form the foundation of the memory MCP server's data model.
- */
-export {};

package/dist/types/import-export.types.js

@@ -1,7 +0,0 @@
-/**
- * Import/Export Types
- *
- * Type definitions for import and export operations, including
- * result summaries, compression results, and export filters.
- */
-export {};

package/dist/types/search.types.js

@@ -1,7 +0,0 @@
-/**
- * Search Types
- *
- * Type definitions for search operations, including search results,
- * saved searches, and boolean query AST structures.
- */
-export {};

package/dist/types/tag.types.js

@@ -1,6 +0,0 @@
-/**
- * Tag Types
- *
- * Type definitions for tag management, including tag aliases for synonyms.
- */
-export {};

package/dist/utils/dateUtils.js

@@ -1,89 +0,0 @@
-/**
- * Date Utilities
- *
- * Helper functions for date parsing, validation, and range filtering.
- * All dates use ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ).
- *
- * @module utils/dateUtils
- */
-/**
- * Check if a date falls within a specified range.
- *
- * @param date - ISO 8601 date string to check
- * @param start - Optional start date (inclusive)
- * @param end - Optional end date (inclusive)
- * @returns True if date is within range
- *
- * @example
- * ```typescript
- * isWithinDateRange('2024-06-15T00:00:00Z', '2024-01-01T00:00:00Z', '2024-12-31T23:59:59Z'); // true
- * isWithinDateRange('2024-06-15T00:00:00Z', '2024-07-01T00:00:00Z'); // false
- * ```
- */
-export function isWithinDateRange(date, start, end) {
-    const dateObj = new Date(date);
-    if (isNaN(dateObj.getTime())) {
-        return false;
-    }
-    if (start) {
-        const startObj = new Date(start);
-        if (isNaN(startObj.getTime())) {
-            return false;
-        }
-        if (dateObj < startObj) {
-            return false;
-        }
-    }
-    if (end) {
-        const endObj = new Date(end);
-        if (isNaN(endObj.getTime())) {
-            return false;
-        }
-        if (dateObj > endObj) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Parse and validate date range strings.
- *
- * @param startDate - Optional ISO 8601 start date
- * @param endDate - Optional ISO 8601 end date
- * @returns Parsed Date objects or null
- */
-export function parseDateRange(startDate, endDate) {
-    let start = null;
-    let end = null;
-    if (startDate) {
-        start = new Date(startDate);
-        if (isNaN(start.getTime())) {
-            start = null;
-        }
-    }
-    if (endDate) {
-        end = new Date(endDate);
-        if (isNaN(end.getTime())) {
-            end = null;
-        }
-    }
-    return { start, end };
-}
-/**
- * Validate if a string is a valid ISO 8601 date.
- *
- * @param date - Date string to validate
- * @returns True if valid ISO 8601 date
- */
-export function isValidISODate(date) {
-    const dateObj = new Date(date);
-    return !isNaN(dateObj.getTime()) && dateObj.toISOString() === date;
-}
-/**
- * Get current timestamp in ISO 8601 format.
- *
- * @returns Current timestamp string
- */
-export function getCurrentTimestamp() {
-    return new Date().toISOString();
-}

package/dist/utils/filterUtils.js

@@ -1,155 +0,0 @@
-/**
- * Entity Filtering Utilities
- *
- * Centralizes common filtering logic for importance, date ranges, and other
- * entity properties to eliminate duplicate patterns across search implementations.
- */
-/**
- * Checks if an entity's importance is within the specified range.
- * Entities without importance are treated as not matching if any filter is set.
- *
- * @param importance - The entity's importance value (may be undefined)
- * @param minImportance - Minimum importance filter (inclusive)
- * @param maxImportance - Maximum importance filter (inclusive)
- * @returns true if importance is within range or no filters are set
- *
- * @example
- * ```typescript
- * // Check if entity passes importance filter
- * if (isWithinImportanceRange(entity.importance, 5, 10)) {
- *   // Entity has importance between 5 and 10
- * }
- * ```
- */
-export function isWithinImportanceRange(importance, minImportance, maxImportance) {
-    // If no filters set, always pass
-    if (minImportance === undefined && maxImportance === undefined) {
-        return true;
-    }
-    // Check minimum importance
-    if (minImportance !== undefined) {
-        if (importance === undefined || importance < minImportance) {
-            return false;
-        }
-    }
-    // Check maximum importance
-    if (maxImportance !== undefined) {
-        if (importance === undefined || importance > maxImportance) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Filters entities by importance range.
- * Returns all entities if no importance filters are specified.
- *
- * @param entities - Array of entities to filter
- * @param minImportance - Minimum importance filter (inclusive)
- * @param maxImportance - Maximum importance filter (inclusive)
- * @returns Filtered entities within the importance range
- */
-export function filterByImportance(entities, minImportance, maxImportance) {
-    if (minImportance === undefined && maxImportance === undefined) {
-        return entities;
-    }
-    return entities.filter(e => isWithinImportanceRange(e.importance, minImportance, maxImportance));
-}
-/**
- * Checks if a date value is within the specified range.
- * Handles undefined values appropriately.
- *
- * @param dateValue - ISO 8601 date string to check (may be undefined)
- * @param startDate - Start of date range (inclusive)
- * @param endDate - End of date range (inclusive)
- * @returns true if date is within range or no filters are set
- */
-export function isWithinDateRange(dateValue, startDate, endDate) {
-    // If no filters set, always pass
-    if (!startDate && !endDate) {
-        return true;
-    }
-    // If date value is undefined but we have filters, fail
-    if (!dateValue) {
-        return false;
-    }
-    const date = new Date(dateValue);
-    if (startDate && date < new Date(startDate)) {
-        return false;
-    }
-    if (endDate && date > new Date(endDate)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Filters entities by creation date range.
- *
- * @param entities - Array of entities to filter
- * @param startDate - Start of date range (inclusive)
- * @param endDate - End of date range (inclusive)
- * @returns Filtered entities created within the date range
- */
-export function filterByCreatedDate(entities, startDate, endDate) {
-    if (!startDate && !endDate) {
-        return entities;
-    }
-    return entities.filter(e => isWithinDateRange(e.createdAt, startDate, endDate));
-}
-/**
- * Filters entities by last modified date range.
- *
- * @param entities - Array of entities to filter
- * @param startDate - Start of date range (inclusive)
- * @param endDate - End of date range (inclusive)
- * @returns Filtered entities modified within the date range
- */
-export function filterByModifiedDate(entities, startDate, endDate) {
-    if (!startDate && !endDate) {
-        return entities;
-    }
-    return entities.filter(e => isWithinDateRange(e.lastModified, startDate, endDate));
-}
-/**
- * Filters entities by entity type.
- *
- * @param entities - Array of entities to filter
- * @param entityType - Entity type to filter by (case-sensitive)
- * @returns Filtered entities of the specified type
- */
-export function filterByEntityType(entities, entityType) {
-    if (!entityType) {
-        return entities;
-    }
-    return entities.filter(e => e.entityType === entityType);
-}
-/**
- * Checks if an entity passes all the specified filters.
- * Short-circuits on first failing filter for performance.
- *
- * Note: Tag filtering should be handled separately using tagUtils.hasMatchingTag
- * as it requires special normalization logic.
- *
- * @param entity - Entity to check
- * @param filters - Filters to apply
- * @returns true if entity passes all filters
- */
-export function entityPassesFilters(entity, filters) {
-    // 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 (!isWithinDateRange(entity.createdAt, filters.createdAfter, filters.createdBefore)) {
-        return false;
-    }
-    // Modified date filter
-    if (!isWithinDateRange(entity.lastModified, filters.modifiedAfter, filters.modifiedBefore)) {
-        return false;
-    }
-    return true;
-}

package/dist/utils/levenshtein.js

@@ -1,62 +0,0 @@
-/**
- * Levenshtein Distance Algorithm
- *
- * Calculates the minimum number of single-character edits (insertions,
- * deletions, or substitutions) needed to change one string into another.
- *
- * Used for fuzzy string matching to find similar entities despite typos.
- *
- * @module utils/levenshtein
- */
-/**
- * Calculate Levenshtein distance between two strings.
- *
- * Returns the minimum number of single-character edits needed to change
- * one word into another.
- *
- * **Algorithm**: Dynamic programming with O(m*n) time and space complexity,
- * where m and n are the lengths of the two strings.
- *
- * @param str1 - First string to compare
- * @param str2 - Second string to compare
- * @returns Minimum number of edits required (0 = identical strings)
- *
- * @example
- * ```typescript
- * levenshteinDistance("kitten", "sitting"); // Returns 3
- * levenshteinDistance("hello", "hello");    // Returns 0
- * levenshteinDistance("abc", "");           // Returns 3
- * ```
- */
-export function levenshteinDistance(str1, str2) {
-    const m = str1.length;
-    const n = str2.length;
-    // Create 2D array for dynamic programming
-    const dp = Array(m + 1)
-        .fill(null)
-        .map(() => Array(n + 1).fill(0));
-    // Initialize base cases: distance from empty string
-    for (let i = 0; i <= m; i++) {
-        dp[i][0] = i;
-    }
-    for (let j = 0; j <= n; j++) {
-        dp[0][j] = j;
-    }
-    // Fill dp table
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (str1[i - 1] === str2[j - 1]) {
-                // Characters match, no edit needed
-                dp[i][j] = dp[i - 1][j - 1];
-            }
-            else {
-                // Take minimum of three operations
-                dp[i][j] = Math.min(dp[i - 1][j] + 1, // deletion
-                dp[i][j - 1] + 1, // insertion
-                dp[i - 1][j - 1] + 1 // substitution
-                );
-            }
-        }
-    }
-    return dp[m][n];
-}