mad-pro-cli 1.1.0 → 1.3.0

package/lib/commands/doctor/architecture-checker.js

@@ -0,0 +1,140 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export async function runArchitectureCheck(rootDir, config) {
+  const issues = [];
+  const arch = config.architecture || 'mvvm';
+  const di = config.di || 'hilt';
+
+  // Helper to scan files
+  const ktFiles = [];
+  function scanDir(dir) {
+    if (!fs.existsSync(dir)) return;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      if (fs.statSync(fullPath).isDirectory()) {
+         // Skip build and generated dirs
+         if (!['build', '.gradle', '.idea', 'node_modules'].includes(file)) {
+            scanDir(fullPath);
+         }
+      } else if (fullPath.endsWith('.kt')) {
+         ktFiles.push(fullPath);
+      }
+    }
+  }
+
+  scanDir(rootDir);
+
+  let hasDomainLayer = false;
+  let hasUiLayer = false;
+  let hasDataLayer = false;
+
+  for (const file of ktFiles) {
+    const relPath = path.relative(rootDir, file);
+    const content = fs.readFileSync(file, 'utf8');
+
+    // Layer checks
+    if (relPath.includes('/domain/') || relPath.includes('/usecase/')) hasDomainLayer = true;
+    if (relPath.includes('/ui/') || relPath.includes('/presentation/')) hasUiLayer = true;
+    if (relPath.includes('/data/')) hasDataLayer = true;
+
+    const lines = content.split('\n');
+
+    // God class check
+    if (lines.length > 300) {
+      issues.push({
+        severity: 'warning',
+        file: relPath,
+        line: 1,
+        title: 'God-class detected',
+        message: 'File is over 300 lines. Consider splitting into smaller classes/composables.'
+      });
+    }
+
+    // Specific file type checks based on content
+    const isViewModel = content.includes('ViewModel()') || file.endsWith('ViewModel.kt') || content.includes('class ') && content.includes('ViewModel');
+    const isActivityOrFragment = content.includes('class ') && (content.includes(' : AppCompatActivity') || content.includes(' : ComponentActivity') || content.includes(' : Fragment'));
+
+    // Activity logic check
+    if (isActivityOrFragment) {
+      if (arch !== 'custom' && (content.includes('viewModelScope') || content.includes('Retrofit') || content.includes('Dao'))) {
+        issues.push({
+          severity: 'critical',
+          file: relPath,
+          line: lines.findIndex(l => l.includes('Retrofit') || l.includes('Dao') || l.includes('viewModelScope')) + 1 || 1,
+          title: `Logic in Activity/Fragment (${arch.toUpperCase()})`,
+          message: `Migrate logic to ViewModel or ${arch === 'viper' ? 'Interactor' : 'UseCase'}`,
+          refactor: `Ensure setContent { } wraps your NavHost, no logic in Activity`
+        });
+      }
+    }
+
+    if (isViewModel) {
+      // Missing DI check
+      if (di === 'hilt' && !content.includes('@HiltViewModel')) {
+        issues.push({ severity: 'warning', file: relPath, line: 1, title: 'Missing @HiltViewModel', message: 'Add @HiltViewModel to use Hilt DI.' });
+      } else if (di === 'koin' && !content.includes('@KoinViewModel') && !content.includes('viewModel {')) {
+         // Koin usually defined in module, but annotations exist in Koin annotations
+      }
+
+      // Bypass UseCase check (Directly injecting Repository)
+      if (['mvi', 'clean+mvi', 'viper'].includes(arch)) {
+        const repoInjectMatch = content.match(/val\s+[a-zA-Z0-9_]+Repository\s*:/);
+        if (repoInjectMatch) {
+          issues.push({
+            severity: 'critical',
+            file: relPath,
+            line: lines.findIndex(l => l.includes(repoInjectMatch[0])) + 1,
+            title: 'Business logic bypass detected',
+            message: `Direct usage of Repository in ViewModel. Expected UseCase/Interactor in ${arch.toUpperCase()}`,
+            refactor: `class MyUseCase @Inject constructor(private val repo: Repository) { operator fun invoke() = repo.exec() }\nInject MyUseCase instead.`
+          });
+        }
+      }
+
+      // MVI Checks
+      if (['mvi', 'clean+mvi'].includes(arch)) {
+         if (!content.includes('StateFlow') && !content.includes('UiState')) {
+            issues.push({ severity: 'critical', file: relPath, line: 1, title: 'Missing StateFlow/UiState', message: 'MVI requires state management via StateFlow.' });
+         }
+         if (!content.includes('Intent') && !content.includes('Action') && !content.includes('Event')) {
+            issues.push({ severity: 'critical', file: relPath, line: 1, title: 'Missing Intent/Action', message: 'MVI expects explicit Intents or Actions.' });
+         }
+      }
+    }
+
+    // `runBlocking` in main thread (generic check)
+    lines.forEach((line, index) => {
+      if (line.includes('runBlocking')) {
+         issues.push({
+            severity: 'critical',
+            file: relPath,
+            line: index + 1,
+            title: 'runBlocking detected',
+            message: 'Avoid runBlocking in production code as it blocks the thread.',
+            refactor: 'Replace with viewModelScope.launch or lifecycleScope.launch'
+         });
+      }
+      
+      // Hardcoded string (naive check inside composables / classes)
+      if (line.match(/Text\(\s*"[^"]+"\s*\)/)) {
+        issues.push({
+          severity: 'warning',
+          file: relPath,
+          line: index + 1,
+          title: 'Hardcoded string in UI',
+          message: 'Found hardcoded string in Text().',
+          refactor: 'Move to res/values/strings.xml and use stringResource(R.string.id)'
+        });
+      }
+    });
+  }
+
+  if (!hasDomainLayer && ['clean+mvi', 'viper'].includes(arch)) {
+     issues.push({ severity: 'warning', file: 'Project Structure', line: 0, title: 'Missing Domain Layer', message: 'Create domain/usecase/ layer.' });
+  }
+
+  return issues;
+}

