dhurandhar 1.0.0

package/tools/cli/commands/test.js

@@ -0,0 +1,277 @@
+/**
+ * Test Command - Contract-First Testing
+ * Generate and validate test suites from Agile Blueprint
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { SDMManager } from '../../lib/sdm-manager.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+import { TestEngine } from '../../lib/test-engine.js';
+import { existsSync } from 'fs';
+import { readFile, writeFile, copyFile } from 'fs/promises';
+import { join } from 'path';
+
+export async function testCommand(options) {
+  try {
+    const sdmManager = new SDMManager(process.cwd());
+    const configManager = new ConfigManager(process.cwd());
+    
+    if (!configManager.exists()) {
+      clack.log.error(chalk.red('Framework not installed.'));
+      clack.log.info('Run: dhurandhar install');
+      process.exit(1);
+    }
+    
+    if (!sdmManager.exists()) {
+      clack.log.error(chalk.red('SYSTEM_DESIGN_MAP.yaml not found.'));
+      process.exit(1);
+    }
+    
+    const testEngine = new TestEngine(process.cwd());
+    
+    if (options.generate) {
+      // Generate test suite from Agile Blueprint
+      await generateTestSuite(sdmManager, testEngine);
+      
+    } else if (options.validate) {
+      // Validate implementation against Agile Blueprint
+      await validateCoverage(sdmManager, testEngine);
+      
+    } else if (options.edgeCases) {
+      // Generate edge case tests for specific story
+      await generateEdgeCases(sdmManager, testEngine, options.edgeCases);
+      
+    } else if (options.init) {
+      // Initialize test infrastructure
+      await initializeTestInfra(testEngine);
+      
+    } else {
+      // Show help
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar test --init              Initialize test infrastructure');
+      console.log('  dhurandhar test --generate          Generate tests from Agile Blueprint');
+      console.log('  dhurandhar test --validate          Validate coverage against Stories');
+      console.log('  dhurandhar test --edge-cases ID     Generate edge cases for Story');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Test operation failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Generate test suite from SDM Agile Blueprint
+ */
+async function generateTestSuite(sdmManager, testEngine) {
+  clack.intro(chalk.cyan.bold('📋 Generate Contract-First Test Suite'));
+  
+  const sdm = await sdmManager.load();
+  
+  if (!sdm.agile_blueprint || !sdm.agile_blueprint.epics) {
+    clack.log.warn('No Agile Blueprint found in SDM.');
+    clack.log.info('Add Epics and Stories first: dhurandhar epic add');
+    process.exit(0);
+  }
+  
+  const spinner = clack.spinner();
+  spinner.start('Generating tests from Agile Blueprint...');
+  
+  // Initialize test structure
+  await testEngine.initializeTestStructure();
+  
+  let totalTests = 0;
+  const generatedFiles = [];
+  
+  // Iterate through all Epics and Stories
+  for (const epic of sdm.agile_blueprint.epics) {
+    for (const story of epic.stories) {
+      spinner.message(`Generating tests for ${story.id}: ${story.name}`);
+      
+      // Generate test suite for this story
+      const tests = await testEngine.generateStoryTests(story, epic);
+      
+      // Save tests to files
+      const files = await testEngine.saveTests(story, tests);
+      generatedFiles.push(...files);
+      totalTests += 3; // standard, errors, edge cases
+    }
+  }
+  
+  spinner.stop(`Generated ${totalTests} test suites`);
+  
+  // Copy test utilities
+  await copyTestUtilities();
+  
+  // Generate package.json test scripts
+  await addTestScripts();
+  
+  clack.outro(chalk.green('✓ Contract-first test suite generated'));
+  
+  console.log('');
+  console.log(chalk.cyan('Generated files:'));
+  generatedFiles.slice(0, 10).forEach(file => {
+    console.log(`  ${chalk.dim(file)}`);
+  });
+  if (generatedFiles.length > 10) {
+    console.log(`  ${chalk.dim(`... and ${generatedFiles.length - 10} more`)}`);
+  }
+  console.log('');
+  console.log(chalk.cyan('Next steps:'));
+  console.log('  1. Install test dependencies: npm install -D vitest');
+  console.log('  2. Review generated tests in tests/ directory');
+  console.log('  3. Run tests: npm test');
+  console.log('  4. Implement services to pass the tests');
+  console.log('');
+}
+
+/**
+ * Validate implementation coverage against Agile Blueprint
+ */
+async function validateCoverage(sdmManager, testEngine) {
+  clack.intro(chalk.cyan.bold('✅ Validate Story Coverage'));
+  
+  const sdm = await sdmManager.load();
+  
+  if (!sdm.agile_blueprint) {
+    clack.log.warn('No Agile Blueprint to validate.');
+    process.exit(0);
+  }
+  
+  const results = {
+    total_stories: 0,
+    tested_stories: 0,
+    implemented_stories: 0,
+    uncovered_stories: [],
+  };
+  
+  // Check each Story
+  for (const epic of sdm.agile_blueprint.epics || []) {
+    for (const story of epic.stories || []) {
+      results.total_stories++;
+      
+      // Check if tests exist
+      const testFile = join(process.cwd(), 'tests', 'contracts', 
+        `${story.id.toLowerCase()}-standard.test.js`);
+      
+      if (existsSync(testFile)) {
+        results.tested_stories++;
+      }
+      
+      // Check if tasks are complete
+      const allTasksComplete = story.tasks?.every(t => t.status === 'complete');
+      if (allTasksComplete) {
+        results.implemented_stories++;
+      } else {
+        results.uncovered_stories.push({
+          id: story.id,
+          name: story.name,
+          has_tests: existsSync(testFile),
+          pending_tasks: story.tasks?.filter(t => t.status !== 'complete').length || 0,
+        });
+      }
+    }
+  }
+  
+  // Calculate coverage
+  const testCoverage = results.total_stories > 0 
+    ? ((results.tested_stories / results.total_stories) * 100).toFixed(1)
+    : 0;
+  
+  const implCoverage = results.total_stories > 0
+    ? ((results.implemented_stories / results.total_stories) * 100).toFixed(1)
+    : 0;
+  
+  // Update SDM
+  sdm.agile_blueprint.test_suite_status = {
+    total_stories: results.total_stories,
+    tested_stories: results.tested_stories,
+    coverage_percentage: parseFloat(testCoverage),
+    last_test_run: new Date().toISOString(),
+  };
+  await sdmManager.save(sdm);
+  
+  // Display results
+  console.log('');
+  console.log(chalk.bold('Coverage Report:'));
+  console.log(`  Total Stories: ${results.total_stories}`);
+  console.log(`  Test Coverage: ${testCoverage}% (${results.tested_stories}/${results.total_stories})`);
+  console.log(`  Implementation: ${implCoverage}% (${results.implemented_stories}/${results.total_stories})`);
+  console.log('');
+  
+  if (results.uncovered_stories.length > 0) {
+    console.log(chalk.yellow('Uncovered Stories:'));
+    results.uncovered_stories.forEach(story => {
+      const status = story.has_tests ? '🟡 Tests exist' : '🔴 No tests';
+      console.log(`  ${status} ${story.id}: ${story.name}`);
+      console.log(`    Pending tasks: ${story.pending_tasks}`);
+    });
+    console.log('');
+  }
+  
+  clack.outro(testCoverage === '100.0' ? chalk.green('✓ Full coverage!') : chalk.yellow('⚠ Incomplete coverage'));
+}
+
+/**
+ * Generate edge case tests
+ */
+async function generateEdgeCases(sdmManager, testEngine, storyId) {
+  // TODO: Implement edge case generation
+  console.log(chalk.cyan(`Generating edge cases for ${storyId}...`));
+}
+
+/**
+ * Initialize test infrastructure
+ */
+async function initializeTestInfra(testEngine) {
+  clack.intro(chalk.cyan.bold('🔧 Initialize Test Infrastructure'));
+  
+  const spinner = clack.spinner();
+  spinner.start('Setting up test structure...');
+  
+  await testEngine.initializeTestStructure();
+  await copyTestUtilities();
+  await addTestScripts();
+  
+  spinner.stop('Test infrastructure ready');
+  
+  clack.outro(chalk.green('✓ Initialized'));
+}
+
+/**
+ * Copy test utilities
+ */
+async function copyTestUtilities() {
+  const templatesDir = join(process.cwd(), 'tools/lib/test-templates');
+  const testUtilsDir = join(process.cwd(), 'tests/utils');
+  
+  const files = [
+    'api-client.template.js',
+    'vitest.config.template.js',
+  ];
+  
+  for (const file of files) {
+    const src = join(templatesDir, file);
+    const dest = join(testUtilsDir, file.replace('.template', ''));
+    
+    if (existsSync(src)) {
+      await copyFile(src, dest);
+    }
+  }
+}
+
+/**
+ * Add test scripts to package.json
+ */
+async function addTestScripts() {
+  const pkgPath = join(process.cwd(), 'package.json');
+  const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+  
+  pkg.scripts = pkg.scripts || {};
+  pkg.scripts.test = pkg.scripts.test || 'vitest run';
+  pkg.scripts['test:watch'] = 'vitest watch';
+  pkg.scripts['test:coverage'] = 'vitest run --coverage';
+  
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf-8');
+}

