@execufunction/mcp-server 0.2.0

package/dist/index.js

@@ -0,0 +1,1868 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ExecuFunction MCP Server
+ *
+ * A Model Context Protocol server that exposes ExecuFunction tools to IDE clients
+ * like Cursor, Claude Desktop, and VS Code.
+ *
+ * Configuration via environment variables:
+ * - EXF_API_URL: ExecuFunction API URL (e.g., https://execufunction.com)
+ * - EXF_PAT: Personal Access Token for authentication
+ *
+ * Usage:
+ * 1. Create a PAT in ExecuFunction Settings > Developer > Access Tokens
+ * 2. Configure your MCP client (e.g., claude_desktop_config.json):
+ *    {
+ *      "mcpServers": {
+ *        "execufunction": {
+ *          "command": "npx",
+ *          "args": ["@execufunction/mcp-server"],
+ *          "env": {
+ *            "EXF_API_URL": "https://execufunction.com",
+ *            "EXF_PAT": "exf_pat_..."
+ *          }
+ *        }
+ *      }
+ *    }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const exfClient_js_1 = require("./exfClient.js");
+const localIndexer_js_1 = require("./localIndexer.js");
+const incrementalIndexer_js_1 = require("./incrementalIndexer.js");
+const gitService_js_1 = require("./gitService.js");
+// =============================================================================
+// Tool Definitions
+// =============================================================================
+const DATASETS_ENABLED = (process.env.DATASETS_ENABLED ?? 'false').toLowerCase() === 'true';
+const DATASET_ONTOLOGY_ENABLED = (process.env.DATASET_ONTOLOGY_ENABLED
+    ?? process.env.DATASETS_ENABLED
+    ?? 'false').toLowerCase() === 'true';
+const DATASET_ACTIONS_ENABLED = ((process.env.DATASET_ACTIONS_ENABLED ?? 'false').toLowerCase() === 'true') && DATASET_ONTOLOGY_ENABLED;
+const TOOLS = [
+    {
+        name: 'project_list',
+        description: 'List projects',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['planning', 'active', 'on_hold', 'blocked', 'completed', 'archived'],
+                },
+                includeArchived: { type: 'boolean' },
+            },
+        },
+    },
+    {
+        name: 'project_create',
+        description: 'Create a project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                summary: { type: 'string' },
+                status: {
+                    type: 'string',
+                    enum: ['planning', 'active', 'on_hold', 'blocked', 'completed'],
+                },
+                emoji: { type: 'string', description: 'Single emoji' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'project_update',
+        description: 'Update a project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+                name: { type: 'string' },
+                summary: { type: 'string' },
+                status: {
+                    type: 'string',
+                    enum: ['planning', 'active', 'on_hold', 'blocked', 'completed'],
+                },
+                emoji: { type: 'string', description: 'Single emoji' },
+            },
+            required: ['projectId'],
+        },
+    },
+    {
+        name: 'project_archive',
+        description: 'Archive a project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+            },
+            required: ['projectId'],
+        },
+    },
+    {
+        name: 'project_get_context',
+        description: 'Get project context (tasks, notes, members, signals)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string', description: 'Project UUID' },
+            },
+            required: ['projectId'],
+        },
+    },
+    {
+        name: 'task_list',
+        description: 'List tasks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+                status: {
+                    type: 'string',
+                    enum: ['inbox', 'next_action', 'in_progress', 'waiting_for', 'completed', 'archived'],
+                },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'task_create',
+        description: 'Create a task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                description: { type: 'string' },
+                priority: {
+                    type: 'string',
+                    enum: ['do_now', 'schedule', 'delegate', 'someday'],
+                },
+                dueAt: { type: 'string', description: 'ISO 8601' },
+                projectId: { type: 'string' },
+                idempotencyKey: { type: 'string' },
+            },
+            required: ['title'],
+        },
+    },
+    {
+        name: 'task_get',
+        description: 'Get a single task with full details',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string' },
+            },
+            required: ['taskId'],
+        },
+    },
+    {
+        name: 'task_update',
+        description: 'Update a task (title, description, status, priority, due date, project)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string' },
+                title: { type: 'string' },
+                description: { type: 'string' },
+                status: {
+                    type: 'string',
+                    enum: ['inbox', 'next_action', 'in_progress', 'waiting_for', 'completed', 'archived'],
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['do_now', 'schedule', 'delegate', 'someday'],
+                },
+                dueAt: { type: 'string', description: 'ISO 8601' },
+                projectId: { type: 'string' },
+                idempotencyKey: { type: 'string' },
+            },
+            required: ['taskId'],
+        },
+    },
+    {
+        name: 'task_delete',
+        description: 'Delete a task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string' },
+            },
+            required: ['taskId'],
+        },
+    },
+    {
+        name: 'task_complete',
+        description: 'Mark task complete',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string' },
+                idempotencyKey: { type: 'string' },
+            },
+            required: ['taskId'],
+        },
+    },
+    {
+        name: 'note_search',
+        description: 'Search notes',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                projectId: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'note_list',
+        description: 'List notes',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+                noteType: {
+                    type: 'string',
+                    enum: ['note', 'concept', 'meeting', 'reference', 'daily', 'dataset'],
+                },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'note_get',
+        description: 'Get a single note with full content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                noteId: { type: 'string' },
+            },
+            required: ['noteId'],
+        },
+    },
+    {
+        name: 'note_create',
+        description: 'Create a note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                content: { type: 'string', description: 'Markdown' },
+                projectId: { type: 'string' },
+                noteType: {
+                    type: 'string',
+                    enum: ['note', 'concept', 'meeting', 'reference', 'daily', 'dataset'],
+                },
+                idempotencyKey: { type: 'string' },
+            },
+            required: ['title'],
+        },
+    },
+    {
+        name: 'note_update',
+        description: 'Update a note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                noteId: { type: 'string' },
+                title: { type: 'string' },
+                content: { type: 'string', description: 'Markdown' },
+                noteType: {
+                    type: 'string',
+                    enum: ['note', 'concept', 'meeting', 'reference', 'daily', 'dataset'],
+                },
+                idempotencyKey: { type: 'string' },
+            },
+            required: ['noteId'],
+        },
+    },
+    {
+        name: 'note_delete',
+        description: 'Delete a note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                noteId: { type: 'string' },
+            },
+            required: ['noteId'],
+        },
+    },
+    {
+        name: 'dataset_list',
+        description: 'List datasets',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'dataset_create',
+        description: 'Create a dataset',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                description: { type: 'string' },
+                fields: { type: 'array', items: { type: 'object' } },
+                metadata: { type: 'object' },
+            },
+            required: ['title'],
+        },
+    },
+    {
+        name: 'dataset_query',
+        description: 'Query dataset records by filters/sorts',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                datasetId: { type: 'string' },
+                filters: { type: 'array', items: { type: 'object' } },
+                sorts: { type: 'array', items: { type: 'object' } },
+                limit: { type: 'number' },
+                cursor: { type: 'string' },
+            },
+            required: ['datasetId'],
+        },
+    },
+    {
+        name: 'dataset_mutate',
+        description: 'Mutate dataset records (create/update/delete)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                datasetId: { type: 'string' },
+                operation: { type: 'string', enum: ['create', 'update', 'delete'] },
+                records: { type: 'array', items: { type: 'object' } },
+                recordId: { type: 'string' },
+                fields: { type: 'object' },
+            },
+            required: ['datasetId', 'operation'],
+        },
+    },
+    {
+        name: 'dataset_schema_modify',
+        description: 'Modify dataset schema (add/update/delete field)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                datasetId: { type: 'string' },
+                operation: { type: 'string', enum: ['add_field', 'update_field', 'delete_field'] },
+                fieldId: { type: 'string' },
+                field: { type: 'object' },
+            },
+            required: ['datasetId', 'operation'],
+        },
+    },
+    {
+        name: 'dataset_summarize',
+        description: 'Summarize dataset schema and sample rows',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                datasetId: { type: 'string' },
+            },
+            required: ['datasetId'],
+        },
+    },
+    {
+        name: 'object_find',
+        description: 'Find ontology objects by object type and property filters',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                objectType: { type: 'string' },
+                where: { type: 'array', items: { type: 'object' } },
+                limit: { type: 'number' },
+            },
+            required: ['objectType'],
+        },
+    },
+    {
+        name: 'object_links',
+        description: 'Traverse graph links for an object record',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                objectRecordId: { type: 'string' },
+                depth: { type: 'number' },
+                limit: { type: 'number' },
+            },
+            required: ['objectRecordId'],
+        },
+    },
+    {
+        name: 'object_action_run',
+        description: 'Run declarative action on an ontology object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                objectTypeKey: { type: 'string' },
+                actionKey: { type: 'string' },
+                objectRecordId: { type: 'string' },
+                idempotencyKey: { type: 'string' },
+                parameters: { type: 'object' },
+            },
+            required: ['objectTypeKey', 'actionKey', 'objectRecordId'],
+        },
+    },
+    {
+        name: 'people_search',
+        description: 'Search contacts',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'calendar_list_events',
+        description: 'List calendar events',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                startDate: { type: 'string', description: 'ISO 8601' },
+                endDate: { type: 'string', description: 'ISO 8601' },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'calendar_create_event',
+        description: 'Create calendar event',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                startTime: { type: 'string', description: 'ISO 8601' },
+                endTime: { type: 'string', description: 'ISO 8601' },
+                description: { type: 'string' },
+                location: { type: 'string' },
+            },
+            required: ['title', 'startTime', 'endTime'],
+        },
+    },
+    {
+        name: 'calendar_update_event',
+        description: 'Update a calendar event',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                eventId: { type: 'string' },
+                title: { type: 'string' },
+                startTime: { type: 'string', description: 'ISO 8601' },
+                endTime: { type: 'string', description: 'ISO 8601' },
+                description: { type: 'string' },
+                location: { type: 'string' },
+            },
+            required: ['eventId'],
+        },
+    },
+    {
+        name: 'calendar_delete_event',
+        description: 'Delete a calendar event',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                eventId: { type: 'string' },
+            },
+            required: ['eventId'],
+        },
+    },
+    // Codebase Indexing Tools
+    {
+        name: 'codebase_list',
+        description: 'List indexed repositories',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'codebase_register',
+        description: 'Register codebase for indexing',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rootPath: { type: 'string', description: 'Absolute path' },
+                name: { type: 'string' },
+                projectId: { type: 'string' },
+                includePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+                excludePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+                autoIndex: { type: 'boolean' },
+            },
+            required: ['rootPath', 'name'],
+        },
+    },
+    {
+        name: 'codebase_status',
+        description: 'Check indexing status',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+            },
+            required: ['repositoryId'],
+        },
+    },
+    {
+        name: 'codebase_snapshot_status',
+        description: 'Get latest index snapshot for a repository',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                branch: { type: 'string' },
+                committedOnly: { type: 'boolean' },
+            },
+            required: ['repositoryId'],
+        },
+    },
+    {
+        name: 'codebase_materialize_snapshot',
+        description: 'Materialize a snapshot archive and return a short-lived download URL',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                snapshotId: { type: 'string' },
+                expiresMinutes: { type: 'number' },
+            },
+            required: ['snapshotId'],
+        },
+    },
+    {
+        name: 'codebase_index',
+        description: 'Full index: scan and upload files',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                rootPath: { type: 'string', description: 'Absolute path' },
+                includePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+                excludePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+            },
+            required: ['repositoryId', 'rootPath'],
+        },
+    },
+    {
+        name: 'codebase_index_incremental',
+        description: 'Incremental index: git-aware, changed files only',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                rootPath: { type: 'string', description: 'Absolute path' },
+                includePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+                excludePatterns: { type: 'array', items: { type: 'string' }, description: 'Globs' },
+                includeWorkingTree: {
+                    type: 'boolean',
+                    description: 'When true (default), also indexes local uncommitted changes',
+                },
+            },
+            required: ['repositoryId', 'rootPath'],
+        },
+    },
+    {
+        name: 'codebase_delete',
+        description: 'Delete a repository and all its indexed data (files, chunks, embeddings, snapshots)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+            },
+            required: ['repositoryId'],
+        },
+    },
+    {
+        name: 'codebase_search',
+        description: 'Semantic code search',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                repositoryId: { type: 'string' },
+                language: { type: 'string' },
+                symbolType: {
+                    type: 'string',
+                    enum: ['function', 'class', 'interface', 'type', 'export', 'impl'],
+                },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+    // Developer Expertise Tools
+    {
+        name: 'code_who_knows',
+        description: 'Find experts for code area',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                codeArea: { type: 'string', description: 'Path, glob, or symbol' },
+                limit: { type: 'number' },
+            },
+            required: ['repositoryId', 'codeArea'],
+        },
+    },
+    {
+        name: 'code_compute_expertise',
+        description: 'Refresh expertise index',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+            },
+            required: ['repositoryId'],
+        },
+    },
+    {
+        name: 'code_history',
+        description: 'Get commit history',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                path: { type: 'string', description: 'Filter by file' },
+                limit: { type: 'number' },
+            },
+            required: ['repositoryId'],
+        },
+    },
+    {
+        name: 'git_blame_symbol',
+        description: 'Git blame (local)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rootPath: { type: 'string', description: 'Repo root' },
+                filePath: { type: 'string', description: 'Relative path' },
+                startLine: { type: 'number' },
+                endLine: { type: 'number' },
+            },
+            required: ['rootPath', 'filePath'],
+        },
+    },
+    {
+        name: 'task_link_code',
+        description: 'Link task to code',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string' },
+                repositoryId: { type: 'string' },
+                filePath: { type: 'string' },
+                commitSha: { type: 'string' },
+                notes: { type: 'string' },
+            },
+            required: ['taskId', 'repositoryId'],
+        },
+    },
+    // Code Memory Tools
+    {
+        name: 'code_memory_store',
+        description: 'Store codebase fact',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fact: { type: 'string', description: '1-2 sentences' },
+                category: {
+                    type: 'string',
+                    enum: ['architecture', 'integration', 'convention', 'entrypoint', 'gotcha', 'ownership'],
+                },
+                filePath: { type: 'string' },
+                repositoryId: { type: 'string' },
+            },
+            required: ['fact', 'category'],
+        },
+    },
+    {
+        name: 'code_memory_search',
+        description: 'Search stored codebase facts',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                category: {
+                    type: 'string',
+                    enum: ['architecture', 'integration', 'convention', 'entrypoint', 'gotcha', 'ownership'],
+                },
+                repositoryId: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'code_memory_list',
+        description: 'List stored facts',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repositoryId: { type: 'string' },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'code_memory_delete',
+        description: 'Delete stored fact',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string' },
+            },
+            required: ['memoryId'],
+        },
+    },
+    // Document Upload Tool
+    {
+        name: 'upload_document',
+        description: 'Upload a document (PDF, Markdown, or text) into Knowledge as a note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to a local file (PDF, .md, or .txt)' },
+                content: { type: 'string', description: 'File content (plain text for .md/.txt, base64 for PDF). Use with filename.' },
+                filename: { type: 'string', description: 'Filename with extension (required when using content instead of filePath)' },
+                contentType: { type: 'string', description: 'MIME type override (auto-detected from extension if omitted)' },
+                title: { type: 'string', description: 'Note title (defaults to filename without extension)' },
+                noteType: {
+                    type: 'string',
+                    enum: ['note', 'concept', 'meeting', 'reference', 'daily', 'dataset'],
+                    description: 'Note type (defaults to "reference" for PDFs, "note" for text)',
+                },
+                projectId: { type: 'string', description: 'Project to attach the note to' },
+            },
+        },
+    },
+    // Vault / Secrets Management Tools
+    {
+        name: 'vault_list',
+        description: 'List vault entries (secrets, API keys, credentials). Returns metadata only — never decrypted values.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entryType: {
+                    type: 'string',
+                    enum: ['env_var', 'credential', 'oauth_token', 'ssh_key', 'certificate', 'note'],
+                },
+                category: { type: 'string' },
+                search: { type: 'string' },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'vault_create',
+        description: 'Store a new encrypted secret in the vault',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                slug: { type: 'string', description: 'Machine-friendly identifier (auto-generated if omitted)' },
+                entryType: {
+                    type: 'string',
+                    enum: ['env_var', 'credential', 'oauth_token', 'ssh_key', 'certificate', 'note'],
+                },
+                payload: { type: 'object', description: 'Key-value pairs to encrypt' },
+                description: { type: 'string' },
+                tags: { type: 'array', items: { type: 'string' } },
+                category: { type: 'string' },
+                url: { type: 'string' },
+            },
+            required: ['name', 'payload'],
+        },
+    },
+    {
+        name: 'vault_read',
+        description: 'Decrypt and read a vault secret. Audit-logged. Only available to trusted MCP clients.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entryId: { type: 'string', description: 'Vault entry UUID' },
+            },
+            required: ['entryId'],
+        },
+    },
+    {
+        name: 'vault_update',
+        description: 'Update vault entry metadata (name, tags, category, description)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entryId: { type: 'string' },
+                name: { type: 'string' },
+                description: { type: 'string' },
+                tags: { type: 'array', items: { type: 'string' } },
+                category: { type: 'string' },
+                url: { type: 'string' },
+            },
+            required: ['entryId'],
+        },
+    },
+    {
+        name: 'vault_search',
+        description: 'Search vault entries by name, slug, or description. Returns metadata only.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+];
+function isToolEnabled(name) {
+    if (name.startsWith('dataset_')) {
+        return DATASETS_ENABLED;
+    }
+    if (name === 'object_find' || name === 'object_links') {
+        return DATASET_ONTOLOGY_ENABLED;
+    }
+    if (name === 'object_action_run') {
+        return DATASET_ACTIONS_ENABLED;
+    }
+    return true;
+}
+// =============================================================================
+// Tool Execution
+// =============================================================================
+async function executeTool(client, name, args) {
+    switch (name) {
+        case 'project_list': {
+            const result = await client.listProjects({
+                status: args.status,
+                includeArchived: args.includeArchived,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const projects = result.data?.projects || [];
+            if (projects.length === 0)
+                return 'No projects found.';
+            return projects.map((p) => `• ${p.emoji || '📁'} ${p.name} [${p.status}] - ${p.summary || 'No description'}`).join('\n');
+        }
+        case 'project_create': {
+            const result = await client.createProject({
+                name: args.name,
+                summary: args.summary,
+                status: args.status,
+                emoji: args.emoji,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const p = result.data?.project;
+            return `Project created: ${p?.emoji || '📁'} ${p?.name} [${p?.status}]\nID: ${p?.id}`;
+        }
+        case 'project_update': {
+            const result = await client.updateProject(args.projectId, {
+                name: args.name,
+                summary: args.summary,
+                status: args.status,
+                emoji: args.emoji,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const p = result.data?.project;
+            return `Project updated: ${p?.emoji || '📁'} ${p?.name} [${p?.status}]`;
+        }
+        case 'project_archive': {
+            const result = await client.archiveProject(args.projectId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Project archived: ${result.data?.project?.name}`;
+        }
+        case 'project_get_context': {
+            const result = await client.getProjectContext(args.projectId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const ctx = result.data?.context ?? result.data;
+            if (!ctx)
+                return 'Project not found.';
+            let output = `# ${ctx.project?.emoji || '📁'} ${ctx.project?.name}\n`;
+            output += `Status: ${ctx.project?.status}\n`;
+            output += `Summary: ${ctx.project?.summary || 'None'}\n\n`;
+            if (ctx.signals) {
+                output += `## Signals\n`;
+                output += `- Open tasks: ${ctx.signals.openTaskCount || 0}\n`;
+                output += `- Blocked tasks: ${ctx.signals.blockedTaskCount || 0}\n`;
+                output += `- Overdue tasks: ${ctx.signals.overdueTaskCount || 0}\n`;
+                output += `- Completed tasks: ${ctx.signals.completedTaskCount || 0}\n`;
+                if (ctx.signals.daysUntilDeadline !== null && ctx.signals.daysUntilDeadline !== undefined) {
+                    output += `- Days until deadline: ${ctx.signals.daysUntilDeadline}\n`;
+                }
+                output += `\n`;
+            }
+            const openTasks = ctx.tasks?.open ?? [];
+            const blockedTasks = ctx.tasks?.blocked ?? [];
+            const overdueTasks = ctx.tasks?.overdue ?? [];
+            if (openTasks.length > 0) {
+                output += `## Open Tasks (${openTasks.length})\n`;
+                openTasks.slice(0, 10).forEach((t) => {
+                    output += `- [${t.status}] ${t.title}${t.dueAt ? ` (due: ${t.dueAt})` : ''}\n`;
+                });
+                if (openTasks.length > 10)
+                    output += `... and ${openTasks.length - 10} more\n`;
+                output += `\n`;
+            }
+            if (blockedTasks.length > 0) {
+                output += `## Blocked (${blockedTasks.length})\n`;
+                blockedTasks.slice(0, 5).forEach((t) => {
+                    const blockedBy = Array.isArray(t.blockedBy) && t.blockedBy.length > 0
+                        ? ` (blocked by: ${t.blockedBy.join(', ')})`
+                        : '';
+                    output += `- ${t.title}${blockedBy}\n`;
+                });
+                if (blockedTasks.length > 5)
+                    output += `... and ${blockedTasks.length - 5} more\n`;
+                output += `\n`;
+            }
+            if (overdueTasks.length > 0) {
+                output += `## Overdue (${overdueTasks.length})\n`;
+                overdueTasks.slice(0, 5).forEach((t) => {
+                    output += `- ${t.title} (due: ${t.dueAt})\n`;
+                });
+                if (overdueTasks.length > 5)
+                    output += `... and ${overdueTasks.length - 5} more\n`;
+                output += `\n`;
+            }
+            return output;
+        }
+        case 'task_list': {
+            const result = await client.listTasks({
+                projectId: args.projectId,
+                status: args.status,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const tasks = result.data?.tasks || [];
+            if (tasks.length === 0)
+                return 'No tasks found.';
+            return tasks.map((t) => `• [${t.status}] ${t.title}${t.dueAt ? ` (due: ${new Date(t.dueAt).toLocaleDateString()})` : ''}`).join('\n');
+        }
+        case 'task_get': {
+            const result = await client.getTask(args.taskId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const t = result.data?.task;
+            if (!t)
+                return 'Task not found.';
+            let output = `# ${t.title}\n`;
+            output += `Status: ${t.status}\n`;
+            output += `Priority: ${t.priority || 'none'}\n`;
+            if (t.dueAt)
+                output += `Due: ${new Date(t.dueAt).toLocaleDateString()}\n`;
+            if (t.projectId)
+                output += `Project: ${t.projectId}\n`;
+            if (t.description)
+                output += `\n${t.description}\n`;
+            output += `\nID: ${t.id}`;
+            return output;
+        }
+        case 'task_update': {
+            const { taskId, idempotencyKey, ...updates } = args;
+            const result = await client.updateTask(taskId, {
+                title: updates.title,
+                description: updates.description,
+                status: updates.status,
+                priority: updates.priority,
+                dueAt: updates.dueAt,
+                projectId: updates.projectId,
+            }, idempotencyKey);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const t = result.data?.task;
+            return `Task updated: ${t?.title} [${t?.status}]`;
+        }
+        case 'task_delete': {
+            const result = await client.deleteTask(args.taskId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Task deleted.`;
+        }
+        case 'task_create': {
+            const result = await client.createTask({
+                title: args.title,
+                description: args.description,
+                priority: args.priority,
+                dueAt: args.dueAt,
+                projectId: args.projectId,
+            }, args.idempotencyKey);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `✅ Task created: ${result.data?.task?.title} (ID: ${result.data?.task?.id})`;
+        }
+        case 'task_complete': {
+            const result = await client.completeTask(args.taskId, args.idempotencyKey);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `✅ Task completed: ${result.data?.task?.title}`;
+        }
+        case 'note_list': {
+            const result = await client.listNotes({
+                projectId: args.projectId,
+                noteType: args.noteType,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const notes = result.data?.notes || [];
+            if (notes.length === 0)
+                return 'No notes found.';
+            return notes.map((n) => `• ${n.title} [${n.noteType}]${n.projectId ? ` (project: ${n.projectId})` : ''}\n  ID: ${n.id}`).join('\n');
+        }
+        case 'note_get': {
+            const result = await client.getNote(args.noteId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const n = result.data?.note;
+            if (!n)
+                return 'Note not found.';
+            let output = `# ${n.title}\n`;
+            output += `Type: ${n.noteType}\n`;
+            if (n.projectId)
+                output += `Project: ${n.projectId}\n`;
+            output += `\n`;
+            // Extract text from contentJson if available
+            if (n.contentJson?.content) {
+                for (const block of n.contentJson.content) {
+                    if (block.type === 'paragraph' && block.content) {
+                        output += block.content.map((c) => c.text || '').join('') + '\n';
+                    }
+                    else if (block.type === 'heading' && block.content) {
+                        const level = block.attrs?.level || 2;
+                        output += '#'.repeat(level) + ' ' + block.content.map((c) => c.text || '').join('') + '\n';
+                    }
+                }
+            }
+            else if (n.content) {
+                output += n.content;
+            }
+            output += `\nID: ${n.id}`;
+            return output;
+        }
+        case 'note_search': {
+            const result = await client.searchNotes(args.query, {
+                projectId: args.projectId,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const results = result.data?.results || [];
+            if (results.length === 0)
+                return 'No notes found.';
+            return results.map((n) => `• ${n.title}${n.snippet ? `\n  ${n.snippet}` : ''}`).join('\n\n');
+        }
+        case 'note_create': {
+            const result = await client.createNote({
+                title: args.title,
+                content: args.content,
+                projectId: args.projectId,
+                noteType: args.noteType,
+            }, args.idempotencyKey);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `✅ Note created: ${result.data?.note?.title} (ID: ${result.data?.note?.id})`;
+        }
+        case 'note_update': {
+            const result = await client.updateNote(args.noteId, {
+                title: args.title,
+                content: args.content,
+                noteType: args.noteType,
+            }, args.idempotencyKey);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Note updated: ${result.data?.note?.title}`;
+        }
+        case 'note_delete': {
+            const result = await client.deleteNote(args.noteId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Note deleted.`;
+        }
+        case 'dataset_list': {
+            const result = await client.listDatasets(args.limit);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const datasets = result.data?.datasets || [];
+            if (datasets.length === 0)
+                return 'No datasets found.';
+            return datasets.map((d) => `• ${d.title} (${d.rowCount} rows, ${d.physicalTableName})\n  ID: ${d.id}`).join('\n\n');
+        }
+        case 'dataset_create': {
+            const result = await client.createDataset({
+                title: args.title,
+                description: args.description,
+                fields: args.fields,
+                metadata: args.metadata,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const dataset = result.data?.dataset;
+            const fields = result.data?.fields || [];
+            return `Dataset created: ${dataset?.title || args.title}\nID: ${dataset?.id}\nFields: ${fields.length}`;
+        }
+        case 'dataset_query': {
+            const result = await client.queryDataset(args.datasetId, {
+                filters: args.filters,
+                sorts: args.sorts,
+                limit: args.limit,
+                cursor: args.cursor,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const records = result.data?.records || [];
+            if (records.length === 0)
+                return 'No records found.';
+            const lines = records.slice(0, 20).map((record, idx) => {
+                return `${idx + 1}. ${record.id} ${JSON.stringify(record.fields)}`;
+            });
+            const nextCursor = result.data?.nextCursor;
+            return `${lines.join('\n')}${nextCursor ? `\n\nnextCursor: ${nextCursor}` : ''}`;
+        }
+        case 'dataset_mutate': {
+            const result = await client.mutateDataset(args.datasetId, {
+                operation: args.operation,
+                records: args.records,
+                recordId: args.recordId,
+                fields: args.fields,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Dataset mutation successful: ${String(args.operation)}`;
+        }
+        case 'dataset_schema_modify': {
+            const result = await client.modifyDatasetSchema(args.datasetId, {
+                operation: args.operation,
+                fieldId: args.fieldId,
+                field: args.field,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Dataset schema updated: ${String(args.operation)}`;
+        }
+        case 'dataset_summarize': {
+            const result = await client.summarizeDataset(args.datasetId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const summary = result.data?.summary;
+            if (!summary)
+                return 'No summary available.';
+            return [
+                `Dataset: ${summary.title}`,
+                `Rows: ${summary.rowCount}`,
+                `Fields: ${summary.fieldCount}`,
+                `Formula fields: ${summary.formulaFieldCount}`,
+                `Relation fields: ${summary.relationFieldCount}`,
+                `Object bound: ${summary.objectBound ? 'yes' : 'no'}`,
+            ].join('\n');
+        }
+        case 'object_find': {
+            const result = await client.findObjects({
+                objectType: args.objectType,
+                where: args.where,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const objects = result.data?.objects || [];
+            if (objects.length === 0)
+                return 'No objects found.';
+            return objects.map((obj) => `• ${obj.display_name} [${obj.status || 'no-status'}]\n  id: ${obj.id}\n  datasetRow: ${obj.dataset_row_id || '-'}`).join('\n\n');
+        }
+        case 'object_links': {
+            const result = await client.getObjectLinks(args.objectRecordId, {
+                depth: args.depth,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const graph = result.data?.graph;
+            if (!graph)
+                return 'No graph returned.';
+            return `Graph nodes: ${graph.nodes?.length || 0}\nGraph edges: ${graph.edges?.length || 0}`;
+        }
+        case 'object_action_run': {
+            const result = await client.runObjectAction({
+                objectTypeKey: args.objectTypeKey,
+                actionKey: args.actionKey,
+                objectRecordId: args.objectRecordId,
+                idempotencyKey: args.idempotencyKey,
+                parameters: args.parameters,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const actionResult = result.data?.result ?? result.data;
+            return `Action executed: ${actionResult?.actionKey || args.actionKey}\nSide effects: ${(actionResult?.sideEffects || []).length}`;
+        }
+        case 'people_search': {
+            const result = await client.searchPeople(args.query, args.limit);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const people = result.data?.people || [];
+            if (people.length === 0)
+                return 'No people found.';
+            return people.map((p) => `• ${p.name}${p.email ? ` <${p.email}>` : ''}${p.company ? ` @ ${p.company}` : ''}`).join('\n');
+        }
+        case 'calendar_list_events': {
+            const result = await client.listCalendarEvents({
+                startDate: args.startDate,
+                endDate: args.endDate,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const events = result.data?.events || [];
+            if (events.length === 0)
+                return 'No calendar events found in the specified range.';
+            return events.map((e) => {
+                const start = new Date(e.startTime);
+                const end = new Date(e.endTime);
+                const dateStr = start.toLocaleDateString();
+                const timeStr = e.isAllDay ? 'All day' : `${start.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })} - ${end.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`;
+                return `• ${dateStr} ${timeStr}: ${e.title}${e.location ? ` @ ${e.location}` : ''}`;
+            }).join('\n');
+        }
+        case 'calendar_create_event': {
+            const result = await client.createCalendarEvent({
+                title: args.title,
+                startTime: args.startTime,
+                endTime: args.endTime,
+                description: args.description,
+                location: args.location,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const event = result.data?.event;
+            if (!event)
+                return 'Event created but no details returned.';
+            const start = new Date(event.startTime);
+            const end = new Date(event.endTime);
+            return `✅ Calendar event created: "${event.title}"\n   ${start.toLocaleDateString()} ${start.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })} - ${end.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}${event.location ? `\n   Location: ${event.location}` : ''}\n   ID: ${event.id}`;
+        }
+        case 'calendar_update_event': {
+            const result = await client.updateCalendarEvent(args.eventId, {
+                title: args.title,
+                startTime: args.startTime,
+                endTime: args.endTime,
+                description: args.description,
+                location: args.location,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const e = result.data?.event;
+            return `Calendar event updated: ${e?.title || 'done'}`;
+        }
+        case 'calendar_delete_event': {
+            const result = await client.deleteCalendarEvent(args.eventId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `Calendar event deleted.`;
+        }
+        // =========================================================================
+        // Codebase Indexing Tools
+        // =========================================================================
+        case 'codebase_list': {
+            const result = await client.listCodeRepositories();
+            if (result.error)
+                return `Error: ${result.error}`;
+            const repos = result.data?.repositories || [];
+            if (repos.length === 0)
+                return 'No code repositories indexed yet. Use codebase_register to add one.';
+            return repos.map((r) => `• ${r.name} [${r.status}] - ${r.rootPath}\n  ID: ${r.id}\n  Files: ${r.fileCount}, Chunks: ${r.chunkCount}${r.lastIndexedAt ? `, Last indexed: ${new Date(r.lastIndexedAt).toLocaleString()}` : ''}`).join('\n\n');
+        }
+        case 'codebase_register': {
+            const rootPath = args.rootPath;
+            const includePatterns = args.includePatterns;
+            const excludePatterns = args.excludePatterns;
+            const autoIndex = args.autoIndex;
+            const result = await client.createCodeRepository({
+                name: args.name,
+                rootPath,
+                projectId: args.projectId,
+                includePatterns,
+                excludePatterns,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const repo = result.data?.repository;
+            if (!autoIndex) {
+                return `✅ Repository registered: ${repo?.name}\nID: ${repo?.id}\nPath: ${repo?.rootPath}\nStatus: ${repo?.status}\n\nTo index files, use codebase_index with repositoryId: ${repo?.id}`;
+            }
+            // Auto-index: scan and upload files
+            console.error(`Auto-indexing ${repo?.name}...`);
+            const progress = await (0, localIndexer_js_1.indexLocalCodebase)(client, repo?.id, rootPath, {
+                includePatterns,
+                excludePatterns,
+                onProgress: (p) => {
+                    if (p.phase === 'uploading' && p.currentFile) {
+                        console.error(`[${p.filesUploaded}/${p.filesFound}] ${p.currentFile}`);
+                    }
+                },
+            });
+            if (progress.phase === 'error') {
+                return `✅ Repository registered: ${repo?.name}\nID: ${repo?.id}\n\n❌ Auto-indexing failed: ${progress.error}`;
+            }
+            return `✅ Repository registered and indexed: ${repo?.name}\n` +
+                `ID: ${repo?.id}\n` +
+                `Path: ${repo?.rootPath}\n` +
+                `Files uploaded: ${progress.filesUploaded}\n` +
+                `Chunks created: ${progress.chunksCreated}\n\n` +
+                `Embeddings will be generated in the background. Use codebase_search to query once ready.`;
+        }
+        case 'codebase_status': {
+            const result = await client.getCodeRepository(args.repositoryId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const repo = result.data?.repository;
+            if (!repo)
+                return 'Repository not found.';
+            return `# ${repo.name}\n` +
+                `Status: ${repo.status}\n` +
+                `Path: ${repo.rootPath}\n` +
+                `Files: ${repo.fileCount}\n` +
+                `Chunks: ${repo.chunkCount}\n` +
+                (repo.rawBlobCoverage ? `Raw blob coverage: ${repo.rawBlobCoverage}\n` : '') +
+                (repo.lastIndexedAt ? `Last indexed: ${new Date(repo.lastIndexedAt).toLocaleString()}\n` : '') +
+                (repo.errorMessage ? `Error: ${repo.errorMessage}\n` : '');
+        }
+        case 'codebase_snapshot_status': {
+            const result = await client.getLatestCodeSnapshot(args.repositoryId, {
+                branch: args.branch,
+                committedOnly: args.committedOnly,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const snapshot = result.data?.snapshot;
+            if (!snapshot)
+                return 'No snapshot found.';
+            return [
+                `Snapshot: ${snapshot.id}`,
+                `Repository: ${snapshot.repositoryId}`,
+                `Commit: ${snapshot.commitSha}`,
+                `Branch: ${snapshot.branch || '(none)'}`,
+                `Mode: ${snapshot.mode}`,
+                `Files: ${snapshot.fileCount}`,
+                `Bytes: ${snapshot.totalBytes}`,
+                `Created: ${new Date(snapshot.createdAt).toLocaleString()}`,
+            ].join('\n');
+        }
+        case 'codebase_materialize_snapshot': {
+            const result = await client.createSnapshotArchiveUrl(args.snapshotId, {
+                expiresMinutes: args.expiresMinutes,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const payload = result.data;
+            if (!payload)
+                return 'No archive response.';
+            return [
+                `Snapshot: ${payload.snapshot?.id}`,
+                `Commit: ${payload.snapshot?.commitSha}`,
+                `Archive URL: ${payload.archiveUrl}`,
+                `Expires At: ${payload.expiresAt}`,
+            ].join('\n');
+        }
+        case 'codebase_index': {
+            const repositoryId = args.repositoryId;
+            const rootPath = args.rootPath;
+            const includePatterns = args.includePatterns;
+            const excludePatterns = args.excludePatterns;
+            // First verify the repository exists
+            const repoResult = await client.getCodeRepository(repositoryId);
+            if (repoResult.error)
+                return `Error: ${repoResult.error}`;
+            if (!repoResult.data?.repository)
+                return 'Repository not found. Register it first with codebase_register.';
+            // Scan to show what will be indexed
+            const files = (0, localIndexer_js_1.scanDirectory)(rootPath, { includePatterns, excludePatterns });
+            if (files.length === 0) {
+                return `No indexable files found in ${rootPath}. Check your include/exclude patterns.`;
+            }
+            // Index the codebase
+            const progress = await (0, localIndexer_js_1.indexLocalCodebase)(client, repositoryId, rootPath, {
+                includePatterns,
+                excludePatterns,
+                onProgress: (p) => {
+                    // Log progress to stderr (stdout is MCP protocol)
+                    if (p.phase === 'uploading' && p.currentFile) {
+                        console.error(`[${p.filesUploaded}/${p.filesFound}] ${p.currentFile}`);
+                    }
+                },
+            });
+            if (progress.phase === 'error') {
+                return `❌ Indexing failed: ${progress.error}`;
+            }
+            return `✅ Indexing complete!\n` +
+                `Files scanned: ${progress.filesFound}\n` +
+                `Files uploaded: ${progress.filesUploaded}\n` +
+                `Chunks created: ${progress.chunksCreated}\n\n` +
+                `Note: Embeddings will be generated in the background. Use codebase_status to check progress.`;
+        }
+        case 'codebase_index_incremental': {
+            const repositoryId = args.repositoryId;
+            const rootPath = args.rootPath;
+            const includePatterns = args.includePatterns;
+            const excludePatterns = args.excludePatterns;
+            const includeWorkingTree = args.includeWorkingTree;
+            // First verify the repository exists
+            const repoResult = await client.getCodeRepository(repositoryId);
+            if (repoResult.error)
+                return `Error: ${repoResult.error}`;
+            if (!repoResult.data?.repository)
+                return 'Repository not found. Register it first with codebase_register.';
+            // Use incremental indexer (git-aware)
+            const progress = await (0, incrementalIndexer_js_1.indexIncrementally)(client, repositoryId, rootPath, {
+                includePatterns,
+                excludePatterns,
+                includeWorkingTree,
+                onProgress: (p) => {
+                    if (p.phase === 'uploading' && p.currentFile) {
+                        console.error(`[${p.filesUploaded}/${p.filesFound}] ${p.currentFile}`);
+                    }
+                },
+            });
+            return (0, incrementalIndexer_js_1.formatIncrementalResult)(progress);
+        }
+        case 'codebase_delete': {
+            const repositoryId = args.repositoryId;
+            // Verify the repository exists first
+            const repoCheck = await client.getCodeRepository(repositoryId);
+            if (repoCheck.error)
+                return `Error: ${repoCheck.error}`;
+            if (!repoCheck.data?.repository)
+                return 'Repository not found.';
+            const repoName = repoCheck.data.repository.name;
+            const result = await client.deleteCodeRepository(repositoryId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `✅ Deleted repository "${repoName}" (${repositoryId}) and all its indexed data (files, chunks, embeddings, snapshots).`;
+        }
+        case 'codebase_search': {
+            const result = await client.searchCode({
+                query: args.query,
+                repositoryId: args.repositoryId,
+                language: args.language,
+                symbolType: args.symbolType,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const results = result.data?.results || [];
+            if (results.length === 0)
+                return 'No matching code found.';
+            return results.map((r, i) => {
+                const header = `## ${i + 1}. ${r.filePath}:${r.startLine}-${r.endLine}`;
+                const meta = r.symbolName ? `${r.symbolType}: ${r.symbolName}` : r.symbolType || '';
+                const score = `(similarity: ${(r.similarity * 100).toFixed(1)}%)`;
+                const codeBlock = '```\n' + r.body.slice(0, 500) + (r.body.length > 500 ? '\n...' : '') + '\n```';
+                return `${header}\n${meta} ${score}\n${codeBlock}`;
+            }).join('\n\n');
+        }
+        // =========================================================================
+        // Developer Expertise Tools (Phase 4)
+        // =========================================================================
+        case 'code_who_knows': {
+            const repositoryId = args.repositoryId;
+            const codeArea = args.codeArea;
+            const limit = args.limit;
+            const result = await client.whoKnows(repositoryId, codeArea, limit);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const experts = result.data?.experts || [];
+            if (experts.length === 0) {
+                return `No experts found for "${codeArea}". Try:\n` +
+                    `1. Running \`code_compute_expertise\` to build the expertise index\n` +
+                    `2. Using a broader code area pattern (e.g., "src/*" instead of "src/services/auth.ts")`;
+            }
+            const header = `# Experts for "${codeArea}"\n`;
+            const rows = experts.map((e, i) => {
+                const score = e.totalScore.toFixed(1);
+                const lastActive = e.lastActive ? new Date(e.lastActive).toLocaleDateString() : 'unknown';
+                return `${i + 1}. **${e.authorName}** (${e.authorEmail})\n` +
+                    `   Score: ${score} | Commits: ${e.commitCount} | Lines: ${e.linesChanged}\n` +
+                    `   Last active: ${lastActive}\n` +
+                    `   Areas: ${e.areas.slice(0, 3).join(', ')}${e.areas.length > 3 ? '...' : ''}`;
+            });
+            return header + rows.join('\n\n');
+        }
+        case 'code_compute_expertise': {
+            const repositoryId = args.repositoryId;
+            const result = await client.computeExpertise(repositoryId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return `✅ Developer expertise computed!\n` +
+                `Entries updated: ${result.data?.updated || 0}\n\n` +
+                `You can now use \`code_who_knows\` to find experts for any code area.`;
+        }
+        case 'code_history': {
+            const repositoryId = args.repositoryId;
+            const path = args.path;
+            const limit = args.limit || 20;
+            const result = await client.getCommits(repositoryId, { path, limit });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const commits = result.data?.commits || [];
+            if (commits.length === 0) {
+                const pathNote = path ? ` for "${path}"` : '';
+                return `No commit history found${pathNote}. Try:\n` +
+                    `1. Running \`codebase_index_incremental\` to index the repository\n` +
+                    `2. Checking if the file path is correct`;
+            }
+            const header = path
+                ? `# Commit History for "${path}"\n`
+                : `# Recent Commits\n`;
+            const rows = commits.map((c, i) => {
+                const date = new Date(c.authorDate).toLocaleDateString();
+                const shortSha = c.sha.substring(0, 7);
+                const msgFirstLine = c.message.split('\n')[0].substring(0, 60);
+                const stats = `+${c.linesAdded}/-${c.linesDeleted}`;
+                const tasks = c.taskReferences?.length > 0
+                    ? ` (refs: ${c.taskReferences.slice(0, 3).join(', ')})`
+                    : '';
+                return `${i + 1}. \`${shortSha}\` ${date} - ${msgFirstLine}${msgFirstLine.length >= 60 ? '...' : ''}\n` +
+                    `   Author: ${c.authorName} | ${stats}${tasks}`;
+            });
+            return header + rows.join('\n\n');
+        }
+        case 'git_blame_symbol': {
+            const rootPath = args.rootPath;
+            const filePath = args.filePath;
+            const startLine = args.startLine;
+            const endLine = args.endLine;
+            const gitService = new gitService_js_1.GitService(rootPath);
+            // Check if path is a git repo
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return `Error: "${rootPath}" is not a git repository`;
+            }
+            const blameEntries = await gitService.getFileBlame(filePath);
+            if (blameEntries.length === 0) {
+                return `No blame data found for "${filePath}". The file may not exist or not be tracked by git.`;
+            }
+            // Filter by line range if specified
+            let filtered = blameEntries;
+            if (startLine || endLine) {
+                const start = startLine || 1;
+                const end = endLine || Infinity;
+                filtered = blameEntries.filter((e) => e.lineStart >= start && e.lineStart <= end);
+            }
+            if (filtered.length === 0) {
+                return `No blame data found for lines ${startLine}-${endLine} in "${filePath}"`;
+            }
+            // Aggregate by author for summary
+            const authorStats = new Map();
+            for (const entry of filtered) {
+                const key = entry.author;
+                if (!authorStats.has(key)) {
+                    authorStats.set(key, { lines: 0, commits: new Set() });
+                }
+                const stat = authorStats.get(key);
+                stat.lines += entry.lineCount;
+                stat.commits.add(entry.sha);
+            }
+            const header = `# Git Blame: ${filePath}\n`;
+            const lineRange = startLine || endLine
+                ? `Lines ${startLine || 1}-${endLine || 'end'}\n\n`
+                : '\n';
+            // Sort by lines descending
+            const sorted = Array.from(authorStats.entries())
+                .sort((a, b) => b[1].lines - a[1].lines);
+            const totalLines = filtered.reduce((s, e) => s + e.lineCount, 0);
+            const summary = sorted.map(([author, stat], i) => {
+                const pct = ((stat.lines / totalLines) * 100).toFixed(0);
+                return `${i + 1}. **${author}**: ${stat.lines} lines (${pct}%) across ${stat.commits.size} commits`;
+            }).join('\n');
+            return header + lineRange + summary;
+        }
+        case 'task_link_code': {
+            const taskId = args.taskId;
+            const repositoryId = args.repositoryId;
+            const filePath = args.filePath;
+            const commitSha = args.commitSha;
+            const notes = args.notes;
+            if (!filePath && !commitSha) {
+                return 'Error: At least one of filePath or commitSha must be provided';
+            }
+            const result = await client.linkTaskToCode(taskId, {
+                repositoryId,
+                filePath,
+                commitSha,
+                notes,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const linkTarget = filePath
+                ? `file "${filePath}"`
+                : `commit ${commitSha?.substring(0, 7)}`;
+            return `✅ Task linked to ${linkTarget}\n` +
+                `Link ID: ${result.data?.id || 'created'}\n` +
+                `Source: ${result.data?.linkSource || 'manual'}`;
+        }
+        // =========================================================================
+        // Code Memory Tools
+        // =========================================================================
+        case 'code_memory_store': {
+            const result = await client.storeCodeMemory({
+                fact: args.fact,
+                category: args.category,
+                filePath: args.filePath,
+                repositoryId: args.repositoryId,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const memory = result.data;
+            const merged = memory?.createdAt !== memory?.updatedAt;
+            return `✅ Code memory ${merged ? 'updated' : 'stored'}:\n` +
+                `ID: ${memory?.id}\n` +
+                `Category: ${memory?.factType}\n` +
+                `Fact: ${memory?.content}`;
+        }
+        case 'code_memory_search': {
+            const result = await client.searchCodeMemories({
+                query: args.query,
+                category: args.category,
+                repositoryId: args.repositoryId,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const memories = result.data?.memories || [];
+            if (memories.length === 0)
+                return 'No code memories found matching your query.';
+            return memories.map((m, i) => {
+                const category = m.factType.replace('code.', '');
+                const filePath = m.filePath ? ` (${m.filePath})` : '';
+                return `${i + 1}. [${category}] ${m.content}${filePath}`;
+            }).join('\n\n');
+        }
+        case 'code_memory_list': {
+            const result = await client.listCodeMemories({
+                repositoryId: args.repositoryId,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const memories = result.data?.memories || [];
+            if (memories.length === 0)
+                return 'No code memories stored yet.';
+            return `# Code Memories (${memories.length})\n\n` +
+                memories.map((m) => {
+                    const category = m.factType.replace('code.', '');
+                    const filePath = m.filePath ? `\n  File: ${m.filePath}` : '';
+                    return `• [${category}] ${m.content}${filePath}\n  ID: ${m.id}`;
+                }).join('\n\n');
+        }
+        case 'code_memory_delete': {
+            const result = await client.deleteCodeMemory(args.memoryId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            return result.data?.deleted
+                ? `✅ Code memory deleted: ${args.memoryId}`
+                : `Memory not found: ${args.memoryId}`;
+        }
+        // =========================================================================
+        // Document Upload
+        // =========================================================================
+        case 'upload_document': {
+            const filePath = args.filePath;
+            const content = args.content;
+            const filename = args.filename;
+            if (!filePath && !(content && filename)) {
+                return 'Error: Either filePath or both content and filename are required';
+            }
+            const result = await client.uploadDocument({
+                filePath,
+                content,
+                filename,
+                contentType: args.contentType,
+                title: args.title,
+                noteType: args.noteType,
+                projectId: args.projectId,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const note = result.data?.note;
+            return `✅ Document uploaded as note: "${note?.title}"\nType: ${note?.noteType || 'note'}\nID: ${note?.id}`;
+        }
+        // Vault / Secrets Management
+        case 'vault_list': {
+            const result = await client.listVaultEntries({
+                entryType: args.entryType,
+                category: args.category,
+                search: args.search,
+                limit: args.limit,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const entries = result.data?.entries || [];
+            if (entries.length === 0)
+                return 'No vault entries found.';
+            return entries.map((e) => `• [${e.entryType}] ${e.name} (slug: ${e.slug})${e.category ? ` [${e.category}]` : ''}${e.tags?.length ? ` tags: ${e.tags.join(', ')}` : ''}`).join('\n');
+        }
+        case 'vault_create': {
+            const result = await client.createVaultEntry({
+                name: args.name,
+                slug: args.slug,
+                entryType: args.entryType,
+                payload: args.payload,
+                description: args.description,
+                tags: args.tags,
+                category: args.category,
+                url: args.url,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const entry = result.data?.entry;
+            return `Secret stored: "${entry?.name}" (slug: ${entry?.slug}, type: ${entry?.entryType})`;
+        }
+        case 'vault_read': {
+            const result = await client.readVaultSecret(args.entryId);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const payload = result.data?.payload;
+            if (!payload)
+                return 'No payload returned.';
+            return Object.entries(payload)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join('\n');
+        }
+        case 'vault_update': {
+            const { entryId, ...updates } = args;
+            const result = await client.updateVaultEntry(entryId, {
+                name: updates.name,
+                description: updates.description,
+                tags: updates.tags,
+                category: updates.category,
+                url: updates.url,
+            });
+            if (result.error)
+                return `Error: ${result.error}`;
+            const entry = result.data?.entry;
+            return `Vault entry updated: "${entry?.name}" (slug: ${entry?.slug})`;
+        }
+        case 'vault_search': {
+            const result = await client.searchVaultEntries(args.query, args.limit);
+            if (result.error)
+                return `Error: ${result.error}`;
+            const entries = result.data?.entries || [];
+            if (entries.length === 0)
+                return `No vault entries found matching "${args.query}".`;
+            return entries.map((e) => `• [${e.entryType}] ${e.name} (slug: ${e.slug})${e.category ? ` [${e.category}]` : ''}`).join('\n');
+        }
+        default:
+            return `Unknown tool: ${name}`;
+    }
+}
+// =============================================================================
+// MCP Server Setup
+// =============================================================================
+async function main() {
+    // Validate environment
+    let client;
+    try {
+        client = (0, exfClient_js_1.createClientFromEnv)();
+    }
+    catch (err) {
+        console.error(`Configuration error: ${err instanceof Error ? err.message : err}`);
+        console.error('\nRequired environment variables:');
+        console.error('  EXF_API_URL - ExecuFunction API URL');
+        console.error('  EXF_PAT     - Personal Access Token');
+        process.exit(1);
+    }
+    const server = new index_js_1.Server({
+        name: 'execufunction',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    });
+    // Handle tool listing
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return { tools: TOOLS.filter((tool) => isToolEnabled(tool.name)) };
+    });
+    // Handle tool execution
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (!isToolEnabled(name)) {
+            return {
+                content: [{ type: 'text', text: `Error: Tool is disabled by feature flag: ${name}` }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await executeTool(client, name, args || {});
+            return {
+                content: [{ type: 'text', text: result }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return {
+                content: [{ type: 'text', text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Handle resource listing (expose project context as resources)
+    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        try {
+            const result = await client.listProjects({ includeArchived: false });
+            if (result.error || !result.data?.projects) {
+                return { resources: [] };
+            }
+            return {
+                resources: result.data.projects.map((p) => ({
+                    uri: `exf://projects/${p.id}/context`,
+                    name: `${p.emoji || '📁'} ${p.name} Context`,
+                    description: `Full context bundle for project: ${p.name}`,
+                    mimeType: 'application/json',
+                })),
+            };
+        }
+        catch {
+            return { resources: [] };
+        }
+    });
+    // Handle resource reading
+    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+        const { uri } = request.params;
+        // Parse exf://projects/{id}/context
+        const match = uri.match(/^exf:\/\/projects\/([^/]+)\/context$/);
+        if (!match) {
+            throw new Error(`Unknown resource URI: ${uri}`);
+        }
+        const projectId = match[1];
+        const result = await client.getProjectContext(projectId);
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        return {
+            contents: [{
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(result.data, null, 2),
+                }],
+        };
+    });
+    // Start server with stdio transport
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr (stdout is reserved for MCP protocol)
+    console.error('ExecuFunction MCP server started');
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map