package/lib/commands/doctor/diff-reviewer.js

@@ -0,0 +1,40 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { runArchitectureCheck } from './architecture-checker.js';
+import { runSecurityScan } from './security-scanner.js';
+
+export async function runDiffReview(rootDir, targetBranch, config, doSecurity) {
+  let changedFiles = [];
+  try {
+    const output = execSync(`git diff ${targetBranch}...HEAD --name-only`, { cwd: rootDir, encoding: 'utf8' });
+    changedFiles = output.split('\n').map(l => l.trim()).filter(l => l.length > 0 && l.endsWith('.kt'));
+  } catch (e) {
+    throw new Error(`Failed to get git diff vs ${targetBranch}. Ensure it exists locally and project is a git repo.`);
+  }
+
+  if (changedFiles.length === 0) return { files: 0, issues: [] };
+
+  // Collect all issues from architecture check and security scan
+  // Usually they scan the whole dir, but for this we might need to filter.
+  // Wait, the arch checker scans the dir recursively. 
+  // For diff review, we can just run the scanners recursively and then filter the output by the changed files list.
+  
+  const archIssues = await runArchitectureCheck(rootDir, config);
+  const securityIssues = doSecurity ? await runSecurityScan(rootDir) : [];
+  
+  const allIssues = [...archIssues, ...securityIssues];
+
+  // Filter issues to only include changed files
+  // arch/security checkers use relative paths from rootDir
+  const filteredIssues = allIssues.filter(issue => {
+      // Changed files paths are usually relative to git root.
+      // Assuming rootDir is git root.
+      return changedFiles.includes(issue.file);
+  });
+
+  return {
+     files: changedFiles.length,
+     issues: filteredIssues
+  };
+}

package/lib/commands/doctor/security-scanner.js

