dhurandhar 1.0.0

package/tools/cli/commands/story.js

@@ -0,0 +1,225 @@
+/**
+ * Story Command - User Journey Definition
+ * Defines Stories with API interaction boundaries (contract-first)
+ */
+
+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';
+
+export async function storyCommand(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) {
+      await listStories(sdmManager);
+    } else if (options.add) {
+      await addStory(sdmManager, options.add, options.epic);
+    } else {
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar story --list                     List all stories');
+      console.log('  dhurandhar story --add "Story" --epic ID    Add story to epic');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Story operation failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function listStories(sdmManager) {
+  const sdm = await sdmManager.load();
+  
+  if (!sdm.agile_blueprint || !sdm.agile_blueprint.epics) {
+    console.log(chalk.dim('  No stories defined yet.'));
+    return;
+  }
+  
+  let totalStories = 0;
+  
+  clack.intro(chalk.cyan.bold('Stories'));
+  
+  console.log('');
+  sdm.agile_blueprint.epics.forEach(epic => {
+    if (!epic.stories || epic.stories.length === 0) return;
+    
+    console.log(chalk.bold(`${epic.id}: ${epic.name}`));
+    epic.stories.forEach(story => {
+      totalStories++;
+      const taskCount = story.tasks?.length || 0;
+      const completeTasks = story.tasks?.filter(t => t.status === 'complete').length || 0;
+      console.log(`  ${story.id}: ${story.name}`);
+      console.log(`    Endpoint: ${chalk.cyan(story.interaction_boundary?.method)} ${story.interaction_boundary?.api_endpoint}`);
+      console.log(`    Tasks: ${completeTasks}/${taskCount} complete`);
+    });
+    console.log('');
+  });
+  
+  clack.outro(`Total: ${totalStories} stories`);
+}
+
+async function addStory(sdmManager, storyName, epicId) {
+  clack.intro(chalk.cyan.bold('Add Story - Test Architect Mode'));
+  
+  const sdm = await sdmManager.load();
+  
+  if (!sdm.agile_blueprint || !sdm.agile_blueprint.epics || sdm.agile_blueprint.epics.length === 0) {
+    clack.log.error('No epics found. Add an epic first:');
+    clack.log.info('dhurandhar epic add "Epic Name"');
+    process.exit(1);
+  }
+  
+  // Select Epic
+  let selectedEpic;
+  if (epicId) {
+    selectedEpic = sdm.agile_blueprint.epics.find(e => e.id === epicId);
+    if (!selectedEpic) {
+      clack.log.error(`Epic ${epicId} not found`);
+      process.exit(1);
+    }
+  } else {
+    const epicChoice = await clack.select({
+      message: 'Which epic?',
+      options: sdm.agile_blueprint.epics.map(e => ({
+        value: e.id,
+        label: `${e.id}: ${e.name}`,
+      })),
+    });
+    
+    if (clack.isCancel(epicChoice)) {
+      clack.cancel('Cancelled.');
+      process.exit(0);
+    }
+    
+    selectedEpic = sdm.agile_blueprint.epics.find(e => e.id === epicChoice);
+  }
+  
+  // Story name
+  let name = typeof storyName === 'string' ? storyName : null;
+  
+  if (!name) {
+    name = await clack.text({
+      message: 'Story name (user journey):',
+      placeholder: 'OAuth2 Social Login Flow',
+      validate: (v) => !v ? 'Required' : undefined,
+    });
+    
+    if (clack.isCancel(name)) {
+      clack.cancel('Cancelled.');
+      process.exit(0);
+    }
+  }
+  
+  // Technical questions (max 3) - Test Architect persona
+  console.log('');
+  console.log(chalk.dim('Technical specification (max 3 questions):'));
+  
+  // Q1: Which service?
+  const service = await clack.select({
+    message: '1. Target service:',
+    options: sdm.services?.map(s => ({ value: s.name, label: s.name })) || 
+      [{ value: 'new-service', label: '(Create new service)' }],
+  });
+  
+  if (clack.isCancel(service)) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  // Q2: API endpoint
+  const endpoint = await clack.text({
+    message: '2. API endpoint:',
+    placeholder: '/api/v1/auth/oauth/callback',
+    validate: (v) => !v || !v.startsWith('/') ? 'Must start with /' : undefined,
+  });
+  
+  if (clack.isCancel(endpoint)) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  // Q3: HTTP method
+  const method = await clack.select({
+    message: '3. HTTP method:',
+    options: [
+      { value: 'GET', label: 'GET' },
+      { value: 'POST', label: 'POST' },
+      { value: 'PUT', label: 'PUT' },
+      { value: 'DELETE', label: 'DELETE' },
+    ],
+  });
+  
+  if (clack.isCancel(method)) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  // Generate Story ID
+  const storyId = `STORY-${String(
+    sdm.agile_blueprint.epics.reduce((acc, e) => acc + (e.stories?.length || 0), 0) + 1
+  ).padStart(3, '0')}`;
+  
+  // Create Story with interaction boundary
+  const story = {
+    id: storyId,
+    name,
+    interaction_boundary: {
+      service,
+      api_endpoint: endpoint,
+      method,
+      request_contract: {},  // To be filled by developer
+      response_contract: {}, // To be filled by developer
+      error_states: [400, 401, 404, 500], // Default errors
+    },
+    technical_acceptance: [
+      `Returns 200 on successful ${method} request`,
+      `Returns appropriate error codes (400, 401, 404, 500)`,
+    ],
+    tasks: [
+      {
+        id: `TASK-${storyId.split('-')[1]}-001`,
+        description: `Write contract tests for ${name}`,
+        type: 'test',
+        status: 'not_started',
+        test_coverage: {
+          test_file: `tests/contracts/${storyId.toLowerCase()}-standard.test.js`,
+          standard_flows: false,
+          error_states: false,
+          edge_cases: false,
+        },
+      },
+      {
+        id: `TASK-${storyId.split('-')[1]}-002`,
+        description: `Implement ${method} ${endpoint}`,
+        type: 'implementation',
+        linked_to: {
+          type: 'service',
+          name: service,
+        },
+        status: 'not_started',
+      },
+    ],
+  };
+  
+  // Add Story to Epic
+  if (!selectedEpic.stories) selectedEpic.stories = [];
+  selectedEpic.stories.push(story);
+  
+  await sdmManager.save(sdm);
+  
+  clack.outro(chalk.green(`✓ Story ${storyId} added with 2 tasks`));
+  
+  console.log('');
+  console.log(chalk.cyan('Next: Generate contract tests'));
+  console.log('  dhurandhar test --generate');
+  console.log('');
+}

package/tools/cli/commands/strategy.js

@@ -0,0 +1,294 @@
+/**
+ * Strategy Command - Direct-Action Architectural Strategy Management
+ * Pluggable patterns: Persistence, State, Communication, Security, Resilience
+ */
+
+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 strategyCommand(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 showStrategies(sdmManager);
+    } else if (options.set) {
+      await setStrategy(sdmManager, options.set);
+    } else if (options.pivot) {
+      await pivotStrategy(sdmManager, options.pivot);
+    } else if (options.align) {
+      await alignServices(sdmManager);
+    } else {
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar strategy --show                Show active strategies');
+      console.log('  dhurandhar strategy --set <category>      Set architectural strategy');
+      console.log('  dhurandhar strategy --pivot <category>    Pivot existing strategy');
+      console.log('  dhurandhar strategy --align               Align all services to strategies');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Strategy operation failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function showStrategies(sdmManager) {
+  const strategies = await sdmManager.getStrategies();
+  
+  clack.intro(chalk.cyan.bold('📐 Active Architectural Strategies'));
+  
+  console.log('');
+  
+  // Persistence
+  if (strategies.persistence?.model) {
+    console.log(chalk.bold('Persistence Strategy:'));
+    console.log(`  Model: ${chalk.cyan(strategies.persistence.model)}`);
+    if (strategies.persistence.constraints?.length > 0) {
+      console.log(`  Constraints: ${strategies.persistence.constraints.join(', ')}`);
+    }
+    console.log('');
+  }
+  
+  // State Management
+  if (strategies.state_management?.caching_layer) {
+    console.log(chalk.bold('State Management:'));
+    console.log(`  Caching: ${chalk.cyan(strategies.state_management.caching_layer)}`);
+    console.log(`  Sessions: ${chalk.cyan(strategies.state_management.session_storage || 'not set')}`);
+    console.log('');
+  }
+  
+  // Communication
+  if (strategies.communication?.primary_pattern) {
+    console.log(chalk.bold('Communication Pattern:'));
+    console.log(`  Primary: ${chalk.cyan(strategies.communication.primary_pattern)}`);
+    if (strategies.communication.event_bus) {
+      console.log(`  Event Bus: ${chalk.cyan(strategies.communication.event_bus.technology)}`);
+    }
+    console.log('');
+  }
+  
+  // Security
+  if (strategies.security?.authentication) {
+    console.log(chalk.bold('Security:'));
+    console.log(`  Authentication: ${chalk.cyan(strategies.security.authentication)}`);
+    console.log(`  Authorization: ${chalk.cyan(strategies.security.authorization || 'not set')}`);
+    console.log('');
+  }
+  
+  // Resilience
+  if (strategies.resilience?.circuit_breaker !== undefined) {
+    console.log(chalk.bold('Resilience:'));
+    console.log(`  Circuit Breaker: ${strategies.resilience.circuit_breaker ? chalk.green('enabled') : chalk.dim('disabled')}`);
+    if (strategies.resilience.retry_strategy) {
+      console.log(`  Retry: ${chalk.cyan(strategies.resilience.retry_strategy)}`);
+    }
+    console.log('');
+  }
+  
+  clack.outro('');
+}
+
+async function setStrategy(sdmManager, category) {
+  clack.intro(chalk.cyan.bold(`Set ${category} Strategy`));
+  
+  let strategy = {};
+  
+  switch (category) {
+    case 'persistence':
+      strategy = await definePersistenceStrategy();
+      break;
+    case 'communication':
+      strategy = await defineCommunicationStrategy();
+      break;
+    case 'state':
+      strategy = await defineStateStrategy();
+      break;
+    case 'security':
+      strategy = await defineSecurityStrategy();
+      break;
+    case 'resilience':
+      strategy = await defineResilienceStrategy();
+      break;
+    default:
+      clack.log.error(`Unknown category: ${category}`);
+      clack.log.info('Valid: persistence, communication, state, security, resilience');
+      process.exit(1);
+  }
+  
+  // Save strategy
+  const categoryKey = category === 'state' ? 'state_management' : category;
+  await sdmManager.setStrategy(categoryKey, strategy);
+  
+  // Check alignment
+  const misaligned = await sdmManager.checkStrategyAlignment(strategy, categoryKey);
+  
+  clack.outro(chalk.green(`✓ ${category} strategy set`));
+  
+  if (misaligned.length > 0) {
+    console.log('');
+    console.log(chalk.yellow(`⚠ ${misaligned.length} services need alignment:`));
+    misaligned.forEach(m => {
+      console.log(`  ${chalk.bold(m.service)}: ${m.issues.join(', ')}`);
+    });
+    console.log('');
+    console.log(chalk.cyan('Run to auto-align:'));
+    console.log('  dhurandhar strategy --align');
+    console.log('');
+  }
+}
+
+async function pivotStrategy(sdmManager, category) {
+  clack.intro(chalk.cyan.bold(`⚡ Pivot ${category} Strategy`));
+  
+  const currentStrategies = await sdmManager.getStrategies();
+  const categoryKey = category === 'state' ? 'state_management' : category;
+  const current = currentStrategies[categoryKey];
+  
+  console.log('');
+  console.log(chalk.dim('Current strategy:'));
+  console.log(JSON.stringify(current, null, 2));
+  console.log('');
+  
+  const confirm = await clack.confirm({
+    message: 'This will update all services. Continue?',
+    initialValue: false,
+  });
+  
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  // Set new strategy
+  await setStrategy(sdmManager, category);
+}
+
+async function alignServices(sdmManager) {
+  clack.intro(chalk.cyan.bold('🔄 Align Services to Strategies'));
+  
+  const spinner = clack.spinner();
+  spinner.start('Realigning services...');
+  
+  await sdmManager.realignServicesToStrategy();
+  
+  spinner.stop('Services aligned');
+  
+  clack.outro(chalk.green('✓ All services now match active strategies'));
+  
+  console.log('');
+  console.log(chalk.cyan('Check results:'));
+  console.log('  dhurandhar service --list');
+  console.log('');
+}
+
+// Strategy Definition Helpers
+
+async function definePersistenceStrategy() {
+  const model = await clack.select({
+    message: 'Persistence model:',
+    options: [
+      { value: 'database_per_service', label: 'Database-per-Service', hint: 'Full isolation, eventual consistency' },
+      { value: 'shared_database', label: 'Shared Database', hint: 'Monolith pattern, ACID transactions' },
+      { value: 'hybrid', label: 'Hybrid', hint: 'Mix of both' },
+      { value: 'event_sourcing', label: 'Event Sourcing', hint: 'Event log as source of truth' },
+    ],
+  });
+  
+  if (clack.isCancel(model)) process.exit(0);
+  
+  const constraints = model === 'database_per_service' 
+    ? ['no_cross_service_queries', 'eventual_consistency']
+    : [];
+  
+  return { model, constraints };
+}
+
+async function defineCommunicationStrategy() {
+  const pattern = await clack.select({
+    message: 'Primary communication pattern:',
+    options: [
+      { value: 'synchronous_rest', label: 'Synchronous REST', hint: 'Request/response, immediate' },
+      { value: 'asynchronous_events', label: 'Asynchronous Events', hint: 'Event-driven, decoupled' },
+      { value: 'hybrid', label: 'Hybrid', hint: 'Both REST and events' },
+      { value: 'grpc_streaming', label: 'gRPC Streaming', hint: 'High performance, bidirectional' },
+    ],
+  });
+  
+  if (clack.isCancel(pattern)) process.exit(0);
+  
+  let eventBus = null;
+  
+  if (pattern === 'asynchronous_events' || pattern === 'hybrid') {
+    const technology = await clack.select({
+      message: 'Event bus technology:',
+      options: [
+        { value: 'kafka', label: 'Apache Kafka' },
+        { value: 'rabbitmq', label: 'RabbitMQ' },
+        { value: 'aws_sns_sqs', label: 'AWS SNS/SQS' },
+        { value: 'redis_streams', label: 'Redis Streams' },
+      ],
+    });
+    
+    if (!clack.isCancel(technology)) {
+      eventBus = { technology, message_format: 'json' };
+    }
+  }
+  
+  return { primary_pattern: pattern, event_bus: eventBus };
+}
+
+async function defineStateStrategy() {
+  const caching = await clack.select({
+    message: 'Caching layer:',
+    options: [
+      { value: 'distributed_redis', label: 'Distributed Redis', hint: 'Shared cache across services' },
+      { value: 'local_in_memory', label: 'Local In-Memory', hint: 'Per-service cache' },
+      { value: 'sidecar_cache', label: 'Sidecar Cache', hint: 'Service mesh pattern' },
+      { value: 'none', label: 'None', hint: 'No caching' },
+    ],
+  });
+  
+  if (clack.isCancel(caching)) process.exit(0);
+  
+  return { caching_layer: caching, cache_invalidation: 'ttl_based' };
+}
+
+async function defineSecurityStrategy() {
+  const auth = await clack.select({
+    message: 'Authentication strategy:',
+    options: [
+      { value: 'jwt_centralized', label: 'JWT Centralized', hint: 'Auth service validates all tokens' },
+      { value: 'oauth2_delegated', label: 'OAuth2 Delegated', hint: 'External OAuth provider' },
+      { value: 'mtls', label: 'mTLS', hint: 'Certificate-based, service-to-service' },
+      { value: 'api_keys', label: 'API Keys', hint: 'Simple key-based auth' },
+    ],
+  });
+  
+  if (clack.isCancel(auth)) process.exit(0);
+  
+  return { authentication: auth, authorization: 'rbac' };
+}
+
+async function defineResilienceStrategy() {
+  const circuitBreaker = await clack.confirm({
+    message: 'Enable circuit breaker pattern?',
+    initialValue: true,
+  });
+  
+  if (clack.isCancel(circuitBreaker)) process.exit(0);
+  
+  return { 
+    circuit_breaker: circuitBreaker,
+    retry_strategy: 'exponential_backoff',
+    timeout_policy: 'moderate_30s',
+  };
+}