i18nsmith 0.4.3 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18nsmith",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "CLI for i18nsmith",
   "type": "module",
   "main": "dist/index.cjs",

package/src/commands/check.ts

@@ -186,7 +186,11 @@ export function registerCheck(program: Command) {
 
 export async function runCheck(options: CheckCommandOptions): Promise<void> {
   const auditEnabled = Boolean(options.audit || options.auditStrict);
-  console.log(chalk.blue('Running guided repository health check...'));
+  if (options.json) {
+    console.error(chalk.blue('Running guided repository health check...'));
+  } else {
+    console.log(chalk.blue('Running guided repository health check...'));
+  }
   try {
     const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);
 

package/src/commands/config.ts

@@ -282,4 +282,130 @@ export function registerConfig(program: Command) {
         }
       })
     );
+
+  // Subcommand: config migrate
+  configCmd
+    .command('migrate')
+    .description('Migrate configuration from v1 to v2 format and apply modern defaults')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .option('--dry-run', 'Show what would be changed without modifying files', false)
+    .option('--json', 'Output result as JSON', false)
+    .action(
+      withErrorHandling(async (options: { config?: string; dryRun?: boolean; json?: boolean }) => {
+        try {
+          const { configPath } = await loadConfigWithMeta(options.config);
+          const { parsed: rawConfig } = await readRawConfig(configPath);
+
+          // Check if migration is needed
+          const currentVersion = (rawConfig.configVersion ?? rawConfig.version ?? 1) as number;
+          if (currentVersion >= 2) {
+            if (options.json) {
+              console.log(JSON.stringify({ migrated: false, reason: 'Already at latest version' }, null, 2));
+            } else {
+              console.log(chalk.blue('Configuration is already up to date (v2 or later)'));
+            }
+            return;
+          }
+
+          // Apply migration transformations
+          const migratedConfig = { ...rawConfig };
+
+          // Set new version
+          migratedConfig.configVersion = 2;
+          delete migratedConfig.version;
+
+          // Migrate field names
+          if (rawConfig.sourceLocale) {
+            migratedConfig.sourceLanguage = rawConfig.sourceLocale;
+            delete migratedConfig.sourceLocale;
+          }
+          if (rawConfig.targetLocales) {
+            migratedConfig.targetLanguages = rawConfig.targetLocales;
+            delete migratedConfig.targetLocales;
+          }
+
+          // Add extraction preset with strict defaults for new configs
+          if (!migratedConfig.extraction) {
+            migratedConfig.extraction = {};
+          }
+          const extraction = migratedConfig.extraction as Record<string, unknown>;
+          if (!extraction.preset) {
+            extraction.preset = 'strict';
+          }
+
+          // Clean up deprecated fields
+          const deprecatedFields = ['projectName'];
+          for (const field of deprecatedFields) {
+            if (field in migratedConfig) {
+              delete migratedConfig[field];
+            }
+          }
+
+          if (options.dryRun) {
+            if (options.json) {
+              console.log(JSON.stringify({
+                migrated: true,
+                dryRun: true,
+                changes: {
+                  added: { configVersion: 2, 'extraction.preset': 'strict' },
+                  removed: deprecatedFields.filter(f => f in rawConfig),
+                  renamed: Object.assign({},
+                    rawConfig.sourceLocale ? { sourceLocale: 'sourceLanguage' } : {},
+                    rawConfig.targetLocales ? { targetLocales: 'targetLanguages' } : {},
+                  ),
+                },
+                result: migratedConfig,
+              }, null, 2));
+            } else {
+              console.log(chalk.blue('Migration preview (dry run):'));
+              console.log();
+              console.log(chalk.green('✓ Would set configVersion: 2'));
+              console.log(chalk.green('✓ Would add extraction.preset: strict'));
+              if (rawConfig.sourceLocale) {
+                console.log(chalk.green(`✓ Would rename sourceLocale → sourceLanguage`));
+              }
+              if (rawConfig.targetLocales) {
+                console.log(chalk.green(`✓ Would rename targetLocales → targetLanguages`));
+              }
+              const removed = deprecatedFields.filter(f => f in rawConfig);
+              if (removed.length > 0) {
+                console.log(chalk.green(`✓ Would remove deprecated fields: ${removed.join(', ')}`));
+              }
+              console.log();
+              console.log(chalk.dim('Run without --dry-run to apply changes'));
+            }
+          } else {
+            await writeConfig(configPath, migratedConfig);
+
+            if (options.json) {
+              console.log(JSON.stringify({
+                migrated: true,
+                configPath,
+                changes: {
+                  added: { configVersion: 2, 'extraction.preset': 'strict' },
+                  removed: deprecatedFields.filter(f => f in rawConfig),
+                  renamed: Object.assign({},
+                    rawConfig.sourceLocale ? { sourceLocale: 'sourceLanguage' } : {},
+                    rawConfig.targetLocales ? { targetLocales: 'targetLanguages' } : {},
+                  ),
+                },
+              }, null, 2));
+            } else {
+              console.log(chalk.green('✓ Configuration migrated to v2'));
+              console.log(chalk.dim(`  Updated: ${configPath}`));
+              console.log();
+              console.log(chalk.blue('New features available:'));
+              console.log(chalk.dim('  • extraction.preset: strict (reduces false positives)'));
+              console.log(chalk.dim('  • Improved field names for clarity'));
+            }
+          }
+        } catch (error) {
+          if (error instanceof CliError) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          throw new CliError(`Failed to migrate config: ${message}`);
+        }
+      })
+    );
 }

