@danielsimonjr/memory-mcp 0.41.0 → 0.48.0

package/dist/utils/tagUtils.js

@@ -0,0 +1,107 @@
+/**
+ * Tag Normalization and Matching Utilities
+ *
+ * Centralizes tag operations to eliminate duplicate normalization logic
+ * across the codebase. All tags are normalized to lowercase for consistent matching.
+ */
+/**
+ * Normalizes a single tag to lowercase and trimmed.
+ *
+ * @param tag - Tag to normalize
+ * @returns Normalized tag
+ */
+export function normalizeTag(tag) {
+    return tag.toLowerCase().trim();
+}
+/**
+ * Normalizes an array of tags to lowercase.
+ * Handles undefined/null input gracefully.
+ *
+ * @param tags - Array of tags to normalize, or undefined
+ * @returns Normalized tags array, or empty array if input is undefined/null
+ */
+export function normalizeTags(tags) {
+    if (!tags || tags.length === 0)
+        return [];
+    return tags.map(tag => tag.toLowerCase());
+}
+/**
+ * Checks if an entity's tags include any of the specified search tags.
+ * Both inputs are normalized before comparison.
+ *
+ * @param entityTags - Tags on the entity (may be undefined)
+ * @param searchTags - Tags to search for (may be undefined)
+ * @returns true if any search tag matches any entity tag, false if no match or either is empty
+ */
+export function hasMatchingTag(entityTags, searchTags) {
+    if (!entityTags || entityTags.length === 0)
+        return false;
+    if (!searchTags || searchTags.length === 0)
+        return false;
+    const normalizedEntity = normalizeTags(entityTags);
+    const normalizedSearch = normalizeTags(searchTags);
+    return normalizedSearch.some(tag => normalizedEntity.includes(tag));
+}
+/**
+ * Checks if entity tags include ALL of the specified required tags.
+ *
+ * @param entityTags - Tags on the entity (may be undefined)
+ * @param requiredTags - All tags that must be present
+ * @returns true if all required tags are present
+ */
+export function hasAllTags(entityTags, requiredTags) {
+    if (!entityTags || entityTags.length === 0)
+        return false;
+    if (requiredTags.length === 0)
+        return true;
+    const normalizedEntity = normalizeTags(entityTags);
+    return normalizeTags(requiredTags).every(tag => normalizedEntity.includes(tag));
+}
+/**
+ * Filters entities by tag match.
+ * Returns all entities if searchTags is empty or undefined.
+ *
+ * @param entities - Array of entities with optional tags property
+ * @param searchTags - Tags to filter by
+ * @returns Filtered entities that have at least one matching tag
+ */
+export function filterByTags(entities, searchTags) {
+    if (!searchTags || searchTags.length === 0) {
+        return entities;
+    }
+    const normalizedSearch = normalizeTags(searchTags);
+    return entities.filter(entity => {
+        if (!entity.tags || entity.tags.length === 0)
+            return false;
+        const normalizedEntity = normalizeTags(entity.tags);
+        return normalizedSearch.some(tag => normalizedEntity.includes(tag));
+    });
+}
+/**
+ * Adds new tags to an existing tag array, avoiding duplicates.
+ * All tags are normalized to lowercase.
+ *
+ * @param existingTags - Current tags (may be undefined)
+ * @param newTags - Tags to add
+ * @returns Combined tags array with no duplicates
+ */
+export function addUniqueTags(existingTags, newTags) {
+    const existing = normalizeTags(existingTags);
+    const toAdd = normalizeTags(newTags);
+    const uniqueNew = toAdd.filter(tag => !existing.includes(tag));
+    return [...existing, ...uniqueNew];
+}
+/**
+ * Removes specified tags from an existing tag array.
+ * Comparison is case-insensitive.
+ *
+ * @param existingTags - Current tags (may be undefined)
+ * @param tagsToRemove - Tags to remove
+ * @returns Tags array with specified tags removed
+ */
+export function removeTags(existingTags, tagsToRemove) {
+    if (!existingTags || existingTags.length === 0)
+        return [];
+    const toRemoveNormalized = normalizeTags(tagsToRemove);
+    return existingTags.filter(tag => !toRemoveNormalized.includes(tag.toLowerCase()));
+}

