dhurandhar 1.0.0

package/tools/lib/test-engine.js

@@ -0,0 +1,255 @@
+/**
+ * Contract-First Testing Engine
+ * Generates comprehensive test suites BEFORE implementation
+ * 
+ * Philosophy: Tests define the contract, implementation fulfills it
+ */
+
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { writeFile } from 'fs/promises';
+
+export class TestEngine {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.testDir = join(projectRoot, 'tests');
+    this.contractsDir = join(this.testDir, 'contracts');
+    this.edgeCasesDir = join(this.testDir, 'edge-cases');
+  }
+  
+  /**
+   * Initialize test directory structure
+   */
+  async initializeTestStructure() {
+    const dirs = [
+      this.testDir,
+      this.contractsDir,
+      this.edgeCasesDir,
+      join(this.testDir, 'integration'),
+      join(this.testDir, 'utils'),
+    ];
+    
+    for (const dir of dirs) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  
+  /**
+   * Generate test suite from Story
+   */
+  async generateStoryTests(story, epic) {
+    const { interaction_boundary } = story;
+    
+    const tests = {
+      standard_flows: this.generateStandardFlowTests(story, interaction_boundary),
+      error_states: this.generateErrorStateTests(story, interaction_boundary),
+      edge_cases: this.generateEdgeCaseTests(story, interaction_boundary),
+    };
+    
+    return tests;
+  }
+  
+  /**
+   * Generate standard flow tests (happy path)
+   */
+  generateStandardFlowTests(story, boundary) {
+    const testCode = `
+/**
+ * Contract Test: ${story.name}
+ * Story: ${story.id}
+ * Service: ${boundary.service}
+ * Endpoint: ${boundary.method} ${boundary.api_endpoint}
+ * 
+ * TEST-FIRST: This test defines the contract BEFORE implementation
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { apiClient } from '../utils/api-client';
+
+describe('${story.name} - Standard Flows', () => {
+  let testContext = {};
+  
+  beforeAll(async () => {
+    // Setup: Initialize test data
+    testContext = await setupTestData();
+  });
+  
+  it('should handle standard request successfully', async () => {
+    // Arrange
+    const request = ${JSON.stringify(boundary.request_contract || {}, null, 4)};
+    
+    // Act
+    const response = await apiClient.${boundary.method.toLowerCase()}(
+      '${boundary.api_endpoint}',
+      request
+    );
+    
+    // Assert - Contract validation
+    expect(response.status).toBe(200);
+    expect(response.data).toMatchObject(${JSON.stringify(boundary.response_contract || {}, null, 4)});
+  });
+  
+  it('should return correct response schema', async () => {
+    const response = await apiClient.${boundary.method.toLowerCase()}('${boundary.api_endpoint}');
+    
+    // Validate response contract structure
+    const expectedSchema = ${JSON.stringify(boundary.response_contract || {}, null, 4)};
+    
+    Object.keys(expectedSchema).forEach(key => {
+      expect(response.data).toHaveProperty(key);
+    });
+  });
+});
+`;
+    
+    return testCode;
+  }
+  
+  /**
+   * Generate error state tests
+   */
+  generateErrorStateTests(story, boundary) {
+    const errorStates = boundary.error_states || [400, 401, 404, 500];
+    
+    const testCode = `
+/**
+ * Error State Tests: ${story.name}
+ * Tests all error conditions defined in the contract
+ */
+
+import { describe, it, expect } from 'vitest';
+import { apiClient } from '../utils/api-client';
+
+describe('${story.name} - Error States', () => {
+  ${errorStates.map(status => `
+  it('should handle ${status} error correctly', async () => {
+    const invalidRequest = generateInvalidRequest${status}();
+    
+    try {
+      await apiClient.${boundary.method.toLowerCase()}(
+        '${boundary.api_endpoint}',
+        invalidRequest
+      );
+      
+      // Should not reach here
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error.response.status).toBe(${status});
+      expect(error.response.data).toHaveProperty('error');
+      expect(error.response.data).toHaveProperty('message');
+    }
+  });
+  `).join('\n')}
+});
+
+// Error case generators
+${errorStates.map(status => `
+function generateInvalidRequest${status}() {
+  // TODO: Generate request that triggers ${status}
+  return {};
+}
+`).join('\n')}
+`;
+    
+    return testCode;
+  }
+  
+  /**
+   * Generate edge case tests (boundary conditions)
+   */
+  generateEdgeCaseTests(story, boundary) {
+    const testCode = `
+/**
+ * Edge Case Tests: ${story.name}
+ * Boundary conditions, race conditions, and security edge cases
+ * 
+ * NOTE: Edge Case Hunter persona should expand this
+ */
+
+import { describe, it, expect } from 'vitest';
+import { apiClient } from '../utils/api-client';
+
+describe('${story.name} - Edge Cases', () => {
+  it('should handle empty request body', async () => {
+    // Edge case: Empty payload
+    const response = await apiClient.${boundary.method.toLowerCase()}(
+      '${boundary.api_endpoint}',
+      {}
+    );
+    
+    // Define expected behavior for empty input
+    expect(response.status).toBeOneOf([200, 400]);
+  });
+  
+  it('should handle extremely large payload', async () => {
+    // Edge case: Payload size limits
+    const largePayload = generateLargePayload(10 * 1024 * 1024); // 10MB
+    
+    try {
+      await apiClient.${boundary.method.toLowerCase()}(
+        '${boundary.api_endpoint}',
+        largePayload
+      );
+    } catch (error) {
+      expect(error.response.status).toBe(413); // Payload Too Large
+    }
+  });
+  
+  it('should handle concurrent requests', async () => {
+    // Edge case: Race conditions
+    const requests = Array(100).fill().map(() =>
+      apiClient.${boundary.method.toLowerCase()}('${boundary.api_endpoint}')
+    );
+    
+    const results = await Promise.allSettled(requests);
+    
+    // All should complete without server errors
+    const serverErrors = results.filter(r => 
+      r.status === 'rejected' && r.reason.response?.status >= 500
+    );
+    expect(serverErrors.length).toBe(0);
+  });
+  
+  // TODO: Add security edge cases (injection, XSS, CSRF)
+  // TODO: Add boundary value tests (min/max integers, string lengths)
+  // TODO: Add timeout and retry scenarios
+});
+
+function generateLargePayload(size) {
+  return { data: 'x'.repeat(size) };
+}
+`;
+    
+    return testCode;
+  }
+  
+  /**
+   * Save generated tests to files
+   */
+  async saveTests(story, tests) {
+    const storyId = story.id.toLowerCase();
+    
+    const files = [
+      {
+        path: join(this.contractsDir, `${storyId}-standard.test.js`),
+        content: tests.standard_flows,
+      },
+      {
+        path: join(this.contractsDir, `${storyId}-errors.test.js`),
+        content: tests.error_states,
+      },
+      {
+        path: join(this.edgeCasesDir, `${storyId}-edge.test.js`),
+        content: tests.edge_cases,
+      },
+    ];
+    
+    for (const file of files) {
+      await writeFile(file.path, file.content, 'utf-8');
+    }
+    
+    return files.map(f => f.path);
+  }
+}