@@ -0,0 +1,93 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function runSecurityScan(rootDir) {
+  const issues = [];
+  
+  const ktFiles = [];
+  const buildFiles = [];
+  
+  function scanDir(dir) {
+    if (!fs.existsSync(dir)) return;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      if (fs.statSync(fullPath).isDirectory()) {
+         if (!['build', '.gradle', '.idea', 'node_modules'].includes(file)) {
+            scanDir(fullPath);
+         }
+      } else if (fullPath.endsWith('.kt')) {
+         ktFiles.push(fullPath);
+      } else if (fullPath.endsWith('.gradle.kts') || fullPath.endsWith('.gradle')) {
+         buildFiles.push(fullPath);
+      }
+    }
+  }
+
+  scanDir(rootDir);
+
+  for (const file of buildFiles) {
+     const relPath = path.relative(rootDir, file);
+     const content = fs.readFileSync(file, 'utf8');
+     if (content.includes('debuggable true') && content.includes('release {')) {
+        issues.push({ severity: 'critical', file: relPath, line: 0, title: 'Debug flag in Release', message: 'Release buildType has debuggable true.', refactor: 'Remove debuggable true or set to false.' });
+     }
+  }
+
+  for (const file of ktFiles) {
+    const relPath = path.relative(rootDir, file);
+    const content = fs.readFileSync(file, 'utf8');
+    const lines = content.split('\n');
+
+    lines.forEach((line, index) => {
+      // Hardcoded API Key/Token
+      if (line.match(/(val|const val)\s+[A-Z_]+_KEY\s*=\s*"[^"]+"/) || line.match(/=\s*"Bearer\s+[^"]+"/)) {
+         issues.push({
+             severity: 'critical', file: relPath, line: index + 1,
+             title: 'Hardcoded API Key / Secret',
+             message: 'Hardcoded secret detected.',
+             refactor: 'Use BuildConfig or BuildConfig field from local.properties/CI environment.'
+         });
+      }
+
+      // HTTP endpoint
+      if (line.match(/baseUrl\s*=\s*"http:\/\//)) {
+         issues.push({ severity: 'critical', file: relPath, line: index + 1, title: 'HTTP endpoint (bukan HTTPS)', message: 'Insecure HTTP URL in base URL.', refactor: 'Use https:// instead.' });
+      }
+
+      // Unencrypted SharedPreferences
+      if (line.includes('getSharedPreferences') && (line.toLowerCase().includes('token') || line.toLowerCase().includes('password'))) {
+         issues.push({ severity: 'critical', file: relPath, line: index + 1, title: 'Sensitive Data in SharedPreferences', message: 'Storing sensitive data in regular SharedPreferences.', refactor: 'Use EncryptedSharedPreferences (Security Crypto library).' });
+      }
+
+      // Log expose
+      if (line.match(/Log\.[deiwv]\([^,]+,\s*[a-zA-Z]*(token|password|secret)[a-zA-Z]*\)/i)) {
+         issues.push({ severity: 'warning', file: relPath, line: index + 1, title: 'Log exposes PII/Token', message: 'Logging sensitive variables.', refactor: 'Remove log statement or mask the value.' });
+      }
+      
+      // GlobalScope warning
+      if (line.includes('GlobalScope.launch')) {
+         issues.push({ severity: 'warning', file: relPath, line: index + 1, title: 'GlobalScope leak', message: 'GlobalScope coroutine might outlive the component.', refactor: 'Use viewModelScope, lifecycleScope or custom CoroutineScope.' });
+      }
+      
+      // World Readable
+      if (line.includes('MODE_WORLD_READABLE')) {
+         issues.push({ severity: 'critical', file: relPath, line: index + 1, title: 'World readable file permission', message: 'MODE_WORLD_READABLE is deprecated and insecure.', refactor: 'Use MODE_PRIVATE' });
+      }
+    });
+
+    // Check BroadcastReceiver
+    if (content.includes('registerReceiver(')) {
+       if (!content.includes('unregisterReceiver(')) {
+          issues.push({ severity: 'critical', file: relPath, line: 0, title: 'BroadcastReceiver leak', message: 'registerReceiver called but no unregisterReceiver found in the same file.', refactor: 'Call unregisterReceiver in onDestroy() / onStop() or use DisposableEffect in Compose.' });
+       }
+    }
+    
+    // Bitmap recycle warning
+    if (content.includes('Bitmap.create') && !content.includes('.recycle()')) {
+       issues.push({ severity: 'warning', file: relPath, line: 0, title: 'Bitmap leak possible', message: 'Bitmap created but no recycle() call found.', refactor: 'Ensure bitmaps are recycled when no longer needed.' });
+    }
+  }
+
+  return issues;
+}

package/lib/commands/doctor.js

