sdd-mcp-server 1.1.22 → 1.2.0

package/README.md

@@ -6,7 +6,7 @@
 
 A Model Context Protocol (MCP) server implementing Spec-Driven Development (SDD) workflows for AI-agent CLIs and IDEs like Claude Code, Cursor, and others.
 
-> **✅ v1.1.21 Update**: Resolved MCP server connection issues. Use global installation (`npm install -g`) instead of npx for reliable Claude Code integration.
+> **✅ v1.2.0 Update**: Complete kiro workflow alignment with empty project support. SDD tools now bootstrap from project descriptions without requiring existing files.
 
 ## 🚀 Quick Start
 
@@ -111,46 +111,57 @@ Once connected to your AI client, you can use these MCP tools:
 | Tool | Description | Usage |
 |------|-------------|--------|
 | `sdd-init` | Initialize new SDD project | Creates .kiro directory structure |
-| `sdd-requirements` | Generate requirements doc | Creates requirements.md from project analysis |
-| `sdd-design` | Create design specifications | Generates design.md with architecture |
-| `sdd-tasks` | Generate task breakdown | Creates tasks.md with implementation plan |
+| `sdd-requirements` | Generate context-aware requirements | Analyzes package.json and structure to create EARS-formatted requirements |
+| `sdd-design` | Create project-specific design | Generates architecture docs based on actual tech stack and dependencies |
+| `sdd-tasks` | Generate implementation breakdown | Creates tasks derived from real project structure and technology choices |
 | `sdd-implement` | Implementation guidelines | Provides implementation steering |
 | `sdd-status` | Check workflow progress | Shows current phase and approvals |
 | `sdd-approve` | Approve workflow phases | Mark phases as approved for progression |
 | `sdd-quality-check` | Code quality analysis | Linus-style 5-layer code review |
 | `sdd-context-load` | Load project context | Restore project memory and state |
 | `sdd-template-render` | Render templates | Generate files from templates |
+| `sdd-steering` | Create/update steering docs | Analyzes project to generate product.md, tech.md, structure.md with real content |
+| `sdd-steering-custom` | Create custom steering docs | Add specialized guidance documents |
+| `sdd-validate-design` | Design quality validation | Interactive GO/NO-GO design review |
+| `sdd-validate-gap` | Implementation gap analysis | Analyze requirements vs codebase |
+| `sdd-spec-impl` | Execute tasks with TDD | Kent Beck's Red-Green-Refactor methodology |
 
 ## 💡 Basic Workflow
 
-1. **Initialize Project**
+1. **Initialize Project & Steering**
    ```
    Use sdd-init to create a new SDD project
+   Use sdd-steering to generate core steering documents
    ```
 
 2. **Generate Requirements**
    ```
-   Use sdd-requirements to analyze and document requirements
+   Use sdd-requirements to analyze package.json and create context-aware requirements
+   Use sdd-validate-gap to analyze implementation feasibility
    ```
 
 3. **Create Design**
    ```
-   Use sdd-design to generate technical architecture
+   Use sdd-design to generate architecture based on actual dependencies
+   Use sdd-validate-design for GO/NO-GO design review
    ```
 
 4. **Plan Tasks**
    ```
-   Use sdd-tasks to break down implementation work
+   Use sdd-tasks to create implementation breakdown from real project structure
    ```
 
-5. **Implement**
+5. **Implement with TDD**
    ```
-   Use sdd-implement for implementation guidance
+   Use sdd-spec-impl to execute tasks with TDD methodology
+   Use sdd-quality-check for code review and analysis
    ```
 
-6. **Quality Check**
+6. **Monitor & Manage**
    ```
-   Use sdd-quality-check for code review and analysis
+   Use sdd-status to check workflow progress
+   Use sdd-approve to approve workflow phases
+   Use sdd-context-load to restore project memory
    ```
 
 ## ⚙️ Configuration
@@ -195,9 +206,12 @@ claude mcp add sdd "sdd-mcp-server"
 ## 🏗️ Key Features
 
 - **5-Phase SDD Workflow**: INIT → REQUIREMENTS → DESIGN → TASKS → IMPLEMENTATION
+- **Context-Aware Generation**: Analyzes package.json, dependencies, and project structure for real content
+- **EARS-Formatted Requirements**: Generate acceptance criteria based on actual npm scripts and dependencies
+- **Architecture Analysis**: Technology stack detection and pattern recognition from real codebase
 - **Quality Enforcement**: Linus-style 5-layer code review system
 - **Multi-Language Support**: 10 languages with cultural adaptation