package/src/commands/init.test.ts

@@ -160,6 +160,7 @@ vi.mock('inquirer', () => ({
       sourceLanguage: 'en',
       adapter: 'custom',
       localesDir: 'locales',
+      seedTargetLocales: false,
     }),
   },
 }));
@@ -256,6 +257,85 @@ describe('init command', () => {
       );
     });
   });
+
+  describe('interactive mode', () => {
+    it('writes seedTargetLocales into config when user enables it', async () => {
+      const program = new Command();
+      registerInit(program);
+      const command = program.commands.find((cmd) => cmd.name() === 'init')!;
+
+      // Mock process.cwd to return a test directory
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue('/test/project');
+
+      // Make fs.access throw so init thinks config doesn't exist
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('File not found'));
+
+      // Override inquirer for this run to enable seedTargetLocales
+      const inquirer = await import('inquirer');
+      vi.mocked(inquirer.default.prompt).mockResolvedValueOnce({
+        setupMode: 'auto',
+        sourceLanguage: 'en',
+        localesDir: 'locales',
+        seedTargetLocales: true,
+      } as any);
+
+      try {
+        await (command as any).parseAsync([], { from: 'user' });
+      } finally {
+        process.cwd = originalCwd;
+      }
+
+      // Find the writeFile call that wrote i18n.config.json
+      const wroteConfig = vi.mocked(fs.writeFile).mock.calls.find((c) => String(c[0]).endsWith('i18n.config.json'));
+      expect(wroteConfig).toBeDefined();
+      expect(String(wroteConfig![1])).toContain('"seedTargetLocales": true');
+    });
+
+    it('continues when user chooses Overwrite for existing assets and records mergeStrategy', async () => {
+      const program = new Command();
+      registerInit(program);
+      const command = program.commands.find((cmd) => cmd.name() === 'init')!;
+
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue('/test/project');
+
+      // Make fs.access throw so init thinks config doesn't exist
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('File not found'));
+
+      // Make diagnoseWorkspace report existing locale files so merge prompt appears
+      const core = await import('@i18nsmith/core');
+      vi.mocked(core.diagnoseWorkspace).mockResolvedValueOnce({
+        localesDir: 'locales',
+        localeFiles: [{ locale: 'en', missing: false, parseError: false }],
+        detectedLocales: [],
+        runtimePackages: [],
+        providerFiles: [],
+        adapterFiles: [],
+        translationUsage: { hookName: 'useTranslation', translationIdentifier: 't', filesExamined: 0, hookOccurrences: 0, identifierOccurrences: 0, hookExampleFiles: [], identifierExampleFiles: [] },
+        actionableItems: [],
+        conflicts: [],
+        recommendations: [],
+      } as any);
+
+      // Sequence of prompts: first the main answers, then the merge strategy choice
+      const inquirer = await import('inquirer');
+      vi.mocked(inquirer.default.prompt)
+        .mockResolvedValueOnce({ setupMode: 'auto', sourceLanguage: 'en', localesDir: 'locales', seedTargetLocales: false } as any)
+        .mockResolvedValueOnce({ strategy: 'overwrite' } as any);
+
+      try {
+        await (command as any).parseAsync([], { from: 'user' });
+      } finally {
+        process.cwd = originalCwd;
+      }
+
+      // Ensure config was written with mergeStrategy set to overwrite
+      const wroteConfig = vi.mocked(fs.writeFile).mock.calls.find((c) => String(c[0]).endsWith('i18n.config.json'));
+      expect(wroteConfig).toBeDefined();
+      expect(String(wroteConfig![1])).toContain('"mergeStrategy": "overwrite"');
+    });
+  });
 });
 
 describe('parseGlobList', () => {

package/src/commands/init.ts

@@ -112,7 +112,7 @@ async function runNonInteractiveInit(commandOptions: InitCommandOptions): Promis
   let suggestedConfig: SuggestedConfig;
 
   if (intelligence) {
-    const { framework, locales, filePatterns, confidence } = intelligence;
+    const { framework, locales, filePatterns } = intelligence;
     
     // Report detection results
     if (framework.type !== 'unknown') {
@@ -510,6 +510,13 @@ export function registerInit(program: Command) {
             return !isNaN(num) && num > 0 ? true : 'Please enter a positive number';
           },
         },
+        {
+          type: 'confirm',
+          name: 'seedTargetLocales',
+          message: 'Seed target locale files with placeholders for missing keys?',
+          when: () => true,
+          default: false,
+        },
       ]);
 
 
@@ -645,6 +652,12 @@ export function registerInit(program: Command) {
         };
       }
 
