dhurandhar 2.1.1 → 2.2.1

package/CHANGELOG.md

@@ -5,6 +5,67 @@ 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.2.1] - 2026-04-02
+
+### Fixed - NOW EXACTLY LIKE BMAD! 🎉
+- **`dhurandhar setup`** now creates directories in **current project directory**
+- Creates **`_dhurandhar/`** directory (like BMAD's `_bmad/`)
+- Creates **`_dhurandhar-output/`** directory (like BMAD's `_bmad-output/`)
+- Creates AI assistant directory (`.augment/`, `.cursor/`, etc.)
+- Creates initial context file in AI directory
+- Directories created immediately on setup, not on init
+
+### Changed
+- Setup creates project structure in current directory
+- AI assistant integration happens during setup
+- Better BMAD compatibility
+
+### User Issue Addressed
+User reported: "setup changed nothing, no _dhurandhar or _dhurandhar-output directories"
+**Fixed**: Setup now creates these directories immediately!
+
+---
+
+## [2.2.0] - 2026-04-02
+
+### Added - BMAD-Style Deep Integration! 🎉
+- **`.dhurandhar-output/` directory** created on init (like BMAD)
+- **AI Assistant Integration** - Context files in assistant's directory:
+  - **Augment Code**: `.augment/` with context, commands, instructions
+  - **Cursor**: `.cursorrules` + `.cursor/` directory
+  - **Claude Code**: `.claude/` directory with context
+  - **GitHub Copilot**: `.github/dhurandhar.md`
+  - **Generic**: `.ai/` directory for other assistants
+- **Commands in chat window** - AI assistants now see Dhurandhar commands
+- **Project context** - AI understands Dhurandhar framework automatically
+- **Deep integration toggle** - Enabled via setup wizard
+
+### Changed
+- `dhurandhar init` now creates comprehensive directory structure
+- Init creates `.dhurandhar-output/` with subdirectories:
+  - `generated/` - Generated code
+  - `diagrams/` - Visual diagrams
+  - `reports/` - Design reports
+- AI assistant gets full context on initialization
+
+### Improved
+- Much better first-time experience (like BMAD)
+- AI assistants understand Dhurandhar workflow
+- Context files guide AI to help with design
+- Commands available in AI chat windows
+
+### Files Created on Init
+- `.dhurandhar/` - Framework config
+- `.dhurandhar-output/` - Output artifacts ← **NEW!**
+- `.augment/` or `.cursor/` etc. - AI context ← **NEW!**
+- `SYSTEM_DESIGN_MAP.yaml` - Design document
+- `README.md` - Project readme
+
+This is a MINOR version bump (2.1.x → 2.2.0) adding significant
+new features while maintaining backward compatibility.
+
+---
+
 ## [2.1.1] - 2026-04-02
 
 ### Fixed

package/cli/commands/init.js

@@ -8,7 +8,8 @@ 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';
+import { isSetupComplete, loadConfig, getAICodingAssistant } from '../../core/config/config-loader.js';
+import { setupAIAssistantIntegration } from '../../core/integrations/ai-assistant-integration.js';
 
 export default async function initCommand(options) {
   console.log(chalk.cyan.bold('🚀 Initialize Dhurandhar Project\n'));
@@ -78,11 +79,17 @@ export default async function initCommand(options) {
   const spinner = clack.spinner();
   spinner.start('Creating project structure...');
 
-  // Create .dhurandhar directory
+  // Create .dhurandhar directory (like BMAD)
   mkdirSync('.dhurandhar', { recursive: true });
   mkdirSync('.dhurandhar/phases', { recursive: true });
   mkdirSync('.dhurandhar/outputs', { recursive: true });
 
+  // Create .dhurandhar-output directory (like BMAD's output structure)
+  mkdirSync('.dhurandhar-output', { recursive: true });
+  mkdirSync('.dhurandhar-output/generated', { recursive: true });
+  mkdirSync('.dhurandhar-output/diagrams', { recursive: true });
+  mkdirSync('.dhurandhar-output/reports', { recursive: true });
+
   // Create config file
   const config = {
     version: '2.0.0',
@@ -207,11 +214,28 @@ dhurandhar next
 
   spinner.stop('Project initialized!');
 
+  // Setup AI coding assistant integration
+  const config = loadConfig();
+  const assistant = getAICodingAssistant();
+
+  if (config.aiCodingAssistant !== 'none' && config.deepIntegration) {
+    console.log(''); // Blank line
+    setupAIAssistantIntegration(config.aiCodingAssistant, projectName, projectType);
+  }
+
   clack.outro(chalk.green.bold('✓ Project created successfully!'));
 
   console.log('');
   console.log(chalk.cyan('Next steps:'));
-  console.log('  1. ' + chalk.bold('dhurandhar phase 1') + ' - Start Features Discovery');
+  console.log('  1. ' + chalk.bold('dhurandhar yudhishthira') + ' - Start Phase 1 (Features)');
   console.log('  2. ' + chalk.bold('dhurandhar status') + ' - Check project status');
+
+  if (config.aiCodingAssistant !== 'none') {
+    console.log('');
+    console.log(chalk.magenta(`💡 ${assistant.name} Integration:`));
+    console.log(chalk.gray('   - Context files created in .augment/'));
+    console.log(chalk.gray('   - Ask your AI assistant for help designing!'));
+  }
+
   console.log('');
 }

package/cli/commands/setup.js

@@ -43,12 +43,14 @@ export default async function setupCommand(options) {
     // Step 6: Save Configuration
     await saveConfiguration(config);
 
+    // Step 7: Create project directories (like BMAD's _bmad and _bmad-output)
+    await createProjectDirectories(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'));
+    console.log(chalk.gray('  1. Run: dhurandhar init (to initialize design)'));
+    console.log(chalk.gray('  2. 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'));
@@ -264,3 +266,117 @@ async function saveConfiguration(config) {
   console.log(chalk.gray(`  Cache Enabled: ${config.enableCache ? 'Yes' : 'No'}`));
   console.log(chalk.gray(`  Progress Indicators: ${config.enableProgress ? 'Yes' : 'No'}\n`));
 }
+
+/**
+ * Step 7: Create project directories (like BMAD's _bmad and _bmad-output)
+ */
+async function createProjectDirectories(config) {
+  const s = clack.spinner();
+  s.start('Creating project directories...');
+
+  const cwd = process.cwd();
+
+  try {
+    // Create _dhurandhar directory (like BMAD's _bmad)
+    const dhurandharDir = join(cwd, '_dhurandhar');
+    if (!existsSync(dhurandharDir)) {
+      mkdirSync(dhurandharDir, { recursive: true });
+      mkdirSync(join(dhurandharDir, 'core'), { recursive: true });
+      mkdirSync(join(dhurandharDir, 'templates'), { recursive: true });
+      mkdirSync(join(dhurandharDir, 'phases'), { recursive: true });
+    }
+
+    // Create _dhurandhar-output directory (like BMAD's _bmad-output)
+    const outputDir = join(cwd, '_dhurandhar-output');
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+      mkdirSync(join(outputDir, 'generated'), { recursive: true });
+      mkdirSync(join(outputDir, 'diagrams'), { recursive: true });
+      mkdirSync(join(outputDir, 'reports'), { recursive: true });
+      mkdirSync(join(outputDir, 'exports'), { recursive: true });
+    }
+
+    // Create AI assistant integration directory and files
+    if (config.aiCodingAssistant && config.aiCodingAssistant !== 'none') {
+      const assistantDirs = {
+        'augment': '.augment',
+        'cursor': '.cursor',
+        'claude': '.claude',
+        'copilot': '.github',
+        'codeium': '.codeium',
+        'tabnine': '.tabnine',
+        'gemini': '.gemini',
+        'codex': '.codex',
+      };
+
+      const assistantDir = assistantDirs[config.aiCodingAssistant];
+      if (assistantDir) {
+        const fullPath = join(cwd, assistantDir);
+        if (!existsSync(fullPath)) {
+          mkdirSync(fullPath, { recursive: true });
+        }
+
+        // Create initial context file
+        const contextFile = join(fullPath, 'dhurandhar-setup.md');
+        const contextContent = `# Dhurandhar Setup Complete
+
+Setup completed on: ${new Date().toISOString()}
+
+## Configuration
+- AI Assistant: ${config.aiCodingAssistant}
+- Deep Integration: ${config.deepIntegration ? 'Enabled' : 'Disabled'}
+- AI Provider: ${config.aiProvider}
+- Integrations: ${config.integrations?.join(', ') || 'None'}
+
+## Directories Created
+- \`_dhurandhar/\` - Core Dhurandhar files
+- \`_dhurandhar-output/\` - Generated outputs
+- \`${assistantDir}/\` - AI assistant integration
+
+## Next Steps
+1. Run \`dhurandhar init\` to initialize your design project
+2. Start Phase 1: \`dhurandhar yudhishthira\`
+
+## Available Commands
+- \`dhurandhar status\` - Check project status
+- \`dhurandhar yudhishthira\` - Phase 1: Features
+- \`dhurandhar bhishma\` - Phase 2: Requirements
+- \`dhurandhar sahadeva\` - Phase 3: Entities
+- \`dhurandhar nakula\` - Phase 4: APIs
+- \`dhurandhar bheema\` - Phase 5: HLD
+- \`dhurandhar arjuna\` - Phase 6: LLD
+- \`dhurandhar draupadi\` - Phase 8: Blessing
+- \`dhurandhar codegen -t all\` - Generate code
+
+🕉️ Dhurandhar is ready to guide your design!
+`;
+        writeFileSync(contextFile, contextContent, 'utf-8');
+      }
+    }
+
+    s.stop('Directories created');
+
+    console.log('');
+    clack.log.success('Created project directories:');
+    console.log(chalk.gray(`  ${cwd}/_dhurandhar/`));
+    console.log(chalk.gray(`  ${cwd}/_dhurandhar-output/`));
+
+    if (config.aiCodingAssistant && config.aiCodingAssistant !== 'none') {
+      const assistantDirs = {
+        'augment': '.augment',
+        'cursor': '.cursor',
+        'claude': '.claude',
+        'copilot': '.github',
+      };
+      const dir = assistantDirs[config.aiCodingAssistant];
+      if (dir) {
+        console.log(chalk.gray(`  ${cwd}/${dir}/`));
+      }
+    }
+    console.log('');
+
+  } catch (error) {
+    s.stop('Failed to create directories');
+    clack.log.error(`Error creating directories: ${error.message}`);
+  }
+}

package/core/integrations/ai-assistant-integration.js

@@ -0,0 +1,203 @@
+/**
+ * AI Assistant Integration Hub
+ * 
+ * Integrates with various AI coding assistants
+ */
+
+import { setupAuggieIntegration } from './auggie-integration.js';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import chalk from 'chalk';
+
+/**
+ * Setup integration based on configured AI assistant
+ */
+export function setupAIAssistantIntegration(assistantType, projectName, projectType) {
+  switch (assistantType) {
+    case 'augment':
+      setupAuggieIntegration(projectName, projectType);
+      break;
+    
+    case 'cursor':
+      setupCursorIntegration(projectName, projectType);
+      break;
+    
+    case 'claude':
+      setupClaudeIntegration(projectName, projectType);
+      break;
+    
+    case 'copilot':
+      setupCopilotIntegration(projectName, projectType);
+      break;
+    
+    default:
+      setupGenericIntegration(projectName, projectType);
+      break;
+  }
+}
+
+/**
+ * Setup Cursor integration
+ */
+function setupCursorIntegration(projectName, projectType) {
+  console.log(chalk.cyan('\n⚡ Setting up Cursor integration...\n'));
+  
+  const cursorDir = '.cursor';
+  if (!existsSync(cursorDir)) {
+    mkdirSync(cursorDir, { recursive: true });
+  }
+  
+  // Create .cursorrules file (Cursor's context file)
+  const cursorrules = `# Dhurandhar Project: ${projectName}
+
+## Project Type
+${projectType}
+
+## Framework
+Dhurandhar v2.1.x - Dharma-centric design framework
+
+## Design Phases
+Execute these phases in order:
+1. dhurandhar yudhishthira (Features)
+2. dhurandhar bhishma (Requirements)
+3. dhurandhar sahadeva (Entities)
+4. dhurandhar nakula (APIs)
+5. dhurandhar bheema (HLD)
+6. dhurandhar arjuna (LLD)
+7. dhurandhar bheema (Implementation)
+8. dhurandhar draupadi (Blessing)
+
+## Key Files
+- SYSTEM_DESIGN_MAP.yaml - Main design document
+- .dhurandhar-output/ - Generated artifacts
+- .dhurandhar/config.json - Project config
+
+## Commands
+See .cursor/dhurandhar-commands.md for all commands.
+`;
+
+  writeFileSync('.cursorrules', cursorrules, 'utf-8');
+  writeFileSync('.cursor/dhurandhar-commands.md', getCommandsMarkdown(), 'utf-8');
+  
+  console.log(chalk.green('✓ Cursor integration complete!\n'));
+  console.log(chalk.gray('  Created:'));
+  console.log(chalk.gray('    - .cursorrules'));
+  console.log(chalk.gray('    - .cursor/dhurandhar-commands.md\n'));
+}
+
+/**
+ * Setup Claude integration
+ */
+function setupClaudeIntegration(projectName, projectType) {
+  console.log(chalk.cyan('\n🧠 Setting up Claude Code integration...\n'));
+  
+  const claudeDir = '.claude';
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  
+  const context = `# Dhurandhar Project Context for Claude
+
+Project: ${projectName}
+Type: ${projectType}
+Framework: Dhurandhar v2.1.x
+
+Use Dhurandhar commands to guide system design.
+See .claude/commands.md for available commands.
+`;
+
+  writeFileSync('.claude/dhurandhar-context.md', context, 'utf-8');
+  writeFileSync('.claude/commands.md', getCommandsMarkdown(), 'utf-8');
+  
+  console.log(chalk.green('✓ Claude integration complete!\n'));
+}
+
+/**
+ * Setup GitHub Copilot integration
+ */
+function setupCopilotIntegration(projectName, projectType) {
+  console.log(chalk.cyan('\n🐙 Setting up GitHub Copilot integration...\n'));
+  
+  const githubDir = '.github';
+  if (!existsSync(githubDir)) {
+    mkdirSync(githubDir, { recursive: true });
+  }
+  
+  const context = `# Dhurandhar Project
+
+Project: ${projectName}
+Type: ${projectType}
+
+This project uses Dhurandhar framework for systematic design.
+Run: dhurandhar status
+`;
+
+  writeFileSync('.github/dhurandhar.md', context, 'utf-8');
+  
+  console.log(chalk.green('✓ Copilot integration complete!\n'));
+}
+
+/**
+ * Setup generic integration (for other AI assistants)
+ */
+function setupGenericIntegration(projectName, projectType) {
+  console.log(chalk.cyan('\n🤖 Setting up AI assistant integration...\n'));
+  
+  const aiDir = '.ai';
+  if (!existsSync(aiDir)) {
+    mkdirSync(aiDir, { recursive: true });
+  }
+  
+  writeFileSync('.ai/dhurandhar-context.md', getGenericContext(projectName, projectType), 'utf-8');
+  writeFileSync('.ai/commands.md', getCommandsMarkdown(), 'utf-8');
+  
+  console.log(chalk.green('✓ AI assistant integration complete!\n'));
+}
+
+/**
+ * Get commands markdown (shared across assistants)
+ */
+function getCommandsMarkdown() {
+  return `# Dhurandhar Commands
+
+## Design Phases
+\`\`\`bash
+dhurandhar yudhishthira  # Phase 1: Features
+dhurandhar bhishma       # Phase 2: Requirements
+dhurandhar sahadeva      # Phase 3: Entities
+dhurandhar nakula        # Phase 4: APIs
+dhurandhar bheema        # Phase 5: HLD & Implementation
+dhurandhar arjuna        # Phase 6: LLD
+dhurandhar draupadi      # Phase 8: Blessing
+\`\`\`
+
+## Utilities
+\`\`\`bash
+dhurandhar status        # Check progress
+dhurandhar codegen -t all # Generate code
+dhurandhar audit         # Run audit
+dhurandhar export -f md  # Export design
+\`\`\`
+`;
+}
+
+/**
+ * Get generic context
+ */
+function getGenericContext(projectName, projectType) {
+  return `# ${projectName}
+
+Type: ${projectType}
+Framework: Dhurandhar v2.1.x
+
+Execute design phases:
+1. dhurandhar yudhishthira
+2. dhurandhar bhishma
+3. dhurandhar sahadeva
+4. dhurandhar nakula
+5. dhurandhar bheema
+6. dhurandhar arjuna
+7. dhurandhar draupadi
+
+Check status: dhurandhar status
+`;
+}

package/core/integrations/auggie-integration.js

@@ -0,0 +1,249 @@
+/**
+ * Auggie (Augment Code) Integration
+ * 
+ * Creates commands and context for Auggie chat window
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+
+/**
+ * Setup Auggie integration for project
+ */
+export function setupAuggieIntegration(projectName, projectType) {
+  console.log(chalk.cyan('\n🤖 Setting up Auggie integration...\n'));
+  
+  // Create .augment directory
+  const augmentDir = '.augment';
+  if (!existsSync(augmentDir)) {
+    mkdirSync(augmentDir, { recursive: true });
+  }
+  
+  // Create context file for Auggie
+  createAuggieContext(projectName, projectType);
+  
+  // Create commands file
+  createAuggieCommands();
+  
+  // Create project instructions
+  createProjectInstructions(projectName, projectType);
+  
+  console.log(chalk.green('✓ Auggie integration complete!\n'));
+  console.log(chalk.gray('  Created:'));
+  console.log(chalk.gray('    - .augment/dhurandhar-context.md'));
+  console.log(chalk.gray('    - .augment/commands.md'));
+  console.log(chalk.gray('    - .augment/project-instructions.md\n'));
+}
+
+/**
+ * Create Auggie context file
+ */
+function createAuggieContext(projectName, projectType) {
+  const context = `# Dhurandhar Project Context
+
+## Project Information
+- **Name**: ${projectName}
+- **Type**: ${projectType}
+- **Framework**: Dhurandhar v2.1.x
+- **Design Approach**: Dharma-centric, 8-phase system design
+
+## What is Dhurandhar?
+Dhurandhar is an AI-powered dharma-centric design framework with:
+- 8 Pandava Master Agents (Yudhishthira, Bhishma, Sahadeva, Nakula, Bheema, Arjuna, Draupadi)
+- 21 Sub-Agents for expert guidance
+- Full-stack code generation
+- Enterprise integrations (GitHub, Jira, Confluence)
+
+## Design Phases
+1. **Phase 1 (Yudhishthira)**: Features - Define what to build
+2. **Phase 2 (Bhishma)**: Requirements - Functional & non-functional requirements
+3. **Phase 3 (Sahadeva)**: Entities - Domain model, data structures
+4. **Phase 4 (Nakula)**: APIs - REST API design
+5. **Phase 5 (Bheema)**: HLD - High-level architecture
+6. **Phase 6 (Arjuna)**: LLD - Low-level design, classes
+7. **Phase 7 (Bheema)**: Implementation - Deployment strategy
+8. **Phase 8 (Draupadi)**: Blessing - Quality gate & approval
+
+## Current Status
+- Project initialized
+- Ready to start Phase 1 (Features)
+
+## Available Commands
+See \`.augment/commands.md\` for all Dhurandhar commands.
+
+## How to Use with Auggie
+1. Ask Auggie to help with design decisions
+2. Use Dhurandhar commands to execute phases
+3. Review outputs in \`.dhurandhar-output/\`
+4. Generate code with \`dhurandhar codegen\`
+
+## Key Files
+- \`.dhurandhar/config.json\` - Project configuration
+- \`SYSTEM_DESIGN_MAP.yaml\` - Main design document
+- \`.dhurandhar-output/\` - Generated outputs
+`;
+
+  writeFileSync('.augment/dhurandhar-context.md', context, 'utf-8');
+}
+
+/**
+ * Create Auggie commands file
+ */
+function createAuggieCommands() {
+  const commands = `# Dhurandhar Commands for Auggie
+
+## Quick Commands
+
+### Check Status
+\`\`\`bash
+dhurandhar status
+\`\`\`
+
+### Design Phases
+\`\`\`bash
+# Phase 1: Features
+dhurandhar yudhishthira
+
+# Phase 2: Requirements
+dhurandhar bhishma
+
+# Phase 3: Entities
+dhurandhar sahadeva
+
+# Phase 4: APIs
+dhurandhar nakula
+
+# Phase 5: HLD
+dhurandhar bheema
+
+# Phase 6: LLD
+dhurandhar arjuna
+
+# Phase 7: Implementation
+# (uses bheema command)
+dhurandhar bheema
+
+# Phase 8: Blessing
+dhurandhar draupadi
+\`\`\`
+
+### Code Generation
+\`\`\`bash
+# Generate all code
+dhurandhar codegen -t all
+
+# Generate specific
+dhurandhar codegen -t backend
+dhurandhar codegen -t frontend
+dhurandhar codegen -t tests
+dhurandhar codegen -t infrastructure
+\`\`\`
+
+### Integrations
+\`\`\`bash
+# Create GitHub issues
+dhurandhar integrate -p github
+
+# Create Jira tickets
+dhurandhar integrate -p jira
+
+# Create Confluence docs
+dhurandhar integrate -p confluence
+\`\`\`
+
+### AI Features
+\`\`\`bash
+# Get AI suggestions
+dhurandhar ai suggest
+
+# Analyze design
+dhurandhar ai analyze
+\`\`\`
+
+### Export & Review
+\`\`\`bash
+# Export design
+dhurandhar export -f markdown
+
+# Run audit
+dhurandhar audit
+\`\`\`
+
+## Auggie Integration Tips
+
+1. **Ask Auggie for help**: "Help me design user authentication feature"
+2. **Run Dhurandhar command**: \`dhurandhar yudhishthira\`
+3. **Review with Auggie**: "Review the features I just designed"
+4. **Iterate**: Continue through all 8 phases
+5. **Generate code**: \`dhurandhar codegen -t all\`
+
+## Context Files
+- This file: \`.augment/commands.md\`
+- Context: \`.augment/dhurandhar-context.md\`
+- Instructions: \`.augment/project-instructions.md\`
+`;
+
+  writeFileSync('.augment/commands.md', commands, 'utf-8');
+}
+
+/**
+ * Create project instructions for Auggie
+ */
+function createProjectInstructions(projectName, projectType) {
+  const instructions = `# Project Instructions for Auggie
+
+## Project: ${projectName}
+## Type: ${projectType}
+
+## Your Role
+You are helping design and implement this project using the Dhurandhar framework.
+
+## Design Process
+1. **Phase 1-8**: Work through each Dhurandhar phase systematically
+2. **Collaborate**: Help the user make design decisions
+3. **Review**: Review outputs after each phase
+4. **Iterate**: Suggest improvements based on dharmic principles
+5. **Generate**: Help generate production-ready code
+
+## Dharmic Principles
+Every design decision should consider:
+- **Satya** (Truth): Is it honest and transparent?
+- **Ahimsa** (Non-harm): Does it avoid harm to users/stakeholders?
+- **Artha** (Value): Does it provide real value?
+- **Karma** (Action): Does it have clear purpose and results?
+- **Moksha** (Liberation): Does it free users from problems?
+
+## When User Asks for Help
+1. Understand the context from \`.augment/dhurandhar-context.md\`
+2. Check current phase in \`.dhurandhar/config.json\`
+3. Review existing design in \`SYSTEM_DESIGN_MAP.yaml\`
+4. Provide guidance aligned with current phase
+5. Suggest Dhurandhar commands to execute
+
+## Code Generation
+After completing all design phases:
+\`\`\`bash
+dhurandhar codegen -t all
+\`\`\`
+
+This generates:
+- Backend (NestJS + TypeORM)
+- Frontend (React + Vite + Tailwind)
+- Tests (Jest)
+- Infrastructure (Docker + Kubernetes)
+
+## Best Practices
+- Review SYSTEM_DESIGN_MAP.yaml frequently
+- Use \`dhurandhar status\` to check progress
+- Run \`dhurandhar audit\` before code generation
+- Check \`.dhurandhar-output/\` for generated artifacts
+
+## Integration
+- This project uses Dhurandhar with Auggie
+- Commands are available in \`.augment/commands.md\`
+- Context is in \`.augment/dhurandhar-context.md\`
+`;
+
+  writeFileSync('.augment/project-instructions.md', instructions, 'utf-8');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "dhurandhar",
-  "version": "2.1.1",
+  "version": "2.2.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",