-- **Template Engine**: Handlebars-based file generation
+- **Template Engine**: Handlebars-based file generation with project-specific data
 - **Plugin System**: Extensible architecture for custom workflows
 - **MCP Protocol**: Full compatibility with AI-agent CLIs and IDEs
 

package/dist/adapters/cli/SDDToolAdapter.d.ts

@@ -3,6 +3,8 @@ 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 { LoggerPort } from '../../domain/ports.js';
 export interface SDDToolHandler {
     name: string;
@@ -14,8 +16,10 @@ export declare class SDDToolAdapter {
     private readonly workflowService;
     private readonly templateService;
     private readonly qualityService;
+    private readonly steeringService;
+    private readonly codebaseAnalysisService;
     private readonly logger;
-    constructor(projectService: ProjectService, workflowService: WorkflowService, templateService: TemplateService, qualityService: QualityService, logger: LoggerPort);
+    constructor(projectService: ProjectService, workflowService: WorkflowService, templateService: TemplateService, qualityService: QualityService, steeringService: SteeringDocumentService, codebaseAnalysisService: CodebaseAnalysisService, logger: LoggerPort);
     getSDDTools(): SDDToolHandler[];
     private handleProjectInit;
     private handleProjectStatus;
@@ -23,4 +27,21 @@ export declare class SDDToolAdapter {
     private handleDesign;
     private handleTasks;
     private handleQualityCheck;
+    private handleSteering;
+    private handleSteeringCustom;
+    private generateProductSteering;
+    private generateTechSteering;
+    private generateStructureSteering;
+    private extractFeatures;
+    private generateTargetUseCase;
+    private generateValueProposition;
+    private generateTargetUsers;
+    private generateTechStack;
+    private generateDependencyList;
+    private generateArchitecturePatterns;
+    private generateQualityStandards;
+    private generateDirectoryStructure;
+    private generateNamingConventions;
+    private generateModuleOrganization;
+    private generateWorkflow;
 }

package/dist/adapters/cli/SDDToolAdapter.js

@@ -17,18 +17,24 @@ 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';
 let SDDToolAdapter = class SDDToolAdapter {
     projectService;
     workflowService;
     templateService;
     qualityService;
+    steeringService;
+    codebaseAnalysisService;
     logger;
-    constructor(projectService, workflowService, templateService, qualityService, logger) {
+    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, logger) {
         this.projectService = projectService;
         this.workflowService = workflowService;
         this.templateService = templateService;
         this.qualityService = qualityService;
+        this.steeringService = steeringService;
+        this.codebaseAnalysisService = codebaseAnalysisService;
         this.logger = logger;
     }
     getSDDTools() {
@@ -37,15 +43,13 @@ let SDDToolAdapter = class SDDToolAdapter {
                 name: 'sdd-init',
                 tool: {
                     name: 'sdd-init',
-                    description: 'Initialize a new SDD project with directory structure and spec files',
+                    description: 'Initialize a new SDD project from description',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            name: { type: 'string', description: 'Project name' },
-                            path: { type: 'string', description: 'Project path' },
-                            language: { type: 'string', enum: ['en', 'ja', 'zh-TW'], default: 'en' }
+                            description: { type: 'string', description: 'Detailed project description' }
                         },
-                        required: ['name', 'path']
+                        required: ['description']
                     }
                 },
                 handler: this.handleProjectInit.bind(this)
@@ -69,13 +73,13 @@ let SDDToolAdapter = class SDDToolAdapter {
                 name: 'sdd-requirements',
                 tool: {
                     name: 'sdd-requirements',
-                    description: 'Generate requirements document template',
+                    description: 'Generate requirements doc',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            projectId: { type: 'string', description: 'Project ID' }
+                            featureName: { type: 'string', description: 'Feature name' }
                         },
-                        required: ['projectId']
+                        required: ['featureName']
                     }
                 },
                 handler: this.handleRequirements.bind(this)
@@ -84,13 +88,13 @@ let SDDToolAdapter = class SDDToolAdapter {
                 name: 'sdd-design',
                 tool: {
                     name: 'sdd-design',
-                    description: 'Generate design document template',
+                    description: 'Create design specifications',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            projectId: { type: 'string', description: 'Project ID' }
+                            featureName: { type: 'string', description: 'Feature name' }
                         },
-                        required: ['projectId']
+                        required: ['featureName']
                     }
                 },
                 handler: this.handleDesign.bind(this)
@@ -99,13 +103,13 @@ let SDDToolAdapter = class SDDToolAdapter {
                 name: 'sdd-tasks',
                 tool: {
                     name: 'sdd-tasks',
-                    description: 'Generate implementation tasks document',
+                    description: 'Generate task breakdown',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            projectId: { type: 'string', description: 'Project ID' }
+                            featureName: { type: 'string', description: 'Feature name' }
                         },
-                        required: ['projectId']
+                        required: ['featureName']
                     }
                 },
                 handler: this.handleTasks.bind(this)
