@asd412id/mcp-context-manager 1.0.0

package/dist/tools/loader.js

@@ -0,0 +1,263 @@
+import * as z from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+function readFileLines(filePath, startLine, endLine) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const start = Math.max(0, startLine - 1);
+        const end = Math.min(lines.length, endLine);
+        return {
+            startLine: start + 1,
+            endLine: end,
+            content: lines.slice(start, end).join('\n')
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function getFileInfo(filePath) {
+    const info = {
+        path: filePath,
+        exists: fs.existsSync(filePath)
+    };
+    if (info.exists) {
+        try {
+            const stats = fs.statSync(filePath);
+            info.size = stats.size;
+            info.modifiedAt = stats.mtime.toISOString();
+            info.extension = path.extname(filePath);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            info.lines = content.split('\n').length;
+        }
+        catch {
+            // ignore errors
+        }
+    }
+    return info;
+}
+function findRelevantSections(content, keywords) {
+    const lines = content.split('\n');
+    const results = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].toLowerCase();
+        for (const keyword of keywords) {
+            if (line.includes(keyword.toLowerCase())) {
+                results.push({ line: i + 1, text: lines[i] });
+                break;
+            }
+        }
+    }
+    return results;
+}
+function extractCodeStructure(content, extension) {
+    const structures = [];
+    const lines = content.split('\n');
+    const patterns = {
+        '.ts': [
+            /^export\s+(async\s+)?function\s+(\w+)/,
+            /^export\s+(const|let|var)\s+(\w+)/,
+            /^export\s+(class|interface|type|enum)\s+(\w+)/,
+            /^(class|interface|type|enum)\s+(\w+)/,
+            /^(async\s+)?function\s+(\w+)/
+        ],
+        '.js': [
+            /^export\s+(async\s+)?function\s+(\w+)/,
+            /^export\s+(const|let|var)\s+(\w+)/,
+            /^export\s+class\s+(\w+)/,
+            /^class\s+(\w+)/,
+            /^(async\s+)?function\s+(\w+)/,
+            /^(const|let|var)\s+(\w+)\s*=/
+        ],
+        '.py': [
+            /^def\s+(\w+)/,
+            /^class\s+(\w+)/,
+            /^async\s+def\s+(\w+)/
+        ]
+    };
+    const applicablePatterns = patterns[extension] || patterns['.js'];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        for (const pattern of applicablePatterns) {
+            const match = line.match(pattern);
+            if (match) {
+                structures.push(`L${i + 1}: ${line.substring(0, 80)}${line.length > 80 ? '...' : ''}`);
+                break;
+            }
+        }
+    }
+    return structures;
+}
+export function registerLoaderTools(server) {
+    server.registerTool('file_smart_read', {
+        title: 'Smart File Read',
+        description: 'Read a file with smart options: specific lines, keyword search, or structure extraction. Optimized for context efficiency.',
+        inputSchema: {
+            path: z.string().describe('File path to read'),
+            startLine: z.number().optional().describe('Start line (1-indexed)'),
+            endLine: z.number().optional().describe('End line'),
+            keywords: z.array(z.string()).optional().describe('Only return lines containing these keywords'),
+            structureOnly: z.boolean().optional().describe('Return only code structure (functions, classes, etc.)'),
+            maxLines: z.number().optional().describe('Maximum lines to return (default: 500)')
+        }
+    }, async ({ path: filePath, startLine, endLine, keywords, structureOnly, maxLines = 500 }) => {
+        const info = getFileInfo(filePath);
+        if (!info.exists) {
+            return {
+                content: [{ type: 'text', text: `File not found: ${filePath}` }]
+            };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (structureOnly && info.extension) {
+            const structure = extractCodeStructure(content, info.extension);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            file: filePath,
+                            totalLines: info.lines,
+                            structure: structure
+                        }, null, 2)
+                    }]
+            };
+        }
+        if (keywords && keywords.length > 0) {
+            const sections = findRelevantSections(content, keywords);
+            const limited = sections.slice(0, maxLines);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            file: filePath,
+                            totalLines: info.lines,
+                            matchedLines: sections.length,
+                            matches: limited
+                        }, null, 2)
+                    }]
+            };
+        }
+        if (startLine || endLine) {
+            const start = startLine || 1;
+            const end = endLine || (info.lines || 1000);
+            const section = readFileLines(filePath, start, Math.min(end, start + maxLines - 1));
+            if (section) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `File: ${filePath} (lines ${section.startLine}-${section.endLine} of ${info.lines})\n\n${section.content}`
+                        }]
+                };
+            }
+        }
+        const lines = content.split('\n');
+        const limitedContent = lines.slice(0, maxLines).join('\n');
+        const truncated = lines.length > maxLines;
+        return {
+            content: [{
+                    type: 'text',
+                    text: `File: ${filePath} (${info.lines} lines${truncated ? `, showing first ${maxLines}` : ''})\n\n${limitedContent}${truncated ? '\n\n... [truncated]' : ''}`
+                }]
+        };
+    });
+    server.registerTool('file_info', {
+        title: 'File Info',
+        description: 'Get file metadata without reading content. Use to check file existence, size, and modification time.',
+        inputSchema: {
+            paths: z.array(z.string()).describe('File paths to check')
+        }
+    }, async ({ paths }) => {
+        const infos = paths.map(p => getFileInfo(p));
+        return {
+            content: [{ type: 'text', text: JSON.stringify(infos, null, 2) }]
+        };
+    });
+    server.registerTool('file_search_content', {
+        title: 'Search File Content',
+        description: 'Search for patterns in a file and return matching lines with context.',
+        inputSchema: {
+            path: z.string().describe('File path to search'),
+            pattern: z.string().describe('Search pattern (supports regex)'),
+            contextLines: z.number().optional().describe('Number of context lines before/after match (default: 2)')
+        }
+    }, async ({ path: filePath, pattern, contextLines = 2 }) => {
+        if (!fs.existsSync(filePath)) {
+            return {
+                content: [{ type: 'text', text: `File not found: ${filePath}` }]
+            };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const regex = new RegExp(pattern, 'gi');
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+                const start = Math.max(0, i - contextLines);
+                const end = Math.min(lines.length, i + contextLines + 1);
+                const context = lines.slice(start, end).map((l, idx) => `${start + idx + 1}${start + idx === i ? '>' : ':'} ${l}`);
+                matches.push({
+                    line: i + 1,
+                    match: lines[i],
+                    context
+                });
+                regex.lastIndex = 0;
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: matches.length > 0
+                        ? JSON.stringify({ file: filePath, matches }, null, 2)
+                        : `No matches found for pattern "${pattern}" in ${filePath}`
+                }]
+        };
+    });
+    server.registerTool('file_list_dir', {
+        title: 'List Directory',
+        description: 'List files in a directory with optional filtering.',
+        inputSchema: {
+            path: z.string().describe('Directory path'),
+            pattern: z.string().optional().describe('File name pattern (e.g., "*.ts")'),
+            recursive: z.boolean().optional().describe('Include subdirectories (default: false)')
+        }
+    }, async ({ path: dirPath, pattern, recursive = false }) => {
+        if (!fs.existsSync(dirPath)) {
+            return {
+                content: [{ type: 'text', text: `Directory not found: ${dirPath}` }]
+            };
+        }
+        const results = [];
+        function walkDir(dir) {
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory() && recursive) {
+                    walkDir(fullPath);
+                }
+                else if (stat.isFile()) {
+                    if (pattern) {
+                        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                        if (regex.test(item)) {
+                            results.push(fullPath);
+                        }
+                    }
+                    else {
+                        results.push(fullPath);
+                    }
+                }
+            }
+        }
+        walkDir(dirPath);
+        return {
+            content: [{
+                    type: 'text',
+                    text: results.length > 0
+                        ? results.join('\n')
+                        : 'No files found'
+                }]
+        };
+    });
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerMemoryTools(server: McpServer): void;

