sdd-mcp-server 3.5.0 → 4.0.0

package/dist/adapters/cli/SDDToolAdapter.js

@@ -13,244 +13,78 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { injectable, inject } from "inversify";
 import { TYPES } from "../../infrastructure/di/types.js";
-import { ProjectService } from "../../application/services/ProjectService.js";
-import { WorkflowService } from "../../application/services/WorkflowService.js";
 import { TemplateService } from "../../application/services/TemplateService.js";
 import { QualityService } from "../../application/services/QualityService.js";
 import { SteeringDocumentService } from "../../application/services/SteeringDocumentService.js";
 import { CodebaseAnalysisService } from "../../application/services/CodebaseAnalysisService.js";
 import { RequirementsClarificationService } from "../../application/services/RequirementsClarificationService.js";
 import { ContextCompactionService } from "../../application/services/ContextCompactionService.js";
-import { WorkflowPhase } from "../../domain/types.js";
+import { WorkflowEngineService } from "../../application/services/WorkflowEngineService.js";
 import { ensureStaticSteeringDocuments } from "../../application/services/staticSteering.js";
+import { SDD_TOOL_DEFINITIONS, SDD_TOOL_NAMES, } from "../../infrastructure/mcp/sddToolDefinitions.js";
+export { SDD_TOOL_NAMES };
 let SDDToolAdapter = class SDDToolAdapter {
-    projectService;
-    workflowService;
     templateService;
     qualityService;
     steeringService;
     codebaseAnalysisService;
     clarificationService;
     contextCompactionService;
+    workflowEngineService;
     logger;
-    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, contextCompactionService, logger) {
-        this.projectService = projectService;
-        this.workflowService = workflowService;
+    constructor(templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, contextCompactionService, workflowEngineService, logger) {
         this.templateService = templateService;
         this.qualityService = qualityService;
         this.steeringService = steeringService;
         this.codebaseAnalysisService = codebaseAnalysisService;
         this.clarificationService = clarificationService;
         this.contextCompactionService = contextCompactionService;
+        this.workflowEngineService = workflowEngineService;
         this.logger = logger;
     }
     getSDDTools() {
-        return [
-            {
-                name: "sdd-init",
-                tool: {
-                    name: "sdd-init",
-                    description: "Initialize a new SDD project with interactive requirements clarification",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectName: {
-                                type: "string",
-                                description: "The name of the project to initialize",
-                            },
-                            description: {
-                                type: "string",
-                                description: "Project description",
-                            },
-                            clarificationAnswers: {
-                                type: "object",
-                                description: "Answers to clarification questions (second pass)",
-                                additionalProperties: { type: "string" },
-                            },
-                            reviewTestCases: {
-                                type: "boolean",
-                                description: "Enable an optional checkpoint requiring TDD test-case review before implementation",
-                            },
-                        },
-                        required: ["projectName"],
-                    },
-                },
-                handler: this.handleProjectInit.bind(this),
-            },
-            {
-                name: "sdd-status",
-                tool: {
-                    name: "sdd-status",
-                    description: "Get current project status and workflow phase information",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                            projectPath: {
-                                type: "string",
-                                description: "Project path (alternative to ID)",
-                            },
-                        },
-                    },
-                },
-                handler: this.handleProjectStatus.bind(this),
-            },
-            {
-                name: "sdd-requirements",
-                tool: {
-                    name: "sdd-requirements",
-                    description: "Generate requirements doc",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleRequirements.bind(this),
-            },
-            {
-                name: "sdd-design",
-                tool: {
-                    name: "sdd-design",
-                    description: "Create design specifications",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleDesign.bind(this),
-            },
-            {
-                name: "sdd-tasks",
-                tool: {
-                    name: "sdd-tasks",
-                    description: "Generate task breakdown",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                            reviewTestCases: {
-                                type: "boolean",
-                                description: "When true, require an explicit TDD test-case review checkpoint before implementation",
-                            },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleTasks.bind(this),
-            },
-            {
-                name: "sdd-review-test-cases",
-                tool: {
-                    name: "sdd-review-test-cases",
-                    description: "Mark the optional TDD test-case review checkpoint as reviewed",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleReviewTestCases.bind(this),
-            },
-            {
-                name: "sdd-quality-check",
-                tool: {
-                    name: "sdd-quality-check",
-                    description: "Perform Linus-style code quality analysis",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            code: { type: "string", description: "Code to analyze" },
-                            language: { type: "string", description: "Programming language" },
-                        },
-                        required: ["code"],
-                    },
-                },
-                handler: this.handleQualityCheck.bind(this),
-            },
-            {
-                name: "sdd-context-load",
-                tool: {
-                    name: "sdd-context-load",
-                    description: "Load compact workflow handoff context by default; use mode=full only when necessary",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                            mode: {
-                                type: "string",
-                                enum: ["compact", "standard", "full"],
-                                description: "Context size mode. compact is default and uses handoff.md.",
-                            },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleContextLoad.bind(this),
-            },
-            {
-                name: "sdd-steering",
-                tool: {
-                    name: "sdd-steering",
-                    description: "Create/update steering documents with project-specific analysis",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            updateMode: {
-                                type: "string",
-                                enum: ["create", "update"],
-                                description: "Whether to create new or update existing documents",
-                            },
-                        },
-                    },
-                },
-                handler: this.handleSteering.bind(this),
-            },
-            {
-                name: "sdd-steering-custom",
-                tool: {
-                    name: "sdd-steering-custom",
-                    description: "Create custom steering documents for specialized contexts",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            fileName: {
-                                type: "string",
-                                description: "Filename for the custom steering document",
-                            },
-                            topic: {
-                                type: "string",
-                                description: "Topic/purpose of the custom steering document",
-                            },
-                            inclusionMode: {
-                                type: "string",
-                                enum: ["always", "conditional", "manual"],
-                                description: "How this steering document should be included",
-                            },
-                            filePattern: {
-                                type: "string",
-                                description: "File pattern for conditional inclusion",
-                            },
-                        },
-                        required: ["fileName", "topic", "inclusionMode"],
-                    },
-                },
-                handler: this.handleSteeringCustom.bind(this),
-            },
-        ];
+        const handlers = {
+            "sdd-init": this.handleProjectInit.bind(this),
+            "sdd-requirements": this.handleRequirements.bind(this),
+            "sdd-design": this.handleDesign.bind(this),
+            "sdd-tasks": this.handleTasks.bind(this),
+            "sdd-implement": this.handleImplement.bind(this),
+            "sdd-status": this.handleProjectStatus.bind(this),
+            "sdd-approve": this.handleApprove.bind(this),
+            "sdd-review-test-cases": this.handleReviewTestCases.bind(this),
+            "sdd-quality-check": this.handleQualityCheck.bind(this),
+            "sdd-context-load": this.handleContextLoad.bind(this),
+            "sdd-template-render": this.handleTemplateRender.bind(this),
+            "sdd-steering": this.handleSteering.bind(this),
+            "sdd-steering-custom": this.handleSteeringCustom.bind(this),
+            "sdd-validate-design": this.handleValidateDesign.bind(this),
+            "sdd-validate-gap": this.handleValidateGap.bind(this),
+            "sdd-spec-impl": this.handleSpecImplementation.bind(this),
+        };
+        return SDD_TOOL_DEFINITIONS.map((tool) => ({
+            name: tool.name,
+            tool,
+            handler: handlers[tool.name],
+        }));
+    }
+    canonicalFeatureName(projectName) {
+        const featureName = projectName
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .slice(0, 80);
+        if (!featureName) {
+            throw new Error("Invalid argument: projectName must contain a letter or number");
+        }
+        return featureName;
     }
     async handleProjectInit(args) {
         const { projectName, description = "", clarificationAnswers, reviewTestCases = false, } = args;
         if (typeof projectName !== "string") {
             throw new Error("Invalid arguments: projectName must be a string");
         }
+        const featureName = this.canonicalFeatureName(projectName);
         const currentPath = process.cwd();
         // FIRST PASS: Analyze description quality
         if (!clarificationAnswers) {
@@ -273,15 +107,22 @@ let SDDToolAdapter = class SDDToolAdapter {
                 enrichedDescription = enriched.enriched;
             }
         }
-        // Create project with enriched description
-        const project = await this.projectService.createProject(projectName, currentPath, "en", { reviewTestCases: reviewTestCases === true });
-        // Generate initial spec.json
-        const specContent = await this.templateService.generateSpecJson(project);
-        await this.templateService.writeProjectFile(project, "spec.json", specContent);
+        await this.workflowEngineService.initializeFeature({
+            projectRoot: currentPath,
+            featureName,
+            language: "en",
+            reviewTestCases: reviewTestCases === true,
+        });
         const clarificationNote = clarificationAnswers
             ? "\n\n✅ Requirements Clarification: Your answers have been incorporated into an enriched project description."
             : "";
-        return `Project "${projectName}" initialized successfully\nProject ID: ${project.id}\n\nDescription:\n${enrichedDescription}${clarificationNote}`;
+        return {
+            featureName,
+            initialized: true,
+            description: enrichedDescription,
+            clarificationApplied: Boolean(clarificationAnswers),
+            message: `Project "${projectName}" initialized successfully${clarificationNote}`,
+        };
     }
     formatClarificationQuestions(questions, analysis) {
         let output = "## Requirements Clarification Needed\n\n";
@@ -306,141 +147,81 @@ let SDDToolAdapter = class SDDToolAdapter {
             "Call sdd-init again with clarificationAnswers parameter containing your answers.\n";
         return output;
     }
+    async requireFeatureProject(featureName) {
+        return this.workflowEngineService.loadProject({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(featureName),
+        });
+    }
+    requireFeatureName(featureName) {
+        if (typeof featureName !== "string" || featureName.length === 0) {
+            throw new Error("Invalid argument: featureName must be a non-empty string");
+        }
+        return featureName;
+    }
     async handleProjectStatus(args) {
-        const { projectId, projectPath } = args;
-        let project;
-        if (projectId && typeof projectId === "string") {
-            project = await this.projectService.getProject(projectId);
-        }
-        else if (projectPath && typeof projectPath === "string") {
-            project = await this.projectService.getProjectByPath(projectPath);
-        }
-        else {
-            throw new Error("Either projectId or projectPath must be provided");
-        }
-        if (!project) {
-            return "Project not found";
-        }
-        const status = await this.workflowService.getWorkflowStatus(project.id);
-        if (!status) {
-            return "Unable to get workflow status";
-        }
-        let output = `Project: ${project.name}\n`;
-        output += `Current Phase: ${status.currentPhase}\n`;
-        output += `Next Phase: ${status.nextPhase ?? "Complete"}\n`;
-        output += `Can Progress: ${status.canProgress ? "Yes" : "No"}\n`;
-        const testCaseCheckpoint = project.metadata.checkpoints?.testCases;
-        if (testCaseCheckpoint?.required) {
-            output += `TDD Test Cases Reviewed: ${testCaseCheckpoint.reviewed ? "Yes" : "No"}\n`;
-        }
-        if (status.blockers && status.blockers.length > 0) {
-            output += `Blockers:\n`;
-            for (const blocker of status.blockers) {
-                output += `- ${blocker}\n`;
-            }
+        const { featureName } = args;
+        if (featureName === undefined) {
+            const features = await this.workflowEngineService.listFeatureStatuses({
+                projectRoot: process.cwd(),
+            });
+            return { features };
         }
-        return output;
+        return this.workflowEngineService.getFeatureStatus({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(featureName),
+        });
     }
     async handleRequirements(args) {
-        const { projectId } = args;
-        if (typeof projectId !== "string") {
-            throw new Error("Invalid argument: projectId must be a string");
-        }
-        const project = await this.projectService.getProject(projectId);
-        if (!project) {
-            throw new Error("Project not found");
-        }
-        // Check if can transition to requirements phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.REQUIREMENTS);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate requirements: ${validation.reason}`);
-        }
-        // Generate requirements template
-        const content = await this.templateService.generateRequirementsTemplate(project);
-        await this.templateService.writeProjectFile(project, "requirements.md", content);
-        // Update project phase and approval status
-        await this.projectService.updateProjectPhase(projectId, WorkflowPhase.REQUIREMENTS);
-        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "requirements", {
-            generated: true,
-            approved: false,
+        return this.workflowEngineService.generatePhase({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+            phase: "requirements",
         });
-        const specContent = await this.templateService.generateSpecJson(updatedProject);
-        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
-        return `Requirements document generated for project "${project.name}"`;
     }
     async handleDesign(args) {
-        const { projectId } = args;
-        if (typeof projectId !== "string") {
-            throw new Error("Invalid argument: projectId must be a string");
-        }
-        const project = await this.projectService.getProject(projectId);
-        if (!project) {
-            throw new Error("Project not found");
-        }
-        // Check if can transition to design phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.DESIGN);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate design: ${validation.reason}`);
-        }
-        // Generate design template
-        const content = await this.templateService.generateDesignTemplate(project);
-        await this.templateService.writeProjectFile(project, "design.md", content);
-        // Update project phase and approval status
-        await this.projectService.updateProjectPhase(projectId, WorkflowPhase.DESIGN);
-        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "design", {
-            generated: true,
-            approved: false,
+        return this.workflowEngineService.generatePhase({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+            phase: "design",
         });
-        const specContent = await this.templateService.generateSpecJson(updatedProject);
-        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
-        return `Design document generated for project "${project.name}"`;
     }
     async handleTasks(args) {
-        const { projectId, reviewTestCases } = args;
-        if (typeof projectId !== "string") {
-            throw new Error("Invalid argument: projectId must be a string");
-        }
-        const project = await this.projectService.getProject(projectId);
-        if (!project) {
-            throw new Error("Project not found");
-        }
-        // Check if can transition to tasks phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.TASKS);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate tasks: ${validation.reason}`);
-        }
-        // Generate tasks template
-        const content = await this.templateService.generateTasksTemplate(project);
-        await this.templateService.writeProjectFile(project, "tasks.md", content);
-        if (typeof reviewTestCases === "boolean") {
-            await this.projectService.updateTestCaseReviewCheckpoint(projectId, {
-                required: reviewTestCases,
-                reviewed: !reviewTestCases,
-            });
-        }
-        // Update project phase and approval status
-        await this.projectService.updateProjectPhase(projectId, WorkflowPhase.TASKS);
-        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "tasks", {
-            generated: true,
-            approved: false,
+        const reviewTestCases = args.reviewTestCases;
+        if (reviewTestCases !== undefined && typeof reviewTestCases !== "boolean") {
+            throw new Error("Invalid argument: reviewTestCases must be a boolean");
+        }
+        return this.workflowEngineService.generatePhase({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+            phase: "tasks",
+            reviewTestCases: reviewTestCases,
+        });
+    }
+    async handleImplement(args) {
+        return this.workflowEngineService.beginImplementation({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+        });
+    }
+    async handleApprove(args) {
+        const featureName = this.requireFeatureName(args.featureName);
+        const phase = args.phase;
+        if (!["requirements", "design", "tasks"].includes(phase)) {
+            throw new Error("Invalid argument: phase must be requirements, design, or tasks");
+        }
+        return this.workflowEngineService.approve({
+            projectRoot: process.cwd(),
+            featureName,
+            phase: phase,
         });
-        const specContent = await this.templateService.generateSpecJson(updatedProject);
-        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
-        return `Tasks document generated for project "${project.name}"`;
     }
     async handleReviewTestCases(args) {
-        const { projectId } = args;
-        if (typeof projectId !== "string") {
-            throw new Error("Invalid argument: projectId must be a string");
-        }
-        const project = await this.projectService.getProject(projectId);
-        if (!project) {
-            throw new Error("Project not found");
-        }
-        const updatedProject = await this.projectService.updateTestCaseReviewCheckpoint(projectId, { required: true, reviewed: true });
-        const specContent = await this.templateService.generateSpecJson(updatedProject);
-        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
-        return `TDD test cases reviewed for project "${project.name}"`;
+        const featureName = this.requireFeatureName(args.featureName);
+        return this.workflowEngineService.reviewTestCases({
+            projectRoot: process.cwd(),
+            featureName,
+        });
     }
     async handleQualityCheck(args) {
         const { code, language = "typescript" } = args;
@@ -454,19 +235,61 @@ let SDDToolAdapter = class SDDToolAdapter {
         return this.qualityService.formatQualityReport(report);
     }
     async handleContextLoad(args) {
-        const { projectId, mode = "compact" } = args;
-        if (typeof projectId !== "string") {
-            throw new Error("Invalid argument: projectId must be a string");
-        }
-        if (!["compact", "standard", "full"].includes(mode)) {
-            throw new Error("Invalid argument: mode must be compact, standard, or full");
-        }
-        const project = await this.projectService.getProject(projectId);
-        if (!project) {
-            throw new Error("Project not found");
-        }
-        const context = await this.contextCompactionService.loadContext(project, mode);
-        return context;
+        const featureName = this.requireFeatureName(args.featureName);
+        const { mode, phase, maxEstimatedTokens, ifNoneMatch, includeUnapproved, } = args;
+        return this.contextCompactionService.loadContext({
+            projectRoot: process.cwd(),
+            featureName,
+            mode: mode,
+            phase: phase,
+            maxEstimatedTokens: maxEstimatedTokens,
+            ifNoneMatch: ifNoneMatch,
+            includeUnapproved: includeUnapproved,
+        });
+    }
+    async handleTemplateRender(args) {
+        const project = await this.requireFeatureProject(args.featureName);
+        const templateType = args.templateType;
+        if (args.customTemplate !== undefined) {
+            if (typeof args.customTemplate !== "string") {
+                throw new Error("Invalid argument: customTemplate must be a string");
+            }
+            return {
+                featureName: project.name,
+                templateType,
+                content: args.customTemplate,
+            };
+        }
+        let content;
+        switch (templateType) {
+            case "requirements":
+                content = await this.templateService.generateRequirementsTemplate(project);
+                break;
+            case "design":
+                content = await this.templateService.generateDesignTemplate(project);
+                break;
+            case "tasks":
+                content = await this.templateService.generateTasksTemplate(project);
+                break;
+            default:
+                throw new Error("Invalid argument: templateType must be requirements, design, or tasks");
+        }
+        return { featureName: project.name, templateType, content };
+    }
+    async handleValidateDesign(args) {
+        const project = await this.requireFeatureProject(args.featureName);
+        return this.qualityService.validateDesign(project);
+    }
+    async handleValidateGap(args) {
+        const project = await this.requireFeatureProject(args.featureName);
+        return {
+            featureName: project.name,
+            analysis: await this.codebaseAnalysisService.analyzeCodebase(project.path),
+        };
+    }
+    async handleSpecImplementation(args) {
+        const result = await this.handleImplement(args);
+        return { ...result, taskNumbers: args.taskNumbers ?? null };
     }
     async handleSteering(args) {
         const { updateMode = "update" } = args;
@@ -553,6 +376,12 @@ Choose Codex or Claude Code interactively, or pass \`--target\` explicitly in au
             typeof inclusionMode !== "string") {
             throw new Error("Invalid arguments: fileName, topic, and inclusionMode must be strings");
         }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*\.md$/.test(fileName)) {
+            throw new Error("Invalid argument: fileName must be a Markdown basename");
+        }
+        if (!["always", "conditional", "manual"].includes(inclusionMode)) {
+            throw new Error("Invalid argument: inclusionMode must be always, conditional, or manual");
+        }
         const content = `# ${topic}
 
 ## Purpose
@@ -858,23 +687,21 @@ ${this.generateWorkflow(analysis)}`;
 };
 SDDToolAdapter = __decorate([
     injectable(),
-    __param(0, inject(TYPES.ProjectService)),
-    __param(1, inject(TYPES.WorkflowService)),
-    __param(2, inject(TYPES.TemplateService)),
-    __param(3, inject(TYPES.QualityService)),
-    __param(4, inject(TYPES.SteeringDocumentService)),
-    __param(5, inject(TYPES.CodebaseAnalysisService)),
-    __param(6, inject(TYPES.RequirementsClarificationService)),
-    __param(7, inject(TYPES.ContextCompactionService)),
-    __param(8, inject(TYPES.LoggerPort)),
-    __metadata("design:paramtypes", [ProjectService,
-        WorkflowService,
-        TemplateService,
+    __param(0, inject(TYPES.TemplateService)),
+    __param(1, inject(TYPES.QualityService)),
+    __param(2, inject(TYPES.SteeringDocumentService)),
+    __param(3, inject(TYPES.CodebaseAnalysisService)),
+    __param(4, inject(TYPES.RequirementsClarificationService)),
+    __param(5, inject(TYPES.ContextCompactionService)),
+    __param(6, inject(TYPES.WorkflowEngineService)),
+    __param(7, inject(TYPES.LoggerPort)),
+    __metadata("design:paramtypes", [TemplateService,
         QualityService,
         SteeringDocumentService,
         CodebaseAnalysisService,
         RequirementsClarificationService,
-        ContextCompactionService, Object])
+        ContextCompactionService,
+        WorkflowEngineService, Object])
 ], SDDToolAdapter);
 export { SDDToolAdapter };
 //# sourceMappingURL=SDDToolAdapter.js.map