andrud 1.0.0

package/src/core/types.ts

@@ -0,0 +1,184 @@
+/**
+ * Core type definitions for the Android project generator
+ */
+
+// Language and UI framework types
+export type LanguageType = 'kotlin' | 'java';
+export type UiFrameworkType = 'xml' | 'compose';
+export type TemplateType = 'kotlin-xml' | 'kotlin-compose' | 'java-xml' | 'native-cpp';
+
+// Android SDK configuration
+export interface AndroidSdkConfig {
+  minSdk: number;
+  targetSdk: number;
+  compileSdk: number;
+  buildToolsVersion?: string;
+}
+
+// Gradle configuration
+export interface GradleConfig {
+  agpVersion: string;
+  gradleVersion: string;
+  kotlinVersion?: string;
+  composeCompilerVersion?: string;
+  composeBomVersion?: string;
+}
+
+// Project features
+export interface ProjectFeatures {
+  git: boolean;
+  readme: boolean;
+  androidX: boolean;
+  kotlinDsl: boolean;
+  adaptiveIcon: boolean;
+  material3: boolean;
+  viewBinding?: boolean;
+  dataBinding?: boolean;
+  jetpackCompose?: boolean;
+}
+
+// Native C++ configuration
+export interface NativeCppConfig {
+  cppStandard: 'c++17' | 'c++20';
+  ndkVersion?: string;
+  stlType?: 'c++_shared' | 'c++_static' | 'none' | 'system';
+  abiFilters?: string[];
+}
+
+// Template context for project generation
+export interface TemplateContext extends ProjectFeatures {
+  // Basic info
+  appName: string;
+  packageName: string;
+  projectDirectory: string;
+  template: TemplateType;
+
+  // Derived info
+  language: LanguageType;
+  uiFramework: UiFrameworkType;
+
+  // SDK and Gradle config
+  android: AndroidSdkConfig;
+  gradle: GradleConfig;
+
+  // Transformed names
+  appNameSnake: string;
+  appNameKebab: string;
+  appNamePascal: string;
+  appNameCamel: string;
+  appNameLower: string;
+
+  // Package path (e.g., "com/example/myapp")
+  packagePath: string;
+
+  // Date and version info
+  year: string;
+  generatorVersion: string;
+
+  // Native C++ config (optional)
+  nativeCpp?: NativeCppConfig;
+}
+
+// Generation options
+export interface GenerationOptions {
+  overwrite: boolean;
+  skipInstall: boolean;
+  dryRun: boolean;
+  verbose: boolean;
+}
+
+// Generation result
+export interface GenerationResult {
+  success: boolean;
+  projectPath: string;
+  generatedFiles: string[];
+  skippedFiles: string[];
+  errors: Array<{
+    file?: string;
+    message: string;
+    code?: string;
+  }>;
+  warnings: string[];
+  duration: number;
+}
+
+// File to be generated
+export interface GeneratedFile {
+  path: string;
+  content: string;
+  overwrite?: boolean;
+}
+
+// Validation result
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+// Directory structure definition
+export interface DirectorySpec {
+  path: string;
+  description?: string;
+}
+
+// Template metadata
+export interface TemplateMetadata {
+  id: TemplateType;
+  name: string;
+  description: string;
+  keywords: string[];
+  features: string[];
+  language: LanguageType;
+  uiFramework: UiFrameworkType;
+  codePreview?: string;
+}
+
+// CLI command options
+export interface NewCommandOptions {
+  name?: string;
+  template?: string;
+  packageName?: string;
+  directory?: string;
+  minSdk?: number;
+  targetSdk?: number;
+  force?: boolean;
+  skipInstall?: boolean;
+  git?: boolean;
+  kotlin?: boolean;
+  verbose?: boolean;
+}
+
+export interface InitCommandOptions {
+  force: boolean;
+  template?: string;
+}
+
+export interface InfoCommandOptions {
+  template?: string;
+  json: boolean;
+}
+
+export interface ListCommandOptions {
+  json: boolean;
+}
+
+// Default options
+export const DEFAULT_GENERATION_OPTIONS: GenerationOptions = {
+  overwrite: false,
+  skipInstall: false,
+  dryRun: false,
+  verbose: false
+};
+
+export const DEFAULT_PROJECT_FEATURES: ProjectFeatures = {
+  git: true,
+  readme: true,
+  androidX: true,
+  kotlinDsl: true,
+  adaptiveIcon: true,
+  material3: true,
+  viewBinding: true,
+  dataBinding: false,
+  jetpackCompose: false
+};

package/src/templates/index.ts

