sdd-mcp-server 2.0.0 → 2.0.2

package/dist/index.js

@@ -22,8 +22,6 @@ if (isMCPMode) {
 import "reflect-metadata";
 import { createContainer } from "./infrastructure/di/container.js";
 import { TYPES } from "./infrastructure/di/types.js";
-import { ensureStaticSteeringDocuments } from "./application/services/staticSteering.js";
-import { loadDocumentGenerator, loadSpecGenerator, } from "./utils/moduleLoader.js";
 export async function createMCPServer() {
     const container = createContainer();
     const logger = container.get(TYPES.LoggerPort);
@@ -383,373 +381,6 @@ function handleLoaderFailure(context, error, allowFallback = false) {
     console.error(`[SDD-DEBUG] Using fallback templates for ${context}`);
     return { useFallback: true, error };
 }
-// Simplified steering implementation for MCP mode
-async function handleSteeringSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    const fsPromises = fs.promises;
-    const projectPath = process.cwd();
-    const stubSteeringService = {
-        async createSteeringDocument(projectDir, config) {
-            const docPath = path.join(projectDir, ".kiro", "steering", config.name);
-            await fsPromises.mkdir(path.dirname(docPath), { recursive: true });
-            await fsPromises.writeFile(docPath, config.content, "utf8");
-            return {
-                name: config.name,
-                path: docPath,
-                type: config.type,
-                mode: config.mode,
-                content: config.content,
-                patterns: config.patterns ?? [],
-                priority: config.priority ?? 50,
-                lastModified: new Date(),
-                isValid: true,
-            };
-        },
-    };
-    try {
-        // Create .kiro/steering directory if it doesn't exist
-        const steeringDir = path.join(projectPath, ".kiro", "steering");
-        if (!fs.existsSync(steeringDir)) {
-            fs.mkdirSync(steeringDir, { recursive: true });
-        }
-        let productContent;
-        let techContent;
-        let structureContent;
-        let projectAnalysis;
-        // Check if fallback is allowed via environment variable or args
-        const allowFallback = process.env.SDD_ALLOW_TEMPLATE_FALLBACK === "true" ||
-            args?.allowFallback === true;
-        try {
-            // Attempt to import and use the dynamic document generator (using unified module loader)
-            console.error("[SDD-DEBUG] Attempting to load documentGenerator using moduleLoader");
-            const { analyzeProject, generateProductDocument, generateTechDocument, generateStructureDocument, } = await loadDocumentGenerator();
-            console.error("[SDD-DEBUG] DocumentGenerator imported successfully, analyzing project...");
-            // Analyze project dynamically
-            projectAnalysis = await analyzeProject(projectPath);
-            console.error("[SDD-DEBUG] Project analysis completed, generating documents...");
-            // Generate documents dynamically
-            productContent = generateProductDocument(projectAnalysis);
-            techContent = generateTechDocument(projectAnalysis);
-            structureContent = generateStructureDocument(projectAnalysis);
-            console.error("[SDD-DEBUG] Dynamic document generation completed successfully");
-        }
-        catch (importError) {
-            // Use shared error handler
-            const { useFallback, error } = handleLoaderFailure("documentGenerator", importError, allowFallback);
-            // Fallback to basic templates
-            const packageJsonPath = path.join(projectPath, "package.json");
-            let projectName = "Unknown Project";
-            let projectVersion = "0.0.0";
-            try {
-                if (fs.existsSync(packageJsonPath)) {
-                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-                    projectName = packageJson.name || projectName;
-                    projectVersion = packageJson.version || projectVersion;
-                }
-            }
-            catch (pkgError) {
-                console.error("[SDD-DEBUG] Could not read package.json, using defaults");
-            }
-            productContent = `# Product Overview
-
-⚠️ **Warning**: This document was generated using fallback templates due to documentGenerator import failure.
-Error: ${error.message}
-
-## Product Description
-${projectName}
-
-**Project**: ${projectName}
-**Version**: ${projectVersion}
-**Type**: MCP Server Application
-
-## Core Features
-- Basic MCP server functionality
-- Spec-driven development workflow support
-
-## Target Use Case
-This project provides MCP server capabilities for AI agent integration.
-
-## Key Value Proposition
-- MCP protocol compatibility
-- AI agent integration support
-
-Generated on: ${new Date().toISOString()}
-`;
-            techContent = `# Technology Stack
-
-⚠️ **Warning**: This document was generated using fallback templates due to documentGenerator import failure.
-Error: ${error.message}
-
-## Architecture
-**Type**: MCP Server Application
-**Language**: TypeScript
-**Module System**: ES Module
-**Framework**: MCP SDK
-**Build Tool**: TypeScript Compiler
-
-## Technology Stack
-- **Node.js**: JavaScript runtime for server-side execution
-- **TypeScript**: Typed superset of JavaScript for enhanced developer experience
-- **MCP SDK**: Model Context Protocol SDK for AI agent integration
-
-## Development Environment
-- **Node Version**: >=18.0.0
-- **Package Manager**: npm
-- **Language**: TypeScript with type safety
-
-Generated on: ${new Date().toISOString()}
-`;
-            structureContent = `# Project Structure
-
-⚠️ **Warning**: This document was generated using fallback templates due to documentGenerator import failure.
-Error: ${error.message}
-
-## Directory Organization
-\`\`\`
-├── .kiro/                    # SDD workflow files
-│   ├── steering/            # Project steering documents
-│   └── specs/              # Feature specifications
-├── src/                     # Source code
-├── dist/                    # Build output
-├── package.json            # Project configuration
-├── tsconfig.json           # TypeScript configuration
-└── README.md               # Project documentation
-\`\`\`
-
-## Key Directories
-- **src/**: Main source code directory containing application logic
-- **dist/**: Compiled output for production deployment
-
-## Code Organization Patterns
-- **Domain-Driven Design**: Business logic isolated in domain layer
-- **Dependency Injection**: IoC container for managing dependencies
-
-Generated on: ${new Date().toISOString()}
-`;
-            // Create fallback project analysis for return message
-            const fallbackAnalysis = {
-                name: projectName,
-                version: projectVersion,
-                architecture: "MCP Server Application",
-                language: "typescript",
-                framework: "MCP SDK",
-                dependencies: [],
-                devDependencies: [],
-                testFramework: null,
-                buildTool: "TypeScript Compiler",
-                directories: ["src", "dist"],
-                hasCI: false,
-                hasDocker: false,
-            };
-            // Use fallback analysis for the return message
-            projectAnalysis = fallbackAnalysis;
-        }
-        // Write the dynamically generated files
-        fs.writeFileSync(path.join(steeringDir, "product.md"), productContent);
-        fs.writeFileSync(path.join(steeringDir, "tech.md"), techContent);
-        fs.writeFileSync(path.join(steeringDir, "structure.md"), structureContent);
-        await ensureStaticSteeringDocuments(projectPath, stubSteeringService);
-        // Ensure AGENTS.md exists (based on CLAUDE.md if available)
-        const agentsPath = path.join(projectPath, "AGENTS.md");
-        if (!fs.existsSync(agentsPath)) {
-            const claudePath = path.join(projectPath, "CLAUDE.md");
-            let agentsContent = "";
-            if (fs.existsSync(claudePath)) {
-                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, "/agent");
-            }
-            else {
-                agentsContent = `# AI Agent Spec-Driven Development
-
-Kiro-style Spec Driven Development implementation using MCP tools.
-
-## Project Context
-
-### Paths
-- Steering: \`.kiro/steering/\`
-- Specs: \`.kiro/specs/\`
-- Commands: \`.ai agent/commands/\`
-
-### Steering vs Specification
-
-**Steering** (\`.kiro/steering/\`) - Guide AI with project-wide rules and context  
-**Specs** (\`.kiro/specs/\`) - Formalize development process for individual features
-
-### Active Specifications
-- Check \`.kiro/specs/\` for active specifications
-- Use \`sdd-status\` to check progress
-
-**Current Specifications:**
-- (None active)
-
-## Development Guidelines
-- Think in English, generate responses in English
-
-## Workflow
-
-### Phase 0: Steering (Optional)
-\`sdd-steering\` - Create/update steering documents  
-\`sdd-steering-custom\` - Create custom steering for specialized contexts
-
-Note: Optional for new features or small additions. You can proceed directly to sdd-init.
-
-### Phase 1: Specification Creation
-1. \`sdd-init\` - Initialize spec with detailed project description
-2. \`sdd-requirements\` - Generate requirements document
-3. \`sdd-design\` - Interactive: "Have you reviewed requirements.md? [y/N]"
-4. \`sdd-tasks\` - Interactive: Confirms both requirements and design review
-
-### Phase 2: Progress Tracking
-\`sdd-status\` - Check current progress and phases
-
-## Development Rules
-1. **Consider steering**: Run \`sdd-steering\` before major development (optional for new features)
-2. **Follow 3-phase approval workflow**: Requirements → Design → Tasks → Implementation
-3. **Approval required**: Each phase requires human review (interactive prompt or manual)
-4. **No skipping phases**: Design requires approved requirements; Tasks require approved design
-5. **Update task status**: Mark tasks as completed when working on them
-6. **Keep steering current**: Run \`sdd-steering\` after significant changes
-7. **Check spec compliance**: Use \`sdd-status\` to verify alignment
-
-## Steering Configuration
-
-### Current Steering Files
-Managed by \`sdd-steering\` tool. Updates here reflect tool changes.
-
-### Active Steering Files
-- \`product.md\`: Always included - Product context and business objectives
-- \`tech.md\`: Always included - Technology stack and architectural decisions
-- \`structure.md\`: Always included - File organization and code patterns
-- \`linus-review.md\`: Always included - Ensuring code quality of the projects
-- \`commit.md\`: Always included - Ensuring the commit / merge request / pull request title and message context
-- \`security-check.md\`: Always included - OWASP Top 10 security checklist (REQUIRED for code generation and review)
-- \`tdd-guideline.md\`: Always included - Test-Driven Development workflow (REQUIRED for all new features)
-- \`principles.md\`: Always included - Core coding principles (SOLID, DRY, KISS, YAGNI, Separation of Concerns, Modularity)
-
-### Custom Steering Files
-<!-- Added by sdd-steering-custom tool -->
-<!-- Format: 
-- \`filename.md\`: Mode - Pattern(s) - Description
-  Mode: Always|Conditional|Manual
-  Pattern: File patterns for Conditional mode
--->
-
-### Inclusion Modes
-- **Always**: Loaded in every interaction (default)
-- **Conditional**: Loaded for specific file patterns (e.g., "*.test.js")
-- **Manual**: Reference with \`@filename.md\` syntax
-`;
-            }
-            fs.writeFileSync(agentsPath, agentsContent);
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `## Steering Documents Updated
-
-**Project**: ${projectAnalysis.name}
-**Version**: ${projectAnalysis.version}
-**Architecture**: ${projectAnalysis.architecture}
-**Mode**: update
-
-**Updated Files**:
-- \`.kiro/steering/product.md\` - Product overview and business context (dynamically generated)
-- \`.kiro/steering/tech.md\` - Technology stack and development environment (dynamically generated)
-- \`.kiro/steering/structure.md\` - Project organization and architectural decisions (dynamically generated)
-- \`.kiro/steering/linus-review.md\` - Code quality review principles (static)
-- \`.kiro/steering/commit.md\` - Commit message standards (static)
-- \`.kiro/steering/security-check.md\` - OWASP Top 10 security checklist (static)
-- \`.kiro/steering/principles.md\` - Core coding principles: SOLID, DRY, KISS, YAGNI, SoC, Modularity (static)
-
-**Dynamic Analysis Results**:
-- **Language**: ${projectAnalysis.language === "typescript" ? "TypeScript" : "JavaScript"}
-- **Framework**: ${projectAnalysis.framework || "None detected"}
-- **Dependencies**: ${projectAnalysis.dependencies.length} production, ${projectAnalysis.devDependencies.length} development
-- **Test Framework**: ${projectAnalysis.testFramework || "None detected"}
-- **Build Tool**: ${projectAnalysis.buildTool || "None detected"}
-- **Project Structure**: ${projectAnalysis.directories.length} directories analyzed
-- **CI/CD**: ${projectAnalysis.hasCI ? "Configured" : "Not configured"}
-- **Docker**: ${projectAnalysis.hasDocker ? "Configured" : "Not configured"}
-
-These steering documents were dynamically generated based on actual project analysis and provide accurate, up-to-date context for AI interactions.`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error generating steering documents: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-async function handleSteeringCustomSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    try {
-        const { fileName, topic, inclusionMode, filePattern } = args;
-        if (!fileName || !topic || !inclusionMode) {
-            throw new Error("fileName, topic, and inclusionMode are required");
-        }
-        const projectPath = process.cwd();
-        const steeringDir = path.join(projectPath, ".kiro", "steering");
-        if (!fs.existsSync(steeringDir)) {
-            fs.mkdirSync(steeringDir, { recursive: true });
-        }
-        const content = `# ${topic}
-
-## Purpose
-Define the purpose and scope of this steering document.
-
-## Guidelines
-- Guideline 1
-- Guideline 2
-
-## Usage
-Describe when and how this steering document should be applied.
-
-## Inclusion Mode
-Mode: ${inclusionMode}${filePattern
-            ? `
-Pattern: ${filePattern}`
-            : ""}
-
-Generated on: ${new Date().toISOString()}
-`;
-        fs.writeFileSync(path.join(steeringDir, fileName), content);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Custom steering document "${fileName}" created successfully with ${inclusionMode} inclusion mode.`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error creating custom steering document: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
 // Status handler aligned with full server behavior
 async function handleStatusSimplified(args) {
     const fs = await import("fs");
@@ -927,877 +558,6 @@ async function handleQualityCheckSimplified(args) {
         };
     }
 }
-// Implement guidelines check
-async function handleImplementSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    const { featureName } = args || {};
-    if (!featureName)
-        return {
-            content: [{ type: "text", text: "featureName is required" }],
-            isError: true,
-        };
-    try {
-        const featurePath = path.join(process.cwd(), ".kiro", "specs", featureName);
-        const specPath = path.join(featurePath, "spec.json");
-        const spec = JSON.parse(fs.readFileSync(specPath, "utf8"));
-        if (!spec.ready_for_implementation) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: Project not ready for implementation. Complete requirements, design, and tasks phases first.",
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `## Implementation Guidelines for ${featureName}\n\nFollow tasks in tasks.md, implement per design.md, and validate against requirements.md. Use sdd-quality-check during development.`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error getting implementation guidelines: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-// Helper functions for simplified analysis
-function extractFeaturesSimplified(packageJson) {
-    const features = [];
-    // Extract features from scripts
-    if (packageJson.scripts) {
-        if (packageJson.scripts.test)
-            features.push("Testing framework");
-        if (packageJson.scripts.build)
-            features.push("Build system");
-        if (packageJson.scripts.dev || packageJson.scripts.start)
-            features.push("Development server");
-        if (packageJson.scripts.lint)
-            features.push("Code linting");
-        if (packageJson.scripts.typecheck)
-            features.push("Type checking");
-    }
-    // Extract features from dependencies
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    if (deps?.express || deps?.fastify || deps?.koa)
-        features.push("Web server");
-    if (deps?.react || deps?.vue || deps?.angular)
-        features.push("Frontend framework");
-    if (deps?.typescript)
-        features.push("TypeScript support");
-    if (deps?.jest || deps?.mocha || deps?.vitest)
-        features.push("Unit testing");
-    if (deps?.eslint)
-        features.push("Code quality enforcement");
-    return features.length > 0 ? features : ["Core functionality"];
-}
-function generateTargetUsersSimplified(packageJson) {
-    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";
-    }
-    return "- Primary user persona\n- Secondary user persona";
-}
-function generateTechStackSimplified(packageJson) {
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const stack = [];
-    if (deps?.typescript)
-        stack.push("TypeScript");
-    if (deps?.node || packageJson.engines?.node)
-        stack.push("Node.js");
-    if (deps?.express)
-        stack.push("Express.js");
-    if (deps?.react)
-        stack.push("React");
-    if (deps?.vue)
-        stack.push("Vue.js");
-    return stack.length > 0 ? stack.join(", ") : "Technology stack to be defined";
-}
-function generateDependencyListSimplified(packageJson) {
-    const deps = packageJson.dependencies || {};
-    const devDeps = packageJson.devDependencies || {};
-    let list = "";
-    const depList = Object.keys(deps);
-    const devDepList = Object.keys(devDeps);
-    if (depList.length > 0) {
-        list += "### Production Dependencies\n";
-        list += depList
-            .slice(0, 10)
-            .map((dep) => `- ${dep}`)
-            .join("\n");
-    }
-    if (devDepList.length > 0) {
-        list += "\n### Development Dependencies\n";
-        list += devDepList
-            .slice(0, 10)
-            .map((dep) => `- ${dep}`)
-            .join("\n");
-    }
-    return list || "Dependencies to be analyzed";
-}
-function generateWorkflowSimplified(packageJson) {
-    const scripts = packageJson.scripts || {};
-    let workflow = "## Development Commands\n";
-    if (scripts.dev)
-        workflow += `- \`npm run dev\` - Start development server\n`;
-    if (scripts.build)
-        workflow += `- \`npm run build\` - Build for production\n`;
-    if (scripts.test)
-        workflow += `- \`npm run test\` - Run tests\n`;
-    if (scripts.lint)
-        workflow += `- \`npm run lint\` - Check code quality\n`;
-    return workflow;
-}
-function generateDirectoryStructureSimplified(projectPath) {
-    const fs = require("fs");
-    try {
-        const items = fs.readdirSync(projectPath, { withFileTypes: true });
-        const directories = items
-            .filter((item) => item.isDirectory() &&
-            !item.name.startsWith(".") &&
-            item.name !== "node_modules")
-            .map((item) => `- ${item.name}/`)
-            .join("\n");
-        return directories || "Directory structure to be analyzed";
-    }
-    catch (error) {
-        return "Directory structure to be analyzed";
-    }
-}
-// Additional context-aware SDD tools
-async function handleRequirementsSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    try {
-        const { featureName } = args;
-        if (!featureName || typeof featureName !== "string") {
-            throw new Error("Feature name is required for requirements generation");
-        }
-        // Load spec context
-        const { spec, requirements } = await loadSpecContext(featureName);
-        if (!spec) {
-            throw new Error(`Feature "${featureName}" not found. Run sdd-init first.`);
-        }
-        // Extract project description from spec
-        let projectDescription = "Feature requirements specification";
-        if (requirements) {
-            const descMatch = requirements.match(/## Project Description \(Input\)\n([\s\S]*?)(?:\n##|$)/);
-            if (descMatch) {
-                projectDescription = descMatch[1].trim();
-            }
-        }
-        // Generate analysis-backed requirements with proper error handling
-        let requirementsContent;
-        let analysisUsed = false;
-        // Check if fallback is allowed
-        const allowFallback = process.env.SDD_ALLOW_TEMPLATE_FALLBACK === "true" ||
-            args?.allowFallback === true;
-        try {
-            console.error("[SDD-DEBUG] Attempting to load specGenerator for comprehensive analysis...");
-            const { generateRequirementsDocument } = await loadSpecGenerator();
-            console.error("[SDD-DEBUG] specGenerator imported successfully, generating requirements...");
-            requirementsContent = await generateRequirementsDocument(process.cwd(), featureName);
-            analysisUsed = true;
-            console.error("[SDD-DEBUG] ✅ Requirements generated using comprehensive codebase analysis");
-        }
-        catch (genErr) {
-            // Use shared error handler
-            const { useFallback, error } = handleLoaderFailure("specGenerator", genErr, allowFallback);
-            requirementsContent = `# Requirements Document
-
-<!-- Note: Using basic template due to analysis error: ${error.message} -->
-
-## Introduction
-${generateIntroductionFromDescription(projectDescription)}
-
-## Requirements
-
-### Requirement 1: Core Functionality
-**Objective:** As a user, I want ${extractPrimaryObjective(projectDescription)}, so that ${extractPrimaryBenefit(projectDescription)}
-
-#### Acceptance Criteria
-${generateEARSRequirements(projectDescription)
-                .map((req, index) => `${index + 1}. ${req}`)
-                .join("\n")}
-
-### Requirement 2: System Quality
-**Objective:** As a user, I want the system to be reliable and performant, so that I can depend on it for my work
-
-#### Acceptance Criteria
-1. WHEN the system is used THEN it SHALL respond within acceptable time limits
-2. IF errors occur THEN the system SHALL handle them gracefully and provide meaningful feedback
-3. WHILE the system is running THE system SHALL maintain data integrity and consistency
-
-### Requirement 3: Usability
-**Objective:** As a user, I want the system to be intuitive and well-documented, so that I can use it effectively
-
-#### Acceptance Criteria
-1. WHEN I use the system for the first time THEN I SHALL be able to complete basic tasks without extensive training
-2. WHERE help is needed THE system SHALL provide clear documentation and guidance
-3. IF I make mistakes THEN the system SHALL provide helpful error messages and recovery options
-`;
-        }
-        // Update spec.json with phase information
-        const specDir = path.join(process.cwd(), ".kiro", "specs", featureName);
-        const updatedSpec = {
-            ...spec,
-            phase: "requirements-generated",
-            approvals: {
-                ...spec.approvals,
-                requirements: {
-                    generated: true,
-                    approved: false,
-                },
-            },
-            updated_at: new Date().toISOString(),
-        };
-        fs.writeFileSync(path.join(specDir, "spec.json"), JSON.stringify(updatedSpec, null, 2));
-        fs.writeFileSync(path.join(specDir, "requirements.md"), requirementsContent);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `## Requirements Document Generated
-
-**Feature**: \`${featureName}\`
-**File**: \`.kiro/specs/${featureName}/requirements.md\`
-
-**Analysis Method**: ${analysisUsed ? "✅ Comprehensive codebase analysis (multi-language support)" : "⚠️ Basic template (analysis failed)"}
-
-**Generated Requirements**:
-- Core functionality requirements with EARS format
-- System quality and reliability requirements
-- Usability and user experience requirements
-
-**Project Description**: "${projectDescription.substring(0, 100)}${projectDescription.length > 100 ? "..." : ""}"
-
-**Workflow Phase**: Requirements Generated
-**Next Step**: Run \`sdd-design ${featureName}\` to create technical design (after requirements review)`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error generating requirements document: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-async function handleDesignSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    try {
-        const { featureName } = args;
-        if (!featureName || typeof featureName !== "string") {
-            throw new Error("Feature name is required for design generation");
-        }
-        // Load spec context
-        const { spec, requirements } = await loadSpecContext(featureName);
-        if (!spec) {
-            throw new Error(`Feature "${featureName}" not found. Run sdd-init first.`);
-        }
-        // Validate phase - requirements must be generated
-        if (!spec.approvals?.requirements?.generated) {
-            throw new Error(`Requirements must be generated before design. Run sdd-requirements ${featureName} first.`);
-        }
-        // Extract project description from requirements
-        let projectDescription = "Technical design specification";
-        if (requirements) {
-            const descMatch = requirements.match(/## Project Description \(Input\)\n([\s\S]*?)(?:\n##|$)/);
-            if (descMatch) {
-                projectDescription = descMatch[1].trim();
-            }
-        }
-        // Generate analysis-backed design with proper error handling
-        let designContent;
-        let analysisUsed = false;
-        // Check if fallback is allowed
-        const allowFallback = process.env.SDD_ALLOW_TEMPLATE_FALLBACK === "true" ||
-            args?.allowFallback === true;
-        try {
-            console.error("[SDD-DEBUG] Attempting to load specGenerator for comprehensive design analysis...");
-            const { generateDesignDocument } = await loadSpecGenerator();
-            console.error("[SDD-DEBUG] specGenerator imported successfully, generating design...");
-            designContent = await generateDesignDocument(process.cwd(), featureName);
-            analysisUsed = true;
-            console.error("[SDD-DEBUG] ✅ Design generated using comprehensive codebase analysis");
-        }
-        catch (genErr) {
-            // Use shared error handler
-            const { useFallback, error } = handleLoaderFailure("specGenerator", genErr, allowFallback);
-            designContent = `# Technical Design Document
-
-<!-- Note: Using basic template due to analysis error: ${error.message} -->
-
-## Overview
-This design document specifies the technical implementation approach for ${spec.feature_name}.
-
-**Purpose**: ${projectDescription}
-
-### System Flow
-1. Input Processing
-2. Business Logic
-3. Result Generation
-4. Error Management
-`;
-        }
-        // Update spec.json with phase information
-        const specDir = path.join(process.cwd(), ".kiro", "specs", featureName);
-        const updatedSpec = {
-            ...spec,
-            phase: "design-generated",
-            approvals: {
-                ...spec.approvals,
-                design: {
-                    generated: true,
-                    approved: false,
-                },
-            },
-            updated_at: new Date().toISOString(),
-        };
-        fs.writeFileSync(path.join(specDir, "spec.json"), JSON.stringify(updatedSpec, null, 2));
-        fs.writeFileSync(path.join(specDir, "design.md"), designContent);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `## Design Document Generated
-
-**Feature**: \`${featureName}\`
-**File**: \`.kiro/specs/${featureName}/design.md\`
-
-**Analysis Method**: ${analysisUsed ? "✅ Comprehensive codebase analysis (architecture patterns detected)" : "⚠️ Basic template (analysis failed)"}
-
-**Design Elements**:
-- Modular architecture with clear component separation
-- Comprehensive interface specifications
-- Data models and error handling strategy
-- Complete testing approach
-
-**Project Description**: "${projectDescription.substring(0, 100)}${projectDescription.length > 100 ? "..." : ""}"
-
-**Workflow Phase**: Design Generated
-**Next Step**: Run \`sdd-tasks ${featureName}\` to generate implementation tasks (after design review)`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error generating design document: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-async function handleTasksSimplified(args) {
-    const fs = await import("fs");
-    const path = await import("path");
-    try {
-        const { featureName } = args;
-        if (!featureName || typeof featureName !== "string") {
-            throw new Error("Feature name is required for tasks generation");
-        }
-        // Load spec context
-        const { spec } = await loadSpecContext(featureName);
-        if (!spec) {
-            throw new Error(`Feature "${featureName}" not found. Run sdd-init first.`);
-        }
-        // Validate phase - design must be generated
-        if (!spec.approvals?.design?.generated) {
-            throw new Error(`Design must be generated before tasks. Run sdd-design ${featureName} first.`);
-        }
-        // Generate analysis-backed tasks with proper error handling
-        let tasksContent;
-        let analysisUsed = false;
-        // Check if fallback is allowed
-        const allowFallback = process.env.SDD_ALLOW_TEMPLATE_FALLBACK === "true" ||
-            args?.allowFallback === true;
-        try {
-            console.error("[SDD-DEBUG] Attempting to load specGenerator for comprehensive task analysis...");
-            const { generateTasksDocument } = await loadSpecGenerator();
-            console.error("[SDD-DEBUG] specGenerator imported successfully, generating tasks...");
-            tasksContent = await generateTasksDocument(process.cwd(), featureName);
-            analysisUsed = true;
-            console.error("[SDD-DEBUG] ✅ Tasks generated using comprehensive codebase analysis");
-        }
-        catch (genErr) {
-            // Use shared error handler
-            const { useFallback, error } = handleLoaderFailure("specGenerator", genErr, allowFallback);
-            tasksContent = `# Implementation Plan
-
-<!-- Note: Using basic template due to analysis error: ${error.message} -->
-
-- [ ] 1. Set up project foundation and infrastructure
-- [ ] 2. Implement core functionality
-- [ ] 3. Implement error handling and validation
-- [ ] 4. Develop testing and quality assurance
-- [ ] 5. Finalize implementation and deployment
-`;
-        }
-        // Update spec.json with phase information
-        const specDir = path.join(process.cwd(), ".kiro", "specs", featureName);
-        const updatedSpec = {
-            ...spec,
-            phase: "tasks-generated",
-            approvals: {
-                ...spec.approvals,
-                tasks: {
-                    generated: true,
-                    approved: false,
-                },
-            },
-            ready_for_implementation: true,
-            updated_at: new Date().toISOString(),
-        };
-        fs.writeFileSync(path.join(specDir, "spec.json"), JSON.stringify(updatedSpec, null, 2));
-        fs.writeFileSync(path.join(specDir, "tasks.md"), tasksContent);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `## Implementation Tasks Generated
-
-**Feature**: \`${featureName}\`
-**File**: \`.kiro/specs/${featureName}/tasks.md\`
-
-**Analysis Method**: ${analysisUsed ? "✅ Comprehensive codebase analysis (tech stack-aware tasks)" : "⚠️ Basic template (analysis failed)"}
-
-**Generated Tasks**:
-- Development, integration, quality, and deployment phases
-- Sequenced with dependency tracking
-- Requirement traceability for all tasks
-- Coverage based on detected tech stack
-
-**Workflow Phase**: Tasks Generated
-**Status**: Ready for Implementation
-**Next Step**: Begin implementation following the task sequence`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error generating tasks document: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-// Helper functions for simplified tool implementations
-function analyzeProjectStructureSync(projectPath) {
-    const fs = require("fs");
-    try {
-        const items = fs.readdirSync(projectPath, { withFileTypes: true });
-        return {
-            directories: items
-                .filter((item) => item.isDirectory() &&
-                !item.name.startsWith(".") &&
-                item.name !== "node_modules")
-                .map((item) => item.name),
-            files: items
-                .filter((item) => item.isFile())
-                .map((item) => item.name),
-            hasSource: items.some((item) => item.isDirectory() && item.name === "src"),
-            hasTests: items.some((item) => item.isDirectory() &&
-                (item.name === "test" || item.name === "__tests__")),
-            hasDocs: items.some((item) => item.isDirectory() &&
-                (item.name === "docs" || item.name === "documentation")),
-        };
-    }
-    catch (error) {
-        return { directories: [], files: [] };
-    }
-}
-function generateCoreObjectiveSimplified(packageJson, projectAnalysis) {
-    if (packageJson.description) {
-        return `Deliver ${packageJson.description} with full functionality and reliability`;
-    }
-    if (packageJson.keywords?.length > 0) {
-        return `Implement ${packageJson.keywords.join(", ")} functionality`;
-    }
-    return "Deliver core application functionality";
-}
-function generateAcceptanceCriteriaSimplified(packageJson, projectAnalysis) {
-    const criteria = [];
-    if (packageJson.scripts?.test) {
-        criteria.push("WHEN tests are run THEN all tests SHALL pass");
-    }
-    if (packageJson.scripts?.build) {
-        criteria.push("WHEN build is executed THEN system SHALL compile without errors");
-    }
-    if (packageJson.scripts?.lint) {
-        criteria.push("WHERE code quality is checked THE system SHALL meet linting standards");
-    }
-    if (packageJson.main || packageJson.bin) {
-        criteria.push("WHEN application starts THEN system SHALL initialize successfully");
-    }
-    criteria.push("IF errors occur THEN system SHALL handle them gracefully");
-    return criteria.length > 0
-        ? criteria
-        : ["System SHALL meet functional requirements"];
-}
-function generateTechRequirementsSimplified(packageJson) {
-    const requirements = [];
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    if (deps?.typescript) {
-        requirements.push("System SHALL use TypeScript for type safety");
-    }
-    if (deps?.express || deps?.fastify) {
-        requirements.push("System SHALL implement RESTful API endpoints");
-    }
-    if (deps?.react || deps?.vue || deps?.angular) {
-        requirements.push("System SHALL provide responsive user interface");
-    }
-    if (deps?.jest || deps?.mocha || deps?.vitest) {
-        requirements.push("System SHALL include comprehensive test coverage");
-    }
-    return requirements.length > 0
-        ? requirements
-        : ["System SHALL integrate required technologies"];
-}
-function generateQualityRequirementsSimplified(packageJson) {
-    const requirements = [];
-    if (packageJson.scripts?.lint) {
-        requirements.push("Code SHALL pass linting checks");
-    }
-    if (packageJson.scripts?.typecheck) {
-        requirements.push("Code SHALL pass type checking");
-    }
-    if (packageJson.scripts?.test) {
-        requirements.push("Code SHALL maintain test coverage standards");
-    }
-    requirements.push("Code SHALL follow established conventions");
-    return requirements;
-}
-function generateArchitectureDescriptionSimplified(packageJson, projectAnalysis) {
-    let description = "";
-    if (packageJson.type === "module") {
-        description += "Modern ES Module-based architecture. ";
-    }
-    if (projectAnalysis.hasSource) {
-        description +=
-            "Modular source code organization with clear separation of concerns. ";
-    }
-    if (packageJson.dependencies?.express) {
-        description +=
-            "RESTful API server architecture using Express.js framework. ";
-    }
-    if (packageJson.dependencies?.typescript ||
-        packageJson.devDependencies?.typescript) {
-        description += "Type-safe development with TypeScript compilation. ";
-    }
-    return (description ||
-        "Application architecture to be defined based on requirements.");
-}
-function generateComponentDescriptionsSimplified(projectAnalysis) {
-    const components = [];
-    if (projectAnalysis.hasSource) {
-        components.push({
-            name: "Core Module",
-            description: "Main application logic and business rules",
-        });
-    }
-    if (projectAnalysis.hasTests) {
-        components.push({
-            name: "Test Suite",
-            description: "Automated testing framework and test cases",
-        });
-    }
-    if (projectAnalysis.hasDocs) {
-        components.push({
-            name: "Documentation",
-            description: "Project documentation and API specifications",
-        });
-    }
-    return components.length > 0
-        ? components
-        : [
-            {
-                name: "Application Core",
-                description: "Main application functionality",
-            },
-        ];
-}
-function generateDataModelsSimplified(packageJson, projectAnalysis) {
-    const models = [];
-    if (packageJson.dependencies?.mongoose || packageJson.dependencies?.mongodb) {
-        models.push("MongoDB Document Models");
-    }
-    if (packageJson.dependencies?.sequelize ||
-        packageJson.dependencies?.typeorm) {
-        models.push("Relational Database Models");
-    }
-    if (packageJson.dependencies?.graphql) {
-        models.push("GraphQL Schema Models");
-    }
-    return models.length > 0 ? models : ["Application Data Models"];
-}
-function generateDetailedTechStackSimplified(packageJson) {
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const stack = [];
-    if (deps?.typescript)
-        stack.push("- **TypeScript**: Type-safe JavaScript development");
-    if (deps?.node || packageJson.engines?.node)
-        stack.push(`- **Node.js**: ${packageJson.engines?.node || "Runtime environment"}`);
-    if (deps?.express)
-        stack.push("- **Express.js**: Web application framework");
-    if (deps?.react)
-        stack.push("- **React**: User interface library");
-    if (deps?.vue)
-        stack.push("- **Vue.js**: Progressive frontend framework");
-    if (deps?.jest)
-        stack.push("- **Jest**: Testing framework");
-    return stack.length > 0
-        ? stack.join("\n")
-        : "- Technology stack to be defined";
-}
-function generateDesignPatternsSimplified(packageJson, projectAnalysis) {
-    const patterns = [];
-    if (packageJson.dependencies?.inversify) {
-        patterns.push("Dependency Injection");
-    }
-    if (projectAnalysis.hasSource) {
-        patterns.push("Modular Architecture");
-    }
-    if (packageJson.dependencies?.express || packageJson.dependencies?.fastify) {
-        patterns.push("MVC Pattern");
-    }
-    return patterns.length > 0 ? patterns : ["Standard Design Patterns"];
-}
-function generateDependencyAnalysisSimplified(packageJson) {
-    const production = Object.keys(packageJson.dependencies || {});
-    const development = Object.keys(packageJson.devDependencies || {});
-    let analysis = "";
-    if (production.length > 0) {
-        analysis += `**Production Dependencies:** ${production.length} packages\n`;
-        analysis += production
-            .slice(0, 5)
-            .map((dep) => `- ${dep}`)
-            .join("\n");
-        if (production.length > 5)
-            analysis += `\n- ... and ${production.length - 5} more`;
-    }
-    if (development.length > 0) {
-        analysis += `\n\n**Development Dependencies:** ${development.length} packages\n`;
-        analysis += development
-            .slice(0, 5)
-            .map((dep) => `- ${dep}`)
-            .join("\n");
-        if (development.length > 5)
-            analysis += `\n- ... and ${development.length - 5} more`;
-    }
-    return analysis || "Dependencies to be analyzed";
-}
-function generateAPIInterfacesSimplified(packageJson, projectAnalysis) {
-    if (packageJson.dependencies?.express || packageJson.dependencies?.fastify) {
-        return `RESTful API endpoints following OpenAPI specification:
-- GET /api/health - Health check endpoint
-- Authentication and authorization middleware
-- Request/response validation
-- Error handling middleware`;
-    }
-    return "Interface specifications to be defined";
-}
-function generateModuleInterfacesSimplified(projectAnalysis) {
-    if (projectAnalysis.hasSource) {
-        return `Internal module interfaces:
-- Clear module boundaries and exports
-- Consistent API patterns across modules
-- Type definitions for all public interfaces`;
-    }
-    return "Module interfaces to be defined";
-}
-function generateEnvVarSpecsSimplified(packageJson) {
-    const envVars = [];
-    if (packageJson.dependencies?.express || packageJson.dependencies?.fastify) {
-        envVars.push("- `PORT`: Server port (default: 3000)");
-        envVars.push("- `NODE_ENV`: Environment mode (development/production)");
-    }
-    envVars.push("- `LOG_LEVEL`: Logging level (debug/info/warn/error)");
-    return envVars.join("\n");
-}
-function generateBuildConfigSimplified(packageJson) {
-    let config = "";
-    if (packageJson.scripts?.build) {
-        config += `Build process: \`${packageJson.scripts.build}\`\n`;
-    }
-    if (packageJson.scripts?.start) {
-        config += `Start command: \`${packageJson.scripts.start}\`\n`;
-    }
-    if (packageJson.type === "module") {
-        config += "Module type: ES Modules\n";
-    }
-    return config || "Build configuration to be defined";
-}
-function generateImplementationTasksSimplified(packageJson, projectAnalysis) {
-    const tasks = {
-        development: [],
-        integration: [],
-        quality: [],
-        deployment: [],
-    };
-    // Development tasks
-    if (projectAnalysis.hasSource) {
-        tasks.development.push({
-            title: "Implement Core Modules",
-            subtasks: [
-                "Set up module structure",
-                "Implement business logic",
-                "Add error handling",
-            ],
-            requirements: "FR-1, FR-2",
-        });
-    }
-    if (packageJson.dependencies?.express) {
-        tasks.development.push({
-            title: "Develop API Endpoints",
-            subtasks: [
-                "Create route handlers",
-                "Add middleware",
-                "Implement validation",
-            ],
-            requirements: "FR-2",
-        });
-    }
-    // Integration tasks
-    if (packageJson.dependencies?.mongodb || packageJson.dependencies?.mongoose) {
-        tasks.integration.push({
-            title: "Database Integration",
-            subtasks: [
-                "Set up database connection",
-                "Create data models",
-                "Implement queries",
-            ],
-            requirements: "NFR-2",
-        });
-    }
-    // Quality tasks
-    if (packageJson.scripts?.test) {
-        tasks.quality.push({
-            title: "Test Implementation",
-            subtasks: [
-                "Write unit tests",
-                "Add integration tests",
-                "Ensure test coverage",
-            ],
-            requirements: "FR-3, NFR-3",
-        });
-    }
-    if (packageJson.scripts?.lint) {
-        tasks.quality.push({
-            title: "Code Quality Assurance",
-            subtasks: [
-                "Run linting checks",
-                "Fix code style issues",
-                "Add documentation",
-            ],
-            requirements: "NFR-3",
-        });
-    }
-    // Deployment tasks
-    if (packageJson.scripts?.build) {
-        tasks.deployment.push({
-            title: "Build and Package",
-            subtasks: [
-                "Run build process",
-                "Optimize for production",
-                "Create deployment artifacts",
-            ],
-            requirements: "NFR-1",
-        });
-    }
-    tasks.deployment.push({
-        title: "Deployment Configuration",
-        subtasks: [
-            "Set up environment variables",
-            "Configure production settings",
-            "Deploy to target environment",
-        ],
-        requirements: "NFR-1, NFR-2",
-    });
-    return tasks;
-}
-// Helper functions for requirement generation from description
-function generateIntroductionFromDescription(description) {
-    const systemName = extractSystemName(description);
-    return `This document specifies the requirements for ${systemName}. The system aims to ${description.toLowerCase()}.`;
-}
-function extractSystemName(description) {
-    // Extract a system name from description
-    const words = description.split(" ");
-    if (words.length >= 2) {
-        return `the ${words.slice(0, 3).join(" ")}`;
-    }
-    return "the system";
-}
-function extractPrimaryObjective(description) {
-    // Convert description into user objective
-    if (description.toLowerCase().includes("tool") ||
-        description.toLowerCase().includes("cli")) {
-        return `use a tool that ${description.toLowerCase()}`;
-    }
-    if (description.toLowerCase().includes("system") ||
-        description.toLowerCase().includes("application")) {
-        return `access a system that ${description.toLowerCase()}`;
-    }
-    return `have functionality that ${description.toLowerCase()}`;
-}
-function extractPrimaryBenefit(description) {
-    // Infer benefit from description
-    if (description.toLowerCase().includes("automate")) {
-        return "I can save time and reduce manual effort";
-    }
-    if (description.toLowerCase().includes("analyze") ||
-        description.toLowerCase().includes("review")) {
-        return "I can make better informed decisions";
-    }
-    if (description.toLowerCase().includes("manage") ||
-        description.toLowerCase().includes("organize")) {
-        return "I can maintain better control and organization";
-    }
-    return "I can accomplish my goals more effectively";
-}
-function generateEARSRequirements(description) {
-    const requirements = [];
-    // Core functional requirement
-    requirements.push(`WHEN I use the system THEN it SHALL provide ${description.toLowerCase()} functionality`);
-    // Input/output handling
-    requirements.push("WHEN I provide input THEN the system SHALL validate and process it correctly");
-    // Error handling
-    requirements.push("IF invalid input is provided THEN the system SHALL reject it with clear error messages");
-    // Success condition
-    requirements.push("WHEN all inputs are valid THEN the system SHALL complete the requested operation successfully");
-    return requirements;
-}
-// Helper functions for kiro-style workflow
 function generateFeatureName(description) {
     // Extract feature name from description - similar to kiro spec-init
     const cleaned = description