dhurandhar 1.0.0

package/tools/cli/commands/epic.js

@@ -0,0 +1,125 @@
+/**
+ * Epic Command - Agile Blueprint Management
+ * Manage Epics (high-level system capabilities)
+ */
+
+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 epicCommand(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 listEpics(sdmManager);
+    } else if (options.add) {
+      await addEpic(sdmManager, options.add);
+    } else {
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar epic --list                  List all epics');
+      console.log('  dhurandhar epic --add "Epic Name"       Add epic');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Epic operation failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function listEpics(sdmManager) {
+  const sdm = await sdmManager.load();
+  
+  if (!sdm.agile_blueprint || !sdm.agile_blueprint.epics || sdm.agile_blueprint.epics.length === 0) {
+    console.log(chalk.dim('  No epics defined yet.'));
+    console.log('');
+    console.log(chalk.cyan('Add one:'));
+    console.log('  dhurandhar epic add "User Authentication & Authorization"');
+    return;
+  }
+  
+  clack.intro(chalk.cyan.bold(`Epics (${sdm.agile_blueprint.epics.length})`));
+  
+  console.log('');
+  sdm.agile_blueprint.epics.forEach(epic => {
+    const storyCount = epic.stories?.length || 0;
+    console.log(chalk.bold(`${epic.id}: ${epic.name}`));
+    console.log(`  Stories: ${storyCount}`);
+    if (epic.description) {
+      console.log(`  ${chalk.dim(epic.description)}`);
+    }
+    console.log('');
+  });
+  
+  clack.outro('');
+}
+
+async function addEpic(sdmManager, epicName) {
+  clack.intro(chalk.cyan.bold('Add Epic'));
+  
+  const name = typeof epicName === 'string' ? epicName : null;
+  
+  let epicTitle = name;
+  
+  if (!epicTitle) {
+    epicTitle = await clack.text({
+      message: 'Epic name (system capability):',
+      placeholder: 'User Authentication & Authorization',
+      validate: (v) => !v ? 'Required' : undefined,
+    });
+    
+    if (clack.isCancel(epicTitle)) {
+      clack.cancel('Cancelled.');
+      process.exit(0);
+    }
+  }
+  
+  // Technical description
+  const description = await clack.text({
+    message: 'Technical description (optional):',
+    placeholder: 'JWT-based auth with OAuth2 social login',
+  });
+  
+  if (clack.isCancel(description)) {
+    clack.cancel('Cancelled.');
+    process.exit(0);
+  }
+  
+  // Generate Epic ID
+  const sdm = await sdmManager.load();
+  if (!sdm.agile_blueprint) {
+    sdm.agile_blueprint = { epics: [], test_suite_status: {} };
+  }
+  if (!sdm.agile_blueprint.epics) {
+    sdm.agile_blueprint.epics = [];
+  }
+  
+  const epicId = `EPIC-${String(sdm.agile_blueprint.epics.length + 1).padStart(3, '0')}`;
+  
+  // Create Epic
+  const epic = {
+    id: epicId,
+    name: epicTitle,
+    description: description || undefined,
+    acceptance_criteria: [],
+    stories: [],
+  };
+  
+  sdm.agile_blueprint.epics.push(epic);
+  await sdmManager.save(sdm);
+  
+  clack.outro(chalk.green(`✓ Epic ${epicId} added`));
+  
+  console.log('');
+  console.log(chalk.cyan('Next: Add Stories'));
+  console.log(`  dhurandhar story add --epic ${epicId}`);
+  console.log('');
+}

package/tools/cli/commands/install.js

@@ -0,0 +1,172 @@
+/**
+ * Install Command - Engineering-First Installation
+ * Direct action model: 3 technical questions max, no justification loops
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { ConfigManager } from '../../lib/config-manager.js';
+import { ModuleInstaller } from '../../lib/module-installer.js';
+import { FileSystem } from '../../lib/filesystem.js';
+import { SDMManager } from '../../lib/sdm-manager.js';
+
+export async function installCommand(options) {
+  console.clear();
+
+  clack.intro(chalk.cyan.bold('🔧 Dhurandhar - Engineering-First System Design'));
+
+  try {
+    const targetDir = options.directory || process.cwd();
+
+    // Check if already installed
+    const configPath = join(targetDir, '.dhurandhar', 'config.yaml');
+    if (existsSync(configPath) && !options.yes) {
+      const shouldReinstall = await clack.confirm({
+        message: 'Framework already installed. Reinstall?',
+        initialValue: false,
+      });
+
+      if (clack.isCancel(shouldReinstall) || !shouldReinstall) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+    }
+
+    // ENGINEERING-FIRST: Only 3 technical questions
+    let config = {};
+    let techConfig = {};
+
+    if (!options.yes) {
+      // Question 1: Project identifier
+      const projectName = await clack.text({
+        message: 'Project identifier (kebab-case):',
+        placeholder: 'my-system',
+        validate: (value) => {
+          if (!value) return 'Required';
+          if (!/^[a-z0-9-]+$/.test(value)) {
+            return 'Must be lowercase, alphanumeric, hyphens only';
+          }
+        },
+      });
+
+      if (clack.isCancel(projectName)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+
+      // Question 2: Architecture type (technical decision)
+      const architectureType = await clack.select({
+        message: 'Architecture type:',
+        options: [
+          { value: 'microservices', label: 'Microservices', hint: 'Multiple services, independent deployment' },
+          { value: 'monolith', label: 'Monolith', hint: 'Single deployable unit' },
+          { value: 'serverless', label: 'Serverless', hint: 'FaaS, event-driven' },
+          { value: 'hybrid', label: 'Hybrid', hint: 'Mix of patterns' },
+        ],
+        initialValue: 'microservices',
+      });
+
+      if (clack.isCancel(architectureType)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+
+      // Question 3: Primary tech stack
+      const primaryLanguage = await clack.select({
+        message: 'Primary language:',
+        options: [
+          { value: 'go', label: 'Go', hint: 'Performance, concurrency' },
+          { value: 'typescript', label: 'TypeScript', hint: 'Type-safe JavaScript' },
+          { value: 'python', label: 'Python', hint: 'Rapid development, ML/AI' },
+          { value: 'rust', label: 'Rust', hint: 'Systems programming, safety' },
+          { value: 'java', label: 'Java', hint: 'Enterprise, JVM ecosystem' },
+        ],
+        initialValue: 'go',
+      });
+
+      if (clack.isCancel(primaryLanguage)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+
+      config = {
+        projectName,
+        userName: 'Engineer', // Default, not critical
+        outputFolder: '_dhurandhar-output',
+      };
+
+      techConfig = {
+        architectureType,
+        primaryLanguage,
+      };
+    } else {
+      config = {
+        projectName: 'dhurandhar-project',
+        userName: 'Engineer',
+        outputFolder: '_dhurandhar-output',
+      };
+      techConfig = {
+        architectureType: 'microservices',
+        primaryLanguage: 'go',
+      };
+    }
+    
+    // Auto-install core only (no module selection prompts)
+    const selectedModules = options.modules || ['core'];
+
+    // Perform installation
+    const spinner = clack.spinner();
+
+    spinner.start('Installing framework...');
+
+    // Create directory structure
+    await FileSystem.ensureDirectories(targetDir);
+
+    // Initialize configuration
+    const configManager = new ConfigManager(targetDir);
+    await configManager.initialize(config);
+
+    spinner.message('Initializing System Design Map...');
+
+    // Initialize SDM (System Design Map) for persistent state
+    const sdmManager = new SDMManager(targetDir);
+    await sdmManager.initialize(config.projectName);
+
+    // Update SDM with architecture type
+    const sdm = await sdmManager.load();
+    sdm.metadata.architecture_type = techConfig.architectureType;
+    sdm.tech_stack.languages = [techConfig.primaryLanguage];
+    await sdmManager.save(sdm);
+
+    spinner.message('Installing core module...');
+
+    // Install modules
+    const installer = new ModuleInstaller(targetDir);
+    await installer.installModules(selectedModules);
+
+    spinner.stop('Framework installed!');
+
+    clack.outro(chalk.green('✓ Ready for engineering'));
+
+    // Show next steps - ENGINEERING-FOCUSED
+    console.log('');
+    console.log(chalk.cyan('System initialized:'));
+    console.log(`  ${chalk.bold('SYSTEM_DESIGN_MAP.yaml')} - Persistent architecture state`);
+    console.log(`  ${chalk.dim('.dhurandhar/config.yaml')} - Framework configuration`);
+    console.log('');
+    console.log(chalk.cyan('Add your first service:'));
+    console.log(`  ${chalk.bold('dhurandhar service add "auth-service: JWT auth using ' + techConfig.primaryLanguage + '"')}`);
+    console.log('');
+    console.log(chalk.cyan('Or add an entity:'));
+    console.log(`  ${chalk.bold('dhurandhar entity add User')}`);
+    console.log('');
+    console.log(chalk.dim('The SDM persists context across sessions - no rediscovery needed.'));
+    console.log('');
+
+  } catch (error) {
+    clack.log.error(chalk.red('Installation failed:'), error.message);
+    process.exit(1);
+  }
+}

package/tools/cli/commands/module.js

@@ -0,0 +1,109 @@
+/**
+ * Module Command
+ * Manages framework modules
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { ModuleManager } from '../../lib/module-manager.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+
+export async function moduleCommand(options) {
+  try {
+    const moduleManager = new ModuleManager(process.cwd());
+    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.list) {
+      // List available modules
+      clack.intro(chalk.cyan.bold('Available Modules'));
+      
+      const modules = await moduleManager.listAvailable();
+      const installed = await moduleManager.listInstalled();
+      
+      console.log('');
+      modules.forEach(module => {
+        const isInstalled = installed.includes(module.code);
+        const status = isInstalled ? chalk.green('✓ installed') : chalk.dim('not installed');
+        console.log(`  ${chalk.bold(module.code)} - ${module.name}`);
+        console.log(`    ${status}`);
+        console.log(`    ${chalk.dim(module.description)}`);
+        console.log('');
+      });
+      
+      clack.outro(chalk.dim(`Total: ${modules.length} modules available`));
+      
+    } else if (options.info) {
+      // Show module information
+      const moduleInfo = await moduleManager.getInfo(options.info);
+      
+      if (!moduleInfo) {
+        clack.log.error(chalk.red(`Module "${options.info}" not found.`));
+        process.exit(1);
+      }
+      
+      clack.intro(chalk.cyan.bold(`Module: ${moduleInfo.name}`));
+      
+      console.log('');
+      console.log(chalk.bold('Details:'));
+      console.log(`  Code: ${chalk.cyan(moduleInfo.code)}`);
+      console.log(`  Name: ${chalk.cyan(moduleInfo.name)}`);
+      console.log(`  Version: ${chalk.cyan(moduleInfo.version || '1.0.0')}`);
+      console.log(`  Description: ${moduleInfo.description}`);
+      console.log('');
+      
+      if (moduleInfo.dependencies && moduleInfo.dependencies.length > 0) {
+        console.log(chalk.bold('Dependencies:'));
+        moduleInfo.dependencies.forEach(dep => {
+          console.log(`  - ${dep}`);
+        });
+        console.log('');
+      }
+      
+      clack.outro('');
+      
+    } else if (options.add) {
+      // Add a module
+      clack.intro(chalk.cyan.bold('Add Module'));
+      
+      const spinner = clack.spinner();
+      spinner.start(`Installing module: ${options.add}`);
+      
+      await moduleManager.install(options.add);
+      
+      spinner.stop(`Module "${options.add}" installed successfully!`);
+      clack.outro(chalk.green('✓ Done'));
+      
+    } else if (options.remove) {
+      // Remove a module
+      const confirm = await clack.confirm({
+        message: `Remove module "${options.remove}"?`,
+      });
+      
+      if (clack.isCancel(confirm) || !confirm) {
+        clack.cancel('Operation cancelled.');
+        process.exit(0);
+      }
+      
+      await moduleManager.uninstall(options.remove);
+      clack.outro(chalk.green(`✓ Module "${options.remove}" removed.`));
+      
+    } else {
+      // No option provided, show help
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar module --list              List all available modules');
+      console.log('  dhurandhar module --info <module>     Show module information');
+      console.log('  dhurandhar module --add <module>      Add a module');
+      console.log('  dhurandhar module --remove <module>   Remove a module');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Module operation failed:'), error.message);
+    process.exit(1);
+  }
+}

package/tools/cli/commands/service.js

@@ -0,0 +1,167 @@
+/**
+ * Service Command - Direct-Action Service Management
+ * Add/modify services with technical specs only, no justification loops
+ */
+
+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 serviceCommand(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 services
+      const sdm = await sdmManager.load();
+      
+      clack.intro(chalk.cyan.bold(`Services (${sdm.services.length})`));
+      
+      if (sdm.services.length === 0) {
+        console.log(chalk.dim('  No services defined yet.'));
+        console.log('');
+        console.log(chalk.cyan('Add one:'));
+        console.log('  dhurandhar service add "auth-service: JWT auth using Go/Echo"');
+      } else {
+        console.log('');
+        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)}`);
+          if (s.tech_stack.database) {
+            console.log(`  Database: ${chalk.cyan(s.tech_stack.database)}`);
+          }
+          if (s.api) {
+            console.log(`  API: ${s.api.type} ${s.api.base_path || ''} ${s.api.port ? ':' + s.api.port : ''}`);
+          }
+          console.log('');
+        });
+      }
+      
+      clack.outro('');
+      
+    } else if (options.add) {
+      // Add service - DIRECT ACTION, max 3 questions
+      clack.intro(chalk.cyan.bold('Add Service'));
+      
+      // Parse quick spec if provided: "service-name: description"
+      let serviceName, serviceScope;
+      
+      if (typeof options.add === 'string' && options.add.includes(':')) {
+        const parts = options.add.split(':');
+        serviceName = parts[0].trim();
+        serviceScope = parts.slice(1).join(':').trim();
+      } else {
+        serviceName = typeof options.add === 'string' ? options.add : null;
+      }
+      
+      // Question 1: Service name (if not provided)
+      if (!serviceName) {
+        serviceName = await clack.text({
+          message: 'Service name (kebab-case):',
+          placeholder: 'auth-service',
+          validate: (v) => !v ? 'Required' : !/^[a-z0-9-]+$/.test(v) ? 'Use kebab-case' : undefined,
+        });
+        
+        if (clack.isCancel(serviceName)) {
+          clack.cancel('Cancelled.');
+          process.exit(0);
+        }
+      }
+      
+      // Question 2: Scope (if not provided)
+      if (!serviceScope) {
+        serviceScope = await clack.text({
+          message: 'What does it do? (1-2 sentences):',
+          placeholder: 'Handles JWT authentication and session management',
+          validate: (v) => !v ? 'Required' : undefined,
+        });
+        
+        if (clack.isCancel(serviceScope)) {
+          clack.cancel('Cancelled.');
+          process.exit(0);
+        }
+      }
+      
+      // Question 3: Tech stack
+      const sdm = await sdmManager.load();
+      const defaultLang = sdm.tech_stack.languages[0] || 'go';
+      
+      const language = await clack.select({
+        message: 'Language:',
+        options: [
+          { value: 'go', label: 'Go' },
+          { value: 'typescript', label: 'TypeScript' },
+          { value: 'python', label: 'Python' },
+          { value: 'rust', label: 'Rust' },
+          { value: 'java', label: 'Java' },
+        ],
+        initialValue: defaultLang,
+      });
+      
+      if (clack.isCancel(language)) {
+        clack.cancel('Cancelled.');
+        process.exit(0);
+      }
+      
+      // Auto-select common framework for language
+      const frameworkMap = {
+        go: 'Echo',
+        typescript: 'Express',
+        python: 'FastAPI',
+        rust: 'Actix',
+        java: 'Spring',
+      };
+      
+      const framework = frameworkMap[language];
+      const database = 'PostgreSQL'; // Default
+      
+      // Build service object
+      const service = {
+        name: serviceName,
+        scope: serviceScope,
+        tech_stack: {
+          language: language.charAt(0).toUpperCase() + language.slice(1),
+          framework,
+          database,
+        },
+        api: {
+          type: 'rest',
+          base_path: `/api/v1/${serviceName.replace('-service', '')}`,
+          port: 8080 + sdm.services.length, // Auto-increment
+        },
+        dependencies: [],
+        data_access: [],
+      };
+      
+      // Add to SDM
+      await sdmManager.addService(service);
+      
+      clack.outro(chalk.green(`✓ Service "${serviceName}" added to architecture`));
+      
+      console.log('');
+      console.log(chalk.cyan('Updated SYSTEM_DESIGN_MAP.yaml'));
+      console.log(chalk.dim('Context persisted for next session.'));
+      console.log('');
+      
+    } else {
+      // Show help
+      console.log(chalk.cyan('Usage:'));
+      console.log('  dhurandhar service --list                          List all services');
+      console.log('  dhurandhar service --add "name: description"       Add service with quick spec');
+      console.log('  dhurandhar service --add                           Add service interactively');
+    }
+    
+  } catch (error) {
+    clack.log.error(chalk.red('Service operation failed:'), error.message);
+    process.exit(1);
+  }
+}