budexp 0.1.0

package/src/commands/check.js

@@ -0,0 +1,130 @@
+// ============================================
+// FILE: src/commands/check.js
+// ============================================
+const logger = require('../utils/logger');
+const expoDoctor = require('../utils/expo-doctor');
+const eas = require('../utils/eas');
+const { execFileSync } = require('child_process');
+
+async function checkCommand(type, buildId, options = {}) {
+  if (type === 'health') {
+    await checkHealth(options);
+  } else if (type === 'eas') {
+    await checkEAS();
+  } else if (type === 'eas:list') {
+    await checkEASList();
+  } else if (type === 'eas:view') {
+    await checkEASView(buildId);
+  } else if (type === 'eas:project') {
+    await checkEASProject();
+  } else if (type === 'fix') {
+    await checkFix(options);
+  } else {
+    logger.error(`Unknown check type: ${type}`);
+    logger.info('Available types: health, eas, eas:list, eas:view [build-id], eas:project, fix');
+  }
+}
+
+async function checkHealth(options = {}) {
+  const doctorResult = await expoDoctor.runExpoDoctor({ openReport: options.open });
+  const issuesSummary = expoDoctor.getIssuesSummary(doctorResult.output);
+
+  console.log('');
+  console.log('='.repeat(50));
+  console.log('Health Check Summary');
+  console.log('='.repeat(50));
+
+  if (!issuesSummary.hasIssues) {
+    logger.success('All checks passed! Your Expo project is healthy.');
+  } else {
+    logger.warning(issuesSummary.summary);
+    console.log('');
+
+    if (issuesSummary.errors && issuesSummary.errors.length > 0) {
+      console.log('Errors:');
+      issuesSummary.errors.forEach((issue, index) => {
+        console.log(`  ${index + 1}. ${issue.message}`);
+      });
+      console.log('');
+    }
+
+    if (issuesSummary.warnings && issuesSummary.warnings.length > 0) {
+      console.log('Warnings:');
+      issuesSummary.warnings.forEach((issue, index) => {
+        console.log(`  ${index + 1}. ${issue.message}`);
+      });
+      console.log('');
+    }
+  }
+
+  console.log(`Detailed HTML report: ${doctorResult.reportPath}`);
+  console.log('='.repeat(50));
+  console.log('');
+}
+
+async function checkEAS() {
+  await eas.displayEASStatus();
+}
+
+async function checkEASList() {
+  await eas.listEASBuilds();
+}
+
+async function checkEASView(buildId) {
+  if (!buildId) {
+    logger.error('Build ID is required');
+    logger.info('Usage: budexp check eas:view <build-id>');
+    return;
+  }
+  await eas.viewEASBuild(buildId);
+}
+
+async function checkEASProject() {
+  await eas.displayEASProjectInfo();
+}
+
+async function checkFix(options = {}) {
+  logger.info('Running health check and looking for fixes...');
+  console.log('');
+
+  const doctorResult = await expoDoctor.runExpoDoctor({ openReport: options.open });
+  const issuesSummary = expoDoctor.getIssuesSummary(doctorResult.output);
+
+  if (!issuesSummary.hasIssues) {
+    logger.success('No issues found! Your project is healthy.');
+    return;
+  }
+
+  logger.warning(issuesSummary.summary);
+  console.log('');
+
+  // Try to run expo fix
+  logger.info('Attempting to fix issues with expo fix...');
+  console.log('');
+
+  try {
+    execFileSync('npx', ['expo', 'fix'], { stdio: 'inherit' });
+    logger.success('expo fix completed');
+    console.log('');
+
+    // Run doctor again to see if issues are resolved
+    logger.info('Re-running health check to verify fixes...');
+    const newDoctorResult = await expoDoctor.runExpoDoctor({ openReport: options.open });
+    const newIssuesSummary = expoDoctor.getIssuesSummary(newDoctorResult.output);
+
+    if (!newIssuesSummary.hasIssues) {
+      logger.success('All issues have been resolved!');
+    } else {
+      logger.warning('Some issues remain. Please check the report for details.');
+    }
+  } catch (e) {
+    logger.error('Failed to run expo fix');
+    logger.info('Please check the HTML report for manual fixes:');
+    logger.info(doctorResult.reportPath);
+  }
+
+  console.log('');
+  logger.info(`Detailed HTML report: ${doctorResult.reportPath}`);
+}
+
+module.exports = checkCommand;

package/src/commands/clean.js

