andrud 1.0.0

package/src/cli/index.ts

@@ -0,0 +1,116 @@
+/**
+ * Command registration and main CLI entry point
+ */
+
+import { cac } from 'cac';
+import pc from 'picocolors';
+import { createCommand } from './commands/create.js';
+import { createNewCommand } from './commands/new.js';
+import { createInitCommand } from './commands/init.js';
+import { createInfoCommand } from './commands/info.js';
+import { createListCommand } from './commands/list.js';
+
+const pkg = { version: '1.0.0' };
+
+const cli = cac('andrud');
+
+cli.version(pkg.version);
+
+// Clean minimal help
+function printHelp(): void {
+  console.log('');
+  console.log(`  ${pc.cyan('andrud')} - Android Project Scaffolding`);
+  console.log('');
+  console.log(`  ${pc.gray('andrud create')}              Create a new project`);
+  console.log(`  ${pc.gray('andrud list')}                 Show available templates`);
+  console.log(`  ${pc.gray('andrud info <template>')}      View template details`);
+  console.log('');
+  console.log(`  ${pc.gray('andrud create MyApp')}         Create with name`);
+  console.log('');
+}
+
+// Commands
+cli
+  .command('create', 'Create a new Android project')
+  .alias('c')
+  .option('-f, --force', 'Overwrite existing files')
+  .example('andrud create')
+  .example('andrud create --force')
+  .action(createCommand);
+
+cli
+  .command('new [name]', 'Create a new project')
+  .alias('n')
+  .option('-t, --template <type>', 'Template type')
+  .option('-p, --package <name>', 'Package name')
+  .option('-f, --force', 'Overwrite')
+  .example('andrud new MyApp -t kotlin-compose')
+  .action(createNewCommand);
+
+cli
+  .command('init', 'Initialize in current directory')
+  .alias('i')
+  .option('-f, --force', 'Overwrite')
+  .example('andrud init')
+  .action(createInitCommand);
+
+cli
+  .command('info [template]', 'Show template info')
+  .example('andrud info kotlin-compose')
+  .action(createInfoCommand);
+
+cli
+  .command('list', 'List all templates')
+  .alias('ls')
+  .option('--json', 'Output as JSON')
+  .action(createListCommand);
+
+cli.on('command:!', () => {
+  console.error(pc.red(`  Unknown command. See ${pc.cyan('--help')}\n`));
+});
+
+process.on('uncaughtException', (error) => {
+  console.error(pc.red(`  ${error.message}\n`));
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  console.error(pc.red(`  ${reason}\n`));
+  process.exit(1);
+});
+
+export function runCli(): void {
+  try {
+    const args = process.argv.slice(2);
+
+    // Show help
+    if (args.includes('--help') || args.includes('-h')) {
+      printHelp();
+      return;
+    }
+
+    // Show version
+    if (args.includes('--version') || args.includes('-V')) {
+      console.log(pkg.version);
+      return;
+    }
+
+    // Quick help on no args
+    if (args.length === 0) {
+      console.log('');
+      console.log(`  ${pc.cyan('andrud')} - Create Android projects`);
+      console.log('');
+      console.log(`  ${pc.gray('andrud create')}     Start interactive setup`);
+      console.log(`  ${pc.gray('andrud --help')}     Show all commands`);
+      console.log('');
+      return;
+    }
+
+    cli.parse(process.argv, { run: true });
+  } catch (error) {
+    console.error(pc.red(`  ${(error as Error).message}\n`));
+    process.exit(1);
+  }
+}
+
+// Note: runCli() is called from bin/andrud.js

package/src/core/config.ts

