mad-pro-cli 1.1.0 → 1.2.0

package/index.js

@@ -2,17 +2,46 @@
 
 import { program } from 'commander';
 import initCommand from './lib/commands/init.js';
+import addCommand from './lib/commands/add.js';
+import listCommand from './lib/commands/list.js';
+import createCommand from './lib/commands/create.js';
+import doctorCommand from './lib/commands/doctor.js';
+import promptCommand from './lib/commands/prompt.js';
 
 program
   .name('mad-pro')
   .description('MAD Pro CLI - Boost your project with AI Expert Skills')
-  .version('1.0.0');
+  .version('1.2.0');
 
 program
   .command('init')
-  .description('Initialize AI skills for your project')
-  .option('--ai <name>', 'Specify the AI bridge to use (e.g., antigravity)')
+  .description('Initialize AI skills for your project (Interactive Wizard)')
   .option('--ide <type>', 'Specify the IDE (vscode, cursor, windsurf, android-studio, intellij, sublime, vim, neovim, zed, code-insiders)')
   .action(initCommand);
 
+program
+  .command('create [name]')
+  .description('Scaffold a fresh MAD-compliant Android project')
+  .action(createCommand);
+
+program
+  .command('add')
+  .description('Add specific skills to your current project')
+  .action(addCommand);
+
+program
+  .command('list')
+  .description('List skills installed in the current project')
+  .action(listCommand);
+
+program
+  .command('doctor')
+  .description('Check architectural health of your project')
+  .action(doctorCommand);
+
+program
+  .command('prompt')
+  .description('Generate optimized system instructions for your AI Agent')
+  .action(promptCommand);
+
 program.parse();

package/lib/commands/add.js

@@ -0,0 +1,68 @@
+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 addCommand() {
+  console.log(chalk.bold.magenta('\n📥 MAD Pro CLI - Add Skills'));
+  console.log(chalk.gray('Search and install specific skills to your project...\n'));
+
+  const rootDir = process.cwd();
+  const sourceDir = path.join(__dirname, '../../../references');
+
+  if (!fs.existsSync(sourceDir)) {
+    console.error(chalk.red('Error: Skill library not found. Please reinstall the CLI.'));
+    process.exit(1);
+  }
+
+  // 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 allSkills = [...coreFiles, ...industryFiles].map(f => ({
+    name: f.replace('.md', '').replace(/_/g, ' ').toUpperCase(),
+    value: f
+  })).sort((a, b) => a.name.localeCompare(b.name));
+
+  // 2. Interactive Selection (Searchable)
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'skills',
+      message: 'Search and select skills to add:',
+      choices: allSkills,
+      pageSize: 15
+    }
+  ]);
+
+  if (answers.skills.length === 0) {
+    console.log(chalk.yellow('\nNo skills selected. Exit.'));
+    return;
+  }
+
+  // 3. Perform Copying
+  const targetRefDir = path.join(rootDir, 'references');
+  const targetIndustryDir = path.join(targetRefDir, 'industry');
+  await fs.ensureDir(targetRefDir);
+  await fs.ensureDir(targetIndustryDir);
+
+  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);
+    
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dest);
+      console.log(`${chalk.green('✓')} Added ${chalk.gray(skill)}`);
+    }
+  }
+
+  console.log(chalk.bold.green(`\n🎉 Successfully added ${answers.skills.length} skills!`));
+  console.log(chalk.gray('Your AI Agent can now use these additional patterns.\n'));
+}

package/lib/commands/create.js