package/dist/utils/validationHelper.js

@@ -0,0 +1,99 @@
+/**
+ * Zod Schema Validation Helper
+ *
+ * Centralizes Zod validation patterns to eliminate redundant error formatting
+ * and validation logic across the codebase.
+ */
+import { ValidationError } from './errors.js';
+/**
+ * Formats Zod errors into human-readable strings.
+ *
+ * @param error - Zod error object
+ * @returns Array of formatted error messages
+ */
+export function formatZodErrors(error) {
+    return error.issues.map(issue => {
+        const path = issue.path.length > 0 ? `${issue.path.join('.')}: ` : '';
+        return `${path}${issue.message}`;
+    });
+}
+/**
+ * Validates data against a Zod schema and returns the typed result.
+ * Throws ValidationError with formatted error messages on failure.
+ *
+ * @param data - The data to validate
+ * @param schema - The Zod schema to validate against
+ * @param errorMessage - Custom error message prefix (default: 'Validation failed')
+ * @returns The validated and typed data
+ * @throws ValidationError if validation fails
+ *
+ * @example
+ * ```typescript
+ * const entities = validateWithSchema(
+ *   input,
+ *   BatchCreateEntitiesSchema,
+ *   'Invalid entity data'
+ * );
+ * ```
+ */
+export function validateWithSchema(data, schema, errorMessage = 'Validation failed') {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        const errors = formatZodErrors(result.error);
+        throw new ValidationError(errorMessage, errors);
+    }
+    return result.data;
+}
+/**
+ * Validates data and returns a result object instead of throwing.
+ * Useful when you want to handle validation errors gracefully.
+ *
+ * @param data - The data to validate
+ * @param schema - The Zod schema to validate against
+ * @returns Result object with success status and either data or errors
+ *
+ * @example
+ * ```typescript
+ * const result = validateSafe(input, EntitySchema);
+ * if (result.success) {
+ *   console.log(result.data);
+ * } else {
+ *   console.error(result.errors);
+ * }
+ * ```
+ */
+export function validateSafe(data, schema) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, errors: formatZodErrors(result.error) };
+}
+/**
+ * Validates an array of items against a schema.
+ * Returns detailed information about which items failed validation.
+ *
+ * @param items - Array of items to validate
+ * @param schema - Zod schema for individual items
+ * @param errorMessage - Custom error message prefix
+ * @returns Array of validated items
+ * @throws ValidationError if any item fails validation
+ */
+export function validateArrayWithSchema(items, schema, errorMessage = 'Array validation failed') {
+    const errors = [];
+    const validated = [];
+    for (let i = 0; i < items.length; i++) {
+        const result = schema.safeParse(items[i]);
+        if (result.success) {
+            validated.push(result.data);
+        }
+        else {
+            const itemErrors = formatZodErrors(result.error);
+            errors.push(...itemErrors.map(e => `[${i}] ${e}`));
+        }
+    }
+    if (errors.length > 0) {
+        throw new ValidationError(errorMessage, errors);
+    }
+    return validated;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielsimonjr/memory-mcp",
-  "version": "0.41.0",
-  "description": "Enhanced MCP memory server with hierarchies, compression, archiving, and 45 advanced tools",
+  "version": "0.48.0",
+  "description": "Enhanced MCP memory server with hierarchies, compression, archiving, and 47 advanced tools",
   "license": "MIT",
   "author": "Daniel Simon Jr. (https://github.com/danielsimonjr)",
   "homepage": "https://github.com/danielsimonjr/memory-mcp",
@@ -23,6 +23,38 @@
     "analytics"
   ],
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    },
+    "./search": {
+      "types": "./dist/search/index.d.ts",
+      "import": "./dist/search/index.js"
+    },
+    "./features": {
+      "types": "./dist/features/index.d.ts",
+      "import": "./dist/features/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/MCPServer.d.ts",
+      "import": "./dist/server/MCPServer.js"
+    }
+  },
   "bin": {
     "mcp-server-memory": "dist/index.js"
   },