@krr2020/taskflow-mcp-server 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { StateMachine, ConfigLoader, GitManager } from "@krr2020/taskflow-core";
+// Initialize Core Components
+const configLoader = new ConfigLoader();
+const gitManager = new GitManager();
+const stateMachine = new StateMachine(configLoader, gitManager);
+// Initialize MCP Server
+const server = new Server({
+    name: "taskflow-mcp-server",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Tool Definitions
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "start_task",
+                description: "Start a new task, checking out the correct story branch and entering PLANNING mode.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "The ID of the task to start (e.g., '1.2.3')",
+                        },
+                        storyId: {
+                            type: "string",
+                            description: "The Story ID this task belongs to (e.g., '15')",
+                        },
+                        slug: {
+                            type: "string",
+                            description: "Short slug for the story (e.g., 'user-auth')",
+                        },
+                    },
+                    required: ["taskId", "storyId", "slug"],
+                },
+            },
+            {
+                name: "approve_plan",
+                description: "Approve the implementation plan and switch to EXECUTION mode.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_status",
+                description: "Get the current state machine status and active task.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "generate_prd",
+                description: "Generate a PRD template based on project context.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        requirements: { type: "string" }
+                    },
+                },
+            },
+            {
+                name: "generate_tasks",
+                description: "Generate tasks from a PRD.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prdContent: { type: "string" }
+                    },
+                },
+            },
+            {
+                name: "run_checks",
+                description: "Run project validations and enter VERIFICATION state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "submit_task",
+                description: "Submit the current task and complete the workflow.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+// Tool Execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "start_task": {
+                const schema = z.object({
+                    taskId: z.string(),
+                    storyId: z.string(),
+                    slug: z.string(),
+                });
+                const { taskId, storyId, slug } = schema.parse(args);
+                await stateMachine.startTask(taskId, storyId, slug);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Task ${taskId} started on branch story/S${storyId}-${slug}. State is now PLANNING.`,
+                        },
+                    ],
+                };
+            }
+            case "approve_plan": {
+                stateMachine.approvePlan();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Plan approved. State is now EXECUTION. You may now write code.",
+                        },
+                    ],
+                };
+            }
+            case "get_status": {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                state: stateMachine.getState(),
+                                activeTask: stateMachine.getActiveTask(),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "generate_prd": {
+                const template = `# Project Requirements Document
+## 1. Objective
+[Describe the goal]
+
+## 2. Scope
+- [ ] In Scope
+- [ ] Out of Scope
+
+## 3. Technical Requirements
+- Language: [e.g., TypeScript]
+- Framework: [e.g., React]
+
+## 4. User Stories
+- Story 1: [Description]
+`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: template,
+                        },
+                    ],
+                };
+            }
+            case "generate_tasks": {
+                // In a real implementation, this would parse the PRD.
+                // For prototype, we return the schema structure.
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Please provide the tasks in the following JSON format matching the TaskSchema:\n" +
+                                JSON.stringify({
+                                    id: "1.0",
+                                    title: "Example Task",
+                                    status: "todo",
+                                    subtasks: [{ id: "1.1", title: "Subtask 1" }]
+                                }, null, 2)
+                        },
+                    ],
+                };
+            }
+            case "run_checks": {
+                stateMachine.startVerification();
+                // TODO: Actually run the validation commands from config
+                return {
+                    content: [{ type: "text", text: "Verification phase started. Running checks... [MOCK PASSED]" }],
+                };
+            }
+            case "submit_task": {
+                stateMachine.completeTask();
+                return {
+                    content: [{ type: "text", text: "Task submitted and completed. State is now IDLE." }],
+                };
+            }
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${error.message}`);
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error executing ${name}: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start Server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Taskflow MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@krr2020/taskflow-mcp-server",
+  "version": "0.1.0-beta.1",
+  "description": "MCP Server for Taskflow 2.0",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "taskflow-mcp": "./dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "zod": "^3.22.4",
+    "@krr2020/taskflow-core": "0.1.0-beta.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.11.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  }
+}

