@claudetools/tools 0.1.0

package/dist/tools.js

@@ -0,0 +1,748 @@
+// =============================================================================
+// MCP Tool Definitions  
+// =============================================================================
+import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+export function registerToolDefinitions(server) {
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'memory_search',
+                description: 'Search the memory system for relevant facts and entities based on a query. Use this to recall past conversations, facts, and relationships. NOTE: Context is now automatically injected - use this only for explicit searches.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The search query to find relevant memories',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 10)',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'memory_explain',
+                description: 'Explain what memory context was automatically injected in the last response. Use this when you want to understand what memories are being used.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'memory_inject',
+                description: 'Manually trigger context injection for a specific query. Normally context is injected automatically, but use this for explicit control.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The query to inject context for',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'memory_add',
+                description: 'Add new memories from conversation messages. The system will automatically extract entities and relationships.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        session_id: {
+                            type: 'string',
+                            description: 'Session identifier for grouping related messages',
+                        },
+                        messages: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    role: { type: 'string', enum: ['user', 'assistant', 'system'] },
+                                    content: { type: 'string' },
+                                },
+                                required: ['role', 'content'],
+                            },
+                            description: 'Array of messages to store',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                        extract_facts: {
+                            type: 'boolean',
+                            description: 'Whether to extract facts and entities (default: true)',
+                        },
+                    },
+                    required: ['session_id', 'messages'],
+                },
+            },
+            {
+                name: 'memory_store_fact',
+                description: 'Store a specific fact as a relationship between two entities. Use this when you learn something concrete about entities.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        entity1: {
+                            type: 'string',
+                            description: 'The first entity (subject)',
+                        },
+                        relationship: {
+                            type: 'string',
+                            description: 'The relationship type (e.g., WORKS_FOR, USES, LIKES)',
+                        },
+                        entity2: {
+                            type: 'string',
+                            description: 'The second entity (object)',
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'Description or context of the fact',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                    required: ['entity1', 'relationship', 'entity2', 'context'],
+                },
+            },
+            {
+                name: 'memory_get_context',
+                description: 'Get the current memory context, optionally filtered by a query. Returns recent facts and entities.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Optional query to filter context',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'memory_summary',
+                description: 'Get a summary of the memory system state including counts of entities, facts, and episodes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'memory_list_entities',
+                description: 'List all known entities in the memory system.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'query_dependencies',
+                description: 'Query function call dependencies from the code graph. Find what functions a given function calls (forward) or what functions call it (reverse). Week 4: Dependency Query Tool.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        function_name: {
+                            type: 'string',
+                            description: 'The function name to query dependencies for',
+                        },
+                        direction: {
+                            type: 'string',
+                            enum: ['forward', 'reverse', 'both'],
+                            description: 'Query direction: "forward" = what does X call, "reverse" = what calls X, "both" = both directions',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                        depth: {
+                            type: 'number',
+                            description: 'Maximum depth to traverse (default: 1, max: 5)',
+                        },
+                    },
+                    required: ['function_name', 'direction'],
+                },
+            },
+            {
+                name: 'analyze_impact',
+                description: 'Analyze the impact of changing a function by traversing its call graph. Shows which functions would be affected by changes. Week 5: Impact Analysis Tool.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        function_name: {
+                            type: 'string',
+                            description: 'The function name to analyze impact for',
+                        },
+                        analysis_type: {
+                            type: 'string',
+                            enum: ['change', 'delete', 'signature'],
+                            description: 'Type of change: "change" = modification, "delete" = removal, "signature" = API change',
+                        },
+                        max_depth: {
+                            type: 'number',
+                            description: 'Maximum depth to traverse call graph (default: 3, max: 5)',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                    required: ['function_name'],
+                },
+            },
+            {
+                name: 'check_patterns',
+                description: 'Check code for security and performance anti-patterns. Returns warnings and recommendations. Week 6: Pattern Detection Tool.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'The code snippet to analyze for patterns',
+                        },
+                        file_path: {
+                            type: 'string',
+                            description: 'Optional file path for context (helps with language detection)',
+                        },
+                        check_types: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['security', 'performance', 'all'] },
+                            description: 'Types of patterns to check for (default: all)',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                    required: ['code'],
+                },
+            },
+            // =========================================================================
+            // TASK MANAGEMENT TOOLS
+            // =========================================================================
+            {
+                name: 'task_plan',
+                description: 'PROACTIVE: When user describes work to be done, automatically create an epic with tasks. Use this whenever the user asks for a feature, fix, or any multi-step work. Creates the full task hierarchy and returns a plan.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        goal: {
+                            type: 'string',
+                            description: 'What the user wants to accomplish (their request in natural language)',
+                        },
+                        epic_title: {
+                            type: 'string',
+                            description: 'Title for the epic (short, descriptive)',
+                        },
+                        tasks: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    title: { type: 'string' },
+                                    description: { type: 'string' },
+                                    effort: { type: 'string', enum: ['xs', 's', 'm', 'l', 'xl'] },
+                                },
+                                required: ['title'],
+                            },
+                            description: 'List of tasks to create under the epic',
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['critical', 'high', 'medium', 'low'],
+                            description: 'Priority level (default: medium)',
+                        },
+                    },
+                    required: ['goal', 'epic_title', 'tasks'],
+                },
+            },
+            {
+                name: 'task_plan_draft',
+                description: 'INTERNAL: Returns a structured plan draft WITHOUT committing to database. Use this to present plans for user approval. Only call task_plan after user explicitly approves.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        goal: {
+                            type: 'string',
+                            description: 'What the user wants to accomplish',
+                        },
+                        epic_title: {
+                            type: 'string',
+                            description: 'Title for the epic',
+                        },
+                        approach: {
+                            type: 'string',
+                            description: 'High-level strategy and rationale',
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'Relevant codebase context discovered during research',
+                        },
+                        tasks: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    title: { type: 'string' },
+                                    description: { type: 'string' },
+                                    effort: { type: 'string', enum: ['xs', 's', 'm', 'l', 'xl'] },
+                                    acceptance_criteria: { type: 'array', items: { type: 'string' } },
+                                },
+                                required: ['title'],
+                            },
+                            description: 'List of tasks with details',
+                        },
+                        risks: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Potential risks or considerations',
+                        },
+                        questions: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Questions needing clarification before starting',
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['critical', 'high', 'medium', 'low'],
+                        },
+                    },
+                    required: ['goal', 'epic_title', 'tasks'],
+                },
+            },
+            {
+                name: 'task_start',
+                description: 'PROACTIVE: When starting work on a task, claim it and get all context. Use this before beginning any task work.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to start working on',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier (default: claude-code)',
+                        },
+                    },
+                    required: ['task_id'],
+                },
+            },
+            {
+                name: 'task_complete',
+                description: 'PROACTIVE: When finished with a task, mark it complete with a summary of work done. Use this after completing any task.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID that was completed',
+                        },
+                        summary: {
+                            type: 'string',
+                            description: 'Summary of what was accomplished',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier (default: claude-code)',
+                        },
+                    },
+                    required: ['task_id', 'summary'],
+                },
+            },
+            {
+                name: 'task_create',
+                description: 'Create a new epic, task, or subtask. Use task_plan instead for creating full work plans.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        type: {
+                            type: 'string',
+                            enum: ['epic', 'task', 'subtask'],
+                            description: 'Type of task: epic (large feature), task (work item), subtask (sub-item)',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Title of the task',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Detailed description of the task',
+                        },
+                        parent_id: {
+                            type: 'string',
+                            description: 'Parent task ID (required for tasks under epics, or subtasks under tasks)',
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['critical', 'high', 'medium', 'low'],
+                            description: 'Priority level (default: medium)',
+                        },
+                        acceptance_criteria: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'List of acceptance criteria for the task',
+                        },
+                        estimated_effort: {
+                            type: 'string',
+                            enum: ['xs', 's', 'm', 'l', 'xl'],
+                            description: 'Estimated effort: xs (< 1hr), s (1-4hr), m (half day), l (full day), xl (multi-day)',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for categorization',
+                        },
+                        blocked_by: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Task IDs that block this task',
+                        },
+                    },
+                    required: ['type', 'title'],
+                },
+            },
+            {
+                name: 'task_list',
+                description: 'List tasks with optional filters. Use to see what work is planned, in progress, or completed.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        type: {
+                            type: 'string',
+                            enum: ['epic', 'task', 'subtask'],
+                            description: 'Filter by task type',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['backlog', 'ready', 'in_progress', 'blocked', 'review', 'done', 'cancelled'],
+                            description: 'Filter by status',
+                        },
+                        parent_id: {
+                            type: 'string',
+                            description: 'Filter by parent task ID',
+                        },
+                        assigned_to: {
+                            type: 'string',
+                            description: 'Filter by assigned agent ID',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 50)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'task_get',
+                description: 'Get details of a specific task, optionally with full context (subtasks, parent, attached context).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to retrieve',
+                        },
+                        full: {
+                            type: 'boolean',
+                            description: 'Include full context (subtasks, parent, attached context)',
+                        },
+                    },
+                    required: ['task_id'],
+                },
+            },
+            {
+                name: 'task_claim',
+                description: 'Claim a task for working on it. Creates a lock preventing other agents from working on it.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to claim',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier',
+                        },
+                        lock_duration_minutes: {
+                            type: 'number',
+                            description: 'Lock duration in minutes (default: 30)',
+                        },
+                    },
+                    required: ['task_id', 'agent_id'],
+                },
+            },
+            {
+                name: 'task_release',
+                description: 'Release a claimed task. Use when done working or need to step away.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to release',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier',
+                        },
+                        new_status: {
+                            type: 'string',
+                            enum: ['backlog', 'ready', 'in_progress', 'blocked', 'review', 'done'],
+                            description: 'New status for the task',
+                        },
+                        work_log: {
+                            type: 'string',
+                            description: 'Summary of work done during this claim',
+                        },
+                    },
+                    required: ['task_id', 'agent_id'],
+                },
+            },
+            {
+                name: 'task_update_status',
+                description: 'Update the status of a task without claiming it.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to update',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['backlog', 'ready', 'in_progress', 'blocked', 'review', 'done', 'cancelled'],
+                            description: 'New status',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier (optional)',
+                        },
+                    },
+                    required: ['task_id', 'status'],
+                },
+            },
+            {
+                name: 'task_add_context',
+                description: 'Add context to a task (code snippets, decisions, patterns, work logs, references).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to add context to',
+                        },
+                        context_type: {
+                            type: 'string',
+                            enum: ['code', 'memory', 'pattern', 'decision', 'reference', 'work_log'],
+                            description: 'Type of context being added',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'The context content',
+                        },
+                        added_by: {
+                            type: 'string',
+                            description: 'Your agent identifier',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'Source reference (e.g., file path, URL)',
+                        },
+                    },
+                    required: ['task_id', 'context_type', 'content', 'added_by'],
+                },
+            },
+            {
+                name: 'task_summary',
+                description: 'Get a summary of tasks for the current project (counts by status, by type, active agents).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'task_heartbeat',
+                description: 'Extend the lock on a claimed task. Use to prevent timeout while still working.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to extend lock for',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Your agent identifier',
+                        },
+                        extend_minutes: {
+                            type: 'number',
+                            description: 'Minutes to extend the lock (default: 30)',
+                        },
+                    },
+                    required: ['task_id', 'agent_id'],
+                },
+            },
+            // =========================================================================
+            // ORCHESTRATION TOOLS
+            // =========================================================================
+            {
+                name: 'task_dispatch',
+                description: 'ORCHESTRATION: Get all tasks ready for parallel execution. Returns tasks that are unblocked, matched to expert workers, with full context. Use this to spawn worker agents.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        epic_id: {
+                            type: 'string',
+                            description: 'Epic ID to dispatch tasks from (optional - if not provided, gets all ready tasks)',
+                        },
+                        max_parallel: {
+                            type: 'number',
+                            description: 'Maximum number of tasks to dispatch at once (default: 5)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'task_execute',
+                description: 'ORCHESTRATION: Get complete execution context for a worker agent. Returns task details, parent context, expert prompt, and all attached context.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task_id: {
+                            type: 'string',
+                            description: 'The task ID to get execution context for',
+                        },
+                    },
+                    required: ['task_id'],
+                },
+            },
+            {
+                name: 'task_resolve_dependencies',
+                description: 'ORCHESTRATION: Check which tasks are now unblocked after a task completion. Returns newly ready tasks that can be dispatched.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        completed_task_id: {
+                            type: 'string',
+                            description: 'The task ID that was just completed',
+                        },
+                        epic_id: {
+                            type: 'string',
+                            description: 'Epic ID to scope the dependency check',
+                        },
+                    },
+                    required: ['completed_task_id'],
+                },
+            },
+            {
+                name: 'task_list_workers',
+                description: 'List all available expert worker types and their capabilities.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            // =========================================================================
+            // CODEBASE MAPPING TOOLS
+            // =========================================================================
+            {
+                name: 'codebase_map',
+                description: 'Get a compact markdown map of the codebase for quick navigation. Shows entry points, directories, key files, and important symbols. Use this FIRST when exploring an unfamiliar codebase.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses current project if not specified)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'codebase_find',
+                description: 'Search the codebase for symbols, files, or directories by name or pattern. Much faster than grep for finding where things are defined.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query (symbol name, file name, or pattern)',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['symbol', 'file', 'directory', 'all'],
+                            description: 'Type of thing to search for (default: all)',
+                        },
+                        exported: {
+                            type: 'boolean',
+                            description: 'If searching symbols, only return exported ones',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum results to return (default: 20)',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'codebase_context',
+                description: 'Get detailed context for a specific file or symbol, including dependencies, dependents, and call graph connections.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        target: {
+                            type: 'string',
+                            description: 'File path or symbol name to get context for',
+                        },
+                    },
+                    required: ['target'],
+                },
+            },
+            {
+                name: 'codebase_callgraph',
+                description: 'Get the call graph for a function - what it calls and what calls it. Useful for understanding impact of changes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        function_name: {
+                            type: 'string',
+                            description: 'Function name to get call graph for',
+                        },
+                        depth: {
+                            type: 'number',
+                            description: 'How many levels deep to traverse (default: 1, max: 3)',
+                        },
+                    },
+                    required: ['function_name'],
+                },
+            },
+        ],
+    }));
+}