@@ -0,0 +1,644 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import initCommand from './init.js';
+
+export default async function createCommand(projectName) {
+  console.log(chalk.bold.magenta('\n🏗️  MAD Pro - New Project Scaffold'));
+  console.log(chalk.gray('Generate a production-ready Android/KMP project.\n'));
+
+  if (!projectName) {
+    const res = await inquirer.prompt([{
+      type: 'input',
+      name: 'name',
+      message: 'Project name:',
+      default: 'MyMadApp',
+      validate: v => /^[A-Za-z][A-Za-z0-9]*$/.test(v) || 'Must start with a letter, alphanumeric only.'
+    }]);
+    projectName = res.name;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'templateType',
+      message: 'Select Template:',
+      choices: [
+        { name: 'KrossWave KMP (Recommended - Multi-module, KMP, Koin, Voyager)', value: 'kmp' },
+        { name: 'Basic Android (Single module, Hilt, Navigation Compose)', value: 'basic' }
+      ]
+    },
+    {
+      type: 'input',
+      name: 'package',
+      message: 'Package name:',
+      default: `com.example.${projectName.toLowerCase()}`,
+      validate: v => /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/.test(v) || 'Invalid package (e.g. com.example.app)'
+    }
+  ]);
+
+  let basicAnswers = {};
+  if (answers.templateType === 'basic') {
+      basicAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'minSdk',
+          message: 'Minimum SDK:',
+          choices: ['24', '26', '28', '30'],
+          default: '26'
+        },
+        {
+          type: 'list',
+          name: 'targetSdk',
+          message: 'Target SDK:',
+          choices: ['34', '35'],
+          default: '35'
+        }
+      ]);
+  }
+
+  const targetDir = path.join(process.cwd(), projectName);
+
+  if (fs.existsSync(targetDir)) {
+    console.error(chalk.red(`\n❌ Directory "${projectName}" already exists.`));
+    process.exit(1);
+  }
+
+  const pkg = answers.package;
+  const pkgPath = pkg.replace(/\./g, '/');
+
+  if (answers.templateType === 'kmp') {
+    console.log(chalk.cyan(`\n🔨 Cloning KrossWave KMP template...\n`));
+    try {
+      execSync(`git clone --depth 1 https://github.com/derohimat/android-kmp-starter.git "${projectName}"`, { stdio: 'inherit' });
+      await fs.remove(path.join(targetDir, '.git'));
+      console.log(`  ${chalk.green('✓')} Template cloned successfully`);
+      
+      console.log(chalk.cyan(`\n🔨 Customizing package name to ${pkg}...\n`));
+      const oldPkg = 'com.derohimat.krosswave';
+      const oldAppName = 'KrossWave'; // typical app name in that repo
+      
+      async function processFolder(dir) {
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+          const fullPath = path.join(dir, file);
+          const stat = await fs.stat(fullPath);
+          
+          if (stat.isDirectory()) {
+            await processFolder(fullPath);
+          } else {
+            const ext = path.extname(fullPath);
+            const validExts = ['.kt', '.xml', '.gradle', '.kts', '.pro', '.properties', '.toml', '.md'];
+            if (validExts.includes(ext) || file === 'gradlew' || file === 'gradlew.bat') {
+              try {
+                let content = await fs.readFile(fullPath, 'utf8');
+                let modified = false;
+                
+                if (content.includes(oldPkg)) {
+                   content = content.replace(new RegExp(oldPkg, 'g'), pkg);
+                   modified = true;
+                }
+                if (content.includes(oldAppName)) {
+                   content = content.replace(new RegExp(oldAppName, 'g'), projectName);
+                   modified = true;
+                }
+                
+                if (modified) {
+                   await fs.writeFile(fullPath, content, 'utf8');
+                }
+              } catch (e) {
+                 // ignore read errors on binary files
+              }
+            }
+          }
+        }
+      }
+
+      await processFolder(targetDir);
+      
+      async function restructureDirs(currentDir) {
+          const items = await fs.readdir(currentDir);
+          for (const item of items) {
+              const fullPath = path.join(currentDir, item);
+              if ((await fs.stat(fullPath)).isDirectory()) {
+                  if (fullPath.endsWith(path.join('com', 'derohimat', 'krosswave'))) {
+                      const newPath = fullPath.replace(path.join('com', 'derohimat', 'krosswave'), path.join(...pkg.split('.')));
+                      await fs.move(fullPath, newPath, { overwrite: true });
+                      
+                      const derohimatDir = path.dirname(fullPath);
+                      const comDir = path.dirname(derohimatDir);
+                      try {
+                          await fs.rmdir(derohimatDir);
+                          await fs.rmdir(comDir);      
+                      } catch(e) { }
+                  } else {
+                      await restructureDirs(fullPath);
+                  }
+              }
+          }
+      }
+      await restructureDirs(targetDir);
+      
+      console.log(`  ${chalk.green('✓')} Package renamed to ${pkg}`);
+      console.log(`  ${chalk.green('✓')} App name updated to ${projectName}\n`);
+
+    } catch (e) {
+      console.error(chalk.red(`\n❌ Failed to clone or process template: ${e.message}`));
+      process.exit(1);
+    }
+  } else {
+    // Generate Basic Android (existing logic)
+    console.log(chalk.cyan(`\n🔨 Generating Basic Android project structure...\n`));
+    
+    const compileSdk = basicAnswers.targetSdk;
+    const minSdk = basicAnswers.minSdk;
+    const targetSdk = basicAnswers.targetSdk;
+
+    const dirs = [
+      `app/src/main/java/${pkgPath}`,
+      `app/src/main/java/${pkgPath}/ui/theme`,
+      `app/src/main/java/${pkgPath}/ui/navigation`,
+      `app/src/main/java/${pkgPath}/ui/screens/home`,
+      `app/src/main/java/${pkgPath}/domain/model`,
+      `app/src/main/java/${pkgPath}/domain/usecase`,
+      `app/src/main/java/${pkgPath}/domain/repository`,
+      `app/src/main/java/${pkgPath}/data/repository`,
+      `app/src/main/java/${pkgPath}/data/remote`,
+      `app/src/main/java/${pkgPath}/data/local`,
+      `app/src/main/java/${pkgPath}/di`,
+      `app/src/main/res/drawable`,
+      `app/src/main/res/values`,
+      `app/src/main/res/mipmap-hdpi`,
+      `app/src/test/java/${pkgPath}`,
+      `app/src/androidTest/java/${pkgPath}`,
+      `gradle/wrapper`,
+    ];
+
+    for (const d of dirs) {
+      await fs.ensureDir(path.join(targetDir, d));
+    }
+
+    const files = {};
+    files['build.gradle.kts'] = `// Top-level build file
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.hilt.android) apply false
+    alias(libs.plugins.ksp) apply false
+}
+`;
+
+    files['settings.gradle.kts'] = `pluginManagement {
+    repositories {
+        google {
+            content {
+                includeGroupByRegex("com\\\\.android.*")
+                includeGroupByRegex("com\\\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "${projectName}"
+include(":app")
+`;
+
+    files['gradle/libs.versions.toml'] = `[versions]
+agp = "8.7.3"
+kotlin = "2.1.0"
+ksp = "2.1.0-1.0.29"
+coreKtx = "1.15.0"
+lifecycle = "2.8.7"
+activityCompose = "1.9.3"
+composeBom = "2024.12.01"
+hilt = "2.53.1"
+hiltNavCompose = "1.2.0"
+navigation = "2.8.5"
+coroutines = "1.9.0"
+junit = "4.13.2"
+junitExt = "1.2.1"
+espresso = "3.6.1"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
+hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
+hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
+hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version.ref = "hiltNavCompose" }
+kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitExt" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espresso" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+`;
+
+    files['app/build.gradle.kts'] = `plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.hilt.android)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "${pkg}"
+    compileSdk = ${compileSdk}
+
+    defaultConfig {
+        applicationId = "${pkg}"
+        minSdk = ${minSdk}
+        targetSdk = ${targetSdk}
+        versionCode = 1
+        versionName = "1.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = true
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    buildFeatures {
+        compose = true
+    }
+}
+
+dependencies {
+    // Core
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.lifecycle.runtime.compose)
+    implementation(libs.androidx.activity.compose)
+
+    // Compose
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.ui)
+    implementation(libs.androidx.ui.graphics)
+    implementation(libs.androidx.ui.tooling.preview)
+    implementation(libs.androidx.material3)
+
+    // Navigation
+    implementation(libs.androidx.navigation.compose)
+
+    // Hilt
+    implementation(libs.hilt.android)
+    ksp(libs.hilt.compiler)
+    implementation(libs.hilt.navigation.compose)
+
+    // Coroutines
+    implementation(libs.kotlinx.coroutines.android)
+
+    // Testing
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    debugImplementation(libs.androidx.ui.tooling)
+}
+`;
+
+    files['gradle.properties'] = `# Project-wide Gradle settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.caching=true
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+`;
+
+    files['gradle/wrapper/gradle-wrapper.properties'] = `distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\\://services.gradle.org/distributions/gradle-8.9-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+`;
+
+    files['app/src/main/AndroidManifest.xml'] = `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:name=".${projectName}Application"
+        android:allowBackup=true
+        android:icon="@mipmap/ic_launcher"
+        android:label="${projectName}"
+        android:supportsRtl="true"
+        android:theme="@android:style/Theme.Material.Light.NoActionBar">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
+`;
+
+    files[`app/src/main/java/${pkgPath}/${projectName}Application.kt`] = `package ${pkg}
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class ${projectName}Application : Application()
+`;
+
+    files[`app/src/main/java/${pkgPath}/MainActivity.kt`] = `package ${pkg}
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import ${pkg}.ui.navigation.AppNavHost
+import ${pkg}.ui.theme.${projectName}Theme
+import dagger.hilt.android.AndroidEntryPoint
+
+@AndroidEntryPoint
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            ${projectName}Theme {
+                AppNavHost()
+            }
+        }
+    }
+}
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/theme/Color.kt`] = `package ${pkg}.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+val Purple80 = Color(0xFFD0BCFF)
+val PurpleGrey80 = Color(0xFFCCC2DC)
+val Pink80 = Color(0xFFEFB8C8)
+
+val Purple40 = Color(0xFF6650a4)
+val PurpleGrey40 = Color(0xFF625b71)
+val Pink40 = Color(0xFF7D5260)
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/theme/Type.kt`] = `package ${pkg}.ui.theme
+
+import androidx.compose.material3.Typography
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+
+val Typography = Typography(
+    displayLarge = TextStyle(
+        fontWeight = FontWeight.Bold,
+        fontSize = 57.sp,
+        lineHeight = 64.sp,
+        letterSpacing = (-0.25).sp
+    ),
+    headlineMedium = TextStyle(
+        fontWeight = FontWeight.SemiBold,
+        fontSize = 28.sp,
+        lineHeight = 36.sp
+    ),
+    bodyLarge = TextStyle(
+        fontWeight = FontWeight.Normal,
+        fontSize = 16.sp,
+        lineHeight = 24.sp,
+        letterSpacing = 0.5.sp
+    ),
+    labelSmall = TextStyle(
+        fontWeight = FontWeight.Medium,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    )
+)
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/theme/Theme.kt`] = `package ${pkg}.ui.theme
+
+import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+
+private val DarkColorScheme = darkColorScheme(
+    primary = Purple80,
+    secondary = PurpleGrey80,
+    tertiary = Pink80
+)
+
+private val LightColorScheme = lightColorScheme(
+    primary = Purple40,
+    secondary = PurpleGrey40,
+    tertiary = Pink40
+)
+
+@Composable
+fun ${projectName}Theme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    dynamicColor: Boolean = true,
+    content: @Composable () -> Unit
+) {
+    val colorScheme = when {
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            val context = LocalContext.current
+            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+        }
+        darkTheme -> DarkColorScheme
+        else -> LightColorScheme
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography,
+        content = content
+    )
+}
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/navigation/AppNavHost.kt`] = `package ${pkg}.ui.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import ${pkg}.ui.screens.home.HomeScreen
+
+@Composable
+fun AppNavHost() {
+    val navController = rememberNavController()
+    NavHost(navController = navController, startDestination = "home") {
+        composable("home") {
+            HomeScreen()
+        }
+    }
+}
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/screens/home/HomeScreen.kt`] = `package ${pkg}.ui.screens.home
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.hilt.navigation.compose.hiltViewModel
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun HomeScreen(viewModel: HomeViewModel = hiltViewModel()) {
+    Scaffold(
+        topBar = {
+            TopAppBar(title = { Text("${projectName}") })
+        }
+    ) { padding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding),
+            contentAlignment = Alignment.Center
+        ) {
+            Text(
+                text = "Welcome to ${projectName}!",
+                style = MaterialTheme.typography.headlineMedium
+            )
+        }
+    }
+}
+`;
+
+    files[`app/src/main/java/${pkgPath}/ui/screens/home/HomeViewModel.kt`] = `package ${pkg}.ui.screens.home
+
+import androidx.lifecycle.ViewModel
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+
+@HiltViewModel
+class HomeViewModel @Inject constructor() : ViewModel()
+`;
+
+    files[`app/src/main/java/${pkgPath}/di/AppModule.kt`] = `package ${pkg}.di
+
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AppModule {
+    // Provide your app-wide dependencies here
+}
+`;
+
+    files['app/src/main/res/values/strings.xml'] = `<resources>
+    <string name="app_name">${projectName}</string>
+</resources>
+`;
+
+    files['app/src/main/res/values/colors.xml'] = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="black">#FF000000</color>
+    <color name="white">#FFFFFFFF</color>
+</resources>
+`;
+
+    files['app/proguard-rules.pro'] = `# Add project specific ProGuard rules here.
+# -keep class ${pkg}.data.remote.dto.** { *; }
+`;
+
+    files['.gitignore'] = `*.iml
+.gradle
+/local.properties
+/.idea
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+local.properties
+`;
+
+    let fileCount = 0;
+    for (const [filePath, content] of Object.entries(files)) {
+      const fullPath = path.join(targetDir, filePath);
+      await fs.ensureDir(path.dirname(fullPath));
+      await fs.writeFile(fullPath, content);
+      fileCount++;
+    }
+
+    console.log(`  ${chalk.green('✓')} Generated ${fileCount} files.`);
+  }
+
+  // ── Chain to Skill Wizard ───────────────────────────────
+  console.log(chalk.yellow('\n⏩ Launching Skill Wizard...\n'));
+
+  const originalCwd = process.cwd();
+  process.chdir(targetDir);
+  await initCommand({});
+  process.chdir(originalCwd);
+
+  console.log(chalk.bold.green(`\n🚀 Project "${projectName}" is ready!`));
+  console.log(chalk.white(`\n  cd ${projectName}`));
+  
+  if (answers.templateType === 'kmp') {
+    console.log(chalk.white(`  ./gradlew composeApp:run\n`));
+  } else {
+    console.log(chalk.white(`  ./gradlew assembleDebug\n`));
+  }
+}

package/lib/commands/doctor.js

@@ -0,0 +1,69 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+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);
+      }
+    }
+
+    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}`));
+    }
+  }
+
+  if (issues === 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.`));
+  }
+}
+
+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;
+    }
+  }
+  return false;
+}

package/lib/commands/init.js

@@ -1,63 +1,150 @@
-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.2.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 }
+      ]
+    }
+  ]);
+
+  // 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');
+  await fs.ensureDir(targetRefDir);
+  if (selectedIndustries.length > 0 || answers.categories.includes('monetization')) {
+    await fs.ensureDir(targetIndustryDir);
+  }
+
+  // 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'
+    ]
+  };
+
+  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;
+    const dest = path.join(targetRefDir, destName);
+    
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dest);
+      console.log(`${chalk.green('✓')} Added ${chalk.gray(destName)}`);
     }
-  } else {
-    console.log(chalk.red(`\n❌ Unknown AI bridge: ${aiName}`));
-    console.log(chalk.gray('Available bridges: antigravity'));
+  }
+
+  // 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)}`);
   }
 }