@@ -0,0 +1,92 @@
+const inquirer = require('inquirer');
+const prompt = inquirer.default?.prompt || inquirer.prompt;
+const logger = require('../utils/logger');
+const cleaner = require('../utils/cleaner');
+
+async function cleanCommand(options) {
+  logger.info('Starting clean process...');
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+
+  let cleanAll = options.all;
+  let cleanCache = options.cache;
+  let cleanNative = options.native;
+
+  // If no options specified, ask user
+  if (!cleanAll && !cleanCache && !cleanNative && isInteractive) {
+    const answer = await prompt([
+      {
+        type: 'list',
+        name: 'cleanType',
+        message: 'What do you want to clean?',
+        choices: [
+          { name: 'Everything (caches, node_modules, native folders)', value: 'all' },
+          { name: 'Caches only', value: 'cache' },
+          { name: 'Native folders only', value: 'native' },
+        ],
+      },
+    ]);
+
+    if (answer.cleanType === 'all') {
+      cleanAll = true;
+    } else if (answer.cleanType === 'cache') {
+      cleanCache = true;
+    } else {
+      cleanNative = true;
+    }
+  } else if (!cleanAll && !cleanCache && !cleanNative) {
+    logger.warning('No clean option provided in non-interactive mode.');
+    logger.info('Use --all, --cache, or --native.');
+    return;
+  }
+
+  if (cleanAll) {
+    logger.info('Cleaning everything...');
+
+    const bundleId = await cleaner.getBundleId();
+    const platform = 'all';
+
+    await cleaner.killRunningApps(bundleId, platform);
+    await cleaner.cleanWatchman();
+    await cleaner.cleanCaches();
+    await cleaner.deleteNativeFolders(platform);
+    await cleaner.cleanDependencies();
+
+    logger.success('✅ Everything cleaned!');
+  } else if (cleanCache) {
+    logger.info('Cleaning caches only...');
+
+    await cleaner.killRunningApps(null, 'all');
+    await cleaner.cleanWatchman();
+    await cleaner.cleanCaches();
+
+    logger.success('✅ Caches cleaned!');
+  } else if (cleanNative) {
+    logger.info('Cleaning native folders only...');
+
+    let platform = 'all';
+
+    if (isInteractive) {
+      const answer = await prompt([
+        {
+          type: 'list',
+          name: 'platform',
+          message: 'Select platform:',
+          choices: [
+            { name: 'Android', value: 'android' },
+            { name: 'iOS', value: 'ios' },
+            { name: 'Both', value: 'all' },
+          ],
+        },
+      ]);
+      platform = answer.platform;
+    } else {
+      logger.info('Non-interactive shell detected. Removing both native folders.');
+    }
+
+    await cleaner.deleteNativeFolders(platform);
+
+    logger.success('✅ Native folders cleaned!');
+  }
+}
+
+module.exports = cleanCommand;

package/src/commands/dev.js

