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

package/dist/index.js

@@ -3,11 +3,13 @@ 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);
+import process from "node:process";
+// Import all commands from core package
+import { InitCommand, StatusCommand, NextCommand, StartCommand, CheckCommand, CommitCommand, ResumeCommand, SkipCommand, PrdCreateCommand, PrdGenerateArchCommand, TasksGenerateCommand, RetroAddCommand, RetroListCommand, } from "@krr2020/taskflow-core";
+// Create command context
+const context = {
+    projectRoot: process.cwd(),
+};
 // Initialize MCP Server
 const server = new Server({
     name: "taskflow-mcp-server",
@@ -21,184 +23,364 @@ const server = new Server({
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
+            // Initialization
             {
-                name: "start_task",
-                description: "Start a new task, checking out the correct story branch and entering PLANNING mode.",
+                name: "init",
+                description: "Initialize Taskflow in the current project. Creates taskflow.config.json and .taskflow directory structure with template files.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        taskId: {
+                        projectName: {
                             type: "string",
-                            description: "The ID of the task to start (e.g., '1.2.3')",
+                            description: "Project name (optional, defaults to directory name)",
                         },
-                        storyId: {
+                    },
+                },
+            },
+            // Status & Navigation
+            {
+                name: "get_status",
+                description: "Get project status, feature status, or story status. Shows progress, tasks, and active task information.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
                             type: "string",
-                            description: "The Story ID this task belongs to (e.g., '15')",
+                            description: "Optional: Feature ID (N) or Story ID (N.M) to get specific status",
                         },
-                        slug: {
+                    },
+                },
+            },
+            {
+                name: "find_next_task",
+                description: "Find the next available task that can be worked on. Checks dependencies and returns task details.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            // PRD Generation
+            {
+                name: "prd_create",
+                description: "Create a new PRD (Product Requirements Document) template. Generates a structured markdown template for defining features.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        featureName: {
                             type: "string",
-                            description: "Short slug for the story (e.g., 'user-auth')",
+                            description: "Name of the feature (e.g., 'user-authentication')",
                         },
                     },
-                    required: ["taskId", "storyId", "slug"],
+                    required: ["featureName"],
                 },
             },
             {
-                name: "approve_plan",
-                description: "Approve the implementation plan and switch to EXECUTION mode.",
+                name: "prd_generate_arch",
+                description: "Generate CODING-STANDARDS.md and ARCHITECTURE-RULES.md from a PRD. Analyzes codebase and PRD to create project-specific standards.",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        prdFile: {
+                            type: "string",
+                            description: "PRD filename (e.g., '2024-01-15-user-auth.md')",
+                        },
+                    },
+                    required: ["prdFile"],
                 },
             },
+            // Task Generation
             {
-                name: "get_status",
-                description: "Get the current state machine status and active task.",
+                name: "tasks_generate",
+                description: "Generate complete task breakdown from a PRD. Creates features, stories, and tasks with dependencies.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prdFile: {
+                            type: "string",
+                            description: "PRD filename to generate tasks from",
+                        },
+                    },
+                    required: ["prdFile"],
+                },
+            },
+            // Task Workflow
+            {
+                name: "start_task",
+                description: "Start working on a task. Switches to story branch, loads requirements, sets status to SETUP. Provides comprehensive AI guidance.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID in format N.M.K (e.g., '1.1.0')",
+                        },
+                    },
+                    required: ["taskId"],
+                },
+            },
+            {
+                name: "check_task",
+                description: "Validate current task and advance to next status. Behavior depends on current status (SETUP→IMPLEMENTING→VERIFYING→VALIDATING→COMMITTING).",
                 inputSchema: {
                     type: "object",
                     properties: {},
                 },
             },
             {
-                name: "generate_prd",
-                description: "Generate a PRD template based on project context.",
+                name: "commit_task",
+                description: "Commit changes and complete the task. Requires bullet points describing changes. Runs git add, commit, push and marks task as completed.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        requirements: { type: "string" }
+                        message: {
+                            type: "string",
+                            description: 'Bullet points describing changes (e.g., "- Added feature X\\n- Fixed bug Y")',
+                        },
                     },
+                    required: ["message"],
                 },
             },
             {
-                name: "generate_tasks",
-                description: "Generate tasks from a PRD.",
+                name: "resume_task",
+                description: "Resume a blocked or on-hold task. Restores task to active status and provides guidance on continuing work.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        prdContent: { type: "string" }
+                        status: {
+                            type: "string",
+                            description: "Status to resume to (setup, implementing, verifying, validating)",
+                            enum: ["setup", "implementing", "verifying", "validating"],
+                        },
                     },
                 },
             },
             {
-                name: "run_checks",
-                description: "Run project validations and enter VERIFICATION state.",
+                name: "block_task",
+                description: "Mark current task as blocked with a reason. Saves current status and finds next available task.",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: "Reason for blocking the task",
+                        },
+                    },
+                    required: ["reason"],
                 },
             },