package/src/index.ts

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ErrorCode,
+    McpError,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { StateMachine, ConfigLoader, GitManager } from "@krr2020/taskflow-core";
+
+// Initialize Core Components
+const configLoader = new ConfigLoader();
+const gitManager = new GitManager();
+const stateMachine = new StateMachine(configLoader, gitManager);
+
+// Initialize MCP Server
+const server = new Server(
+    {
+        name: "taskflow-mcp-server",
+        version: "0.1.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// Tool Definitions
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "start_task",
+                description: "Start a new task, checking out the correct story branch and entering PLANNING mode.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "The ID of the task to start (e.g., '1.2.3')",
+                        },
+                        storyId: {
+                            type: "string",
+                            description: "The Story ID this task belongs to (e.g., '15')",
+                        },
+                        slug: {
+                            type: "string",
+                            description: "Short slug for the story (e.g., 'user-auth')",
+                        },
+                    },
+                    required: ["taskId", "storyId", "slug"],
+                },
+            },
+            {
+                name: "approve_plan",
+                description: "Approve the implementation plan and switch to EXECUTION mode.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_status",
+                description: "Get the current state machine status and active task.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "generate_prd",
+                description: "Generate a PRD template based on project context.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        requirements: { type: "string" }
+                    },
+                },
+            },
+            {
+                name: "generate_tasks",
+                description: "Generate tasks from a PRD.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prdContent: { type: "string" }
+                    },
+                },
+            },
+            {
+                name: "run_checks",
+                description: "Run project validations and enter VERIFICATION state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "submit_task",
+                description: "Submit the current task and complete the workflow.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+
+// Tool Execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case "start_task": {
+                const schema = z.object({
+                    taskId: z.string(),
+                    storyId: z.string(),
+                    slug: z.string(),
+                });
+                const { taskId, storyId, slug } = schema.parse(args);
+
+                await stateMachine.startTask(taskId, storyId, slug);
+
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Task ${taskId} started on branch story/S${storyId}-${slug}. State is now PLANNING.`,
+                        },
+                    ],
+                };
+            }
+
+            case "approve_plan": {
+                stateMachine.approvePlan();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Plan approved. State is now EXECUTION. You may now write code.",
+                        },
+                    ],
+                };
+            }
+
+            case "get_status": {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                state: stateMachine.getState(),
+                                activeTask: stateMachine.getActiveTask(),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+
+            case "generate_prd": {
+                const template = `# Project Requirements Document
+## 1. Objective
+[Describe the goal]
+
+## 2. Scope
+- [ ] In Scope
+- [ ] Out of Scope
+
+## 3. Technical Requirements
+- Language: [e.g., TypeScript]
+- Framework: [e.g., React]
+
+## 4. User Stories
+- Story 1: [Description]
+`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: template,
+                        },
+                    ],
+                };
+            }
+
+            case "generate_tasks": {
+                // In a real implementation, this would parse the PRD.
+                // For prototype, we return the schema structure.
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Please provide the tasks in the following JSON format matching the TaskSchema:\n" +
+                                JSON.stringify({
+                                    id: "1.0",
+                                    title: "Example Task",
+                                    status: "todo",
+                                    subtasks: [{ id: "1.1", title: "Subtask 1" }]
+                                }, null, 2)
+                        },
+                    ],
+                };
+            }
+
+            case "run_checks": {
+                stateMachine.startVerification();
+                // TODO: Actually run the validation commands from config
+                return {
+                    content: [{ type: "text", text: "Verification phase started. Running checks... [MOCK PASSED]" }],
+                };
+            }
+
+            case "submit_task": {
+                stateMachine.completeTask();
+                return {
+                    content: [{ type: "text", text: "Task submitted and completed. State is now IDLE." }],
+                };
+            }
+
+            default:
+                throw new McpError(
+                    ErrorCode.MethodNotFound,
+                    `Unknown tool: ${name}`
+                );
+        }
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new McpError(
+                ErrorCode.InvalidParams,
+                `Invalid arguments: ${error.message}`
+            );
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error executing ${name}: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+
+// Start Server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Taskflow MCP Server running on stdio");
+}
+
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}