+      // Honor explicit interactive answer for seeding target locales regardless
+      // of which setup mode (auto/template/manual) produced the initial config.
+      if (typeof (answers as InitAnswers).seedTargetLocales === 'boolean' && config) {
+        config.seedTargetLocales = (answers as InitAnswers).seedTargetLocales;
+      }
+
       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.'));
@@ -787,35 +800,33 @@ async function maybePromptMergeStrategy(
       }
     }
 
-    if (!mergeRequested) {
-      const { proceed } = await inquirer.prompt<{ proceed: boolean }>([
-        {
-          type: 'confirm',
-          name: 'proceed',
-          message: 'Merge with the existing setup instead of overwriting?',
-          default: true,
-        },
-      ]);
-      if (!proceed) {
-        return { strategy: null, aborted: true };
-      }
-    }
+    // Single consolidated prompt for both --merge and interactive flows. When
+    // `--merge` is provided we omit the 'Abort' choice and default to
+    // 'keep-source'; otherwise include an explicit 'Abort' option (last).
+    const baseChoices = [
+      { name: 'Keep source values (append new keys only)', value: 'keep-source' },
+      { name: 'Overwrite with placeholders (backup first)', value: 'overwrite' },
+      { name: 'Prompt during sync to review changes interactively', value: 'interactive' },
+    ];
+
+    const choices = mergeRequested ? baseChoices : [...baseChoices, { name: 'Abort (do not touch existing files)', value: 'abort' }];
 