package/dist/tools/memory.js

@@ -0,0 +1,182 @@
+import * as z from 'zod';
+import { getStore } from '../storage/file-store.js';
+const MEMORY_FILE = 'memory.json';
+async function getMemoryStore() {
+    const store = getStore();
+    return store.read(MEMORY_FILE, { entries: {} });
+}
+async function saveMemoryStore(data) {
+    const store = getStore();
+    await store.write(MEMORY_FILE, data);
+}
+function isExpired(entry) {
+    if (!entry.ttl)
+        return false;
+    const expiresAt = new Date(entry.createdAt).getTime() + entry.ttl;
+    return Date.now() > expiresAt;
+}
+export function registerMemoryTools(server) {
+    server.registerTool('memory_set', {
+        title: 'Memory Set',
+        description: 'Store a key-value pair in persistent memory. Use for saving important context, decisions, or data across sessions.',
+        inputSchema: {
+            key: z.string().describe('Unique identifier for this memory'),
+            value: z.unknown().describe('Data to store (any JSON-serializable value)'),
+            tags: z.array(z.string()).optional().describe('Tags for categorization and searching'),
+            ttl: z.number().optional().describe('Time-to-live in milliseconds (optional)')
+        }
+    }, async ({ key, value, tags, ttl }) => {
+        const memStore = await getMemoryStore();
+        const now = new Date().toISOString();
+        const existing = memStore.entries[key];
+        memStore.entries[key] = {
+            key,
+            value,
+            tags: tags || [],
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+            ttl
+        };
+        await saveMemoryStore(memStore);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Memory saved: "${key}"${ttl ? ` (expires in ${ttl}ms)` : ''}`
+                }]
+        };
+    });
+    server.registerTool('memory_get', {
+        title: 'Memory Get',
+        description: 'Retrieve a value from persistent memory by key.',
+        inputSchema: {
+            key: z.string().describe('Key to retrieve')
+        }
+    }, async ({ key }) => {
+        const memStore = await getMemoryStore();
+        const entry = memStore.entries[key];
+        if (!entry) {
+            return {
+                content: [{ type: 'text', text: `Memory not found: "${key}"` }]
+            };
+        }
+        if (isExpired(entry)) {
+            delete memStore.entries[key];
+            await saveMemoryStore(memStore);
+            return {
+                content: [{ type: 'text', text: `Memory expired: "${key}"` }]
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        key: entry.key,
+                        value: entry.value,
+                        tags: entry.tags,
+                        createdAt: entry.createdAt,
+                        updatedAt: entry.updatedAt
+                    }, null, 2)
+                }]
+        };
+    });
+    server.registerTool('memory_search', {
+        title: 'Memory Search',
+        description: 'Search memories by key pattern or tags.',
+        inputSchema: {
+            pattern: z.string().optional().describe('Key pattern to search (supports * wildcard)'),
+            tags: z.array(z.string()).optional().describe('Filter by tags (any match)')
+        }
+    }, async ({ pattern, tags }) => {
+        const memStore = await getMemoryStore();
+        let results = Object.values(memStore.entries);
+        results = results.filter(entry => !isExpired(entry));
+        if (pattern) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$', 'i');
+            results = results.filter(entry => regex.test(entry.key));
+        }
+        if (tags && tags.length > 0) {
+            results = results.filter(entry => tags.some(tag => entry.tags.includes(tag)));
+        }
+        const output = results.map(entry => ({
+            key: entry.key,
+            value: entry.value,
+            tags: entry.tags,
+            updatedAt: entry.updatedAt
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: results.length > 0
+                        ? JSON.stringify(output, null, 2)
+                        : 'No memories found matching criteria'
+                }]
+        };
+    });
+    server.registerTool('memory_delete', {
+        title: 'Memory Delete',
+        description: 'Delete a memory entry by key.',
+        inputSchema: {
+            key: z.string().describe('Key to delete')
+        }
+    }, async ({ key }) => {
+        const memStore = await getMemoryStore();
+        if (!memStore.entries[key]) {
+            return {
+                content: [{ type: 'text', text: `Memory not found: "${key}"` }]
+            };
+        }
+        delete memStore.entries[key];
+        await saveMemoryStore(memStore);
+        return {
+            content: [{ type: 'text', text: `Memory deleted: "${key}"` }]
+        };
+    });
+    server.registerTool('memory_list', {
+        title: 'Memory List',
+        description: 'List all memory keys with their tags.',
+        inputSchema: {}
+    }, async () => {
+        const memStore = await getMemoryStore();
+        const entries = Object.values(memStore.entries).filter(e => !isExpired(e));
+        if (entries.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No memories stored' }]
+            };
+        }
+        const list = entries.map(e => ({
+            key: e.key,
+            tags: e.tags,
+            updatedAt: e.updatedAt
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify(list, null, 2) }]
+        };
+    });
+    server.registerTool('memory_clear', {
+        title: 'Memory Clear',
+        description: 'Clear all memories or memories matching specific tags.',
+        inputSchema: {
+            tags: z.array(z.string()).optional().describe('Only clear memories with these tags (clears all if not specified)')
+        }
+    }, async ({ tags }) => {
+        const memStore = await getMemoryStore();
+        let count = 0;
+        if (tags && tags.length > 0) {
+            for (const key of Object.keys(memStore.entries)) {
+                const entry = memStore.entries[key];
+                if (tags.some(tag => entry.tags.includes(tag))) {
+                    delete memStore.entries[key];
+                    count++;
+                }
+            }
+        }
+        else {
+            count = Object.keys(memStore.entries).length;
+            memStore.entries = {};
+        }
+        await saveMemoryStore(memStore);
+        return {
+            content: [{ type: 'text', text: `Cleared ${count} memories` }]
+        };
+    });
+}

package/dist/tools/summarizer.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSummarizerTools(server: McpServer): void;

package/dist/tools/summarizer.js

@@ -0,0 +1,228 @@
+import * as z from 'zod';
+import { getStore } from '../storage/file-store.js';
+const SUMMARIES_DIR = 'summaries';
+async function getSummaryStore() {
+    const store = getStore().getSubStore(SUMMARIES_DIR);
+    return store.read('index.json', { summaries: [] });
+}
+async function saveSummaryStore(data) {
+    const store = getStore().getSubStore(SUMMARIES_DIR);
+    await store.write('index.json', data);
+}
+function extractKeyPoints(text) {
+    const points = [];
+    const lines = text.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.match(/^[-*•]\s+/) || trimmed.match(/^\d+\.\s+/)) {
+            points.push(trimmed.replace(/^[-*•\d.]+\s*/, ''));
+        }
+        if (trimmed.toLowerCase().includes('important:') ||
+            trimmed.toLowerCase().includes('note:') ||
+            trimmed.toLowerCase().includes('key:')) {
+            points.push(trimmed);
+        }
+    }
+    return points.slice(0, 10);
+}
+function extractDecisions(text) {
+    const decisions = [];
+    const patterns = [
+        /decided to ([^.]+)/gi,
+        /will use ([^.]+)/gi,
+        /chose ([^.]+)/gi,
+        /agreed on ([^.]+)/gi,
+        /decision:\s*([^.\n]+)/gi
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            decisions.push(match[1].trim());
+        }
+    }
+    return [...new Set(decisions)].slice(0, 5);
+}
+function extractActionItems(text) {
+    const actions = [];
+    const patterns = [
+        /todo:\s*([^.\n]+)/gi,
+        /action:\s*([^.\n]+)/gi,
+        /need to ([^.]+)/gi,
+        /should ([^.]+)/gi,
+        /must ([^.]+)/gi,
+        /\[ \]\s*([^\n]+)/g
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            actions.push(match[1].trim());
+        }
+    }
+    return [...new Set(actions)].slice(0, 10);
+}
+function compressText(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+    const important = [];
+    const normal = [];
+    for (const sentence of sentences) {
+        const lower = sentence.toLowerCase();
+        if (lower.includes('important') ||
+            lower.includes('key') ||
+            lower.includes('must') ||
+            lower.includes('error') ||
+            lower.includes('decision')) {
+            important.push(sentence.trim());
+        }
+        else {
+            normal.push(sentence.trim());
+        }
+    }
+    let result = important.join(' ');
+    for (const sentence of normal) {
+        if ((result + ' ' + sentence).length <= maxLength) {
+            result += ' ' + sentence;
+        }
+    }
+    return result.trim() || text.slice(0, maxLength) + '...';
+}
+export function registerSummarizerTools(server) {
+    server.registerTool('context_summarize', {
+        title: 'Context Summarize',
+        description: 'Summarize and compress context/conversation. Extracts key points, decisions, and action items. Use this when context is getting too long.',
+        inputSchema: {
+            text: z.string().describe('Text to summarize'),
+            maxLength: z.number().optional().describe('Maximum length for compressed summary (default: 2000)'),
+            sessionId: z.string().optional().describe('Session identifier for grouping summaries')
+        }
+    }, async ({ text, maxLength = 2000, sessionId }) => {
+        const keyPoints = extractKeyPoints(text);
+        const decisions = extractDecisions(text);
+        const actionItems = extractActionItems(text);
+        const compressed = compressText(text, maxLength);
+        const summary = {
+            id: `sum_${Date.now()}`,
+            originalLength: text.length,
+            summaryLength: compressed.length,
+            keyPoints,
+            decisions,
+            actionItems,
+            context: compressed,
+            createdAt: new Date().toISOString(),
+            sessionId
+        };
+        const store = await getSummaryStore();
+        store.summaries.push(summary);
+        await saveSummaryStore(store);
+        const output = {
+            id: summary.id,
+            compression: `${summary.originalLength} -> ${summary.summaryLength} chars (${Math.round((1 - summary.summaryLength / summary.originalLength) * 100)}% reduced)`,
+            keyPoints,
+            decisions,
+            actionItems,
+            summary: compressed
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
+        };
+    });
+    server.registerTool('context_get_summary', {
+        title: 'Get Summary',
+        description: 'Retrieve a previously saved summary by ID.',
+        inputSchema: {
+            id: z.string().describe('Summary ID to retrieve')
+        }
+    }, async ({ id }) => {
+        const store = await getSummaryStore();
+        const summary = store.summaries.find(s => s.id === id);
+        if (!summary) {
+            return {
+                content: [{ type: 'text', text: `Summary not found: ${id}` }]
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }]
+        };
+    });
+    server.registerTool('context_list_summaries', {
+        title: 'List Summaries',
+        description: 'List all saved summaries with metadata.',
+        inputSchema: {
+            sessionId: z.string().optional().describe('Filter by session ID'),
+            limit: z.number().optional().describe('Maximum number of summaries to return (default: 10)')
+        }
+    }, async ({ sessionId, limit = 10 }) => {
+        const store = await getSummaryStore();
+        let summaries = store.summaries;
+        if (sessionId) {
+            summaries = summaries.filter(s => s.sessionId === sessionId);
+        }
+        summaries = summaries.slice(-limit);
+        const list = summaries.map(s => ({
+            id: s.id,
+            createdAt: s.createdAt,
+            originalLength: s.originalLength,
+            summaryLength: s.summaryLength,
+            keyPointsCount: s.keyPoints.length,
+            decisionsCount: s.decisions.length,
+            actionItemsCount: s.actionItems.length,
+            sessionId: s.sessionId
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: list.length > 0
+                        ? JSON.stringify(list, null, 2)
+                        : 'No summaries found'
+                }]
+        };
+    });
+    server.registerTool('context_merge_summaries', {
+        title: 'Merge Summaries',
+        description: 'Merge multiple summaries into a single consolidated summary. Useful for combining session history.',
+        inputSchema: {
+            ids: z.array(z.string()).describe('Summary IDs to merge'),
+            maxLength: z.number().optional().describe('Max length for merged summary (default: 4000)')
+        }
+    }, async ({ ids, maxLength = 4000 }) => {
+        const store = await getSummaryStore();
+        const summaries = store.summaries.filter(s => ids.includes(s.id));
+        if (summaries.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No summaries found with provided IDs' }]
+            };
+        }
+        const allKeyPoints = [...new Set(summaries.flatMap(s => s.keyPoints))];
+        const allDecisions = [...new Set(summaries.flatMap(s => s.decisions))];
+        const allActionItems = [...new Set(summaries.flatMap(s => s.actionItems))];
+        const combinedContext = summaries.map(s => s.context).join('\n\n---\n\n');
+        const compressedContext = compressText(combinedContext, maxLength);
+        const merged = {
+            id: `merged_${Date.now()}`,
+            originalLength: summaries.reduce((acc, s) => acc + s.originalLength, 0),
+            summaryLength: compressedContext.length,
+            keyPoints: allKeyPoints.slice(0, 15),
+            decisions: allDecisions.slice(0, 10),
+            actionItems: allActionItems.slice(0, 15),
+            context: compressedContext,
+            createdAt: new Date().toISOString()
+        };
+        store.summaries.push(merged);
+        await saveSummaryStore(store);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        id: merged.id,
+                        mergedCount: summaries.length,
+                        compression: `${merged.originalLength} -> ${merged.summaryLength} chars`,
+                        keyPoints: merged.keyPoints,
+                        decisions: merged.decisions,
+                        actionItems: merged.actionItems,
+                        summary: merged.context
+                    }, null, 2)
+                }]
+        };
+    });
+}

package/dist/tools/tracker.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTrackerTools(server: McpServer): void;