mad-pro-cli 1.2.0 → 1.3.0

package/index.js

@@ -11,7 +11,7 @@ import promptCommand from './lib/commands/prompt.js';
 program
   .name('mad-pro')
   .description('MAD Pro CLI - Boost your project with AI Expert Skills')
-  .version('1.2.0');
+  .version('1.3.0');
 
 program
   .command('init')

package/lib/commands/add.js

@@ -22,9 +22,11 @@ export default async function addCommand() {
   // 1. Get all available skills
   const coreFiles = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));
   const industryPath = path.join(sourceDir, 'industry');
-  const industryFiles = fs.readdirSync(industryPath).filter(f => f.endsWith('.md')).map(f => `industry/${f}`);
+  const industryFiles = fs.existsSync(industryPath) ? fs.readdirSync(industryPath).filter(f => f.endsWith('.md')).map(f => `industry/${f}`) : [];
+  const tokenPath = path.join(sourceDir, 'design-tokens');
+  const tokenFiles = fs.existsSync(tokenPath) ? fs.readdirSync(tokenPath).filter(f => f.endsWith('.md')).map(f => `design-tokens/${f}`) : [];
 
-  const allSkills = [...coreFiles, ...industryFiles].map(f => ({
+  const allSkills = [...coreFiles, ...industryFiles, ...tokenFiles].map(f => ({
     name: f.replace('.md', '').replace(/_/g, ' ').toUpperCase(),
     value: f
   })).sort((a, b) => a.name.localeCompare(b.name));
@@ -48,14 +50,16 @@ export default async function addCommand() {
   // 3. Perform Copying
   const targetRefDir = path.join(rootDir, 'references');
   const targetIndustryDir = path.join(targetRefDir, 'industry');
+  const targetTokenDir = path.join(targetRefDir, 'design-tokens');
   await fs.ensureDir(targetRefDir);
   await fs.ensureDir(targetIndustryDir);
+  await fs.ensureDir(targetTokenDir);
 
   console.log(chalk.cyan('\n📦 Adding selected skills...'));
 
   for (const skill of answers.skills) {
     const src = path.join(sourceDir, skill);
-    const dest = path.join(targetRefDir, skill);
+    const dest = path.join(targetRefDir, skill.replace('industry/', 'industry/').replace('design-tokens/', 'design-tokens/'));
     
     if (fs.existsSync(src)) {
       await fs.copy(src, dest);

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

@@ -1,69 +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');
 
-export default async function doctorCommand() {
   console.log(chalk.bold.magenta('\n🩺 MAD Pro Doctor - Project Audit'));
-  console.log(chalk.gray('Checking your project for architectural health...\n'));
 
   const rootDir = process.cwd();
-  
-  const checks = [
-    { name: 'MAD Pro Initialization', path: 'references/', type: 'dir', critical: true, help: 'Run `mad-pro init` to install base skills.' },
-    { name: 'Skill Master Index', path: 'references/SKILL.md', type: 'file', critical: false, help: 'Master index (SKILL.md) is missing. This weakens AI context.' },
-    { name: 'Clean Arch: UI Layer', path: 'app/src/main/java/', type: 'dir', contains: 'ui', critical: false, help: 'Missing "ui" package. Conventional MAD apps should have it.' },
-    { name: 'Clean Arch: Data Layer', path: 'app/src/main/java/', type: 'dir', contains: 'data', critical: false, help: 'Missing "data" package. Offline-first apps need a data source.' },
-    { name: 'Hilt Dependency Injection', path: 'app/build.gradle.kts', type: 'content', contains: 'dagger.hilt', critical: false, help: 'Consider using Hilt for easier dependency management.' },
-  ];
-
-  let issues = 0;
-
-  for (const check of checks) {
-    let passed = false;
-    const fullPath = path.join(rootDir, check.path);
-
-    if (check.type === 'dir') {
-      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
-        if (check.contains) {
-          passed = findFolderRecursive(fullPath, check.contains);
-        } else {
-          passed = true;
-        }
-      }
-    } else if (check.type === 'file') {
-      passed = fs.existsSync(fullPath) && fs.statSync(fullPath).isFile();
-    } else if (check.type === 'content') {
-      if (fs.existsSync(fullPath)) {
-        const content = fs.readFileSync(fullPath, 'utf8');
-        passed = content.includes(check.contains);
-      }
-    }
+  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' }
+      ]
+    }]);
 
-    if (passed) {
-      console.log(`${chalk.green('✓')} ${check.name}`);
-    } else {
-      issues++;
-      const prefix = check.critical ? chalk.red('❌') : chalk.yellow('⚠️');
-      console.log(`${prefix} ${check.name}`);
-      console.log(chalk.gray(`   💡 Recommendation: ${check.help}`));
+    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];
     }
   }
 
-  if (issues === 0) {
+  // Formatting and outputting issues
+  if (issues.length === 0) {
     console.log(chalk.bold.green('\n🎉 Your project looks 100% MAD-compliant!'));
   } else {
-    console.log(chalk.bold.yellow(`\n⚠️  Found ${issues} items to improve.`));
-  }
-}
+    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).`));
 
-function findFolderRecursive(startDir, targetName) {
-  const files = fs.readdirSync(startDir);
-  for (const file of files) {
-    const fullPath = path.join(startDir, file);
-    if (fs.statSync(fullPath).isDirectory()) {
-      if (file.toLowerCase() === targetName.toLowerCase()) return true;
-      if (findFolderRecursive(fullPath, targetName)) return true;
+    // 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}`));
     }
   }