package/tools/lib/test-templates/api-client.template.js

@@ -0,0 +1,100 @@
+/**
+ * API Client Template for Contract Testing
+ * Generated by Dhurandhar Test-First Engine
+ * 
+ * This client defines the interaction boundaries for all services
+ */
+
+class APIClient {
+  constructor(baseURL = process.env.API_BASE_URL || 'http://localhost:8080') {
+    this.baseURL = baseURL;
+    this.headers = {
+      'Content-Type': 'application/json',
+    };
+  }
+  
+  /**
+   * Set authentication token
+   */
+  setAuthToken(token) {
+    this.headers['Authorization'] = `Bearer ${token}`;
+  }
+  
+  /**
+   * Generic request handler
+   */
+  async request(method, endpoint, data = null, options = {}) {
+    const url = `${this.baseURL}${endpoint}`;
+    
+    const config = {
+      method,
+      headers: { ...this.headers, ...options.headers },
+    };
+    
+    if (data && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      config.body = JSON.stringify(data);
+    }
+    
+    try {
+      const response = await fetch(url, config);
+      
+      const responseData = await response.json().catch(() => ({}));
+      
+      if (!response.ok) {
+        const error = new Error(`HTTP ${response.status}`);
+        error.response = {
+          status: response.status,
+          data: responseData,
+        };
+        throw error;
+      }
+      
+      return {
+        status: response.status,
+        data: responseData,
+        headers: response.headers,
+      };
+    } catch (error) {
+      if (error.response) {
+        throw error; // HTTP error with response
+      }
+      
+      // Network or other error
+      const networkError = new Error('Network error');
+      networkError.response = {
+        status: 0,
+        data: { error: 'NetworkError', message: error.message },
+      };
+      throw networkError;
+    }
+  }
+  
+  /**
+   * HTTP Methods
+   */
+  get(endpoint, options) {
+    return this.request('GET', endpoint, null, options);
+  }
+  
+  post(endpoint, data, options) {
+    return this.request('POST', endpoint, data, options);
+  }
+  
+  put(endpoint, data, options) {
+    return this.request('PUT', endpoint, data, options);
+  }
+  
+  patch(endpoint, data, options) {
+    return this.request('PATCH', endpoint, data, options);
+  }
+  
+  delete(endpoint, options) {
+    return this.request('DELETE', endpoint, null, options);
+  }
+}
+
+// Export singleton instance
+export const apiClient = new APIClient();
+
+// Export class for custom instances
+export default APIClient;