@@ -125,6 +129,38 @@ let SDDToolAdapter = class SDDToolAdapter {
                     }
                 },
                 handler: this.handleQualityCheck.bind(this)
+            },
+            {
+                name: 'sdd-steering',
+                tool: {
+                    name: 'sdd-steering',
+                    description: 'Create/update steering documents with project-specific analysis',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            updateMode: { type: 'string', enum: ['create', 'update'], description: 'Whether to create new or update existing documents' }
+                        }
+                    }
+                },
+                handler: this.handleSteering.bind(this)
+            },
+            {
+                name: 'sdd-steering-custom',
+                tool: {
+                    name: 'sdd-steering-custom',
+                    description: 'Create custom steering documents for specialized contexts',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            fileName: { type: 'string', description: 'Filename for the custom steering document' },
+                            topic: { type: 'string', description: 'Topic/purpose of the custom steering document' },
+                            inclusionMode: { type: 'string', enum: ['always', 'conditional', 'manual'], description: 'How this steering document should be included' },
+                            filePattern: { type: 'string', description: 'File pattern for conditional inclusion' }
+                        },
+                        required: ['fileName', 'topic', 'inclusionMode']
+                    }
+                },
+                handler: this.handleSteeringCustom.bind(this)
             }
         ];
     }
@@ -256,6 +292,348 @@ let SDDToolAdapter = class SDDToolAdapter {
         });
         return this.qualityService.formatQualityReport(report);
     }
