expo-forge 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 moasko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# Expo Forge - Bulletproof Expo Architecture
+
+Forge modern Expo apps with bulletproof architecture. Generate complete projects and features with TanStack Query, Zustand, and NativeWind.
+
+## Installation
+
+```bash
+npm install -g expo-forge
+```
+
+## Usage
+
+### Initialize a new Expo project
+
+```bash
+expo-forge init my-app
+```
+
+This creates:
+- ✅ New Expo project with create-expo-app
+- ✅ Modern dependencies installation
+- ✅ Bulletproof structure (src/api, src/features, etc.)
+- ✅ TanStack Query & Zustand configuration
+- ✅ Tailwind CSS with NativeWind setup
+
+### Generate a new feature
+
+```bash
+expo-forge generate feature booking
+```
+
+This creates a complete structure:
+```
+src/features/booking/
+├── api/              # TanStack Query hooks
+├── components/       # UI components
+├── hooks/            # Business logic
+├── services/         # API calls
+├── store/            # Zustand stores
+├── types/            # TypeScript types
+├── utils/            # Helpers
+├── BookingScreen.tsx # Main screen
+└── index.ts          # Exports
+```
+
+## Tech Stack
+
+- **React Native** - Mobile framework
+- **Expo** - React Native platform
+- **TanStack Query** - Async state management
+- **Zustand** - Local state management
+- **Axios** - HTTP client
+- **NativeWind** - Tailwind CSS for React Native
+- **Lucide** - Icons
+
+## Links
+
+- [GitHub Repository](https://github.com/moasko/expo-forge)
+- [Documentation](https://github.com/moasko/expo-forge#readme)
+- [Issues](https://github.com/moasko/expo-forge/issues)
+
+## License
+
+MIT - see LICENSE file for details.

package/bin/expo-forge.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const path = require('path');
+
+// Import our modules
+const initExpo = require('../lib/initExpo');
+const featureGenerator = require('../lib/featureGenerator');
+const logger = require('../lib/logger');
+
+program
+  .name('expo-forge')
+  .description('Forge modern Expo apps with bulletproof architecture')
+  .version('1.0.0');
+
+program
+  .command('init [projectName]')
+  .description('Initialize a new Expo project with bulletproof architecture')
+  .action(async (projectName) => {
+    try {
+      if (!projectName) {
+        logger.error('Please provide a project name: expo-forge init <projectName>');
+        process.exit(1);
+      }
+
+      logger.rocket(`Initializing Expo Forge project: ${projectName}`);
+      await initExpo.initializeProject(projectName);
+      logger.success(`Project ${projectName} created successfully!`);
+      logger.info(`Run: cd ${projectName} && npx expo start`);
+    } catch (error) {
+      logger.error(`Failed to initialize project: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('generate <type> <name>')
+  .description('Generate a new feature or component')
+  .action(async (type, name) => {
+    try {
+      if (type !== 'feature') {
+        logger.error('Currently only "feature" type is supported');
+        process.exit(1);
+      }
+
+      logger.build(`Generating ${type}: ${name}`);
+      await featureGenerator.generateFeature(name);
+      logger.success(`${type} ${name} generated successfully!`);
+    } catch (error) {
+      logger.error(`Failed to generate ${type}: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Add help examples
+program.addHelpText('after', `
+Examples:
+  $ expo-forge init my-app
+  $ expo-forge generate feature booking
+
+For more information, visit: https://github.com/moasko/expo-forge
+`);
+
+// Parse command line arguments
+program.parse();

package/lib/config.js

@@ -0,0 +1,50 @@
+/**
+ * Config - Configuration centralisée du projet
+ */
+
+const DEPENDENCIES = [
+  'expo-router',
+  'expo-constants',
+  'expo-linking',
+  'expo-status-bar',
+  'react-native-safe-area-context',
+  'react-native-screens',
+  '@tanstack/react-query',
+  'zustand',
+  'axios',
+  'lucide-react-native',
+  'nativewind',
+  'tailwindcss',
+  'typescript',
+  '@types/react',
+  '@types/react-native',
+];
+
+const FOLDER_STRUCTURE = [
+  'src/api',           // Clients API & Query Providers
+  'src/app',           // Routes (Expo Router)
+  'src/components/ui', // Composants atomiques réutilisables
+  'src/features',      // Logique par domaine
+  'src/hooks',         // Hooks globaux
+  'src/store',         // Zustand stores
+  'src/types',         // Interfaces TS globales
+  'src/utils',         // Fonctions helpers
+  'src/constants',     // Theme, API URLs
+  'src/lib',           // Utilitaires (API client, etc.)
+];
+
+const FEATURE_STRUCTURE = [
+  'api',        // Hooks TanStack Query
+  'components', // Composants UI
+  'hooks',      // Logique métier
+  'services',   // Appels API pure
+  'store',      // Zustand stores
+  'types',      // TypeScript types
+  'utils',      // Helpers et utilitaires
+];
+
+module.exports = {
+  DEPENDENCIES,
+  FOLDER_STRUCTURE,
+  FEATURE_STRUCTURE,
+};

package/lib/executor.js

@@ -0,0 +1,62 @@
+/**
+ * Executor - Gestion de l'exécution des commandes système
+ */
+
+const { execSync } = require('child_process');
+const logger = require('./logger');
+
+/**
+ * Exécute une commande avec affichage en direct
+ */
+const executeCommand = (command, options = {}) => {
+  const defaultOptions = {
+    stdio: 'inherit',
+    shell: true,
+    ...options,
+  };
+
+  try {
+    execSync(command, defaultOptions);
+    return true;
+  } catch (error) {
+    logger.error(`Erreur lors de l'exécution: ${command}`);
+    throw error;
+  }
+};
+
+/**
+ * Exécute une commande silencieusement (récupère le résultat)
+ */
+const executeCommandSilent = (command) => {
+  try {
+    const result = execSync(command, { encoding: 'utf-8' });
+    return result.trim();
+  } catch (error) {
+    throw error;
+  }
+};
+
+/**
+ * Change le répertoire courant
+ */
+const changeDirectory = (dirPath) => {
+  try {
+    process.chdir(dirPath);
+    return true;
+  } catch (error) {
+    logger.error(`Impossible de changer de répertoire: ${dirPath}`);
+    throw error;
+  }
+};
+
+/**
+ * Obtient le répertoire courant
+ */
+const getCurrentDirectory = () => process.cwd();
+
+module.exports = {
+  executeCommand,
+  executeCommandSilent,
+  changeDirectory,
+  getCurrentDirectory,
+};

package/lib/featureGenerator.js

@@ -0,0 +1,68 @@
+/**
+ * FeatureGenerator - Logique de génération de features modulaires
+ */
+
+const path = require('path');
+const { createDirectories, writeFiles } = require('./fileWriter');
+const { featureTemplates } = require('./templates');
+const { FEATURE_STRUCTURE } = require('./config');
+const { pascalCase } = require('./helpers');
+const logger = require('./logger');
+
+const validateFeatureName = (name) => {
+  if (!name || typeof name !== 'string') {
+    logger.error('Nom de feature requis (ex: booking)');
+    process.exit(1);
+  }
+  return true;
+};
+
+const generateModernFeature = (featureName) => {
+  validateFeatureName(featureName);
+
+  const nameUpper = pascalCase(featureName);
+  const nameLower = featureName.toLowerCase();
+  const baseDir = path.join(process.cwd(), 'src', 'features', nameLower);
+
+  logger.build(`Construction de la feature: ${nameUpper}`);
+
+  try {
+    // 1. Créer la structure de dossiers
+    logger.section('ÉTAPE 1: Création de l\'arborescence');
+    createDirectories(baseDir, FEATURE_STRUCTURE);
+
+    // 2. Générer les fichiers
+    logger.section('ÉTAPE 2: Génération des fichiers');
+    const files = {
+      'types/index.ts': featureTemplates.types(nameUpper),
+      [`services/${nameLower}.service.ts`]: featureTemplates.service(nameLower, nameUpper),
+      [`api/use${nameUpper}s.ts`]: featureTemplates.queries(nameUpper, nameLower),
+      [`store/use${nameUpper}Store.ts`]: featureTemplates.store(nameUpper),
+      [`components/${nameUpper}Card.tsx`]: featureTemplates.card(nameUpper),
+      [`${nameUpper}Screen.tsx`]: featureTemplates.screen(nameUpper, nameLower),
+      'index.ts': featureTemplates.index(nameUpper),
+    };
+
+    writeFiles(baseDir, files);
+
+    // 3. Afficher le message de succès
+    logger.section('✅ SUCCÈS');
+    logger.sparkle(`Feature "${nameUpper}" créée avec succès!`);
+    console.log(`
+📚 Structure générée:
+  📁 types/        - Définitions TypeScript
+  📁 services/     - Logique API (Axios)
+  📁 api/          - Hooks TanStack Query
+  📁 store/        - Zustand stores
+  📁 components/   - Composants UI
+  
+💡 Prêt à utiliser:
+  import { ${nameUpper}Screen } from '@/features/${nameLower}';
+    `);
+  } catch (error) {
+    logger.error(`Génération échouée: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = { generateModernFeature, validateFeatureName };

package/lib/fileWriter.js

@@ -0,0 +1,89 @@
+/**
+ * FileWriter - Gestion de la création de fichiers et répertoires
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('./logger');
+
+/**
+ * Crée les répertoires s'ils n'existent pas
+ */
+const createDirectories = (baseDir, folders) => {
+  folders.forEach((dir) => {
+    const fullPath = path.join(baseDir, dir);
+    try {
+      fs.mkdirSync(fullPath, { recursive: true });
+    } catch (error) {
+      logger.error(`Impossible de créer le dossier: ${dir}`);
+      throw error;
+    }
+  });
+};
+
+/**
+ * Écrit un ensemble de fichiers
+ */
+const writeFiles = (baseDir, filesObject) => {
+  Object.entries(filesObject).forEach(([filePath, content]) => {
+    const fullPath = path.join(baseDir, filePath);
+    const dir = path.dirname(fullPath);
+
+    // Créer le répertoire parent s'il n'existe pas
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    try {
+      fs.writeFileSync(fullPath, content, 'utf-8');
+      logger.success(`${filePath}`);
+    } catch (error) {
+      logger.error(`Impossible d'écrire le fichier: ${filePath}`);
+      throw error;
+    }
+  });
+};
+
+/**
+ * Écrit un fichier unique
+ */
+const writeFile = (filePath, content) => {
+  const dir = path.dirname(filePath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  try {
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return true;
+  } catch (error) {
+    logger.error(`Impossible d'écrire le fichier: ${filePath}`);
+    throw error;
+  }
+};
+
+/**
+ * Vérifie si un répertoire existe
+ */
+const directoryExists = (dirPath) => fs.existsSync(dirPath);
+
+/**
+ * Lit le contenu d'un fichier
+ */
+const readFile = (filePath) => {
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    logger.error(`Impossible de lire le fichier: ${filePath}`);
+    throw error;
+  }
+};
+
+module.exports = {
+  createDirectories,
+  writeFiles,
+  writeFile,
+  directoryExists,
+  readFile,
+};

package/lib/helpers.js

@@ -0,0 +1,30 @@
+/**
+ * Helpers - Fonctions utilitaires générales
+ */
+
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+const pascalCase = (str) => capitalize(str.toLowerCase());
+
+const camelCase = (str) => {
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+};
+
+const snakeCase = (str) => str.toLowerCase().replace(/\s/g, '_');
+
+const kebabCase = (str) => str.toLowerCase().replace(/\s/g, '-');
+
+const formatPath = (basePath, subPath) => {
+  const path = require('path');
+  return path.join(basePath, subPath);
+};
+
+module.exports = {
+  capitalize,
+  pascalCase,
+  camelCase,
+  snakeCase,
+  kebabCase,
+  formatPath,
+};

package/lib/index.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * Expo Forge - Main Entry Point
+ * Forge modern Expo apps with bulletproof architecture
+ */
+
+const { initializeProject } = require('./initExpo');
+const { generateModernFeature } = require('./featureGenerator');
+const logger = require('./logger');
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subCommand = args[1];
+const name = args[2];
+
+console.log(`
+🔥 EXPO FORGE 🔥
+Forge modern Expo apps with bulletproof architecture
+`);
+
+if (!command) {
+  showHelp();
+  process.exit(0);
+}
+
+switch (command) {
+  case 'init':
+    const projectName = name || 'my-expo-app';
+    logger.info(`Initializing new Expo project: ${projectName}`);
+    initializeProject(projectName);
+    break;
+
+  case 'generate':
+    if (subCommand === 'feature' && name) {
+      logger.info(`Generating feature: ${name}`);
+      generateModernFeature(name);
+    } else {
+      logger.error('Usage: expo-forge generate feature <name>');
+      process.exit(1);
+    }
+    break;
+
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+
+  case '--version':
+  case '-v':
+    showVersion();
+    break;
+
+  default:
+    logger.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}
+
+function showHelp() {
+  console.log(`
+Usage:
+  expo-forge init [project-name]     Initialize a new Expo project
+  expo-forge generate feature <name> Generate a new feature
+
+Examples:
+  expo-forge init my-awesome-app
+  expo-forge generate feature booking
+  expo-forge generate feature payment
+
+Options:
+  -h, --help     Show this help message
+  -v, --version  Show version information
+
+For more information, visit: https://github.com/moasko/expo-forge
+`);
+}
+
+function showVersion() {
+  const package = require('../package.json');
+  console.log(`${package.version}`);
+}

package/lib/initExpo.js

@@ -0,0 +1,69 @@
+/**
+ * InitExpo - Logique d'initialisation du projet Expo
+ */
+
+const path = require('path');
+const { executeCommand, changeDirectory } = require('./executor');
+const { createDirectories, writeFiles } = require('./fileWriter');
+const { initTemplates } = require('./templates');
+const { DEPENDENCIES, FOLDER_STRUCTURE } = require('./config');
+const logger = require('./logger');
+
+const initializeProject = (projectName = 'my-modern-app') => {
+  const projectPath = path.join(process.cwd(), projectName);
+
+  logger.rocket(`Initialisation d'un projet Expo Ultra-Moderne: ${projectName}`);
+
+  try {
+    // 1. Créer le projet avec Expo
+    logger.section('ÉTAPE 1: Création du projet');
+    executeCommand(`npx create-expo-app@latest ${projectName} --template blank-typescript`);
+
+    // 2. Changer le répertoire
+    changeDirectory(projectPath);
+
+    // 3. Installer les dépendances
+    logger.section('ÉTAPE 2: Installation des dépendances');
+    logger.package('Installation des frameworks modernes...');
+    executeCommand(`npx expo install ${DEPENDENCIES.join(' ')}`);
+
+    // 4. Créer la structure de dossiers
+    logger.section('ÉTAPE 3: Création de l\'arborescence');
+    createDirectories(projectPath, FOLDER_STRUCTURE);
+    logger.success('Structure de dossiers créée');
+
+    // 5. Générer les fichiers de configuration
+    logger.section('ÉTAPE 4: Génération des fichiers');
+    const files = {
+      'src/api/query-client.ts': initTemplates.queryClient(),
+      'src/store/useAuthStore.ts': initTemplates.authStore(),
+      'src/app/_layout.tsx': initTemplates.rootLayout(),
+      'src/app/index.tsx': initTemplates.homeScreen(),
+      'tailwind.config.js': initTemplates.tailwindConfig(),
+      'tsconfig.json': initTemplates.tsconfig(),
+      '.env.example': initTemplates.envExample(),
+    };
+
+    writeFiles(projectPath, files);
+
+    // 6. Afficher le message de succès
+    logger.section('✅ SUCCÈS');
+    logger.sparkle('Projet initialisé avec succès!');
+    console.log(`
+Pour démarrer:
+  1. cd ${projectName}
+  2. npx expo start
+
+Structure:
+  📁 src/features  - Pour tes modules métiers
+  📁 src/app       - Pour tes pages (navigation auto)
+  🚀 TanStack Query & Zustand configurés
+  🎨 NativeWind & Tailwind CSS prêts
+    `);
+  } catch (error) {
+    logger.error(`Initialisation échouée: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = { initializeProject };

package/lib/logger.js

@@ -0,0 +1,26 @@
+/**
+ * Logger - Gestion des messages formatés
+ */
+
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+const logger = {
+  success: (msg) => console.log(`${colors.green}✅ ${msg}${colors.reset}`),
+  error: (msg) => console.error(`${colors.red}❌ ${msg}${colors.reset}`),
+  info: (msg) => console.log(`${colors.blue}ℹ️  ${msg}${colors.reset}`),
+  warning: (msg) => console.warn(`${colors.yellow}⚠️  ${msg}${colors.reset}`),
+  build: (msg) => console.log(`${colors.cyan}🏗️  ${msg}${colors.reset}`),
+  rocket: (msg) => console.log(`${colors.cyan}🚀 ${msg}${colors.reset}`),
+  package: (msg) => console.log(`${colors.blue}📦 ${msg}${colors.reset}`),
+  sparkle: (msg) => console.log(`${colors.green}✨ ${msg}${colors.reset}`),
+  section: (msg) => console.log(`\n${colors.cyan}──── ${msg} ────${colors.reset}\n`),
+};
+
+module.exports = logger;

package/lib/templates.js

@@ -0,0 +1,293 @@
+/**
+ * Templates - Tous les fichiers templates par domaine
+ */
+
+/**
+ * Templates pour l'initialisation d'un projet Expo
+ */
+const initTemplates = {
+  queryClient: () => `import { QueryClient } from '@tanstack/react-query';
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      retry: 2,
+      staleTime: 1000 * 60 * 5,
+    },
+  },
+});`,
+
+  authStore: () => `import { create } from 'zustand';
+
+interface AuthState {
+  user: any | null;
+  setUser: (user: any) => void;
+  logout: () => void;
+}
+
+export const useAuthStore = create<AuthState>((set) => ({
+  user: null,
+  setUser: (user) => set({ user }),
+  logout: () => set({ user: null }),
+}));`,
+
+  rootLayout: () => `import { Stack } from 'expo-router';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { queryClient } from '../api/query-client';
+
+export default function RootLayout() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <Stack screenOptions={{ headerShown: false }}>
+        <Stack.Screen name="index" />
+      </Stack>
+    </QueryClientProvider>
+  );
+}`,
+
+  homeScreen: () => `import { View, Text } from 'react-native';
+
+export default function HomeScreen() {
+  return (
+    <View className="flex-1 items-center justify-center bg-white">
+      <Text className="text-2xl font-bold text-blue-600">Expo 2026 Stack</Text>
+      <Text className="text-gray-500 mt-2">TanStack Query • Zustand • NativeWind</Text>
+    </View>
+  );
+}`,
+
+  tailwindConfig: () => `module.exports = {
+  content: [
+    './App.{js,jsx,ts,tsx}',
+    './src/**/*.{js,jsx,ts,tsx}',
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};`,
+
+  envExample: () => `EXPO_PUBLIC_API_URL=https://api.example.com
+EXPO_PUBLIC_API_TIMEOUT=30000`,
+
+  tsconfig: () => `{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}`,
+
+  packageJson: () => `{
+  "name": "my-modern-app",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "expo start",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web"
+  }
+}`,
+};
+
+/**
+ * Templates pour la génération de features
+ * Utilise des fonctions pour interpoler les variables
+ */
+const featureTemplates = {
+  types: (nameUpper) => `export type ${nameUpper} = {
+  id: string;
+  title: string;
+  status: 'pending' | 'completed';
+  createdAt: string;
+};
+
+export type Create${nameUpper}DTO = Pick<${nameUpper}, 'title'>;
+
+export type Update${nameUpper}DTO = Partial<${nameUpper}>;`,
+
+  service: (nameLower, nameUpper) => `import { apiClient } from '@/lib/api-client';
+import { ${nameUpper}, Create${nameUpper}DTO, Update${nameUpper}DTO } from '../types';
+
+const BASE_URL = '/${nameLower}';
+
+export const ${nameLower}Service = {
+  getAll: async (): Promise<${nameUpper}[]> => {
+    const { data } = await apiClient.get(BASE_URL);
+    return data;
+  },
+
+  getById: async (id: string): Promise<${nameUpper}> => {
+    const { data } = await apiClient.get(\`\${BASE_URL}/\${id}\`);
+    return data;
+  },
+
+  create: async (payload: Create${nameUpper}DTO): Promise<${nameUpper}> => {
+    const { data } = await apiClient.post(BASE_URL, payload);
+    return data;
+  },
+
+  update: async (id: string, payload: Update${nameUpper}DTO): Promise<${nameUpper}> => {
+    const { data } = await apiClient.patch(\`\${BASE_URL}/\${id}\`, payload);
+    return data;
+  },
+
+  delete: async (id: string): Promise<void> => {
+    await apiClient.delete(\`\${BASE_URL}/\${id}\`);
+  },
+};`,
+
+  queries: (nameUpper, nameLower) => `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { ${nameLower}Service } from '../services/${nameLower}.service';
+import { Create${nameUpper}DTO, Update${nameUpper}DTO } from '../types';
+
+const QUERY_KEY = ['${nameLower}'];
+
+export const use${nameUpper}s = () => {
+  return useQuery({
+    queryKey: QUERY_KEY,
+    queryFn: ${nameLower}Service.getAll,
+  });
+};
+
+export const use${nameUpper} = (id: string) => {
+  return useQuery({
+    queryKey: [...QUERY_KEY, id],
+    queryFn: () => ${nameLower}Service.getById(id),
+  });
+};
+
+export const useCreate${nameUpper} = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ${nameLower}Service.create,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: QUERY_KEY });
+    },
+  });
+};
+
+export const useUpdate${nameUpper} = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Update${nameUpper}DTO }) =>
+      ${nameLower}Service.update(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: QUERY_KEY });
+    },
+  });
+};
+
+export const useDelete${nameUpper} = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ${nameLower}Service.delete,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: QUERY_KEY });
+    },
+  });
+};`,
+
+  store: (nameUpper) => `import { create } from 'zustand';
+
+interface ${nameUpper}State {
+  filter: string;
+  sortBy: 'date' | 'title';
+  setFilter: (filter: string) => void;
+  setSortBy: (sortBy: 'date' | 'title') => void;
+}
+
+export const use${nameUpper}Store = create<${nameUpper}State>((set) => ({
+  filter: '',
+  sortBy: 'date',
+  setFilter: (filter) => set({ filter }),
+  setSortBy: (sortBy) => set({ sortBy }),
+}));`,
+
+  card: (nameUpper) => `import React from 'react';
+import { View, Text, Pressable } from 'react-native';
+import { ${nameUpper} } from '../types';
+
+interface Props {
+  item: ${nameUpper};
+  onPress: (id: string) => void;
+}
+
+export const ${nameUpper}Card = ({ item, onPress }: Props) => (
+  <Pressable
+    onPress={() => onPress(item.id)}
+    className="p-4 bg-white border border-gray-200 rounded-lg shadow-sm hover:bg-gray-50"
+  >
+    <Text className="text-lg font-semibold text-gray-800">{item.title}</Text>
+    <View className="flex-row justify-between items-center mt-2">
+      <Text className="text-sm text-gray-500">{new Date(item.createdAt).toLocaleDateString()}</Text>
+      <Text className={\`text-xs font-medium \${item.status === 'completed' ? 'text-green-600' : 'text-yellow-600'}\`}>
+        {item.status}
+      </Text>
+    </View>
+  </Pressable>
+);`,
+
+  screen: (nameUpper, nameLower) => `import React from 'react';
+import { View, FlatList, Text, ActivityIndicator } from 'react-native';
+import { use${nameUpper}s } from './api/use${nameUpper}s';
+import { ${nameUpper}Card } from './components/${nameUpper}Card';
+import { use${nameUpper}Store } from './store/use${nameUpper}Store';
+
+export const ${nameUpper}Screen = () => {
+  const { data: items, isLoading, error } = use${nameUpper}s();
+  const { filter } = use${nameUpper}Store();
+
+  if (isLoading) {
+    return (
+      <View className="flex-1 items-center justify-center">
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
+  if (error) {
+    return (
+      <View className="flex-1 items-center justify-center">
+        <Text className="text-red-500 font-semibold">Erreur lors du chargement</Text>
+      </View>
+    );
+  }
+
+  const filteredItems = items?.filter((i) =>
+    i.title.toLowerCase().includes(filter.toLowerCase())
+  ) || [];
+
+  return (
+    <View className="flex-1 bg-white">
+      <FlatList
+        data={filteredItems}
+        renderItem={({ item }) => (
+          <${nameUpper}Card
+            item={item}
+            onPress={(id) => console.log('Navigate to:', id)}
+          />
+        )}
+        keyExtractor={(item) => item.id}
+        contentContainerStyle={{ padding: 16 }}
+        ListEmptyComponent={
+          <Text className="text-center text-gray-500">Aucun ${nameLower} trouvé</Text>
+        }
+      />
+    </View>
+  );
+};`,
+
+  index: (nameUpper) => `export * from './store/use${nameUpper}Store';
+export { use${nameUpper}s, useCreate${nameUpper}, useUpdate${nameUpper}, useDelete${nameUpper} } from './api/use${nameUpper}s';
+export { ${nameUpper}Screen } from './${nameUpper}Screen';`,
+};
+
+module.exports = {
+  initTemplates,
+  featureTemplates,
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "expo-forge",
+  "version": "2.0.0",
+  "description": "Forge modern Expo apps with bulletproof architecture - TanStack Query, Zustand, NativeWind",
+  "author": "moasko <moasko.dev@gmail.com>",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "expo",
+    "react-native",
+    "generator",
+    "scaffold",
+    "cli",
+    "typescript",
+    "tanstack-query",
+    "zustand",
+    "nativewind",
+    "bulletproof",
+    "architecture",
+    "mobile",
+    "cross-platform"
+  ],
+  "scripts": {
+    "init": "node init-expo.js",
+    "init:custom": "node init-expo.js $npm_config_name",
+    "gen": "node generate-feature.js generate feature",
+    "gen:feature": "node generate-feature.js generate feature $npm_config_name",
+    "help": "echo 'Usage: npm run init [projectName] or npm run gen:feature -- --name=featureName'",
+    "test": "node test.js",
+    "prepublishOnly": "npm run test",
+    "publish:beta": "npm publish --tag beta",
+    "publish:latest": "npm publish",
+    "pack": "npm pack",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
+  },
+  "dependencies": {
+    "commander": "^11.1.0"
+  },
+  "bin": {
+    "expo-forge": "bin/expo-forge.js"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moasko/expo-forge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/moasko/expo-forge/issues"
+  },
+  "homepage": "https://github.com/moasko/expo-forge#readme"
+}