sdd-mcp-server 1.4.5 → 1.5.1

package/dist/adapters/cli/SDDToolAdapter.js

@@ -11,16 +11,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-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 { WorkflowPhase } from '../../domain/types.js';
-import { ensureStaticSteeringDocuments } from '../../application/services/staticSteering.js';
+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 { WorkflowPhase } from "../../domain/types.js";
+import { ensureStaticSteeringDocuments } from "../../application/services/staticSteering.js";
 let SDDToolAdapter = class SDDToolAdapter {
     projectService;
     workflowService;
@@ -28,179 +29,262 @@ let SDDToolAdapter = class SDDToolAdapter {
     qualityService;
     steeringService;
     codebaseAnalysisService;
+    clarificationService;
     logger;
-    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, logger) {
+    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, logger) {
         this.projectService = projectService;
         this.workflowService = workflowService;
         this.templateService = templateService;
         this.qualityService = qualityService;
         this.steeringService = steeringService;
         this.codebaseAnalysisService = codebaseAnalysisService;
+        this.clarificationService = clarificationService;
         this.logger = logger;
     }
     getSDDTools() {
         return [
             {
-                name: 'sdd-init',
+                name: "sdd-init",
                 tool: {
-                    name: 'sdd-init',
-                    description: 'Initialize a new SDD project from description',
+                    name: "sdd-init",
+                    description: "Initialize a new SDD project with interactive requirements clarification",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            description: { type: 'string', description: 'Detailed project description' }
+                            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" },
+                            },
                         },
-                        required: ['description']
-                    }
+                        required: ["projectName"],
+                    },
                 },
-                handler: this.handleProjectInit.bind(this)
+                handler: this.handleProjectInit.bind(this),
             },
             {
-                name: 'sdd-status',
+                name: "sdd-status",
                 tool: {
-                    name: 'sdd-status',
-                    description: 'Get current project status and workflow phase information',
+                    name: "sdd-status",
+                    description: "Get current project status and workflow phase information",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            projectId: { type: 'string', description: 'Project ID' },
-                            projectPath: { type: 'string', description: 'Project path (alternative to ID)' }
-                        }
-                    }
+                            projectId: { type: "string", description: "Project ID" },
+                            projectPath: {
+                                type: "string",
+                                description: "Project path (alternative to ID)",
+                            },
+                        },
+                    },
                 },
-                handler: this.handleProjectStatus.bind(this)
+                handler: this.handleProjectStatus.bind(this),
             },
             {
-                name: 'sdd-requirements',
+                name: "sdd-requirements",
                 tool: {
-                    name: 'sdd-requirements',
-                    description: 'Generate requirements doc',
+                    name: "sdd-requirements",
+                    description: "Generate requirements doc",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            featureName: { type: 'string', description: 'Feature name' }
+                            featureName: { type: "string", description: "Feature name" },
                         },
-                        required: ['featureName']
-                    }
+                        required: ["featureName"],
+                    },
                 },
-                handler: this.handleRequirements.bind(this)
+                handler: this.handleRequirements.bind(this),
             },
             {
-                name: 'sdd-design',
+                name: "sdd-design",
                 tool: {
-                    name: 'sdd-design',
-                    description: 'Create design specifications',
+                    name: "sdd-design",
+                    description: "Create design specifications",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            featureName: { type: 'string', description: 'Feature name' }
+                            featureName: { type: "string", description: "Feature name" },
                         },
-                        required: ['featureName']
-                    }
+                        required: ["featureName"],
+                    },
                 },
-                handler: this.handleDesign.bind(this)
+                handler: this.handleDesign.bind(this),
             },
             {
-                name: 'sdd-tasks',
+                name: "sdd-tasks",
                 tool: {
-                    name: 'sdd-tasks',
-                    description: 'Generate task breakdown',
+                    name: "sdd-tasks",
+                    description: "Generate task breakdown",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            featureName: { type: 'string', description: 'Feature name' }
+                            featureName: { type: "string", description: "Feature name" },
                         },
-                        required: ['featureName']
-                    }
+                        required: ["featureName"],
+                    },
                 },
-                handler: this.handleTasks.bind(this)
+                handler: this.handleTasks.bind(this),
             },
             {
-                name: 'sdd-quality-check',
+                name: "sdd-quality-check",
                 tool: {
-                    name: 'sdd-quality-check',
-                    description: 'Perform Linus-style code quality analysis',
+                    name: "sdd-quality-check",
+                    description: "Perform Linus-style code quality analysis",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            code: { type: 'string', description: 'Code to analyze' },
-                            language: { type: 'string', description: 'Programming language' }
+                            code: { type: "string", description: "Code to analyze" },
+                            language: { type: "string", description: "Programming language" },
                         },
-                        required: ['code']
-                    }
+                        required: ["code"],
+                    },
                 },
-                handler: this.handleQualityCheck.bind(this)
+                handler: this.handleQualityCheck.bind(this),
             },
             {
-                name: 'sdd-steering',
+                name: "sdd-steering",
                 tool: {
-                    name: 'sdd-steering',
-                    description: 'Create/update steering documents with project-specific analysis',
+                    name: "sdd-steering",
+                    description: "Create/update steering documents with project-specific analysis",
                     inputSchema: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            updateMode: { type: 'string', enum: ['create', 'update'], description: 'Whether to create new or update existing documents' }
-                        }
-                    }
+                            updateMode: {
+                                type: "string",
+                                enum: ["create", "update"],
+                                description: "Whether to create new or update existing documents",
+                            },
+                        },
+                    },
                 },
-                handler: this.handleSteering.bind(this)
+                handler: this.handleSteering.bind(this),
             },
             {
-                name: 'sdd-steering-custom',
+                name: "sdd-steering-custom",
                 tool: {
-                    name: 'sdd-steering-custom',
-                    description: 'Create custom steering documents for specialized contexts',
+                    name: "sdd-steering-custom",
+                    description: "Create custom steering documents for specialized contexts",
                     inputSchema: {
-                        type: 'object',
+                        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' }
+                            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']
-                    }
+                        required: ["fileName", "topic", "inclusionMode"],
+                    },
                 },
