@cleocode/mcp-server 0.86.0

package/dist/domains/tasks.js

@@ -0,0 +1,704 @@
+/**
+ * Tasks Domain Handler
+ *
+ * Implements all 30 task operations for CLEO MCP server:
+ * - Query (16): show, get, list, find, exists, next, depends, deps, stats, export, history, lint, batch-validate, manifest, tree, blockers, analyze
+ * - Mutate (13): add, create, update, complete, delete, archive, restore, unarchive, import, reorder, reparent, promote, reopen
+ *
+ * Each operation maps to corresponding CLEO CLI commands with proper
+ * parameter validation and error handling.
+ *
+ * @task T2916
+ */
+import { ManifestReader } from '../lib/manifest.js';
+/**
+ * Tasks domain handler implementation
+ */
+export class TasksHandler {
+    executor;
+    manifestReader;
+    constructor(executor, manifestPath = 'claudedocs/agent-outputs/MANIFEST.jsonl') {
+        this.executor = executor;
+        this.manifestReader = new ManifestReader(manifestPath);
+    }
+    /**
+     * Query operations (read-only)
+     */
+    async query(operation, params) {
+        const startTime = Date.now();
+        try {
+            switch (operation) {
+                case 'show':
+                    return await this.queryShow(params);
+                case 'list':
+                    return await this.queryList(params);
+                case 'find':
+                    return await this.queryFind(params);
+                case 'exists':
+                    return await this.queryExists(params);
+                case 'next':
+                    return await this.queryNext(params);
+                case 'depends':
+                    return await this.queryDepends(params);
+                case 'stats':
+                    return await this.queryStats(params);
+                case 'export':
+                    return await this.queryExport(params);
+                case 'history':
+                    return await this.queryHistory(params);
+                case 'lint':
+                    return await this.queryLint(params);
+                case 'batch-validate':
+                    return await this.queryBatchValidate(params);
+                case 'manifest':
+                    return await this.queryManifest(params);
+                case 'tree':
+                    return await this.queryTree(params);
+                case 'blockers':
+                    return await this.queryBlockers(params);
+                case 'analyze':
+                    return await this.queryAnalyze(params);
+                case 'get':
+                    return await this.queryShow(params);
+                case 'deps':
+                    return await this.queryDepends(params);
+                default:
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_OPERATION', `Unknown query operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_query', 'tasks', operation, error, startTime);
+        }
+    }
+    /**
+     * Mutate operations (write)
+     */
+    async mutate(operation, params) {
+        const startTime = Date.now();
+        try {
+            switch (operation) {
+                case 'add':
+                    return await this.mutateAdd(params);
+                case 'update':
+                    return await this.mutateUpdate(params);
+                case 'complete':
+                    return await this.mutateComplete(params);
+                case 'delete':
+                    return await this.mutateDelete(params);
+                case 'archive':
+                    return await this.mutateArchive(params);
+                case 'restore':
+                    return await this.mutateRestore(params);
+                case 'import':
+                    return await this.mutateImport(params);
+                case 'reorder':
+                    return await this.mutateReorder(params);
+                case 'reparent':
+                    return await this.mutateReparent(params);
+                case 'promote':
+                    return await this.mutatePromote(params);
+                case 'reopen':
+                    return await this.mutateReopen(params);
+                case 'create':
+                    return await this.mutateAdd(params);
+                case 'unarchive':
+                    return await this.mutateRestore(params);
+                default:
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_OPERATION', `Unknown mutate operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_mutate', 'tasks', operation, error, startTime);
+        }
+    }
+    /**
+     * Get supported operations
+     */
+    getSupportedOperations() {
+        return {
+            query: [
+                'show',
+                'get',
+                'list',
+                'find',
+                'exists',
+                'next',
+                'depends',
+                'deps',
+                'stats',
+                'export',
+                'history',
+                'lint',
+                'batch-validate',
+                'manifest',
+                'tree',
+                'blockers',
+                'analyze',
+            ],
+            mutate: [
+                'add',
+                'create',
+                'update',
+                'complete',
+                'delete',
+                'archive',
+                'restore',
+                'unarchive',
+                'import',
+                'reorder',
+                'reparent',
+                'promote',
+                'reopen',
+            ],
+        };
+    }
+    // ===== Query Operations =====
+    /**
+     * show - Get single task details
+     * CLI: cleo show <taskId>
+     */
+    async queryShow(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'show', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'show',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'show', startTime);
+    }
+    /**
+     * list - List tasks with filters
+     * CLI: cleo list [--parent <id>] [--status <status>] [--limit <n>]
+     */
+    async queryList(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.parent)
+            flags.parent = params.parent;
+        if (params?.status)
+            flags.status = params.status;
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'list',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'list', startTime);
+    }
+    /**
+     * find - Fuzzy search tasks
+     * CLI: cleo find <query> [--limit <n>]
+     */
+    async queryFind(params) {
+        const startTime = Date.now();
+        if (!params?.query) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'find', 'E_INVALID_INPUT', 'query is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'find',
+            operation: params.query,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'find', startTime);
+    }
+    /**
+     * exists - Check task existence
+     * CLI: cleo exists <taskId>
+     */
+    async queryExists(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'exists', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'exists',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'exists', startTime);
+    }
+    /**
+     * next - Get next suggested task
+     * CLI: cleo next [--epic <id>] [--count <n>]
+     */
+    async queryNext(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        if (params?.count)
+            flags.count = params.count;
+        const result = await this.executor.execute({
+            domain: 'next',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'next', startTime);
+    }
+    /**
+     * depends - Get task dependencies
+     * CLI: cleo depends <taskId> [--direction <dir>]
+     */
+    async queryDepends(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'depends', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.direction)
+            flags.direction = params.direction;
+        const result = await this.executor.execute({
+            domain: 'depends',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'depends', startTime);
+    }
+    /**
+     * stats - Task statistics
+     * CLI: cleo stats [--epic <id>]
+     */
+    async queryStats(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        const result = await this.executor.execute({
+            domain: 'stats',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'stats', startTime);
+    }
+    /**
+     * export - Export tasks to JSON
+     * CLI: cleo export [--format <fmt>] [--status <status>] [--parent <id>]
+     */
+    async queryExport(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.format)
+            flags.format = params.format;
+        if (params?.filter?.status)
+            flags.status = params.filter.status;
+        if (params?.filter?.parent)
+            flags.parent = params.filter.parent;
+        const result = await this.executor.execute({
+            domain: 'export',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'export', startTime);
+    }
+    /**
+     * history - Task history
+     * CLI: cleo history <taskId> [--limit <n>]
+     */
+    async queryHistory(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'history', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'history',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'history', startTime);
+    }
+    /**
+     * lint - Validate task data
+     * CLI: cleo lint [<taskId>]
+     */
+    async queryLint(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        const result = await this.executor.execute({
+            domain: 'lint',
+            operation: params?.taskId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'lint', startTime);
+    }
+    /**
+     * batch-validate - Validate multiple tasks
+     * CLI: cleo validate <id1> <id2> ... [--mode <mode>]
+     */
+    async queryBatchValidate(params) {
+        const startTime = Date.now();
+        if (!params?.taskIds || params.taskIds.length === 0) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'batch-validate', 'E_INVALID_INPUT', 'taskIds array is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.checkMode)
+            flags.mode = params.checkMode;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: '',
+            args: params.taskIds,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'batch-validate', startTime);
+    }
+    /**
+     * manifest - Get manifest entries for task
+     * Direct: ManifestReader (not CLI)
+     */
+    async queryManifest(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'manifest', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        try {
+            const entries = await this.manifestReader.getTaskEntries(params.taskId);
+            return {
+                _meta: {
+                    gateway: 'cleo_query',
+                    domain: 'tasks',
+                    operation: 'manifest',
+                    version: '1.0.0',
+                    timestamp: new Date().toISOString(),
+                    duration_ms: Date.now() - startTime,
+                },
+                success: true,
+                data: {
+                    taskId: params.taskId,
+                    entries,
+                    total: entries.length,
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'manifest', 'E_MANIFEST_READ_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * tree - Hierarchical task view
+     * CLI: cleo tree [rootId] [--depth N]
+     */
+    async queryTree(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.depth)
+            flags.depth = params.depth;
+        const result = await this.executor.execute({
+            domain: 'tree',
+            operation: params?.rootId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'tree', startTime);
+    }
+    /**
+     * blockers - Get blocking tasks
+     * CLI: cleo blockers <taskId>
+     */
+    async queryBlockers(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'blockers', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'blockers',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'blockers', startTime);
+    }
+    /**
+     * analyze - Triage analysis
+     * CLI: cleo analyze [epicId]
+     */
+    async queryAnalyze(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        const result = await this.executor.execute({
+            domain: 'analyze',
+            operation: params?.epicId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'analyze', startTime);
+    }
+    // ===== Mutate Operations =====
+    /**
+     * add - Create new task
+     * CLI: cleo add <title> --description <desc> [--parent <id>] [--depends <id>...] [--priority <p>] [--labels <l>...]
+     */
+    async mutateAdd(params) {
+        const startTime = Date.now();
+        if (!params?.title || !params?.description) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'add', 'E_INVALID_INPUT', 'title and description are required', startTime);
+        }
+        const flags = {
+            json: true,
+            description: params.description,
+        };
+        if (params?.parent)
+            flags.parent = params.parent;
+        if (params?.depends)
+            flags.depends = params.depends;
+        if (params?.priority)
+            flags.priority = params.priority;
+        if (params?.labels)
+            flags.labels = params.labels;
+        const result = await this.executor.execute({
+            domain: 'add',
+            operation: params.title,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'add', startTime);
+    }
+    /**
+     * update - Update task fields
+     * CLI: cleo update <taskId> [--title <t>] [--description <d>] [--status <s>] [--priority <p>] [--notes <n>]
+     */
+    async mutateUpdate(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'update', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.title)
+            flags.title = params.title;
+        if (params?.description)
+            flags.description = params.description;
+        if (params?.status)
+            flags.status = params.status;
+        if (params?.priority)
+            flags.priority = params.priority;
+        if (params?.notes)
+            flags.notes = params.notes;
+        const result = await this.executor.execute({
+            domain: 'update',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'update', startTime);
+    }
+    /**
+     * complete - Mark task done
+     * CLI: cleo complete <taskId> [--notes <n>] [--archive]
+     */
+    async mutateComplete(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'complete', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.notes)
+            flags.notes = params.notes;
+        if (params?.archive)
+            flags.archive = true;
+        const result = await this.executor.execute({
+            domain: 'complete',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'complete', startTime);
+    }
+    /**
+     * delete - Delete task
+     * CLI: cleo delete <taskId> [--force]
+     */
+    async mutateDelete(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'delete', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.force)
+            flags.force = true;
+        const result = await this.executor.execute({
+            domain: 'delete',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'delete', startTime);
+    }
+    /**
+     * archive - Archive completed tasks
+     * CLI: cleo archive [<taskId>] [--before <date>]
+     */
+    async mutateArchive(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.before)
+            flags.before = params.before;
+        const result = await this.executor.execute({
+            domain: 'archive',
+            operation: params?.taskId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'archive', startTime);
+    }
+    /**
+     * restore - Restore from archive
+     * CLI: cleo restore <taskId>
+     */
+    async mutateRestore(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'restore', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'restore',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'restore', startTime);
+    }
+    /**
+     * import - Import tasks from JSON
+     * CLI: cleo import <source> [--overwrite]
+     */
+    async mutateImport(params) {
+        const startTime = Date.now();
+        if (!params?.source) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'import', 'E_INVALID_INPUT', 'source is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.overwrite)
+            flags.overwrite = true;
+        const result = await this.executor.execute({
+            domain: 'import',
+            operation: params.source,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'import', startTime);
+    }
+    /**
+     * reorder - Change task order
+     * CLI: cleo reorder <taskId> <position>
+     */
+    async mutateReorder(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || params?.position === undefined) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reorder', 'E_INVALID_INPUT', 'taskId and position are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reorder',
+            operation: params.taskId,
+            args: [params.position],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reorder', startTime);
+    }
+    /**
+     * reparent - Change task parent
+     * CLI: cleo reparent <taskId> <newParent>
+     */
+    async mutateReparent(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.newParent) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reparent', 'E_INVALID_INPUT', 'taskId and newParent are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reparent',
+            operation: params.taskId,
+            args: [params.newParent],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reparent', startTime);
+    }
+    /**
+     * promote - Promote subtask to task
+     * CLI: cleo promote <taskId>
+     */
+    async mutatePromote(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'promote', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'promote',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'promote', startTime);
+    }
+    /**
+     * reopen - Reopen completed task
+     * CLI: cleo reopen <taskId>
+     */
+    async mutateReopen(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reopen', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reopen',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reopen', startTime);
+    }
+    // ===== Helper Methods =====
+    /**
+     * Wrap executor result in DomainResponse format
+     */
+    wrapExecutorResult(result, gateway, domain, operation, startTime) {
+        const duration_ms = Date.now() - startTime;
+        if (result.success) {
+            return {
+                _meta: {
+                    gateway,
+                    domain,
+                    operation,
+                    version: '1.0.0',
+                    timestamp: new Date().toISOString(),
+                    duration_ms,
+                },
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: {
+                gateway,
+                domain,
+                operation,
+                version: '1.0.0',
+                timestamp: new Date().toISOString(),
+                duration_ms,
+            },
+            success: false,
+            error: result.error,
+        };
+    }
+    /**
+     * Create error response
+     */
+    createErrorResponse(gateway, domain, operation, code, message, startTime) {
+        return {
+            _meta: {
+                gateway,
+                domain,
+                operation,
+                version: '1.0.0',
+                timestamp: new Date().toISOString(),
+                duration_ms: Date.now() - startTime,
+            },
+            success: false,
+            error: {
+                code,
+                message,
+            },
+        };
+    }
+    /**
+     * Handle unexpected errors
+     */
+    handleError(gateway, domain, operation, error, startTime) {
+        return this.createErrorResponse(gateway, domain, operation, 'E_INTERNAL_ERROR', error instanceof Error ? error.message : String(error), startTime);
+    }
+}
+//# sourceMappingURL=tasks.js.map