@@ -0,0 +1,186 @@
+const inquirer = require('inquirer');
+const prompt = inquirer.default?.prompt || inquirer.prompt;
+const logger = require('../utils/logger');
+const cleaner = require('../utils/cleaner');
+const expoDoctor = require('../utils/expo-doctor');
+const { execFileSync, execSync } = require('child_process');
+
+async function devCommand(options) {
+  logger.info('Starting development mode...');
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+
+  // Determine platform
+  let platform = 'android'; // default
+  if (options.all) {
+    platform = 'all';
+  } else if (options.ios) {
+    platform = 'ios';
+  } else if (options.android) {
+    platform = 'android';
+  } else if (isInteractive) {
+    // Ask user if no platform specified
+    const answer = await prompt([
+      {
+        type: 'list',
+        name: 'platform',
+        message: 'Select platform:',
+        choices: [
+          { name: 'Android', value: 'android' },
+          { name: 'iOS', value: 'ios' },
+          { name: 'Both', value: 'all' },
+        ],
+      },
+    ]);
+    platform = answer.platform;
+  } else {
+    logger.info('Non-interactive shell detected. Using default platform: android');
+  }
+
+  logger.info(`Platform: ${platform}`);
+  console.log('');
+
+  // Step 1: Run expo-doctor
+  // logger.info('Step 1: Running health check...');
+  const doctorResult = await expoDoctor.runExpoDoctor({ openReport: options.open });
+  const issuesSummary = expoDoctor.getIssuesSummary(doctorResult.output);
+
+  if (issuesSummary.hasIssues) {
+    logger.warning(issuesSummary.summary);
+    logger.info(`Detailed report saved to: ${doctorResult.reportPath}`);
+
+    let shouldContinue = Boolean(options.yes);
+
+    if (!shouldContinue && isInteractive) {
+      const continueAnswer = await prompt([
+        {
+          type: 'confirm',
+          name: 'continue',
+          message: 'Issues found. Do you want to continue anyway?',
+          default: false,
+        },
+      ]);
+      shouldContinue = continueAnswer.continue;
+    }
+
+    if (!shouldContinue) {
+      logger.info('Aborted by user');
+      return;
+    }
+  } else {
+    logger.success('Health check passed!');
+  }
+
+  console.log('');
+
+  // Step 2: Clean everything
+  logger.info('Step 2: Cleaning caches and dependencies...');
+  const bundleId = await cleaner.getBundleId();
+
+  await cleaner.killRunningApps(bundleId, platform);
+  await cleaner.cleanWatchman();
+  await cleaner.cleanCaches();
+  await cleaner.deleteNativeFolders(platform);
+  await cleaner.cleanDependencies();
+
+  console.log('');
+
+  // Step 3: Reinstall dependencies
+  logger.info('Step 3: Reinstalling dependencies...');
+  await cleaner.reinstallDependencies();
+
+  console.log('');
+
+  // Step 4: Rebuild native code
+  logger.info('Step 4: Rebuilding native code...');
+  await cleaner.rebuildNative(platform);
+
+  console.log('');
+
+  // Step 5: Run development build
+  logger.info('Step 5: Starting development build...');
+
+  try {
+    const runWithDeviceSelection = async (targetPlatform) => {
+      if (options.device) {
+        // Expo CLI will prompt to choose among available emulators/simulators and connected devices.
+        execFileSync('npx', ['expo', `run:${targetPlatform}`, '--device'], { stdio: 'inherit' });
+        return;
+      }
+
+      if (targetPlatform === 'android') {
+        execSync('bun run android || npm run android || yarn android', { stdio: 'inherit' });
+        return;
+      }
+
+      if (targetPlatform === 'ios') {
+        execSync('bun run ios || npm run ios || yarn ios', { stdio: 'inherit' });
+        return;
+      }
+    };
+
+    if (platform === 'android') {
+      await runWithDeviceSelection('android');
+    } else if (platform === 'ios') {
+      await runWithDeviceSelection('ios');
+    } else {
+      // For 'all', run Android first, then iOS
+      logger.info('Building Android first...');
+      await runWithDeviceSelection('android');
+      logger.info('Now building iOS...');
+      await runWithDeviceSelection('ios');
+    }
+
+    logger.success('✅ Development build completed!');
+  } catch (e) {
+    console.log('');
+    logger.error('Failed to start development build');
+
+    // Provide helpful error messages based on common issues
+    // Note: Since we use stdio: 'inherit', the actual error output is already shown
+    // We check the error code and provide context-specific help
+    const errorCode = e.status || e.code;
+    const errorMessage = (e.message || e.toString()).toLowerCase();
+
+    // Check if it's a device/emulator issue (common exit codes: 1 for command errors)
+    if (errorCode === 1 || errorMessage.includes('device') || errorMessage.includes('emulator')) {
+      if (platform === 'android' || platform === 'all') {
+        console.log('');
+        logger.warning('No Android device or emulator found.');
+        console.log('');
+        logger.info('To fix this:');
+        logger.info('  1. Connect an Android device via USB and enable USB debugging');
+        logger.info('  2. Or start an Android emulator from Android Studio');
+        logger.info(
+          '  3. Or create an emulator: https://docs.expo.dev/workflow/android-studio-emulator'
+        );
+        console.log('');
+        logger.info('Once a device is available, you can run:');
+        logger.info('  budexp dev --android');
+      } else if (platform === 'ios') {
+        console.log('');
+        logger.warning('No iOS simulator found.');
+        console.log('');
+        logger.info('To fix this:');
+        logger.info('  1. Open Xcode and start a simulator');
+        logger.info('  2. Or run: xcrun simctl list devices');
+        logger.info('  3. Or create a simulator in Xcode: Xcode > Window > Devices and Simulators');
+        console.log('');
+        logger.info('Once a simulator is available, you can run:');
+        logger.info('  budexp dev --ios');
+      }
+    } else {
+      console.log('');
+      logger.warning('Build failed. Check the error messages above for details.');
+    }
+
+    console.log('');
+    logger.info('Note: All cleanup and setup steps completed successfully.');
+    logger.info('The project is ready - you just need a device/emulator to run the build.');
+    console.log('');
+
+    // Exit gracefully instead of throwing
+    process.exit(1);
+  }
+}
+
+module.exports = devCommand;