-                handler: this.handleSteeringCustom.bind(this)
-            }
+                handler: this.handleSteeringCustom.bind(this),
+            },
         ];
     }
     async handleProjectInit(args) {
-        const { name, path, language = 'en' } = args;
-        if (typeof name !== 'string' || typeof path !== 'string') {
-            throw new Error('Invalid arguments: name and path must be strings');
+        const { projectName, description = "", clarificationAnswers } = args;
+        if (typeof projectName !== "string") {
+            throw new Error("Invalid arguments: projectName must be a string");
+        }
+        const currentPath = process.cwd();
+        // FIRST PASS: Analyze description quality
+        if (!clarificationAnswers) {
+            const result = await this.clarificationService.analyzeDescription(description, currentPath);
+            // If clarification needed, BLOCK and return questions
+            if (result.needsClarification && result.questions) {
+                return this.formatClarificationQuestions(result.questions, result.analysis);
+            }
+        }
+        // SECOND PASS: Validate and synthesize enriched description
+        let enrichedDescription = description;
+        if (clarificationAnswers && typeof clarificationAnswers === "object") {
+            const result = await this.clarificationService.analyzeDescription(description, currentPath);
+            if (result.questions) {
+                const validation = this.clarificationService.validateAnswers(result.questions, clarificationAnswers);
+                if (!validation.valid) {
+                    throw new Error(`Missing required answers: ${validation.missingRequired.join(", ")}`);
+                }
+                const enriched = this.clarificationService.synthesizeDescription(description, result.questions, clarificationAnswers);
+                enrichedDescription = enriched.enriched;
+            }
         }
-        const project = await this.projectService.createProject(name, path, language);
+        // Create project with enriched description
+        const project = await this.projectService.createProject(projectName, currentPath, "en");
         // Generate initial spec.json
         const specContent = await this.templateService.generateSpecJson(project);
-        await this.templateService.writeProjectFile(project, 'spec.json', specContent);
+        await this.templateService.writeProjectFile(project, "spec.json", specContent);
         // Create AGENTS.md if it doesn't exist
-        await this.createAgentsFile(path);
-        return `Project "${name}" initialized successfully at ${path}\nProject ID: ${project.id}`;
+        await this.createAgentsFile(currentPath);
+        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}`;
+    }
+    formatClarificationQuestions(questions, analysis) {
+        let output = "## Requirements Clarification Needed\n\n";
+        output +=
+            "Your project description needs more detail to ensure we build the right solution.\n\n";
+        output += `**Quality Score**: ${Math.round(analysis.qualityScore)}/100 (need 70+ to proceed)\n\n`;
+        output += "### Please answer these questions:\n\n";
+        let questionNum = 1;
+        for (const q of questions) {
+            output += `**${questionNum}. ${q.question}**${q.required ? " *(required)*" : ""}\n`;
+            if (q.examples && q.examples.length > 0) {
+                output += `   Examples:\n`;
+                for (const ex of q.examples) {
+                    output += `   - ${ex}\n`;
+                }
+            }
+            output += `   Answer ID: \`${q.id}\`\n\n`;
+            questionNum++;
+        }
+        output += "\n### How to Provide Answers\n\n";
+        output +=
+            "Call sdd-init again with clarificationAnswers parameter containing your answers.\n";
+        return output;
     }
     async handleProjectStatus(args) {
         const { projectId, projectPath } = args;
         let project;
-        if (projectId && typeof projectId === 'string') {
+        if (projectId && typeof projectId === "string") {
             project = await this.projectService.getProject(projectId);
         }
-        else if (projectPath && typeof projectPath === 'string') {
+        else if (projectPath && typeof projectPath === "string") {
             project = await this.projectService.getProjectByPath(projectPath);
         }
         else {
-            throw new Error('Either projectId or projectPath must be provided');
+            throw new Error("Either projectId or projectPath must be provided");
         }
         if (!project) {
-            return 'Project not found';
+            return "Project not found";
         }
         const status = await this.workflowService.getWorkflowStatus(project.id);
         if (!status) {
-            return 'Unable to get workflow 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`;
+        output += `Next Phase: ${status.nextPhase ?? "Complete"}\n`;
+        output += `Can Progress: ${status.canProgress ? "Yes" : "No"}\n`;
         if (status.blockers && status.blockers.length > 0) {
             output += `Blockers:\n`;
             for (const blocker of status.blockers) {
@@ -211,12 +295,12 @@ let SDDToolAdapter = class SDDToolAdapter {
     }
     async handleRequirements(args) {
         const { projectId } = args;
-        if (typeof projectId !== 'string') {
-            throw new Error('Invalid argument: projectId must be a string');
+        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');
+            throw new Error("Project not found");
         }
         // Check if can transition to requirements phase
         const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.REQUIREMENTS);
@@ -225,23 +309,23 @@ let SDDToolAdapter = class SDDToolAdapter {
         }
         // Generate requirements template
         const content = await this.templateService.generateRequirementsTemplate(project);
-        await this.templateService.writeProjectFile(project, 'requirements.md', content);
+        await this.templateService.writeProjectFile(project, "requirements.md", content);
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.REQUIREMENTS);
-        await this.projectService.updateApprovalStatus(projectId, 'requirements', {
+        await this.projectService.updateApprovalStatus(projectId, "requirements", {
             generated: true,
-            approved: false
+            approved: false,
         });
         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');
+        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');
+            throw new Error("Project not found");
         }
         // Check if can transition to design phase
         const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.DESIGN);
@@ -250,23 +334,23 @@ let SDDToolAdapter = class SDDToolAdapter {
         }
         // Generate design template
         const content = await this.templateService.generateDesignTemplate(project);
-        await this.templateService.writeProjectFile(project, 'design.md', content);
+        await this.templateService.writeProjectFile(project, "design.md", content);
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.DESIGN);
-        await this.projectService.updateApprovalStatus(projectId, 'design', {
+        await this.projectService.updateApprovalStatus(projectId, "design", {
             generated: true,
-            approved: false
+            approved: false,
         });
         return `Design document generated for project "${project.name}"`;
     }
     async handleTasks(args) {
         const { projectId } = args;
-        if (typeof projectId !== 'string') {
-            throw new Error('Invalid argument: projectId must be a string');
+        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');
+            throw new Error("Project not found");
         }
         // Check if can transition to tasks phase
         const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.TASKS);
@@ -275,28 +359,28 @@ let SDDToolAdapter = class SDDToolAdapter {
         }
         // Generate tasks template
         const content = await this.templateService.generateTasksTemplate(project);
-        await this.templateService.writeProjectFile(project, 'tasks.md', content);
+        await this.templateService.writeProjectFile(project, "tasks.md", content);
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.TASKS);
-        await this.projectService.updateApprovalStatus(projectId, 'tasks', {
+        await this.projectService.updateApprovalStatus(projectId, "tasks", {
             generated: true,
-            approved: false
+            approved: false,
         });
         return `Tasks document generated for project "${project.name}"`;
     }
     async handleQualityCheck(args) {
-        const { code, language = 'typescript' } = args;
-        if (typeof code !== 'string') {
-            throw new Error('Invalid argument: code must be a string');
+        const { code, language = "typescript" } = args;
+        if (typeof code !== "string") {
+            throw new Error("Invalid argument: code must be a string");
         }
         const report = await this.qualityService.performQualityCheck({
             code,
-            language: language
+            language: language,
         });
         return this.qualityService.formatQualityReport(report);
     }
     async handleSteering(args) {
-        const { updateMode = 'update' } = args;
+        const { updateMode = "update" } = args;
         const projectPath = process.cwd();
         try {
             // Analyze the project
@@ -307,22 +391,22 @@ let SDDToolAdapter = class SDDToolAdapter {
             const structureContent = await this.generateStructureSteering(analysis);
             // Create steering documents
             await this.steeringService.createSteeringDocument(projectPath, {
-                name: 'product.md',
-                type: 'PRODUCT',
-                mode: 'ALWAYS',
-                content: productContent
+                name: "product.md",
+                type: "PRODUCT",
+                mode: "ALWAYS",
+                content: productContent,
             });
             await this.steeringService.createSteeringDocument(projectPath, {
-                name: 'tech.md',
-                type: 'TECHNICAL',
-                mode: 'ALWAYS',
-                content: techContent
+                name: "tech.md",
+                type: "TECHNICAL",
+                mode: "ALWAYS",
+                content: techContent,
             });
             await this.steeringService.createSteeringDocument(projectPath, {
-                name: 'structure.md',
-                type: 'STRUCTURE',
-                mode: 'ALWAYS',
-                content: structureContent
+                name: "structure.md",
+                type: "STRUCTURE",
+                mode: "ALWAYS",
+                content: structureContent,
             });
             // Create static steering documents if they don't exist
             await this.createStaticSteeringDocuments(projectPath);
@@ -331,11 +415,11 @@ let SDDToolAdapter = class SDDToolAdapter {
             // Get project info from package.json
             let packageJson = {};
             try {
-                const fs = await import('fs');
-                const path = await import('path');
-                const packagePath = path.join(projectPath, 'package.json');
+                const fs = await import("fs");
+                const path = await import("path");
+                const packagePath = path.join(projectPath, "package.json");
                 if (fs.existsSync(packagePath)) {
-                    const packageContent = fs.readFileSync(packagePath, 'utf8');
+                    const packageContent = fs.readFileSync(packagePath, "utf8");
                     packageJson = JSON.parse(packageContent);
                 }
             }
@@ -344,31 +428,33 @@ let SDDToolAdapter = class SDDToolAdapter {
             }
             return `## Steering Documents Updated
 
-**Project**: ${packageJson.name || 'Unknown'}
+**Project**: ${packageJson.name || "Unknown"}
 **Mode**: ${updateMode}
 
 **Updated Files**:
 - \`.kiro/steering/product.md\` - Product overview and business context
-- \`.kiro/steering/tech.md\` - Technology stack and development environment  
+- \`.kiro/steering/tech.md\` - Technology stack and development environment
 - \`.kiro/steering/structure.md\` - Project organization and architectural decisions
 
 **Analysis**:
 - Technology stack: ${Object.keys({ ...packageJson.dependencies, ...packageJson.devDependencies }).length} dependencies detected
-- Project type: ${packageJson.type || 'Unknown'}
+- Project type: ${packageJson.type || "Unknown"}
 - Existing steering: Updated preserving customizations
 
 These steering documents provide consistent project context for all AI interactions and spec-driven development workflows.`;
         }
         catch (error) {
-            this.logger.error('Failed to generate steering documents', error);
+            this.logger.error("Failed to generate steering documents", error);
             throw new Error(`Failed to generate steering documents: ${error.message}`);
         }
     }
     async handleSteeringCustom(args) {
         const { fileName, topic, inclusionMode, filePattern } = args;
         const projectPath = process.cwd();
-        if (typeof fileName !== 'string' || typeof topic !== 'string' || typeof inclusionMode !== 'string') {
-            throw new Error('Invalid arguments: fileName, topic, and inclusionMode must be strings');
+        if (typeof fileName !== "string" ||
+            typeof topic !== "string" ||
+            typeof inclusionMode !== "string") {
+            throw new Error("Invalid arguments: fileName, topic, and inclusionMode must be strings");
         }
         const content = `# ${topic}
 
@@ -383,17 +469,19 @@ Define the purpose and scope of this steering document.
 Describe when and how this steering document should be applied.
 
 ## Inclusion Mode
-Mode: ${inclusionMode}${filePattern ? `
-Pattern: ${filePattern}` : ''}
+Mode: ${inclusionMode}${filePattern
+            ? `
+Pattern: ${filePattern}`
+            : ""}
 
 Generated on: ${new Date().toISOString()}
 `;
         await this.steeringService.createSteeringDocument(projectPath, {
             name: fileName,
-            type: 'CUSTOM',
+            type: "CUSTOM",
             mode: inclusionMode.toUpperCase(),
             patterns: filePattern ? [filePattern] : [],
-            content
+            content,
         });
         return `Custom steering document "${fileName}" created successfully with ${inclusionMode} inclusion mode.`;
     }
@@ -401,11 +489,11 @@ Generated on: ${new Date().toISOString()}
         // Try to read package.json for project info
         let packageJson = {};
         try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const packagePath = path.join(process.cwd(), 'package.json');
+            const fs = await import("fs");
+            const path = await import("path");
+            const packagePath = path.join(process.cwd(), "package.json");
             if (fs.existsSync(packagePath)) {
-                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                const packageContent = fs.readFileSync(packagePath, "utf8");
                 packageJson = JSON.parse(packageContent);
             }
         }
@@ -413,12 +501,14 @@ Generated on: ${new Date().toISOString()}
             // Ignore errors
         }
         return `# Product Overview
-    
+
 ## Product Description
-${packageJson.description || 'No description available'}
+${packageJson.description || "No description available"}
 
 ## Core Features
-${this.extractFeatures(packageJson, analysis).map((feature) => `- ${feature}`).join('\n')}
+${this.extractFeatures(packageJson, analysis)
+            .map((feature) => `- ${feature}`)
+            .join("\n")}
 
 ## Target Use Case
 ${this.generateTargetUseCase(packageJson)}
@@ -433,11 +523,11 @@ ${this.generateTargetUsers(packageJson)}`;
         // Try to read package.json for project info
         let packageJson = {};
         try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const packagePath = path.join(process.cwd(), 'package.json');
+            const fs = await import("fs");
+            const path = await import("path");
+            const packagePath = path.join(process.cwd(), "package.json");
             if (fs.existsSync(packagePath)) {
-                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                const packageContent = fs.readFileSync(packagePath, "utf8");
                 packageJson = JSON.parse(packageContent);
             }
         }
@@ -450,7 +540,7 @@ ${this.generateTargetUsers(packageJson)}`;
 ${this.generateTechStack(packageJson, analysis)}
 
 ## Development Environment
-- Node.js: ${packageJson.engines?.node || 'Unknown'}
+- Node.js: ${packageJson.engines?.node || "Unknown"}
 - Package Manager: npm
 
 ## Key Dependencies
@@ -482,124 +572,148 @@ ${this.generateWorkflow(analysis)}`;
         // Extract features from scripts
         if (packageJson.scripts) {
             if (packageJson.scripts.test)
-                features.push('Testing framework');
+                features.push("Testing framework");
             if (packageJson.scripts.build)
-                features.push('Build system');
+                features.push("Build system");
             if (packageJson.scripts.dev || packageJson.scripts.start)
-                features.push('Development server');
+                features.push("Development server");
             if (packageJson.scripts.lint)
-                features.push('Code linting');
+                features.push("Code linting");
             if (packageJson.scripts.typecheck)
-                features.push('Type checking');
+                features.push("Type checking");
         }
         // Extract features from dependencies
-        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
         if (deps?.express || deps?.fastify || deps?.koa)
-            features.push('Web server');
+            features.push("Web server");
         if (deps?.react || deps?.vue || deps?.angular)
-            features.push('Frontend framework');
+            features.push("Frontend framework");
         if (deps?.typescript)
-            features.push('TypeScript support');
+            features.push("TypeScript support");
         if (deps?.jest || deps?.mocha || deps?.vitest)
-            features.push('Unit testing');
+            features.push("Unit testing");
         if (deps?.eslint)
-            features.push('Code quality enforcement');
-        return features.length > 0 ? features : ['Core functionality to be defined'];
+            features.push("Code quality enforcement");
+        return features.length > 0
+            ? features
+            : ["Core functionality to be defined"];
     }
     generateTargetUseCase(packageJson) {
         if (packageJson.keywords) {
-            return `This product is designed for ${packageJson.keywords.join(', ')} use cases.`;
+            return `This product is designed for ${packageJson.keywords.join(", ")} use cases.`;
         }
-        return 'Target use cases to be defined based on project requirements.';
+        return "Target use cases to be defined based on project requirements.";
     }
     generateValueProposition(packageJson, analysis) {
         const features = this.extractFeatures(packageJson, analysis);
-        return features.map(feature => `- **${feature}**: Enhanced development experience`).join('\n');
+        return features
+            .map((feature) => `- **${feature}**: Enhanced development experience`)
+            .join("\n");
     }
     generateTargetUsers(packageJson) {
-        if (packageJson.keywords?.includes('cli')) {
-            return '- Command-line tool users\n- Developers and system administrators';
+        if (packageJson.keywords?.includes("cli")) {
+            return "- Command-line tool users\n- Developers and system administrators";
         }
-        if (packageJson.keywords?.includes('api')) {
-            return '- API consumers\n- Third-party integrators';
+        if (packageJson.keywords?.includes("api")) {
+            return "- API consumers\n- Third-party integrators";
         }
-        return '- Primary user persona\n- Secondary user persona';
+        return "- Primary user persona\n- Secondary user persona";
     }
     generateTechStack(packageJson, analysis) {
-        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
         const stack = [];
         if (deps?.typescript)
-            stack.push('TypeScript');
+            stack.push("TypeScript");
         if (deps?.node || packageJson.engines?.node)
-            stack.push('Node.js');
+            stack.push("Node.js");
         if (deps?.express)
-            stack.push('Express.js');
+            stack.push("Express.js");
         if (deps?.react)
-            stack.push('React');
+            stack.push("React");
         if (deps?.vue)
-            stack.push('Vue.js');
-        return stack.length > 0 ? stack.join(', ') : 'Technology stack to be defined';
+            stack.push("Vue.js");
+        return stack.length > 0
+            ? stack.join(", ")
+            : "Technology stack to be defined";
     }
     generateDependencyList(packageJson) {
         const production = Object.keys(packageJson.dependencies || {});
         const development = Object.keys(packageJson.devDependencies || {});
-        let list = '';
+        let list = "";
         if (production.length > 0) {
-            list += '### Production Dependencies\n';
-            list += production.slice(0, 10).map((dep) => `- ${dep}`).join('\n');
+            list += "### Production Dependencies\n";
+            list += production
+                .slice(0, 10)
+                .map((dep) => `- ${dep}`)
+                .join("\n");
         }
         if (development.length > 0) {
-            list += '\n### Development Dependencies\n';
-            list += development.slice(0, 10).map((dep) => `- ${dep}`).join('\n');
+            list += "\n### Development Dependencies\n";
+            list += development
+                .slice(0, 10)
+                .map((dep) => `- ${dep}`)
+                .join("\n");
         }
-        return list || 'Dependencies to be analyzed';
+        return list || "Dependencies to be analyzed";
     }
     generateArchitecturePatterns(analysis) {
         const patterns = [];
         // Try to analyze directory structure from filesystem
         try {
-            const fs = require('fs');
+            const fs = require("fs");
             const projectPath = process.cwd();
             const items = fs.readdirSync(projectPath, { withFileTypes: true });
             const directories = items
                 .filter((item) => item.isDirectory())
                 .map((item) => item.name);
-            if (directories.includes('src'))
-                patterns.push('Source code organization');
-            if (directories.includes('test') || directories.includes('__tests__'))
-                patterns.push('Test-driven development');
-            if (directories.includes('dist') || directories.includes('build'))
-                patterns.push('Build artifact separation');
+            if (directories.includes("src"))
+                patterns.push("Source code organization");
+            if (directories.includes("test") || directories.includes("__tests__"))
+                patterns.push("Test-driven development");
+            if (directories.includes("dist") || directories.includes("build"))
+                patterns.push("Build artifact separation");
         }
         catch (error) {
             // Ignore filesystem errors
         }
-        return patterns.length > 0 ? patterns.map(p => `- ${p}`).join('\n') : '- Patterns to be defined';
+        return patterns.length > 0
+            ? patterns.map((p) => `- ${p}`).join("\n")
+            : "- Patterns to be defined";
     }
     generateQualityStandards(packageJson) {
         const standards = [];
         if (packageJson.scripts?.lint)
-            standards.push('Code linting with ESLint');
+            standards.push("Code linting with ESLint");
         if (packageJson.scripts?.typecheck)
-            standards.push('Type checking with TypeScript');
+            standards.push("Type checking with TypeScript");
         if (packageJson.scripts?.test)
-            standards.push('Unit testing required');
-        return standards.length > 0 ? standards.map(s => `- ${s}`).join('\n') : '- Quality standards to be defined';
+            standards.push("Unit testing required");
+        return standards.length > 0
+            ? standards.map((s) => `- ${s}`).join("\n")
+            : "- Quality standards to be defined";
     }
     generateDirectoryStructure(analysis) {
         // Try to get directory structure from filesystem
         try {
-            const fs = require('fs');
+            const fs = require("fs");
             const projectPath = process.cwd();
             const items = fs.readdirSync(projectPath, { withFileTypes: true });
             const directories = items
-                .filter((item) => item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules')
+                .filter((item) => item.isDirectory() &&
+                !item.name.startsWith(".") &&
+                item.name !== "node_modules")
                 .map((item) => `- ${item.name}/`)
-                .join('\n');
-            return directories || 'Directory structure to be analyzed';
+                .join("\n");
+            return directories || "Directory structure to be analyzed";
         }
         catch (error) {
-            return 'Directory structure to be analyzed';
+            return "Directory structure to be analyzed";
         }
     }
     generateNamingConventions(analysis) {
@@ -618,11 +732,11 @@ ${this.generateWorkflow(analysis)}`;
         // Try to read package.json for scripts
         let packageJson = {};
         try {
-            const fs = require('fs');
-            const path = require('path');
-            const packagePath = path.join(process.cwd(), 'package.json');
+            const fs = require("fs");
+            const path = require("path");
+            const packagePath = path.join(process.cwd(), "package.json");
             if (fs.existsSync(packagePath)) {
-                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                const packageContent = fs.readFileSync(packagePath, "utf8");
                 packageJson = JSON.parse(packageContent);
             }
         }
@@ -630,7 +744,7 @@ ${this.generateWorkflow(analysis)}`;
             // Ignore errors
         }
         const scripts = packageJson.scripts || {};
-        let workflow = '## Development Commands\n';
+        let workflow = "## Development Commands\n";
         if (scripts.dev)
             workflow += `- \`npm run dev\` - Start development server\n`;
         if (scripts.build)
@@ -645,23 +759,23 @@ ${this.generateWorkflow(analysis)}`;
         await ensureStaticSteeringDocuments(projectPath, this.steeringService);
     }
     async createAgentsFile(projectPath) {
-        const fs = await import('fs');
-        const path = await import('path');
+        const fs = await import("fs");
+        const path = await import("path");
         // Check if AGENTS.md exists, if not create it based on CLAUDE.md
-        const agentsPath = path.join(projectPath, 'AGENTS.md');
+        const agentsPath = path.join(projectPath, "AGENTS.md");
         if (!fs.existsSync(agentsPath)) {
             // Try to read CLAUDE.md to use as template
-            const claudePath = path.join(projectPath, 'CLAUDE.md');
-            let agentsContent = '';
+            const claudePath = path.join(projectPath, "CLAUDE.md");
+            let agentsContent = "";
             if (fs.existsSync(claudePath)) {
                 // Read CLAUDE.md and adapt it for general agents
-                const claudeContent = fs.readFileSync(claudePath, 'utf8');
+                const claudeContent = fs.readFileSync(claudePath, "utf8");
                 agentsContent = claudeContent
-                    .replace(/# Claude Code Spec-Driven Development/g, '# AI Agent Spec-Driven Development')
-                    .replace(/Claude Code/g, 'AI Agent')
-                    .replace(/claude code/g, 'ai agent')
-                    .replace(/Claude/g, 'AI Agent')
-                    .replace(/claude/g, 'ai agent');
+                    .replace(/# Claude Code Spec-Driven Development/g, "# AI Agent Spec-Driven Development")
+                    .replace(/Claude Code/g, "AI Agent")
+                    .replace(/claude code/g, "ai agent")
+                    .replace(/Claude/g, "AI Agent")
+                    .replace(/claude/g, "ai agent");
             }
             else {
                 // Fallback to basic template if CLAUDE.md doesn't exist
@@ -678,7 +792,7 @@ Kiro-style Spec Driven Development implementation for AI agents across different
 
 ### Steering vs Specification
 
-**Steering** (\`.kiro/steering/\`) - Guide AI with project-wide rules and context  
+**Steering** (\`.kiro/steering/\`) - Guide AI with project-wide rules and context
 **Specs** (\`.kiro/specs/\`) - Formalize development process for individual features
 
 ### Active Specifications
@@ -694,7 +808,7 @@ Kiro-style Spec Driven Development implementation for AI agents across different
 ## Workflow
 
 ### Phase 0: Steering (Optional)
-Agent steering commands - Create/update steering documents  
+Agent steering commands - Create/update steering documents
 Agent steering-custom commands - Create custom steering for specialized contexts
 
 Note: Optional for new features or small additions. You can proceed directly to spec-init.
@@ -731,7 +845,7 @@ Managed by agent steering commands. Updates here reflect command changes.
 
 ### Custom Steering Files
 <!-- Added by agent steering-custom commands -->
-<!-- Format: 
+<!-- Format:
 - \`filename.md\`: Mode - Pattern(s) - Description
   Mode: Always|Conditional|Manual
   Pattern: File patterns for Conditional mode
@@ -757,13 +871,15 @@ SDDToolAdapter = __decorate([
     __param(3, inject(TYPES.QualityService)),
     __param(4, inject(TYPES.SteeringDocumentService)),
     __param(5, inject(TYPES.CodebaseAnalysisService)),
-    __param(6, inject(TYPES.LoggerPort)),
+    __param(6, inject(TYPES.RequirementsClarificationService)),
+    __param(7, inject(TYPES.LoggerPort)),
     __metadata("design:paramtypes", [ProjectService,
         WorkflowService,
         TemplateService,
         QualityService,
         SteeringDocumentService,
-        CodebaseAnalysisService, Object])
+        CodebaseAnalysisService,
+        RequirementsClarificationService, Object])
 ], SDDToolAdapter);
 export { SDDToolAdapter };
 //# sourceMappingURL=SDDToolAdapter.js.map