@jetstart/cli 1.6.0 → 2.0.0

package/.eslintrc.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../.eslintrc.json",
-  "parserOptions": {
-    "project": ["./tsconfig.json", "./tsconfig.tests.json"]
-  }
-}

package/src/cli.ts

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * CLI Entry Point
- * Defines all commands and handles command execution
- */
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { createCommand } from './commands/create';
-import { devCommand } from './commands/dev';
-import { buildCommand } from './commands/build';
-import { logsCommand } from './commands/logs';
-import { installAuditCommand } from './commands/install-audit';
-import { androidEmulatorCommand } from './commands/android-emulator';
-import { JETSTART_VERSION } from '@jetstart/shared';
-import {version} from '../package.json';
-const program = new Command();
-
-program
-  .name('jetstart')
-  .description('Fast, wireless Android development with Kotlin and Jetpack Compose')
-  .version(version || JETSTART_VERSION);
-
-// Create command
-program
-  .command('create <name>')
-  .description('Create a new JetStart project')
-  .option('-p, --package <name>', 'Package name (e.g., com.example.app)')
-  .option('-t, --template <name>', 'Template to use', 'default')
-  .option('--skip-install', 'Skip npm install')
-  .option('--full-install', 'Automatically install all required Android dependencies')
-  .action(createCommand);
-
-// Dev command
-program
-  .command('dev')
-  .description('Start development server')
-  .option('-p, --port <port>', 'Port for dev server', '8765')
-  .option('-H, --host <host>', 'Host address (defaults to auto-detected network IP)')
-  .option('--no-qr', 'Do not show QR code')
-  .option('--no-open', 'Do not open browser')
-  .option('--web', 'Open Web Emulator automatically')
-  .option('--emulator', 'Deploy to running Android emulator')
-  .option('--avd <name>', 'Target specific emulator by name')
-  .action(devCommand);
-
-// Build command
-program
-  .command('build')
-  .description('Build production APK')
-  .option('-o, --output <path>', 'Output directory', './build')
-  .option('-r, --release', 'Build release version', false)
-  .option('--sign', 'Sign the APK')
-  .action(buildCommand);
-
-// Logs command
-program
-  .command('logs')
-  .description('Stream application logs')
-  .option('-f, --follow', 'Follow log output', true)
-  .option('-l, --level <level>', 'Filter by log level')
-  .option('-s, --source <source>', 'Filter by log source')
-  .option('-n, --lines <number>', 'Number of lines to show', '100')
-  .action(logsCommand);
-
-// Install audit command
-program
-  .command('install-audit')
-  .description('Audit installation of required tools and dependencies')
-  .option('--json', 'Output results in JSON format')
-  .action(installAuditCommand);
-
-// Android emulator command
-program
-  .command('android-emulator')
-  .description('Manage Android emulators (AVDs)')
-  .action(androidEmulatorCommand);
-
-// Error handling
-program.on('command:*', (operands) => {
-  console.error(chalk.red(`Error: Unknown command '${operands[0]}'`));
-  console.log(chalk.yellow('\nRun "jetstart --help" for available commands'));
-  process.exit(1);
-});
-
-// Handle errors gracefully
-process.on('unhandledRejection', (err: Error) => {
-  console.error(chalk.red('Unhandled error:'), err.message);
-  process.exit(1);
-});
-
-// Parse arguments
-program.parse(process.argv);
-
-// Show help if no command provided
-if (!process.argv.slice(2).length) {
-  program.outputHelp();
-}

package/src/commands/android-emulator.ts