@@ -0,0 +1,162 @@
+/**
+ * Template registry and metadata
+ */
+
+import type { TemplateType } from '../core/types.js';
+
+interface TemplateMetadata {
+  id: TemplateType;
+  name: string;
+  description: string;
+  keywords: string[];
+  features: string[];
+  language: 'kotlin' | 'java';
+  uiFramework: 'xml' | 'compose';
+}
+
+export type { TemplateMetadata };
+
+export const TEMPLATE_REGISTRY: TemplateMetadata[] = [
+  {
+    id: 'kotlin-xml',
+    name: 'Kotlin with XML Layouts',
+    description: 'Traditional Android Views with Kotlin. Best for developers who prefer XML layouts and ViewBinding.',
+    keywords: ['kotlin', 'xml', 'views', 'viewbinding', 'material'],
+    features: ['Material Design 3', 'ViewBinding', 'Kotlin Coroutines', 'RecyclerView', 'ConstraintLayout'],
+    language: 'kotlin',
+    uiFramework: 'xml'
+  },
+  {
+    id: 'kotlin-compose',
+    name: 'Kotlin with Jetpack Compose',
+    description: 'Modern declarative UI with Kotlin and Jetpack Compose. Latest Android UI toolkit with Material 3 support.',
+    keywords: ['kotlin', 'compose', 'declarative', 'material3', 'modern'],
+    features: ['Material Design 3', 'Compose Navigation', 'Kotlin Coroutines', 'ViewModel', 'Hilt'],
+    language: 'kotlin',
+    uiFramework: 'compose'
+  },
+  {
+    id: 'java-xml',
+    name: 'Java with XML Layouts',
+    description: 'Traditional Android Views with Java. Ideal for teams maintaining Java codebases or preferring Java syntax.',
+    keywords: ['java', 'xml', 'views', 'viewbinding', 'legacy'],
+    features: ['Material Design 3', 'ViewBinding', 'Java 17', 'RecyclerView', 'ConstraintLayout'],
+    language: 'java',
+    uiFramework: 'xml'
+  },
+  {
+    id: 'native-cpp',
+    name: 'Kotlin with Native C++/NDK',
+    description: 'Native C++ development with JNI integration. For high-performance code, game engines, or system-level programming.',
+    keywords: ['kotlin', 'native', 'cpp', 'ndk', 'jni', 'cmake'],
+    features: ['CMake Integration', 'JNI Bridge', 'Native Development', 'Multi-ABI Support', 'STL'],
+    language: 'kotlin',
+    uiFramework: 'xml'
+  }
+];
+
+/**
+ * Get template metadata by ID
+ */
+export function getTemplateMetadata(id: TemplateType): TemplateMetadata | undefined {
+  return TEMPLATE_REGISTRY.find((t) => t.id === id);
+}
+
+/**
+ * Get all available templates
+ */
+export function getAllTemplates(): TemplateMetadata[] {
+  return [...TEMPLATE_REGISTRY];
+}
+
+/**
+ * Search templates by query
+ */
+export function searchTemplates(query: string): TemplateMetadata[] {
+  const lowerQuery = query.toLowerCase();
+
+  return TEMPLATE_REGISTRY.filter((template) => {
+    if (template.name.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    if (template.description.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    if (template.keywords.some((k) => k.toLowerCase().includes(lowerQuery))) {
+      return true;
+    }
+    if (template.id.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    return false;
+  });
+}
+
+/**
+ * Get templates by category
+ */
+export function getTemplatesByCategory(category: 'kotlin' | 'java' | 'native'): TemplateMetadata[] {
+  return TEMPLATE_REGISTRY.filter((t) => {
+    switch (category) {
+      case 'kotlin':
+        return t.id === 'kotlin-xml' || t.id === 'kotlin-compose' || t.id === 'native-cpp';
+      case 'java':
+        return t.id === 'java-xml';
+      case 'native':
+        return t.id === 'native-cpp';
+      default:
+        return false;
+    }
+  });
+}
+
+/**
+ * Get template preview code
+ */
+export function getTemplatePreview(id: TemplateType): string | undefined {
+  const previews: Record<string, string> = {
+    'kotlin-compose': `// MainActivity.kt
+@Composable
+fun MainScreen() {
+    var count by remember { mutableIntStateOf(0) }
+
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(16.dp),
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Text(
+            text = "Count: $count",
+            style = MaterialTheme.typography.headlineMedium
+        )
+    }
+}`,
+    'kotlin-xml': `// MainActivity.kt
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+    }
+}`,
+    'java-xml': `// MainActivity.java
+public class MainActivity extends AppCompatActivity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+    }
+}`,
+    'native-cpp': `// native-lib.cpp
+#include <jni.h>
+#include <string>
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_example_app_NativeLib_stringFromJNI(
+    JNIEnv* env, jobject /* this */) {
+    return env->NewStringUTF("Hello from C++");
+}`
+  };
+
+  return previews[id];
+}

package/src/types/gradient-string.d.ts

@@ -0,0 +1,25 @@
+declare module 'gradient-string' {
+  interface Gradient {
+    (text: string): string;
+    rainbow(text: string): string;
+    pastel(text: string): string;
+    ice(text: string): string;
+  }
+
+  interface GradientStatic {
+    (color1: string, color2: string): Gradient;
+    rainbow: Gradient;
+    pastel: Gradient;
+    teen: Gradient;
+    mind: Gradient;
+    summer: Gradient;
+    winter: Gradient;
+    autumn: Gradient;
+    spring: Gradient;
+    forest: Gradient;
+  }
+
+  const gradient: GradientStatic;
+  export default gradient;
+  export { Gradient, GradientStatic };
+}

package/src/ui/colors.ts

@@ -0,0 +1,139 @@
+/**
+ * Color and text formatting utilities using picocolors and gradient-string
+ */
+
+import pc from 'picocolors';
+import gradient from 'gradient-string';
+
+// Style function to apply color based on type
+export function style(text: string, type: 'primary' | 'success' | 'warning' | 'error' | 'info' | 'muted'): string {
+  switch (type) {
+    case 'primary':
+      return pc.cyan(text);
+    case 'success':
+      return pc.green(text);
+    case 'warning':
+      return pc.yellow(text);
+    case 'error':
+      return pc.red(text);
+    case 'info':
+      return pc.blue(text);
+    case 'muted':
+      return pc.gray(text);
+    default:
+      return text;
+  }
+}
+
+// Text formatting functions
+export const bold = (text: string): string => pc.bold(text);
+export const dim = (text: string): string => pc.dim(text);
+export const underline = (text: string): string => pc.underline(text);
+export const inverse = (text: string): string => pc.inverse(text);
+export const italic = (text: string): string => pc.italic(text);
+
+// Color functions
+export const primary = (text: string): string => pc.cyan(text);
+export const success = (text: string): string => pc.green(text);
+export const warning = (text: string): string => pc.yellow(text);
+export const error = (text: string): string => pc.red(text);
+export const info = (text: string): string => pc.blue(text);
+export const muted = (text: string): string => pc.gray(text);
+
+// Aliases for backward compatibility
+export const cyan = (text: string): string => pc.cyan(text);
+export const green = (text: string): string => pc.green(text);
+export const yellow = (text: string): string => pc.yellow(text);
+export const red = (text: string): string => pc.red(text);
+export const blue = (text: string): string => pc.blue(text);
+export const gray = (text: string): string => pc.gray(text);
+
+// Gradient functions using gradient-string
+export function gradientTeen(text: string): string {
+  const g = gradient('#00C9FF', '#92FE9D');
+  return g(text);
+}
+
+export function gradientRainbow(text: string): string {
+  return gradient.rainbow(text);
+}
+
+export function gradientCool(text: string): string {
+  const g = gradient('#667eea', '#764ba2');
+  return g(text);
+}
+
+export function gradientPassion(text: string): string {
+  const g = gradient('#ee0979', '#ff6a00');
+  return g(text);
+}
+
+// Section formatting
+export const header = (text: string): string => {
+  return bold(pc.cyan(pc.bold(`\n${text}\n`)));
+};
+
+export const section = (text: string): string => {
+  return bold(pc.white(text));
+};
+
+export const subsection = (text: string): string => {
+  return pc.dim(text);
+};
+
+// Symbol functions for visual elements
+export const checkmark = (text?: string): string => {
+  const symbol = pc.green('✓');
+  return text ? `${symbol} ${text}` : symbol;
+};
+
+export const crossmark = (text?: string): string => {
+  const symbol = pc.red('✗');
+  return text ? `${symbol} ${text}` : symbol;
+};
+
+// Arrow and bullet functions
+export const bullet = (text: string): string => {
+  return `${pc.gray('•')} ${text}`;
+};
+
+export const numbered = (num: number, text: string): string => {
+  return `${pc.gray(`${num}.`)} ${text}`;
+};
+
+export const arrow = (text: string): string => {
+  return `${pc.gray('→')} ${text}`;
+};
+
+export const rightArrow = (from: string, to: string): string => {
+  return `${from} ${pc.gray('→')} ${to}`;
+};
+
+// Progress bar
+export function progressBar(current: number, total: number, width: number = 20): string {
+  const percentage = Math.min(Math.max(current / total, 0), 1);
+  const filled = Math.round(percentage * width);
+  const empty = width - filled;
+  const filledBar = pc.green('█'.repeat(filled));
+  const emptyBar = pc.gray('░'.repeat(empty));
+  const percentText = pc.cyan(`${Math.round(percentage * 100)}%`);
+  return `${filledBar}${emptyBar} ${percentText}`;
+}
+
+// Separator line
+export function printSeparator(char: string = '─', length: number = 60): string {
+  return pc.gray(char.repeat(length));
+}
+
+// Terminal control functions
+export function clearLine(): void {
+  process.stdout.write('\r\x1B[K');
+}
+
+export function cursorHide(): void {
+  process.stdout.write('\x1B[?25l');
+}
+
+export function cursorShow(): void {
+  process.stdout.write('\x1B[?25h');
+}