@@ -0,0 +1,172 @@
+/**
+ * Configuration constants for Android and Gradle versions
+ */
+
+/**
+ * Default Android SDK configuration
+ */
+export const ANDROID_SDK_DEFAULTS = {
+  MIN_SDK: 24,
+  TARGET_SDK: 36,
+  COMPILE_SDK: 36,
+  BUILD_TOOLS_VERSION: '36.0.0'
+};
+
+/**
+ * Gradle-related versions
+ */
+export const GRADLE_VERSIONS = {
+  AGP: '8.7.3',
+  GRADLE: '8.14',
+  KOTLIN: '2.0.21',
+  COMPOSE_COMPILER: '1.5.14',
+  COMPOSE_BOM: '2024.09.03',
+  NDK: '28.2.13676358'
+};
+
+/**
+ * AndroidX library versions
+ */
+export const ANDROIDX_VERSIONS = {
+  CORE_KTX: '1.15.0',
+  APP_COMPAT: '1.7.0',
+  MATERIAL: '1.12.0',
+  LIFECYCLE: '2.8.7',
+  ACTIVITY: '1.9.3',
+  CONSTRAINT_LAYOUT: '2.2.0',
+  RECYCLER_VIEW: '1.3.2',
+  CARD_VIEW: '1.0.0',
+  SWIPE_REFRESH: '1.1.0',
+  NAVIGATION: '2.8.4',
+  ROOM: '2.6.1',
+  WORK: '2.10.0',
+  HILT: '2.52'
+};
+
+/**
+ * Compose versions
+ */
+export const COMPOSE_VERSIONS = {
+  BOM: '2025.01.00',
+  UI: '1.3.0',
+  UI_GRAPHICS: '1.3.0',
+  UI_TOOLING: '1.3.0',
+  MATERIAL3: '1.3.0',
+  MATERIAL_ICONS: '1.3.0',
+  FOUNDATION: '1.3.0',
+  ACTIVITY: '1.9.3',
+  LIFECYCLE: '2.8.7',
+  NAVIGATION: '2.8.4'
+};
+
+/**
+ * Default Gradle properties for Android projects
+ */
+export function getDefaultGradleProperties(): Record<string, string | number | boolean> {
+  return {
+    'org.gradle.jvmargs': '-Xmx2048m -Dfile.encoding=UTF-8',
+    'android.useAndroidX': true,
+    'android.enableJetifier': true,
+    'kotlin.code.style': 'official',
+    'org.gradle.parallel': true,
+    'org.gradle.caching': true,
+    'org.gradle.configureondemand': true,
+    'android.nonTransitiveRClass': true,
+    'android.defaults.buildfeatures.buildconfig': true
+  };
+}
+
+/**
+ * Get recommended minimum SDK based on year
+ */
+export function getRecommendedMinSdk(): number {
+  return 24; // Android 7.0 Nougat
+}
+
+/**
+ * Get target SDK for a given year
+ */
+export function getTargetSdkForYear(year: number): number {
+  // By default, target the latest stable SDK
+  if (year >= 2024) {
+    return 35; // Android 15
+  } else if (year >= 2023) {
+    return 34; // Android 14
+  } else if (year >= 2022) {
+    return 33; // Android 13
+  } else {
+    return 32; // Android 12L
+  }
+}
+
+/**
+ * Template-specific configurations
+ */
+export interface TemplateConfig {
+  language: 'kotlin' | 'java';
+  uiFramework: 'xml' | 'compose' | 'none';
+  minSdk: number;
+  targetSdk: number;
+  compileSdk: number;
+  kotlinVersion: string;
+  agpVersion: string;
+  gradleVersion: string;
+  composeEnabled: boolean;
+  ndkVersion?: string;
+}
+
+export const TEMPLATE_CONFIGS: Record<string, TemplateConfig> = {
+  'kotlin-compose': {
+    language: 'kotlin',
+    uiFramework: 'compose',
+    minSdk: 31,
+    targetSdk: 36,
+    compileSdk: 36,
+    kotlinVersion: GRADLE_VERSIONS.KOTLIN,
+    agpVersion: GRADLE_VERSIONS.AGP,
+    gradleVersion: GRADLE_VERSIONS.GRADLE,
+    composeEnabled: true
+  },
+  'kotlin-xml': {
+    language: 'kotlin',
+    uiFramework: 'xml',
+    minSdk: 31,
+    targetSdk: 36,
+    compileSdk: 36,
+    kotlinVersion: GRADLE_VERSIONS.KOTLIN,
+    agpVersion: GRADLE_VERSIONS.AGP,
+    gradleVersion: GRADLE_VERSIONS.GRADLE,
+    composeEnabled: false
+  },
+  'java-xml': {
+    language: 'java',
+    uiFramework: 'xml',
+    minSdk: 31,
+    targetSdk: 36,
+    compileSdk: 36,
+    kotlinVersion: '', // Not used for Java
+    agpVersion: GRADLE_VERSIONS.AGP,
+    gradleVersion: GRADLE_VERSIONS.GRADLE,
+    composeEnabled: false
+  },
+  'native-cpp': {
+    language: 'kotlin',
+    uiFramework: 'xml',
+    minSdk: 31,
+    targetSdk: 36,
+    compileSdk: 36,
+    kotlinVersion: GRADLE_VERSIONS.KOTLIN,
+    agpVersion: GRADLE_VERSIONS.AGP,
+    gradleVersion: GRADLE_VERSIONS.GRADLE,
+    composeEnabled: false,
+    ndkVersion: GRADLE_VERSIONS.NDK
+  }
+};
+
+/**
+ * Get template configuration
+ */
+export function getTemplateConfig(template: string): TemplateConfig {
+  const config = TEMPLATE_CONFIGS[template];
+  return config ?? TEMPLATE_CONFIGS['kotlin-xml']!;
+}

package/src/core/context.ts

