andrud 1.0.0

package/src/__tests__/validation.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Test suite for validation utilities
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import {
+  validateAppName,
+  validatePackageNameInput,
+  validateDirectoryPath,
+  camelCase,
+  pascalCase,
+  kebabCase,
+  snakeCase
+} from '../utils/validation.js';
+
+test('Validation - App Name', async (t) => {
+  await t.test('should accept valid app name', () => {
+    const result = validateAppName('MyAwesomeApp');
+    assert.strictEqual(result.valid, true);
+  });
+
+  await t.test('should reject app name starting with number', () => {
+    const result = validateAppName('1App');
+    assert.strictEqual(result.valid, false);
+    assert.ok(result.errors.length > 0);
+  });
+
+  await t.test('should reject app name with spaces', () => {
+    const result = validateAppName('My App');
+    assert.strictEqual(result.valid, false);
+  });
+
+  await t.test('should reject empty app name', () => {
+    const result = validateAppName('');
+    assert.strictEqual(result.valid, false);
+  });
+});
+
+test('Validation - Package Name', async (t) => {
+  await t.test('should accept valid package name', () => {
+    const result = validatePackageNameInput('com.example.myapp');
+    assert.strictEqual(result.valid, true);
+  });
+
+  await t.test('should reject reserved prefix android', () => {
+    const result = validatePackageNameInput('android.example.app');
+    assert.strictEqual(result.valid, false);
+  });
+
+  await t.test('should reject reserved prefix kotlin', () => {
+    const result = validatePackageNameInput('kotlin.example.app');
+    assert.strictEqual(result.valid, false);
+  });
+
+  await t.test('should reject package with single segment', () => {
+    const result = validatePackageNameInput('myapp');
+    assert.strictEqual(result.valid, false);
+  });
+
+  await t.test('should warn on generic com.example prefix', () => {
+    const result = validatePackageNameInput('com.example.app');
+    assert.strictEqual(result.valid, true);
+    assert.ok(result.warnings && result.warnings.length > 0);
+  });
+});
+
+test('Validation - Directory Path', async (t) => {
+  await t.test('should accept valid directory path', () => {
+    const result = validateDirectoryPath('./my-project');
+    assert.strictEqual(result.valid, true);
+  });
+
+  await t.test('should reject empty directory path', () => {
+    const result = validateDirectoryPath('');
+    assert.strictEqual(result.valid, false);
+  });
+
+  await t.test('should reject directory traversal', () => {
+    const result = validateDirectoryPath('../../../etc/passwd');
+    assert.strictEqual(result.valid, false);
+  });
+});
+
+test('String Case Transformations', async (t) => {
+  await t.test('camelCase should transform correctly', () => {
+    const result = camelCase('my awesome app');
+    assert.strictEqual(result, 'myAwesomeApp');
+  });
+
+  await t.test('pascalCase should transform correctly', () => {
+    const result = pascalCase('my awesome app');
+    assert.strictEqual(result, 'MyAwesomeApp');
+  });
+
+  await t.test('kebabCase should transform correctly', () => {
+    const result = kebabCase('my awesome app');
+    assert.strictEqual(result, 'my-awesome-app');
+  });
+
+  await t.test('snakeCase should transform correctly', () => {
+    const result = snakeCase('my awesome app');
+    assert.strictEqual(result, 'my_awesome_app');
+  });
+});

package/src/cli/commands/create.ts

