@anastops/mcp-server 0.1.0 → 1.1.0

package/dist/handlers/task-handlers.js

@@ -0,0 +1,677 @@
+/**
+ * Task management handlers
+ * Handles: task_create, task_queue, task_status, task_complete, task_list, task_execute, task_cancel, task_retry
+ */
+import { nanoid } from 'nanoid';
+import { getTask, safePersist } from './utils.js';
+export const toolDefinitions = [
+    {
+        name: 'task_create',
+        description: 'Create a task with intelligent routing. Supports agents and skills for Claude provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string' },
+                type: { type: 'string' },
+                description: { type: 'string' },
+                prompt: { type: 'string' },
+                context_files: { type: 'array', items: { type: 'string' } },
+                force_provider: { type: 'string' },
+                force_tier: { type: 'number' },
+                agent: {
+                    type: 'string',
+                    description: 'Agent name to use (e.g., orchestration-specialist). Agent defines model, tools, and skills.',
+                },
+                skills: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific skills to load (e.g., ["anastops-sessions", "anastops-tasks"])',
+                },
+            },
+            required: ['session_id', 'type', 'description', 'prompt'],
+        },
+    },
+    {
+        name: 'task_queue',
+        description: 'Queue a task for execution',
+        inputSchema: {
+            type: 'object',
+            properties: { task_id: { type: 'string' } },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'task_status',
+        description: 'Get task status',
+        inputSchema: {
+            type: 'object',
+            properties: { task_id: { type: 'string' } },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'task_complete',
+        description: 'Mark task as completed',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string' },
+                content: { type: 'string' },
+                artifacts: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['task_id', 'content'],
+        },
+    },
+    {
+        name: 'task_list',
+        description: 'List tasks in a session. Use format="table" for beautiful ASCII table output.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string' },
+                status: { type: 'string' },
+                format: {
+                    type: 'string',
+                    enum: ['table', 'json'],
+                    description: 'Output format: "table" for ASCII table, "json" for raw JSON (default)',
+                },
+            },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'task_execute',
+        description: 'Execute a pending or queued task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string', description: 'ID of the task to execute' },
+                wait: { type: 'boolean', description: 'Wait for task completion (default: true)' },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'task_cancel',
+        description: 'Cancel a pending, queued, or running task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string', description: 'ID of the task to cancel' },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'task_retry',
+        description: 'Retry a failed task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string', description: 'ID of the failed task to retry' },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'task_batch_create',
+        description: 'Create multiple tasks in a single call. ALWAYS use this instead of multiple task_create calls when creating 2+ tasks.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session to create tasks in' },
+                tasks: {
+                    type: 'array',
+                    description: 'Array of task definitions (max 50)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string' },
+                            description: { type: 'string' },
+                            prompt: { type: 'string' },
+                            context_files: { type: 'array', items: { type: 'string' } },
+                            force_provider: { type: 'string' },
+                            force_tier: { type: 'number' },
+                            agent: { type: 'string' },
+                            skills: { type: 'array', items: { type: 'string' } },
+                        },
+                        required: ['type', 'description', 'prompt'],
+                    },
+                },
+            },
+            required: ['session_id', 'tasks'],
+        },
+    },
+    {
+        name: 'task_batch_execute',
+        description: 'Execute multiple tasks in parallel. Use after task_batch_create or with existing task IDs. Much more efficient than sequential task_execute calls.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of task IDs to execute (max 50)',
+                },
+                parallel: {
+                    type: 'boolean',
+                    description: 'Execute tasks in parallel (default: true). Set false for sequential.',
+                },
+                wait: {
+                    type: 'boolean',
+                    description: 'Wait for all tasks to complete (default: true)',
+                },
+            },
+            required: ['task_ids'],
+        },
+    },
+];
+export async function handleTool(name, args, context) {
+    switch (name) {
+        case 'task_create': {
+            const taskId = nanoid(21);
+            const now = new Date();
+            const taskType = args['type'] ?? 'other';
+            // Store agent and skills in task input for execution
+            const taskInput = {
+                prompt: args['prompt'],
+                context_files: args['context_files'] ?? [],
+            };
+            if (args['agent'] !== undefined) {
+                taskInput.agent = args['agent'];
+            }
+            if (args['skills'] !== undefined) {
+                taskInput.skills = args['skills'];
+            }
+            const task = {
+                id: taskId,
+                session_id: args['session_id'],
+                agent_id: null,
+                type: taskType,
+                status: 'pending',
+                description: args['description'],
+                input: taskInput,
+                output: null,
+                error: null,
+                complexity_score: 0,
+                routing_tier: 3,
+                provider: 'claude',
+                model: 'claude-sonnet',
+                token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
+                created_at: now,
+                started_at: null,
+                completed_at: null,
+                dependencies: [],
+                priority: 5,
+                retry_count: 0,
+                max_retries: 3,
+                failover_history: [],
+                failover_enabled: args['disable_failover'] !== true,
+            };
+            // Use default routing (simplified for now)
+            const provider = args['force_provider'] ?? 'claude';
+            const model = 'claude-sonnet';
+            const tier = args['force_tier'] ?? 3;
+            task.provider = provider;
+            task.model = model;
+            task.routing_tier = tier;
+            task.complexity_score = 50;
+            context.tasks.set(taskId, task);
+            // Persist to MongoDB
+            safePersist(context.getPersistence().saveTask(task));
+            const response = {
+                task_id: task.id,
+                type: task.type,
+                routing: { tier, provider, model },
+            };
+            if (taskInput.agent !== undefined) {
+                response.agent = taskInput.agent;
+            }
+            return response;
+        }
+        case 'task_queue': {
+            const task = await getTask(args['task_id'], context);
+            if (task === null)
+                throw new Error('Task not found');
+            task.status = 'queued';
+            context.tasks.set(task.id, task);
+            safePersist(context.getPersistence().saveTask(task));
+            return { task_id: task.id, status: task.status };
+        }
+        case 'task_status': {
+            const task = await getTask(args['task_id'], context);
+            if (task === null)
+                throw new Error('Task not found');
+            return task;
+        }
+        case 'task_complete': {
+            const task = await getTask(args['task_id'], context);
+            if (task === null)
+                throw new Error('Task not found');
+            task.status = 'completed';
+            task.completed_at = new Date();
+            task.output = {
+                content: args['content'],
+                artifacts: args['artifacts'] ?? [],
+                files_modified: [],
+                metadata: {},
+            };
+            context.tasks.set(task.id, task);
+            // Persist to MongoDB
+            safePersist(context.getPersistence().saveTask(task));
+            return { task_id: task.id, status: task.status };
+        }
+        case 'task_list': {
+            // Get from in-memory cache first
+            const inMemoryTasks = [];
+            for (const [, task] of context.tasks.entries()) {
+                if (args['session_id'] === undefined ||
+                    args['session_id'] === '' ||
+                    task.session_id === args['session_id']) {
+                    inMemoryTasks.push(task);
+                }
+            }
+            // Also get from MongoDB for persistence
+            const persistedTasks = await context.getPersistence().listTasks({
+                ...(args['session_id'] !== undefined && { session_id: args['session_id'] }),
+            });
+            // Merge: in-memory takes precedence
+            const inMemoryIds = new Set(inMemoryTasks.map((t) => t.id));
+            const sessionTasks = [
+                ...inMemoryTasks,
+                ...persistedTasks.filter((t) => !inMemoryIds.has(t.id)),
+            ];
+            return {
+                count: sessionTasks.length,
+                tasks: sessionTasks.map((t) => ({
+                    id: t.id,
+                    type: t.type,
+                    status: t.status,
+                    description: t.description.slice(0, 50),
+                })),
+            };
+        }
+        case 'task_execute': {
+            const taskId = args['task_id'];
+            const wait = args['wait'] ?? true;
+            const task = await getTask(taskId, context);
+            if (task === null) {
+                throw new Error(`Task not found: ${taskId}`);
+            }
+            if (task.status !== 'pending' && task.status !== 'queued') {
+                return {
+                    task_id: taskId,
+                    status: task.status,
+                    error: `Task cannot be executed - current status is '${task.status}'`,
+                };
+            }
+            // Update task status to running
+            task.status = 'running';
+            task.started_at = new Date();
+            context.tasks.set(taskId, task);
+            // Persist running status
+            safePersist(context.getPersistence().saveTask(task));
+            try {
+                // Get adapter for the routed provider
+                const adapter = context.registry.get(task.provider);
+                if (adapter === undefined) {
+                    throw new Error(`Provider adapter not found: ${task.provider}`);
+                }
+                // Execute task with adapter
+                // Use workspace root from environment or cwd
+                const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
+                // Build request with optional agent and skills
+                const taskInput = task.input;
+                const executeRequest = {
+                    model: task.model,
+                    prompt: taskInput?.prompt ?? task.description,
+                    working_dir: workingDir,
+                };
+                // Pass agent and skills if specified
+                if (taskInput?.agent !== undefined) {
+                    executeRequest.agent = taskInput.agent;
+                }
+                if (taskInput?.skills !== undefined) {
+                    executeRequest.skills = taskInput.skills;
+                }
+                // Execute request without onProgress (not supported in ExecuteOptions)
+                const response = await adapter.execute(executeRequest, {
+                    workingDir,
+                });
+                // Update task with result
+                task.status = 'completed';
+                task.completed_at = new Date();
+                task.token_usage = response.usage ?? task.token_usage;
+                task.output = {
+                    content: response.content,
+                    artifacts: [],
+                    files_modified: [],
+                    metadata: { usage: response.usage },
+                };
+                context.tasks.set(taskId, task);
+                // Persist completed task
+                safePersist(context.getPersistence().saveTask(task));
+                // Update session metadata via sessionManager
+                if (context.sessionManager.exists(task.session_id)) {
+                    const session = context.sessionManager.getSession(task.session_id);
+                    session.metadata = session.metadata ?? {
+                        total_tokens: 0,
+                        total_cost: 0,
+                        agents_used: [],
+                        files_affected: [],
+                        tasks_completed: 0,
+                        tasks_failed: 0,
+                    };
+                    session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
+                    session.metadata.total_tokens =
+                        (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
+                    session.metadata.total_cost =
+                        (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
+                    session.updated_at = new Date();
+                    safePersist(context.getPersistence().saveSession(session));
+                }
+                return {
+                    task_id: taskId,
+                    status: 'completed',
+                    result: response,
+                    waited: wait,
+                };
+            }
+            catch (error) {
+                task.status = 'failed';
+                task.completed_at = new Date();
+                task.error = error instanceof Error ? error.message : String(error);
+                context.tasks.set(taskId, task);
+                // Persist failed task
+                safePersist(context.getPersistence().saveTask(task));
+                // Update session metadata for failure via sessionManager
+                if (context.sessionManager.exists(task.session_id)) {
+                    const session = context.sessionManager.getSession(task.session_id);
+                    session.metadata = session.metadata ?? {
+                        total_tokens: 0,
+                        total_cost: 0,
+                        agents_used: [],
+                        files_affected: [],
+                        tasks_completed: 0,
+                        tasks_failed: 0,
+                    };
+                    session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
+                    session.updated_at = new Date();
+                    safePersist(context.getPersistence().saveSession(session));
+                }
+                throw error;
+            }
+        }
+        case 'task_cancel': {
+            const taskId = args['task_id'];
+            const task = await getTask(taskId, context);
+            if (task === null) {
+                throw new Error(`Task not found: ${taskId}`);
+            }
+            // Check if task is cancelable (pending, queued, or running)
+            const cancelableStatuses = ['pending', 'queued', 'running'];
+            if (!cancelableStatuses.includes(task.status)) {
+                return {
+                    task_id: taskId,
+                    status: task.status,
+                    cancelled: false,
+                    error: `Task cannot be cancelled - current status is '${task.status}'`,
+                };
+            }
+            // Cancel the task
+            task.status = 'cancelled';
+            task.completed_at = new Date();
+            context.tasks.set(taskId, task);
+            // Persist to MongoDB
+            safePersist(context.getPersistence().saveTask(task));
+            return {
+                task_id: taskId,
+                status: task.status,
+                cancelled: true,
+            };
+        }
+        case 'task_retry': {
+            const taskId = args['task_id'];
+            const task = await getTask(taskId, context);
+            if (task === null) {
+                throw new Error(`Task not found: ${taskId}`);
+            }
+            // Check if task is in failed status
+            if (task.status !== 'failed') {
+                return {
+                    task_id: taskId,
+                    status: task.status,
+                    retried: false,
+                    error: `Task cannot be retried - current status is '${task.status}' (must be 'failed')`,
+                };
+            }
+            // Check if max retries exceeded
+            if (task.retry_count >= task.max_retries) {
+                return {
+                    task_id: taskId,
+                    status: task.status,
+                    retried: false,
+                    error: `Task has exceeded max retries (${task.max_retries})`,
+                    retry_count: task.retry_count,
+                };
+            }
+            // Retry the task
+            task.status = 'pending';
+            task.retry_count += 1;
+            task.error = null;
+            task.started_at = null;
+            task.completed_at = null;
+            context.tasks.set(taskId, task);
+            // Persist to MongoDB
+            safePersist(context.getPersistence().saveTask(task));
+            return {
+                task_id: taskId,
+                status: task.status,
+                retried: true,
+                retry_count: task.retry_count,
+                max_retries: task.max_retries,
+            };
+        }
+        case 'task_batch_create': {
+            const sessionId = args['session_id'];
+            const taskDefs = args['tasks'];
+            const createdTasks = [];
+            const now = new Date();
+            for (const def of taskDefs) {
+                const taskId = nanoid(21);
+                const taskType = def.type ?? 'other';
+                // Store agent and skills in task input for execution
+                const taskInput = {
+                    prompt: def.prompt,
+                    context_files: def.context_files ?? [],
+                };
+                if (def.agent !== undefined) {
+                    taskInput.agent = def.agent;
+                }
+                if (def.skills !== undefined) {
+                    taskInput.skills = def.skills;
+                }
+                const provider = def.force_provider ?? 'claude';
+                const model = 'claude-sonnet';
+                const tier = def.force_tier ?? 3;
+                const task = {
+                    id: taskId,
+                    session_id: sessionId,
+                    agent_id: null,
+                    type: taskType,
+                    status: 'pending',
+                    description: def.description,
+                    input: taskInput,
+                    output: null,
+                    error: null,
+                    complexity_score: 50,
+                    routing_tier: tier,
+                    provider: provider,
+                    model: model,
+                    token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
+                    created_at: now,
+                    started_at: null,
+                    completed_at: null,
+                    dependencies: [],
+                    priority: 5,
+                    retry_count: 0,
+                    max_retries: 3,
+                    failover_history: [],
+                    failover_enabled: true,
+                };
+                context.tasks.set(taskId, task);
+                // Persist to MongoDB
+                safePersist(context.getPersistence().saveTask(task));
+                const createdTask = {
+                    task_id: taskId,
+                    type: task.type,
+                    routing: { tier, provider, model },
+                };
+                if (taskInput.agent !== undefined) {
+                    createdTask.agent = taskInput.agent;
+                }
+                createdTasks.push(createdTask);
+            }
+            return {
+                created: createdTasks.length,
+                task_ids: createdTasks.map((t) => t.task_id),
+                tasks: createdTasks,
+            };
+        }
+        case 'task_batch_execute': {
+            const taskIds = args['task_ids'];
+            const parallel = args['parallel'] ?? true;
+            const wait = args['wait'] ?? true;
+            // Helper to execute a single task and return result
+            const executeOne = async (taskId) => {
+                const task = await getTask(taskId, context);
+                if (task === null) {
+                    return { task_id: taskId, status: 'not_found', error: `Task not found: ${taskId}` };
+                }
+                if (task.status !== 'pending' && task.status !== 'queued') {
+                    return {
+                        task_id: taskId,
+                        status: task.status,
+                        error: `Task cannot be executed - current status is '${task.status}'`,
+                    };
+                }
+                // Update task status to running
+                task.status = 'running';
+                task.started_at = new Date();
+                context.tasks.set(taskId, task);
+                safePersist(context.getPersistence().saveTask(task));
+                try {
+                    // Get adapter for the routed provider
+                    const adapter = context.registry.get(task.provider);
+                    if (adapter === undefined) {
+                        throw new Error(`Provider adapter not found: ${task.provider}`);
+                    }
+                    const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
+                    const taskInput = task.input;
+                    const executeRequest = {
+                        model: task.model,
+                        prompt: taskInput?.prompt ?? task.description,
+                        working_dir: workingDir,
+                    };
+                    if (taskInput?.agent !== undefined) {
+                        executeRequest.agent = taskInput.agent;
+                    }
+                    if (taskInput?.skills !== undefined) {
+                        executeRequest.skills = taskInput.skills;
+                    }
+                    const response = await adapter.execute(executeRequest, { workingDir });
+                    // Update task with result
+                    task.status = 'completed';
+                    task.completed_at = new Date();
+                    task.token_usage = response.usage ?? task.token_usage;
+                    task.output = {
+                        content: response.content,
+                        artifacts: [],
+                        files_modified: [],
+                        metadata: { usage: response.usage },
+                    };
+                    context.tasks.set(taskId, task);
+                    safePersist(context.getPersistence().saveTask(task));
+                    // Update session metadata
+                    if (context.sessionManager.exists(task.session_id)) {
+                        const session = context.sessionManager.getSession(task.session_id);
+                        session.metadata = session.metadata ?? {
+                            total_tokens: 0,
+                            total_cost: 0,
+                            agents_used: [],
+                            files_affected: [],
+                            tasks_completed: 0,
+                            tasks_failed: 0,
+                        };
+                        session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
+                        session.metadata.total_tokens =
+                            (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
+                        session.metadata.total_cost =
+                            (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
+                        session.updated_at = new Date();
+                        safePersist(context.getPersistence().saveSession(session));
+                    }
+                    return {
+                        task_id: taskId,
+                        status: 'completed',
+                        result: { content: response.content, usage: response.usage },
+                    };
+                }
+                catch (error) {
+                    task.status = 'failed';
+                    task.completed_at = new Date();
+                    task.error = error instanceof Error ? error.message : String(error);
+                    context.tasks.set(taskId, task);
+                    safePersist(context.getPersistence().saveTask(task));
+                    // Update session metadata for failure
+                    if (context.sessionManager.exists(task.session_id)) {
+                        const session = context.sessionManager.getSession(task.session_id);
+                        session.metadata = session.metadata ?? {
+                            total_tokens: 0,
+                            total_cost: 0,
+                            agents_used: [],
+                            files_affected: [],
+                            tasks_completed: 0,
+                            tasks_failed: 0,
+                        };
+                        session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
+                        session.updated_at = new Date();
+                        safePersist(context.getPersistence().saveSession(session));
+                    }
+                    return {
+                        task_id: taskId,
+                        status: 'failed',
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            };
+            // Execute tasks either in parallel or sequentially
+            let results;
+            if (parallel) {
+                results = await Promise.all(taskIds.map(executeOne));
+            }
+            else {
+                results = [];
+                for (const taskId of taskIds) {
+                    results.push(await executeOne(taskId));
+                }
+            }
+            // Calculate summary
+            const summary = {
+                completed: results.filter((r) => r.status === 'completed').length,
+                failed: results.filter((r) => r.status === 'failed').length,
+                skipped: results.filter((r) => r.status !== 'completed' && r.status !== 'failed').length,
+            };
+            return {
+                executed: results.length,
+                parallel,
+                waited: wait,
+                results,
+                summary,
+            };
+        }
+        default:
+            throw new Error(`Unknown task tool: ${name}`);
+    }
+}
+//# sourceMappingURL=task-handlers.js.map