dhurandhar 2.0.2 → 2.1.1

package/CHANGELOG.md

@@ -5,6 +5,61 @@ All notable changes to Dhurandhar will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.1] - 2026-04-02
+
+### Fixed
+- Better error handling in setup wizard (catches TTY issues with npx)
+- Added try-catch for performance settings prompts
+- Added helpful instructions: "Press Enter to confirm selections"
+- Setup uses defaults if prompts fail
+
+### Added
+- SETUP_TROUBLESHOOTING.md - Comprehensive troubleshooting guide
+- Better user guidance in setup wizard
+
+### Note for npx users
+If setup hangs on last question, **press Enter** to confirm selection!
+Or install globally for better experience:
+```bash
+npm install -g dhurandhar
+dhurandhar setup
+```
+
+---
+
+## [2.1.0] - 2026-04-02
+
+### Added - Setup Wizard! 🎉
+- **`dhurandhar setup`** - Interactive first-time setup wizard
+- Verifies/selects installation directory
+- Configures AI coding assistant integration:
+  - Augment Code (auggie)
+  - Cursor
+  - Claude Code
+  - GitHub Copilot
+  - Codeium
+  - Tabnine
+  - Google Gemini Code
+  - OpenAI Codex
+- Configures enterprise integrations (GitHub, Jira, Confluence)
+- Selects AI provider for design suggestions
+- Configures performance settings (cache, progress indicators)
+- Saves configuration to `~/.dhurandhar/config.json`
+
+### Changed
+- `dhurandhar init` now checks if setup is complete
+- If setup not complete, prompts user to run setup first
+- Better command suggestions: "install" now suggests "setup"
+- Configuration persisted across all projects
+
+### Improved
+- Much better first-time user experience
+- Like BMAD's installation process
+- Clear configuration summary after setup
+- Guided workflow: setup → init → design
+
+---
+
 ## [2.0.2] - 2026-04-02
 
 ### Fixed

package/cli/commands/init.js

@@ -8,10 +8,34 @@ import * as clack from '@clack/prompts';
 import chalk from 'chalk';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