@@ -0,0 +1,140 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { program } from 'commander';
+import { loadConfig, updateConfig } from '../utils/config.js';
+import { runArchitectureCheck } from './doctor/architecture-checker.js';
+import { runSecurityScan } from './doctor/security-scanner.js';
+import { runDiffReview } from './doctor/diff-reviewer.js';
+
+export default async function doctorCommand(cmdObj) {
+  // Setup flags natively (if called directly or parsed from args)
+  // In a robust setup this would be registered in index.js for the commander instance,
+  // but we can check raw arguments here if not passed.
+  const isSecurity = cmdObj?.security || process.argv.includes('--security') || process.argv.includes('-s');
+  const isFix = cmdObj?.fix || process.argv.includes('--fix');
+  const reviewBranch = cmdObj?.review || getArgValue('--review');
+  const outputFile = cmdObj?.output || getArgValue('--output');
+
+  console.log(chalk.bold.magenta('\n🩺 MAD Pro Doctor - Project Audit'));
+
+  const rootDir = process.cwd();
+  let config = loadConfig(rootDir) || {};
+
+  // Interactive Architecture Template Selection on first run
+  if (!config.architecture) {
+    console.log(chalk.cyan('It looks like your project does not have an architecture defined yet.'));
+    const archRes = await inquirer.prompt([{
+      type: 'list',
+      name: 'architecture',
+      message: 'Select your project architecture (for accurate anti-pattern scanning):',
+      choices: [
+        { name: 'MVVM (ViewModel + StateFlow/LiveData)', value: 'mvvm' },
+        { name: 'MVI (Intent → State → Effect)', value: 'mvi' },
+        { name: 'Clean + MVI (Use Case + MVI in ViewModel)', value: 'clean+mvi' },
+        { name: 'MVP (Presenter + View interface)', value: 'mvp' },
+        { name: 'VIPER (View, Interactor, Presenter, Entity, Router)', value: 'viper' },
+        { name: 'Custom (Skip strict architecture checks)', value: 'custom' }
+      ]
+    }]);
+
+    const diRes = await inquirer.prompt([{
+      type: 'list',
+      name: 'di',
+      message: 'Select your Dependency Injection framework:',
+      choices: [
+        { name: 'Hilt', value: 'hilt' },
+        { name: 'Koin', value: 'koin' },
+        { name: 'None/Manual', value: 'none' }
+      ]
+    }]);
+
+    config = updateConfig({ architecture: archRes.architecture, di: diRes.di }, rootDir);
+    console.log(chalk.green(`\n✓ Configured for ${archRes.architecture.toUpperCase()} + ${diRes.di}. (Saved in .mad-pro.json)\n`));
+  }
+
+  console.log(chalk.gray(`Running checks for Architecture: [${config.architecture.toUpperCase()}] and DI: [${config.di}]...\n`));
+
+  let issues = [];
+  let fileCount = 0;
+
+  if (reviewBranch) {
+    console.log(chalk.cyan(`🔍 Diff Code Review against branch: ${reviewBranch}`));
+    try {
+      const reviewResult = await runDiffReview(rootDir, reviewBranch, config, isSecurity);
+      issues = reviewResult.issues;
+      fileCount = reviewResult.files;
+      console.log(chalk.gray(`Scanned ${fileCount} changed files.\n`));
+    } catch (e) {
+      console.error(chalk.red(e.message));
+      return;
+    }
+  } else {
+    issues = await runArchitectureCheck(rootDir, config);
+    if (isSecurity) {
+      console.log(chalk.cyan(`🔒 Running Security & Memory Leak Scanners...`));
+      const secIssues = await runSecurityScan(rootDir);
+      issues = [...issues, ...secIssues];
+    }
+  }
+
+  // Formatting and outputting issues
+  if (issues.length === 0) {
+    console.log(chalk.bold.green('\n🎉 Your project looks 100% MAD-compliant!'));
+  } else {
+    let criticals = 0;
+    let warnings = 0;
+
+    issues.forEach(issue => {
+      const prefix = issue.severity === 'critical' ? chalk.red('❌ [CRITICAL]') : chalk.yellow('⚠️  [WARNING]');
+      if (issue.severity === 'critical') criticals++; else warnings++;
+      
+      console.log(`${prefix} ${issue.title}`);
+      console.log(chalk.gray(`   📍 File: ${issue.file}:${issue.line}`));
+      if (issue.message) console.log(chalk.white(`   ℹ️  ${issue.message}`));
+      if (issue.refactor) {
+         console.log(chalk.cyan(`   💡 Refactor:`));
+         const refactorLines = issue.refactor.split('\\n');
+         refactorLines.forEach(l => console.log(chalk.cyan(`      ${l}`)));
+      }
+      console.log('');
+    });
+
+    console.log(chalk.bold('——————————————————————'));
+    console.log(`${chalk.red(`❌ ${criticals} Critical`)} | ${chalk.yellow(`⚠️ ${warnings} Warning`)}`);
+    console.log(chalk.bold.yellow(`\n⚠️  Found ${issues.length} items to improve.`));
+    if (!isFix) console.log(chalk.white(`Run with --fix to scaffold recommended fixes (experimental).`));
+
+    // Simple auto-fix demo based on the flag
+    if (isFix) {
+       console.log(chalk.green('\n🛠️  Scaffolding fixes (Simulated)...'));
+       issues.filter(i => i.severity === 'critical' && i.title.includes('Business logic bypass')).forEach(issue => {
+          const expectedFile = 'app/src/main/java/com/example/domain/usecase/GeneratedUseCase.kt';
+          console.log(`  ${chalk.green('✓')} Scaffolded: ${expectedFile}`);
+          // In real implementation, this would actually generate the file based on the refactor string.
+       });
+    }
+
+    if (outputFile) {
+       let mdOutput = `# MAD Pro Code Review\n\n`;
+       if (reviewBranch) mdOutput += `**Target Branch:** \`${reviewBranch}\`\n**Changed Files:** ${fileCount}\n\n`;
+       
+       mdOutput += `## Issues Found: ${issues.length}\n`;
+       issues.forEach(issue => {
+          mdOutput += `### ${issue.severity === 'critical' ? '❌' : '⚠️'} ${issue.title}\n`;
+          mdOutput += `- **File:** \`${issue.file}:${issue.line}\`\n`;
+          mdOutput += `- **Message:** ${issue.message}\n`;
+          if (issue.refactor) mdOutput += `- **Refactor:** \n\`\`\`kotlin\n${issue.refactor}\n\`\`\`\n\n`;
+       });
+
+       fs.writeFileSync(path.join(rootDir, outputFile), mdOutput);
+       console.log(chalk.green(`\nReport saved to ${outputFile}`));
+    }
+  }
+}
+
+function getArgValue(flag) {
+  const index = process.argv.indexOf(flag);
+  return index !== -1 ? process.argv[index + 1] : null;
+}