+    async handleSteering(args) {
+        const { updateMode = 'update' } = args;
+        const projectPath = process.cwd();
+        try {
+            // Analyze the project
+            const analysis = await this.codebaseAnalysisService.analyzeCodebase(projectPath);
+            // Generate steering documents based on project analysis
+            const productContent = await this.generateProductSteering(analysis);
+            const techContent = await this.generateTechSteering(analysis);
+            const structureContent = await this.generateStructureSteering(analysis);
+            // Create steering documents
+            await this.steeringService.createSteeringDocument(projectPath, {
+                name: 'product.md',
+                type: 'PRODUCT',
+                mode: 'ALWAYS',
+                content: productContent
+            });
+            await this.steeringService.createSteeringDocument(projectPath, {
+                name: 'tech.md',
+                type: 'TECHNICAL',
+                mode: 'ALWAYS',
+                content: techContent
+            });
+            await this.steeringService.createSteeringDocument(projectPath, {
+                name: 'structure.md',
+                type: 'STRUCTURE',
+                mode: 'ALWAYS',
+                content: structureContent
+            });
+            // 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');
+                if (fs.existsSync(packagePath)) {
+                    const packageContent = fs.readFileSync(packagePath, 'utf8');
+                    packageJson = JSON.parse(packageContent);
+                }
+            }
+            catch (error) {
+                // Ignore errors
+            }
+            return `## Steering Documents Updated
+
+**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/structure.md\` - Project organization and architectural decisions
+
+**Analysis**:
+- Technology stack: ${Object.keys({ ...packageJson.dependencies, ...packageJson.devDependencies }).length} dependencies detected
+- 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);
+            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');
+        }
+        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()}
+`;
+        await this.steeringService.createSteeringDocument(projectPath, {
+            name: fileName,
+            type: 'CUSTOM',
+            mode: inclusionMode.toUpperCase(),
+            patterns: filePattern ? [filePattern] : [],
+            content
+        });
+        return `Custom steering document "${fileName}" created successfully with ${inclusionMode} inclusion mode.`;
+    }
+    async generateProductSteering(analysis) {
+        // 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');
+            if (fs.existsSync(packagePath)) {
+                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                packageJson = JSON.parse(packageContent);
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return `# Product Overview
+    
+## Product Description
+${packageJson.description || 'No description available'}
+
+## Core Features
+${this.extractFeatures(packageJson, analysis).map((feature) => `- ${feature}`).join('\n')}
+
+## Target Use Case
+${this.generateTargetUseCase(packageJson)}
+
+## Key Value Proposition
+${this.generateValueProposition(packageJson, analysis)}
+
+## Target Users
+${this.generateTargetUsers(packageJson)}`;
+    }
+    async generateTechSteering(analysis) {
+        // 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');
+            if (fs.existsSync(packagePath)) {
+                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                packageJson = JSON.parse(packageContent);
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return `# Technology Overview
+
+## Technology Stack
+${this.generateTechStack(packageJson, analysis)}
+
+## Development Environment
+- Node.js: ${packageJson.engines?.node || 'Unknown'}
+- Package Manager: npm
+
+## Key Dependencies
+${this.generateDependencyList(packageJson)}
+
+## Architecture Patterns
+${this.generateArchitecturePatterns(analysis)}
+
+## Quality Standards
+${this.generateQualityStandards(packageJson)}`;
+    }
+    async generateStructureSteering(analysis) {
+        return `# Project Structure
+
+## Directory Organization
+${this.generateDirectoryStructure(analysis)}
+
+## File Naming Conventions
+${this.generateNamingConventions(analysis)}
+
+## Module Organization
+${this.generateModuleOrganization(analysis)}
+
+## Development Workflow
+${this.generateWorkflow(analysis)}`;
+    }
+    extractFeatures(packageJson, analysis) {
+        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 to be defined'];
+    }
+    generateTargetUseCase(packageJson) {
+        if (packageJson.keywords) {
+            return `This product is designed for ${packageJson.keywords.join(', ')} use cases.`;
+        }
+        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');
+    }
+    generateTargetUsers(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';
+    }
+    generateTechStack(packageJson, analysis) {
+        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';
+    }
+    generateDependencyList(packageJson) {
+        const production = Object.keys(packageJson.dependencies || {});
+        const development = Object.keys(packageJson.devDependencies || {});
+        let list = '';
+        if (production.length > 0) {
+            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');
+        }
+        return list || 'Dependencies to be analyzed';
+    }
+    generateArchitecturePatterns(analysis) {
+        const patterns = [];
+        // Try to analyze directory structure from filesystem
+        try {
+            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');
+        }
+        catch (error) {
+            // Ignore filesystem errors
+        }
+        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');
+        if (packageJson.scripts?.typecheck)
+            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';
+    }
+    generateDirectoryStructure(analysis) {
+        // Try to get directory structure from filesystem
+        try {
+            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')
+                .map((item) => `- ${item.name}/`)
+                .join('\n');
+            return directories || 'Directory structure to be analyzed';
+        }
+        catch (error) {
+            return 'Directory structure to be analyzed';
+        }
+    }
+    generateNamingConventions(analysis) {
+        return `- Use kebab-case for file names
+- Use PascalCase for class names
+- Use camelCase for variable names
+- Use UPPER_SNAKE_CASE for constants`;
+    }
+    generateModuleOrganization(analysis) {
+        return `- Group related functionality in modules
+- Use barrel exports (index.ts files)
+- Separate business logic from infrastructure
+- Keep dependencies flowing inward`;
+    }
+    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');
+            if (fs.existsSync(packagePath)) {
+                const packageContent = fs.readFileSync(packagePath, 'utf8');
+                packageJson = JSON.parse(packageContent);
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        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;
+    }
 };
 SDDToolAdapter = __decorate([
     injectable(),
@@ -263,11 +641,15 @@ SDDToolAdapter = __decorate([
     __param(1, inject(TYPES.WorkflowService)),
     __param(2, inject(TYPES.TemplateService)),
     __param(3, inject(TYPES.QualityService)),
-    __param(4, inject(TYPES.LoggerPort)),
+    __param(4, inject(TYPES.SteeringDocumentService)),
+    __param(5, inject(TYPES.CodebaseAnalysisService)),
+    __param(6, inject(TYPES.LoggerPort)),
     __metadata("design:paramtypes", [ProjectService,
         WorkflowService,
         TemplateService,
-        QualityService, Object])
+        QualityService,
+        SteeringDocumentService,
+        CodebaseAnalysisService, Object])
 ], SDDToolAdapter);
 export { SDDToolAdapter };
 //# sourceMappingURL=SDDToolAdapter.js.map