andrud 1.0.0

package/src/ui/output.ts

@@ -0,0 +1,230 @@
+/**
+ * Output formatting utilities
+ */
+
+import pc from 'picocolors';
+import { style, bold, dim, muted, primary, success, error, warning, info, section, printSeparator } from './colors.js';
+import gradient from 'gradient-string';
+
+export interface Logger {
+  log: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  success: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  debug: (message: string, ...args: unknown[]) => void;
+  verbose: (message: string, ...args: unknown[]) => void;
+}
+
+const logger: Logger = {
+  log: (message: string, ...args: unknown[]) => {
+    console.log(message, ...args);
+  },
+  info: (message: string, ...args: unknown[]) => {
+    console.log(pc.blue('INFO: ') + message, ...args);
+  },
+  success: (message: string, ...args: unknown[]) => {
+    console.log(pc.green('SUCCESS: ') + message, ...args);
+  },
+  warn: (message: string, ...args: unknown[]) => {
+    console.log(pc.yellow('WARN: ') + message, ...args);
+  },
+  error: (message: string, ...args: unknown[]) => {
+    console.error(pc.red('ERROR: ') + message, ...args);
+  },
+  debug: (message: string, ...args: unknown[]) => {
+    if (process.env.DEBUG || process.env.VERBOSE) {
+      console.log(pc.gray('DEBUG: ') + message, ...args);
+    }
+  },
+  verbose: (message: string, ...args: unknown[]) => {
+    if (process.env.VERBOSE) {
+      console.log(pc.gray('VERBOSE: ') + message, ...args);
+    }
+  }
+};
+
+export { logger };
+
+/**
+ * Creates a gradient from cyan to green (singleton pattern to prevent memory leak)
+ */
+const teenGradient = gradient('#00C9FF', '#92FE9D');
+
+/**
+ * Prints the welcome banner
+ */
+export function printWelcome(): void {
+  console.log('');
+  console.log(pc.cyan(`
+    ╔═══════════════════════════════════════════════════════════╗
+    ║                                                           ║
+    ║     ██╗    ██╗ █████╗ ██████╗     ███████╗███╗   ██╗      ║
+    ║     ██║    ██║██╔══██╗██╔══██╗    ██╔════╝████╗  ██║      ║
+    ║     ██║ █╗ ██║███████║██████╔╝    █████╗  ██╔██╗ ██║      ║
+    ║     ██║███╗██║██╔══██║██╔══██╗    ██╔══╝  ██║╚██╗██║      ║
+    ║     ╚███╔███╔╝██║  ██║██║  ██║    ███████╗██║ ╚████║      ║
+    ║      ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝    ╚══════╝╚═╝  ╚═══╝      ║
+    ║                                                           ║
+    ║     Android Project Generator v1.0.0                      ║
+    ║     Modern Android Development CLI                         ║
+    ║                                                           ║
+    ╚═══════════════════════════════════════════════════════════╝
+  `));
+  console.log('');
+}
+
+/**
+ * Prints the goodbye message
+ */
+export function printGoodbye(success: boolean = true): void {
+  // Uses module-level teenGradient constant
+  if (success) {
+    console.log('');
+    console.log(teenGradient(`
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+      Thanks for using andrud! Happy coding! 🚀
+
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    `));
+  } else {
+    console.log('');
+    console.log(pc.red(`
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+      Operation failed. Please check the error above.
+
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    `));
+  }
+}
+
+/**
+ * Prints a success message
+ */
+export function printSuccess(message: string, details?: string): void {
+  console.log(pc.green('  ✓ ') + pc.white(message));
+  if (details) {
+    console.log(pc.gray(`    ${details}`));
+  }
+}
+
+/**
+ * Prints an error message
+ */
+export function printError(message: string, details?: string): void {
+  console.error(pc.red('  ✗ ') + pc.white(message));
+  if (details) {
+    console.error(pc.gray(`    ${details}`));
+  }
+}
+
+/**
+ * Prints a section header
+ */
+export function printSection(text: string): void {
+  console.log('');
+  console.log(section(text));
+  console.log(dim(printSeparator('─', 50)));
+}
+
+/**
+ * Prints key-value pairs
+ */
+export function printKeyValue(items: Array<{ key: string; value: string }>): void {
+  const maxKeyLength = Math.max(...items.map(item => item.key.length));
+  items.forEach(item => {
+    const padding = ' '.repeat(maxKeyLength - item.key.length);
+    console.log(`  ${pc.cyan(item.key)}${padding}   ${item.value}`);
+  });
+}
+
+/**
+ * Prints a separator line
+ */
+export function printSeparatorLine(char: string = '─', length: number = 60): void {
+  console.log(dim(char.repeat(length)));
+}
+
+/**
+ * Prints a banner with text
+ */
+export function printBanner(text: string, color: 'primary' | 'success' | 'warning' | 'error' = 'primary'): void {
+  const padding = 4;
+  const line = ' '.repeat(padding);
+  const border = '━'.repeat(text.length + padding * 2);
+
+  console.log('');
+  console.log(pc.cyan('  ' + border));
+  console.log(pc.cyan('  ║') + ' '.repeat(padding) + text + ' '.repeat(padding) + pc.cyan('║'));
+  console.log(pc.cyan('  ' + border));
+  console.log('');
+}
+
+/**
+ * Prints an ASCII box with content
+ */
+export function printAsciiBox(lines: string[], options: { border?: string; padding?: number } = {}): void {
+  const border = options.border ?? '─';
+  const padding = options.padding ?? 2;
+  const maxLength = Math.max(...lines.map(l => l.length));
+  const width = maxLength + padding * 2;
+
+  console.log(pc.gray('  ┌' + border.repeat(width) + '┐'));
+
+  if (lines.length === 0) {
+    console.log(pc.gray('  │' + ' '.repeat(width) + '│'));
+  } else {
+    lines.forEach(line => {
+      const padded = line + ' '.repeat(maxLength - line.length);
+      console.log(pc.gray('  │') + ' '.repeat(padding) + padded + ' '.repeat(padding) + pc.gray('│'));
+    });
+  }
+
+  console.log(pc.gray('  └' + border.repeat(width) + '┘'));
+}
+
+/**
+ * Prints a table with columns
+ */
+export function printTable<T>(
+  columns: Array<{ header: string; accessor: (row: T) => string; width?: number }>,
+  rows: T[]
+): void {
+  const colWidths = columns.map(col => {
+    const headerWidth = col.header.length;
+    const dataWidths = rows.map(row => col.accessor(row).length);
+    return col.width ?? Math.max(headerWidth, ...dataWidths);
+  });
+
+  // Print header
+  const headerRow = columns.map((_col, i) => {
+    const width = colWidths[i] ?? 10;
+    return _col.header.substring(0, width).padEnd(width);
+  });
+  console.log(bold(headerRow.join('   ')));
+  console.log(pc.gray(colWidths.map(w => '─'.repeat(w)).join('   ')));
+
+  // Print rows
+  rows.forEach(row => {
+    const dataRow = columns.map((col, i) => {
+      const width = colWidths[i] ?? 10;
+      const value = col.accessor(row);
+      return value.substring(0, width).padEnd(width);
+    });
+    console.log(dataRow.join('   '));
+  });
+}
+
+/**
+ * Prints numbered steps
+ */
+export function printSteps(steps: string[]): void {
+  console.log('');
+  steps.forEach((step, index) => {
+    const num = pc.cyan(`${index + 1}.`);
+    console.log(`  ${num} ${step}`);
+  });
+  console.log('');
+}