package/tools/lib/test-templates/vitest.config.template.js

@@ -0,0 +1,37 @@
+/**
+ * Vitest Configuration for Contract-First Testing
+ * Generated by Dhurandhar
+ */
+
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    // Test environment
+    environment: 'node',
+    
+    // Global test timeout
+    testTimeout: 10000,
+    
+    // Coverage configuration
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/**',
+        'tests/utils/**',
+        '**/*.config.js',
+      ],
+    },
+    
+    // Test execution
+    globals: true,
+    watch: false,
+    
+    // Setup files
+    setupFiles: ['./tests/setup.js'],
+    
+    // Reporters
+    reporters: ['verbose'],
+  },
+});

package/tools/lib/validators/config-validator.js

@@ -0,0 +1,113 @@
+/**
+ * Configuration Validator
+ * Validates configuration files and settings
+ */
+
+import { ConfigManager } from '../config-manager.js';
+
+export class ConfigValidator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.configManager = new ConfigManager(projectRoot);
+  }
+  
+  /**
+   * Validate configuration
+   */
+  async validate(strict = false) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+    };
+    
+    try {
+      // Check if config exists
+      if (!this.configManager.exists()) {
+        result.valid = false;
+        result.errors.push('Configuration file not found');
+        return result;
+      }
+      
+      // Load and validate structure
+      const config = await this.configManager.load();
+      
+      // Required fields
+      const required = ['version', 'projectName', 'userName', 'outputFolder'];
+      for (const field of required) {
+        if (!config[field]) {
+          result.valid = false;
+          result.errors.push(`Missing required field: ${field}`);
+        }
+      }
+      
+      // Validate project name format
+      if (config.projectName && !/^[a-z0-9-]+$/.test(config.projectName)) {
+        if (strict) {
+          result.valid = false;
+          result.errors.push('Project name must contain only lowercase letters, numbers, and hyphens');
+        } else {
+          result.warnings.push('Project name should contain only lowercase letters, numbers, and hyphens');
+        }
+      }
+      
+      // Validate output folder
+      if (config.outputFolder && config.outputFolder.includes('..')) {
+        result.valid = false;
+        result.errors.push('Output folder cannot contain parent directory references (..)');
+      }
+      
+      // Validate modules array
+      if (config.modules && !Array.isArray(config.modules)) {
+        result.valid = false;
+        result.errors.push('Modules field must be an array');
+      }
+      
+      // Validate version format
+      if (config.version && !/^\d+\.\d+\.\d+/.test(config.version)) {
+        result.warnings.push('Version should follow semantic versioning (x.y.z)');
+      }
+      
+      // Check for unknown fields (in strict mode)
+      if (strict) {
+        const knownFields = ['version', 'projectName', 'userName', 'outputFolder', 'modules', 'settings', 'variables'];
+        const unknownFields = Object.keys(config).filter(key => !knownFields.includes(key));
+        
+        if (unknownFields.length > 0) {
+          result.warnings.push(`Unknown configuration fields: ${unknownFields.join(', ')}`);
+        }
+      }
+      
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Validation error: ${error.message}`);
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Validate a specific configuration value
+   */
+  validateValue(field, value, rules) {
+    const errors = [];
+    
+    if (rules.required && !value) {
+      errors.push(`${field} is required`);
+    }
+    
+    if (rules.pattern && value && !rules.pattern.test(value)) {
+      errors.push(`${field} does not match required pattern`);
+    }
+    
+    if (rules.minLength && value && value.length < rules.minLength) {
+      errors.push(`${field} must be at least ${rules.minLength} characters`);
+    }
+    
+    if (rules.maxLength && value && value.length > rules.maxLength) {
+      errors.push(`${field} must be at most ${rules.maxLength} characters`);
+    }
+    
+    return errors;
+  }
+}

package/tools/lib/validators/module-validator.js

@@ -0,0 +1,137 @@
+/**
+ * Module Validator
+ * Validates module structure and metadata
+ */
+
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import yaml from 'yaml';
+import { ModuleManager } from '../module-manager.js';
+
+export class ModuleValidator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.moduleManager = new ModuleManager(projectRoot);
+    this.modulesDir = join(projectRoot, '.dhurandhar/modules');
+  }
+  
+  /**
+   * Validate all installed modules
+   */
+  async validate(strict = false) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+    };
+    
+    try {
+      // Check if modules directory exists
+      if (!existsSync(this.modulesDir)) {
+        result.warnings.push('No modules directory found');
+        return result;
+      }
+      
+      // Get installed modules
+      const installed = await this.moduleManager.listInstalled();
+      
+      if (installed.length === 0) {
+        result.warnings.push('No modules installed');
+        return result;
+      }
+      
+      // Validate each module
+      for (const moduleCode of installed) {
+        const moduleResult = await this.validateModule(moduleCode, strict);
+        
+        if (!moduleResult.valid) {
+          result.valid = false;
+        }
+        
+        result.errors.push(...moduleResult.errors.map(e => `[${moduleCode}] ${e}`));
+        result.warnings.push(...moduleResult.warnings.map(w => `[${moduleCode}] ${w}`));
+      }
+      
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Module validation error: ${error.message}`);
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Validate a single module
+   */
+  async validateModule(moduleCode, strict = false) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+    };
+    
+    const modulePath = join(this.modulesDir, moduleCode);
+    const moduleYamlPath = join(modulePath, 'module.yaml');
+    
+    // Check if module.yaml exists
+    if (!existsSync(moduleYamlPath)) {
+      result.valid = false;
+      result.errors.push('module.yaml not found');
+      return result;
+    }
+    
+    try {
+      // Parse module.yaml
+      const content = await readFile(moduleYamlPath, 'utf-8');
+      const metadata = yaml.parse(content);
+      
+      // Required fields
+      const required = ['code', 'name', 'description'];
+      for (const field of required) {
+        if (!metadata[field]) {
+          result.valid = false;
+          result.errors.push(`Missing required field: ${field}`);
+        }
+      }
+      
+      // Validate code matches directory name
+      if (metadata.code && metadata.code !== moduleCode) {
+        if (strict) {
+          result.valid = false;
+          result.errors.push(`Module code "${metadata.code}" does not match directory name "${moduleCode}"`);
+        } else {
+          result.warnings.push(`Module code "${metadata.code}" does not match directory name "${moduleCode}"`);
+        }
+      }
+      
+      // Validate dependencies
+      if (metadata.dependencies) {
+        if (!Array.isArray(metadata.dependencies)) {
+          result.valid = false;
+          result.errors.push('Dependencies must be an array');
+        } else {
+          const installed = await this.moduleManager.listInstalled();
+          const missing = metadata.dependencies.filter(dep => !installed.includes(dep));
+          
+          if (missing.length > 0) {
+            result.valid = false;
+            result.errors.push(`Missing dependencies: ${missing.join(', ')}`);
+          }
+        }
+      }
+      
+      // Check for README
+      const readmePath = join(modulePath, 'README.md');
+      if (!existsSync(readmePath)) {
+        result.warnings.push('README.md not found');
+      }
+      
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Failed to parse module.yaml: ${error.message}`);
+    }
+    
+    return result;
+  }
+}