devendra-skill-package 1.0.2

package/.github/skills/boiler-project-generator/scripts/react-native.js

@@ -0,0 +1,1041 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {spawn} = require('node:child_process');
+const readline = require('node:readline/promises');
+
+const skillRoot = path.resolve(__dirname, '..');
+const templateDir = path.join(skillRoot, 'assets', 'templates', 'react-native');
+
+const defaultConfig = {
+  reactNativeVersion: 'latest',
+  useTypeScript: true,
+  enableNavigation: false,
+  enableRedux: false,
+  enableEnv: false,
+  uatApiBaseUrl: 'https://api-uat.example.com',
+  stagingApiBaseUrl: 'https://api-staging.example.com',
+  prodApiBaseUrl: 'https://api.example.com',
+  verificationTarget: 'none',
+};
+
+function isWindows() {
+  return process.platform === 'win32';
+}
+
+function resolveCommand(command) {
+  if (!isWindows()) {
+    return command;
+  }
+
+  if (command === 'npm' || command === 'npx') {
+    return `${command}.cmd`;
+  }
+
+  return command;
+}
+
+function runCommand(command, args, options = {}) {
+  const display = [command, ...args].join(' ');
+  console.log(`\n$ ${display}`);
+
+  const resolvedCommand = resolveCommand(command);
+  return new Promise((resolve, reject) => {
+    const child = spawn(resolvedCommand, args, {
+      cwd: options.cwd || process.cwd(),
+      shell: isWindows() && resolvedCommand.endsWith('.cmd'),
+      env: process.env,
+    });
+
+    let output = '';
+
+    child.stdout.on('data', chunk => {
+      const text = chunk.toString();
+      output += text;
+      process.stdout.write(text);
+    });
+
+    child.stderr.on('data', chunk => {
+      const text = chunk.toString();
+      output += text;
+      process.stderr.write(text);
+    });
+
+    child.on('error', error => {
+      reject(new Error(`Failed to run ${display}: ${error.message}`));
+    });
+
+    child.on('close', status => {
+      if (status !== 0 && !options.allowFailure) {
+        reject(new Error(`Command failed: ${display}\n${output.trim()}`.trim()));
+        return;
+      }
+
+      resolve({
+        status,
+        output,
+      });
+    });
+  });
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (!token.startsWith('--')) {
+      continue;
+    }
+
+    const key = token.slice(2);
+    const next = argv[index + 1];
+
+    if (!next || next.startsWith('--')) {
+      parsed[key] = 'true';
+      continue;
+    }
+
+    parsed[key] = next;
+    index += 1;
+  }
+
+  return parsed;
+}
+
+function showHelp() {
+  console.log(`
+React Native Boilerplate Generator (boiler-project-generator)
+
+Usage:
+  node react-native.js [options]
+  node react-native.js <projectName> [language]
+
+The project is created under the current working directory.
+
+Options:
+  --project <PascalCase>              Project name (alias for --projectName)
+  --projectName <PascalCase>          Project name
+  --language <javascript|typescript>  Language preference
+  --reactNativeVersion <latest|x.y.z>
+  --useTypeScript <yes|no>
+  --enableNavigation <yes|no>
+  --enableRedux <yes|no>
+  --enableEnv <yes|no>
+  --uatApiBaseUrl <url>
+  --stagingApiBaseUrl <url>
+  --prodApiBaseUrl <url>
+  --verificationTarget <none|android|ios>
+  --help
+
+If options are omitted, the script prompts for them one-by-one.
+`);
+}
+
+function isValidProjectName(value) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(value);
+}
+
+function isValidReactNativeVersion(value) {
+  return value === 'latest' || /^\d+\.\d+\.\d+$/.test(value);
+}
+
+function isValidUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function parseBoolean(value, label) {
+  const normalized = String(value).trim().toLowerCase();
+
+  if (['y', 'yes', 'true'].includes(normalized)) {
+    return true;
+  }
+
+  if (['n', 'no', 'false'].includes(normalized)) {
+    return false;
+  }
+
+  throw new Error(`${label} must be yes or no.`);
+}
+
+function validateVerificationTarget(value) {
+  const normalized = String(value).trim().toLowerCase();
+
+  if (['none', 'android', 'ios'].includes(normalized)) {
+    return normalized;
+  }
+
+  throw new Error('verificationTarget must be one of: none, android, ios.');
+}
+
+async function askQuestion(reader, label, defaultValue, validator, parser = value => value) {
+  while (true) {
+    const suffix = defaultValue === undefined ? '' : ` [${defaultValue}]`;
+    const answer = (await reader.question(`${label}${suffix}: `)).trim();
+    const value = answer || defaultValue;
+
+    try {
+      validator(value);
+      return parser(value);
+    } catch (error) {
+      console.log(error.message);
+    }
+  }
+}
+
+async function collectConfig(rawArgs) {
+  const args = {...rawArgs};
+
+  if (args.help === 'true') {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Support legacy positional args: react-native.js <projectName> <language>
+  const positionalProject = process.argv[2] && !process.argv[2].startsWith('--') ? process.argv[2] : null;
+  const positionalLang = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : null;
+
+  if (!args.projectName && !args.project && positionalProject) {
+    args.projectName = positionalProject;
+  }
+  if (!args.projectName && args.project) {
+    args.projectName = args.project;
+  }
+
+  // Map --language to --useTypeScript if useTypeScript not explicitly set
+  if (args.useTypeScript === undefined) {
+    const lang = args.language || positionalLang;
+    if (lang === 'typescript') {
+      args.useTypeScript = 'yes';
+    } else if (lang === 'javascript') {
+      args.useTypeScript = 'no';
+    }
+  }
+
+  const reader = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const projectName = args.projectName
+      ? (() => {
+          if (!isValidProjectName(args.projectName)) {
+            throw new Error('projectName must be PascalCase and alphanumeric.');
+          }
+          return args.projectName;
+        })()
+      : await askQuestion(
+          reader,
+          'Project name',
+          undefined,
+          value => {
+            if (!isValidProjectName(value)) {
+              throw new Error('Project name must be PascalCase and alphanumeric.');
+            }
+          },
+        );
+
+    const reactNativeVersion = args.reactNativeVersion
+      ? (() => {
+          if (!isValidReactNativeVersion(args.reactNativeVersion)) {
+            throw new Error('reactNativeVersion must be latest or a semver value like 0.79.2.');
+          }
+          return args.reactNativeVersion;
+        })()
+      : await askQuestion(
+          reader,
+          'React Native version',
+          defaultConfig.reactNativeVersion,
+          value => {
+            if (!isValidReactNativeVersion(value)) {
+              throw new Error('React Native version must be latest or a semver value like 0.79.2.');
+            }
+          },
+        );
+
+    const useTypeScript = args.useTypeScript !== undefined
+      ? parseBoolean(args.useTypeScript, 'useTypeScript')
+      : await askQuestion(
+          reader,
+          'Use TypeScript? (yes/no)',
+          'yes',
+          value => parseBoolean(value, 'useTypeScript'),
+          value => parseBoolean(value, 'useTypeScript'),
+        );
+
+    const enableNavigation = args.enableNavigation !== undefined
+      ? parseBoolean(args.enableNavigation, 'enableNavigation')
+      : await askQuestion(
+          reader,
+          'Enable Navigation? (yes/no)',
+          'no',
+          value => parseBoolean(value, 'enableNavigation'),
+          value => parseBoolean(value, 'enableNavigation'),
+        );
+
+    const enableRedux = args.enableRedux !== undefined
+      ? parseBoolean(args.enableRedux, 'enableRedux')
+      : await askQuestion(
+          reader,
+          'Enable Redux Toolkit? (yes/no)',
+          'no',
+          value => parseBoolean(value, 'enableRedux'),
+          value => parseBoolean(value, 'enableRedux'),
+        );
+
+    const enableEnv = args.enableEnv !== undefined
+      ? parseBoolean(args.enableEnv, 'enableEnv')
+      : await askQuestion(
+          reader,
+          'Enable environment config? (yes/no)',
+          'no',
+          value => parseBoolean(value, 'enableEnv'),
+          value => parseBoolean(value, 'enableEnv'),
+        );
+
+    const uatApiBaseUrl = enableEnv || args.uatApiBaseUrl
+      ? args.uatApiBaseUrl && isValidUrl(args.uatApiBaseUrl)
+        ? args.uatApiBaseUrl
+        : await askQuestion(
+            reader,
+            'UAT API base URL',
+            defaultConfig.uatApiBaseUrl,
+            value => {
+              if (!isValidUrl(value)) {
+                throw new Error('UAT API base URL must be a valid http or https URL.');
+              }
+            },
+          )
+      : defaultConfig.uatApiBaseUrl;
+
+    const stagingApiBaseUrl = enableEnv || args.stagingApiBaseUrl
+      ? args.stagingApiBaseUrl && isValidUrl(args.stagingApiBaseUrl)
+        ? args.stagingApiBaseUrl
+        : await askQuestion(
+            reader,
+            'Staging API base URL',
+            defaultConfig.stagingApiBaseUrl,
+            value => {
+              if (!isValidUrl(value)) {
+                throw new Error('Staging API base URL must be a valid http or https URL.');
+              }
+            },
+          )
+      : defaultConfig.stagingApiBaseUrl;
+
+    const prodApiBaseUrl = enableEnv || args.prodApiBaseUrl
+      ? args.prodApiBaseUrl && isValidUrl(args.prodApiBaseUrl)
+        ? args.prodApiBaseUrl
+        : await askQuestion(
+            reader,
+            'Production API base URL',
+            defaultConfig.prodApiBaseUrl,
+            value => {
+              if (!isValidUrl(value)) {
+                throw new Error('Production API base URL must be a valid http or https URL.');
+              }
+            },
+          )
+      : defaultConfig.prodApiBaseUrl;
+
+    const verificationTarget = args.verificationTarget !== undefined
+      ? validateVerificationTarget(args.verificationTarget)
+      : await askQuestion(
+          reader,
+          'Verification target (none/android/ios)',
+          'none',
+          value => validateVerificationTarget(value),
+          value => validateVerificationTarget(value),
+        );
+
+    return {
+      projectName,
+      reactNativeVersion,
+      useTypeScript,
+      enableNavigation,
+      enableRedux,
+      enableEnv,
+      uatApiBaseUrl,
+      stagingApiBaseUrl,
+      prodApiBaseUrl,
+      verificationTarget,
+    };
+  } finally {
+    reader.close();
+  }
+}
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function writeText(filePath, content, summary) {
+  fs.mkdirSync(path.dirname(filePath), {recursive: true});
+  const relativePath = path.relative(summary.projectDir, filePath).replace(/\\/g, '/');
+
+  if (fs.existsSync(filePath)) {
+    summary.updatedFiles.add(relativePath);
+  } else {
+    summary.createdFiles.add(relativePath);
+  }
+
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function ensureTsconfig(projectDir, summary) {
+  const tsconfigPath = path.join(projectDir, 'tsconfig.json');
+  let tsconfig = {
+    extends: '@react-native/typescript-config/tsconfig.json',
+    compilerOptions: {},
+  };
+
+  if (fs.existsSync(tsconfigPath)) {
+    tsconfig = JSON.parse(readText(tsconfigPath));
+  }
+
+  tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+  tsconfig.compilerOptions.jsx = 'react-native';
+
+  writeText(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}\n`, summary);
+}
+
+async function installPackages(projectDir, packages, summary, options = {}) {
+  if (!packages.length) {
+    return;
+  }
+
+  const command = ['install'];
+
+  if (options.dev) {
+    command.push('--save-dev');
+  }
+
+  command.push(...packages);
+
+  try {
+    await runCommand('npm', command, {cwd: projectDir});
+  } catch (error) {
+    if (!/ERESOLVE|Invalid Version|peer dep/i.test(error.message)) {
+      throw error;
+    }
+
+    // Step 1: Try unpinned versions to auto-resolve compatible ones
+    const unpinned = packages.map(pkg => pkg.replace(/@\d[\d.]*(-[\w.]+)?$/, ''));
+    const hasVersionDiff = unpinned.some((u, i) => u !== packages[i]);
+
+    if (hasVersionDiff) {
+      console.log('\nVersion conflict detected. Retrying with unpinned versions...');
+      const retryCmd = ['install', ...(options.dev ? ['--save-dev'] : []), ...unpinned];
+      try {
+        await runCommand('npm', retryCmd, {cwd: projectDir});
+        summary.warnings.add(`Installed with unpinned versions due to conflict: ${packages.join(', ')}`);
+        unpinned.forEach(pkg => summary.installedPackages.add(pkg));
+        return;
+      } catch {
+        // Fall through to clean reinstall
+      }
+    }
+
+    // Step 2: Clean reinstall then retry original versions
+    console.log('\nClean reinstalling all dependencies...');
+    fs.rmSync(path.join(projectDir, 'node_modules'), {recursive: true, force: true});
+    fs.rmSync(path.join(projectDir, 'package-lock.json'), {force: true});
+    await runCommand('npm', ['install'], {cwd: projectDir});
+    await runCommand('npm', command, {cwd: projectDir});
+  }
+
+  packages.forEach(pkg => summary.installedPackages.add(pkg));
+}
+
+function getNavigationPackages(reactNativeVersion) {
+  if (/^0\.79\./.test(reactNativeVersion)) {
+    return [
+      '@react-navigation/native@6.1.18',
+      '@react-navigation/native-stack@6.11.0',
+      'react-native-screens@4.4.0',
+      'react-native-safe-area-context@4.14.0',
+      'react-native-gesture-handler@2.20.2',
+      'react-native-reanimated@3.16.1',
+    ];
+  }
+
+  return [
+    '@react-navigation/native',
+    '@react-navigation/native-stack',
+    'react-native-screens',
+    'react-native-safe-area-context',
+    'react-native-gesture-handler',
+    'react-native-reanimated@4',
+    'react-native-worklets',
+  ];
+}
+
+function hasDirectDependency(projectDir, packageName) {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  const packageJson = JSON.parse(readText(packageJsonPath));
+
+  return Boolean(
+    packageJson.dependencies?.[packageName] ||
+    packageJson.devDependencies?.[packageName],
+  );
+}
+
+function isWorkletsRelatedFailure(error) {
+  return /react-native-worklets|worklets|react-native-reanimated/i.test(error.message);
+}
+
+async function ensureWorkletsDependency(projectDir, summary) {
+  if (hasDirectDependency(projectDir, 'react-native-worklets')) {
+    return false;
+  }
+
+  summary.warnings.add(
+    'Adding react-native-worklets explicitly because the current navigation/reanimated setup requires it.',
+  );
+  await installPackages(projectDir, ['react-native-worklets'], summary);
+  return true;
+}
+
+function ensureReanimatedPlugin(projectDir, summary) {
+  const babelConfigPath = path.join(projectDir, 'babel.config.js');
+  const plugin = "'react-native-reanimated/plugin'";
+  let content = fs.existsSync(babelConfigPath)
+    ? readText(babelConfigPath)
+    : "module.exports = {presets: ['module:@react-native/babel-preset']};\n";
+
+  if (content.includes(plugin)) {
+    content = content.replace(/plugins:\s*\[(.*?)\]/s, (match, inner) => {
+      const items = inner
+        .split(',')
+        .map(item => item.trim())
+        .filter(Boolean)
+        .filter(item => item !== plugin);
+      items.push(plugin);
+      return `plugins: [${items.join(', ')}]`;
+    });
+  } else if (/module\.exports\s*=\s*\{[\s\S]*\}/.test(content)) {
+    if (/plugins:\s*\[.*?\]/s.test(content)) {
+      content = content.replace(/plugins:\s*\[(.*?)\]/s, (match, inner) => {
+        const items = inner
+          .split(',')
+          .map(item => item.trim())
+          .filter(Boolean);
+        items.push(plugin);
+        return `plugins: [${items.join(', ')}]`;
+      });
+    } else {
+      content = content.replace(/module\.exports\s*=\s*\{/, "module.exports = {\n  plugins: ['react-native-reanimated/plugin'],");
+    }
+  }
+
+  writeText(babelConfigPath, content.endsWith('\n') ? content : `${content}\n`, summary);
+}
+
+function ensureGestureHandlerImport(projectDir, summary) {
+  const entryPath = path.join(projectDir, 'index.js');
+  let content = readText(entryPath);
+
+  if (!content.includes("import 'react-native-gesture-handler';")) {
+    content = `import 'react-native-gesture-handler';\n${content}`;
+    writeText(entryPath, content, summary);
+  }
+}
+
+function resolveInstalledRnVersion(projectDir) {
+  const pkgPath = path.join(projectDir, 'node_modules', 'react-native', 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return null;
+  }
+  return JSON.parse(readText(pkgPath)).version;
+}
+
+async function verifyDependencyCompatibility(projectDir, summary) {
+  const result = await runCommand('npm', ['ls', '--depth=0'], {
+    cwd: projectDir,
+    allowFailure: true,
+  });
+
+  if (result.status !== 0 && result.output) {
+    const issues = result.output.split('\n')
+      .filter(line => /peer dep|ERESOLVE|invalid|missing peer/i.test(line))
+      .map(line => line.trim())
+      .filter(Boolean);
+
+    if (issues.length > 0) {
+      issues.forEach(issue => summary.warnings.add(`Dependency: ${issue}`));
+      console.log(`\nFound ${issues.length} compatibility issue(s). Attempting clean reinstall...`);
+      fs.rmSync(path.join(projectDir, 'node_modules'), {recursive: true, force: true});
+      fs.rmSync(path.join(projectDir, 'package-lock.json'), {force: true});
+      await runCommand('npm', ['install'], {cwd: projectDir});
+
+      const recheck = await runCommand('npm', ['ls', '--depth=0'], {
+        cwd: projectDir,
+        allowFailure: true,
+      });
+      if (recheck.status === 0) {
+        console.log('Compatibility issues resolved after reinstall.');
+      } else {
+        summary.warnings.add('Some dependency issues persist. Run npm ls manually to review.');
+      }
+    } else {
+      console.log('All dependencies are compatible.');
+    }
+  } else {
+    console.log('All dependencies are compatible.');
+  }
+}
+
+function seedEnvironmentFiles(projectDir, config, summary) {
+  const template = readText(path.join(templateDir, 'env-config.env'));
+  const files = [
+    {name: '.env', env: 'prod', url: config.prodApiBaseUrl},
+    {name: '.env.example', env: 'prod', url: config.prodApiBaseUrl},
+    {name: '.env.uat', env: 'uat', url: config.uatApiBaseUrl},
+    {name: '.env.staging', env: 'staging', url: config.stagingApiBaseUrl},
+    {name: '.env.prod', env: 'prod', url: config.prodApiBaseUrl},
+  ];
+
+  files.forEach(file => {
+    const content = template
+      .replace('__APP_ENV__', file.env)
+      .replace('__API_BASE_URL__', file.url);
+    writeText(path.join(projectDir, file.name), `${content}\n`, summary);
+  });
+}
+
+function createSrcStructure(projectDir) {
+  [
+    'src/assets/image',
+    'src/features/auth',
+    'src/features/dashboard',
+    'src/features/profile',
+    'src/components',
+    'src/services',
+    'src/navigation',
+    'src/hooks',
+    'src/utils',
+    'src/theme',
+    'src/store',
+  ].forEach(dir => {
+    fs.mkdirSync(path.join(projectDir, dir), {recursive: true});
+  });
+}
+
+function writeTemplate(projectDir, templateName, destination, summary) {
+  const content = readText(path.join(templateDir, templateName));
+  writeText(path.join(projectDir, destination), `${content.trimEnd()}\n`, summary);
+}
+
+function applyTemplates(projectDir, config, summary) {
+  createSrcStructure(projectDir);
+
+  writeTemplate(projectDir, 'api-setup.ts', 'src/services/api.ts', summary);
+  writeTemplate(projectDir, 'feature-auth-screen.tsx', 'src/features/auth/AuthScreen.tsx', summary);
+  writeTemplate(projectDir, 'feature-dashboard-screen.tsx', 'src/features/dashboard/DashboardScreen.tsx', summary);
+  writeTemplate(projectDir, 'feature-profile-screen.tsx', 'src/features/profile/ProfileScreen.tsx', summary);
+  writeTemplate(projectDir, 'component-primary-button.tsx', 'src/components/PrimaryButton.tsx', summary);
+  writeTemplate(projectDir, 'hook-use-app-boot.ts', 'src/hooks/useAppBoot.ts', summary);
+  writeTemplate(projectDir, 'utils-helpers.ts', 'src/utils/helpers.ts', summary);
+  writeTemplate(projectDir, 'theme-index.ts', 'src/theme/index.ts', summary);
+
+  if (config.enableNavigation) {
+    writeTemplate(projectDir, 'navigation-setup.tsx', 'src/navigation/RootNavigator.tsx', summary);
+  }
+
+  if (config.enableRedux) {
+    writeTemplate(projectDir, 'redux-store.ts', 'src/store/store.ts', summary);
+    writeTemplate(projectDir, 'redux-hooks.ts', 'src/store/hooks.ts', summary);
+    writeTemplate(projectDir, 'redux-session-slice.ts', 'src/features/auth/sessionSlice.ts', summary);
+  }
+}
+
+function buildAppContent(config, projectDir) {
+  const prefersTsx = fs.existsSync(path.join(projectDir, 'App.tsx')) || config.useTypeScript;
+  const returnType = prefersTsx ? ': React.JSX.Element' : '';
+  const lines = ["import React from 'react';"];
+
+  if (config.enableNavigation) {
+    lines.push("import {NavigationContainer} from '@react-navigation/native';");
+  }
+
+  if (config.enableRedux) {
+    lines.push("import {Provider} from 'react-redux';");
+  }
+
+  if (config.enableNavigation) {
+    lines.push("import RootNavigator from './src/navigation/RootNavigator';");
+  } else {
+    lines.push("import DashboardScreen from './src/features/dashboard/DashboardScreen';");
+  }
+
+  if (config.enableRedux) {
+    lines.push("import {store} from './src/store/store';");
+  }
+
+  lines.push('');
+  lines.push(`function App()${returnType} {`);
+
+  let body = config.enableNavigation
+    ? ['<NavigationContainer>', '  <RootNavigator />', '</NavigationContainer>']
+    : ['<DashboardScreen />'];
+
+  if (config.enableRedux) {
+    body = ['<Provider store={store}>', ...body.map(line => `  ${line}`), '</Provider>'];
+  }
+
+  lines.push('  return (');
+  body.forEach(line => lines.push(`    ${line}`));
+  lines.push('  );');
+  lines.push('}');
+  lines.push('');
+  lines.push('export default App;');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function writeAppEntrypoint(projectDir, config, summary) {
+  const appTsPath = path.join(projectDir, 'App.tsx');
+  const appJsPath = path.join(projectDir, 'App.js');
+  const target = fs.existsSync(appTsPath) || config.useTypeScript ? appTsPath : appJsPath;
+  const content = buildAppContent(config, projectDir);
+
+  writeText(target, content, summary);
+
+  if (!config.useTypeScript && fs.existsSync(appTsPath) && target === appJsPath) {
+    fs.rmSync(appTsPath, {force: true});
+  }
+}
+
+function buildAppTestContent(config) {
+  const lines = [
+    '/**',
+    ' * @format',
+    ' */',
+    '',
+    "import React from 'react';",
+    "import ReactTestRenderer from 'react-test-renderer';",
+  ];
+
+  if (config.enableNavigation) {
+    lines.push('');
+    lines.push("jest.mock('@react-navigation/native', () => ({");
+    lines.push('  NavigationContainer: ({children}: {children: React.ReactNode}) => children,');
+    lines.push('}));');
+    lines.push('');
+    lines.push("jest.mock('@react-navigation/native-stack', () => ({");
+    lines.push('  createNativeStackNavigator: () => ({');
+    lines.push('    Navigator: ({children}: {children: React.ReactNode}) => children,');
+    lines.push('    Screen: ({component: Component}: {component: React.ComponentType}) => <Component />,');
+    lines.push('  }),');
+    lines.push('}));');
+  }
+
+  if (config.enableRedux) {
+    lines.push('');
+    lines.push("jest.mock('react-redux', () => ({");
+    lines.push('  Provider: ({children}: {children: React.ReactNode}) => children,');
+    lines.push('  useDispatch: jest.fn(),');
+    lines.push('  useSelector: jest.fn(),');
+    lines.push('}));');
+    lines.push('');
+    lines.push("jest.mock('../src/store/store', () => ({");
+    lines.push('  store: {');
+    lines.push('    getState: () => ({}),');
+    lines.push('    dispatch: jest.fn(),');
+    lines.push('    subscribe: () => jest.fn(),');
+    lines.push('  },');
+    lines.push('}));');
+  }
+
+  lines.push('');
+  lines.push("import App from '../App';");
+  lines.push('');
+  lines.push("test('renders correctly', async () => {");
+  lines.push('  await ReactTestRenderer.act(() => {');
+  lines.push('    ReactTestRenderer.create(<App />);');
+  lines.push('  });');
+  lines.push('});');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function writeAppTest(projectDir, config, summary) {
+  writeText(
+    path.join(projectDir, '__tests__', 'App.test.tsx'),
+    buildAppTestContent(config),
+    summary,
+  );
+}
+
+function updatePackageScripts(projectDir, config, summary) {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  const packageJson = JSON.parse(readText(packageJsonPath));
+  packageJson.scripts = packageJson.scripts || {};
+
+  if (config.enableEnv) {
+    Object.assign(packageJson.scripts, {
+      'start:uat': 'cross-env ENVFILE=.env.uat react-native start',
+      'start:staging': 'cross-env ENVFILE=.env.staging react-native start',
+      'start:prod': 'cross-env ENVFILE=.env.prod react-native start',
+      'android:uat': 'cross-env ENVFILE=.env.uat react-native run-android',
+      'android:staging': 'cross-env ENVFILE=.env.staging react-native run-android',
+      'android:prod': 'cross-env ENVFILE=.env.prod react-native run-android',
+      'ios:uat': 'cross-env ENVFILE=.env.uat react-native run-ios',
+      'ios:staging': 'cross-env ENVFILE=.env.staging react-native run-ios',
+      'ios:prod': 'cross-env ENVFILE=.env.prod react-native run-ios',
+      'apk:uat': 'cross-env ENVFILE=.env.uat react-native build-android --mode=release',
+      'apk:staging': 'cross-env ENVFILE=.env.staging react-native build-android --mode=release',
+      'apk:prod': 'cross-env ENVFILE=.env.prod react-native build-android --mode=release',
+    });
+  }
+
+  writeText(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, summary);
+}
+
+async function runPreflightChecks(config, summary) {
+  const nodeMajor = Number(process.versions.node.split('.')[0]);
+  summary.runtime.nodeMajor = nodeMajor;
+  summary.runtime.cliVersion = nodeMajor >= 20 ? 'latest' : '18.0.0';
+
+  if (config.verificationTarget === 'android') {
+    const javaCheck = await runCommand('java', ['-version'], {allowFailure: true});
+    if (javaCheck.status !== 0) {
+      summary.warnings.add('Java was not detected during Android preflight.');
+    }
+
+    if (!process.env.ANDROID_HOME && !process.env.ANDROID_SDK_ROOT) {
+      summary.warnings.add('ANDROID_HOME or ANDROID_SDK_ROOT is not set.');
+    }
+  }
+
+  if (config.verificationTarget === 'ios') {
+    if (process.platform !== 'darwin') {
+      summary.warnings.add('iOS verification was requested on a non-macOS system.');
+      return;
+    }
+
+    const xcodeCheck = await runCommand('xcodebuild', ['-version'], {allowFailure: true});
+    const podCheck = await runCommand('pod', ['--version'], {allowFailure: true});
+
+    if (xcodeCheck.status !== 0) {
+      summary.warnings.add('xcodebuild was not detected during iOS preflight.');
+    }
+
+    if (podCheck.status !== 0) {
+      summary.warnings.add('CocoaPods was not detected during iOS preflight.');
+    }
+  }
+}
+
+async function verifyProject(projectDir, config, summary) {
+  const checks = [
+    {name: 'lint', command: 'npm', args: ['run', 'lint']},
+  ];
+
+  if (fs.existsSync(path.join(projectDir, 'tsconfig.json'))) {
+    checks.push({name: 'typecheck', command: 'npx', args: ['tsc', '--noEmit']});
+  }
+
+  checks.push({name: 'tests', command: 'npm', args: ['test', '--', '--watch=false']});
+
+  if (config.verificationTarget === 'android') {
+    checks.push({name: 'android', command: 'npm', args: ['run', 'android']});
+  }
+
+  if (config.verificationTarget === 'ios' && process.platform === 'darwin') {
+    checks.push({name: 'ios', command: 'npm', args: ['run', 'ios']});
+  }
+
+  for (const check of checks) {
+    try {
+      await runCommand(check.command, check.args, {cwd: projectDir});
+    } catch (error) {
+      const canRetryAndroidWithWorklets =
+        check.name === 'android' &&
+        config.enableNavigation &&
+        isWorkletsRelatedFailure(error);
+
+      if (!canRetryAndroidWithWorklets) {
+        throw error;
+      }
+
+      const addedWorklets = await ensureWorkletsDependency(projectDir, summary);
+
+      if (!addedWorklets) {
+        throw error;
+      }
+
+      await runCommand(check.command, check.args, {cwd: projectDir});
+    }
+
+    summary.verificationResults.set(check.name, 'passed');
+  }
+}
+
+async function maybeRunPodInstall(projectDir, config, summary) {
+  if (process.platform !== 'darwin') {
+    if (config.enableNavigation || config.enableEnv) {
+      summary.warnings.add('Skipping pod install because the current system is not macOS.');
+    }
+    return;
+  }
+
+  if (config.enableNavigation || config.enableEnv) {
+    await runCommand('pod', ['install'], {cwd: path.join(projectDir, 'ios')});
+  }
+}
+
+async function initializeProject(config, summary) {
+  const targetDir = path.join(process.cwd(), config.projectName);
+  summary.projectDir = targetDir;
+
+  if (fs.existsSync(targetDir)) {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+
+    if (!fs.existsSync(packageJsonPath)) {
+      throw new Error(`Target directory already exists and is not a React Native project: ${targetDir}`);
+    }
+
+    summary.warnings.add(
+      `Target directory already existed. Reusing ${targetDir} and continuing from the existing scaffold.`,
+    );
+  } else {
+    console.log('\nInitializing React Native app. This can take several minutes on first run.');
+    await runCommand(
+      'npx',
+      [
+        '--yes',
+        `@react-native-community/cli@${summary.runtime.cliVersion}`,
+        'init',
+        config.projectName,
+        '--version',
+        config.reactNativeVersion,
+      ],
+      {cwd: process.cwd()},
+    );
+  }
+
+  if (!config.useTypeScript) {
+    summary.warnings.add(
+      'JavaScript-only mode is not fully specialized; the generator keeps the default React Native TypeScript-capable scaffold.',
+    );
+  }
+
+  ensureTsconfig(targetDir, summary);
+
+  const resolvedRnVersion = resolveInstalledRnVersion(targetDir) || config.reactNativeVersion;
+  console.log(`\nResolved React Native version: ${resolvedRnVersion}`);
+
+  console.log('\n[1/6] Installing core packages (axios, react-native-config)...');
+  await installPackages(targetDir, ['axios', 'react-native-config'], summary);
+
+  if (config.enableNavigation) {
+    console.log('\n[2/6] Installing navigation packages...');
+    await installPackages(targetDir, getNavigationPackages(resolvedRnVersion), summary);
+    ensureReanimatedPlugin(targetDir, summary);
+    ensureGestureHandlerImport(targetDir, summary);
+  } else {
+    console.log('\n[2/6] Navigation skipped.');
+  }
+
+  if (config.enableRedux) {
+    console.log('\n[3/6] Installing Redux Toolkit...');
+    await installPackages(targetDir, ['@reduxjs/toolkit', 'react-redux'], summary);
+  } else {
+    console.log('\n[3/6] Redux skipped.');
+  }
+
+  if (config.enableEnv) {
+    console.log('\n[4/6] Installing environment config...');
+    await installPackages(
+      targetDir,
+      [summary.runtime.nodeMajor >= 20 ? 'cross-env@10' : 'cross-env@7.0.3'],
+      summary,
+      {dev: true},
+    );
+    seedEnvironmentFiles(targetDir, config, summary);
+  } else {
+    console.log('\n[4/6] Environment config skipped.');
+  }
+
+  console.log('\n[5/6] Applying templates and wiring entry point...');
+  applyTemplates(targetDir, config, summary);
+  writeAppEntrypoint(targetDir, config, summary);
+  writeAppTest(targetDir, config, summary);
+  updatePackageScripts(targetDir, config, summary);
+  await maybeRunPodInstall(targetDir, config, summary);
+
+  console.log('\n[6/6] Verifying dependency compatibility...');
+  await verifyDependencyCompatibility(targetDir, summary);
+}
+
+function printSummary(summary) {
+  console.log('\nCreated files:');
+  [...summary.createdFiles].sort().forEach(file => console.log(`- ${file}`));
+
+  console.log('\nUpdated files:');
+  [...summary.updatedFiles].sort().forEach(file => console.log(`- ${file}`));
+
+  console.log('\nInstalled packages:');
+  [...summary.installedPackages].sort().forEach(pkg => console.log(`- ${pkg}`));
+
+  console.log('\nVerification results:');
+  if (!summary.verificationResults.size) {
+    console.log('- verification skipped');
+  } else {
+    [...summary.verificationResults.entries()].forEach(([name, status]) => {
+      console.log(`- ${name}: ${status}`);
+    });
+  }
+
+  console.log('\nWarnings:');
+  if (!summary.warnings.size) {
+    console.log('- none');
+  } else {
+    [...summary.warnings].forEach(warning => console.log(`- ${warning}`));
+  }
+
+  console.log('\nNext command:');
+  if (summary.projectDir) {
+    console.log(`- cd ${summary.projectDir}`);
+    console.log('- npm run start');
+  } else {
+    console.log('- not available');
+  }
+}
+
+async function main() {
+  const config = await collectConfig(parseArgs(process.argv.slice(2)));
+  const summary = {
+    projectDir: '',
+    createdFiles: new Set(),
+    updatedFiles: new Set(),
+    installedPackages: new Set(),
+    verificationResults: new Map(),
+    warnings: new Set(),
+    runtime: {
+      nodeMajor: 0,
+      cliVersion: '',
+    },
+  };
+
+  await runPreflightChecks(config, summary);
+  await initializeProject(config, summary);
+  await verifyProject(summary.projectDir, config, summary);
+  printSummary(summary);
+}
+
+main().catch(error => {
+  console.error(`\nGenerator failed: ${error.message}`);
+  process.exitCode = 1;
+});