+import { isSetupComplete, loadConfig } from '../../core/config/config-loader.js';
 
 export default async function initCommand(options) {
   console.log(chalk.cyan.bold('🚀 Initialize Dhurandhar Project\n'));
 
+  // Check if setup is complete
+  if (!isSetupComplete()) {
+    clack.log.warn('Dhurandhar setup not completed yet.');
+    console.log(chalk.yellow('\n💡 Run setup first:'));
+    console.log(chalk.cyan('   dhurandhar setup\n'));
+
+    const runSetup = await clack.confirm({
+      message: 'Run setup now?',
+      initialValue: true,
+    });
+
+    if (clack.isCancel(runSetup) || !runSetup) {
+      clack.cancel('Initialization cancelled');
+      return;
+    }
+
+    // Run setup
+    const { default: setupCommand } = await import('./setup.js');
+    await setupCommand({});
+
+    console.log(chalk.cyan('\n🚀 Continuing with project initialization...\n'));
+  }
+
   // Check if already initialized
   if (existsSync('.dhurandhar')) {
     clack.log.error('Dhurandhar project already initialized in this directory.');

package/cli/commands/setup.js

@@ -0,0 +1,266 @@
+/**
+ * Dhurandhar Setup Wizard
+ * 
+ * Interactive installation process:
+ * - Verify installation directory
+ * - Configure AI coding assistant integration
+ * - Setup enterprise integrations
+ * - Configure preferences
+ */
+
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export default async function setupCommand(options) {
+  try {
+    console.clear();
+
+    clack.intro(chalk.cyan.bold('🕉️  DHURANDHAR SETUP WIZARD'));
+
+    console.log(chalk.gray('Welcome! Let\'s configure Dhurandhar for your environment.\n'));
+    console.log(chalk.gray('(Press Enter to confirm selections, Ctrl+C to cancel)\n'));
+
+    const config = {};
+
+    // Step 1: Installation Directory
+    await selectInstallationDirectory(config);
+
+    // Step 2: AI Coding Assistant
+    await selectAICodingAssistant(config);
+
+    // Step 3: Enterprise Integrations
+    await setupEnterpriseIntegrations(config);
+
+    // Step 4: AI Provider
+    await selectAIProvider(config);
+
+    // Step 5: Performance Settings
+    await configurePerformance(config);
+
+    // Step 6: Save Configuration
+    await saveConfiguration(config);
+
+    clack.outro(chalk.green.bold('✅ Setup Complete!'));
+
+    console.log(chalk.cyan('\n📚 Next Steps:'));
+    console.log(chalk.gray('  1. cd to your project directory'));
+    console.log(chalk.gray('  2. Run: dhurandhar init'));
+    console.log(chalk.gray('  3. Start designing: dhurandhar yudhishthira\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Setup failed:'), error.message);
+    console.log(chalk.yellow('\n💡 Tip: Try running setup again with a stable terminal'));
+    console.log(chalk.gray('      dhurandhar setup\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Step 1: Select installation directory
+ */
+async function selectInstallationDirectory(config) {
+  const s = clack.spinner();
+  s.start('Detecting current directory...');
+  
+  const cwd = process.cwd();
+  const home = homedir();
+  
+  s.stop('Current directory detected');
+  
+  const dirChoice = await clack.select({
+    message: 'Where should Dhurandhar projects be created?',
+    options: [
+      { value: 'current', label: `Current directory: ${cwd}` },
+      { value: 'home', label: `Home directory: ${home}/dhurandhar-projects` },
+      { value: 'custom', label: 'Custom directory (I\'ll specify)' },
+    ],
+  });
+  
+  if (clack.isCancel(dirChoice)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+  
+  if (dirChoice === 'current') {
+    config.projectsDirectory = cwd;
+  } else if (dirChoice === 'home') {
+    config.projectsDirectory = join(home, 'dhurandhar-projects');
+  } else {
+    const customDir = await clack.text({
+      message: 'Enter custom directory path:',
+      placeholder: '/path/to/projects',
+      validate: (value) => {
+        if (!value) return 'Directory path is required';
+      },
+    });
+    
+    if (clack.isCancel(customDir)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    
+    config.projectsDirectory = customDir;
+  }
+  
+  // Create directory if it doesn't exist
+  if (!existsSync(config.projectsDirectory)) {
+    mkdirSync(config.projectsDirectory, { recursive: true });
+    clack.log.success(`Created directory: ${config.projectsDirectory}`);
+  } else {
+    clack.log.info(`Using existing directory: ${config.projectsDirectory}`);
+  }
+}
+
+/**
+ * Step 2: Select AI coding assistant
+ */
+async function selectAICodingAssistant(config) {
+  const assistant = await clack.select({
+    message: 'Which AI coding assistant do you use?',
+    options: [
+      { value: 'augment', label: '🤖 Augment Code (auggie)' },
+      { value: 'cursor', label: '⚡ Cursor' },
+      { value: 'claude', label: '🧠 Claude Code (Code Claude)' },
+      { value: 'copilot', label: '🐙 GitHub Copilot' },
+      { value: 'codeium', label: '💫 Codeium' },
+      { value: 'tabnine', label: '🔮 Tabnine' },
+      { value: 'gemini', label: '💎 Google Gemini Code' },
+      { value: 'codex', label: '🌟 OpenAI Codex' },
+      { value: 'none', label: '❌ None / I\'ll configure later' },
+    ],
+  });
+  
+  if (clack.isCancel(assistant)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+  
+  config.aiCodingAssistant = assistant;
+  
+  if (assistant !== 'none') {
+    clack.log.success(`Selected: ${assistant}`);
+    
+    const integrate = await clack.confirm({
+      message: `Enable deep integration with ${assistant}?`,
+      initialValue: true,
+    });
+    
+    if (!clack.isCancel(integrate)) {
+      config.deepIntegration = integrate;
+    }
+  }
+}
+
+/**
+ * Step 3: Setup enterprise integrations
+ */
+async function setupEnterpriseIntegrations(config) {
+  const integrations = await clack.multiselect({
+    message: 'Which integrations would you like to enable?',
+    options: [
+      { value: 'github', label: '🐙 GitHub (Issues, PRs, Repository)' },
+      { value: 'jira', label: '📋 Jira (Epics, Stories, Tasks)' },
+      { value: 'confluence', label: '📚 Confluence (Documentation)' },
+    ],
+    required: false,
+  });
+  
+  if (clack.isCancel(integrations)) {
+    config.integrations = [];
+  } else {
+    config.integrations = integrations;
+  }
+}
+
+/**
+ * Step 4: Select AI provider
+ */
+async function selectAIProvider(config) {
+  const provider = await clack.select({
+    message: 'Which AI provider for design suggestions?',
+    options: [
+      { value: 'mock', label: '🎭 Mock (No API key needed, for testing)' },
+      { value: 'openai', label: '🤖 OpenAI (GPT-4)' },
+      { value: 'anthropic', label: '🧠 Anthropic (Claude)' },
+    ],
+  });
+  
+  if (clack.isCancel(provider)) {
+    provider = 'mock';
+  }
+  
+  config.aiProvider = provider;
+}
+
+/**
+ * Step 5: Configure performance settings
+ */
+async function configurePerformance(config) {
+  try {
+    const enableCache = await clack.confirm({
+      message: 'Enable caching for faster performance?',
+      initialValue: true,
+    });
+
+    if (clack.isCancel(enableCache)) {
+      config.enableCache = true; // Default to true if cancelled
+    } else {
+      config.enableCache = enableCache;
+    }
+
+    const enableProgress = await clack.confirm({
+      message: 'Show progress indicators for long operations?',
+      initialValue: true,
+    });
+
+    if (clack.isCancel(enableProgress)) {
+      config.enableProgress = true; // Default to true if cancelled
+    } else {
+      config.enableProgress = enableProgress;
+    }
+  } catch (error) {
+    // If prompts fail (e.g., with npx), use defaults
+    clack.log.warn('Using default performance settings (cache: on, progress: on)');
+    config.enableCache = true;
+    config.enableProgress = true;
+  }
+}
+
+/**
+ * Step 6: Save configuration
+ */
+async function saveConfiguration(config) {
+  const s = clack.spinner();
+  s.start('Saving configuration...');
+
+  const configDir = join(homedir(), '.dhurandhar');
+  const configPath = join(configDir, 'config.json');
+
+  // Create config directory if it doesn't exist
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+
+  // Add metadata
+  config.version = '2.0.2';
+  config.setupDate = new Date().toISOString();
+  config.setupCompleted = true;
+
+  // Write config
+  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  s.stop('Configuration saved');
+
+  clack.log.success(`Configuration saved to: ${configPath}`);
+
+  // Display summary
+  console.log(chalk.cyan('\n📋 Configuration Summary:\n'));
+  console.log(chalk.gray(`  Projects Directory: ${config.projectsDirectory}`));
+  console.log(chalk.gray(`  AI Coding Assistant: ${config.aiCodingAssistant || 'None'}`));
+  console.log(chalk.gray(`  AI Provider: ${config.aiProvider}`));
+  console.log(chalk.gray(`  Integrations: ${config.integrations?.join(', ') || 'None'}`));
+  console.log(chalk.gray(`  Cache Enabled: ${config.enableCache ? 'Yes' : 'No'}`));
+  console.log(chalk.gray(`  Progress Indicators: ${config.enableProgress ? 'Yes' : 'No'}\n`));
+}

package/cli/dhurandhar.js

@@ -46,6 +46,15 @@ program.hook('preAction', () => {
   console.log('');
 });
 
+// Command: setup - First-time setup wizard
+program
+  .command('setup')
+  .description('Run first-time setup wizard (configure AI assistants, integrations)')
+  .action(async (options) => {
+    const { default: setupCommand } = await import('./commands/setup.js');
+    await setupCommand(options);
+  });
+
 // Command: init - Initialize new project
 program
   .command('init')
@@ -271,8 +280,9 @@ program.on('command:*', function (operands) {
 
   // Suggest similar commands
   const suggestions = {
-    'install': 'init',
-    'setup': 'init',
+    'install': 'setup',
+    'configure': 'setup',
+    'config': 'setup',
     'create': 'init',
     'start': 'init',
     'generate': 'codegen',

package/core/config/config-loader.js

@@ -0,0 +1,152 @@
+/**
+ * Configuration Loader
+ * 
+ * Loads and manages Dhurandhar configuration
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Get configuration file path
+ */
+export function getConfigPath() {
+  return join(homedir(), '.dhurandhar', 'config.json');
+}
+
+/**
+ * Check if setup has been completed
+ */
+export function isSetupComplete() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return false;
+  }
+  
+  try {
+    const config = loadConfig();
+    return config.setupCompleted === true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Load configuration
+ */
+export function loadConfig() {
+  const configPath = getConfigPath();
+  
+  if (!existsSync(configPath)) {
+    return getDefaultConfig();
+  }
+  
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error loading config:', error.message);
+    return getDefaultConfig();
+  }
+}
+
+/**
+ * Get default configuration
+ */
+export function getDefaultConfig() {
+  return {
+    version: '2.0.2',
+    projectsDirectory: process.cwd(),
+    aiCodingAssistant: 'none',
+    deepIntegration: false,
+    aiProvider: 'mock',
+    integrations: [],
+    enableCache: true,
+    enableProgress: true,
+    setupCompleted: false,
+  };
+}
+
+/**
+ * Get configuration value
+ */
+export function getConfigValue(key, defaultValue = null) {
+  const config = loadConfig();
+  return config[key] ?? defaultValue;
+}
+
+/**
+ * Check if integration is enabled
+ */
+export function isIntegrationEnabled(integration) {
+  const config = loadConfig();
+  return config.integrations?.includes(integration) ?? false;
+}
+
+/**
+ * Get AI coding assistant info
+ */
+export function getAICodingAssistant() {
+  const config = loadConfig();
+  
+  const assistants = {
+    augment: {
+      name: 'Augment Code',
+      command: 'auggie',
+      configFile: '.augment',
+      description: 'Augment Code (auggie)',
+    },
+    cursor: {
+      name: 'Cursor',
+      command: 'cursor',
+      configFile: '.cursor',
+      description: 'Cursor AI Editor',
+    },
+    claude: {
+      name: 'Claude Code',
+      command: 'claude',
+      configFile: '.claude',
+      description: 'Anthropic Claude Code',
+    },
+    copilot: {
+      name: 'GitHub Copilot',
+      command: 'github-copilot',
+      configFile: '.github',
+      description: 'GitHub Copilot',
+    },
+    codeium: {
+      name: 'Codeium',
+      command: 'codeium',
+      configFile: '.codeium',
+      description: 'Codeium AI',
+    },
+    tabnine: {
+      name: 'Tabnine',
+      command: 'tabnine',
+      configFile: '.tabnine',
+      description: 'Tabnine AI',
+    },
+    gemini: {
+      name: 'Google Gemini Code',
+      command: 'gemini',
+      configFile: '.gemini',
+      description: 'Google Gemini Code',
+    },
+    codex: {
+      name: 'OpenAI Codex',
+      command: 'codex',
+      configFile: '.codex',
+      description: 'OpenAI Codex',
+    },
+    none: {
+      name: 'None',
+      command: null,
+      configFile: null,
+      description: 'No AI coding assistant',
+    },
+  };
+  
+  const assistantKey = config.aiCodingAssistant || 'none';
+  return assistants[assistantKey] || assistants.none;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "dhurandhar",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "The world's first AI-powered dharma-centric design framework. 8 Pandava agents + 21 sub-agents guide you from idea to production code. Features → Requirements → Entities → API → HLD → LLD → Implementation → Blessing. Complete with code generation, enterprise integrations, and mythological accuracy.",
   "keywords": [
     "system-design",