-    const { strategy } = await inquirer.prompt<{ strategy: MergeStrategy }>([
+    const { strategy } = await inquirer.prompt<{
+      strategy: 'abort' | MergeStrategy;
+    }>([
       {
         type: 'list',
         name: 'strategy',
-        message: 'Choose a merge strategy for existing locale keys',
-        choices: [
-          { name: 'Keep source values (append new keys only)', value: 'keep-source' },
-          { name: 'Overwrite with placeholders (backup first)', value: 'overwrite' },
-          { name: 'Interactive review during sync', value: 'interactive' },
-        ],
+        message: 'Existing i18n assets detected — choose how to proceed',
+        choices,
         default: 'keep-source',
       },
     ]);
 
-    return { strategy, aborted: false };
+    if (strategy === 'abort') {
+      return { strategy: null, aborted: true };
+    }
+    return { strategy: strategy as MergeStrategy, aborted: false };
   } catch (error) {
     console.warn(chalk.gray(`Skipping merge diagnostics: ${(error as Error).message}`));
     return { strategy: null, aborted: false };

package/src/commands/scan.ts

@@ -57,7 +57,14 @@ export function registerScan(program: Command) {
     .option('--exclude <patterns...>', 'Override exclude globs from config (comma or space separated)', collectTargetPatterns, [])
     .action(
       withErrorHandling(async (options: ScanOptions) => {
-        console.log(chalk.blue('Starting scan...'));
+        // When JSON output is requested, avoid human-readable preamble on stdout
+        // so callers can reliably parse the JSON summary. Send banner to stderr
+        // when --json is used.
+        if (options.json) {
+          console.error(chalk.blue('Starting scan...'));
+        } else {
+          console.log(chalk.blue('Starting scan...'));
+        }
 
         try {
           const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);

package/src/commands/sync.ts

@@ -48,7 +48,7 @@ interface SyncCommandOptions {
   invalidateCache?: boolean;
   autoRenameSuspicious?: boolean;
   renameMapFile?: string;
-  namingConvention?: "kebab-case" | "camelCase" | "snake_case";
+  namingConvention?: "kebab-case" | "camelCase" | "snake_case" | "auto";
   rewriteShape?: "flat" | "nested";
   shapeDelimiter?: string;
   seedTargetLocales?: boolean;
@@ -193,7 +193,7 @@ export function registerSync(program: Command) {
     )
     .option(
       "--naming-convention <convention>",
-      "Naming convention for auto-rename (kebab-case, camelCase, snake_case)",
+      "Naming convention for auto-rename (kebab-case, camelCase, snake_case, auto)",
       "kebab-case"
     )
     .option(
@@ -328,7 +328,14 @@ export function registerSync(program: Command) {
           : writeEnabled
             ? "Syncing locale files..."
             : "Checking locale drift...";
-      console.log(chalk.blue(banner));
+      // When JSON output is requested, avoid human-readable preamble on stdout
+      // so callers can reliably parse the JSON summary. Send banner to stderr
+      // when --json is used.
+      if (options.json) {
+        console.error(chalk.blue(banner));
+      } else {
+        console.log(chalk.blue(banner));
+      }
 
       try {
         const { config, projectRoot, configPath } = await loadConfigWithMeta(
@@ -480,6 +487,8 @@ export function registerSync(program: Command) {
             namingConvention,
             workspaceRoot: projectRoot,
             allowExistingConflicts: true,
+            allExistingKeys: Object.keys(sourceData), // Pass all existing keys for convention detection
+            preserveExistingConvention: true, // Respect existing project conventions
           });
 
           if (report.safeProposals.length > 0) {
@@ -769,6 +778,18 @@ function printSyncSummary(summary: SyncSummary) {
     console.log(chalk.green("No unused locale keys detected."));
   }
 
+  if (summary.untranslatedKeys.length) {
+    console.log(chalk.blue("Untranslated keys (protected from pruning):"));
+    summary.untranslatedKeys.slice(0, 50).forEach((item) => {
+      console.log(`  • ${item.key} (${item.locales.join(", ")})`);
+    });
+    if (summary.untranslatedKeys.length > 50) {
+      console.log(
+        chalk.gray(`  ...and ${summary.untranslatedKeys.length - 50} more.`)
+      );
+    }
+  }
+
   if (summary.validation.interpolations) {
     if (summary.placeholderIssues.length) {
       console.log(chalk.yellow("Placeholder mismatches:"));
@@ -880,11 +901,29 @@ async function handleAutoRenameSuspicious(
   const sourceData = await localeStore.get(sourceLocale);
   const existingKeys = new Set(Object.keys(sourceData));
 
-  // Generate rename proposals
+  // For auto-detection, collect all existing keys from all locales
+  let allExistingKeys: string[] | undefined;
   const namingConvention = options.namingConvention ?? "kebab-case";
+  if (namingConvention === "auto") {
+    try {
+      const allLocales = await localeStore.getStoredLocales();
+      const allKeys = new Set<string>();
+      for (const locale of allLocales) {
+        const localeData = await localeStore.get(locale);
+        Object.keys(localeData).forEach(key => allKeys.add(key));
+      }
+      allExistingKeys = Array.from(allKeys);
+      console.log(`  Auto-detected naming convention from ${allKeys.size} existing keys`);
+    } catch (error) {
+      console.warn(chalk.yellow("  Warning: Could not load all locales for convention detection, falling back to kebab-case"));
+    }
+  }
+
+  // Generate rename proposals
   const report = generateRenameProposals(summary.suspiciousKeys, {
     existingKeys,
     namingConvention,
+    allExistingKeys,
     allowExistingConflicts: true,
   });
 

package/src/commands/transform.ts

@@ -227,7 +227,14 @@ export function registerTransform(program: Command) {
         : writeEnabled
         ? 'Running transform (write mode)...'
         : 'Planning transform (dry-run)...';
-      console.log(chalk.blue(banner));
+      // When JSON output is requested, avoid human-readable preamble on stdout
+      // so callers can reliably parse the JSON summary. Send banner to stderr
+      // when --json is used.
+      if (options.json) {
+        console.error(chalk.blue(banner));
+      } else {
+        console.log(chalk.blue(banner));
+      }
 
       try {
         const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);

package/src/index.ts

@@ -24,7 +24,7 @@ export const program = new Command();
 program
   .name('i18nsmith')
   .description('Universal Automated i18n Library')
-  .version('0.4.3');
+  .version('0.5.1');
 
 registerInit(program);
 registerScaffoldAdapter(program);