dhurandhar 1.0.0

package/tools/cli/commands/audit.js

@@ -0,0 +1,267 @@
+/**
+ * Audit Command - Architectural Drift Detection
+ * System Observer: Compare SDM (intended) vs Codebase (actual)
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { SDMManager } from '../../lib/sdm-manager.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+
+export async function auditCommand(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);
+    }
+    
+    if (options.summary) {
+      await showSummary(sdmManager);
+    } else if (options.drift) {
+      await showDrift(sdmManager);
+    } else if (options.sync) {
+      await syncToCodebase(sdmManager);
+    } else {
+      await fullAudit(sdmManager);
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Audit failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function showSummary(sdmManager) {
+  const spinner = clack.spinner();
+  spinner.start('Scanning codebase...');
+  
+  const audit = await sdmManager.performAudit();
+  
+  spinner.stop('Scan complete');
+  
+  clack.intro(chalk.cyan.bold('📊 System Health Summary'));
+  
+  console.log('');
+  console.log(chalk.bold('Architectural Alignment:'));
+  console.log(`  Services: ${chalk.cyan(audit.summary.implemented_services)}/${audit.summary.total_services} implemented`);
+  console.log(`  Entities: ${chalk.cyan(audit.summary.implemented_entities)}/${audit.summary.total_entities} implemented`);
+  
+  if (audit.summary.total_stories > 0) {
+    console.log(`  Stories: ${chalk.cyan(audit.summary.tested_stories)}/${audit.summary.total_stories} tested`);
+  }
+  
+  console.log(`  Strategy Compliance: ${getComplianceColor(audit.summary.strategy_compliance_percentage)}${audit.summary.strategy_compliance_percentage}%${chalk.reset()}`);
+  console.log('');
+  
+  const driftColor = audit.drift_percentage <= 10 ? chalk.green 
+    : audit.drift_percentage <= 25 ? chalk.yellow 
+    : chalk.red;
+  
+  console.log(chalk.bold('Drift Assessment:'));
+  console.log(`  Drift Percentage: ${driftColor(audit.drift_percentage + '%')}`);
+  console.log(`  Status: ${getDriftStatus(audit.drift_percentage)}`);
+  console.log('');
+  
+  if (audit.drift_percentage > 10) {
+    console.log(chalk.yellow('⚠ Architectural drift detected'));
+    console.log('');
+    console.log(chalk.cyan('View details:'));
+    console.log('  dhurandhar audit --drift');
+    console.log('');
+  } else {
+    clack.outro(chalk.green('✓ System aligned'));
+  }
+}
+
+async function showDrift(sdmManager) {
+  const spinner = clack.spinner();
+  spinner.start('Analyzing drift...');
+  
+  const audit = await sdmManager.performAudit();
+  
+  spinner.stop('Analysis complete');
+  
+  clack.intro(chalk.cyan.bold('🔍 Drift Detection Report'));
+  
+  console.log('');
+  console.log(chalk.dim(`Timestamp: ${audit.timestamp}`));
+  console.log('');
+  
+  // Unimplemented (SDM → Code)
+  if (audit.unimplemented.services.length > 0 || 
+      audit.unimplemented.entities.length > 0 || 
+      audit.unimplemented.stories.length > 0) {
+    console.log(chalk.bold.red('Unimplemented (Defined in SDM, Missing in Code):'));
+    
+    if (audit.unimplemented.services.length > 0) {
+      console.log('');
+      console.log(chalk.dim('  Services:'));
+      audit.unimplemented.services.forEach(s => {
+        console.log(`    ${chalk.red('✗')} ${s.name}: ${chalk.dim(s.scope)}`);
+      });
+    }
+    
+    if (audit.unimplemented.entities.length > 0) {
+      console.log('');
+      console.log(chalk.dim('  Entities:'));
+      audit.unimplemented.entities.forEach(e => {
+        console.log(`    ${chalk.red('✗')} ${e.name} (table: ${e.table_name})`);
+      });
+    }
+    
+    if (audit.unimplemented.stories.length > 0) {
+      console.log('');
+      console.log(chalk.dim('  Stories (Tests not generated):'));
+      audit.unimplemented.stories.forEach(s => {
+        console.log(`    ${chalk.red('✗')} ${s.id}: ${s.name} (${s.epic})`);
+      });
+    }
+    
+    console.log('');
+  }
+  
+  // Unmanaged (Code → SDM)
+  if (audit.unmanaged.services.length > 0 || 
+      audit.unmanaged.entities.length > 0) {
+    console.log(chalk.bold.yellow('Unmanaged (Exists in Code, Not in SDM):'));
+    
+    if (audit.unmanaged.services.length > 0) {
+      console.log('');
+      console.log(chalk.dim('  Services:'));
+      audit.unmanaged.services.forEach(s => {
+        console.log(`    ${chalk.yellow('⚠')} ${s.name} (${s.path})`);
+      });
+    }
+    
+    if (audit.unmanaged.entities.length > 0) {
+      console.log('');
+      console.log(chalk.dim('  Entities:'));
+      audit.unmanaged.entities.forEach(e => {
+        console.log(`    ${chalk.yellow('⚠')} ${e.name} (${e.file})`);
+      });
+    }
+    
+    console.log('');
+  }
+  
+  // Strategy Violations
+  if (audit.strategy_violations.length > 0) {
+    console.log(chalk.bold.magenta('Strategy Violations:'));
+    console.log('');
+    
+    audit.strategy_violations.forEach(v => {
+      console.log(`  ${chalk.magenta('⚡')} ${chalk.bold(v.service)}: ${v.violation}`);
+      console.log(`     Strategy: ${chalk.cyan(v.strategy)}`);
+      console.log(`     Expected: ${v.expected}`);
+      console.log(`     Actual: ${chalk.dim(v.actual)}`);
+      console.log('');
+    });
+  }
+  
+  // Recommendations
+  console.log(chalk.bold('Recommendations:'));
+  console.log('');
+  
+  if (audit.unmanaged.services.length > audit.unimplemented.services.length) {
+    console.log(`  ${chalk.cyan('→')} Codebase is ahead of SDM`);
+    console.log(`    Run: ${chalk.bold('dhurandhar audit --sync')} to update SDM`);
+  } else if (audit.unimplemented.services.length > 0) {
+    console.log(`  ${chalk.cyan('→')} SDM is ahead of codebase`);
+    console.log(`    Implement missing services or remove from SDM`);
+  }
+  
+  if (audit.strategy_violations.length > 0) {
+    console.log(`  ${chalk.cyan('→')} Strategy violations detected`);
+    console.log(`    Run: ${chalk.bold('dhurandhar strategy --align')} to fix`);
+  }
+  
+  console.log('');
+  clack.outro('');
+}
+
+async function syncToCodebase(sdmManager) {
+  clack.intro(chalk.cyan.bold('🔄 Sync SDM to Codebase'));
+  
+  const spinner = clack.spinner();
+  spinner.start('Analyzing...');
+  
+  const audit = await sdmManager.performAudit();
+  
+  spinner.stop('Analysis complete');
+  
+  console.log('');
+  console.log(chalk.bold('Sync Analysis:'));
+  console.log(`  Unimplemented (SDM ahead): ${audit.unimplemented.services.length} services, ${audit.unimplemented.entities.length} entities`);
+  console.log(`  Unmanaged (Code ahead): ${audit.unmanaged.services.length} services, ${audit.unmanaged.entities.length} entities`);
+  console.log('');
+  
+  const direction = audit.unmanaged.services.length > audit.unimplemented.services.length
+    ? 'Update SDM to match code'
+    : 'Mark unimplemented as "planned"';
+  
+  console.log(chalk.cyan(`Recommendation: ${direction}`));
+  console.log('');
+  
+  const confirm = await clack.confirm({
+    message: 'Sync SDM to codebase state?',
+    initialValue: false,
+  });
+  
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  spinner.start('Synchronizing...');
+  
+  const changes = await sdmManager.syncToCodebase();
+  
+  spinner.stop('Synchronized');
+  
+  clack.outro(chalk.green('✓ SDM synchronized'));
+  
+  console.log('');
+  console.log(chalk.bold('Changes:'));
+  if (changes.added.services > 0) {
+    console.log(`  ${chalk.green('+')} ${changes.added.services} services added to SDM`);
+  }
+  if (changes.added.entities > 0) {
+    console.log(`  ${chalk.green('+')} ${changes.added.entities} entities added to SDM`);
+  }
+  console.log('');
+  
+  console.log(chalk.cyan('Verify changes:'));
+  console.log('  dhurandhar audit --summary');
+  console.log('');
+}
+
+async function fullAudit(sdmManager) {
+  await showSummary(sdmManager);
+  console.log('');
+  console.log(chalk.dim('─'.repeat(60)));
+  console.log('');
+  await showDrift(sdmManager);
+}
+
+// Helper functions
+
+function getComplianceColor(percentage) {
+  if (percentage >= 90) return chalk.green;
+  if (percentage >= 70) return chalk.yellow;
+  return chalk.red;
+}
+
+function getDriftStatus(percentage) {
+  if (percentage <= 10) return chalk.green('✓ Excellent alignment');
+  if (percentage <= 25) return chalk.yellow('⚠ Minor drift detected');
+  return chalk.red('✗ Significant drift - action required');
+}

package/tools/cli/commands/config.js

@@ -0,0 +1,113 @@
+/**
+ * Config Command
+ * Manages framework configuration
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { ConfigManager } from '../../lib/config-manager.js';
+
+export async function configCommand(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);
+    }
+    
+    if (options.show) {
+      // Show current configuration
+      clack.intro(chalk.cyan.bold('Dhurandhar Configuration'));
+      const config = await configManager.load();
+      
+      console.log('');
+      console.log(chalk.bold('Project Settings:'));
+      console.log(`  Project Name: ${chalk.cyan(config.projectName || 'Not set')}`);
+      console.log(`  User Name: ${chalk.cyan(config.userName || 'Not set')}`);
+      console.log(`  Output Folder: ${chalk.cyan(config.outputFolder || 'Not set')}`);
+      console.log('');
+      
+      if (config.modules && config.modules.length > 0) {
+        console.log(chalk.bold('Installed Modules:'));
+        config.modules.forEach(module => {
+          console.log(`  ${chalk.green('✓')} ${module}`);
+        });
+        console.log('');
+      }
+      
+      clack.outro(chalk.dim(`Config file: .dhurandhar/config.yaml`));
+      
+    } else if (options.edit) {
+      // Edit configuration interactively
+      clack.intro(chalk.cyan.bold('Edit Configuration'));
+      
+      const config = await configManager.load();
+      
+      const projectName = await clack.text({
+        message: 'Project name:',
+        initialValue: config.projectName,
+      });
+      
+      if (clack.isCancel(projectName)) {
+        clack.cancel('Configuration edit cancelled.');
+        process.exit(0);
+      }
+      
+      const userName = await clack.text({
+        message: 'User name:',
+        initialValue: config.userName,
+      });
+      
+      if (clack.isCancel(userName)) {
+        clack.cancel('Configuration edit cancelled.');
+        process.exit(0);
+      }
+      
+      const outputFolder = await clack.text({
+        message: 'Output folder:',
+        initialValue: config.outputFolder,
+      });
+      
+      if (clack.isCancel(outputFolder)) {
+        clack.cancel('Configuration edit cancelled.');
+        process.exit(0);
+      }
+      
+      await configManager.update({
+        ...config,
+        projectName,
+        userName,
+        outputFolder,
+      });
+      
+      clack.outro(chalk.green('✓ Configuration updated successfully!'));
+      
+    } else if (options.reset) {
+      // Reset to defaults
+      const confirm = await clack.confirm({
+        message: 'Are you sure you want to reset to default configuration?',
+      });
+      
+      if (clack.isCancel(confirm) || !confirm) {
+        clack.cancel('Reset cancelled.');
+        process.exit(0);
+      }
+      
+      await configManager.reset();
+      clack.outro(chalk.green('✓ Configuration reset to defaults.'));
+      
+    } else {
+      // No option provided, show help
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar config --show     Show current configuration');
+      console.log('  dhurandhar config --edit     Edit configuration');
+      console.log('  dhurandhar config --reset    Reset to defaults');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Config operation failed:'), error.message);
+    process.exit(1);
+  }
+}

package/tools/cli/commands/context.js

@@ -0,0 +1,170 @@
+/**
+ * Context Command - Display SDM for Context Rehydration
+ * Shows current architecture state for agent/developer consumption
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { SDMManager } from '../../lib/sdm-manager.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+
+export async function contextCommand(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 context = await sdmManager.getRehydrationContext();
+    const sdm = context.fullMap;
+    
+    if (options.summary) {
+      // Brief summary
+      console.log('');
+      console.log(chalk.cyan.bold(`📋 ${sdm.metadata.project_name}`));
+      console.log(chalk.dim(`Architecture: ${sdm.metadata.architecture_type}`));
+      console.log(chalk.dim(`Last Updated: ${new Date(sdm.metadata.last_updated).toLocaleString()}`));
+      console.log('');
+      console.log(chalk.bold('Tech Stack:'));
+      console.log(`  Languages: ${sdm.tech_stack.languages.join(', ') || 'None'}`);
+      console.log(`  Frameworks: ${sdm.tech_stack.frameworks.join(', ') || 'None'}`);
+      console.log(`  Databases: ${sdm.tech_stack.databases.join(', ') || 'None'}`);
+      console.log('');
+      console.log(chalk.bold('Components:'));
+      console.log(`  Services: ${sdm.services.length}`);
+      console.log(`  Entities: ${sdm.entities.length}`);
+      console.log(`  User Types: ${sdm.user_types.length}`);
+      console.log('');
+      
+    } else if (options.full) {
+      // Full architecture display
+      console.clear();
+      clack.intro(chalk.cyan.bold('🏗️  System Architecture Context'));
+      
+      console.log('');
+      console.log(chalk.bold.underline('Project Metadata'));
+      console.log(`Name: ${chalk.cyan(sdm.metadata.project_name)}`);
+      console.log(`Version: ${chalk.cyan(sdm.metadata.version)}`);
+      console.log(`Architecture: ${chalk.cyan(sdm.metadata.architecture_type)}`);
+      console.log(`Updated: ${chalk.dim(new Date(sdm.metadata.last_updated).toLocaleString())}`);
+      
+      console.log('');
+      console.log(chalk.bold.underline('Tech Stack'));
+      console.log(`Languages: ${chalk.cyan(sdm.tech_stack.languages.join(', ') || 'None')}`);
+      console.log(`Frameworks: ${chalk.cyan(sdm.tech_stack.frameworks.join(', ') || 'None')}`);
+      console.log(`Databases: ${chalk.cyan(sdm.tech_stack.databases.join(', ') || 'None')}`);
+      console.log(`Infrastructure: ${chalk.cyan(sdm.tech_stack.infrastructure.join(', ') || 'None')}`);
+      
+      if (sdm.user_types.length > 0) {
+        console.log('');
+        console.log(chalk.bold.underline(`User Types (${sdm.user_types.length})`));
+        sdm.user_types.forEach(ut => {
+          console.log(`  ${chalk.bold(ut.role)}`);
+          console.log(`    Auth: ${ut.authentication}`);
+          console.log(`    Permissions: ${ut.permissions.join(', ')}`);
+        });
+      }
+      
+      if (sdm.entities.length > 0) {
+        console.log('');
+        console.log(chalk.bold.underline(`Entities (${sdm.entities.length})`));
+        sdm.entities.forEach(e => {
+          console.log(`  ${chalk.bold(e.name)} (${e.attributes.length} attributes)`);
+          if (e.relationships && e.relationships.length > 0) {
+            e.relationships.forEach(rel => {
+              console.log(`    ${chalk.dim(rel.type)} → ${chalk.cyan(rel.target)}`);
+            });
+          }
+        });
+      }
+      
+      if (sdm.services.length > 0) {
+        console.log('');
+        console.log(chalk.bold.underline(`Services (${sdm.services.length})`));
+        sdm.services.forEach(s => {
+          console.log(`  ${chalk.bold(s.name)}`);
+          console.log(`    ${chalk.dim(s.scope)}`);
+          console.log(`    Stack: ${chalk.cyan(s.tech_stack.language)}/${chalk.cyan(s.tech_stack.framework)}/${chalk.cyan(s.tech_stack.database || 'N/A')}`);
+          if (s.api) {
+            console.log(`    API: ${s.api.type.toUpperCase()} ${s.api.base_path || ''} :${s.api.port || 'N/A'}`);
+          }
+          if (s.dependencies && s.dependencies.length > 0) {
+            console.log(`    Depends on: ${s.dependencies.join(', ')}`);
+          }
+        });
+      }
+      
+      if (sdm.communication.length > 0) {
+        console.log('');
+        console.log(chalk.bold.underline(`Service Communication (${sdm.communication.length})`));
+        sdm.communication.forEach(c => {
+          console.log(`  ${chalk.cyan(c.from)} → ${chalk.cyan(c.to)} (${c.protocol}/${c.pattern})`);
+        });
+      }
+      
+      if (sdm.infrastructure && sdm.infrastructure.components && sdm.infrastructure.components.length > 0) {
+        console.log('');
+        console.log(chalk.bold.underline('Infrastructure'));
+        console.log(`Deployment: ${chalk.cyan(sdm.infrastructure.deployment_target || 'Not specified')}`);
+        sdm.infrastructure.components.forEach(comp => {
+          console.log(`  ${comp.type}: ${chalk.cyan(comp.name)} (${comp.technology})`);
+        });
+      }
+
+      // Technical Strategies
+      if (sdm.technical_strategies) {
+        console.log('');
+        console.log(chalk.bold.underline('Active Architectural Strategies'));
+
+        if (sdm.technical_strategies.persistence?.model) {
+          console.log(`  Persistence: ${chalk.cyan(sdm.technical_strategies.persistence.model)}`);
+        }
+        if (sdm.technical_strategies.communication?.primary_pattern) {
+          console.log(`  Communication: ${chalk.cyan(sdm.technical_strategies.communication.primary_pattern)}`);
+          if (sdm.technical_strategies.communication.event_bus) {
+            console.log(`    Event Bus: ${chalk.cyan(sdm.technical_strategies.communication.event_bus.technology)}`);
+          }
+        }
+        if (sdm.technical_strategies.state_management?.caching_layer) {
+          console.log(`  Caching: ${chalk.cyan(sdm.technical_strategies.state_management.caching_layer)}`);
+        }
+        if (sdm.technical_strategies.security?.authentication) {
+          console.log(`  Auth: ${chalk.cyan(sdm.technical_strategies.security.authentication)}`);
+        }
+        if (sdm.technical_strategies.resilience?.circuit_breaker) {
+          console.log(`  Resilience: Circuit Breaker ${chalk.green('enabled')}`);
+        }
+      }
+
+      console.log('');
+      clack.outro(chalk.dim('This context is persisted in SYSTEM_DESIGN_MAP.yaml'));
+      
+    } else if (options.json) {
+      // JSON output for programmatic use
+      console.log(JSON.stringify(sdm, null, 2));
+      
+    } else {
+      // Default: Agent-friendly summary
+      console.log('');
+      console.log(chalk.cyan.bold('🔄 Context Rehydrated'));
+      console.log('');
+      console.log(context.summary);
+      console.log('');
+      console.log(chalk.dim('Use --full for complete architecture view'));
+      console.log('');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Context retrieval failed:'), error.message);
+    process.exit(1);
+  }
+}