sdd-mcp-server 1.3.10 → 1.4.0

package/mcp-server.js

@@ -11,6 +11,26 @@ import {
   generateStructureDocument 
 } from './documentGenerator.js';
 
+// Best-effort dynamic loader for spec generators (requirements/design/tasks)
+async function loadSpecGenerator() {
+  const tried = [];
+  const attempts = [
+    './specGenerator.js',                 // root-level JS (dev/runtime)
+    './dist/utils/specGenerator.js',      // compiled TS output
+    './utils/specGenerator.js'            // TS runtime (when transpiled on-the-fly)
+  ];
+  for (const p of attempts) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const mod = await import(p);
+      return { mod, path: p };
+    } catch (e) {
+      tried.push(`${p}: ${(e && e.message) || e}`);
+    }
+  }
+  throw new Error(`Unable to load specGenerator from known paths. Tried: \n- ${tried.join('\n- ')}`);
+}
+
 // Resolve version dynamically from package.json when possible
 async function resolveVersion() {
   try {
@@ -172,39 +192,14 @@ server.registerTool("sdd-requirements", {
     const specContent = await fs.readFile(specPath, 'utf8');
     const spec = JSON.parse(specContent);
     
-    // Generate requirements based on project analysis and AI understanding
-    const requirementsContent = `# Requirements Document
-
-## Project Context
-**Feature**: ${spec.feature_name}
-**Description**: ${spec.description || 'Feature to be implemented'}
-
-## Instructions for AI Agent
-
-Please analyze the current project structure and the feature description above to generate comprehensive requirements. Consider:
-
-1. **Project Analysis**: Examine the codebase structure, existing files, dependencies, and architecture patterns
-2. **Feature Scope**: Based on the feature description, identify what needs to be built
-3. **User Stories**: Create user stories that capture the value this feature provides
-4. **Technical Requirements**: Identify technical constraints and integration points
-5. **Acceptance Criteria**: Use EARS format (WHEN/IF/WHILE/WHERE) for testable criteria
-
-## Requirements Generation Guidelines
-
-Generate requirements that:
-- Are specific to this actual project (not generic)
-- Consider the existing codebase architecture
-- Include functional and non-functional requirements
-- Use EARS format for acceptance criteria
-- Are testable and measurable
-- Consider integration with existing features
-
-## Current Project Information
-- Project Path: ${process.cwd()}
-- Feature Name: ${spec.feature_name}
-- Initialization Date: ${spec.created_at}
-
-**Note**: This template will be replaced by AI-generated requirements specific to your project and feature description.`;
+    // Generate requirements using specGenerator with fallback
+    let requirementsContent;
+    try {
+      const { mod } = await loadSpecGenerator();
+      requirementsContent = await mod.generateRequirementsDocument(currentPath, featureName);
+    } catch (e) {
+      requirementsContent = `# Requirements Document\n\n<!-- Warning: Analysis-backed generation failed. Using fallback template. -->\n<!-- Error: ${e && e.message ? e.message : String(e)} -->\n\n## Project Context\n**Feature**: ${spec.feature_name}\n**Description**: ${spec.description || 'Feature to be implemented'}\n`;
+    }
     
     await fs.writeFile(path.join(featurePath, 'requirements.md'), requirementsContent);
     
@@ -266,8 +261,14 @@ server.registerTool("sdd-design", {
       requirementsContext = 'Requirements document not available';
     }
 
-    // Generate design document
-    const designContent = `# Technical Design Document\n\n## Project Context\n**Feature**: ${spec.feature_name}\n**Description**: ${spec.description || 'Feature to be implemented'}\n**Requirements Phase**: ${spec.approvals.requirements.generated ? 'Completed' : 'Pending'}\n\n## Instructions for AI Agent\n\nPlease analyze the requirements document and current project structure to create a comprehensive technical design. Consider:\n\n1. **Requirements Analysis**: Review the requirements to understand what needs to be built\n2. **Architecture Review**: Examine the existing codebase architecture and patterns\n3. **Technology Stack**: Identify the current tech stack and integration points\n4. **Design Decisions**: Make architectural decisions based on the project context\n5. **Component Design**: Define components, interfaces, and data models\n6. **Implementation Strategy**: Outline how this feature fits into the existing system\n\n## Design Generation Guidelines\n\nCreate a design that:\n- Addresses all requirements from requirements.md\n- Fits naturally into the existing codebase architecture\n- Uses the project's existing technology stack and patterns\n- Includes specific component interfaces and data models\n- Considers error handling and edge cases\n- Provides clear implementation guidance\n\n## Requirements Context\n\`\`\`\n${requirementsContext.substring(0, 2000)}${requirementsContext.length > 2000 ? '...\n[Requirements document truncated - see requirements.md for full content]' : ''}\n\`\`\`\n\n## Current Project Information\n- Project Path: ${process.cwd()}\n- Feature Name: ${spec.feature_name}\n- Phase: ${spec.phase}\n- Created: ${spec.created_at}\n\n**Note**: This template will be replaced by AI-generated design specific for spec-driven development workflows to AI development teams.\n\n**Users**: AI developers and development teams will utilize this for structured project development.\n\n**Impact**: Transforms ad-hoc development into systematic, phase-based workflows with quality gates.\n\n### Goals\n- Provide complete SDD workflow automation\n- Ensure quality through Linus-style code review\n- Enable multi-language development support\n- Integrate seamlessly with AI development tools\n\n### Non-Goals\n- Real-time collaboration features\n- Deployment automation\n- Version control integration\n\n## Architecture\n\n### High-Level Architecture\n\n\`\`\`mermaid\ngraph TB\n    A[AI Client] --> B[MCP Server]\n    B --> C[SDD Workflow Engine]\n    C --> D[Project Management]\n    C --> E[Template System]\n    C --> F[Quality Analysis]\n    D --> G[File System]\n    E --> G\n    F --> G\n\`\`\`\n\n### Technology Stack\n\n**Runtime**: Node.js with ES modules\n**Protocol**: Model Context Protocol (MCP)\n**Templates**: Handlebars-based generation\n**Quality**: AST-based code analysis\n**Storage**: File-based project persistence\n\n### Key Design Decisions\n\n**Decision**: Use MCP protocol for AI tool integration\n**Context**: Need seamless integration with Claude Code and other AI development tools\n**Alternatives**: REST API, GraphQL, custom protocol\n**Selected Approach**: MCP provides standardized AI tool integration\n**Rationale**: Direct integration with AI development workflows\n**Trade-offs**: Protocol-specific but optimized for AI use cases\n\n## Components and Interfaces\n\n### SDD Workflow Engine\n\n**Responsibility**: Manages 5-phase workflow state transitions\n**Domain Boundary**: Workflow orchestration and validation\n**Data Ownership**: Phase state, approval tracking, transition rules\n\n**Contract Definition**:\n\`\`\`typescript\ninterface SDDWorkflowEngine {\n  initializeProject(name: string, description: string): ProjectSpec;\n  generateRequirements(featureName: string): RequirementsDoc;\n  generateDesign(featureName: string): DesignDoc;\n  generateTasks(featureName: string): TasksDoc;\n  checkQuality(code: string): QualityReport;\n}\n\`\`\`\n\n### Template System\n\n**Responsibility**: Generate structured documents from templates\n**Domain Boundary**: Document generation and formatting\n**Data Ownership**: Template definitions, generated content\n\n### Quality Analysis Engine\n\n**Responsibility**: Perform Linus-style 5-layer code review\n**Domain Boundary**: Code quality assessment\n**Data Ownership**: Quality metrics, review reports\n\n## Data Models\n\n### Project Specification\n\`\`\`json\n{\n  "feature_name": "string",\n  "created_at": "ISO8601",\n  "updated_at": "ISO8601",\n  "language": "en",\n  "phase": "initialized|requirements-generated|design-generated|tasks-generated|implementation",\n  "approvals": {\n    "requirements": { "generated": boolean, "approved": boolean },\n    "design": { "generated": boolean, "approved": boolean },\n    "tasks": { "generated": boolean, "approved": boolean }\n  },\n  "ready_for_implementation": boolean\n}\n\`\`\`\n\n## Error Handling\n\n### Error Strategy\n- Phase validation with clear error messages\n- Graceful degradation for missing dependencies\n- Detailed logging for debugging\n\n### Error Categories\n**User Errors**: Invalid phase transitions → workflow guidance\n**System Errors**: File system failures → graceful error handling\n**Business Logic Errors**: Missing approvals → phase requirement messages\n\n## Testing Strategy\n\n- Unit Tests: SDD workflow engine methods\n- Integration Tests: MCP protocol communication\n- E2E Tests: Complete workflow execution\n- Performance Tests: Large project handling`;
+    // Generate design using specGenerator with fallback
+    let designContent;
+    try {
+      const { mod } = await loadSpecGenerator();
+      designContent = await mod.generateDesignDocument(currentPath, featureName);
+    } catch (e) {
+      designContent = `# Technical Design Document\n\n<!-- Warning: Analysis-backed generation failed. Using fallback template. -->\n<!-- Error: ${e && e.message ? e.message : String(e)} -->\n\n## Project Context\n**Feature**: ${spec.feature_name}\n**Phase**: ${spec.phase}`;
+    }
     
     await fs.writeFile(path.join(featurePath, 'design.md'), designContent);
     
@@ -384,6 +385,14 @@ ${designContext.substring(0, 1000)}${designContext.length > 1000 ? '...\n[Design
 - Created: ${spec.created_at}
 
 **Note**: This template will be replaced by AI-generated implementation tasks specific to your project requirements and design.`;
+
+    // Try to replace template with analysis-backed tasks
+    try {
+      const { mod } = await loadSpecGenerator();
+      tasksContent = await mod.generateTasksDocument(currentPath, featureName);
+    } catch (e) {
+      // Keep template; include debug info in file header already
+    }
     
     await fs.writeFile(path.join(featurePath, 'tasks.md'), tasksContent);
     
@@ -859,136 +868,13 @@ server.registerTool("sdd-steering", {
       updateMode = (productExists || techExists || structureExists) ? 'update' : 'create';
     }
     
-    // Create AI-driven steering documents with project analysis instructions
-    const productContent = `# Product Overview
-
-## Project Analysis Required
-
-Please analyze the current project structure and create a comprehensive product overview document. Consider:
-
-1. **Project Discovery**: Examine files, directory structure, configuration files, and documentation
-2. **Purpose Identification**: Understand what this project/product does based on code, README, and structure
-3. **Feature Analysis**: Identify key features and capabilities
-4. **User Base**: Determine who uses this product and how
-5. **Business Context**: Understand the value proposition and use cases
-
-## Instructions for AI Agent
-
-Generate a product.md document that includes:
-
-### Product Description
-- What this project/product does
-- Its primary purpose and goals
-- Key value propositions
-
-### Core Features
-- Main features and capabilities
-- What makes it unique or valuable
-
-### Target Users
-- Who uses this product
-- Primary user personas
-- Use cases and scenarios
-
-### Success Metrics
-- How success is measured
-- Key performance indicators
-- Business objectives
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual project.`;
-
-    const techContent = `# Technology Stack
-
-## Project Analysis Required
-
-Please analyze the current project's technology stack and create a comprehensive technical overview. Consider:
-
-1. **Language Detection**: Identify primary programming languages used
-2. **Framework Analysis**: Detect frameworks, libraries, and dependencies
-3. **Architecture Review**: Understand the system architecture and patterns
-4. **Build System**: Identify build tools, package managers, and deployment methods
-5. **Development Environment**: Understand development setup and requirements
-
-## Instructions for AI Agent
-
-Generate a tech.md document that includes:
-
-### Technology Stack
-- Programming languages used
-- Frameworks and libraries
-- Key dependencies and their purposes
-
-### Architecture
-- System architecture (monolith, microservices, etc.)
-- Design patterns employed
-- Database and storage solutions
-
-### Development Environment
-- Required tools and versions
-- Build and deployment processes
-- Development workflows
-
-### Dependencies
-- Production dependencies and their roles
-- Development dependencies and tooling
-- Version constraints and compatibility
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual technology stack.`;
-
-    const structureContent = `# Project Structure
-
-## Project Analysis Required
-
-Please analyze the current project's organization and create a comprehensive structure overview. Consider:
-
-1. **Directory Structure**: Examine folder organization and naming conventions
-2. **Code Organization**: Understand how code is structured and modularized
-3. **Configuration**: Identify configuration files and their purposes
-4. **Documentation**: Locate and assess existing documentation
-5. **Patterns**: Identify organizational patterns and conventions
-
-## Instructions for AI Agent
-
-Generate a structure.md document that includes:
-
-### File Organization
-- Directory structure and purpose of each folder
-- Naming conventions and patterns
-- Key files and their roles
-
-### Code Architecture
-- How code is organized and modularized
-- Separation of concerns
-- Layer structure (if applicable)
-
-### Configuration Management
-- Configuration files and their purposes
-- Environment-specific settings
-- Build and deployment configurations
-
-### Documentation Structure
-- Location of documentation
-- Types of documentation available
-- Documentation standards and conventions
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual project structure.`;
+    // Generate actual analyzed content using documentGenerator functions
+    const analysis = await analyzeProject(currentPath);
+    const productContent = generateProductDocument(analysis);
+    const techContent = generateTechDocument(analysis);
+    const structureContent = generateStructureDocument(analysis);
 
-    // Write the AI-driven instruction documents
+    // Write the analyzed steering documents
     await fs.writeFile(path.join(steeringPath, 'product.md'), productContent);
     await fs.writeFile(path.join(steeringPath, 'tech.md'), techContent);
     await fs.writeFile(path.join(steeringPath, 'structure.md'), structureContent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-mcp-server",
-  "version": "1.3.10",
+  "version": "1.4.0",
   "description": "MCP server for spec-driven development workflows across AI-agent CLIs and IDEs",
   "main": "dist/index.js",
   "bin": {
@@ -12,6 +12,7 @@
     "dist/**/*",
     "mcp-server.js",
     "documentGenerator.js",
+    "specGenerator.js",
     "README.md",
     "LICENSE",
     "package.json"

package/specGenerator.js

@@ -0,0 +1,263 @@
+import { analyzeProject } from './documentGenerator.js';
+
+export async function generateRequirementsDocument(projectPath, featureName) {
+  const analysis = await analyzeProject(projectPath);
+  const desc = analysis.description || 'Feature requirements specification';
+  const obj = generateCoreObjective(analysis);
+  const acceptance = generateAcceptanceCriteria(analysis)
+    .map((c, i) => `${i + 1}. ${c}`)
+    .join('\n');
+
+  return `# Requirements Document
+
+## Introduction
+${featureName} - Requirements derived from codebase analysis.
+
+**Project**: ${analysis.name}  
+**Description**: ${desc}
+
+Generated on: ${new Date().toISOString()}
+
+## Functional Requirements
+
+### FR-1: Core Functionality
+**Objective:** ${obj}
+
+#### Acceptance Criteria
+${acceptance}
+
+### FR-2: Technology Integration
+**Objective:** Integrate with the detected technology stack
+
+#### Acceptance Criteria
+${generateTechRequirements(analysis).map((r, i) => `${i + 1}. ${r}`).join('\n')}
+
+### FR-3: Quality Standards
+**Objective:** Meet quality, testing, and review standards
+
+#### Acceptance Criteria
+${generateQualityRequirements(analysis).map((r, i) => `${i + 1}. ${r}`).join('\n')}
+
+## Non-Functional Requirements
+
+### NFR-1: Performance
+- System SHALL respond within acceptable time limits
+- Memory usage SHALL remain within reasonable bounds
+
+### NFR-2: Reliability
+- System SHALL handle errors gracefully
+- System SHALL maintain data integrity
+
+### NFR-3: Maintainability
+- Code SHALL follow established conventions
+- System SHALL be well-documented
+`;
+}
+
+export async function generateDesignDocument(projectPath, featureName) {
+  const analysis = await analyzeProject(projectPath);
+  const arch = describeArchitecture(analysis);
+  const components = generateComponentList(analysis).map(c => `- **${c.name}**: ${c.description}`).join('\n');
+  const dataModels = generateDataModels(analysis).map(m => `- **${m}**: Data structure definition`).join('\n');
+  const techStack = generateDetailedTechStack(analysis);
+
+  return `# Technical Design Document
+
+## Project: ${featureName}
+
+**Project Name:** ${analysis.name}
+**Architecture:** ${analysis.architecture}
+**Language:** ${analysis.language}
+
+Generated on: ${new Date().toISOString()}
+
+## Architecture Overview
+
+### System Architecture
+${arch}
+
+### Key Components
+${components}
+
+### Data Models
+${dataModels}
+
+## Implementation Details
+
+### Technology Stack
+${techStack}
+
+### Dependencies
+${generateDependencySummary(analysis)}
+
+## Interface Specifications
+
+### Module Interfaces
+${generateModuleInterfaces(analysis)}
+
+## Configuration
+
+### Environment Variables
+${generateEnvVars(analysis)}
+
+### Build Configuration
+${generateBuildConfig(analysis)}
+`;
+}
+
+export async function generateTasksDocument(projectPath, featureName) {
+  const analysis = await analyzeProject(projectPath);
+  const tasks = generateImplementationTasks(analysis);
+
+  const section = (title, list) =>
+    list.map((task, idx) => `- [ ] ${idx + 1}. ${task.title}
+  ${task.subtasks.map(s => `  - ${s}`).join('\n')}
+  - _Requirements: ${task.requirements}_`).join('\n\n');
+
+  return `# Implementation Plan
+
+## Project: ${featureName}
+
+**Project Name:** ${analysis.name}
+**Detected Stack:** ${[analysis.language, analysis.framework || '', analysis.buildTool || ''].filter(Boolean).join(' / ')}
+
+Generated on: ${new Date().toISOString()}
+
+## Development Phase Tasks
+
+${section('Development', tasks.development)}
+
+## Integration Phase Tasks
+
+${section('Integration', tasks.integration)}
+
+## Quality & Testing Tasks
+
+${section('Quality', tasks.quality)}
+`;
+}
+
+// Helper functions
+function generateCoreObjective(analysis) {
+  if (analysis.dependencies?.includes('@modelcontextprotocol/sdk')) return 'Provide MCP tools for spec-driven development workflows';
+  if (analysis.framework === 'Express.js') return 'Expose REST endpoints and middleware for business logic';
+  if (analysis.framework === 'React') return 'Render interactive UI components with state management';
+  return 'Deliver feature-aligned functionality integrated with existing architecture';
+}
+
+function generateAcceptanceCriteria(analysis) {
+  const criteria = [
+    'WHEN invoked THEN it SHALL execute without runtime errors',
+    'IF input is invalid THEN it SHALL return meaningful errors',
+    'WHILE under typical load IT SHALL meet performance targets'
+  ];
+  if (analysis.testFramework) criteria.push('WHERE tests exist THEY SHALL pass with adequate coverage');
+  if (analysis.language === 'typescript') criteria.push('WHEN type-checking THEN no TypeScript errors SHALL occur');
+  return criteria;
+}
+
+function generateTechRequirements(analysis) {
+  const out = ['Integrate with existing build and run scripts'];
+  if (analysis.dependencies?.includes('@modelcontextprotocol/sdk')) out.push('Expose MCP-compliant tools over stdio');
+  if (analysis.buildTool) out.push(`Provide build artifacts using ${analysis.buildTool}`);
+  return out;
+}
+
+function generateQualityRequirements(analysis) {
+  const out = ['Follow project coding conventions', 'Apply error handling and logging'];
+  if (analysis.testFramework) out.push(`Include ${analysis.testFramework} tests for new code`);
+  return out;
+}
+
+function describeArchitecture(analysis) {
+  if (analysis.architecture === 'Domain-Driven Design (DDD)') return 'Layered DDD: Domain, Application, Infrastructure, Presentation';
+  if (analysis.architecture.includes('API')) return 'REST API with routing, middleware, services, and data access layers';
+  if (analysis.framework === 'MCP SDK') return 'MCP server exposing development tools via stdio protocol';
+  return analysis.architecture || 'Modular architecture with clear separation of concerns';
+}
+
+function generateComponentList(analysis) {
+  const comps = [];
+  if (analysis.framework === 'MCP SDK') {
+    comps.push({ name: 'MCPServer', description: 'Handles stdio transport and tool registry' });
+    comps.push({ name: 'ToolHandlers', description: 'Implement SDD tools (init, requirements, design, tasks, etc.)' });
+  }
+  if (analysis.architecture.includes('API')) {
+    comps.push({ name: 'Controllers', description: 'HTTP route handlers' });
+    comps.push({ name: 'Services', description: 'Business logic orchestration' });
+  }
+  if (comps.length === 0) comps.push({ name: 'CoreModule', description: 'Primary feature implementation module' });
+  return comps;
+}
+
+function generateDataModels(analysis) {
+  if (analysis.framework === 'MCP SDK') return ['Tool', 'Request', 'Response'];
+  if (analysis.architecture.includes('API')) return ['RequestDTO', 'ResponseDTO'];
+  return ['Entity', 'ValueObject'];
+}
+
+function generateDetailedTechStack(analysis) {
+  const parts = [];
+  parts.push(`- Runtime: ${analysis.language === 'typescript' ? 'Node.js (TypeScript)' : 'Node.js (JavaScript)'}`);
+  if (analysis.framework) parts.push(`- Framework: ${analysis.framework}`);
+  if (analysis.buildTool) parts.push(`- Build: ${analysis.buildTool}`);
+  if (analysis.testFramework) parts.push(`- Testing: ${analysis.testFramework}`);
+  return parts.join('\n');
+}
+
+function generateDependencySummary(analysis) {
+  const deps = (analysis.dependencies || []).slice(0, 10).map(d => `- ${d}`).join('\n');
+  const dev = (analysis.devDependencies || []).slice(0, 10).map(d => `- ${d}`).join('\n');
+  return `#### Production\n${deps || '- (none)'}\n\n#### Development\n${dev || '- (none)'}`;
+}
+
+function generateModuleInterfaces(analysis) {
+  if (analysis.framework === 'MCP SDK') {
+    return `- registerTool(name: string, handler: (args) => Promise<unknown>)\n- connect(transport): Promise<void>`;
+  }
+  if (analysis.architecture.includes('API')) {
+    return `- handle(request): Response\n- service.process(input): Result`;
+  }
+  return `- execute(input): Output`;
+}
+
+function generateEnvVars(analysis) {
+  const envs = ['NODE_ENV', 'LOG_LEVEL'];
+  if (analysis.framework === 'MCP SDK') envs.push('MCP_MODE');
+  return envs.map(e => `- ${e}`).join('\n');
+}
+
+function generateBuildConfig(analysis) {
+  if (analysis.buildTool) return `Use ${analysis.buildTool} to emit production artifacts`;
+  return 'Use npm scripts (build/test/lint) defined in package.json';
+}
+
+function generateImplementationTasks(analysis) {
+  const dev = [
+    { title: 'Set up project scaffolding', subtasks: ['Initialize directories', 'Configure scripts'], requirements: 'FR-1' },
+    { title: 'Implement core feature logic', subtasks: ['Add modules', 'Wire integrations'], requirements: 'FR-1' }
+  ];
+  const integ = [
+    { title: 'Integrate with stack', subtasks: ['Validate build', 'Run dev server'], requirements: 'FR-2' }
+  ];
+  const quality = [
+    { title: 'Add tests and quality checks', subtasks: ['Unit tests', 'Lint/typecheck', 'Quality review'], requirements: 'FR-3' }
+  ];
+
+  if (analysis.framework === 'MCP SDK') {
+    dev.unshift({ title: 'Expose MCP tools', subtasks: ['Register tools', 'Handle stdio transport'], requirements: 'FR-2' });
+  }
+  if (analysis.architecture.includes('API')) {
+    dev.unshift({ title: 'Add HTTP endpoints', subtasks: ['Define routes', 'Implement handlers'], requirements: 'FR-1' });
+  }
+
+  if (analysis.testFramework) {
+    quality[0].subtasks.unshift(`Set up ${analysis.testFramework}`);
+  }
+  if (analysis.language === 'typescript') {
+    quality[0].subtasks.push('Ensure type safety (tsc)');
+  }
+
+  return { development: dev, integration: integ, quality };
+}
+