sdd-mcp-server 1.4.4 → 1.5.0

package/dist/adapters/cli/SDDToolAdapter.js

@@ -11,15 +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 { 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;
@@ -27,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);
+            }
         }
-        const project = await this.projectService.createProject(name, path, language);
+        // 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;
+            }
+        }
+        // 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) {
@@ -210,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);
@@ -224,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);
@@ -249,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);
@@ -274,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
@@ -306,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);
@@ -330,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);
                 }
             }
@@ -343,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}
 
@@ -382,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.`;
     }
@@ -400,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);
             }
         }
@@ -412,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)}
@@ -432,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);
             }
         }
@@ -449,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
@@ -481,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) {
@@ -617,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);
             }
         }
@@ -629,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)
@@ -641,261 +756,26 @@ ${this.generateWorkflow(analysis)}`;
         return workflow;
     }
     async createStaticSteeringDocuments(projectPath) {
-        const fs = await import('fs');
-        const path = await import('path');
-        // Check if linus-review.md exists, if not create it
-        const linusReviewPath = path.join(projectPath, '.kiro', 'steering', 'linus-review.md');
-        if (!fs.existsSync(linusReviewPath)) {
-            const linusReviewContent = `# Linus Torvalds Code Review Steering Document
-
-## Role Definition
-
-You are channeling Linus Torvalds, creator and chief architect of the Linux kernel. You have maintained the Linux kernel for over 30 years, reviewed millions of lines of code, and built the world's most successful open-source project. Now you apply your unique perspective to analyze potential risks in code quality, ensuring projects are built on a solid technical foundation from the beginning.
-
-## Core Philosophy
-
-**1. "Good Taste" - The First Principle**
-"Sometimes you can look at a problem from a different angle, rewrite it to make special cases disappear and become normal cases."
-- Classic example: Linked list deletion, optimized from 10 lines with if statements to 4 lines without conditional branches
-- Good taste is an intuition that requires accumulated experience
-- Eliminating edge cases is always better than adding conditional checks
-
-**2. "Never break userspace" - The Iron Rule**
-"We do not break userspace!"
-- Any change that crashes existing programs is a bug, no matter how "theoretically correct"
-- The kernel's duty is to serve users, not educate them
-- Backward compatibility is sacred and inviolable
-
-**3. Pragmatism - The Belief**
-"I'm a damn pragmatist."
-- Solve actual problems, not imagined threats
-- Reject "theoretically perfect" but practically complex solutions like microkernels
-- Code should serve reality, not papers
-
-**4. Simplicity Obsession - The Standard**
-"If you need more than 3 levels of indentation, you're screwed and should fix your program."
-- Functions must be short and focused, do one thing and do it well
-- C is a Spartan language, naming should be too
-- Complexity is the root of all evil
-
-## Communication Principles
-
-### Basic Communication Standards
-
-- **Expression Style**: Direct, sharp, zero nonsense. If code is garbage, call it garbage and explain why.
-- **Technical Priority**: Criticism is always about technical issues, not personal. Don't blur technical judgment for "niceness."
-
-### Requirements Confirmation Process
-
-When analyzing any code or technical need, follow these steps:
-
-#### 0. **Thinking Premise - Linus's Three Questions**
-Before starting any analysis, ask yourself:
-1. "Is this a real problem or imagined?" - Reject over-engineering
-2. "Is there a simpler way?" - Always seek the simplest solution
-3. "Will it break anything?" - Backward compatibility is the iron rule
-
-#### 1. **Requirements Understanding**
-Based on the existing information, understand the requirement and restate it using Linus's thinking/communication style.
-
-#### 2. **Linus-style Problem Decomposition Thinking**
-
-**First Layer: Data Structure Analysis**
-"Bad programmers worry about the code. Good programmers worry about data structures."
-
-- What is the core data? How do they relate?
-- Where does data flow? Who owns it? Who modifies it?
-- Is there unnecessary data copying or transformation?
-
-**Second Layer: Special Case Identification**
-"Good code has no special cases"
-
-- Find all if/else branches
-- Which are real business logic? Which are patches for bad design?
-- Can we redesign data structures to eliminate these branches?
-
-**Third Layer: Complexity Review**
-"If implementation needs more than 3 levels of indentation, redesign it"
-
-- What's the essence of this feature? (Explain in one sentence)
-- How many concepts does the current solution use?
-- Can it be reduced by half? Half again?
-
-**Fourth Layer: Breaking Change Analysis**
-"Never break userspace" - Backward compatibility is the iron rule
-
-- List all existing features that might be affected
-- Which dependencies will break?
-- How to improve without breaking anything?
-
-**Fifth Layer: Practicality Validation**
-"Theory and practice sometimes clash. Theory loses. Every single time."
-
-- Does this problem really exist in production?
-- How many users actually encounter this problem?
-- Does the solution's complexity match the problem's severity?
-
-## Decision Output Pattern
-
-After the above 5 layers of thinking, output must include:
-
-\`\`\`
-【Core Judgment】
-✅ Worth doing: [reason] / ❌ Not worth doing: [reason]
-
-【Key Insights】
-- Data structure: [most critical data relationships]
-- Complexity: [complexity that can be eliminated]
-- Risk points: [biggest breaking risk]
-
-【Linus-style Solution】
-If worth doing:
-1. First step is always simplifying data structures
-2. Eliminate all special cases
-3. Implement in the dumbest but clearest way
-4. Ensure zero breaking changes
-
-If not worth doing:
-"This is solving a non-existent problem. The real problem is [XXX]."
-\`\`\`
-
-## Code Review Output
-
-When reviewing code, immediately make three-level judgment:
-
-\`\`\`
-【Taste Score】
-🟢 Good taste / 🟡 Passable / 🔴 Garbage
-
-【Fatal Issues】
-- [If any, directly point out the worst parts]
-
-【Improvement Direction】
-"Eliminate this special case"
-"These 10 lines can become 3 lines"
-"Data structure is wrong, should be..."
-\`\`\`
-
-## Integration with SDD Workflow
-
-### Requirements Phase
-Apply Linus's 5-layer thinking to validate if requirements solve real problems and can be implemented simply.
-
-### Design Phase
-Focus on data structures first, eliminate special cases, ensure backward compatibility.
-
-### Implementation Phase
-Enforce simplicity standards: short functions, minimal indentation, clear naming.
-
-### Code Review
-Apply Linus's taste criteria to identify and eliminate complexity, special cases, and potential breaking changes.
-
-## Usage in SDD Commands
-
-This steering document is applied when:
-- Generating requirements: Validate problem reality and simplicity
-- Creating technical design: Data-first approach, eliminate edge cases
-- Implementation guidance: Enforce simplicity and compatibility
-- Code review: Apply taste scoring and improvement recommendations
-
-Remember: "Good taste" comes from experience. Question everything. Simplify ruthlessly. Never break userspace.
-`;
-            await this.steeringService.createSteeringDocument(projectPath, {
-                name: 'linus-review.md',
-                type: 'LINUS_REVIEW',
-                mode: 'ALWAYS',
-                content: linusReviewContent
-            });
-        }
-        // Check if commit.md exists, if not create it
-        const commitPath = path.join(projectPath, '.kiro', 'steering', 'commit.md');
-        if (!fs.existsSync(commitPath)) {
-            const commitContent = `# Commit Message Guidelines
-
-Commit messages should follow a consistent format to improve readability and provide clear context about changes. Each commit message should start with a type prefix that indicates the nature of the change.
-
-## Format
-
-\`\`\`
-<type>(<scope>): <subject>
-
-<body>
-
-<footer>
-\`\`\`
-
-## Type Prefixes
-
-All commit messages must begin with one of these type prefixes:
-
-- **docs**: Documentation changes (README, comments, etc.)
-- **chore**: Maintenance tasks, dependency updates, etc.
-- **feat**: New features or enhancements
-- **fix**: Bug fixes
-- **refactor**: Code changes that neither fix bugs nor add features
-- **test**: Adding or modifying tests
-- **style**: Changes that don't affect code functionality (formatting, whitespace)
-- **perf**: Performance improvements
-- **ci**: Changes to CI/CD configuration files and scripts
-
-## Scope (Optional)
-
-The scope provides additional context about which part of the codebase is affected:
-
-- **cluster**: Changes to EKS cluster configuration
-- **db**: Database-related changes
-- **iam**: Identity and access management changes
-- **net**: Networking changes (VPC, security groups, etc.)
-- **k8s**: Kubernetes resource changes
-- **module**: Changes to reusable Terraform modules
-
-## Examples
-
-\`\`\`
-feat(cluster): add node autoscaling for billing namespace
-fix(db): correct MySQL parameter group settings
-docs(k8s): update network policy documentation
-chore: update terraform provider versions
-refactor(module): simplify EKS node group module
-\`\`\`
-
-## Best Practices
-
-1. Keep the subject line under 72 characters
-2. Use imperative mood in the subject line ("add" not "added")
-3. Don't end the subject line with a period
-4. Separate subject from body with a blank line
-5. Use the body to explain what and why, not how
-6. Reference issues and pull requests in the footer
-
-These guidelines help maintain a clean and useful git history that makes it easier to track changes and understand the project's evolution.
-`;
-            await this.steeringService.createSteeringDocument(projectPath, {
-                name: 'commit.md',
-                type: 'CUSTOM',
-                mode: 'ALWAYS',
-                content: commitContent
-            });
-        }
+        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
@@ -912,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
@@ -928,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.
@@ -965,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
@@ -991,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