grimoire-framework 1.0.0

package/.grimoire/development/tasks/qa-generate-tests.md

@@ -0,0 +1,1176 @@
+---
+
+## Execution Modes
+
+**Choose your execution mode:**
+
+### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
+- Autonomous decision making with logging
+- Minimal user interaction
+- **Best for:** Simple, deterministic tasks
+
+### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
+- Explicit decision checkpoints
+- Educational explanations
+- **Best for:** Learning, complex decisions
+
+### 3. Pre-Flight Planning - Comprehensive Upfront Planning
+- Task analysis phase (identify all ambiguities)
+- Zero ambiguity execution
+- **Best for:** Ambiguous requirements, critical work
+
+**Parameter:** `mode` (optional, default: `interactive`)
+
+---
+
+## Task Definition (grimoire Task Format V1.0)
+
+```yaml
+task: qaGenerateTests()
+responsável: Quinn (Guardian)
+responsavel_type: Agente
+atomic_layer: Config
+
+**Entrada:**
+- campo: target
+  tipo: string
+  origem: User Input
+  obrigatório: true
+  validação: Must exist
+
+- campo: criteria
+  tipo: array
+  origem: config
+  obrigatório: true
+  validação: Non-empty validation criteria
+
+- campo: strict
+  tipo: boolean
+  origem: User Input
+  obrigatório: false
+  validação: Default: true
+
+**Saída:**
+- campo: validation_result
+  tipo: boolean
+  destino: Return value
+  persistido: false
+
+- campo: errors
+  tipo: array
+  destino: Memory
+  persistido: false
+
+- campo: report
+  tipo: object
+  destino: File (.ai/*.json)
+  persistido: true
+```
+
+---
+
+## Pre-Conditions
+
+**Purpose:** Validate prerequisites BEFORE task execution (blocking)
+
+**Checklist:**
+
+```yaml
+pre-conditions:
+  - [ ] Validation rules loaded; target available for validation
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      Check validation rules loaded; target available for validation
+    error_message: "Pre-condition failed: Validation rules loaded; target available for validation"
+```
+
+---
+
+## Post-Conditions
+
+**Purpose:** Validate execution success AFTER task completes
+
+**Checklist:**
+
+```yaml
+post-conditions:
+  - [ ] Validation executed; results accurate; report generated
+    tipo: post-condition
+    blocker: true
+    validação: |
+      Verify validation executed; results accurate; report generated
+    error_message: "Post-condition failed: Validation executed; results accurate; report generated"
+```
+
+---
+
+## Acceptance Criteria
+
+**Purpose:** Definitive pass/fail criteria for task completion
+
+**Checklist:**
+
+```yaml
+acceptance-criteria:
+  - [ ] Validation rules applied; pass/fail accurate; actionable feedback
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      Assert validation rules applied; pass/fail accurate; actionable feedback
+    error_message: "Acceptance criterion not met: Validation rules applied; pass/fail accurate; actionable feedback"
+```
+
+---
+
+## Tools
+
+**External/shared resources used by this task:**
+
+- **Tool:** validation-engine
+  - **Purpose:** Rule-based validation and reporting
+  - **Source:** .grimoire/utils/validation-engine.js
+
+- **Tool:** schema-validator
+  - **Purpose:** JSON/YAML schema validation
+  - **Source:** ajv or similar
+
+---
+
+## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** run-validation.js
+  - **Purpose:** Execute validation rules and generate report
+  - **Language:** JavaScript
+  - **Location:** .grimoire/scripts/run-validation.js
+
+---
+
+## Error Handling
+
+**Strategy:** retry
+
+**Common Errors:**
+
+1. **Error:** Validation Criteria Missing
+   - **Cause:** Required validation rules not defined
+   - **Resolution:** Ensure validation criteria loaded from config
+   - **Recovery:** Use default validation rules, log warning
+
+2. **Error:** Invalid Schema
+   - **Cause:** Target does not match expected schema
+   - **Resolution:** Update schema or fix target structure
+   - **Recovery:** Detailed validation error report
+
+3. **Error:** Dependency Missing
+   - **Cause:** Required dependency for validation not found
+   - **Resolution:** Install missing dependencies
+   - **Recovery:** Abort with clear dependency list
+
+---
+
+## Performance
+
+**Expected Metrics:**
+
+```yaml
+duration_expected: 2-10 min (estimated)
+cost_estimated: $0.001-0.008
+token_usage: ~800-2,500 tokens
+```
+
+**Optimization Notes:**
+- Validate configuration early; use atomic writes; implement rollback checkpoints
+
+---
+
+## Metadata
+
+```yaml
+story: N/A
+version: 1.0.0
+dependencies:
+  - N/A
+tags:
+  - quality-assurance
+  - testing
+updated_at: 2025-11-17
+```
+
+---
+
+tools:
+  - github-cli
+# TODO: Create test-generation-checklist.md for validation (follow-up story needed)
+# checklists:
+#   - test-generation-checklist.md
+---
+
+# Generate Tests - grimoire Developer Task
+
+## Purpose
+Automatically generate comprehensive test suites for framework components using AI analysis and template systems.
+
+## Command Pattern
+```
+*generate-tests <component-type> <component-name> [options]
+```
+
+## Parameters
+- `component-type`: Type of component (agent, task, workflow, util)
+- `component-name`: Name/ID of the component to generate tests for
+- `options`: Test generation configuration
+
+### Options
+- `--test-type <type>`: Type of tests to generate (unit, integration, e2e, all)
+- `--coverage-target <percentage>`: Target code coverage percentage (default: 80)
+- `--framework <name>`: Test framework to use (jest, mocha, vitest)
+- `--mock-level <level>`: Mocking level (minimal, moderate, extensive)
+- `--update-existing`: Update existing test files instead of creating new ones
+- `--quality-level <level>`: Test quality level (basic, standard, comprehensive)
+- `--output-dir <path>`: Custom output directory for generated tests
+
+## Examples
+```bash
+# Generate unit tests for an agent
+*generate-tests agent weather-fetcher --test-type unit --coverage-target 90
+
+# Generate comprehensive test suite for a utility
+*generate-tests util logger --test-type all --quality-level comprehensive
+
+# Update existing tests for a task
+*generate-tests task data-processor --update-existing --coverage-target 85
+
+# Generate integration tests with extensive mocking
+*generate-tests workflow user-onboarding --test-type integration --mock-level extensive
+
+# Generate tests for all component types
+*generate-tests all components --framework vitest --output-dir tests/auto-generated
+```
+
+## Implementation
+
+```javascript
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+class GenerateTestsTask {
+  constructor() {
+    this.taskName = 'generate-tests';
+    this.description = 'Generate comprehensive test suites for framework components';
+    this.rootPath = process.cwd();
+    this.testTemplateSystem = null;
+    this.testGenerator = null;
+    this.coverageAnalyzer = null;
+    this.qualityAssessment = null;
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('🧪 grimoire Test Generation'));
+      console.log(chalk.gray('Generating comprehensive test suites for components\n'));
+
+      // Parse and validate parameters
+      const config = await this.parseParameters(params);
+      
+      // Initialize dependencies
+      await this.initializeDependencies();
+
+      // Analyze target components
+      const components = await this.identifyTargetComponents(config);
+      if (components.length === 0) {
+        throw new Error('No components found matching the criteria');
+      }
+
+      console.log(chalk.gray(`Found ${components.length} component(s) for test generation`));
+
+      // Generate test plan
+      const testPlan = await this.generateTestPlan(components, config);
+
+      // Display test generation summary
+      await this.displayTestGenerationSummary(testPlan);
+
+      // Request confirmation
+      const confirmed = await this.requestConfirmation(testPlan);
+      if (!confirmed) {
+        console.log(chalk.gray('Test generation cancelled'));
+        return;
+      }
+
+      // Execute test generation
+      const generationResults = await this.executeTestGeneration(testPlan);
+
+      // Analyze generated tests
+      const analysisResults = await this.analyzeGeneratedTests(generationResults);
+
+      // Update existing test documentation
+      await this.updateTestDocumentation(generationResults);
+
+      // Display success summary
+      console.log(chalk.green('\n✅ Test generation completed successfully'));
+      console.log(chalk.gray(`   Components tested: ${components.length}`));
+      console.log(chalk.gray(`   Test files generated: ${generationResults.testFilesGenerated}`));
+      console.log(chalk.gray(`   Expected coverage: ${analysisResults.expectedCoverage}%`));
+      console.log(chalk.gray(`   Quality score: ${analysisResults.qualityScore}/10`));
+
+      return {
+        success: true,
+        components: components.length,
+        testFilesGenerated: generationResults.testFilesGenerated,
+        expectedCoverage: analysisResults.expectedCoverage,
+        qualityScore: analysisResults.qualityScore
+      };
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Test generation failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  async parseParameters(params) {
+    if (params.length < 2 && params[0] !== 'all') {
+      throw new Error('Usage: *generate-tests <component-type> <component-name> [options]');
+    }
+
+    const config = {
+      componentType: params[0],
+      componentName: params[1] || null,
+      testType: 'unit',
+      coverageTarget: 80,
+      framework: 'jest',
+      mockLevel: 'moderate',
+      updateExisting: false,
+      qualityLevel: 'standard',
+      outputDir: null,
+      generateAll: params[0] === 'all'
+    };
+
+    // Parse options
+    for (let i = 2; i < params.length; i++) {
+      const param = params[i];
+      
+      if (param === '--update-existing') {
+        config.updateExisting = true;
+      } else if (param.startsWith('--test-type') && params[i + 1]) {
+        config.testType = params[++i];
+      } else if (param.startsWith('--coverage-target') && params[i + 1]) {
+        config.coverageTarget = parseInt(params[++i]) || 80;
+      } else if (param.startsWith('--framework') && params[i + 1]) {
+        config.framework = params[++i];
+      } else if (param.startsWith('--mock-level') && params[i + 1]) {
+        config.mockLevel = params[++i];
+      } else if (param.startsWith('--quality-level') && params[i + 1]) {
+        config.qualityLevel = params[++i];
+      } else if (param.startsWith('--output-dir') && params[i + 1]) {
+        config.outputDir = params[++i];
+      }
+    }
+
+    // Validation
+    if (!config.generateAll) {
+      const validTypes = ['agent', 'task', 'workflow', 'util'];
+      if (!validTypes.includes(config.componentType)) {
+        throw new Error(`Invalid component type: ${config.componentType}. Must be one of: ${validTypes.join(', ')}`);
+      }
+    }
+
+    const validTestTypes = ['unit', 'integration', 'e2e', 'all'];
+    if (!validTestTypes.includes(config.testType)) {
+      throw new Error(`Invalid test type: ${config.testType}. Must be one of: ${validTestTypes.join(', ')}`);
+    }
+
+    const validFrameworks = ['jest', 'mocha', 'vitest'];
+    if (!validFrameworks.includes(config.framework)) {
+      throw new Error(`Invalid framework: ${config.framework}. Must be one of: ${validFrameworks.join(', ')}`);
+    }
+
+    const validMockLevels = ['minimal', 'moderate', 'extensive'];
+    if (!validMockLevels.includes(config.mockLevel)) {
+      throw new Error(`Invalid mock level: ${config.mockLevel}. Must be one of: ${validMockLevels.join(', ')}`);
+    }
+
+    const validQualityLevels = ['basic', 'standard', 'comprehensive'];
+    if (!validQualityLevels.includes(config.qualityLevel)) {
+      throw new Error(`Invalid quality level: ${config.qualityLevel}. Must be one of: ${validQualityLevels.join(', ')}`);
+    }
+
+    if (config.coverageTarget < 0 || config.coverageTarget > 100) {
+      throw new Error('Coverage target must be between 0 and 100');
+    }
+
+    return config;
+  }
+
+  async initializeDependencies() {
+    try {
+      // Initialize test template system
+      const TestTemplateSystem = require('../scripts/test-template-system');
+      this.testTemplateSystem = new TestTemplateSystem({ rootPath: this.rootPath });
+      await this.testTemplateSystem.initialize();
+
+      // Initialize test generator
+      const TestGenerator = require('../scripts/test-generator');
+      this.testGenerator = new TestGenerator({ 
+        rootPath: this.rootPath,
+        templateSystem: this.testTemplateSystem
+      });
+
+      // Initialize coverage analyzer
+      const CoverageAnalyzer = require('../scripts/coverage-analyzer');
+      this.coverageAnalyzer = new CoverageAnalyzer({ rootPath: this.rootPath });
+
+      // Initialize quality assessment
+      const TestQualityAssessment = require('../scripts/test-quality-assessment');
+      this.qualityAssessment = new TestQualityAssessment({ rootPath: this.rootPath });
+
+    } catch (error) {
+      throw new Error(`Failed to initialize dependencies: ${error.message}`);
+    }
+  }
+
+  async identifyTargetComponents(config) {
+    const components = [];
+
+    if (config.generateAll) {
+      // Find all components in the framework
+      const allComponents = await this.discoverAllComponents();
+      components.push(...allComponents);
+    } else {
+      // Find specific component
+      const ComponentSearch = require('../scripts/component-search');
+      const componentSearch = new ComponentSearch({ rootPath: this.rootPath });
+      
+      const component = await componentSearch.findComponent(config.componentType, config.componentName);
+      if (!component) {
+        // Suggest similar components
+        const suggestions = await componentSearch.findSimilarComponents(config.componentType, config.componentName);
+        if (suggestions.length > 0) {
+          console.log(chalk.yellow('\nDid you mean one of these?'));
+          suggestions.forEach(suggestion => {
+            console.log(chalk.gray(`  - ${suggestion.type}/${suggestion.name}`));
+          });
+        }
+        throw new Error(`Component not found: ${config.componentType}/${config.componentName}`);
+      }
+      
+      components.push(component);
+    }
+
+    return components;
+  }
+
+  async discoverAllComponents() {
+    const components = [];
+    const componentTypes = ['agents', 'tasks', 'workflows', 'utils'];
+
+    for (const type of componentTypes) {
+      const typeDir = path.join(this.rootPath, 'grimoire', type);
+      
+      try {
+        const files = await fs.readdir(typeDir);
+        
+        for (const file of files) {
+          const filePath = path.join(typeDir, file);
+          const stats = await fs.stat(filePath);
+          
+          if (stats.isFile()) {
+            const componentType = type.slice(0, -1); // Remove 's' from plural
+            const componentName = path.basename(file, path.extname(file));
+            
+            components.push({
+              id: `${componentType}/${componentName}`,
+              type: componentType,
+              name: componentName,
+              filePath: filePath
+            });
+          }
+        }
+      } catch (error) {
+        // Directory doesn't exist, skip
+        continue;
+      }
+    }
+
+    return components;
+  }
+
+  async generateTestPlan(components, config) {
+    const testPlan = {
+      generation_id: `test-gen-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`,
+      components: components,
+      config: config,
+      test_suites: [],
+      estimated_duration: 0,
+      expected_files: 0,
+      quality_targets: {}
+    };
+
+    console.log(chalk.gray('Analyzing components and generating test plan...'));
+
+    for (const component of components) {
+      const componentAnalysis = await this.analyzeComponentForTesting(component, config);
+      const testSuite = await this.planTestSuite(component, componentAnalysis, config);
+      
+      testPlan.test_suites.push(testSuite);
+      testPlan.estimated_duration += testSuite.estimated_duration;
+      testPlan.expected_files += testSuite.test_files.length;
+    }
+
+    // Set quality targets
+    testPlan.quality_targets = {
+      coverage_target: config.coverageTarget,
+      quality_level: config.qualityLevel,
+      mock_coverage: this.calculateMockCoverage(config.mockLevel),
+      assertion_density: this.calculateAssertionDensity(config.qualityLevel)
+    };
+
+    return testPlan;
+  }
+
+  async analyzeComponentForTesting(component, config) {
+    const analysis = {
+      component_id: component.id,
+      complexity: 'medium',
+      dependencies: [],
+      external_dependencies: [],
+      testable_functions: [],
+      edge_cases: [],
+      mock_requirements: [],
+      existing_tests: null
+    };
+
+    try {
+      // Read component file
+      const content = await fs.readFile(component.filePath, 'utf-8');
+      
+      // Analyze component complexity
+      analysis.complexity = this.assessComplexity(content, component.type);
+      
+      // Identify dependencies
+      analysis.dependencies = this.extractDependencies(content, component.type);
+      analysis.external_dependencies = this.extractExternalDependencies(content);
+      
+      // Identify testable functions/methods
+      analysis.testable_functions = this.extractTestableFunctions(content, component.type);
+      
+      // Identify edge cases
+      analysis.edge_cases = this.identifyEdgeCases(content, component.type);
+      
+      // Determine mock requirements
+      analysis.mock_requirements = this.determineMockRequirements(analysis, config.mockLevel);
+      
+      // Check for existing tests
+      analysis.existing_tests = await this.findExistingTests(component);
+
+    } catch (error) {
+      console.warn(chalk.yellow(`Failed to analyze ${component.id}: ${error.message}`));
+    }
+
+    return analysis;
+  }
+
+  async planTestSuite(component, analysis, config) {
+    const testSuite = {
+      component_id: component.id,
+      component_type: component.type,
+      test_files: [],
+      total_tests: 0,
+      estimated_duration: 0,
+      coverage_plan: {},
+      quality_metrics: {}
+    };
+
+    // Plan different types of tests based on config
+    if (config.testType === 'unit' || config.testType === 'all') {
+      const unitTestFile = await this.planUnitTests(component, analysis, config);
+      testSuite.test_files.push(unitTestFile);
+    }
+
+    if (config.testType === 'integration' || config.testType === 'all') {
+      const integrationTestFile = await this.planIntegrationTests(component, analysis, config);
+      if (integrationTestFile) {
+        testSuite.test_files.push(integrationTestFile);
+      }
+    }
+
+    if (config.testType === 'e2e' || config.testType === 'all') {
+      const e2eTestFile = await this.planE2ETests(component, analysis, config);
+      if (e2eTestFile) {
+        testSuite.test_files.push(e2eTestFile);
+      }
+    }
+
+    // Calculate totals
+    testSuite.total_tests = testSuite.test_files.reduce((sum, file) => sum + file.test_count, 0);
+    testSuite.estimated_duration = testSuite.test_files.reduce((sum, file) => sum + file.estimated_duration, 0);
+
+    // Plan coverage
+    testSuite.coverage_plan = {
+      target_percentage: config.coverageTarget,
+      lines_to_cover: analysis.testable_functions.length * 5, // Estimate
+      assertions_planned: testSuite.total_tests * this.calculateAssertionDensity(config.qualityLevel)
+    };
+
+    return testSuite;
+  }
+
+  async planUnitTests(component, analysis, config) {
+    const testFile = {
+      file_path: this.generateTestFilePath(component, 'unit', config),
+      test_type: 'unit',
+      test_count: 0,
+      estimated_duration: 0,
+      test_cases: [],
+      mocks_required: [],
+      setup_requirements: []
+    };
+
+    // Generate test cases for each testable function
+    for (const func of analysis.testable_functions) {
+      const testCases = await this.generateFunctionTestCases(func, analysis, config);
+      testFile.test_cases.push(...testCases);
+      testFile.test_count += testCases.length;
+    }
+
+    // Add edge case tests
+    for (const edgeCase of analysis.edge_cases) {
+      const edgeCaseTest = await this.generateEdgeCaseTest(edgeCase, analysis, config);
+      testFile.test_cases.push(edgeCaseTest);
+      testFile.test_count++;
+    }
+
+    // Determine mocks required
+    testFile.mocks_required = analysis.mock_requirements.filter(mock => mock.level !== 'none');
+
+    // Calculate estimated duration
+    testFile.estimated_duration = testFile.test_count * 2; // 2 minutes per test case
+
+    return testFile;
+  }
+
+  async planIntegrationTests(component, analysis, config) {
+    // Skip integration tests for simple components
+    if (analysis.complexity === 'low' && analysis.dependencies.length === 0) {
+      return null;
+    }
+
+    const testFile = {
+      file_path: this.generateTestFilePath(component, 'integration', config),
+      test_type: 'integration',
+      test_count: 0,
+      estimated_duration: 0,
+      test_cases: [],
+      integration_scenarios: [],
+      setup_requirements: ['test database', 'mock services']
+    };
+
+    // Generate integration scenarios
+    testFile.integration_scenarios = await this.generateIntegrationScenarios(component, analysis);
+    testFile.test_count = testFile.integration_scenarios.length;
+    testFile.estimated_duration = testFile.test_count * 5; // 5 minutes per integration test
+
+    return testFile;
+  }
+
+  async planE2ETests(component, analysis, config) {
+    // Only generate E2E tests for workflows and certain tasks
+    if (component.type !== 'workflow' && component.type !== 'task') {
+      return null;
+    }
+
+    const testFile = {
+      file_path: this.generateTestFilePath(component, 'e2e', config),
+      test_type: 'e2e',
+      test_count: 0,
+      estimated_duration: 0,
+      test_scenarios: [],
+      setup_requirements: ['full system', 'test data']
+    };
+
+    // Generate E2E scenarios
+    testFile.test_scenarios = await this.generateE2EScenarios(component, analysis);
+    testFile.test_count = testFile.test_scenarios.length;
+    testFile.estimated_duration = testFile.test_count * 10; // 10 minutes per E2E test
+
+    return testFile;
+  }
+
+  generateTestFilePath(component, testType, config) {
+    const baseDir = config.outputDir || path.join(this.rootPath, 'tests');
+    const typeDir = testType === 'unit' ? 'unit' : testType === 'integration' ? 'integration' : 'e2e';
+    const componentDir = component.type === 'util' ? 'utils' : component.type;
+    
+    const fileName = `${component.name}.${testType}.test.js`;
+    return path.join(baseDir, typeDir, componentDir, fileName);
+  }
+
+  async displayTestGenerationSummary(testPlan) {
+    console.log(chalk.blue('\n📋 Test Generation Plan'));
+    console.log(chalk.gray('━'.repeat(50)));
+    
+    console.log(`Components: ${chalk.white(testPlan.components.length)}`);
+    console.log(`Test suites: ${chalk.white(testPlan.test_suites.length)}`);
+    console.log(`Expected test files: ${chalk.white(testPlan.expected_files)}`);
+    console.log(`Total tests planned: ${chalk.white(testPlan.test_suites.reduce((sum, suite) => sum + suite.total_tests, 0))}`);
+    console.log(`Coverage target: ${chalk.white(testPlan.config.coverageTarget)}%`);
+    console.log(`Quality level: ${chalk.white(testPlan.config.qualityLevel)}`);
+    console.log(`Estimated duration: ${chalk.white(Math.round(testPlan.estimated_duration / 60))} hours`);
+
+    console.log(chalk.blue('\nTest Suites:'));
+    testPlan.test_suites.forEach((suite, index) => {
+      console.log(`  ${index + 1}. ${suite.component_id} (${suite.total_tests} tests)`);
+    });
+  }
+
+  async requestConfirmation(testPlan) {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Generate ${testPlan.expected_files} test files for ${testPlan.components.length} components?`,
+      default: true
+    }]);
+
+    return confirmed;
+  }
+
+  async executeTestGeneration(testPlan) {
+    const results = {
+      testFilesGenerated: 0,
+      testsGenerated: 0,
+      errors: [],
+      generated_files: []
+    };
+
+    console.log(chalk.gray('\nGenerating test files...'));
+
+    for (const testSuite of testPlan.test_suites) {
+      try {
+        const component = testPlan.components.find(c => c.id === testSuite.component_id);
+        
+        for (const testFile of testSuite.test_files) {
+          console.log(chalk.gray(`  Generating ${testFile.test_type} tests for ${component.name}...`));
+          
+          const generatedContent = await this.testGenerator.generateTestFile(
+            component,
+            testFile,
+            testPlan.config
+          );
+
+          // Ensure directory exists
+          await fs.mkdir(path.dirname(testFile.file_path), { recursive: true });
+
+          // Write test file
+          if (testPlan.config.updateExisting || !(await this.fileExists(testFile.file_path))) {
+            await fs.writeFile(testFile.file_path, generatedContent);
+            results.testFilesGenerated++;
+            results.testsGenerated += testFile.test_count;
+            results.generated_files.push(testFile.file_path);
+            
+            console.log(chalk.green(`    ✓ Generated ${testFile.file_path}`));
+          } else {
+            console.log(chalk.yellow(`    ⚠ Skipped ${testFile.file_path} (already exists)`));
+          }
+        }
+
+      } catch (error) {
+        results.errors.push({
+          component_id: testSuite.component_id,
+          error: error.message
+        });
+        console.error(chalk.red(`    ✗ Failed to generate tests for ${testSuite.component_id}: ${error.message}`));
+      }
+    }
+
+    return results;
+  }
+
+  async analyzeGeneratedTests(generationResults) {
+    const analysis = {
+      expectedCoverage: 0,
+      qualityScore: 0,
+      testDistribution: {},
+      recommendations: []
+    };
+
+    if (generationResults.testFilesGenerated > 0) {
+      // Analyze each generated test file
+      for (const filePath of generationResults.generated_files) {
+        try {
+          const testAnalysis = await this.qualityAssessment.analyzeSingleTestFile(filePath);
+          analysis.expectedCoverage += testAnalysis.estimatedCoverage || 0;
+          analysis.qualityScore += testAnalysis.qualityScore || 0;
+        } catch (error) {
+          console.warn(chalk.yellow(`Failed to analyze ${filePath}: ${error.message}`));
+        }
+      }
+
+      // Calculate averages
+      analysis.expectedCoverage = Math.round(analysis.expectedCoverage / generationResults.testFilesGenerated);
+      analysis.qualityScore = Math.round((analysis.qualityScore / generationResults.testFilesGenerated) * 10) / 10;
+    }
+
+    return analysis;
+  }
+
+  async updateTestDocumentation(generationResults) {
+    // Update test documentation with newly generated tests
+    const testDocs = {
+      generated_at: new Date().toISOString(),
+      test_files: generationResults.generated_files,
+      total_tests: generationResults.testsGenerated,
+      generation_notes: 'Auto-generated by grimoire test generation system'
+    };
+
+    const docsPath = path.join(this.rootPath, 'docs', 'testing', 'auto-generated-tests.json');
+    
+    try {
+      await fs.mkdir(path.dirname(docsPath), { recursive: true });
+      await fs.writeFile(docsPath, JSON.stringify(testDocs, null, 2));
+    } catch (error) {
+      console.warn(chalk.yellow(`Failed to update test documentation: ${error.message}`));
+    }
+  }
+
+  // Helper methods
+
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  assessComplexity(content, componentType) {
+    // Simple heuristic for complexity assessment
+    const lines = content.split('\n').length;
+    const functions = (content.match(/function|=>/g) || []).length;
+    const conditions = (content.match(/if|switch|for|while/g) || []).length;
+    
+    const complexityScore = (lines / 10) + (functions * 2) + (conditions * 3);
+    
+    if (complexityScore > 50) return 'high';
+    if (complexityScore > 20) return 'medium';
+    return 'low';
+  }
+
+  extractDependencies(content, componentType) {
+    const dependencies = [];
+    
+    // Extract require/import statements
+    const requireMatches = content.match(/require\(['"]([^'"]+)['"]\)/g) || [];
+    const importMatches = content.match(/import .+ from ['"]([^'"]+)['"]/g) || [];
+    
+    requireMatches.forEach(match => {
+      const dep = match.match(/require\(['"]([^'"]+)['"]\)/)[1];
+      if (dep.startsWith('./') || dep.startsWith('../')) {
+        dependencies.push(dep);
+      }
+    });
+
+    importMatches.forEach(match => {
+      const dep = match.match(/from ['"]([^'"]+)['"]/)[1];
+      if (dep.startsWith('./') || dep.startsWith('../')) {
+        dependencies.push(dep);
+      }
+    });
+
+    return dependencies;
+  }
+
+  extractExternalDependencies(content) {
+    const externalDeps = [];
+    
+    const requireMatches = content.match(/require\(['"]([^'"]+)['"]\)/g) || [];
+    const importMatches = content.match(/import .+ from ['"]([^'"]+)['"]/g) || [];
+    
+    requireMatches.forEach(match => {
+      const dep = match.match(/require\(['"]([^'"]+)['"]\)/)[1];
+      if (!dep.startsWith('./') && !dep.startsWith('../') && !dep.startsWith('node:')) {
+        externalDeps.push(dep);
+      }
+    });
+
+    importMatches.forEach(match => {
+      const dep = match.match(/from ['"]([^'"]+)['"]/)[1];
+      if (!dep.startsWith('./') && !dep.startsWith('../') && !dep.startsWith('node:')) {
+        externalDeps.push(dep);
+      }
+    });
+
+    return [...new Set(externalDeps)]; // Remove duplicates
+  }
+
+  extractTestableFunctions(content, componentType) {
+    const functions = [];
+    
+    // Extract function declarations and expressions
+    const functionMatches = content.match(/(?:function\s+(\w+)|(\w+)\s*[:=]\s*(?:async\s+)?function|(\w+)\s*[:=]\s*(?:async\s+)?\([^)]*\)\s*=>)/g) || [];
+    
+    functionMatches.forEach(match => {
+      let functionName = null;
+      
+      if (match.includes('function ')) {
+        functionName = match.match(/function\s+(\w+)/)?.[1];
+      } else {
+        functionName = match.match(/(\w+)\s*[:=]/)?.[1];
+      }
+      
+      if (functionName && !functionName.startsWith('_')) {
+        functions.push({
+          name: functionName,
+          type: 'function',
+          visibility: 'public'
+        });
+      }
+    });
+
+    return functions;
+  }
+
+  identifyEdgeCases(content, componentType) {
+    const edgeCases = [];
+    
+    // Look for common edge case patterns
+    if (content.includes('null') || content.includes('undefined')) {
+      edgeCases.push({ type: 'null_undefined', description: 'Handle null/undefined values' });
+    }
+    
+    if (content.includes('length') || content.includes('size')) {
+      edgeCases.push({ type: 'empty_collections', description: 'Handle empty arrays/objects' });
+    }
+    
+    if (content.includes('catch') || content.includes('throw')) {
+      edgeCases.push({ type: 'error_handling', description: 'Test error conditions' });
+    }
+    
+    if (content.includes('async') || content.includes('await')) {
+      edgeCases.push({ type: 'async_operations', description: 'Test async operation failures' });
+    }
+
+    return edgeCases;
+  }
+
+  determineMockRequirements(analysis, mockLevel) {
+    const mocks = [];
+    
+    if (mockLevel === 'minimal') {
+      // Only mock external dependencies
+      analysis.external_dependencies.forEach(dep => {
+        mocks.push({ type: 'external', target: dep, level: 'full' });
+      });
+    } else if (mockLevel === 'moderate') {
+      // Mock external dependencies and some internal ones
+      analysis.external_dependencies.forEach(dep => {
+        mocks.push({ type: 'external', target: dep, level: 'full' });
+      });
+      analysis.dependencies.slice(0, 3).forEach(dep => {
+        mocks.push({ type: 'internal', target: dep, level: 'partial' });
+      });
+    } else if (mockLevel === 'extensive') {
+      // Mock everything possible
+      analysis.external_dependencies.forEach(dep => {
+        mocks.push({ type: 'external', target: dep, level: 'full' });
+      });
+      analysis.dependencies.forEach(dep => {
+        mocks.push({ type: 'internal', target: dep, level: 'full' });
+      });
+    }
+
+    return mocks;
+  }
+
+  async findExistingTests(component) {
+    const possibleTestPaths = [
+      path.join(this.rootPath, 'tests', 'unit', component.type, `${component.name}.test.js`),
+      path.join(this.rootPath, 'tests', 'unit', component.type, `${component.name}.spec.js`),
+      path.join(this.rootPath, 'test', `${component.name}.test.js`),
+      path.join(this.rootPath, '__tests__', `${component.name}.test.js`)
+    ];
+
+    for (const testPath of possibleTestPaths) {
+      if (await this.fileExists(testPath)) {
+        return {
+          path: testPath,
+          exists: true
+        };
+      }
+    }
+
+    return { exists: false };
+  }
+
+  calculateMockCoverage(mockLevel) {
+    const coverage = {
+      minimal: 30,
+      moderate: 60,
+      extensive: 90
+    };
+    return coverage[mockLevel] || 60;
+  }
+
+  calculateAssertionDensity(qualityLevel) {
+    const density = {
+      basic: 2,
+      standard: 4,
+      comprehensive: 6
+    };
+    return density[qualityLevel] || 4;
+  }
+
+  async generateFunctionTestCases(func, analysis, config) {
+    // This would generate test cases based on function analysis
+    // For now, return basic test case structure
+    return [
+      {
+        name: `should ${func.name} successfully`,
+        type: 'success_case',
+        description: `Test successful execution of ${func.name}`,
+        assertions: config.qualityLevel === 'comprehensive' ? 3 : 2
+      },
+      {
+        name: `should handle ${func.name} errors`,
+        type: 'error_case',
+        description: `Test error handling in ${func.name}`,
+        assertions: 2
+      }
+    ];
+  }
+
+  async generateEdgeCaseTest(edgeCase, analysis, config) {
+    return {
+      name: `should handle ${edgeCase.type}`,
+      type: 'edge_case',
+      description: edgeCase.description,
+      assertions: 1
+    };
+  }
+
+  async generateIntegrationScenarios(component, analysis) {
+    // Generate integration test scenarios based on component dependencies
+    const scenarios = [];
+    
+    if (analysis.dependencies.length > 0) {
+      scenarios.push({
+        name: 'should integrate with dependencies',
+        description: 'Test integration with internal dependencies',
+        dependencies: analysis.dependencies.slice(0, 3)
+      });
+    }
+
+    if (analysis.external_dependencies.length > 0) {
+      scenarios.push({
+        name: 'should integrate with external services',
+        description: 'Test integration with external dependencies',
+        dependencies: analysis.external_dependencies.slice(0, 2)
+      });
+    }
+
+    return scenarios;
+  }
+
+  async generateE2EScenarios(component, analysis) {
+    const scenarios = [];
+    
+    if (component.type === 'workflow') {
+      scenarios.push({
+        name: 'should complete full workflow',
+        description: 'Test complete workflow execution end-to-end',
+        steps: ['initialize', 'execute', 'validate', 'cleanup']
+      });
+    }
+
+    if (component.type === 'task') {
+      scenarios.push({
+        name: 'should execute task end-to-end',
+        description: 'Test complete task execution with real dependencies',
+        steps: ['setup', 'execute', 'verify_output']
+      });
+    }
+
+    return scenarios;
+  }
+}
+
+module.exports = GenerateTestsTask;
+```
+
+## Validation Rules
+
+### Input Validation
+- Component type must be valid or 'all' for bulk generation
+- Coverage target must be 0-100%
+- Test framework must be supported
+- Quality level must be recognized
+
+### Safety Checks
+- Don't overwrite existing tests without confirmation
+- Validate component exists before test generation
+- Ensure output directory is writable
+- Check for conflicting test frameworks
+
+### Generation Requirements
+- Must generate syntactically valid test code
+- Should include appropriate setup/teardown
+- Must include meaningful test descriptions
+- Should follow testing best practices
+
+## Integration Points
+
+### Test Template System
+- Provides reusable test templates
+- Manages test code generation patterns
+- Handles framework-specific syntax
+- Supports custom test structures
+
+### Test Generator
+- Orchestrates test file creation
+- Analyzes components for testable elements
+- Generates comprehensive test suites
+- Handles different test types (unit, integration, e2e)
+
+### Coverage Analyzer
+- Analyzes existing test coverage
+- Identifies coverage gaps
+- Provides coverage metrics
+- Suggests coverage improvements
+
+### Quality Assessment
+- Evaluates generated test quality
+- Provides quality metrics and scores
+- Identifies test improvement opportunities
+- Validates test effectiveness
+
+## Output Structure
+
+### Success Response
+```json
+{
+  "success": true,
+  "components": 5,
+  "testFilesGenerated": 12,
+  "expectedCoverage": 85,
+  "qualityScore": 8.5
+}
+```
+
+### Error Response
+```json
+{
+  "success": false,
+  "error": "Component not found: agent/invalid-name",
+  "suggestions": ["weather-agent", "data-agent"]
+}
+```
+
+## Security Considerations
+- Validate all file paths to prevent directory traversal
+- Sanitize component names and test descriptions
+- Ensure generated code doesn't include sensitive information
+- Validate test framework dependencies for security vulnerabilities 
+