+            // Retrospective
             {
-                name: "submit_task",
-                description: "Submit the current task and complete the workflow.",
+                name: "add_retrospective",
+                description: "Add a new error pattern to the retrospective. Helps prevent repeated mistakes by documenting solutions.",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        category: {
+                            type: "string",
+                            description: "Error category (type_error, lint, runtime, build, test, etc.)",
+                        },
+                        pattern: {
+                            type: "string",
+                            description: "Error pattern to match in validation output",
+                        },
+                        solution: {
+                            type: "string",
+                            description: "Solution to the error",
+                        },
+                        criticality: {
+                            type: "string",
+                            description: "Criticality level (low, medium, high)",
+                            enum: ["low", "medium", "high"],
+                        },
+                    },
+                    required: ["category", "pattern", "solution"],
+                },
+            },
+            {
+                name: "list_retrospectives",
+                description: "List all retrospective entries. Can filter by category. Shows error patterns, solutions, and counts.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: {
+                            type: "string",
+                            description: "Optional: Filter by category",
+                        },
+                    },
                 },
             },
         ],
     };
 });
+// Helper function to format command result for MCP
+function formatCommandResult(result) {
+    const parts = [];
+    // Add output
+    if (result.output) {
+        parts.push(result.output);
+    }
+    // Add next steps
+    if (result.nextSteps) {
+        parts.push("\n\nNEXT STEPS:");
+        parts.push("─".repeat(60));
+        parts.push(result.nextSteps);
+    }
+    // Add AI guidance
+    if (result.aiGuidance) {
+        parts.push("\n\nAI GUIDANCE:");
+        parts.push("─".repeat(60));
+        parts.push(result.aiGuidance);
+    }
+    // Add context files
+    if (result.contextFiles && result.contextFiles.length > 0) {
+        parts.push("\n\nCONTEXT FILES:");
+        parts.push("─".repeat(60));
+        for (const file of result.contextFiles) {
+            parts.push(`  ${file}`);
+        }
+    }
+    // Add warnings
+    if (result.warnings && result.warnings.length > 0) {
+        parts.push("\n\n⚠️  WARNINGS:");
+        parts.push("─".repeat(60));
+        for (const warning of result.warnings) {
+            parts.push(`  ${warning}`);
+        }
+    }
+    // Add errors if failure
+    if (result.errors && result.errors.length > 0) {
+        parts.push("\n\n✗ ERRORS:");
+        parts.push("─".repeat(60));
+        for (const error of result.errors) {
+            parts.push(`  ${error}`);
+        }
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: parts.join("\n"),
+            },
+        ],
+        isError: result.success === false,
+    };
+}
 // Tool Execution
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
+            case "init": {
+                const schema = z.object({
+                    projectName: z.string().optional(),
+                });
+                const { projectName } = schema.parse(args || {});
+                const cmd = new InitCommand(context);
+                const result = await cmd.execute(projectName);
+                return formatCommandResult(result);
+            }
+            case "get_status": {
+                const schema = z.object({
+                    id: z.string().optional(),
+                });
+                const { id } = schema.parse(args || {});
+                const cmd = new StatusCommand(context);
+                const result = await cmd.execute(id);
+                return formatCommandResult(result);
+            }
+            case "find_next_task": {
+                const cmd = new NextCommand(context);
+                const result = await cmd.execute();
+                return formatCommandResult(result);
+            }
+            case "prd_create": {
+                const schema = z.object({
+                    featureName: z.string(),
+                });
+                const { featureName } = schema.parse(args);
+                const cmd = new PrdCreateCommand(context);
+                const result = await cmd.execute(featureName);
+                return formatCommandResult(result);
+            }
+            case "prd_generate_arch": {
+                const schema = z.object({
+                    prdFile: z.string(),
+                });
+                const { prdFile } = schema.parse(args);
+                const cmd = new PrdGenerateArchCommand(context);
+                const result = await cmd.execute(prdFile);
+                return formatCommandResult(result);
+            }
+            case "tasks_generate": {
+                const schema = z.object({
+                    prdFile: z.string(),
+                });
+                const { prdFile } = schema.parse(args);
+                const cmd = new TasksGenerateCommand(context);
+                const result = await cmd.execute(prdFile);
+                return formatCommandResult(result);
+            }
             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.`,
-                        },
-                    ],
-                };
+                const { taskId } = schema.parse(args);
+                const cmd = new StartCommand(context);
+                const result = await cmd.execute(taskId);
+                return formatCommandResult(result);
             }
-            case "approve_plan": {
-                stateMachine.approvePlan();
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Plan approved. State is now EXECUTION. You may now write code.",
-                        },
-                    ],
-                };
+            case "check_task": {
+                const cmd = new CheckCommand(context);
+                const result = await cmd.execute();
+                return formatCommandResult(result);
             }
-            case "get_status": {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                state: stateMachine.getState(),
-                                activeTask: stateMachine.getActiveTask(),
-                            }, null, 2),
-                        },
-                    ],
-                };
+            case "commit_task": {
+                const schema = z.object({
+                    message: z.string(),
+                });
+                const { message } = schema.parse(args);
+                const cmd = new CommitCommand(context);
+                const result = await cmd.execute(message);
+                return formatCommandResult(result);
             }
-            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 "resume_task": {
+                const schema = z.object({
+                    status: z.string().optional(),
+                });
+                const { status } = schema.parse(args || {});
+                const cmd = new ResumeCommand(context);
+                const result = await cmd.execute(status);
+                return formatCommandResult(result);
             }
-            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 "block_task": {
+                const schema = z.object({
+                    reason: z.string(),
+                });
+                const { reason } = schema.parse(args);
+                const cmd = new SkipCommand(context);
+                const result = await cmd.execute(reason);
+                return formatCommandResult(result);
             }
-            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 "add_retrospective": {
+                const schema = z.object({
+                    category: z.string(),
+                    pattern: z.string(),
+                    solution: z.string(),
+                    criticality: z.string().optional().default("medium"),
+                });
+                const { category, pattern, solution, criticality } = schema.parse(args);
+                const cmd = new RetroAddCommand(context);
+                const result = await cmd.execute(category, pattern, solution, criticality);
+                return formatCommandResult(result);
             }
-            case "submit_task": {
-                stateMachine.completeTask();
-                return {
-                    content: [{ type: "text", text: "Task submitted and completed. State is now IDLE." }],
-                };
+            case "list_retrospectives": {
+                const schema = z.object({
+                    category: z.string().optional(),
+                });
+                const { category } = schema.parse(args || {});
+                const cmd = new RetroListCommand(context);
+                const result = await cmd.execute(category);
+                return formatCommandResult(result);
             }
             default:
                 throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);

package/package.json

@@ -1,27 +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"
-  }
-}
+	"name": "@krr2020/taskflow-mcp-server",
+	"version": "0.1.0-beta.3",
+	"description": "MCP Server for Taskflow",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"taskflow-mcp": "node dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "1.25.1",
+		"@krr2020/taskflow-core": "0.1.0-beta.3",
+		"zod": "4.3.2"
+	},
+	"devDependencies": {
+		"typescript": "5.9.3",
+		"@types/node": "25.0.3"
+	}
+}

package/resources/prd-requirements.md

@@ -0,0 +1,21 @@
+# Rule: Generating a Product Requirements Document (PRD)
+
+## Goal
+
+To guide an AI assistant in creating a detailed Product Requirements Document (PRD) in Markdown format, based on an initial user prompt. The PRD should be clear, actionable, and suitable for a junior developer to understand and implement the feature.
+
+## Process
+
+1.  **Receive Initial Prompt:** The user provides a brief description or request for a new feature or functionality.
+2.  **Ask Clarifying Questions:** Before writing the PRD, the AI *must* ask only the most essential clarifying questions needed to write a clear PRD. Limit questions to 3-5 critical gaps in understanding.
+3.  **Generate PRD:** Based on the initial prompt and the user's answers, generate a PRD using the structure outlined below.
+4.  **Save PRD:** Save the generated document as `prd-[feature-name].md` inside the `/tasks` directory.
+
+## Clarifying Questions (Guidelines)
+
+Ask only the most critical questions needed to write a clear PRD.
+*   **Problem/Goal:** "What problem does this feature solve?"
+*   **Core Functionality:** "What are the key actions?"
+*   **Success Criteria:** "How will we know when this feature is successfully implemented?"
+
+**Format:** Numbered list with options (A, B, C) for easy user response.

package/resources/prd-template.md

@@ -0,0 +1,21 @@
+## PRD Structure
+
+The generated PRD should include:
+
+1.  **Introduction/Overview**
+2.  **Goals** (Specific, Measurable)
+3.  **User Stories**
+4.  **Functional Requirements** (Clear, concise, numbered)
+5.  **Non-Goals (Out of Scope)**
+6.  **Success Metrics**
+7.  **Open Questions**
+
+## Target Audience
+
+Assume the primary reader is a **junior developer**. Requirements should be explicit and unambiguous.
+
+## Output
+
+*   **Format:** Markdown (`.md`)
+*   **Location:** `/tasks/`
+*   **Filename:** `prd-[feature-name].md`