contextforge-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1483 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ApiClient, ApiClientError } from './api-client.js';
+import { ConfigSchema, IngestInputSchema, QueryInputSchema, CreateSpaceInputSchema, RelateInputSchema, DeleteInputSchema, GitConnectInputSchema, GitActivateInputSchema, GitDisconnectInputSchema, GitSyncInputSchema, GitHistoryInputSchema, SnapshotCreateInputSchema, SnapshotRestoreInputSchema, SnapshotDeleteInputSchema, ExportInputSchema, ImportInputSchema, IngestBatchInputSchema, DeleteBatchInputSchema, } from './types.js';
+import { appendFileSync } from 'fs';
+// ============ Logger with Colors ============
+const LOG_FILE = process.env.CONTEXTFORGE_LOG_FILE || '/tmp/contextforge-mcp.log';
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    bgBlue: '\x1b[44m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgRed: '\x1b[41m',
+};
+function log(icon, message, color = colors.white) {
+    const timestamp = new Date().toLocaleTimeString();
+    const logLine = `${colors.dim}[${timestamp}]${colors.reset} ${icon} ${color}${message}${colors.reset}`;
+    console.error(logLine);
+    // Also write to log file (without colors)
+    const plainLine = `[${timestamp}] ${icon} ${message}\n`;
+    try {
+        appendFileSync(LOG_FILE, plainLine);
+    }
+    catch {
+        // Ignore file write errors
+    }
+}
+function logTool(toolName, details) {
+    const icons = {
+        memory_ingest: '📥',
+        memory_query: '🔍',
+        memory_list_spaces: '📂',
+        memory_list_items: '📋',
+        memory_create_space: '✨',
+        memory_relate: '🔗',
+        memory_delete: '🗑️',
+        memory_stats: '📊',
+        memory_help: '❓',
+        memory_git_connect: '🔌',
+        memory_git_list: '📡',
+        memory_git_activate: '✅',
+        memory_git_disconnect: '🔌',
+        memory_git_sync: '🔄',
+        memory_git_commits: '📝',
+        memory_git_prs: '🔀',
+        memory_snapshot_create: '📸',
+        memory_snapshot_list: '🗂️',
+        memory_snapshot_restore: '⏪',
+        memory_snapshot_delete: '🗑️',
+        memory_export: '📤',
+        memory_import: '📥',
+        memory_ingest_batch: '📦',
+        memory_delete_batch: '🗑️',
+    };
+    const icon = icons[toolName] || '🔧';
+    log(icon, `${colors.bright}${toolName}${colors.reset}${details ? ` ${colors.dim}${details}${colors.reset}` : ''}`, colors.cyan);
+}
+function logSuccess(message) {
+    log('✅', message, colors.green);
+}
+function logError(message) {
+    log('❌', message, colors.red);
+}
+function logInfo(message) {
+    log('ℹ️', message, colors.blue);
+}
+// ============ Configuration ============
+function loadConfig() {
+    const apiKey = process.env.CONTEXTFORGE_API_KEY;
+    const apiUrl = process.env.CONTEXTFORGE_API_URL ?? 'https://api.contextforge.io';
+    const defaultSpace = process.env.CONTEXTFORGE_DEFAULT_SPACE;
+    const result = ConfigSchema.safeParse({
+        apiKey,
+        apiUrl,
+        defaultSpace,
+    });
+    if (!result.success) {
+        console.error('Configuration error:', result.error.format());
+        console.error('\nRequired environment variables:');
+        console.error('  CONTEXTFORGE_API_KEY - Your ContextForge API key');
+        console.error('\nOptional environment variables:');
+        console.error('  CONTEXTFORGE_API_URL - API URL (default: https://api.contextforge.io)');
+        console.error('  CONTEXTFORGE_DEFAULT_SPACE - Default space UUID');
+        process.exit(1);
+    }
+    return result.data;
+}
+// ============ Tool Definitions ============
+const TOOLS = [
+    {
+        name: 'memory_ingest',
+        description: 'Add content to the contextual memory. Use this to store code snippets, documentation, decisions, or any knowledge you want to remember.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'The content to store in memory',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Optional title for the content',
+                },
+                source_type: {
+                    type: 'string',
+                    enum: ['manual', 'url', 'file_upload', 'api_ingestion'],
+                    description: 'Type of source (default: manual)',
+                },
+                source_uri: {
+                    type: 'string',
+                    description: 'Optional source URI (file path, URL, etc.)',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional tags for categorization',
+                },
+                category: {
+                    type: 'string',
+                    description: 'Optional category',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (uses default if not specified)',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'memory_query',
+        description: 'Search the contextual memory using semantic search. Returns the most relevant stored content based on your query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (uses default if not specified)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of results (1-50, default: 10)',
+                },
+                min_score: {
+                    type: 'number',
+                    description: 'Minimum similarity score (0-1, default: 0.5)',
+                },
+                filters: {
+                    type: 'object',
+                    properties: {
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by tags',
+                        },
+                        source_types: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by source types',
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Filter by category',
+                        },
+                    },
+                    description: 'Optional filters',
+                },
+                include_relationships: {
+                    type: 'boolean',
+                    description: 'Include related items (default: false)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'memory_list_spaces',
+        description: 'List all available memory spaces (workspaces)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'memory_create_space',
+        description: 'Create a new memory space (workspace) for organizing knowledge',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Name of the space',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional description',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'memory_relate',
+        description: 'Create a relationship between two knowledge items',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source_id: {
+                    type: 'string',
+                    description: 'Source item UUID',
+                },
+                target_id: {
+                    type: 'string',
+                    description: 'Target item UUID',
+                },
+                relationship_type: {
+                    type: 'string',
+                    enum: [
+                        'references', 'implements', 'extends', 'depends_on',
+                        'related_to', 'contradicts', 'supersedes', 'part_of',
+                        'similar_to', 'derived_from',
+                    ],
+                    description: 'Type of relationship',
+                },
+                weight: {
+                    type: 'number',
+                    description: 'Relationship weight (0-1, default: 0.5)',
+                },
+                bidirectional: {
+                    type: 'boolean',
+                    description: 'Create relationship in both directions (default: false)',
+                },
+            },
+            required: ['source_id', 'target_id', 'relationship_type'],
+        },
+    },
+    {
+        name: 'memory_delete',
+        description: 'Delete a knowledge item from memory by ID or title',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Item UUID to delete (optional if title is provided)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Item title to search and delete (optional if id is provided)',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID to narrow down title search (optional)',
+                },
+                cascade: {
+                    type: 'boolean',
+                    description: 'Also delete related relationships (default: false)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_stats',
+        description: 'Get statistics about memory usage',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (optional, shows all if not specified)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_list_items',
+        description: 'List all items stored in memory. Shows titles, previews, tags, and creation dates.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (optional, lists all spaces if not specified)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of items to return (1-100, default: 50)',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Number of items to skip (for pagination, default: 0)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_help',
+        description: 'Show help and usage instructions for ContextForge memory commands',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    // ============ Git Integration Tools ============
+    {
+        name: 'memory_git_connect',
+        description: 'Connect a GitHub repository to automatically sync commits and PRs to memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo_url: {
+                    type: 'string',
+                    description: 'GitHub repository URL or owner/repo format (e.g., "owner/repo" or "https://github.com/owner/repo")',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID where git knowledge will be stored',
+                },
+            },
+            required: ['repo_url', 'space_id'],
+        },
+    },
+    {
+        name: 'memory_git_list',
+        description: 'List all connected GitHub repositories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Filter by space UUID (optional)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_git_activate',
+        description: 'Activate or deactivate a connected repository webhook after setup',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repository_id: {
+                    type: 'string',
+                    description: 'Repository UUID (optional if repo is provided)',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name in owner/repo format (optional if repository_id is provided)',
+                },
+                active: {
+                    type: 'boolean',
+                    description: 'Set to true to activate, false to deactivate (default: true)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_git_disconnect',
+        description: 'Disconnect a GitHub repository and stop syncing',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repository_id: {
+                    type: 'string',
+                    description: 'Repository UUID (optional if repo is provided)',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name in owner/repo format (optional if repository_id is provided)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_git_sync',
+        description: 'Sync existing commits and PRs from a connected GitHub repository into memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repository_id: {
+                    type: 'string',
+                    description: 'Repository UUID (optional if repo is provided)',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name in owner/repo format (optional if repository_id is provided)',
+                },
+                sync_type: {
+                    type: 'string',
+                    enum: ['commits', 'prs', 'all'],
+                    description: 'What to sync: commits, prs, or all (default: all)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of items to sync (1-100, default: 30)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_git_commits',
+        description: 'List commits stored in memory from connected repositories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repository_id: {
+                    type: 'string',
+                    description: 'Filter by repository UUID (optional)',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Filter by repository name in owner/repo format (optional)',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Filter by space UUID (optional)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of commits to return (1-100, default: 50)',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Number of items to skip for pagination (default: 0)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_git_prs',
+        description: 'List pull requests stored in memory from connected repositories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repository_id: {
+                    type: 'string',
+                    description: 'Filter by repository UUID (optional)',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Filter by repository name in owner/repo format (optional)',
+                },
+                space_id: {
+                    type: 'string',
+                    description: 'Filter by space UUID (optional)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of PRs to return (1-100, default: 50)',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Number of items to skip for pagination (default: 0)',
+                },
+            },
+            required: [],
+        },
+    },
+    // ============ Snapshot Tools ============
+    {
+        name: 'memory_snapshot_create',
+        description: 'Create a snapshot (backup) of the current memory state',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID to snapshot',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Name for the snapshot (e.g., "Before refactoring")',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional description of why this snapshot was created',
+                },
+            },
+            required: ['space_id', 'name'],
+        },
+    },
+    {
+        name: 'memory_snapshot_list',
+        description: 'List all available snapshots',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Filter by space UUID (optional)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'memory_snapshot_restore',
+        description: 'Restore memory to a previous snapshot state',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                snapshot_id: {
+                    type: 'string',
+                    description: 'Snapshot UUID to restore',
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['merge', 'replace'],
+                    description: 'merge: add missing items, replace: delete current and restore all (default: merge)',
+                },
+            },
+            required: ['snapshot_id'],
+        },
+    },
+    {
+        name: 'memory_snapshot_delete',
+        description: 'Delete a snapshot',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                snapshot_id: {
+                    type: 'string',
+                    description: 'Snapshot UUID to delete',
+                },
+            },
+            required: ['snapshot_id'],
+        },
+    },
+    // ============ Import/Export Tools ============
+    {
+        name: 'memory_export',
+        description: 'Export all items from a space to JSON, Markdown, or CSV format',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID to export',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['json', 'markdown', 'csv'],
+                    description: 'Export format (default: json)',
+                },
+            },
+            required: ['space_id'],
+        },
+    },
+    {
+        name: 'memory_import',
+        description: 'Import items from JSON, Markdown, Notion, or Obsidian format into a space',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID to import into',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['contextforge', 'markdown', 'notion', 'obsidian'],
+                    description: 'Import format (auto-detected if not specified)',
+                },
+                data: {
+                    type: 'object',
+                    description: 'The data to import (format-specific structure)',
+                },
+                items: {
+                    type: 'array',
+                    description: 'Direct array of items to import (alternative to data)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string' },
+                            content: { type: 'string' },
+                            tags: { type: 'array', items: { type: 'string' } },
+                            category: { type: 'string' },
+                        },
+                        required: ['content'],
+                    },
+                },
+            },
+            required: ['space_id'],
+        },
+    },
+    // ============ Batch Operations Tools ============
+    {
+        name: 'memory_ingest_batch',
+        description: 'Add multiple items to memory in a single operation. More efficient than multiple single ingests.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (uses default if not specified)',
+                },
+                items: {
+                    type: 'array',
+                    description: 'Array of items to ingest (max 100)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            content: { type: 'string', description: 'The content to store' },
+                            title: { type: 'string', description: 'Optional title' },
+                            source_type: {
+                                type: 'string',
+                                enum: ['manual', 'url', 'file_upload', 'api_ingestion'],
+                                description: 'Type of source',
+                            },
+                            source_uri: { type: 'string', description: 'Source URI' },
+                            tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                            category: { type: 'string', description: 'Category' },
+                        },
+                        required: ['content'],
+                    },
+                },
+            },
+            required: ['items'],
+        },
+    },
+    {
+        name: 'memory_delete_batch',
+        description: 'Delete multiple items from memory based on filters. Use dry_run=true first to preview what will be deleted.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                space_id: {
+                    type: 'string',
+                    description: 'Space UUID (optional, deletes from all spaces if not specified)',
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filters to select items to delete',
+                    properties: {
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Delete items with any of these tags',
+                        },
+                        source_types: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Delete items with these source types',
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Delete items in this category',
+                        },
+                        older_than: {
+                            type: 'string',
+                            description: 'Delete items older than this date (ISO format)',
+                        },
+                        newer_than: {
+                            type: 'string',
+                            description: 'Delete items newer than this date (ISO format)',
+                        },
+                        title_contains: {
+                            type: 'string',
+                            description: 'Delete items with title containing this text',
+                        },
+                        content_contains: {
+                            type: 'string',
+                            description: 'Delete items with content containing this text',
+                        },
+                    },
+                },
+                dry_run: {
+                    type: 'boolean',
+                    description: 'If true, only preview what would be deleted without actually deleting (default: true for safety)',
+                },
+            },
+            required: [],
+        },
+    },
+];
+// ============ Main Server ============
+async function main() {
+    const config = loadConfig();
+    const apiClient = new ApiClient(config);
+    // Startup banner
+    console.error('');
+    console.error(`${colors.bgBlue}${colors.white}${colors.bright} ContextForge MCP ${colors.reset}`);
+    console.error(`${colors.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${colors.reset}`);
+    console.error(`${colors.cyan}Version:${colors.reset}  0.1.0`);
+    console.error(`${colors.cyan}API URL:${colors.reset}  ${config.apiUrl}`);
+    console.error(`${colors.cyan}Space:${colors.reset}    ${config.defaultSpace || '(not set)'}`);
+    console.error(`${colors.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${colors.reset}`);
+    console.error('');
+    const server = new Server({
+        name: 'contextforge-mcp',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        logInfo(`Tools requested (${TOOLS.length} available)`);
+        return { tools: TOOLS };
+    });
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const startTime = Date.now();
+        try {
+            switch (name) {
+                case 'memory_ingest': {
+                    const input = IngestInputSchema.parse(args);
+                    const title = input.title || input.content.slice(0, 50) + '...';
+                    logTool(name, `"${title}"`);
+                    const result = await apiClient.ingest(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Saved ${result.created} item(s) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    created: result.created,
+                                    duplicates_skipped: result.duplicates_skipped,
+                                    items: result.items,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_query': {
+                    const input = QueryInputSchema.parse(args);
+                    logTool(name, `"${input.query}"`);
+                    const result = await apiClient.query(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Found ${result.results.length} result(s) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    results: result.results.map(r => ({
+                                        id: r.id,
+                                        title: r.title,
+                                        content: r.content,
+                                        score: r.score,
+                                        source_type: r.source_type,
+                                        tags: r.tags,
+                                        relationships: r.relationships,
+                                    })),
+                                    total: result.results.length,
+                                    latency_ms: result.latency_ms,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_list_spaces': {
+                    logTool(name);
+                    const spaces = await apiClient.listSpaces();
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${spaces.length} space(s) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    spaces: spaces.map(s => ({
+                                        id: s.id,
+                                        name: s.name,
+                                        slug: s.slug,
+                                        description: s.description,
+                                    })),
+                                    total: spaces.length,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_create_space': {
+                    const input = CreateSpaceInputSchema.parse(args);
+                    logTool(name, `"${input.name}"`);
+                    const space = await apiClient.createSpace(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Created space "${space.name}" in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    space: {
+                                        id: space.id,
+                                        name: space.name,
+                                        slug: space.slug,
+                                    },
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_relate': {
+                    const input = RelateInputSchema.parse(args);
+                    logTool(name, `${input.relationship_type}`);
+                    const relationship = await apiClient.relate(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Created relationship in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    relationship: {
+                                        id: relationship.id,
+                                        type: relationship.relationship_type,
+                                        weight: relationship.weight,
+                                    },
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_delete': {
+                    const input = DeleteInputSchema.parse(args);
+                    const identifier = input.id || `"${input.title}"`;
+                    logTool(name, identifier);
+                    const result = await apiClient.deleteItem(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Deleted "${result.title}" in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    deleted: {
+                                        id: result.id,
+                                        title: result.title,
+                                    },
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_stats': {
+                    logTool(name);
+                    const spaceId = typeof args === 'object' && args !== null && 'space_id' in args
+                        ? String(args.space_id)
+                        : undefined;
+                    const stats = await apiClient.getStats(spaceId);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Got stats in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(stats, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_list_items': {
+                    logTool(name);
+                    const spaceId = typeof args === 'object' && args !== null && 'space_id' in args
+                        ? String(args.space_id)
+                        : undefined;
+                    const limit = typeof args === 'object' && args !== null && 'limit' in args
+                        ? Number(args.limit)
+                        : undefined;
+                    const offset = typeof args === 'object' && args !== null && 'offset' in args
+                        ? Number(args.offset)
+                        : undefined;
+                    const result = await apiClient.listItems(spaceId, limit, offset);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${result.items.length} of ${result.total} item(s) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    items: result.items,
+                                    total: result.total,
+                                    showing: result.items.length,
+                                    offset: result.offset,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // ============ Git Integration Handlers ============
+                case 'memory_git_connect': {
+                    const input = GitConnectInputSchema.parse(args);
+                    logTool(name, input.repo_url);
+                    const result = await apiClient.gitConnect(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Connected ${result.repository.full_name} in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    repository: result.repository,
+                                    webhook_setup: result.webhook_setup,
+                                    message: `Repository connected! Follow the webhook setup instructions to complete the integration.`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_list': {
+                    logTool(name);
+                    const spaceId = typeof args === 'object' && args !== null && 'space_id' in args
+                        ? String(args.space_id)
+                        : undefined;
+                    const result = await apiClient.gitList(spaceId);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${result.total} repository(ies) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    repositories: result.repositories,
+                                    total: result.total,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_activate': {
+                    const input = GitActivateInputSchema.parse(args);
+                    const identifier = input.repository_id || input.repo;
+                    logTool(name, identifier);
+                    const result = await apiClient.gitActivate(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`${input.active !== false ? 'Activated' : 'Deactivated'} ${result.repository.full_name} in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_disconnect': {
+                    const input = GitDisconnectInputSchema.parse(args);
+                    const identifier = input.repository_id || input.repo;
+                    logTool(name, identifier);
+                    const result = await apiClient.gitDisconnect(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Disconnected repository in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_sync': {
+                    const input = GitSyncInputSchema.parse(args);
+                    const identifier = input.repository_id || input.repo;
+                    logTool(name, `${identifier} (${input.sync_type || 'all'})`);
+                    const result = await apiClient.gitSync(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Synced ${result.synced} items from ${result.repository.full_name} in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    repository: result.repository,
+                                    sync_type: result.sync_type,
+                                    synced: result.synced,
+                                    skipped: result.skipped,
+                                    items: result.items,
+                                    message: `Synced ${result.synced} items (${result.skipped} already existed)`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_commits': {
+                    const input = GitHistoryInputSchema.parse({ ...args, type: 'commits' });
+                    const identifier = input.repository_id || input.repo || 'all repos';
+                    logTool(name, identifier);
+                    const result = await apiClient.gitHistory(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${result.commits_count} commits in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    commits: result.items,
+                                    total: result.total,
+                                    showing: result.items.length,
+                                    offset: result.offset,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_git_prs': {
+                    const input = GitHistoryInputSchema.parse({ ...args, type: 'prs' });
+                    const identifier = input.repository_id || input.repo || 'all repos';
+                    logTool(name, identifier);
+                    const result = await apiClient.gitHistory(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${result.prs_count} PRs in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    pull_requests: result.items,
+                                    total: result.total,
+                                    showing: result.items.length,
+                                    offset: result.offset,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // ============ Snapshot Handlers ============
+                case 'memory_snapshot_create': {
+                    const input = SnapshotCreateInputSchema.parse(args);
+                    logTool(name, `"${input.name}"`);
+                    const result = await apiClient.snapshotCreate(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Created snapshot "${result.snapshot.name}" with ${result.snapshot.item_count} items in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    snapshot: result.snapshot,
+                                    message: `Snapshot "${result.snapshot.name}" created with ${result.snapshot.item_count} items`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_snapshot_list': {
+                    logTool(name);
+                    const spaceId = typeof args === 'object' && args !== null && 'space_id' in args
+                        ? String(args.space_id)
+                        : undefined;
+                    const result = await apiClient.snapshotList(spaceId);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Listed ${result.total} snapshot(s) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    snapshots: result.snapshots,
+                                    total: result.total,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_snapshot_restore': {
+                    const input = SnapshotRestoreInputSchema.parse(args);
+                    logTool(name, input.snapshot_id);
+                    const result = await apiClient.snapshotRestore(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Restored from "${result.restored_from.name}" (${result.stats.restored_count} items) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    restored_from: result.restored_from,
+                                    mode: result.mode,
+                                    stats: result.stats,
+                                    auto_backup_id: result.auto_backup_id,
+                                    message: `Restored ${result.stats.restored_count} items from snapshot "${result.restored_from.name}"`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_snapshot_delete': {
+                    const input = SnapshotDeleteInputSchema.parse(args);
+                    logTool(name, input.snapshot_id);
+                    const result = await apiClient.snapshotDelete(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Deleted snapshot in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // ============ Import/Export Handlers ============
+                case 'memory_export': {
+                    const input = ExportInputSchema.parse(args);
+                    logTool(name, `space ${input.space_id} as ${input.format || 'json'}`);
+                    const result = await apiClient.exportSpace(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Exported ${result.total_items} items in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    exported_at: result.exported_at,
+                                    space: result.space,
+                                    total_items: result.total_items,
+                                    format: input.format || 'json',
+                                    data: result,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_import': {
+                    const input = ImportInputSchema.parse(args);
+                    logTool(name, `to space ${input.space_id}`);
+                    const result = await apiClient.importToSpace(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Imported ${result.imported} items (${result.skipped} skipped) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    imported: result.imported,
+                                    skipped: result.skipped,
+                                    errors: result.errors,
+                                    total_processed: result.total_processed,
+                                    space: result.space,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // ============ Batch Operations Handlers ============
+                case 'memory_ingest_batch': {
+                    const input = IngestBatchInputSchema.parse(args);
+                    logTool(name, `${input.items.length} items`);
+                    const result = await apiClient.ingestBatchItems(input);
+                    const elapsed = Date.now() - startTime;
+                    logSuccess(`Ingested ${result.created} items (${result.duplicates_skipped} duplicates) in ${elapsed}ms`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    created: result.created,
+                                    duplicates_skipped: result.duplicates_skipped,
+                                    items: result.items,
+                                    message: `Successfully ingested ${result.created} items`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_delete_batch': {
+                    const input = DeleteBatchInputSchema.parse(args);
+                    const isDryRun = input.dry_run !== false;
+                    logTool(name, isDryRun ? '(dry run)' : '(executing)');
+                    const result = await apiClient.deleteBatch(input);
+                    const elapsed = Date.now() - startTime;
+                    if (result.dry_run) {
+                        logSuccess(`Would delete ${result.would_delete} items in ${elapsed}ms (dry run)`);
+                    }
+                    else {
+                        logSuccess(`Deleted ${result.deleted} items in ${elapsed}ms`);
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'memory_help': {
+                    logTool(name);
+                    const helpText = `
+# ContextForge Memory - Help
+
+## Available Commands
+
+### 📥 Save to Memory
+Save code, documentation, decisions, or any knowledge.
+\`\`\`
+"save to memory that this project uses React 18"
+"remember how the authentication flow works"
+"store this API documentation in memory"
+\`\`\`
+
+### 🔍 Search Memory
+Find relevant information using semantic search.
+\`\`\`
+"search my memory for authentication"
+"what do I have saved about React?"
+"find information about the login flow"
+\`\`\`
+
+### 📋 List Items
+View all saved items in your memory.
+\`\`\`
+"list all my saved memory items"
+"show me what's in my memory"
+"what have I saved?"
+\`\`\`
+
+### 📂 List Spaces
+View all your memory workspaces.
+\`\`\`
+"list my memory spaces"
+"show my workspaces"
+\`\`\`
+
+### ✨ Create Space
+Create a new workspace to organize knowledge.
+\`\`\`
+"create a new memory space called 'Backend API'"
+"make a new workspace for the mobile app"
+\`\`\`
+
+### 🗑️ Delete Item
+Remove an item from memory by title or ID.
+\`\`\`
+"delete the item about authentication from memory"
+"remove 'React Setup' from my memory"
+"delete item with id [uuid] from memory"
+\`\`\`
+
+### 🔗 Create Relationship
+Link two knowledge items together.
+\`\`\`
+"relate [item1] to [item2] as 'implements'"
+\`\`\`
+
+### 📊 Get Stats
+View memory usage statistics.
+\`\`\`
+"show my memory stats"
+\`\`\`
+
+---
+
+## Git Integration
+
+### 🔌 Connect Repository
+Connect a GitHub repo to auto-sync commits and PRs.
+\`\`\`
+"connect my github repo owner/repo-name to space [space-id]"
+"sync my repository https://github.com/user/project"
+\`\`\`
+
+### 📡 List Connected Repos
+View all connected repositories.
+\`\`\`
+"list my connected git repositories"
+"show my synced repos"
+\`\`\`
+
+### 🔄 Sync Commits/PRs
+Sync existing commits and PRs from GitHub into memory.
+\`\`\`
+"sync commits from owner/repo"
+"sync all from my-project"
+"sync the last 50 PRs from owner/repo"
+\`\`\`
+
+### 📝 List Commits
+View commits stored in memory.
+\`\`\`
+"list commits from owner/repo"
+"show my synced commits"
+"list the last 20 commits"
+\`\`\`
+
+### 🔀 List Pull Requests
+View PRs stored in memory.
+\`\`\`
+"list PRs from owner/repo"
+"show my synced pull requests"
+\`\`\`
+
+### ✅ Activate/Deactivate
+Enable or disable syncing for a repository.
+\`\`\`
+"activate the webhook for owner/repo"
+"disable git sync for my-project"
+\`\`\`
+
+### 🔌 Disconnect Repository
+Stop syncing and remove a repository.
+\`\`\`
+"disconnect owner/repo from memory"
+"remove git sync for my-project"
+\`\`\`
+
+---
+
+## Snapshots (Version Control)
+
+### 📸 Create Snapshot
+Save the current state of your memory.
+\`\`\`
+"create a snapshot called 'Before refactoring'"
+"backup my memory state"
+\`\`\`
+
+### 🗂️ List Snapshots
+View all available snapshots.
+\`\`\`
+"list my memory snapshots"
+"show available backups"
+\`\`\`
+
+### ⏪ Restore Snapshot
+Restore memory to a previous state.
+\`\`\`
+"restore snapshot [id]"
+"rollback to 'Before refactoring'"
+\`\`\`
+
+### 🗑️ Delete Snapshot
+Remove a snapshot.
+\`\`\`
+"delete snapshot [id]"
+\`\`\`
+
+---
+
+## Import/Export
+
+### 📤 Export Space
+Export all items from a space.
+\`\`\`
+"export my Backend space as JSON"
+"export space [id] to markdown"
+"download my memory as CSV"
+\`\`\`
+
+### 📥 Import Data
+Import from various sources.
+\`\`\`
+"import this JSON data into my space"
+"import from my Obsidian vault"
+"import these items to memory"
+\`\`\`
+
+Supported formats:
+- **contextforge**: Our native JSON format
+- **markdown**: Markdown files (split by ## headers)
+- **notion**: Notion export JSON
+- **obsidian**: Obsidian vault export
+
+## Tips
+- Memory persists across all your Claude Code sessions
+- Search is semantic - it understands meaning, not just keywords
+- Use tags to categorize your knowledge
+- Create separate spaces for different projects
+
+## More Info
+https://github.com/contextforge/contextforge-mcp
+`;
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: helpText,
+                            },
+                        ],
+                    };
+                }
+                default:
+                    logError(`Unknown tool: ${name}`);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Unknown tool: ${name}`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+            }
+        }
+        catch (error) {
+            const elapsed = Date.now() - startTime;
+            if (error instanceof ApiClientError) {
+                logError(`${error.message} (${error.statusCode}) [${elapsed}ms]`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: error.message,
+                                code: error.code,
+                                statusCode: error.statusCode,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            if (error instanceof Error) {
+                logError(`${error.message} [${elapsed}ms]`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: error.message,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            logError(`Unknown error [${elapsed}ms]`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Unknown error occurred',
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Start the server
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logInfo('Server connected and ready');
+}
+main().catch((error) => {
+    console.error(`${colors.red}Fatal error:${colors.reset}`, error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map