@@ -0,0 +1,212 @@
+/**
+ * Context builder for generating Android project context
+ */
+
+import { camelCase, kebabCase, pascalCase, snakeCase } from '../utils/validation.js';
+import { GRADLE_VERSIONS, ANDROID_SDK_DEFAULTS, getTemplateConfig } from './config.js';
+import type { TemplateType, TemplateContext, AndroidSdkConfig, GradleConfig, ProjectFeatures, NativeCppConfig } from './types.js';
+
+const GENERATOR_VERSION = '1.0.0';
+
+/**
+ * Build default context from basic parameters
+ */
+export function buildDefaultProjectContext(
+  appName: string,
+  packageName: string,
+  projectDirectory: string,
+  template: TemplateType,
+  features: Partial<ProjectFeatures> = {},
+  minSdk?: number,
+  targetSdk?: number
+): Omit<TemplateContext, 'packagePath' | 'appNameSnake' | 'appNameKebab' | 'appNamePascal' | 'appNameCamel' | 'appNameLower' | 'year' | 'generatorVersion'> {
+  // Determine language and UI framework from template
+  const isCompose = template === 'kotlin-compose';
+  const isNativeCpp = template === 'native-cpp';
+  const isKotlin = template !== 'java-xml';
+  const isXml = !isCompose;
+
+  // Get template config for version info
+  const templateConfig = getTemplateConfig(template);
+
+  // Create Android SDK config
+  const android: AndroidSdkConfig = {
+    minSdk: minSdk ?? templateConfig.minSdk,
+    targetSdk: targetSdk ?? templateConfig.targetSdk,
+    compileSdk: templateConfig.compileSdk,
+    buildToolsVersion: ANDROID_SDK_DEFAULTS.BUILD_TOOLS_VERSION
+  };
+
+  // Create Gradle config
+  const gradle: GradleConfig = {
+    agpVersion: templateConfig.agpVersion,
+    gradleVersion: templateConfig.gradleVersion,
+    kotlinVersion: isKotlin ? templateConfig.kotlinVersion : undefined,
+    composeCompilerVersion: isCompose ? GRADLE_VERSIONS.COMPOSE_COMPILER : undefined,
+    composeBomVersion: isCompose ? GRADLE_VERSIONS.COMPOSE_BOM : undefined
+  };
+
+  // Build project features
+  const projectFeatures: ProjectFeatures = {
+    git: features.git ?? true,
+    readme: features.readme ?? true,
+    androidX: features.androidX ?? true,
+    kotlinDsl: features.kotlinDsl ?? true,
+    adaptiveIcon: features.adaptiveIcon ?? true,
+    material3: isCompose || (features.material3 ?? true),
+    viewBinding: features.viewBinding ?? isXml,
+    dataBinding: features.dataBinding ?? false,
+    jetpackCompose: isCompose ? true : (features.jetpackCompose ?? false)
+  };
+
+  // Build native C++ config if needed
+  const nativeCpp: NativeCppConfig | undefined = isNativeCpp ? {
+    cppStandard: 'c++17',
+    ndkVersion: templateConfig.ndkVersion ?? GRADLE_VERSIONS.NDK,
+    stlType: 'c++_shared',
+    abiFilters: ['armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64']
+  } : undefined;
+
+  // Build base context - spread features at top level to match TemplateContext (which extends ProjectFeatures)
+  const baseContext = {
+    appName,
+    packageName,
+    projectDirectory,
+    template,
+    language: templateConfig.language,
+    uiFramework: templateConfig.uiFramework,
+    android,
+    gradle,
+    ...projectFeatures,
+    nativeCpp
+  };
+
+  // Cast to Omit<TemplateContext, ...> for the fields that buildTemplateContext adds
+  const contextForBuildTemplate: Omit<TemplateContext, 'packagePath' | 'appNameSnake' | 'appNameKebab' | 'appNamePascal' | 'appNameCamel' | 'appNameLower' | 'year' | 'generatorVersion'> = baseContext as unknown as Omit<TemplateContext, 'packagePath' | 'appNameSnake' | 'appNameKebab' | 'appNamePascal' | 'appNameCamel' | 'appNameLower' | 'year' | 'generatorVersion'>;
+  return contextForBuildTemplate;
+}
+
+/**
+ * Build full template context with all derived values
+ */
+export function buildTemplateContext(
+  context: {
+    appName: string;
+    packageName: string;
+    projectDirectory: string;
+    template: string;
+    uiFramework: string;
+    language: 'kotlin' | 'java';
+    android: { minSdk: number; targetSdk: number; compileSdk: number };
+    gradle: {
+      agpVersion: string;
+      gradleVersion: string;
+      kotlinVersion?: string;
+      composeCompilerVersion?: string;
+      composeBomVersion?: string;
+    };
+    features: Record<string, boolean>;
+    nativeCpp?: { cppStandard: string; ndkVersion?: string; stlType?: string; abiFilters?: string[] };
+    year?: string;
+  }
+): TemplateContext {
+  // Transform app name to various cases
+  const normalizedAppName = context.appName.replace(/\s+/g, '_');
+  const appNameSnake = snakeCase(context.appName);
+  const appNameKebab = kebabCase(context.appName);
+  const appNamePascal = pascalCase(context.appName);
+  const appNameCamel = camelCase(context.appName);
+  const appNameLower = context.appName.toLowerCase().replace(/\s+/g, '');
+
+  // Convert package name to path format (e.g., "com.example.myapp" -> "com/example/myapp")
+  const packagePath = context.packageName.replace(/\./g, '/');
+
+  // Get current year
+  const year = context.year ?? new Date().getFullYear().toString();
+
+  // Build native C++ config
+  const nativeCpp: NativeCppConfig | undefined = context.nativeCpp ? {
+    cppStandard: (context.nativeCpp.cppStandard === 'c++20' ? 'c++20' : 'c++17') as 'c++17' | 'c++20',
+    ndkVersion: context.nativeCpp.ndkVersion,
+    stlType: (context.nativeCpp.stlType as NativeCppConfig['stlType']) ?? 'c++_shared',
+    abiFilters: context.nativeCpp.abiFilters
+  } : undefined;
+
+  // Build project features from context (features may be at top level or nested)
+  const featuresObj = context.features as Record<string, unknown> || {};
+  const features: ProjectFeatures = {
+    git: typeof featuresObj.git === 'boolean' ? featuresObj.git : true,
+    readme: typeof featuresObj.readme === 'boolean' ? featuresObj.readme : true,
+    androidX: typeof featuresObj.androidX === 'boolean' ? featuresObj.androidX : true,
+    kotlinDsl: typeof featuresObj.kotlinDsl === 'boolean' ? featuresObj.kotlinDsl : true,
+    adaptiveIcon: typeof featuresObj.adaptiveIcon === 'boolean' ? featuresObj.adaptiveIcon : true,
+    material3: typeof featuresObj.material3 === 'boolean' ? featuresObj.material3 : true,
+    viewBinding: typeof featuresObj.viewBinding === 'boolean' ? featuresObj.viewBinding : undefined,
+    dataBinding: typeof featuresObj.dataBinding === 'boolean' ? featuresObj.dataBinding : undefined,
+    jetpackCompose: typeof featuresObj.jetpackCompose === 'boolean' ? featuresObj.jetpackCompose : undefined
+  };
+
+  // Build the complete template context
+  const templateContext: TemplateContext = {
+    appName: context.appName,
+    packageName: context.packageName,
+    projectDirectory: context.projectDirectory,
+    template: context.template as TemplateType,
+    language: context.language,
+    uiFramework: context.uiFramework as 'xml' | 'compose',
+    android: {
+      minSdk: context.android.minSdk,
+      targetSdk: context.android.targetSdk,
+      compileSdk: context.android.compileSdk,
+      buildToolsVersion: context.android.compileSdk > 34 ? '35.0.0' : '34.0.0'
+    },
+    gradle: {
+      agpVersion: context.gradle.agpVersion,
+      gradleVersion: context.gradle.gradleVersion,
+      kotlinVersion: context.gradle.kotlinVersion,
+      composeCompilerVersion: context.gradle.composeCompilerVersion,
+      composeBomVersion: context.gradle.composeBomVersion
+    },
+    appNameSnake,
+    appNameKebab,
+    appNamePascal,
+    appNameCamel,
+    appNameLower,
+    packagePath,
+    year,
+    generatorVersion: GENERATOR_VERSION,
+    ...features,
+    nativeCpp
+  };
+
+  return templateContext;
+}
+
+/**
+ * Validate context has all required fields
+ */
+export function validateContext(context: Partial<TemplateContext>): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!context.appName) errors.push('appName is required');
+  if (!context.packageName) errors.push('packageName is required');
+  if (!context.projectDirectory) errors.push('projectDirectory is required');
+  if (!context.template) errors.push('template is required');
+  if (!context.language) errors.push('language is required');
+  if (!context.uiFramework) errors.push('uiFramework is required');
+  if (!context.android) errors.push('android config is required');
+  if (!context.gradle) errors.push('gradle config is required');
+
+  if (context.android) {
+    if (!context.android.minSdk) errors.push('android.minSdk is required');
+    if (!context.android.targetSdk) errors.push('android.targetSdk is required');
+    if (!context.android.compileSdk) errors.push('android.compileSdk is required');
+  }
+
+  if (context.gradle) {
+    if (!context.gradle.agpVersion) errors.push('gradle.agpVersion is required');
+    if (!context.gradle.gradleVersion) errors.push('gradle.gradleVersion is required');
+  }
+
+  return { valid: errors.length === 0, errors };
+}