@asd412id/mcp-context-manager 1.0.0

package/dist/tools/tracker.js

@@ -0,0 +1,196 @@
+import * as z from 'zod';
+import { getStore } from '../storage/file-store.js';
+const TRACKER_FILE = 'tracker.json';
+async function getTrackerStore() {
+    const store = getStore();
+    return store.read(TRACKER_FILE, { entries: [] });
+}
+async function saveTrackerStore(data) {
+    const store = getStore();
+    await store.write(TRACKER_FILE, data);
+}
+export function registerTrackerTools(server) {
+    server.registerTool('tracker_log', {
+        title: 'Tracker Log',
+        description: 'Log a decision, change, todo, note, or error to the project tracker.',
+        inputSchema: {
+            type: z.enum(['decision', 'change', 'todo', 'note', 'error']).describe('Type of entry'),
+            content: z.string().describe('Description of the entry'),
+            tags: z.array(z.string()).optional().describe('Tags for categorization'),
+            metadata: z.record(z.unknown()).optional().describe('Additional metadata')
+        }
+    }, async ({ type, content, tags, metadata }) => {
+        const trackerStore = await getTrackerStore();
+        const now = new Date().toISOString();
+        const entry = {
+            id: `${type}_${Date.now()}`,
+            type,
+            content,
+            metadata,
+            tags: tags || [],
+            status: type === 'todo' ? 'pending' : undefined,
+            createdAt: now,
+            updatedAt: now
+        };
+        trackerStore.entries.push(entry);
+        await saveTrackerStore(trackerStore);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Logged ${type}: "${content}" (ID: ${entry.id})`
+                }]
+        };
+    });
+    server.registerTool('tracker_status', {
+        title: 'Tracker Status',
+        description: 'Get current project status including recent decisions, pending todos, and recent changes.',
+        inputSchema: {
+            limit: z.number().optional().describe('Maximum entries per type (default: 5)')
+        }
+    }, async ({ limit = 5 }) => {
+        const trackerStore = await getTrackerStore();
+        const entries = trackerStore.entries;
+        const decisions = entries
+            .filter(e => e.type === 'decision')
+            .slice(-limit);
+        const pendingTodos = entries
+            .filter(e => e.type === 'todo' && e.status === 'pending')
+            .slice(-limit);
+        const recentChanges = entries
+            .filter(e => e.type === 'change')
+            .slice(-limit);
+        const recentErrors = entries
+            .filter(e => e.type === 'error')
+            .slice(-limit);
+        const status = {
+            projectName: trackerStore.projectName,
+            totalEntries: entries.length,
+            decisions: decisions.map(d => ({ id: d.id, content: d.content, date: d.createdAt })),
+            pendingTodos: pendingTodos.map(t => ({ id: t.id, content: t.content, tags: t.tags })),
+            recentChanges: recentChanges.map(c => ({ id: c.id, content: c.content, date: c.createdAt })),
+            recentErrors: recentErrors.map(e => ({ id: e.id, content: e.content, date: e.createdAt }))
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(status, null, 2) }]
+        };
+    });
+    server.registerTool('tracker_todo_update', {
+        title: 'Update Todo',
+        description: 'Update the status of a todo item.',
+        inputSchema: {
+            id: z.string().describe('Todo ID to update'),
+            status: z.enum(['pending', 'done', 'cancelled']).describe('New status')
+        }
+    }, async ({ id, status }) => {
+        const trackerStore = await getTrackerStore();
+        const entry = trackerStore.entries.find(e => e.id === id);
+        if (!entry) {
+            return {
+                content: [{ type: 'text', text: `Entry not found: ${id}` }]
+            };
+        }
+        if (entry.type !== 'todo') {
+            return {
+                content: [{ type: 'text', text: `Entry ${id} is not a todo` }]
+            };
+        }
+        entry.status = status;
+        entry.updatedAt = new Date().toISOString();
+        await saveTrackerStore(trackerStore);
+        return {
+            content: [{ type: 'text', text: `Todo "${entry.content}" marked as ${status}` }]
+        };
+    });
+    server.registerTool('tracker_search', {
+        title: 'Tracker Search',
+        description: 'Search tracker entries by type, tags, or content.',
+        inputSchema: {
+            type: z.enum(['decision', 'change', 'todo', 'note', 'error']).optional().describe('Filter by type'),
+            tags: z.array(z.string()).optional().describe('Filter by tags'),
+            query: z.string().optional().describe('Search in content'),
+            limit: z.number().optional().describe('Maximum results (default: 20)')
+        }
+    }, async ({ type, tags, query, limit = 20 }) => {
+        const trackerStore = await getTrackerStore();
+        let results = trackerStore.entries;
+        if (type) {
+            results = results.filter(e => e.type === type);
+        }
+        if (tags && tags.length > 0) {
+            results = results.filter(e => tags.some(tag => e.tags.includes(tag)));
+        }
+        if (query) {
+            const lowerQuery = query.toLowerCase();
+            results = results.filter(e => e.content.toLowerCase().includes(lowerQuery));
+        }
+        results = results.slice(-limit);
+        return {
+            content: [{
+                    type: 'text',
+                    text: results.length > 0
+                        ? JSON.stringify(results, null, 2)
+                        : 'No entries found'
+                }]
+        };
+    });
+    server.registerTool('tracker_set_project', {
+        title: 'Set Project Name',
+        description: 'Set the current project name for context.',
+        inputSchema: {
+            name: z.string().describe('Project name')
+        }
+    }, async ({ name }) => {
+        const trackerStore = await getTrackerStore();
+        trackerStore.projectName = name;
+        await saveTrackerStore(trackerStore);
+        return {
+            content: [{ type: 'text', text: `Project name set to: ${name}` }]
+        };
+    });
+    server.registerTool('tracker_export', {
+        title: 'Export Tracker',
+        description: 'Export all tracker entries as markdown format for documentation.',
+        inputSchema: {}
+    }, async () => {
+        const trackerStore = await getTrackerStore();
+        const entries = trackerStore.entries;
+        let md = `# Project Tracker${trackerStore.projectName ? `: ${trackerStore.projectName}` : ''}\n\n`;
+        md += `Generated: ${new Date().toISOString()}\n\n`;
+        const decisions = entries.filter(e => e.type === 'decision');
+        if (decisions.length > 0) {
+            md += `## Decisions\n\n`;
+            for (const d of decisions) {
+                md += `- **${d.createdAt.split('T')[0]}**: ${d.content}\n`;
+            }
+            md += '\n';
+        }
+        const todos = entries.filter(e => e.type === 'todo');
+        if (todos.length > 0) {
+            md += `## Todos\n\n`;
+            for (const t of todos) {
+                const checkbox = t.status === 'done' ? '[x]' : '[ ]';
+                md += `- ${checkbox} ${t.content}${t.status === 'cancelled' ? ' _(cancelled)_' : ''}\n`;
+            }
+            md += '\n';
+        }
+        const changes = entries.filter(e => e.type === 'change');
+        if (changes.length > 0) {
+            md += `## Changes\n\n`;
+            for (const c of changes) {
+                md += `- **${c.createdAt.split('T')[0]}**: ${c.content}\n`;
+            }
+            md += '\n';
+        }
+        const errors = entries.filter(e => e.type === 'error');
+        if (errors.length > 0) {
+            md += `## Errors/Issues\n\n`;
+            for (const e of errors) {
+                md += `- **${e.createdAt.split('T')[0]}**: ${e.content}\n`;
+            }
+            md += '\n';
+        }
+        return {
+            content: [{ type: 'text', text: md }]
+        };
+    });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@asd412id/mcp-context-manager",
+  "version": "1.0.0",
+  "description": "MCP tools for context management - summarizer, memory store, project tracker, checkpoints, and smart file loader",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-context-manager": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "context",
+    "ai",
+    "memory",
+    "llm",
+    "model-context-protocol",
+    "claude",
+    "anthropic"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}