@@ -0,0 +1,252 @@
+/**
+ * Clean, minimal Vite-style project creation command
+ */
+
+import {
+  text,
+  select,
+  confirm,
+  isCancel,
+  cancel,
+  spinner
+} from '@clack/prompts';
+import { generateProject } from '../../core/generator.js';
+import { buildDefaultProjectContext, buildTemplateContext } from '../../core/context.js';
+import { exists, getAbsolutePath } from '../../utils/filesystem.js';
+import { getAllTemplates, getTemplateMetadata } from '../../templates/index.js';
+import type { TemplateType } from '../../core/types.js';
+import pc from 'picocolors';
+import { resolve, isAbsolute } from 'path';
+import { platform } from 'os';
+
+/**
+ * Normalize path for cross-platform compatibility
+ */
+function normalizePath(path: string): string {
+  if (!path || path.trim() === '') {
+    return path;
+  }
+
+  const trimmed = path.trim();
+
+  // On Windows, convert Unix-style paths like /d/... to D:\...
+  if (platform() === 'win32') {
+    const unixPathMatch = trimmed.match(/^\/([a-zA-Z])\/(.*)$/);
+    if (unixPathMatch && unixPathMatch[1] && unixPathMatch[2]) {
+      return `${unixPathMatch[1].toUpperCase()}:\\${unixPathMatch[2].replace(/\//g, '\\')}`;
+    }
+  }
+
+  // Force relative paths to be relative to current directory
+  if (!isAbsolute(trimmed)) {
+    return resolve(trimmed);
+  }
+
+  return trimmed;
+}
+
+/**
+ * Create a new Android project with clean minimal UI
+ */
+export async function createCommand(options: { force?: boolean } = {}): Promise<void> {
+  // ============================================
+  // Step 1: App Name
+  // ============================================
+  console.log('');
+
+  let appName: string;
+  const nameResult = await text({
+    message: '  ? Project name:',
+    placeholder: 'MyApp',
+    defaultValue: 'MyApp',
+  });
+
+  if (isCancel(nameResult)) {
+    cancel();
+    return;
+  }
+
+  appName = nameResult.trim();
+  if (!appName || !/^[a-zA-Z]/.test(appName)) {
+    console.log(pc.red('\n  ✘ Project name must start with a letter\n'));
+    return;
+  }
+
+  // ============================================
+  // Step 2: Template Selection
+  // ============================================
+  const templates = getAllTemplates();
+
+  const templateOptions = templates.map(t => ({
+    label: t.name,
+    value: t.id,
+    hint: t.language === 'kotlin' ? 'Kotlin' : 'Java'
+  }));
+
+  const templateResult = await select({
+    message: '  ? Select template:',
+    options: templateOptions
+  });
+
+  if (isCancel(templateResult)) {
+    cancel();
+    return;
+  }
+
+  const selectedTemplate = templateResult as TemplateType;
+  const selectedMeta = getTemplateMetadata(selectedTemplate);
+
+  // ============================================
+  // Step 3: Package Name
+  // ============================================
+  const defaultPackage = `com.example.${appName.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+
+  const packageResult = await text({
+    message: '  ? Package name:',
+    placeholder: defaultPackage,
+    defaultValue: defaultPackage,
+  });
+
+  if (isCancel(packageResult)) {
+    cancel();
+    return;
+  }
+
+  const packageName = packageResult.trim().toLowerCase();
+  if (!packageName || !/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/.test(packageName)) {
+    console.log(pc.red('\n  ✘ Invalid package name format (e.g., com.example.myapp)\n'));
+    return;
+  }
+
+  // ============================================
+  // Step 4: Directory
+  // ============================================
+  const dirResult = await text({
+    message: '  ? Where to create the project:',
+    placeholder: 'D:\\Projects\\Android',
+    defaultValue: 'D:\\Projects\\Android',
+  });
+
+  if (isCancel(dirResult)) {
+    cancel();
+    return;
+  }
+
+  // Normalize and append app name as project folder
+  let baseDir = dirResult.trim();
+  
+  if (!baseDir) {
+    console.log(pc.red('\n  ✘ Directory path cannot be empty\n'));
+    return;
+  }
+
+  baseDir = normalizePath(baseDir);
+
+  // Ensure the directory path ends properly (no trailing slash issues)
+  let projectDirectory: string;
+
+  // If the path is ./something, append app name
+  if (baseDir.startsWith('./') || baseDir === '.') {
+    const baseName = baseDir === '.' ? '' : baseDir.slice(1).replace(/^[\\\/]/, '');
+    projectDirectory = baseName
+      ? `${baseName}/${appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`
+      : `./${appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+  } else {
+    // For absolute paths, append app name + sanitize
+    projectDirectory = `${baseDir}\\${appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+  }
+
+  // Check if directory exists
+  const dirExists = await exists(projectDirectory);
+  if (dirExists) {
+    if (!options.force) {
+      console.log(pc.red(`\n  ✘ Directory already exists: ${projectDirectory}`));
+      console.log(pc.gray('    Use --force to overwrite\n'));
+      return;
+    }
+  }
+
+  // ============================================
+  // Step 5: Summary & Confirm
+  // ============================================
+  console.log('');
+  console.log(pc.gray('─').repeat(50));
+  console.log('');
+  console.log(`   ${pc.cyan('Project:')} ${pc.bold(appName)}`);
+  console.log(`   ${pc.cyan('Template:')} ${selectedMeta?.name}`);
+  console.log(`   ${pc.cyan('Package:')} ${packageName}`);
+  console.log(`   ${pc.cyan('Path:')} ${projectDirectory}`);
+  console.log('');
+
+  const shouldCreate = await confirm({
+    message: '  Create project?',
+    initialValue: true
+  });
+
+  if (isCancel(shouldCreate)) {
+    cancel();
+    return;
+  }
+
+  if (!shouldCreate) {
+    console.log(pc.gray('\n  Cancelled.\n'));
+    return;
+  }
+
+  // ============================================
+  // Generate Project
+  // ============================================
+  console.log('');
+
+  const s = spinner();
+  s.start('  Creating project...');
+
+  // Build context
+  const baseContext = buildDefaultProjectContext(
+    appName,
+    packageName,
+    projectDirectory,
+    selectedTemplate,
+    { 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 the project
+  const result = await generateProject(context, {
+    overwrite: options.force ?? false,
+    dryRun: false,
+    skipInstall: false,
+    verbose: false
+  });
+
+  s.stop('  Done!');
+
+  if (result.success) {
+    console.log('');
+    console.log(pc.green(`  ✓ Project "${appName}" created`));
+    console.log(pc.gray('─'.repeat(50)));
+    console.log('');
+    console.log(pc.gray(`  cd ${projectDirectory}`));
+    console.log(pc.gray('  ./gradlew assembleDebug'));
+    console.log(pc.gray('  studio .'));
+    console.log('');
+  } else {
+    console.log(pc.red('\n  ✘ Failed to create project'));
+    result.errors.forEach(err => {
+      console.log(`    ${pc.red('•')} ${err.file ? `${err.file}: ` : ''}${err.message}`);
+    });
+    console.log('');
+  }
+}

package/src/cli/commands/info.ts

@@ -0,0 +1,178 @@
+/**
+ * Template info command - shows detailed information about templates
+ */
+
+import { printSection, printKeyValue } from '../../ui/output.js';
+import { gradientTeen, bold, primary, muted } from '../../ui/colors.js';
+import { getTemplateMetadata, getAllTemplates, getTemplatePreview } from '../../templates/index.js';
+import { GRADLE_VERSIONS, TEMPLATE_CONFIGS } from '../../core/config.js';
+import pc from 'picocolors';
+import type { TemplateType, TemplateMetadata } from '../../core/types.js';
+
+interface InfoCommandOptions {
+  template?: string;
+  json: boolean;
+}
+
+/**
+ * Show detailed info about a template
+ */
+export async function createInfoCommand(
+  template?: string,
+  options: InfoCommandOptions = { json: false }
+): Promise<void> {
+  if (options.json) {
+    if (template) {
+      const meta = getTemplateMetadata(template as TemplateType);
+      if (!meta) {
+        console.log(JSON.stringify({ error: `Template "${template}" not found` }, null, 2));
+        return;
+      }
+      printInfoJson(meta);
+    } else {
+      // Show info for all templates
+      const templates = getAllTemplates();
+      console.log(JSON.stringify(templates, null, 2));
+    }
+    return;
+  }
+
+  if (template) {
+    await showTemplateInfo(template as TemplateType);
+  } else {
+    // Show brief info for all templates
+    console.log('');
+    console.log(gradientTeen('Available Templates'));
+    console.log('');
+
+    const templates = getAllTemplates();
+    const maxNameLength = Math.max(...templates.map(t => t.name.length));
+    const maxIdLength = Math.max(...templates.map(t => t.id.length));
+
+    templates.forEach((t, index) => {
+      const paddedName = t.name.padEnd(maxNameLength);
+      const paddedId = t.id.padEnd(maxIdLength);
+
+      console.log(`  ${primary(`${index + 1}.`)} ${bold(paddedName)} ${muted(`(${paddedId})`)}`);
+      console.log(`     ${t.description}`);
+      console.log('');
+    });
+
+    console.log('Usage: andrud info <template-name>');
+    console.log('Example: andrud info kotlin-compose');
+  }
+}
+
+/**
+ * Show detailed info for a specific template
+ */
+async function showTemplateInfo(templateId: TemplateType): Promise<void> {
+  const meta = getTemplateMetadata(templateId);
+  if (!meta) {
+    console.log(pc.red(`Template "${templateId}" not found.`));
+    console.log('Available templates:');
+    getAllTemplates().forEach(t => console.log(`  - ${t.id}`));
+    return;
+  }
+
+  // Get template config for version info
+  const config = TEMPLATE_CONFIGS[templateId];
+  if (!config) {
+    console.log(pc.red(`Template configuration not found for "${templateId}".`));
+    return;
+  }
+  const isCompose = templateId === 'kotlin-compose';
+
+  console.log('');
+  console.log(gradientTeen(`═══ ${meta.name} ═══`));
+  console.log('');
+  console.log(bold(meta.description));
+  console.log('');
+
+  // Key information
+  printSection('Configuration');
+  printKeyValue([
+    { key: 'Template ID', value: meta.id },
+    { key: 'Language', value: config.language === 'kotlin' ? pc.green('Kotlin') : pc.yellow('Java') },
+    { key: 'UI Framework', value: isCompose ? pc.cyan('Jetpack Compose') : pc.gray('XML Layouts') },
+    { key: 'Min SDK', value: `API ${config.minSdk}` },
+    { key: 'Target SDK', value: `API ${config.targetSdk}` },
+    { key: 'Compile SDK', value: `API ${config.compileSdk}` }
+  ]);
+
+  // Version information
+  printSection('Versions');
+  printKeyValue([
+    { key: 'Gradle', value: config.gradleVersion },
+    { key: 'Android Gradle Plugin', value: config.agpVersion },
+    { key: 'Kotlin', value: config.kotlinVersion || 'N/A' },
+    ...(isCompose ? [
+      { key: 'Compose BOM', value: GRADLE_VERSIONS.COMPOSE_BOM },
+      { key: 'Compose Compiler', value: GRADLE_VERSIONS.COMPOSE_COMPILER }
+    ] : []),
+    ...(templateId === 'native-cpp' ? [
+      { key: 'NDK', value: config.ndkVersion || GRADLE_VERSIONS.NDK }
+    ] : [])
+  ]);
+
+  // Features
+  printSection('Features');
+  meta.features.forEach((feature, i) => {
+    console.log(`  ${pc.green('+')} ${feature}`);
+  });
+
+  // Keywords
+  printSection('Keywords');
+  console.log(`  ${meta.keywords.map(k => pc.cyan(k)).join(', ')}`);
+
+  // Code preview
+  const preview = getTemplatePreview(templateId);
+  if (preview) {
+    printSection('Code Preview');
+    console.log(pc.gray('─'.repeat(60)));
+    console.log(pc.dim(preview.split('\n').slice(0, 15).join('\n')));
+    if (preview.split('\n').length > 15) {
+      console.log(pc.gray('...'));
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * Print template info as JSON
+ */
+function printInfoJson(meta: TemplateMetadata): void {
+  const config = TEMPLATE_CONFIGS[meta.id];
+  if (!config) return;
+
+  const isCompose = meta.id === 'kotlin-compose';
+
+  const info = {
+    id: meta.id,
+    name: meta.name,
+    description: meta.description,
+    language: config.language,
+    uiFramework: config.uiFramework === 'compose' ? 'Jetpack Compose' : 'XML Layouts',
+    keywords: meta.keywords,
+    features: meta.features,
+    versions: {
+      gradle: config.gradleVersion,
+      agp: config.agpVersion,
+      kotlin: config.kotlinVersion || null,
+      compose: config.composeEnabled ? {
+        bom: GRADLE_VERSIONS.COMPOSE_BOM,
+        compiler: GRADLE_VERSIONS.COMPOSE_COMPILER
+      } : null,
+      ndk: config.ndkVersion || null
+    },
+    sdk: {
+      min: config.minSdk,
+      target: config.targetSdk,
+      compile: config.compileSdk
+    },
+    codePreview: getTemplatePreview(meta.id)
+  };
+
+  console.log(JSON.stringify(info, null, 2));
+}