package/lib/commands/list.js

@@ -0,0 +1,42 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export default async function listCommand() {
+  const rootDir = process.cwd();
+  const targetRefDir = path.join(rootDir, 'references');
+
+  console.log(chalk.bold.magenta('\n📋 MAD Pro Installed Skills'));
+
+  if (!fs.existsSync(targetRefDir)) {
+    console.log(chalk.yellow('\nNo skills initialized in this project. Run `mad-pro init` first.'));
+    return;
+  }
+
+  const getFiles = (dir) => {
+    let results = [];
+    const list = fs.readdirSync(dir);
+    list.forEach(file => {
+      const fullPath = path.join(dir, file);
+      const stat = fs.statSync(fullPath);
+      if (stat && stat.isDirectory()) {
+        results = results.concat(getFiles(fullPath));
+      } else if (file.endsWith('.md')) {
+        results.push(path.relative(targetRefDir, fullPath));
+      }
+    });
+    return results;
+  };
+
+  const installed = getFiles(targetRefDir);
+
+  if (installed.length === 0) {
+    console.log(chalk.gray('Zero skills found in /references directory.'));
+  } else {
+    installed.sort().forEach(file => {
+      console.log(`${chalk.green('✓')} ${file.replace('.md', '').toUpperCase().replace(/_/g, ' ')}`);
+    });
+    console.log(chalk.cyan(`\nTotal: ${installed.length} skills active.`));
+  }
+  console.log("");
+}

package/lib/commands/prompt.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export default async function promptCommand() {
+  const rootDir = process.cwd();
+  const targetRefDir = path.join(rootDir, 'references');
+
+  console.log(chalk.bold.magenta('\n🤖 MAD Pro - Agent Instruction Generator'));
+  
+  if (!fs.existsSync(targetRefDir)) {
+    console.log(chalk.yellow('\nNo skills found. Run `mad-pro init` first to generate a tailored prompt.'));
+    return;
+  }
+
+  // Identify installed skills
+  const getFiles = (dir) => {
+    let 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));
+      } else if (file.endsWith('.md')) {
+        results.push(path.basename(file, '.md').replace(/_/g, ' ').toUpperCase());
+      }
+    });
+    return results;
+  };
+
+  const skills = getFiles(targetRefDir);
+
+  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));
+  console.log(chalk.white('------------------------------------------------------------------\n'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mad-pro-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -25,6 +25,7 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
-    "fs-extra": "^11.3.4"
+    "fs-extra": "^11.3.4",
+    "inquirer": "^12.4.2"
   }
 }