@@ -1,304 +0,0 @@
-/**
- * Android emulator management command
- */
-
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { createAVDManager } from '../utils/emulator';
-import { error as logError, success, info, warning } from '../utils/logger';
-
-/**
- * Display list of AVDs
- */
-async function handleListAVDs(): Promise<void> {
-  const avdManager = createAVDManager();
-
-  const avds = await avdManager.listAVDs();
-
-  if (avds.length === 0) {
-    console.log();
-    warning('No Android emulators found.');
-    console.log();
-
-    const { shouldCreate } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldCreate',
-        message: 'Would you like to create a JetStart-optimized emulator?',
-        default: true,
-      },
-    ]);
-
-    if (shouldCreate) {
-      await handleCreateJetStartAVD();
-    }
-    return;
-  }
-
-  console.log();
-  console.log(chalk.bold('Available Android Virtual Devices:'));
-  console.log('━'.repeat(70));
-  console.log();
-
-  for (const avd of avds) {
-    const statusIcon = avd.running ? chalk.green('✓') : chalk.gray('○');
-    const statusText = avd.running ? chalk.green('(Running)') : '';
-
-    console.log(`  ${statusIcon} ${chalk.bold(avd.name)} ${statusText}`);
-    console.log(`    - Device: ${avd.device || 'Unknown'}`);
-    console.log(`    - Target: ${avd.target || 'Unknown'}`);
-    if (avd.basedOn) {
-      console.log(`    - Based on: ${avd.basedOn}`);
-    }
-    console.log();
-  }
-}
-
-/**
- * Start an emulator
- */
-async function handleStartEmulator(): Promise<void> {
-  const avdManager = createAVDManager();
-  const avds = await avdManager.listAVDs();
-
-  if (avds.length === 0) {
-    warning('No emulators available. Create one first.');
-    return;
-  }
-
-  // Filter out running emulators
-  const availableAVDs = avds.filter((avd) => !avd.running);
-
-  if (availableAVDs.length === 0) {
-    info('All emulators are already running.');
-    return;
-  }
-
-  const { avdName } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'avdName',
-      message: 'Select emulator to start:',
-      choices: availableAVDs.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
-    },
-  ]);
-
-  await avdManager.startEmulator({ avdName });
-}
-
-/**
- * Stop an emulator
- */
-async function handleStopEmulator(): Promise<void> {
-  const avdManager = createAVDManager();
-  const avds = await avdManager.listAVDs();
-
-  // Filter running emulators
-  const runningAVDs = avds.filter((avd) => avd.running);
-
-  if (runningAVDs.length === 0) {
-    warning('No emulators are currently running.');
-    return;
-  }
-
-  const { avdName } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'avdName',
-      message: 'Select emulator to stop:',
-      choices: runningAVDs.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
-    },
-  ]);
-
-  await avdManager.stopEmulator(avdName);
-}
-
-/**
- * Create JetStart-optimized AVD
- */
-async function handleCreateJetStartAVD(): Promise<void> {
-  const avdManager = createAVDManager();
-
-  try {
-    await avdManager.createJetStartAVD();
-  } catch (err: any) {
-    logError(`Failed to create AVD: ${err.message}`);
-  }
-}
-
-/**
- * Create custom AVD
- */
-async function handleCreateCustomAVD(): Promise<void> {
-  const avdManager = createAVDManager();
-
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'name',
-      message: 'Enter AVD name:',
-      default: 'my-android-emulator',
-      validate: (input: string) => {
-        if (!input || input.trim().length === 0) {
-          return 'Name cannot be empty';
-        }
-        if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
-          return 'Name can only contain letters, numbers, hyphens, and underscores';
-        }
-        return true;
-      },
-    },
-    {
-      type: 'list',
-      name: 'device',
-      message: 'Select device profile:',
-      choices: [
-        { name: 'Pixel 5', value: 'pixel_5' },
-        { name: 'Pixel 6', value: 'pixel_6' },
-        { name: 'Pixel 8', value: 'pixel_8' },
-        { name: 'Nexus 5', value: 'Nexus 5' },
-      ],
-      default: 'pixel_5',
-    },
-    {
-      type: 'list',
-      name: 'apiLevel',
-      message: 'Select API level:',
-      choices: [
-        { name: 'API 34 (Android 14) - Recommended', value: 34 },
-        { name: 'API 33 (Android 13)', value: 33 },
-        { name: 'API 31 (Android 12)', value: 31 },
-        { name: 'API 29 (Android 10)', value: 29 },
-        { name: 'API 24 (Android 7.0) - Minimum', value: 24 },
-      ],
-      default: 34,
-    },
-    {
-      type: 'list',
-      name: 'abi',
-      message: 'Select ABI (architecture):',
-      choices: [
-        { name: 'x86_64 (Intel/AMD 64-bit)', value: 'x86_64' },
-        { name: 'arm64-v8a (ARM 64-bit)', value: 'arm64-v8a' },
-      ],
-      default: process.arch === 'arm64' ? 'arm64-v8a' : 'x86_64',
-    },
-  ]);
-
-  try {
-    await avdManager.createAVD({
-      name: answers.name,
-      device: answers.device,
-      apiLevel: answers.apiLevel,
-      abi: answers.abi,
-    });
-  } catch (err: any) {
-    logError(`Failed to create AVD: ${err.message}`);
-  }
-}
-
-/**
- * Delete an AVD
- */
-async function handleDeleteAVD(): Promise<void> {
-  const avdManager = createAVDManager();
-  const avds = await avdManager.listAVDs();
-
-  if (avds.length === 0) {
-    warning('No emulators available to delete.');
-    return;
-  }
-
-  const { avdName } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'avdName',
-      message: 'Select emulator to delete:',
-      choices: avds.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
-    },
-  ]);
-
-  const { confirm } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'confirm',
-      message: `Are you sure you want to delete "${avdName}"?`,
-      default: false,
-    },
-  ]);
-
-  if (confirm) {
-    await avdManager.deleteAVD(avdName);
-  } else {
-    info('Deletion cancelled');
-  }
-}
-
-/**
- * Android emulator command handler
- */
-export async function androidEmulatorCommand(): Promise<void> {
-  try {
-    console.log();
-    console.log(chalk.cyan.bold('  JetStart Android Emulator Manager'));
-    console.log();
-
-    let running = true;
-
-    while (running) {
-      const { action } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'action',
-          message: 'What would you like to do?',
-          choices: [
-            { name: 'List existing emulators', value: 'list' },
-            { name: 'Start emulator', value: 'start' },
-            { name: 'Stop emulator', value: 'stop' },
-            new inquirer.Separator(),
-            { name: 'Create JetStart-optimized emulator', value: 'create-jetstart' },
-            { name: 'Create custom emulator', value: 'create-custom' },
-            { name: 'Delete emulator', value: 'delete' },
-            new inquirer.Separator(),
-            { name: 'Exit', value: 'exit' },
-          ],
-        },
-      ]);
-
-      switch (action) {
-        case 'list':
-          await handleListAVDs();
-          break;
-        case 'start':
-          await handleStartEmulator();
-          break;
-        case 'stop':
-          await handleStopEmulator();
-          break;
-        case 'create-jetstart':
-          await handleCreateJetStartAVD();
-          break;
-        case 'create-custom':
-          await handleCreateCustomAVD();
-          break;
-        case 'delete':
-          await handleDeleteAVD();
-          break;
-        case 'exit':
-          running = false;
-          console.log();
-          success('Goodbye!');
-          console.log();
-          break;
-      }
-
-      if (running && action !== 'list') {
-        console.log();
-      }
-    }
-  } catch (err: any) {
-    console.log();
-    logError(`Emulator management failed: ${err.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/build.ts

@@ -1,60 +0,0 @@
-/**
- * Build Command
- * Builds production APK
- */
-
-import path from 'path';
-import chalk from 'chalk';
-import { log, success, error, info } from '../utils/logger';
-import { startSpinner, stopSpinner } from '../utils/spinner';
-import { BuildType } from '@jetstart/shared';
-
-interface BuildOptions {
-  output?: string;
-  release?: boolean;
-  sign?: boolean;
-}
-
-export async function buildCommand(options: BuildOptions) {
-  try {
-    const buildType = options.release ? BuildType.RELEASE : BuildType.DEBUG;
-    const outputDir = options.output || './build';
-
-    log(`Building ${buildType} APK...`);
-    console.log();
-
-    // Validate project
-    const spinner = startSpinner('Validating project...');
-    await new Promise(resolve => setTimeout(resolve, 500));
-    stopSpinner(spinner, true, 'Project validated');
-
-    // Compile Kotlin
-    const compileSpinner = startSpinner('Compiling Kotlin sources...');
-    await new Promise(resolve => setTimeout(resolve, 2000));
-    stopSpinner(compileSpinner, true, 'Kotlin compiled');
-
-    // Package APK
-    const packageSpinner = startSpinner('Packaging APK...');
-    await new Promise(resolve => setTimeout(resolve, 1500));
-    stopSpinner(packageSpinner, true, 'APK packaged');
-
-    // Sign APK (if release)
-    if (options.release && options.sign) {
-      const signSpinner = startSpinner('Signing APK...');
-      await new Promise(resolve => setTimeout(resolve, 800));
-      stopSpinner(signSpinner, true, 'APK signed');
-    }
-
-    console.log();
-    success('Build completed successfully!');
-    console.log();
-    info(`Output: ${chalk.cyan(path.resolve(outputDir))}`);
-    info(`Size: ${chalk.cyan('5.2 MB')}`);
-    info(`Type: ${chalk.cyan(buildType)}`);
-    console.log();
-
-  } catch (err: any) {
-    error(`Build failed: ${err.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/create.ts

@@ -1,232 +0,0 @@
-/**
- * Create Command
- * Scaffolds a new JetStart project
- */
-
-import path from 'path';
-import fs from 'fs-extra';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { log, success, error, info, warning } from '../utils/logger';
-import { startSpinner, stopSpinner } from '../utils/spinner';
-import { prompt } from '../utils/prompt';
-import { generateProjectTemplate } from '../utils/template';
-import { isValidProjectName, isValidPackageName } from '@jetstart/shared';
-import { CreateOptions } from '../types';
-import { detectJava, installJava, isJavaCompatible } from '../utils/java';
-import { createSDKManager, REQUIRED_SDK_COMPONENTS } from '../utils/android-sdk';
-import { findAndroidSDK } from '../utils/system-tools';
-
-/**
- * Run full installation (automated mode)
- */
-async function runFullInstallation(): Promise<void> {
-  info('Starting full automated installation...');
-  console.log();
-
-  // 1. Check and install Java
-  const java = await detectJava();
-  if (!java || !(await isJavaCompatible(java.version))) {
-    await installJava();
-  } else {
-    success(`Java ${java.version} already installed`);
-  }
-
-  // 2. Check and install Android SDK
-  const sdkManager = createSDKManager();
-  const sdkRoot = await findAndroidSDK();
-
-  if (!sdkRoot) {
-    info('Installing Android SDK components...');
-    await sdkManager.installCmdlineTools();
-  } else {
-    success(`Android SDK found at ${sdkRoot}`);
-  }
-
-  // 3. Install required SDK components
-  for (const component of REQUIRED_SDK_COMPONENTS) {
-    await sdkManager.installComponent(component);
-  }
-
-  console.log();
-  success('All dependencies installed successfully!');
-  console.log();
-}
-
-/**
- * Run interactive installation
- */
-async function runInteractiveInstallation(): Promise<void> {
-  info('Checking dependencies...');
-  console.log();
-
-  // Check Java
-  const java = await detectJava();
-  if (!java || !(await isJavaCompatible(java.version))) {
-    const { shouldInstall } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldInstall',
-        message: 'Java 17+ not found. Would you like to install it?',
-        default: true,
-      },
-    ]);
-
-    if (shouldInstall) {
-      await installJava();
-    } else {
-      warning('Java installation skipped. You may need to install it manually.');
-    }
-  } else {
-    success(`Java ${java.version} detected`);
-  }
-
-  // Check Android SDK
-  const sdkRoot = await findAndroidSDK();
-  if (!sdkRoot) {
-    const { shouldInstall } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldInstall',
-        message: 'Android SDK not found. Would you like to install it?',
-        default: true,
-      },
-    ]);
-
-    if (shouldInstall) {
-      const sdkManager = createSDKManager();
-      await sdkManager.installCmdlineTools();
-
-      // Ask about components
-      const { installComponents } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'installComponents',
-          message: 'Install required SDK components?',
-          default: true,
-        },
-      ]);
-
-      if (installComponents) {
-        for (const component of REQUIRED_SDK_COMPONENTS) {
-          await sdkManager.installComponent(component);
-        }
-      }
-    } else {
-      warning('Android SDK installation skipped. Project creation may fail without SDK.');
-    }
-  } else {
-    success(`Android SDK found at ${sdkRoot}`);
-  }
-
-  console.log();
-}
-
-export async function createCommand(name: string, options: CreateOptions) {
-  try {
-    // Validate project name
-    if (!isValidProjectName(name)) {
-      error('Invalid project name. Use letters, numbers, hyphens, and underscores only.');
-      error('Project name must start with a letter and be 1-64 characters long.');
-      process.exit(1);
-    }
-
-    const projectPath = path.resolve(process.cwd(), name);
-
-    // Check if directory already exists
-    if (await fs.pathExists(projectPath)) {
-      error(`Directory '${name}' already exists!`);
-      process.exit(1);
-    }
-
-    log(`Creating JetStart project: ${chalk.cyan(name)}`);
-    console.log();
-
-    // Run installation if requested
-    if (options.fullInstall) {
-      await runFullInstallation();
-    } else {
-      // Interactive mode: ask user
-      const { shouldCheckDeps } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'shouldCheckDeps',
-          message: 'Check and install dependencies?',
-          default: true,
-        },
-      ]);
-
-      if (shouldCheckDeps) {
-        await runInteractiveInstallation();
-      }
-    }
-
-    // Get package name
-    let packageName = options.package;
-    if (!packageName) {
-      const defaultPackage = `com.jetstart.${name.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
-      const answer = await prompt({
-        type: 'input',
-        name: 'packageName',
-        message: 'Package name:',
-        default: defaultPackage,
-        validate: (input: string) => {
-          if (!isValidPackageName(input)) {
-            return 'Invalid package name. Use format: com.company.app';
-          }
-          return true;
-        },
-      });
-      packageName = answer.packageName;
-    }
-
-    // Validate package name
-    if (!isValidPackageName(packageName!)) {
-      error('Invalid package name. Use format: com.company.app');
-      process.exit(1);
-    }
-
-    // Create project structure
-    const spinner = startSpinner('Creating project structure...');
-
-    try {
-      await fs.ensureDir(projectPath);
-
-      // Generate project files
-      await generateProjectTemplate(projectPath, {
-        projectName: name,
-        packageName: packageName!,
-        template: options.template || 'default',
-      });
-
-      stopSpinner(spinner, true, 'Project structure created');
-
-      // Install dependencies
-      if (!options.skipInstall) {
-        const installSpinner = startSpinner('Installing dependencies...');
-        
-        // In a real implementation, we'd run npm/gradle here
-        // For now, we'll simulate it
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
-        stopSpinner(installSpinner, true, 'Dependencies installed');
-      }
-
-      console.log();
-      success(`Successfully created project: ${chalk.cyan(name)}`);
-      console.log();
-      console.log(chalk.bold('Next steps:'));
-      console.log(`  ${chalk.cyan('cd')} ${name}`);
-      console.log(`  ${chalk.cyan('jetstart dev')}`);
-      console.log();
-
-    } catch (err: any) {
-      stopSpinner(spinner, false, 'Failed to create project');
-      throw err;
-    }
-
-  } catch (err: any) {
-    error(`Failed to create project: ${err.message}`);
-    process.exit(1);
-  }
-}