package/src/ui/prompts.ts

@@ -0,0 +1,170 @@
+/**
+ * Wrapper around @clack/prompts with proper TypeScript types
+ */
+
+import {
+  select,
+  text,
+  multiselect,
+  confirm,
+  isCancel,
+  cancel,
+  type SelectOptions,
+  type TextOptions,
+  type MultiSelectOptions,
+  type ConfirmOptions
+} from '@clack/prompts';
+
+// Re-export core functions
+export {
+  select,
+  text,
+  multiselect,
+  confirm,
+  isCancel,
+  cancel,
+  type SelectOptions,
+  type TextOptions,
+  type MultiSelectOptions,
+  type ConfirmOptions
+};
+
+// Helper function to ask for app name
+export async function askAppName(defaultValue?: string): Promise<string> {
+  const value = await text({
+    message: '? What is the app name?',
+    placeholder: 'MyAwesomeApp',
+    defaultValue: defaultValue ?? 'MyAwesomeApp',
+    validate: (value: string) => {
+      if (!value || value.trim().length === 0) {
+        return 'App name cannot be empty';
+      }
+      if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)) {
+        return 'App name must start with a letter and contain only letters, numbers, and underscores';
+      }
+      return undefined;
+    }
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as string;
+}
+
+// Helper function to ask for package name
+export async function askPackageName(defaultValue?: string): Promise<string> {
+  const value = await text({
+    message: '? What is the package name?',
+    placeholder: 'com.example.myapp',
+    defaultValue: defaultValue ?? 'com.example.myapp',
+    validate: (value: string) => {
+      if (!value || value.trim().length === 0) {
+        return 'Package name cannot be empty';
+      }
+      if (!/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/.test(value)) {
+        return 'Package name must be a valid domain structure (e.g., com.example.myapp)';
+      }
+      return undefined;
+    }
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as string;
+}
+
+// Helper function to ask for project directory
+export async function askDirectory(defaultValue?: string): Promise<string> {
+  const value = await text({
+    message: '? In which directory should the project be created?',
+    placeholder: './my-app',
+    defaultValue: defaultValue ?? './my-app',
+    validate: (value: string) => {
+      if (!value || value.trim().length === 0) {
+        return 'Directory path cannot be empty';
+      }
+      if (value.includes('..')) {
+        return 'Directory path cannot contain ".." to prevent directory traversal';
+      }
+      return undefined;
+    }
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as string;
+}
+
+// Template selection helper
+export async function selectTemplate<T extends string>(
+  templates: Array<{ label: string; value: T; hint?: string }>
+): Promise<T> {
+  const options = templates.map(t => ({
+    label: t.label + (t.hint ? ` ${t.hint}` : ''),
+    value: t.value
+  }));
+
+  const value = await select({
+    message: '? Select a project template',
+    options
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as T;
+}
+
+// Multi-select helper
+export async function askMultiSelect<T>(
+  options: Array<{ label: string; value: T; hint?: string }>,
+  message: string = '? Select options',
+  min?: number
+): Promise<T[]> {
+  const formattedOptions = options.map(o => ({
+    label: o.label + (o.hint ? ` (${o.hint})` : ''),
+    value: o.value
+  }));
+
+  const value = await multiselect({
+    message,
+    options: formattedOptions,
+    ...(min !== undefined ? { min } : {})
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as T[];
+}
+
+// Confirmation helper
+export async function askConfirmation(
+  message: string,
+  initialValue: boolean = false
+): Promise<boolean> {
+  const value = await confirm({
+    message: `? ${message}`,
+    initialValue
+  });
+
+  if (isCancel(value)) {
+    cancel();
+    process.exit(0);
+  }
+
+  return value as boolean;
+}

package/src/ui/spinners.ts

@@ -0,0 +1,95 @@
+/**
+ * Spinner utilities using ora
+ */
+
+import ora, { type Ora } from 'ora';
+
+export class AsyncSpinner {
+  private spinner: Ora | null = null;
+  private startTime: number = 0;
+
+  start(text?: string): void {
+    this.startTime = Date.now();
+    this.spinner = ora({
+      text: text ?? 'Loading...',
+      spinner: 'dots'
+    }).start();
+  }
+
+  update(text: string): void {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+  }
+
+  succeed(text?: string): void {
+    if (this.spinner) {
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+      this.spinner.succeed(text ? `${text} (${elapsed}s)` : undefined);
+      this.spinner = null;
+    }
+  }
+
+  fail(text?: string): void {
+    if (this.spinner) {
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+      this.spinner.fail(text ? `${text} (${elapsed}s)` : undefined);
+      this.spinner = null;
+    }
+  }
+
+  warn(text?: string): void {
+    if (this.spinner) {
+      this.spinner.warn(text);
+    }
+  }
+
+  stop(): void {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+
+  isSpinning(): boolean {
+    return this.spinner?.isSpinning ?? false;
+  }
+}
+
+export interface WithSpinnerOptions {
+  text?: string;
+  successText?: string;
+  failText?: string;
+  warnText?: string;
+}
+
+/**
+ * Executes an async function with a spinner
+ */
+export async function withSpinner<T>(
+  text: string,
+  fn: () => Promise<T>,
+  options?: WithSpinnerOptions
+): Promise<T> {
+  const spinner = new AsyncSpinner();
+  spinner.start(text);
+
+  try {
+    const result = await fn();
+    spinner.succeed(options?.successText);
+    return result;
+  } catch (error) {
+    spinner.fail(options?.failText ?? (error instanceof Error ? error.message : 'An error occurred'));
+    throw error;
+  }
+}
+
+/**
+ * Creates a simple loading indicator
+ */
+export function createSpinner(text?: string): Ora {
+  return ora({
+    text,
+    spinner: 'dots'
+  });
+}

package/src/ui/types.ts

@@ -0,0 +1,41 @@
+/**
+ * Type definitions for UI components and utilities
+ */
+
+export type StyleType = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'muted';
+
+export interface SpinnerOptions {
+  text?: string;
+  color?: string;
+}
+
+export interface TableColumn<T> {
+  header: string;
+  accessor: (row: T) => string;
+  width?: number;
+}
+
+export interface ConfirmationOptions {
+  message: string;
+  initialValue?: boolean;
+}
+
+export interface SelectOption<T> {
+  label: string;
+  value: T;
+  hint?: string;
+}
+
+export interface TextInputOptions {
+  message: string;
+  placeholder?: string;
+  defaultValue?: string;
+  validate?: (value: string) => string | null;
+}
+
+export interface MultiSelectOptions<T> {
+  message: string;
+  options: SelectOption<T>[];
+  min?: number;
+  max?: number;
+}