mcp-learning-memory 0.2.0

package/dist/validation.js

@@ -0,0 +1,153 @@
+/**
+ * Input validation and normalization
+ */
+export const LIMITS = {
+    TITLE_MAX: 200,
+    TAGS_MAX: 10,
+    TAG_LENGTH_MAX: 50,
+    CONTENT_MAX: 10000,
+    SOURCE_URL_MAX: 2000,
+};
+export function validateInsightInput(title, tags, content, sourceUrl) {
+    // Trim inputs for validation
+    const trimmedTitle = title.trim();
+    const trimmedContent = content.trim();
+    if (!trimmedTitle || trimmedTitle.length === 0) {
+        return 'Title is required';
+    }
+    if (trimmedTitle.length > LIMITS.TITLE_MAX) {
+        return `Title exceeds ${LIMITS.TITLE_MAX} characters`;
+    }
+    if (tags.length > LIMITS.TAGS_MAX) {
+        return `Maximum ${LIMITS.TAGS_MAX} tags allowed`;
+    }
+    // Validate tags after trimming
+    for (const tag of tags) {
+        const trimmedTag = tag.trim();
+        if (trimmedTag.length > LIMITS.TAG_LENGTH_MAX) {
+            return `Tag exceeds ${LIMITS.TAG_LENGTH_MAX} characters`;
+        }
+    }
+    // Normalize tags to check if we have at least one non-empty tag after normalization
+    const normalizedTags = normalizeTags(tags);
+    if (normalizedTags.length === 0) {
+        return 'At least one non-empty tag is required';
+    }
+    if (!trimmedContent || trimmedContent.length === 0) {
+        return 'Content is required';
+    }
+    if (trimmedContent.length > LIMITS.CONTENT_MAX) {
+        return `Content exceeds ${LIMITS.CONTENT_MAX} characters`;
+    }
+    // Validate sourceUrl if provided
+    if (sourceUrl !== undefined) {
+        const trimmedUrl = sourceUrl.trim();
+        if (trimmedUrl.length > LIMITS.SOURCE_URL_MAX) {
+            return `Source URL exceeds ${LIMITS.SOURCE_URL_MAX} characters`;
+        }
+    }
+    return null;
+}
+export function normalizeTags(tags) {
+    const normalized = tags
+        .map(tag => tag.trim().toLowerCase())
+        .filter(tag => tag.length > 0);
+    // Remove duplicates using Set
+    return Array.from(new Set(normalized));
+}
+export function generateId(nextNumber) {
+    const padded = nextNumber.toString().padStart(6, '0');
+    return `ace-${padded}`;
+}
+/**
+ * Calculate Levenshtein distance between two strings (case-insensitive)
+ * Used for detecting similar titles in auto-deduplication
+ */
+export function levenshteinDistance(str1, str2) {
+    const s1 = str1.toLowerCase();
+    const s2 = str2.toLowerCase();
+    const len1 = s1.length;
+    const len2 = s2.length;
+    // Create 2D array for dynamic programming
+    const matrix = Array(len1 + 1)
+        .fill(null)
+        .map(() => Array(len2 + 1).fill(0));
+    // Initialize first row and column
+    for (let i = 0; i <= len1; i++) {
+        matrix[i][0] = i;
+    }
+    for (let j = 0; j <= len2; j++) {
+        matrix[0][j] = j;
+    }
+    // Fill the matrix
+    for (let i = 1; i <= len1; i++) {
+        for (let j = 1; j <= len2; j++) {
+            const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
+            matrix[i][j - 1] + 1, // insertion
+            matrix[i - 1][j - 1] + cost // substitution
+            );
+        }
+    }
+    return matrix[len1][len2];
+}
+/**
+ * Validate parameters for list_index tool
+ */
+export function validateListIndexParams(params) {
+    if (params.tags !== undefined) {
+        if (!Array.isArray(params.tags)) {
+            return 'Tags must be an array';
+        }
+        if (params.tags.length > LIMITS.TAGS_MAX) {
+            return `Maximum ${LIMITS.TAGS_MAX} filter tags allowed`;
+        }
+    }
+    if (params.minHelpful !== undefined) {
+        if (typeof params.minHelpful !== 'number') {
+            return 'MinHelpful must be a number';
+        }
+        if (!Number.isFinite(params.minHelpful)) {
+            return 'MinHelpful must be a finite number';
+        }
+        if (!Number.isInteger(params.minHelpful)) {
+            return 'MinHelpful must be an integer';
+        }
+        if (params.minHelpful < 0) {
+            return 'MinHelpful must be >= 0';
+        }
+    }
+    if (params.sortBy !== undefined) {
+        if (!['created', 'lastUsed', 'helpful'].includes(params.sortBy)) {
+            return 'SortBy must be one of: created, lastUsed, helpful';
+        }
+    }
+    if (params.limit !== undefined) {
+        if (typeof params.limit !== 'number') {
+            return 'Limit must be a number';
+        }
+        if (!Number.isFinite(params.limit)) {
+            return 'Limit must be a finite number';
+        }
+        if (!Number.isInteger(params.limit)) {
+            return 'Limit must be an integer';
+        }
+        if (params.limit < 1) {
+            return 'Limit must be >= 1';
+        }
+    }
+    return null;
+}
+/**
+ * Validate search query for search_insights tool
+ */
+export function validateSearchQuery(query) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) {
+        return 'Query cannot be empty';
+    }
+    if (trimmed.length > LIMITS.TITLE_MAX) {
+        return `Query exceeds ${LIMITS.TITLE_MAX} characters`;
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "mcp-learning-memory",
+  "version": "0.2.0",
+  "description": "MCP server for AI agent memory that learns from feedback",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "agent",
+    "learning",
+    "claude",
+    "anthropic",
+    "model-context-protocol",
+    "persistent-memory",
+    "feedback",
+    "llm",
+    "context"
+  ],
+  "author": "nulone",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nulone/mcp-learning-memory"
+  },
+  "homepage": "https://github.com/nulone/mcp-learning-memory#readme",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}