i18nsmith 0.3.3 → 0.4.0

package/src/commands/init.ts

@@ -3,9 +3,10 @@ import inquirer from 'inquirer';
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
-import { diagnoseWorkspace, I18nConfig, TranslationConfig, ensureGitignore } from '@i18nsmith/core';
+import { diagnoseWorkspace, I18nConfig, TranslationConfig, ensureGitignore, ProjectIntelligenceService, type ProjectIntelligence, type SuggestedConfig, Scanner, KeyGenerator } from '@i18nsmith/core';
 import { scaffoldTranslationContext, scaffoldI18next } from '../utils/scaffold.js';
 import { hasDependency, readPackageJson } from '../utils/pkg.js';
+import { detectPackageManager, installDependencies } from '../utils/package-manager.js';
 import { CliError, withErrorHandling } from '../utils/errors.js';
 
 /**
@@ -41,9 +42,14 @@ export function parseGlobList(value: string): string[] {
 interface InitCommandOptions {
   merge?: boolean;
   yes?: boolean;
+  template?: string;
+  scaffold?: boolean;
 }
 
 interface InitAnswers {
+  setupMode?: 'auto' | 'template' | 'manual';
+  template?: string;
+  confirmAuto?: boolean;
   sourceLanguage: string;
   targetLanguages: string;
   localesDir: string;
@@ -65,9 +71,22 @@ interface InitAnswers {
   seedTargetLocales: boolean;
 }
 
+/**
+ * Run project intelligence detection to gather smart defaults.
+ */
+async function detectProjectIntelligence(workspaceRoot: string): Promise<ProjectIntelligence | null> {
+  try {
+    const service = new ProjectIntelligenceService();
+    const result = await service.analyze({ workspaceRoot });
+    return result;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Run init in non-interactive mode with sensible defaults.
- * Auto-detects existing adapters and locales.
+ * Uses ProjectIntelligenceService for smart detection.
  */
 async function runNonInteractiveInit(commandOptions: InitCommandOptions): Promise<void> {
   const workspaceRoot = process.cwd();
@@ -85,97 +104,92 @@ async function runNonInteractiveInit(commandOptions: InitCommandOptions): Promis
     // Config doesn't exist, proceed
   }
 
-  // Create a minimal config for diagnostics
-  const minimalConfig: I18nConfig = {
-    version: 1 as const,
-    sourceLanguage: 'en',
-    targetLanguages: [],
-    localesDir: 'locales',
-    include: ['src/**/*.{ts,tsx,js,jsx}'],
-    exclude: ['node_modules/**'],
-    minTextLength: 1,
-    translation: { provider: 'manual' },
-    translationAdapter: { module: 'react-i18next', hookName: 'useTranslation' },
-    keyGeneration: { namespace: 'common', shortHashLen: 6 },
-    seedTargetLocales: false,
-  };
+  console.log(chalk.blue('🔍 Detecting project configuration...'));
 
-  // Try to detect existing setup
-  let detectedAdapter: string | undefined;
-  let detectedLocales: string[] = [];
+  // Use ProjectIntelligenceService for detection
+  const intelligence = await detectProjectIntelligence(workspaceRoot);
 
-  try {
-    const report = await diagnoseWorkspace(minimalConfig, { workspaceRoot });
+  let suggestedConfig: SuggestedConfig;
+
+  if (intelligence) {
+    const { framework, locales, filePatterns, confidence } = intelligence;
     
-    // Detect adapter files
-    if (report.adapterFiles.length > 0) {
-      detectedAdapter = report.adapterFiles[0].path;
-      console.log(chalk.blue(`Detected adapter: ${detectedAdapter}`));
+    // Report detection results
+    if (framework.type !== 'unknown') {
+      console.log(chalk.green(`  ✓ Framework: ${framework.type}`));
     }
-
-    // Detect existing locales
-    const existingLocales = report.localeFiles.filter(
-      (entry) => !entry.missing && !entry.parseError
-    );
-    if (existingLocales.length > 0) {
-      detectedLocales = existingLocales.map((entry) => entry.locale);
-      console.log(chalk.blue(`Detected locales: ${detectedLocales.join(', ')}`));
+    if (framework.adapter) {
+      console.log(chalk.green(`  ✓ i18n Adapter: ${framework.adapter}`));
+    }
+    if (locales.existingFiles.length > 0) {
+      const langs = [locales.sourceLanguage, ...locales.targetLanguages].filter(Boolean);
+      console.log(chalk.green(`  ✓ Locales: ${langs.join(', ')}`));
+    }
+    if (filePatterns.sourceDirectories.length > 0) {
+      console.log(chalk.green(`  ✓ Source directories: ${filePatterns.sourceDirectories.slice(0, 3).join(', ')}${filePatterns.sourceDirectories.length > 3 ? '...' : ''}`));
     }
-  } catch (error) {
-    console.log(chalk.dim(`Could not run diagnostics: ${(error as Error).message}`));
-  }
 
-  // Determine source and target languages from detected locales
-  let sourceLanguage = 'en';
-  let targetLanguages: string[] = [];
-  
-  if (detectedLocales.length > 0) {
-    // Use 'en' as source if present, otherwise first detected locale
-    if (detectedLocales.includes('en')) {
-      sourceLanguage = 'en';
-      targetLanguages = detectedLocales.filter((l) => l !== 'en');
+    // Use template if specified, otherwise use detected config
+    if (commandOptions.template) {
+      const service = new ProjectIntelligenceService();
+      suggestedConfig = service.applyTemplate(commandOptions.template, intelligence);
+      console.log(chalk.green(`  ✓ Template: ${commandOptions.template}`));
     } else {
-      sourceLanguage = detectedLocales[0];
-      targetLanguages = detectedLocales.slice(1);
+      suggestedConfig = intelligence.suggestedConfig;
     }
+
+    // Report confidence
+    const confidencePercent = Math.round(intelligence.confidence.overall * 100);
+    const confidenceColor = intelligence.confidence.level === 'high' ? chalk.green : intelligence.confidence.level === 'medium' ? chalk.yellow : chalk.red;
+    console.log(confidenceColor(`  Detection confidence: ${confidencePercent}% (${intelligence.confidence.level})`));
+
+    // Check for low confidence in non-interactive mode
+    if (intelligence.confidence.level === 'low' || intelligence.confidence.level === 'uncertain') {
+      console.log(chalk.red('\n❌ Detection confidence is too low for automatic setup.'));
+      console.log(chalk.dim('This could lead to incorrect configuration choices.'));
+      console.log(chalk.blue('\nSuggestions:'));
+      console.log(chalk.cyan('  • Use --template <name> to specify your framework explicitly'));
+      console.log(chalk.cyan('  • Run without --yes for interactive setup'));
+      console.log(chalk.cyan('  • Check that your project has clear framework indicators (package.json, config files)'));
+      throw new CliError('Detection confidence too low for non-interactive mode. Use --template or run interactively.');
+    }
+  } else {
+    // Fallback when detection fails completely
+    console.log(chalk.red('❌ Project analysis failed.'));
+    console.log(chalk.dim('Unable to detect project configuration automatically.'));
+    console.log(chalk.blue('\nSuggestions:'));
+    console.log(chalk.cyan('  • Use --template <name> to specify your framework explicitly'));
+    console.log(chalk.cyan('  • Run without --yes for interactive setup'));
+    console.log(chalk.cyan('  • Ensure package.json exists and contains framework dependencies'));
+    throw new CliError('Project analysis failed. Use --template or run interactively.');
   }
 
-  // Build the config
+  // Build config from suggested values
   const config: I18nConfig = {
     version: 1 as const,
-    sourceLanguage,
-    targetLanguages,
-    localesDir: 'locales',
-    include: [
-      'src/**/*.{ts,tsx,js,jsx}',
-      'app/**/*.{ts,tsx,js,jsx}',
-      'pages/**/*.{ts,tsx,js,jsx}',
-      'components/**/*.{ts,tsx,js,jsx}',
-    ],
-    exclude: ['node_modules/**', '**/*.test.*'],
+    sourceLanguage: suggestedConfig.sourceLanguage,
+    targetLanguages: suggestedConfig.targetLanguages,
+    localesDir: suggestedConfig.localesDir,
+    include: suggestedConfig.include,
+    exclude: suggestedConfig.exclude,
     minTextLength: 1,
     translation: { provider: 'manual' },
     translationAdapter: {
-      module: detectedAdapter ?? 'react-i18next',
-      hookName: 'useTranslation',
-    },
-    keyGeneration: {
-      namespace: 'common',
-      shortHashLen: 6,
+      module: suggestedConfig.translationAdapter.module,
+      hookName: suggestedConfig.translationAdapter.hookName,
     },
+    keyGeneration: suggestedConfig.keyGeneration,
     seedTargetLocales: false,
   };
 
   try {
     await fs.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(chalk.green(`\n✓ Configuration created at ${configPath}`));
-    console.log(chalk.dim('  Source language: ' + sourceLanguage));
-    if (targetLanguages.length > 0) {
-      console.log(chalk.dim('  Target languages: ' + targetLanguages.join(', ')));
-    }
-    if (detectedAdapter) {
-      console.log(chalk.dim('  Adapter: ' + detectedAdapter));
+    console.log(chalk.dim('  Source language: ' + config.sourceLanguage));
+    if (config.targetLanguages.length > 0) {
+      console.log(chalk.dim('  Target languages: ' + config.targetLanguages.join(', ')));
     }
+    console.log(chalk.dim('  Adapter: ' + (config.translationAdapter?.module ?? 'react-i18next')));
 
     // Ensure .gitignore has i18nsmith artifacts
     const gitignoreResult = await ensureGitignore(workspaceRoot);
@@ -183,6 +197,149 @@ async function runNonInteractiveInit(commandOptions: InitCommandOptions): Promis
       console.log(chalk.green(`✓ Updated .gitignore with i18nsmith artifacts`));
     }
 
+    // Create a minimal source locale file to avoid immediate "missing source locale" diagnostics
+    try {
+      const localesDirPath = path.join(workspaceRoot, config.localesDir || 'locales');
+      await fs.mkdir(localesDirPath, { recursive: true });
+      const sourceLocalePath = path.join(localesDirPath, `${config.sourceLanguage}.json`);
+      // Only create if it doesn't already exist
+      try {
+        await fs.access(sourceLocalePath);
+      } catch {
+        await fs.writeFile(sourceLocalePath, JSON.stringify({}, null, 2));
+        console.log(chalk.green(`✓ Created source locale file at ${sourceLocalePath}`));
+      }
+    } catch (err) {
+      console.log(chalk.yellow('Could not create source locale file automatically. You can create it at <localesDir>/<sourceLanguage>.json'));
+    }
+
+    // Seed source locale with detected keys to avoid immediate "missing-key" diagnostics
+    try {
+      console.log(chalk.blue('🔍 Scanning for existing hardcoded text...'));
+      const scanner = await Scanner.create(config, { workspaceRoot });
+      const scanResult = await scanner.scan();
+      
+      if (scanResult.buckets.highConfidence.length > 0) {
+        const sourceLocalePath = path.join(workspaceRoot, config.localesDir || 'locales', `${config.sourceLanguage}.json`);
+        
+        // Read existing content or create empty object
+        let existingKeys: Record<string, string> = {};
+        try {
+          const content = await fs.readFile(sourceLocalePath, 'utf-8');
+          existingKeys = JSON.parse(content);
+        } catch {
+          // File doesn't exist or is invalid, start with empty
+        }
+        
+        // Generate keys for high-confidence candidates
+        const keyGenerator = new KeyGenerator({
+          namespace: config.keyGeneration?.namespace || 'common',
+          hashLength: config.keyGeneration?.shortHashLen || 6,
+          workspaceRoot,
+        });
+        
+        let keysAdded = 0;
+        for (const candidate of scanResult.buckets.highConfidence) {
+          const generated = keyGenerator.generate(candidate.text, {
+            filePath: candidate.filePath,
+            kind: candidate.kind,
+            context: candidate.context,
+          });
+          
+          if (!existingKeys[generated.key]) {
+            existingKeys[generated.key] = candidate.text;
+            keysAdded++;
+          }
+        }
+        
+        if (keysAdded > 0) {
+          await fs.writeFile(sourceLocalePath, JSON.stringify(existingKeys, null, 2));
+          console.log(chalk.green(`✓ Seeded source locale with ${keysAdded} detected keys`));
+        } else {
+          console.log(chalk.dim('  No new keys to seed (all detected keys already exist)'));
+        }
+      } else {
+        console.log(chalk.dim('  No high-confidence hardcoded text detected'));
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`Could not seed locale with detected keys: ${(error as Error).message}`));
+    }
+
+    // Auto-scaffold adapter if requested and conditions are met
+    let scaffolded = false;
+    if (commandOptions.scaffold && intelligence && intelligence.confidence.level === 'high' && intelligence.existingSetup.runtimePackages.length === 0) {
+      console.log(chalk.blue('\n🔧 Auto-scaffolding translation adapter...'));
+      
+      try {
+        const adapterType = suggestedConfig.translationAdapter.module === 'react-i18next' ? 'react-i18next' : 'custom';
+        
+        if (adapterType === 'react-i18next') {
+          const i18nPath = 'src/lib/i18n.ts';
+          const providerPath = 'src/components/i18n-provider.tsx';
+          
+          const { i18nResult, providerResult } = await scaffoldI18next(
+            i18nPath,
+            providerPath,
+            config.sourceLanguage,
+            config.localesDir || 'locales',
+            { workspaceRoot }
+          );
+          
+          console.log(chalk.green('✓ Scaffolded react-i18next runtime:'));
+          console.log(chalk.green(`  • ${i18nResult.path}`));
+          console.log(chalk.green(`  • ${providerResult.path}`));
+          
+          // Try to install dependencies
+          const pkg = await readPackageJson();
+          const missingDeps = ['react-i18next', 'i18next'].filter((dep) => !hasDependency(pkg, dep));
+          if (missingDeps.length) {
+            try {
+              const manager = await detectPackageManager();
+              console.log(chalk.blue(`Installing dependencies with ${manager}...`));
+              await installDependencies(manager, missingDeps);
+              console.log(chalk.green('✓ Dependencies installed successfully.'));
+            } catch (error) {
+              console.log(chalk.yellow('Could not install dependencies automatically. Install them manually:'));
+              console.log(chalk.cyan(`  pnpm add ${missingDeps.join(' ')}`));
+            }
+          }
+          
+          scaffolded = true;
+        } else {
+          // Custom adapter for other frameworks
+          const contextPath = `src/contexts/translation-context.tsx`;
+          const result = await scaffoldTranslationContext(contextPath, config.sourceLanguage, {
+            localesDir: config.localesDir || 'locales',
+            workspaceRoot
+          });
+          
+          console.log(chalk.green(`✓ Scaffolded custom translation context at ${result.path}`));
+          
+          // Update config to use the custom adapter
+          config.translationAdapter = {
+            module: contextPath.replace(/\.tsx?$/, ''),
+            hookName: 'useTranslation',
+          };
+          
+          // Rewrite config file with updated adapter
+          await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+          
+          scaffolded = true;
+        }
+      } catch (error) {
+        console.log(chalk.yellow(`Could not auto-scaffold adapter: ${(error as Error).message}`));
+      }
+    }
+
+    // Inform user about next steps
+    console.log(chalk.blue('\nNext steps:'));
+    if (!scaffolded) {
+      console.log(chalk.dim('  • Install and scaffold a runtime (e.g. react-i18next or vue-i18n) to enable in-app translations.'));
+      console.log(chalk.cyan(`    i18nsmith scaffold-adapter --type ${suggestedConfig.translationAdapter.module} --install-deps`));
+    } else {
+      console.log(chalk.dim('  • Your translation adapter is ready! Import and use it in your components.'));
+    }
+
     console.log(chalk.blue('\nRun "i18nsmith check" to verify your setup.'));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -196,6 +353,8 @@ export function registerInit(program: Command) {
     .description('Initialize i18nsmith configuration')
     .option('--merge', 'Merge with existing locales/runtimes when detected', false)
     .option('-y, --yes', 'Skip prompts and use defaults (non-interactive mode)', false)
+    .option('--template <template>', 'Use a preset template (react, next-app, next-pages, vue3, nuxt3, svelte, minimal)', undefined)
+    .option('--scaffold', 'Automatically scaffold translation adapter when confidence is high and runtime is missing', false)
     .action(
       withErrorHandling(async (commandOptions: InitCommandOptions) => {
         console.log(chalk.blue('Initializing i18nsmith configuration...'));
@@ -206,41 +365,83 @@ export function registerInit(program: Command) {
           return;
         }
 
+      const workspaceRoot = process.cwd();
+      let config: I18nConfig | undefined;
+
+      // Detect project intelligence early to use for suggestions
+      const intelligence = await detectProjectIntelligence(workspaceRoot);
+      const suggestedValues = intelligence?.suggestedConfig;
+
       const answers = await inquirer.prompt<InitAnswers>([
+        {
+          type: 'list',
+          name: 'setupMode',
+          message: 'How would you like to set up i18nsmith?',
+          choices: [
+            { name: 'Auto-detect (recommended) - Analyze your project and suggest optimal configuration', value: 'auto' },
+            { name: 'Use template - Choose from popular framework presets', value: 'template' },
+            { name: 'Manual setup - Configure everything manually', value: 'manual' },
+          ],
+          default: 'auto',
+        },
+        {
+          type: 'list',
+          name: 'template',
+          message: 'Which template matches your project?',
+          when: (answers) => answers.setupMode === 'template',
+          choices: [
+            { name: 'React with react-i18next', value: 'react' },
+            { name: 'Next.js App Router', value: 'next-app' },
+            { name: 'Next.js Pages Router', value: 'next-pages' },
+            { name: 'Vue 3 with vue-i18n', value: 'vue3' },
+            { name: 'Nuxt 3', value: 'nuxt3' },
+            { name: 'Svelte/SvelteKit', value: 'svelte' },
+            { name: 'Minimal setup', value: 'minimal' },
+          ],
+          default: 'react',
+        },
+
+        // Manual Configuration Questions with Smart Suggestions
         {
           type: 'input',
           name: 'sourceLanguage',
           message: 'What is the source language?',
-          default: 'en',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.sourceLanguage || 'en',
         },
         {
           type: 'input',
           name: 'targetLanguages',
           message: 'Which target languages do you need? (comma separated)',
-          default: 'fr',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.targetLanguages?.join(', ') || 'fr',
         },
         {
           type: 'input',
           name: 'localesDir',
           message: 'Where should locale files be stored?',
-          default: 'locales',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.localesDir || 'locales',
         },
         {
           type: 'input',
           name: 'include',
           message: 'Which files should be scanned? (comma separated glob patterns)',
-          default: 'src/**/*.{ts,tsx,js,jsx}, app/**/*.{ts,tsx,js,jsx}, pages/**/*.{ts,tsx,js,jsx}, components/**/*.{ts,tsx,js,jsx}',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.include?.join(', ') || 'src/**/*.{ts,tsx,js,jsx}, app/**/*.{ts,tsx,js,jsx}, pages/**/*.{ts,tsx,js,jsx}, components/**/*.{ts,tsx,js,jsx}',
         },
         {
           type: 'input',
           name: 'exclude',
           message: 'Which files should be excluded? (comma separated glob patterns)',
-          default: 'node_modules/**,**/*.test.*',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.exclude?.join(', ') || 'node_modules/**,**/*.test.*',
         },
         {
           type: 'input',
           name: 'minTextLength',
           message: 'Minimum length for translatable text?',
+          when: (answers) => answers.setupMode === 'manual',
           default: '1',
           validate: (input) => {
             const num = parseInt(input, 10);
@@ -251,6 +452,7 @@ export function registerInit(program: Command) {
           type: 'list',
           name: 'service',
           message: 'Which translation service do you want to use?',
+          when: (answers) => answers.setupMode === 'manual',
           choices: ['google', 'deepl', 'manual'],
           default: 'google',
         },
@@ -258,7 +460,7 @@ export function registerInit(program: Command) {
           type: 'input',
           name: 'translationSecretEnvVar',
           message: 'Name of the environment variable containing your translation API key',
-          when: (answers) => answers.service !== 'manual',
+          when: (answers) => answers.setupMode === 'manual' && answers.service !== 'manual',
           default: (answers: InitAnswers) =>
             answers.service === 'deepl' ? 'DEEPL_API_KEY' : 'GOOGLE_TRANSLATE_API_KEY',
         },
@@ -266,168 +468,243 @@ export function registerInit(program: Command) {
           type: 'list',
           name: 'adapterPreset',
           message: 'How should transformed components access translations?',
+          when: (answers) => answers.setupMode === 'manual',
           choices: [
             { name: 'react-i18next (default)', value: 'react-i18next' },
+            { name: 'vue-i18n', value: 'vue-i18n' },
+            { name: 'svelte-i18n', value: 'svelte-i18n' },
+            { name: 'next-intl', value: 'next-intl' },
             { name: 'Custom hook/module', value: 'custom' },
           ],
-          default: 'react-i18next',
+          default: suggestedValues?.translationAdapter?.module || 'react-i18next',
         },
         {
           type: 'input',
           name: 'customAdapterModule',
           message: 'Provide the module specifier for your translation hook (e.g. "@/contexts/translation-context")',
-          when: (answers) => answers.adapterPreset === 'custom',
+          when: (answers) => answers.setupMode === 'manual' && answers.adapterPreset === 'custom',
           validate: (input) => (input && input.trim().length > 0 ? true : 'Module specifier cannot be empty'),
         },
         {
           type: 'input',
           name: 'customAdapterHook',
           message: 'Name of the hook/function to import (default: useTranslation)',
-          when: (answers) => answers.adapterPreset === 'custom',
+          when: (answers) => answers.setupMode === 'manual' && answers.adapterPreset === 'custom',
           default: 'useTranslation',
         },
-        {
-          type: 'confirm',
-          name: 'scaffoldAdapter',
-          message: 'Scaffold a lightweight translation context file?',
-          when: (answers) => answers.adapterPreset === 'custom',
-          default: true,
-        },
-        {
-          type: 'input',
-          name: 'scaffoldAdapterPath',
-          message: 'Path to scaffold the translation context file (relative to project root)',
-          when: (answers) => answers.scaffoldAdapter,
-          default: 'src/contexts/translation-context.tsx',
-        },
-        {
-          type: 'confirm',
-          name: 'scaffoldReactRuntime',
-          message: 'Scaffold i18next initializer and provider?',
-          when: (answers) => answers.adapterPreset === 'react-i18next',
-          default: true,
-        },
-        {
-          type: 'input',
-          name: 'reactI18nPath',
-          message: 'Path for i18next initializer (e.g. src/lib/i18n.ts)',
-          when: (answers) => answers.scaffoldReactRuntime,
-          default: 'src/lib/i18n.ts',
-        },
-        {
-          type: 'input',
-          name: 'reactProviderPath',
-          message: 'Path for I18nProvider component (e.g. src/components/i18n-provider.tsx)',
-          when: (answers) => answers.scaffoldReactRuntime,
-          default: 'src/components/i18n-provider.tsx',
-        },
         {
           type: 'input',
           name: 'keyNamespace',
           message: 'Namespace prefix for generated keys',
-          default: 'common',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.keyGeneration?.namespace || 'common',
         },
         {
           type: 'input',
           name: 'shortHashLen',
           message: 'Length of short hash suffix for keys',
-          default: '6',
+          when: (answers) => answers.setupMode === 'manual',
+          default: suggestedValues?.keyGeneration?.shortHashLen?.toString() || '6',
           validate: (input) => {
             const num = parseInt(input, 10);
             return !isNaN(num) && num > 0 ? true : 'Please enter a positive number';
           },
         },
-        {
-          type: 'confirm',
-          name: 'seedTargetLocales',
-          message: 'Seed target locale files with empty values?',
-          default: false,
-        },
       ]);
 
-      const adapterModule =
-        answers.adapterPreset === 'custom'
-          ? answers.customAdapterModule?.trim()
-          : 'react-i18next';
-      const adapterHook =
-        answers.adapterPreset === 'custom'
-          ? (answers.customAdapterHook?.trim() || 'useTranslation')
-          : 'useTranslation';
-
-      const translationConfig: TranslationConfig =
-        answers.service === 'manual'
-          ? { provider: 'manual' }
-          : {
-              provider: answers.service,
-              secretEnvVar: answers.translationSecretEnvVar?.trim() || undefined,
-              concurrency: 5,
-            };
-
-      const config: I18nConfig = {
-        version: 1 as const,
-        sourceLanguage: answers.sourceLanguage,
-        targetLanguages: parseGlobList(answers.targetLanguages),
-        localesDir: answers.localesDir,
-        include: parseGlobList(answers.include),
-        exclude: parseGlobList(answers.exclude),
-        minTextLength: parseInt(answers.minTextLength, 10),
-        translation: translationConfig,
-        translationAdapter: {
-          module: adapterModule ?? 'react-i18next',
-          hookName: adapterHook,
-        },
-        keyGeneration: {
-          namespace: answers.keyNamespace,
-          shortHashLen: parseInt(answers.shortHashLen, 10),
-        },
-        seedTargetLocales: answers.seedTargetLocales,
-      };
 
-        const workspaceRoot = process.cwd();
-        const mergeDecision = await maybePromptMergeStrategy(config, workspaceRoot, Boolean(commandOptions.merge));
-        if (mergeDecision?.aborted) {
-          console.log(chalk.yellow('Aborting init to avoid overwriting existing i18n assets. Re-run with --merge to bypass.'));
+      if (answers.setupMode === 'auto') {
+        if (!intelligence) {
+          console.log(chalk.yellow('Could not analyze project. Please use Manual setup.'));
           return;
+        } else {
+          const { framework, locales, filePatterns, confidence } = intelligence;
+          
+          // Report detection results
+          if (framework.type !== 'unknown') {
+            console.log(chalk.green(`  ✓ Framework: ${framework.type}`));
+          }
+          if (framework.adapter) {
+            console.log(chalk.green(`  ✓ i18n Adapter: ${framework.adapter}`));
+          }
+          if (locales.existingFiles.length > 0) {
+            const langs = [locales.sourceLanguage, ...locales.targetLanguages].filter(Boolean);
+            console.log(chalk.green(`  ✓ Locales: ${langs.join(', ')}`));
+          }
+          
+          const confidencePercent = Math.round(confidence.overall * 100);
+          const confidenceColor = confidence.level === 'high' ? chalk.green : confidence.level === 'medium' ? chalk.yellow : chalk.red;
+          console.log(confidenceColor(`  Detection confidence: ${confidencePercent}% (${confidence.level})`));
+
+          // Create config from intelligence
+          config = {
+            version: 1 as const,
+            sourceLanguage: locales.sourceLanguage || 'en',
+            targetLanguages: locales.targetLanguages,
+            localesDir: locales.localesDir || 'locales',
+            include: filePatterns.include,
+            exclude: filePatterns.exclude,
+            minTextLength: 1,
+            translation: { provider: 'manual' },
+            translationAdapter: {
+              module: framework.adapter || 'react-i18next',
+              hookName: framework.hookName || 'useTranslation',
+            },
+            keyGeneration: {
+              namespace: 'common',
+              shortHashLen: 6,
+            },
+            seedTargetLocales: false,
+          };
         }
+      }
+
+      if (answers.setupMode === 'template') {
+        // Use template
+        console.log(chalk.blue(`📋 Applying ${answers.template} template...`));
+        const service = new ProjectIntelligenceService();
+        // Uses pre-detected intelligence from outer scope
+        const suggestedConfig = service.applyTemplate(answers.template!, intelligence || {
+          framework: { type: 'unknown', adapter: 'react-i18next', hookName: 'useTranslation', features: [], confidence: 0, evidence: [] },
+          locales: { sourceLanguage: 'en', targetLanguages: [], localesDir: 'locales', format: 'flat', existingFiles: [], existingKeyCount: 0, confidence: 0 },
+          filePatterns: { include: ['**/*.{ts,tsx,js,jsx}'], exclude: ['node_modules/**', 'dist/**'], sourceDirectories: [], hasTypeScript: false, hasJsx: false, hasVue: false, hasSvelte: false, sourceFileCount: 0, confidence: 0 },
+          existingSetup: { hasExistingConfig: false, hasExistingLocales: false, hasI18nProvider: false, runtimePackages: [], translationUsage: { hookName: 'useTranslation', translationIdentifier: 't', filesWithHooks: 0, translationCalls: 0, exampleFiles: [] } },
+          confidence: { framework: 0, filePatterns: 0, existingSetup: 0, locales: 0, overall: 0, level: 'low' },
+          warnings: [],
+          recommendations: [],
+          suggestedConfig: {
+            sourceLanguage: 'en',
+            targetLanguages: [],
+            localesDir: 'locales',
+            include: ['**/*.{ts,tsx,js,jsx}'],
+            exclude: ['node_modules/**', 'dist/**'],
+            translationAdapter: { module: 'react-i18next', hookName: 'useTranslation' },
+            keyGeneration: { namespace: 'common', shortHashLen: 6 }
+          },
+        });
+
+        config = {
+          version: 1 as const,
+          ...suggestedConfig,
+          minTextLength: 1,
+          translation: { provider: 'manual' },
+          seedTargetLocales: false,
+        };
+      }
 
-        const configPath = path.join(workspaceRoot, 'i18n.config.json');
+      if (answers.setupMode === 'manual' || !config) {
+        // Manual setup - use the existing prompts
+        console.log(chalk.blue('🔧 Manual configuration...'));
+        
+        // Map the selected adapter preset to the correct module name and hook.
+        // The prompt offers 'react-i18next', 'vue-i18n', 'svelte-i18n', 'next-intl', and 'custom'.
+        // Only 'custom' uses the user-provided module specifier; all known presets
+        // are used directly as the adapter module name.
+        const adapterModule =
+          answers.adapterPreset === 'custom'
+            ? answers.customAdapterModule?.trim()
+            : answers.adapterPreset; // Use actual selection (vue-i18n, svelte-i18n, etc.)
+        const ADAPTER_HOOKS: Record<string, string> = {
+          'react-i18next': 'useTranslation',
+          'vue-i18n': 'useI18n',
+          'svelte-i18n': 't',
+          'next-intl': 'useTranslations',
+        };
+        const adapterHook =
+          answers.adapterPreset === 'custom'
+            ? (answers.customAdapterHook?.trim() || 'useTranslation')
+            : ADAPTER_HOOKS[answers.adapterPreset] || 'useTranslation';
+
+        const translationConfig: TranslationConfig =
+          answers.service === 'manual'
+            ? { provider: 'manual' }
+            : {
+                provider: answers.service,
+                secretEnvVar: answers.translationSecretEnvVar?.trim() || undefined,
+                concurrency: 5,
+              };
+
+        config = {
+          version: 1 as const,
+          sourceLanguage: answers.sourceLanguage,
+          targetLanguages: parseGlobList(answers.targetLanguages),
+          localesDir: answers.localesDir,
+          include: parseGlobList(answers.include),
+          exclude: parseGlobList(answers.exclude),
+          minTextLength: parseInt(answers.minTextLength, 10),
+          translation: translationConfig,
+          translationAdapter: {
+            module: adapterModule ?? 'react-i18next',
+            hookName: adapterHook,
+          },
+          keyGeneration: {
+            namespace: answers.keyNamespace,
+            shortHashLen: parseInt(answers.shortHashLen, 10),
+          },
+          seedTargetLocales: answers.seedTargetLocales,
+        };
+      }
 
-        try {
-          await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-          console.log(chalk.green(`\nConfiguration created at ${configPath}`));
+      const mergeDecision = await maybePromptMergeStrategy(config, workspaceRoot, Boolean(commandOptions.merge));
+      if (mergeDecision?.aborted) {
+        console.log(chalk.yellow('Aborting init to avoid overwriting existing i18n assets. Re-run with --merge to bypass.'));
+        return;
+      }
 
-          // Ensure .gitignore has i18nsmith artifacts
-          const gitignoreResult = await ensureGitignore(workspaceRoot);
-          if (gitignoreResult.updated) {
-            console.log(chalk.green(`Updated .gitignore with i18nsmith artifacts`));
+      const configPath = path.join(workspaceRoot, 'i18n.config.json');
+
+      try {
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        console.log(chalk.green(`\nConfiguration created at ${configPath}`));
+
+        // Ensure .gitignore has i18nsmith artifacts
+        const gitignoreResult = await ensureGitignore(workspaceRoot);
+        if (gitignoreResult.updated) {
+          console.log(chalk.green(`Updated .gitignore with i18nsmith artifacts`));
+        }
+
+        // Create locales directory and minimal source locale file so
+        // `i18nsmith check` doesn't immediately report missing source locale.
+        try {
+          const localesDirPath = path.join(workspaceRoot, config!.localesDir || 'locales');
+          await fs.mkdir(localesDirPath, { recursive: true });
+          const sourceLocalePath = path.join(localesDirPath, `${config!.sourceLanguage}.json`);
+          try {
+            await fs.access(sourceLocalePath);
+          } catch {
+            await fs.writeFile(sourceLocalePath, JSON.stringify({}, null, 2));
+            console.log(chalk.green(`✓ Created source locale file at ${sourceLocalePath}`));
           }
+        } catch {
+          console.log(chalk.yellow('Could not create source locale file automatically.'));
+        }
 
-          if (answers.scaffoldAdapter && answers.scaffoldAdapterPath) {
-            try {
-              await scaffoldTranslationContext(answers.scaffoldAdapterPath, answers.sourceLanguage, {
-                localesDir: answers.localesDir,
-              });
-              console.log(chalk.green(`Translation context scaffolded at ${answers.scaffoldAdapterPath}`));
-            } catch (error) {
-              console.warn(chalk.yellow(`Skipping adapter scaffold: ${(error as Error).message}`));
-            }
+        if (answers.scaffoldAdapter && answers.scaffoldAdapterPath) {
+          try {
+            await scaffoldTranslationContext(answers.scaffoldAdapterPath, answers.sourceLanguage, {
+              localesDir: answers.localesDir,
+            });
+            console.log(chalk.green(`Translation context scaffolded at ${answers.scaffoldAdapterPath}`));
+          } catch (error) {
+            console.warn(chalk.yellow(`Skipping adapter scaffold: ${(error as Error).message}`));
           }
+        }
 
-          if (
-            answers.adapterPreset === 'react-i18next' &&
-            answers.scaffoldReactRuntime &&
-            answers.reactI18nPath &&
-            answers.reactProviderPath
-          ) {
-            try {
-              await scaffoldI18next(
-                answers.reactI18nPath,
-                answers.reactProviderPath,
-                answers.sourceLanguage,
-                answers.localesDir
-              );
-              console.log(chalk.green('react-i18next runtime scaffolded:'));
-              console.log(chalk.green(`  • ${answers.reactI18nPath}`));
+        if (
+          answers.adapterPreset === 'react-i18next' &&
+          answers.scaffoldReactRuntime &&
+          answers.reactI18nPath &&
+          answers.reactProviderPath
+        ) {
+          try {
+            await scaffoldI18next(
+              answers.reactI18nPath,
+              answers.reactProviderPath,
+              answers.sourceLanguage,
+              answers.localesDir
+            );
+            console.log(chalk.green('react-i18next runtime scaffolded:'));
+            console.log(chalk.green(`  • ${answers.reactI18nPath}`));
               console.log(chalk.green(`  • ${answers.reactProviderPath}`));
               console.log(chalk.blue('\nWrap your app with the provider (e.g. Next.js providers.tsx):'));
               console.log(