-  return false;
+}
+
+function getArgValue(flag) {
+  const index = process.argv.indexOf(flag);
+  return index !== -1 ? process.argv[index + 1] : null;
 }

package/lib/commands/init.js

@@ -8,7 +8,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export default async function initCommand(options) {
-  console.log(chalk.bold.magenta('\n🚀 MAD Pro CLI - Skill Wizard v1.2.0'));
+  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
@@ -47,7 +47,8 @@ export default async function initCommand(options) {
         { 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: 'Engineering Excellence (Modularization, CI/CD)', value: 'engineering', checked: false },
+        { name: 'Design Tokens (Colors, Typography, Spacing)', value: 'tokens', checked: true }
       ]
     }
   ]);
@@ -72,10 +73,14 @@ export default async function initCommand(options) {
   // 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 = {
@@ -92,7 +97,8 @@ export default async function initCommand(options) {
     '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 = [];
@@ -115,7 +121,7 @@ export default async function initCommand(options) {
   
   for (const file of filesToCopy) {
     const src = path.join(sourceDir, file);
-    const destName = file.includes('industry/') ? file.replace('industry/', 'industry/') : 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)) {

package/lib/commands/prompt.js

@@ -1,12 +1,15 @@
 import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { loadConfig } from '../utils/config.js';
 
-export default async function promptCommand() {
+export default async function promptCommand(cmdObj) {
   const rootDir = process.cwd();
   const targetRefDir = path.join(rootDir, 'references');
+  const config = loadConfig(rootDir) || { architecture: 'mvvm', di: 'hilt' };
 
-  console.log(chalk.bold.magenta('\n🤖 MAD Pro - Agent Instruction Generator'));
+  console.log(chalk.bold.magenta('\n🤖 MAD Pro - Contextual Agent Instruction Generator'));
   
   if (!fs.existsSync(targetRefDir)) {
     console.log(chalk.yellow('\nNo skills found. Run `mad-pro init` first to generate a tailored prompt.'));
@@ -16,43 +19,110 @@ export default async function promptCommand() {
   // Identify installed skills
   const getFiles = (dir) => {
     let results = [];
+    if (!fs.existsSync(dir)) return results;
     const list = fs.readdirSync(dir);
     list.forEach(file => {
       const fullPath = path.join(dir, file);
       if (fs.statSync(fullPath).isDirectory()) {
-        results = results.concat(getFiles(fullPath));
+         if (file !== 'design-tokens') {
+            results = results.concat(getFiles(fullPath));
+         }
       } else if (file.endsWith('.md')) {
-        results.push(path.basename(file, '.md').replace(/_/g, ' ').toUpperCase());
+         if (!fullPath.includes('design-tokens')) {
+            results.push(path.basename(file, '.md').replace(/_/g, ' ').toUpperCase());
+         }
       }
     });
     return results;
   };
 
   const skills = getFiles(targetRefDir);
+  const industryDir = path.join(targetRefDir, 'industry');
+  const industrySkills = getFiles(industryDir);
 
-  const prompt = `
-# AI AGENT INSTRUCTIONS (MAD PRO)
-You are an expert Android Developer using the MAD Pro v1.2.0 framework.
-Your goal is to build highly scalable, testable, and maintainable Android apps.
-
-## PROJECT CONTEXT
-This project has the following architectural patterns installed in /references:
-${skills.map(s => `- ${s}`).join('\n')}
-
-## CORE RULES
-1. ALWAYS check the matching file in /references before implementing a new feature.
-2. Follow Clean Architecture: UI -> Domain -> Data layers.
-3. Use Hilt for Dependency Injection.
-4. Use Jetpack Compose with Unidirectional Data Flow (UDF).
-5. If a requested industry pattern (e.g., Banking, E-commerce) exists in /references/industry, adhere strictly to its security and structure guidelines.
-
-## OUTPUT STYLE
-- Provide production-ready Kotlin code.
-- Include KDoc for public functions.
-- Ensure all UI components follow the defined Material 3 theme.
-`;
-
-  console.log(chalk.white('\n--- COPY THE TEXT BELOW TO YOUR SYSTEM PROMPT / .cursorrules ---\n'));
-  console.log(chalk.cyan(prompt));
+  const archRules = {
+      'mvvm': 'Follow MVVM architecture: UI -> ViewModel -> (UseCase) -> Repository -> Data Source.',
+      'mvi': 'Follow MVI architecture: UI -> Intent -> ViewModel -> StateFlow -> UI.',
+      'mvp': 'Follow MVP architecture: View <-> Presenter -> Repository.',
+      'clean+mvi': 'Follow Clean + MVI: UI -> Intent -> ViewModel -> UseCase -> Repository.',
+      'viper': 'Follow VIPER architecture: View, Interactor, Presenter, Entity, Router.',
+      'custom': 'Follow the custom architecture patterns established in the project.'
+  };
+
+  const diRules = {
+      'hilt': 'Use Hilt for Dependency Injection (@HiltViewModel, @Inject).',
+      'koin': 'Use Koin for Dependency Injection (constructor injection, get()).',
+      'none': 'Use manual Dependency Injection.'
+  };
+
+  const hasTokens = fs.existsSync(path.join(targetRefDir, 'design-tokens'));
+
+  const formatRes = await inquirer.prompt([{
+      type: 'list',
+      name: 'format',
+      message: 'Select target format:',
+      choices: [
+          { name: '.cursorrules (Cursor)', value: 'cursor' },
+          { name: '.windsurfrules (Windsurf)', value: 'windsurf' },
+          { name: 'System Prompt (Clipboard / Generic)', value: 'generic' }
+      ]
+  }]);
+
+  const promptBuilder = [];
+  
+  if (formatRes.format !== 'generic') {
+     promptBuilder.push(`You are an expert Android Developer using the MAD Pro v1.3.0 framework.`);
+     promptBuilder.push(`Your goal is to build highly scalable, testable, and maintainable Android apps.\n`);
+  } else {
+     promptBuilder.push(`# AI AGENT INSTRUCTIONS (MAD PRO)`);
+     promptBuilder.push(`System Role: Expert Android Developer\n`);
+  }
+
+  promptBuilder.push(`## PROJECT CONTEXT`);
+  promptBuilder.push(`This project uses the following architecture: **${config.architecture.toUpperCase()}** with **${config.di.toUpperCase()}**.`);
+  if (skills.length > 0) {
+      promptBuilder.push(`Installed architectural patterns in /references:`);
+      skills.slice(0, 15).forEach(s => promptBuilder.push(`- ${s}`));
+      if (skills.length > 15) promptBuilder.push(`- ...and ${skills.length - 15} more.`);
+  }
+  promptBuilder.push('');
+
+  promptBuilder.push(`## CORE RULES`);
+  promptBuilder.push(`1. ALWAYS check the matching file in /references before implementing a new feature.`);
+  promptBuilder.push(`2. ${archRules[config.architecture] || archRules['mvvm']}`);
+  promptBuilder.push(`3. ${diRules[config.di] || diRules['hilt']}`);
+  promptBuilder.push(`4. Use Jetpack Compose with Unidirectional Data Flow (UDF).`);
+  
+  if (industrySkills.length > 0) {
+      promptBuilder.push(`5. Adhere strictly to the industry best practices found in /references/industry/ for: ${industrySkills.join(', ')}.`);
+  }
+
+  promptBuilder.push(`\n## OUTPUT STYLE`);
+  promptBuilder.push(`- Provide production-ready Kotlin code.`);
+  if (hasTokens) {
+      promptBuilder.push(`- STYLING: You MUST use the design tokens defined in /references/design-tokens/ (colors, typography, spacing). Do not hardcode dimensions or generic colors.`);
+  }
+  promptBuilder.push(`- Ensure all UI components follow the defined Material 3 theme. Avoid outdated XML layouts unless required.`);
+
+  const finalPrompt = promptBuilder.join('\n');
+
+  console.log(chalk.white(`\n--- COPY THIS TO YOUR ${formatRes.format === 'generic' ? 'SYSTEM PROMPT' : formatRes.format === 'cursor' ? '.cursorrules' : '.windsurfrules'} ---\n`));
+  console.log(chalk.cyan(finalPrompt));
   console.log(chalk.white('------------------------------------------------------------------\n'));
+  
+  // Optionally auto-write to file if it's cursor or windsurf
+  if (formatRes.format === 'cursor' || formatRes.format === 'windsurf') {
+      const fileName = formatRes.format === 'cursor' ? '.cursorrules' : '.windsurfrules';
+      const fileRes = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'write',
+          message: `Do you want to write this to ${fileName} in the current directory?`,
+          default: true
+      }]);
+      
+      if (fileRes.write) {
+          fs.writeFileSync(path.join(rootDir, fileName), finalPrompt);
+          console.log(chalk.green(`✓ Saved to ${fileName}`));
+      }
+  }
 }

package/lib/utils/config.js

@@ -0,0 +1,32 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+const CONFIG_FILE = '.mad-pro.json';
+
+export function getConfigPath(rootDir = process.cwd()) {
+  return path.join(rootDir, CONFIG_FILE);
+}
+
+export function loadConfig(rootDir = process.cwd()) {
+  const configPath = getConfigPath(rootDir);
+  if (fs.existsSync(configPath)) {
+    try {
+      return fs.readJsonSync(configPath);
+    } catch (e) {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function saveConfig(config, rootDir = process.cwd()) {
+  const configPath = getConfigPath(rootDir);
+  fs.writeJsonSync(configPath, config, { spaces: 2 });
+}
+
+export function updateConfig(updates, rootDir = process.cwd()) {
+  const currentConfig = loadConfig(rootDir) || {};
+  const newConfig = { ...currentConfig, ...updates };
+  saveConfig(newConfig, rootDir);
+  return newConfig;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mad-pro-cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -27,5 +27,8 @@
     "commander": "^14.0.3",
     "fs-extra": "^11.3.4",
     "inquirer": "^12.4.2"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }