andrud 1.0.0

package/src/cli/commands/init.ts

@@ -0,0 +1,186 @@
+/**
+ * Init project command - initialize Android project in current directory
+ */
+
+import {
+  select,
+  text,
+  confirm,
+  isCancel,
+  cancel
+} from '@clack/prompts';
+import {
+  printWelcome,
+  printSuccess,
+  printError,
+  printSection,
+  printKeyValue,
+  printGoodbye
+} from '../../ui/output.js';
+import { validatePackageStructure } from '../../utils/validation.js';
+import { generateProject } from '../../core/generator.js';
+import { buildDefaultProjectContext, buildTemplateContext } from '../../core/context.js';
+import { getCurrentWorkingDirectory } from '../../utils/filesystem.js';
+import { getTemplateMetadata, getAllTemplates } from '../../templates/index.js';
+import pc from 'picocolors';
+import type { TemplateType } from '../../core/types.js';
+
+interface InitCommandOptions {
+  force: boolean;
+  template?: string;
+}
+
+/**
+ * Initialize Android project in current directory
+ */
+export async function createInitCommand(
+  _options: InitCommandOptions,
+  args?: { template?: string }
+): Promise<void> {
+  try {
+    printWelcome();
+
+    const cwd = getCurrentWorkingDirectory();
+    const projectName = cwd.split(/[\\/]/).pop() ?? 'MyApp';
+
+    printSection('Initialize Android Project');
+    console.log(`Current directory: ${pc.cyan(cwd)}`);
+    console.log('');
+
+    // Get templates
+    const templates = getAllTemplates();
+
+    // Step 1: Select template
+    let selectedTemplate: string;
+    if (args?.template) {
+      const meta = getTemplateMetadata(args.template as TemplateType);
+      if (!meta) {
+        printError(`Unknown template: ${args.template}`);
+        return;
+      }
+      selectedTemplate = args.template;
+    } else {
+      const templateOptions = templates.map(t => ({
+        label: t.name,
+        value: t.id,
+        hint: t.keywords.slice(0, 2).join(', ')
+      }));
+
+      const templateResult = await select({
+        message: '? Select a project template',
+        options: templateOptions
+      });
+
+      if (isCancel(templateResult)) {
+        cancel();
+        return;
+      }
+
+      selectedTemplate = templateResult as string;
+    }
+
+    // Step 2: Get package name
+    const defaultPackage = `com.example.${projectName.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+    const packageResult = await text({
+      message: '? What is the package name?',
+      placeholder: 'com.example.myapp',
+      defaultValue: defaultPackage,
+      validate: (value: string) => {
+        const result = validatePackageStructure(value);
+        if (!result.valid) {
+          return result.errors[0];
+        }
+        return undefined;
+      }
+    });
+
+    if (isCancel(packageResult)) {
+      cancel();
+      return;
+    }
+
+    const packageName = packageResult as string;
+    const validation = validatePackageStructure(packageName);
+    if (!validation.valid) {
+      printError('Invalid package name', validation.errors.join(', '));
+      return;
+    }
+
+    // Confirm initialization
+    const confirmInit = await confirm({
+      message: `? Initialize Android project in ${cwd}?`,
+      initialValue: true
+    });
+
+    if (isCancel(confirmInit)) {
+      cancel();
+      return;
+    }
+
+    if (!confirmInit) {
+      console.log('Initialization cancelled.');
+      return;
+    }
+
+    // Build context
+    const baseContext = buildDefaultProjectContext(
+      projectName,
+      packageName,
+      cwd,
+      selectedTemplate as TemplateType,
+      {
+        git: true,
+        readme: true,
+        androidX: true,
+        kotlinDsl: true
+      }
+    );
+
+    const context = buildTemplateContext({
+      appName: baseContext.appName,
+      packageName: baseContext.packageName,
+      projectDirectory: baseContext.projectDirectory,
+      template: baseContext.template,
+      uiFramework: baseContext.uiFramework,
+      language: baseContext.language,
+      android: baseContext.android,
+      gradle: baseContext.gradle,
+      features: baseContext as unknown as Record<string, boolean>,
+      nativeCpp: baseContext.nativeCpp
+    });
+
+    // Generate project
+    printSection('Generating Project');
+
+    const result = await generateProject(context, {
+      overwrite: true,
+      dryRun: false,
+      skipInstall: false,
+      verbose: false
+    });
+
+    if (result.success) {
+      printSuccess('Project initialized successfully!');
+      printKeyValue([
+        { key: 'Package', value: packageName },
+        { key: 'Template', value: selectedTemplate },
+        { key: 'Location', value: cwd },
+        { key: 'Files created', value: result.generatedFiles.length.toString() }
+      ]);
+
+      printGoodbye(true);
+    } else {
+      printError('Project initialization failed');
+      if (result.errors.length > 0) {
+        result.errors.forEach(err => {
+          console.log(`  ${pc.red('•')} ${err.file ? `${err.file}: ` : ''}${err.message}`);
+        });
+      }
+      printGoodbye(false);
+    }
+  } catch (error) {
+    printError('An unexpected error occurred', (error as Error).message);
+    printGoodbye(false);
+    process.exit(1);
+  }
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,156 @@
+/**
+ * List templates command - shows all available templates
+ */
+
+import { gradientTeen, bold, primary, muted } from '../../ui/colors.js';
+import { printSection } from '../../ui/output.js';
+import { getAllTemplates, getTemplatePreview, searchTemplates } from '../../templates/index.js';
+import { TEMPLATE_CONFIGS } from '../../core/config.js';
+import pc from 'picocolors';
+import type { TemplateType, TemplateMetadata } from '../../core/types.js';
+
+interface ListCommandOptions {
+  json: boolean;
+  search?: string;
+}
+
+/**
+ * List all available templates
+ */
+export async function createListCommand(
+  options: ListCommandOptions = { json: false }
+): Promise<void> {
+  // Validate search input
+  if (options.search && typeof options.search !== 'string') {
+    console.log(pc.red('Error: Search query must be a string'));
+    return;
+  }
+
+  if (options.search && options.search.length > 100) {
+    console.log(pc.red('Error: Search query is too long (maximum 100 characters)'));
+    return;
+  }
+
+  // Filter templates based on search
+  const templates = options.search?.trim()
+    ? searchTemplates(options.search.trim())
+    : getAllTemplates();
+
+  if (options.json) {
+    const templateList = templates.map(t => ({
+      id: t.id,
+      name: t.name,
+      description: t.description,
+      language: TEMPLATE_CONFIGS[t.id]?.language === 'kotlin' ? 'Kotlin' : 'Java',
+      uiFramework: TEMPLATE_CONFIGS[t.id]?.uiFramework === 'compose' ? 'Compose' : 'XML'
+    }));
+    console.log(JSON.stringify(templateList, null, 2));
+    return;
+  }
+
+  if (templates.length === 0) {
+    console.log(pc.yellow('No templates found.'));
+    return;
+  }
+
+  console.log('');
+  console.log(gradientTeen('╔══════════════════════════════════════════════════════════════╗'));
+  console.log(gradientTeen('║                    Android Project Templates                   ║'));
+  console.log(gradientTeen('╚══════════════════════════════════════════════════════════════╝'));
+  console.log('');
+
+  templates.forEach((template, index) => {
+    printTemplateCard(template, index + 1);
+  });
+
+  // Summary
+  printSection('Summary');
+  console.log(`  Total templates: ${bold(templates.length.toString())}`);
+  console.log(`  Kotlin templates: ${bold(
+    templates.filter(t => TEMPLATE_CONFIGS[t.id]?.language === 'kotlin').length.toString()
+  )}`);
+  console.log(`  Java templates: ${bold(
+    templates.filter(t => TEMPLATE_CONFIGS[t.id]?.language === 'java').length.toString()
+  )}`);
+  console.log(`  Compose templates: ${bold(
+    templates.filter(t => TEMPLATE_CONFIGS[t.id]?.uiFramework === 'compose').length.toString()
+  )}`);
+  console.log('');
+
+  console.log(muted('  Use ') + primary('andrud info <template>') + muted(' for more details'));
+  console.log('');
+}
+
+/**
+ * Print a template as a card
+ */
+function printTemplateCard(template: TemplateMetadata, number: number): void {
+  const config = TEMPLATE_CONFIGS[template.id];
+  if (!config) return;
+
+  const isKotlin = config.language === 'kotlin';
+  const isCompose = config.uiFramework === 'compose';
+
+  // Template header
+  console.log(primary(`  ${number}. `) + bold(template.name));
+  console.log(`    ${template.description}`);
+  console.log('');
+
+  // Tags
+  const tags: string[] = [];
+  tags.push(isKotlin ? pc.green('Kotlin') : pc.yellow('Java'));
+  tags.push(isCompose ? pc.cyan('Compose') : pc.gray('XML'));
+  if (template.id === 'native-cpp') {
+    tags.push(pc.magenta('NDK'));
+  }
+  console.log(`    ${tags.join('  ')}`);
+
+  // Key features
+  const features = template.features.slice(0, 3);
+  console.log(`    ${muted('Features:')} ${features.join(pc.gray(', '))}`);
+
+  // Version info
+  console.log(`    ${muted('Gradle:')} ${config.gradleVersion}  ${muted('AGP:')} ${config.agpVersion}`);
+
+  // Command example
+  console.log('');
+  console.log(`    ${muted('Run:')} ${primary(`andrud new MyApp -t ${template.id}`)}`);
+
+  // Code preview snippet
+  const preview = getTemplatePreview(template.id);
+  if (preview) {
+    const lines = preview.split('\n').slice(0, 4);
+    console.log('');
+    console.log('    ' + pc.gray('┌─ Code preview'));
+    lines.forEach((line, i) => {
+      const isLast = i === lines.length - 1;
+      const prefix = isLast ? '    ' : '    ';
+      const linePrefix = isLast ? '└─' : '│ ';
+      console.log(prefix + pc.gray(linePrefix) + pc.dim(line.substring(0, 50) + (line.length > 50 ? '...' : '')));
+    });
+  }
+
+  console.log('');
+  console.log(pc.gray('    ' + '─'.repeat(60)));
+  console.log('');
+}
+
+/**
+ * Print templates as a compact list
+ */
+export function printTemplateList(templates: TemplateMetadata[]): void {
+  const maxIdLength = Math.max(...templates.map(t => t.id.length));
+  const maxNameLength = Math.max(...templates.map(t => t.name.length));
+
+  templates.forEach((t, i) => {
+    const config = TEMPLATE_CONFIGS[t.id];
+    if (!config) return;
+
+    const id = t.id.padEnd(maxIdLength);
+    const name = t.name.padEnd(maxNameLength);
+    const lang = config.language === 'kotlin' ? pc.green('K') : pc.yellow('J');
+    const ui = config.uiFramework === 'compose' ? pc.cyan('C') : pc.gray('X');
+
+    console.log(`  ${primary(String(i + 1).padStart(2))} ${bold(id)}  ${name}  ${lang}${ui}  ${muted(t.description.substring(0, 40))}`);
+  });
+}

package/src/cli/commands/new.ts

@@ -0,0 +1,316 @@
+/**
+ * New project creation command with interactive prompts
+ */
+
+import {
+  select,
+  text,
+  multiselect,
+  confirm,
+  isCancel,
+  cancel
+} from '@clack/prompts';
+import {
+  printWelcome,
+  printSuccess,
+  printError,
+  printSection,
+  printKeyValue,
+  printGoodbye,
+  printSteps
+} from '../../ui/output.js';
+import { gradientTeen } from '../../ui/colors.js';
+import { validateAppName, validatePackageStructure, validateDirectoryPath } from '../../utils/validation.js';
+import { generateProject } from '../../core/generator.js';
+import { buildDefaultProjectContext, buildTemplateContext } from '../../core/context.js';
+import { exists, getCurrentWorkingDirectory } from '../../utils/filesystem.js';
+import { getTemplateMetadata, getAllTemplates } from '../../templates/index.js';
+import pc from 'picocolors';
+import type { TemplateType } from '../../core/types.js';
+
+interface NewCommandOptions {
+  name?: string;
+  template?: string;
+  packageName?: string;
+  directory?: string;
+  minSdk?: number;
+  targetSdk?: number;
+  force?: boolean;
+  skipInstall?: boolean;
+  git?: boolean;
+  kotlin?: boolean;
+  verbose?: boolean;
+}
+
+/**
+ * Create a new Android project
+ */
+export async function createNewCommand(
+  name?: string,
+  options: NewCommandOptions = {}
+): Promise<void> {
+  try {
+    // Print welcome banner
+    printWelcome();
+
+    // Get all available templates
+    const templates = getAllTemplates();
+
+    // Step 1: Select template
+    let selectedTemplate: string;
+    if (options.template) {
+      const meta = getTemplateMetadata(options.template as TemplateType);
+      if (!meta) {
+        printError(`Unknown template: ${options.template}`);
+        console.log('Available templates:');
+        templates.forEach(t => console.log(`  - ${t.id}`));
+        return;
+      }
+      selectedTemplate = options.template;
+    } else {
+      const templateOptions = templates.map(t => ({
+        label: `${t.name}`,
+        value: t.id,
+        hint: t.keywords.slice(0, 2).join(', ')
+      }));
+
+      const templateResult = await select({
+        message: '? Select a project template',
+        options: templateOptions
+      });
+
+      if (isCancel(templateResult)) {
+        cancel();
+        return;
+      }
+
+      selectedTemplate = templateResult as string;
+    }
+
+    printSection(`Template: ${selectedTemplate}`);
+
+    // Step 2: Get app name
+    let appName: string;
+    if (name) {
+      const validation = validateAppName(name);
+      if (!validation.valid) {
+        printError('Invalid app name', validation.errors.join(', '));
+        return;
+      }
+      appName = validation.normalized ?? name;
+    } else {
+      const nameResult = await text({
+        message: '? What is the app name?',
+        placeholder: 'MyAwesomeApp',
+        defaultValue: 'MyAwesomeApp',
+        validate: (value: string) => {
+          const result = validateAppName(value);
+          if (!result.valid) {
+            return result.errors[0];
+          }
+          return undefined;
+        }
+      });
+
+      if (isCancel(nameResult)) {
+        cancel();
+        return;
+      }
+
+      const validation = validateAppName(nameResult as string);
+      if (!validation.valid) {
+        printError('Invalid app name', validation.errors.join(', '));
+        return;
+      }
+      appName = validation.normalized ?? (nameResult as string);
+    }
+
+    // Step 3: Get package name
+    let packageName: string;
+    if (options.packageName) {
+      const validation = validatePackageStructure(options.packageName);
+      if (!validation.valid) {
+        printError('Invalid package name', validation.errors.join(', '));
+        return;
+      }
+      packageName = options.packageName;
+    } else {
+      // Generate default package name from app name
+      const defaultPackage = `com.example.${appName.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+
+      const packageResult = await text({
+        message: '? What is the package name?',
+        placeholder: 'com.example.myapp',
+        defaultValue: defaultPackage,
+        validate: (value: string) => {
+          const result = validatePackageStructure(value);
+          if (!result.valid) {
+            return result.errors[0];
+          }
+          return undefined;
+        }
+      });
+
+      if (isCancel(packageResult)) {
+        cancel();
+        return;
+      }
+
+      const validation = validatePackageStructure(packageResult as string);
+      if (!validation.valid) {
+        printError('Invalid package name', validation.errors.join(', '));
+        return;
+      }
+      packageName = packageResult as string;
+    }
+
+    // Step 4: Get project directory
+    let projectDirectory: string;
+    if (options.directory) {
+      const validation = validateDirectoryPath(options.directory);
+      if (!validation.valid) {
+        printError('Invalid directory', validation.errors.join(', '));
+        return;
+      }
+      projectDirectory = validation.normalized ?? options.directory;
+    } else {
+      const defaultDir = `./${appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+      const dirResult = await text({
+        message: '? In which directory should the project be created?',
+        placeholder: defaultDir,
+        defaultValue: defaultDir,
+        validate: (value: string) => {
+          const result = validateDirectoryPath(value);
+          if (!result.valid) {
+            return result.errors[0];
+          }
+          return undefined;
+        }
+      });
+
+      if (isCancel(dirResult)) {
+        cancel();
+        return;
+      }
+
+      const validation = validateDirectoryPath(dirResult as string);
+      if (!validation.valid) {
+        printError('Invalid directory', validation.errors.join(', '));
+        return;
+      }
+      projectDirectory = validation.normalized ?? (dirResult as string);
+    }
+
+    // Step 5: Optional features
+    const featureOptions = [
+      { label: 'Git repository', value: 'git', hint: 'Initialize with git' },
+      { label: 'README.md', value: 'readme', hint: 'Generate readme' },
+      { label: 'AndroidX libraries', value: 'androidX', hint: 'Use AndroidX (recommended)', selected: true },
+      { label: 'Kotlin DSL', value: 'kotlinDsl', hint: 'Use Kotlin DSL for Gradle', selected: true }
+    ];
+
+    const featuresResult = await multiselect({
+      message: '? Select additional features (optional)',
+      options: featureOptions,
+      required: false
+    });
+
+    if (isCancel(featuresResult)) {
+      cancel();
+      return;
+    }
+
+    const selectedFeatures = featuresResult as string[];
+    const features = {
+      git: selectedFeatures.includes('git') || options.git === true,
+      readme: selectedFeatures.includes('readme'),
+      androidX: selectedFeatures.includes('androidX'),
+      kotlinDsl: selectedFeatures.includes('kotlinDsl')
+    };
+
+    // Build context
+    const baseContext = buildDefaultProjectContext(
+      appName,
+      packageName,
+      projectDirectory,
+      selectedTemplate as TemplateType,
+      features,
+      options.minSdk,
+      options.targetSdk
+    );
+
+    const context = buildTemplateContext({
+      appName: baseContext.appName,
+      packageName: baseContext.packageName,
+      projectDirectory: baseContext.projectDirectory,
+      template: baseContext.template,
+      uiFramework: baseContext.uiFramework,
+      language: baseContext.language,
+      android: baseContext.android,
+      gradle: baseContext.gradle,
+      features: baseContext as unknown as Record<string, boolean>,
+      nativeCpp: baseContext.nativeCpp
+    });
+
+    // Check if directory exists
+    const dirExists = await exists(projectDirectory);
+    if (dirExists && !options.force) {
+      printError(
+        `Directory "${projectDirectory}" already exists`,
+        'Use --force to overwrite existing files'
+      );
+      return;
+    }
+
+    // Generate project
+    console.log('');
+    printSection('Generating Project');
+
+    const result = await generateProject(context, {
+      overwrite: options.force,
+      dryRun: false,
+      skipInstall: options.skipInstall,
+      verbose: options.verbose ?? false
+    });
+
+    if (result.success) {
+      printSuccess('Project generated successfully!');
+      printKeyValue([
+        { key: 'Project', value: appName },
+        { key: 'Package', value: packageName },
+        { key: 'Template', value: selectedTemplate },
+        { key: 'Location', value: projectDirectory },
+        { key: 'Files created', value: result.generatedFiles.length.toString() },
+        { key: 'Duration', value: `${(result.duration / 1000).toFixed(1)}s` }
+      ]);
+
+      console.log('');
+      printSteps([
+        `cd ${projectDirectory}`,
+        'Open in Android Studio: studio .',
+        'Or build from command line: ./gradlew assembleDebug'
+      ]);
+
+      printGoodbye(true);
+    } else {
+      printError('Project generation failed');
+      if (result.errors.length > 0) {
+        console.log('');
+        result.errors.forEach(err => {
+          console.log(`  ${pc.red('•')} ${err.file ? `${err.file}: ` : ''}${err.message}`);
+        });
+      }
+      printGoodbye(false);
+    }
+  } catch (error) {
+    printError('An unexpected error occurred', (error as Error).message);
+    if (process.env.DEBUG || process.env.VERBOSE) {
+      console.error(error);
+    }
+    printGoodbye(false);
+    process.exit(1);
+  }
+}
+
+// Export for use in CLI
+export type { NewCommandOptions };