package/tools/cli/commands/validate.js

@@ -0,0 +1,107 @@
+/**
+ * Validate Command
+ * Validates configuration and modules
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { ConfigValidator } from '../../lib/validators/config-validator.js';
+import { ModuleValidator } from '../../lib/validators/module-validator.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+
+export async function validateCommand(options) {
+  try {
+    const configManager = new ConfigManager(process.cwd());
+    
+    if (!configManager.exists()) {
+      clack.log.error(chalk.red('Dhurandhar is not installed in this directory.'));
+      clack.log.info('Run: dhurandhar install');
+      process.exit(1);
+    }
+    
+    clack.intro(chalk.cyan.bold('Dhurandhar Validation'));
+    
+    const results = {
+      config: { valid: true, errors: [], warnings: [] },
+      modules: { valid: true, errors: [], warnings: [] },
+    };
+    
+    // Validate configuration
+    if (!options.modules) {
+      const spinner = clack.spinner();
+      spinner.start('Validating configuration...');
+      
+      const configValidator = new ConfigValidator(process.cwd());
+      results.config = await configValidator.validate(options.strict);
+      
+      if (results.config.valid) {
+        spinner.stop(chalk.green('✓ Configuration is valid'));
+      } else {
+        spinner.stop(chalk.red('✗ Configuration has errors'));
+      }
+    }
+    
+    // Validate modules
+    if (!options.config) {
+      const spinner = clack.spinner();
+      spinner.start('Validating modules...');
+      
+      const moduleValidator = new ModuleValidator(process.cwd());
+      results.modules = await moduleValidator.validate(options.strict);
+      
+      if (results.modules.valid) {
+        spinner.stop(chalk.green('✓ Modules are valid'));
+      } else {
+        spinner.stop(chalk.red('✗ Modules have errors'));
+      }
+    }
+    
+    // Display detailed results
+    console.log('');
+    
+    if (results.config.errors.length > 0) {
+      console.log(chalk.red.bold('Configuration Errors:'));
+      results.config.errors.forEach(error => {
+        console.log(`  ${chalk.red('✗')} ${error}`);
+      });
+      console.log('');
+    }
+    
+    if (results.config.warnings.length > 0) {
+      console.log(chalk.yellow.bold('Configuration Warnings:'));
+      results.config.warnings.forEach(warning => {
+        console.log(`  ${chalk.yellow('⚠')} ${warning}`);
+      });
+      console.log('');
+    }
+    
+    if (results.modules.errors.length > 0) {
+      console.log(chalk.red.bold('Module Errors:'));
+      results.modules.errors.forEach(error => {
+        console.log(`  ${chalk.red('✗')} ${error}`);
+      });
+      console.log('');
+    }
+    
+    if (results.modules.warnings.length > 0) {
+      console.log(chalk.yellow.bold('Module Warnings:'));
+      results.modules.warnings.forEach(warning => {
+        console.log(`  ${chalk.yellow('⚠')} ${warning}`);
+      });
+      console.log('');
+    }
+    
+    const allValid = results.config.valid && results.modules.valid;
+    
+    if (allValid) {
+      clack.outro(chalk.green('✓ All validations passed!'));
+    } else {
+      clack.outro(chalk.red('✗ Validation failed. Please fix the errors above.'));
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Validation failed:'), error.message);
+    process.exit(1);
+  }
+}

package/tools/cli/dhurandhar.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * Dhurandhar CLI
+ * Main entry point for the Dhurandhar system design framework
+ */
+
+import { program } from 'commander';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+import chalk from 'chalk';
+import { installCommand } from './commands/install.js';
+import { configCommand } from './commands/config.js';
+import { moduleCommand } from './commands/module.js';
+import { validateCommand } from './commands/validate.js';
+import { serviceCommand } from './commands/service.js';
+import { entityCommand } from './commands/entity.js';
+import { contextCommand } from './commands/context.js';
+import { epicCommand } from './commands/epic.js';
+import { storyCommand } from './commands/story.js';
+import { testCommand } from './commands/test.js';
+import { strategyCommand } from './commands/strategy.js';
+import { auditCommand } from './commands/audit.js';
+import { decisionsCommand } from './commands/decisions.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Read package.json for version info
+const packagePath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+
+// Configure CLI
+program
+  .name('dhurandhar')
+  .description('A System Building Mapwork - Framework for system design and build processes')
+  .version(packageJson.version, '-v, --version', 'Output the current version');
+
+// Install command - Initialize framework in a project
+program
+  .command('install')
+  .description('Install Dhurandhar framework in the current project')
+  .option('-d, --directory <path>', 'Target directory', process.cwd())
+  .option('-m, --modules <modules...>', 'Modules to install')
+  .option('-y, --yes', 'Skip prompts and use defaults')
+  .action(installCommand);
+
+// Config command - Manage configuration
+program
+  .command('config')
+  .description('Manage Dhurandhar configuration')
+  .option('-s, --show', 'Show current configuration')
+  .option('-e, --edit', 'Edit configuration interactively')
+  .option('-r, --reset', 'Reset to default configuration')
+  .action(configCommand);
+
+// Module command - Manage modules
+program
+  .command('module')
+  .description('Manage Dhurandhar modules')
+  .option('-l, --list', 'List available modules')
+  .option('-i, --info <module>', 'Show module information')
+  .option('-a, --add <module>', 'Add a module')
+  .option('-r, --remove <module>', 'Remove a module')
+  .action(moduleCommand);
+
+// Validate command - Validate configuration and modules
+program
+  .command('validate')
+  .description('Validate Dhurandhar configuration and modules')
+  .option('-c, --config', 'Validate configuration only')
+  .option('-m, --modules', 'Validate modules only')
+  .option('--strict', 'Use strict validation')
+  .action(validateCommand);
+
+// Service command - Engineering-first service management
+program
+  .command('service')
+  .description('Manage microservices and system components')
+  .option('-l, --list', 'List all services')
+  .option('-a, --add [spec]', 'Add service (optional quick spec: "name: description")')
+  .action(serviceCommand);
+
+// Entity command - Engineering-first entity management
+program
+  .command('entity')
+  .description('Manage database entities and relationships')
+  .option('-l, --list', 'List all entities')
+  .option('-a, --add [name]', 'Add entity')
+  .option('-r, --relate', 'Add relationship between entities')
+  .action(entityCommand);
+
+// Context command - Display SDM for rehydration
+program
+  .command('context')
+  .description('Display system architecture context')
+  .option('-s, --summary', 'Show brief summary')
+  .option('-f, --full', 'Show full architecture')
+  .option('--json', 'Output JSON format')
+  .action(contextCommand);
+
+// Epic command - Agile Blueprint (high-level capabilities)
+program
+  .command('epic')
+  .description('Manage Epics (system capabilities)')
+  .option('-l, --list', 'List all epics')
+  .option('-a, --add [name]', 'Add epic')
+  .action(epicCommand);
+
+// Story command - User journeys with API contracts
+program
+  .command('story')
+  .description('Manage Stories (user journeys)')
+  .option('-l, --list', 'List all stories')
+  .option('-a, --add [name]', 'Add story')
+  .option('-e, --epic <id>', 'Target epic ID')
+  .action(storyCommand);
+
+// Test command - Contract-first test generation
+program
+  .command('test')
+  .description('Contract-first testing')
+  .option('--init', 'Initialize test infrastructure')
+  .option('--generate', 'Generate tests from Agile Blueprint')
+  .option('--validate', 'Validate coverage against Stories')
+  .option('--edge-cases <id>', 'Generate edge cases for Story ID')
+  .action(testCommand);
+
+// Strategy command - Pluggable architectural patterns
+program
+  .command('strategy')
+  .description('Manage architectural strategies')
+  .option('--show', 'Show active strategies')
+  .option('--set <category>', 'Set strategy (persistence, communication, state, security, resilience)')
+  .option('--pivot <category>', 'Pivot existing strategy')
+  .option('--align', 'Align all services to current strategies')
+  .action(strategyCommand);
+
+// Audit command - Architectural drift detection
+program
+  .command('audit')
+  .description('Detect architectural drift (SDM vs codebase)')
+  .option('--summary', 'Show high-level alignment status')
+  .option('--drift', 'Show detailed drift report')
+  .option('--sync', 'Sync SDM to match codebase state')
+  .action(auditCommand);
+
+// Decisions command - Technical decision registry
+program
+  .command('decisions')
+  .description('Manage technical decision registry (Bmad-inspired)')
+  .option('--show', 'Show all registered decisions')
+  .option('--set <category>', 'Set decisions (naming, patterns, errors, observability)')
+  .option('--stock', 'Stock all decisions (complete setup)')
+  .action(decisionsCommand);
+
+// Help command enhancement
+program.on('--help', () => {
+  console.log('');
+  console.log(chalk.cyan('Examples - Engineering-First + Test-First Workflow:'));
+  console.log('');
+  console.log(chalk.bold('1. Initialize:'));
+  console.log('  $ dhurandhar install                               # Framework setup');
+  console.log('');
+  console.log(chalk.bold('2. Define Architecture:'));
+  console.log('  $ dhurandhar service add "auth: JWT auth"          # Add service');
+  console.log('  $ dhurandhar entity add User                       # Add entity');
+  console.log('');
+  console.log(chalk.bold('3. Test-First Agile:'));
+  console.log('  $ dhurandhar epic add "User Authentication"        # Add Epic');
+  console.log('  $ dhurandhar story add --epic EPIC-001             # Add Story');
+  console.log('  $ dhurandhar test --generate                       # Generate contract tests');
+  console.log('  $ npm test                                         # Run tests (will fail)');
+  console.log('  $ # Implement services to pass tests');
+  console.log('');
+  console.log(chalk.bold('4. Validate:'));
+  console.log('  $ dhurandhar test --validate                       # Check coverage');
+  console.log('  $ dhurandhar context --full                        # View full architecture');
+  console.log('');
+  console.log(chalk.cyan('Test-First Philosophy:'));
+  console.log('  1. Epic/Story define WHAT (capabilities & journeys)');
+  console.log('  2. Tests define HOW (API contracts & boundaries)');
+  console.log('  3. Implementation fulfills the contract');
+  console.log('');
+  console.log(chalk.cyan('Context Persistence:'));
+  console.log('  SYSTEM_DESIGN_MAP.yaml contains:');
+  console.log('  - Services & Entities (architecture)');
+  console.log('  - Epics & Stories (agile blueprint)');
+  console.log('  - Test coverage status (definition of done)');
+  console.log('');
+  console.log(chalk.cyan('Documentation:'));
+  console.log('  https://github.com/yourusername/dhurandhar');
+  console.log('');
+});
+
+// Error handling
+program.exitOverride();
+
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  if (err.code === 'commander.help') {
+    process.exit(0);
+  }
+  if (err.code === 'commander.version') {
+    process.exit(0);
+  }
+  
+  console.error(chalk.red('Error:'), err.message);
+  process.exit(1);
+}