dhurandhar 1.0.0

package/tools/cli/commands/decisions.js

@@ -0,0 +1,398 @@
+/**
+ * Decisions Command - Technical Decision Registry Management
+ * "Stock of Decisions" - Bmad-Method inspired decision management
+ */
+
+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 decisionsCommand(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 (options.show) {
+      await showDecisions(sdmManager);
+    } else if (options.set) {
+      await setDecision(sdmManager, options.set);
+    } else if (options.stock) {
+      await stockAllDecisions(sdmManager);
+    } else {
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar decisions --show              Show all registered decisions');
+      console.log('  dhurandhar decisions --set <category>    Set decisions for category');
+      console.log('  dhurandhar decisions --stock             Stock all decisions (full setup)');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Decision operation failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function showDecisions(sdmManager) {
+  const sdm = await sdmManager.load();
+  const decisions = sdm.decision_registry || {};
+  
+  clack.intro(chalk.cyan.bold('📋 Technical Decision Registry'));
+  
+  console.log('');
+  
+  // Naming Conventions
+  if (decisions.naming_conventions) {
+    console.log(chalk.bold('Naming Conventions:'));
+    if (decisions.naming_conventions.case_styles) {
+      console.log('  Case Styles:');
+      Object.entries(decisions.naming_conventions.case_styles).forEach(([key, value]) => {
+        console.log(`    ${key}: ${chalk.cyan(value)}`);
+      });
+    }
+    if (decisions.naming_conventions.file_patterns) {
+      console.log('  File Patterns:');
+      Object.entries(decisions.naming_conventions.file_patterns).forEach(([key, value]) => {
+        console.log(`    ${key}: ${chalk.cyan(value)}`);
+      });
+    }
+    console.log('');
+  }
+  
+  // Design Patterns
+  if (decisions.design_patterns) {
+    console.log(chalk.bold('Design Patterns:'));
+    Object.entries(decisions.design_patterns).forEach(([key, value]) => {
+      if (key !== 'service_specific_patterns') {
+        console.log(`  ${key}: ${chalk.cyan(value)}`);
+      }
+    });
+    if (decisions.design_patterns.service_specific_patterns?.length > 0) {
+      console.log('  Service-Specific Patterns:');
+      decisions.design_patterns.service_specific_patterns.forEach(p => {
+        console.log(`    ${chalk.bold(p.service)}: ${chalk.cyan(p.pattern)}`);
+      });
+    }
+    console.log('');
+  }
+  
+  // Error Standards
+  if (decisions.error_response_standards) {
+    console.log(chalk.bold('Error Response Standards:'));
+    if (decisions.error_response_standards.error_code_mapping) {
+      console.log('  HTTP Status Mapping:');
+      Object.entries(decisions.error_response_standards.error_code_mapping).forEach(([key, value]) => {
+        console.log(`    ${key}: ${chalk.cyan(value)}`);
+      });
+    }
+    if (decisions.error_response_standards.response_envelope) {
+      console.log('  Response Envelope:');
+      console.log(`    Success: ${chalk.dim(decisions.error_response_standards.response_envelope.success_format)}`);
+      console.log(`    Error: ${chalk.dim(decisions.error_response_standards.response_envelope.error_format)}`);
+    }
+    console.log('');
+  }
+  
+  // Observability Standards
+  if (decisions.observability_standards) {
+    console.log(chalk.bold('Observability Standards:'));
+    if (decisions.observability_standards.logging) {
+      console.log('  Logging:');
+      console.log(`    Structured: ${decisions.observability_standards.logging.structured_logging ? chalk.green('yes') : chalk.dim('no')}`);
+      if (decisions.observability_standards.logging.mandatory_fields) {
+        console.log(`    Mandatory Fields: ${decisions.observability_standards.logging.mandatory_fields.join(', ')}`);
+      }
+    }
+    if (decisions.observability_standards.tracing) {
+      console.log('  Tracing:');
+      console.log(`    Trace ID Header: ${chalk.cyan(decisions.observability_standards.tracing.trace_id_header)}`);
+      console.log(`    Correlation ID Header: ${chalk.cyan(decisions.observability_standards.tracing.correlation_id_header)}`);
+    }
+    console.log('');
+  }
+  
+  clack.outro('');
+}
+
+async function setDecision(sdmManager, category) {
+  clack.intro(chalk.cyan.bold(`Set ${category} Decisions`));
+  
+  let decisions = {};
+  
+  switch (category) {
+    case 'naming':
+      decisions = await defineNamingConventions();
+      break;
+    case 'patterns':
+      decisions = await defineDesignPatterns();
+      break;
+    case 'errors':
+      decisions = await defineErrorStandards();
+      break;
+    case 'observability':
+      decisions = await defineObservabilityStandards();
+      break;
+    default:
+      clack.log.error(`Unknown category: ${category}`);
+      clack.log.info('Valid: naming, patterns, errors, observability');
+      process.exit(1);
+  }
+  
+  // Save decisions
+  const sdm = await sdmManager.load();
+  if (!sdm.decision_registry) {
+    sdm.decision_registry = {};
+  }
+  
+  const categoryKey = getCategoryKey(category);
+  sdm.decision_registry[categoryKey] = decisions;
+  
+  await sdmManager.save(sdm);
+  
+  clack.outro(chalk.green(`✓ ${category} decisions registered`));
+  
+  console.log('');
+  console.log(chalk.cyan('These decisions will be automatically applied to:'));
+  console.log('  - All new services');
+  console.log('  - All new entities');
+  console.log('  - All new stories');
+  console.log('');
+}
+
+async function stockAllDecisions(sdmManager) {
+  clack.intro(chalk.cyan.bold('📦 Stock All Technical Decisions'));
+  
+  console.log('');
+  console.log(chalk.dim('This will set up your complete technical decision registry.'));
+  console.log(chalk.dim('Answer once, apply everywhere.'));
+  console.log('');
+  
+  // Stock naming conventions
+  console.log(chalk.bold('1/4: Naming Conventions'));
+  const naming = await defineNamingConventions();
+  
+  console.log('');
+  console.log(chalk.bold('2/4: Design Patterns'));
+  const patterns = await defineDesignPatterns();
+  
+  console.log('');
+  console.log(chalk.bold('3/4: Error Standards'));
+  const errors = await defineErrorStandards();
+  
+  console.log('');
+  console.log(chalk.bold('4/4: Observability Standards'));
+  const observability = await defineObservabilityStandards();
+  
+  // Save all decisions
+  const sdm = await sdmManager.load();
+  sdm.decision_registry = {
+    naming_conventions: naming,
+    design_patterns: patterns,
+    error_response_standards: errors,
+    observability_standards: observability,
+  };
+  
+  await sdmManager.save(sdm);
+  
+  clack.outro(chalk.green('✓ All decisions stocked'));
+  
+  console.log('');
+  console.log(chalk.cyan('Decision registry complete. These standards will be:'));
+  console.log('  - Automatically applied to all new code');
+  console.log('  - Enforced by drift detection');
+  console.log('  - Used as constraints by implementation personas');
+  console.log('');
+}
+
+// Helper functions
+
+function getCategoryKey(category) {
+  const mapping = {
+    'naming': 'naming_conventions',
+    'patterns': 'design_patterns',
+    'errors': 'error_response_standards',
+    'observability': 'observability_standards',
+  };
+  return mapping[category] || category;
+}
+
+async function defineNamingConventions() {
+  const classes = await clack.select({
+    message: 'Class naming style:',
+    options: [
+      { value: 'PascalCase', label: 'PascalCase', hint: 'UserService, OrderController' },
+      { value: 'camelCase', label: 'camelCase', hint: 'userService, orderController' },
+      { value: 'snake_case', label: 'snake_case', hint: 'user_service, order_controller' },
+    ],
+  });
+
+  const functions = await clack.select({
+    message: 'Function naming style:',
+    options: [
+      { value: 'camelCase', label: 'camelCase', hint: 'getUserById, createOrder' },
+      { value: 'snake_case', label: 'snake_case', hint: 'get_user_by_id, create_order' },
+      { value: 'PascalCase', label: 'PascalCase', hint: 'GetUserById, CreateOrder' },
+    ],
+  });
+
+  const dbTables = await clack.select({
+    message: 'Database table naming:',
+    options: [
+      { value: 'snake_case', label: 'snake_case', hint: 'users, order_items' },
+      { value: 'PascalCase', label: 'PascalCase', hint: 'Users, OrderItems' },
+    ],
+  });
+
+  const apiEndpoints = await clack.select({
+    message: 'API endpoint naming:',
+    options: [
+      { value: 'kebab-case', label: 'kebab-case', hint: '/api/v1/user-profiles' },
+      { value: 'snake_case', label: 'snake_case', hint: '/api/v1/user_profiles' },
+      { value: 'camelCase', label: 'camelCase', hint: '/api/v1/userProfiles' },
+    ],
+  });
+
+  return {
+    case_styles: {
+      classes,
+      functions,
+      variables: functions, // Same as functions by default
+      constants: 'SCREAMING_SNAKE_CASE',
+      database_tables: dbTables,
+      database_columns: dbTables,
+      api_endpoints: apiEndpoints,
+    },
+    file_patterns: {
+      components: classes === 'PascalCase' ? 'ComponentName.tsx' : 'component-name.tsx',
+      services: classes === 'PascalCase' ? 'ServiceName.service.ts' : 'service-name.service.ts',
+      models: classes === 'PascalCase' ? 'ModelName.model.ts' : 'model-name.model.ts',
+      tests: 'filename.test.ts',
+    },
+  };
+}
+
+async function defineDesignPatterns() {
+  const dataAccess = await clack.select({
+    message: 'Data access pattern:',
+    options: [
+      { value: 'repository_pattern', label: 'Repository Pattern', hint: 'UserRepository abstraction' },
+      { value: 'active_record', label: 'Active Record', hint: 'Models with DB methods' },
+      { value: 'data_mapper', label: 'Data Mapper', hint: 'Separate mapper layer' },
+    ],
+  });
+
+  const di = await clack.select({
+    message: 'Dependency injection:',
+    options: [
+      { value: 'constructor_injection', label: 'Constructor Injection', hint: 'Dependencies in constructor' },
+      { value: 'property_injection', label: 'Property Injection', hint: 'Set after instantiation' },
+      { value: 'none', label: 'None', hint: 'Direct imports/requires' },
+    ],
+  });
+
+  const validation = await clack.select({
+    message: 'Validation strategy:',
+    options: [
+      { value: 'dto_validation', label: 'DTO Validation', hint: 'Validate at DTO layer' },
+      { value: 'middleware_validation', label: 'Middleware Validation', hint: 'Validate in middleware' },
+      { value: 'domain_validation', label: 'Domain Validation', hint: 'Validate in domain layer' },
+    ],
+  });
+
+  return {
+    data_access: dataAccess,
+    service_layer: 'service_classes',
+    dependency_injection: di,
+    validation,
+    cqrs: false,
+    event_sourcing: false,
+    domain_driven_design: false,
+  };
+}
+
+async function defineErrorStandards() {
+  const envelopeChoice = await clack.select({
+    message: 'Error response format:',
+    options: [
+      { value: 'standard', label: 'Standard Envelope', hint: '{"error": {"code": "", "message": ""}, "meta": {}}' },
+      { value: 'simple', label: 'Simple', hint: '{"error": "message"}' },
+    ],
+  });
+
+  const includeRequestId = await clack.confirm({
+    message: 'Include request_id in all responses?',
+    initialValue: true,
+  });
+
+  const includeTimestamp = await clack.confirm({
+    message: 'Include timestamp in all responses?',
+    initialValue: true,
+  });
+
+  let successFormat, errorFormat;
+  if (envelopeChoice === 'standard') {
+    successFormat = '{"data": {}, "meta": {"request_id": "", "timestamp": ""}}';
+    errorFormat = '{"error": {"code": "", "message": "", "details": []}, "meta": {"request_id": "", "timestamp": ""}}';
+  } else {
+    successFormat = '{"data": {}}';
+    errorFormat = '{"error": "message"}';
+  }
+
+  return {
+    error_code_mapping: {
+      validation_error: 400,
+      authentication_error: 401,
+      authorization_error: 403,
+      not_found_error: 404,
+      conflict_error: 409,
+      internal_error: 500,
+    },
+    response_envelope: {
+      success_format: successFormat,
+      error_format: errorFormat,
+      include_request_id: includeRequestId,
+      include_timestamp: includeTimestamp,
+    },
+    error_detail_level: 'standard',
+  };
+}
+
+async function defineObservabilityStandards() {
+  const structuredLogging = await clack.confirm({
+    message: 'Use structured JSON logging?',
+    initialValue: true,
+  });
+
+  const traceIdHeader = await clack.text({
+    message: 'Trace ID header name:',
+    initialValue: 'X-Trace-ID',
+  });
+
+  const correlationIdHeader = await clack.text({
+    message: 'Correlation ID header name:',
+    initialValue: 'X-Correlation-ID',
+  });
+
+  return {
+    logging: {
+      levels: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
+      structured_logging: structuredLogging,
+      mandatory_fields: ['trace_id', 'correlation_id', 'service_name', 'timestamp', 'level'],
+      sensitive_data_masking: true,
+    },
+    tracing: {
+      trace_id_header: traceIdHeader,
+      correlation_id_header: correlationIdHeader,
+      span_naming_format: 'service.operation',
+    },
+    metrics: {
+      naming_format: 'service_name_metric_name_unit',
+      mandatory_labels: ['service', 'environment', 'version'],
+    },
+  };
+}

package/tools/cli/commands/entity.js

@@ -0,0 +1,218 @@
+/**
+ * Entity Command - Direct-Action Entity Management
+ * Define database entities and relationships without ceremony
+ */
+
+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 entityCommand(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 (options.list) {
+      // List entities
+      const sdm = await sdmManager.load();
+      
+      clack.intro(chalk.cyan.bold(`Entities (${sdm.entities.length})`));
+      
+      if (sdm.entities.length === 0) {
+        console.log(chalk.dim('  No entities defined yet.'));
+        console.log('');
+        console.log(chalk.cyan('Add one:'));
+        console.log('  dhurandhar entity add User');
+      } else {
+        console.log('');
+        sdm.entities.forEach(e => {
+          console.log(chalk.bold(`${e.name}`));
+          console.log(`  Attributes (${e.attributes.length}):`);
+          e.attributes.forEach(attr => {
+            const constraints = attr.constraints ? ` [${attr.constraints.join(', ')}]` : '';
+            console.log(`    ${chalk.cyan(attr.name)}: ${attr.type}${constraints}`);
+          });
+          if (e.relationships && e.relationships.length > 0) {
+            console.log(`  Relationships (${e.relationships.length}):`);
+            e.relationships.forEach(rel => {
+              console.log(`    ${rel.type} → ${chalk.cyan(rel.target)}`);
+            });
+          }
+          console.log('');
+        });
+      }
+      
+      clack.outro('');
+      
+    } else if (options.add) {
+      // Add entity - DIRECT ACTION
+      clack.intro(chalk.cyan.bold('Add Entity'));
+      
+      const entityName = typeof options.add === 'string' ? options.add : null;
+      
+      let name = entityName;
+      
+      // Question 1: Entity name
+      if (!name) {
+        name = await clack.text({
+          message: 'Entity name (PascalCase):',
+          placeholder: 'User',
+          validate: (v) => !v ? 'Required' : !/^[A-Z][a-zA-Z0-9]*$/.test(v) ? 'Use PascalCase' : undefined,
+        });
+        
+        if (clack.isCancel(name)) {
+          clack.cancel('Cancelled.');
+          process.exit(0);
+        }
+      }
+      
+      // Auto-generate common attributes
+      const commonAttributes = [
+        { name: 'id', type: 'uuid', constraints: ['primary_key', 'not_null'] },
+        { name: 'created_at', type: 'timestamp', constraints: ['not_null'] },
+        { name: 'updated_at', type: 'timestamp', constraints: ['not_null'] },
+      ];
+      
+      // Ask for custom attributes
+      const addCustom = await clack.confirm({
+        message: 'Add custom attributes now? (or edit YAML later)',
+        initialValue: false,
+      });
+      
+      const customAttributes = [];
+      
+      if (!clack.isCancel(addCustom) && addCustom) {
+        let addMore = true;
+        while (addMore) {
+          const attrName = await clack.text({
+            message: 'Attribute name:',
+            placeholder: 'email',
+          });
+          
+          if (clack.isCancel(attrName)) break;
+          
+          const attrType = await clack.select({
+            message: `Type for ${attrName}:`,
+            options: [
+              { value: 'varchar', label: 'varchar (string)' },
+              { value: 'int', label: 'int' },
+              { value: 'uuid', label: 'uuid' },
+              { value: 'boolean', label: 'boolean' },
+              { value: 'timestamp', label: 'timestamp' },
+              { value: 'text', label: 'text (long string)' },
+              { value: 'jsonb', label: 'jsonb (JSON)' },
+            ],
+          });
+          
+          if (clack.isCancel(attrType)) break;
+          
+          customAttributes.push({
+            name: attrName,
+            type: attrType,
+            constraints: ['not_null'],
+          });
+          
+          addMore = await clack.confirm({
+            message: 'Add another attribute?',
+            initialValue: false,
+          });
+          
+          if (clack.isCancel(addMore)) break;
+        }
+      }
+      
+      // Build entity
+      const entity = {
+        name,
+        table_name: name.replace(/([A-Z])/g, '_$1').toLowerCase().substring(1),
+        attributes: [...commonAttributes, ...customAttributes],
+        relationships: [],
+      };
+      
+      // Add to SDM
+      await sdmManager.addEntity(entity);
+      
+      clack.outro(chalk.green(`✓ Entity "${name}" added to data model`));
+      
+      console.log('');
+      console.log(chalk.cyan('Updated SYSTEM_DESIGN_MAP.yaml'));
+      console.log(chalk.dim('Add relationships with: dhurandhar entity relate'));
+      console.log('');
+      
+    } else if (options.relate) {
+      // Add relationship between entities
+      const sdm = await sdmManager.load();
+      
+      if (sdm.entities.length < 2) {
+        clack.log.error('Need at least 2 entities to create relationships.');
+        process.exit(1);
+      }
+      
+      clack.intro(chalk.cyan.bold('Add Relationship'));
+      
+      const entityOptions = sdm.entities.map(e => ({ value: e.name, label: e.name }));
+      
+      const from = await clack.select({
+        message: 'From entity:',
+        options: entityOptions,
+      });
+      
+      if (clack.isCancel(from)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+      
+      const to = await clack.select({
+        message: 'To entity:',
+        options: entityOptions.filter(e => e.value !== from),
+      });
+      
+      if (clack.isCancel(to)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+      
+      const relType = await clack.select({
+        message: 'Relationship type:',
+        options: [
+          { value: 'one_to_many', label: 'One-to-Many', hint: `One ${from} has many ${to}` },
+          { value: 'many_to_one', label: 'Many-to-One', hint: `Many ${from} belong to one ${to}` },
+          { value: 'one_to_one', label: 'One-to-One' },
+          { value: 'many_to_many', label: 'Many-to-Many', hint: 'Requires junction table' },
+        ],
+      });
+      
+      // Update entity with relationship
+      const fromEntity = sdm.entities.find(e => e.name === from);
+      if (!fromEntity.relationships) fromEntity.relationships = [];
+      
+      fromEntity.relationships.push({
+        type: relType,
+        target: to,
+        foreign_key: `${to.toLowerCase()}_id`,
+      });
+      
+      await sdmManager.save(sdm);
+      
+      clack.outro(chalk.green(`✓ Relationship added: ${from} → ${to}`));
+      
+    } else {
+      // Show help
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar entity --list           List all entities');
+      console.log('  dhurandhar entity --add User       Add entity');
+      console.log('  dhurandhar entity --relate         Add relationship');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Entity operation failed:'), error.message);
+    process.exit(1);
+  }
+}