package/lib/commands/init.js

@@ -1,63 +1,156 @@
-import path from 'path';
 import fs from 'fs-extra';
+import path from 'path';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export default async function initCommand(options) {
-  const targetDir = process.cwd();
-  const aiName = options.ai || 'antigravity';
-
-  console.log(chalk.blue(`Initializing project with ${aiName} skills...`));
-
-  if (aiName === 'antigravity') {
-    try {
-      const ide = options.ide || 'vscode';
-      
-      // Mapping IDE to destination path
-      const idePaths = {
-        'vscode': path.join('.agent', 'skills', 'mad-skills'),
-        'code-insiders': path.join('.agent', 'skills', 'mad-skills'),
-        'cursor': path.join('.cursor', 'skills', 'mad-skills'),
-        'windsurf': path.join('.windsurf', 'skills', 'mad-skills'),
-        'android-studio': path.join('.idea', 'skills', 'mad-skills'),
-        'intellij': path.join('.idea', 'skills', 'mad-skills'),
-        'sublime': path.join('.sublime', 'skills', 'mad-skills'),
-        'vim': path.join('.vim', 'skills', 'mad-skills'),
-        'neovim': path.join('.vim', 'skills', 'mad-skills'),
-        'zed': path.join('.zed', 'skills', 'mad-skills'),
-        'antigravity': path.join('.agent', 'skills', 'mad-skills'),
-        'fleet': path.join('.fleet', 'skills', 'mad-skills'),
-        'nova': path.join('.nova', 'skills', 'mad-skills'),
-        'xcode': path.join('Xcode', 'skills', 'mad-skills'),
-        'webstorm': path.join('.idea', 'skills', 'mad-skills')
-      };
-
-      const relativeDestPath = idePaths[ide.toLowerCase()] || idePaths['vscode'];
-      const destinationPath = path.join(targetDir, relativeDestPath);
-      const sourceSkillsPath = path.resolve(__dirname, '../../templates/mad-skills');
-
-      console.log(chalk.yellow(`Installing skills for ${chalk.bold(ide)} to ${destinationPath}...`));
-
-      await fs.ensureDir(destinationPath);
-      
-      // Copy SKILL.md
-      await fs.copy(path.join(sourceSkillsPath, 'SKILL.md'), path.join(destinationPath, 'SKILL.md'));
-      
-      // Copy references directory
-      await fs.copy(path.join(sourceSkillsPath, 'references'), path.join(destinationPath, 'references'));
-
-      console.log(chalk.green('\n✅ Success! MAD Skills (Antigravity Bridge) installed.'));
-      console.log(chalk.cyan(`\nYour AI agent (Antigravity) can now find these skills at: ${destinationPath}`));
-      console.log(chalk.gray('\nTo use these skills, make sure your agent is instructed to read the .agent/skills directory.'));
-
-    } catch (error) {
-      console.error(chalk.red('\n❌ Error installing skills:'), error.message);
+  console.log(chalk.bold.magenta('\n🚀 MAD Pro CLI - Skill Wizard v1.3.0'));
+  console.log(chalk.gray('Setting up your Android project with architecture excellence...\n'));
+
+  // 1. Identify Source & Target
+  const rootDir = process.cwd();
+  const sourceDir = path.join(__dirname, '../../../references');
+
+  // Verify source exists
+  if (!fs.existsSync(sourceDir)) {
+    console.error(chalk.red('Error: Skill library not found. Please reinstall the CLI.'));
+    process.exit(1);
+  }
+
+  // 2. Interactive Prompts
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'ide',
+      message: 'Which IDE are you using?',
+      choices: [
+        { name: 'Cursor (Highly Recommended)', value: 'cursor' },
+        { name: 'Windsurf', value: 'windsurf' },
+        { name: 'VS Code', value: 'vscode' },
+        { name: 'Android Studio', value: 'android-studio' },
+        { name: 'Zed', value: 'zed' },
+        { name: 'Others', value: 'default' }
+      ],
+      default: options.ide || 'cursor'
+    },
+    {
+      type: 'checkbox',
+      name: 'categories',
+      message: 'Select Skill Categories to include:',
+      choices: [
+        { name: 'Core MAD (UI, Domain, Data Layers)', value: 'core', checked: true },
+        { name: 'Platform Capabilities (Camera, Biometrics, etc.)', value: 'platform', checked: true },
+        { name: 'AI & Emerging (Gemini, LLM UI, ARCore)', value: 'ai', checked: false },
+        { name: 'Industry Verticals (Banking, E-commerce, etc.)', value: 'industry', checked: false },
+        { name: 'Monetization & Play (Billing, Subs)', value: 'monetization', checked: false },
+        { name: 'Engineering Excellence (Modularization, CI/CD)', value: 'engineering', checked: false },
+        { name: 'Design Tokens (Colors, Typography, Spacing)', value: 'tokens', checked: true }
+      ]
     }
-  } else {
-    console.log(chalk.red(`\n❌ Unknown AI bridge: ${aiName}`));
-    console.log(chalk.gray('Available bridges: antigravity'));
+  ]);
+
+  // 3. Selective Industry prompt (only if 'industry' is selected)
+  let selectedIndustries = [];
+  if (answers.categories.includes('industry')) {
+    const industryPath = path.join(sourceDir, 'industry');
+    const allIndustries = fs.readdirSync(industryPath).filter(f => f.endsWith('.md') && f !== 'google_play_subscriptions.md' && f !== 'in_app_payments.md');
+
+    const industryChoices = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'industries',
+        message: 'Which Industry Verticals do you need?',
+        choices: allIndustries.map(f => ({ name: f.replace('.md', '').replace(/_/g, ' ').toUpperCase(), value: f }))
+      }
+    ]);
+    selectedIndustries = industryChoices.industries;
+  }
+
+  // 4. Create Target Directories
+  const targetRefDir = path.join(rootDir, 'references');
+  const targetIndustryDir = path.join(targetRefDir, 'industry');
+  const targetTokenDir = path.join(targetRefDir, 'design-tokens');
+  await fs.ensureDir(targetRefDir);
+  if (selectedIndustries.length > 0 || answers.categories.includes('monetization')) {
+    await fs.ensureDir(targetIndustryDir);
+  }
+  if (answers.categories.includes('tokens')) {
+    await fs.ensureDir(targetTokenDir);
+  }
+
+  // 5. Build Mapping & Copy Files
+  const skillMapping = {
+    'core': [
+      'ui_layer_state.md', 'ui_patterns.md', 'ui_layouts.md', 'ui_modifiers.md', 'ui_theming.md', 'ui_navigation.md',
+      'domain_layer_use_case.md', 'data_layer_room.md', 'data_layer_networking.md', 'data_layer_serialization.md'
+    ],
+    'platform': [
+      'camera_media.md', 'barcode_qr.md', 'image_editing.md', 'voice_speech.md', 'biometric_auth.md', 'security.md',
+      'maps_location.md', 'push_notifications.md', 'widget_glance.md', 'app_shortcuts.md'
+    ],
+    'ai': ['gemini_api.md', 'llm_ui_patterns.md', 'ar_core.md', 'on_device_ai.md'],
+    'monetization': ['industry/in_app_payments.md', 'industry/google_play_subscriptions.md'],
+    'engineering': [
+      'modularization.md', 'architecture_di.md', 'concurrency.md', 'performance.md', 'testing.md',
+      'design_systems.md', 'observability.md', 'ci_cd.md'
+    ],
+    'tokens': ['design-tokens/color-tokens.md', 'design-tokens/typography-tokens.md', 'design-tokens/spacing-tokens.md']
+  };
+
+  let filesToCopy = [];
+  answers.categories.forEach(cat => {
+    if (skillMapping[cat]) {
+      filesToCopy = [...filesToCopy, ...skillMapping[cat]];
+    }
+  });
+
+  // Add individual industry files
+  selectedIndustries.forEach(industryFile => {
+    filesToCopy.push(`industry/${industryFile}`);
+  });
+
+  // Always include the master index but pruned
+  filesToCopy.push('../SKILL.md');
+
+  // Perform Copying
+  console.log(chalk.cyan('\n📦 Installing selected skills...'));
+  
+  for (const file of filesToCopy) {
+    const src = path.join(sourceDir, file);
+    const destName = file.includes('industry/') ? file.replace('industry/', 'industry/') : (file.includes('design-tokens/') ? file.replace('design-tokens/', 'design-tokens/') : file);
+    const dest = path.join(targetRefDir, destName);
+    
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dest);
+      console.log(`${chalk.green('✓')} Added ${chalk.gray(destName)}`);
+    }
+  }
+
+  // 6. Project Configuration (IDE Specific)
+  await configureIDE(answers.ide, rootDir);
+
+  console.log(chalk.bold.green('\n🎉 Setup Complete!'));
+  console.log(chalk.white(`Configured IDE: ${chalk.bold.yellow(answers.ide.toUpperCase())}`));
+  console.log(chalk.white(`Skills Installed: ${chalk.bold.yellow(filesToCopy.length - 1)} items`));
+  console.log(chalk.gray('\nYour AI Agent is now ready with expert context. Happy coding! 🚀\n'));
+}
+
+async function configureIDE(ide, rootDir) {
+  const configFiles = {
+    'cursor': { file: '.cursorrules', content: 'Use the patterns in the /references directory for all Android work.' },
+    'windsurf': { file: '.windsurf/rules', content: 'Follow MAD Pro architecture in /references folder.' },
+    'vscode': { file: '.vscode/settings.json', content: '{\n  "android.skillPath": "./references"\n}' }
+  };
+
+  const config = configFiles[ide];
+  if (config) {
+    const targetFile = path.join(rootDir, config.file);
+    await fs.ensureDir(path.dirname(targetFile));
+    await fs.writeFile(targetFile, config.content);
+    console.log(`${chalk.blue('ℹ')} Created IDE config: ${chalk.gray(config.file)}`);
   }
 }