i18nsmith 0.4.2 → 0.4.3

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBpC,eAAO,MAAM,OAAO,SAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBpC,eAAO,MAAM,OAAO,SAAgB,CAAC"}

package/package.json

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

package/src/commands/check.ts

@@ -2,8 +2,8 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import type { Command } from 'commander';
-import { loadConfigWithMeta, CheckRunner } from '@i18nsmith/core';
-import type { CheckSummary } from '@i18nsmith/core';
+import { loadConfigWithMeta, CheckRunner, isPackageResolvable } from '@i18nsmith/core';
+import type { CheckSummary, I18nConfig } from '@i18nsmith/core';
 import { printLocaleDiffs } from '../utils/diff-utils.js';
 import { getDiagnosisExitSignal } from '../utils/diagnostics-exit.js';
 import { CHECK_EXIT_CODES } from '../utils/exit-codes.js';
@@ -39,6 +39,12 @@ interface CheckCommandOptions {
   auditOrphaned?: boolean;
 }
 
+interface ParserWarning {
+  dependency: string;
+  message: string;
+  installHint: string;
+}
+
 const collectAssumedKeys = (value: string, previous: string[]) => {
   const tokens = value
     .split(',')
@@ -75,6 +81,8 @@ function printCheckSummary(summary: CheckSummary) {
     )
   );
 
+  printDynamicKeyCoverage(summary);
+
   if (summary.actionableItems.length) {
     console.log(chalk.blue('\nActionable items'));
     summary.actionableItems.slice(0, 25).forEach((item) => {
@@ -101,6 +109,46 @@ function printCheckSummary(summary: CheckSummary) {
   }
 }
 
+function printDynamicKeyCoverage(summary: CheckSummary) {
+  const coverage = summary.sync.dynamicKeyCoverage ?? [];
+  if (!coverage.length) {
+    return;
+  }
+
+  const entriesWithGaps = coverage.filter((entry) =>
+    entry.missingByLocale && Object.keys(entry.missingByLocale).length > 0
+  );
+  const totalMissing = entriesWithGaps.reduce((total, entry) => {
+    return (
+      total +
+      Object.values(entry.missingByLocale).reduce((sum, list) => sum + (Array.isArray(list) ? list.length : 0), 0)
+    );
+  }, 0);
+
+  if (!entriesWithGaps.length) {
+    console.log(chalk.green('Dynamic key coverage: all expanded keys present.'));
+    return;
+  }
+
+  console.log(
+    chalk.yellow(
+      `Dynamic key coverage: ${totalMissing} missing translation${totalMissing === 1 ? '' : 's'} across ${entriesWithGaps.length} pattern${entriesWithGaps.length === 1 ? '' : 's'}.`
+    )
+  );
+
+  entriesWithGaps.slice(0, 5).forEach((entry) => {
+    const localeSummary = Object.entries(entry.missingByLocale)
+      .map(([locale, missing]) => `${locale}(${missing.length})`)
+      .join(', ');
+    console.log(chalk.gray(`  • ${entry.pattern}: ${localeSummary}`));
+  });
+
+  if (entriesWithGaps.length > 5) {
+    console.log(chalk.gray(`  ...and ${entriesWithGaps.length - 5} more.`));
+  }
+  console.log(chalk.gray('  Tip: run `i18nsmith sync --write` to scaffold missing dynamic keys.'));
+}
+
 function formatSeverityLabel(severity: 'info' | 'warn' | 'error'): string {
   if (severity === 'error') {
     return chalk.red('ERROR');
@@ -157,6 +205,19 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
         ...options.assumeGlobs,
       ];
     }
+    const parserWarnings: ParserWarning[] = [];
+    const parserStatus = buildParserStatus(config, projectRoot);
+    const vueStatus = parserStatus.vue;
+    if (vueStatus?.required && !vueStatus.available) {
+      parserWarnings.push({
+        dependency: 'vue-eslint-parser',
+        message: 'Vue files detected but "vue-eslint-parser" is not installed. Results may be incomplete.',
+        installHint: 'npm install --save-dev vue-eslint-parser',
+      });
+      console.log(chalk.yellow('⚠️  Vue files detected but "vue-eslint-parser" is not installed.'));
+      console.log(chalk.yellow('   Some Vue template references may be skipped.'));
+    }
+
     const runner = new CheckRunner(config, { workspaceRoot: projectRoot });
     const summary = await runner.run({
       assumedKeys: options.assume,
@@ -183,7 +244,9 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
       );
     }
 
-    const payload = localeAudit ? { ...summary, audit: localeAudit } : summary;
+    const payload = localeAudit
+      ? { ...summary, audit: localeAudit, parserStatus, ...(parserWarnings.length ? { parserWarnings } : {}) }
+      : { ...summary, parserStatus, ...(parserWarnings.length ? { parserWarnings } : {}) };
 
     if (options.report) {
       const outputPath = path.resolve(process.cwd(), options.report);
@@ -196,6 +259,13 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
       console.log(JSON.stringify(payload, null, 2));
     } else {
       printCheckSummary(summary);
+      if (parserWarnings.length) {
+        console.log(chalk.yellow('\nParser warnings'));
+        parserWarnings.forEach((warning) => {
+          console.log(`  • ${warning.message}`);
+          console.log(chalk.gray(`    Install: ${warning.installHint}`));
+        });
+      }
       if (options.diff) {
         printLocaleDiffs(summary.sync.diffs);
       }
@@ -240,3 +310,53 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
     throw new CliError(`Check failed: ${message}`);
   }
 }
+
+type ParserStatusEntry = {
+  available: boolean;
+  required: boolean;
+};
+
+type ParserStatusMap = Record<string, ParserStatusEntry>;
+
+function buildParserStatus(config: I18nConfig, projectRoot: string): ParserStatusMap {
+  const includePatterns = config.include ?? [];
+  const requiresVue = includesExtension(includePatterns, '.vue');
+  const requiresTypeScript =
+    includesExtension(includePatterns, '.ts') ||
+    includesExtension(includePatterns, '.tsx') ||
+    includesExtension(includePatterns, '.js') ||
+    includesExtension(includePatterns, '.jsx');
+
+  let vueAvailable = false;
+  try {
+    vueAvailable = isPackageResolvable('vue-eslint-parser', projectRoot);
+  } catch {
+    vueAvailable = false;
+  }
+
+  return {
+    typescript: { available: true, required: requiresTypeScript },
+    vue: { available: vueAvailable, required: requiresVue },
+  };
+}
+
+function includesExtension(patterns: string[], extension: string): boolean {
+  const ext = extension.toLowerCase();
+  const extToken = ext.startsWith('.') ? ext.slice(1) : ext;
+  const extRegex = new RegExp(`\\.${extToken}(?:\\b|\\}|,|$)`, 'i');
+
+  return patterns.some((pattern) => {
+    const normalized = pattern.toLowerCase();
+    if (normalized.includes(ext)) {
+      return true;
+    }
+    const braceMatch = normalized.match(/\{([^}]+)\}/);
+    if (braceMatch) {
+      const entries = braceMatch[1].split(',').map((value) => value.trim());
+      if (entries.includes(extToken)) {
+        return true;
+      }
+    }
+    return extRegex.test(normalized);
+  });
+}

package/src/commands/coverage.ts

@@ -0,0 +1,97 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+import { loadConfigWithMeta, Syncer } from '@i18nsmith/core';
+import type { DynamicKeyCoverage, I18nConfig } from '@i18nsmith/core';
+import { CliError, withErrorHandling } from '../utils/errors.js';
+
+interface CoverageCommandOptions {
+  config?: string;
+  report?: string;
+  json?: boolean;
+  target?: string[];
+  invalidateCache?: boolean;
+}
+
+const collectTargetPatterns = (value: string | string[], previous: string[]) => {
+  const list = Array.isArray(value) ? value : [value];
+  const tokens = list
+    .flatMap((entry) => entry.split(','))
+    .map((token) => token.trim())
+    .filter(Boolean);
+  return [...previous, ...tokens];
+};
+
+function buildCoverageSummary(coverage: DynamicKeyCoverage[]): {
+  patterns: number;
+  missing: number;
+} {
+  const entriesWithGaps = coverage.filter((entry) => Object.keys(entry.missingByLocale ?? {}).length > 0);
+  const missing = entriesWithGaps.reduce((total, entry) => {
+    return (
+      total +
+      Object.values(entry.missingByLocale ?? {}).reduce((sum, list) => sum + (Array.isArray(list) ? list.length : 0), 0)
+    );
+  }, 0);
+  return { patterns: entriesWithGaps.length, missing };
+}
+
+function buildCoverageReport(
+  coverage: DynamicKeyCoverage[],
+  config: I18nConfig,
+  projectRoot: string,
+  configPath: string
+) {
+  const summary = buildCoverageSummary(coverage);
+  return {
+    generatedAt: new Date().toISOString(),
+    projectRoot,
+    configPath,
+    sourceLanguage: config.sourceLanguage ?? 'en',
+    targetLanguages: config.targetLanguages ?? [],
+    summary,
+    coverage,
+  };
+}
+
+export function registerCoverage(program: Command) {
+  program
+    .command('coverage')
+    .description('Export dynamic key coverage report')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', 'i18n.config.json')
+    .option('--report <path>', 'Write coverage report JSON to a file', '.i18nsmith/dynamic-key-coverage.json')
+    .option('--json', 'Print report JSON to stdout', false)
+    .option('--target <pattern...>', 'Limit reference scanning to specific files or patterns', collectTargetPatterns, [])
+    .option('--invalidate-cache', 'Ignore cached sync analysis and rescan all source files', false)
+    .action(withErrorHandling(async (options: CoverageCommandOptions) => runCoverage(options)));
+}
+
+export async function runCoverage(options: CoverageCommandOptions): Promise<void> {
+  const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);
+  const syncer = new Syncer(config, { workspaceRoot: projectRoot });
+
+  const summary = await syncer.run({
+    write: false,
+    targets: options.target,
+    invalidateCache: options.invalidateCache,
+  });
+
+  const coverage = summary.dynamicKeyCoverage ?? [];
+  const report = buildCoverageReport(coverage, config, projectRoot, configPath);
+
+  if (options.report) {
+    const outputPath = path.resolve(process.cwd(), options.report);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(report, null, 2));
+    console.log(chalk.green(`Dynamic key coverage report written to ${outputPath}`));
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  }
+
+  if (!options.report && !options.json) {
+    throw new CliError('No output specified. Use --report to write a file or --json to print to stdout.');
+  }
+}

package/src/commands/init.ts

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
-import { diagnoseWorkspace, I18nConfig, TranslationConfig, ensureGitignore, ProjectIntelligenceService, type ProjectIntelligence, type SuggestedConfig, Scanner, KeyGenerator } from '@i18nsmith/core';
+import { diagnoseWorkspace, I18nConfig, TranslationConfig, ensureGitignore, ProjectIntelligenceService, type ProjectIntelligence, type SuggestedConfig, Scanner, KeyGenerator, LocaleStore, createBackup } 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';
@@ -651,6 +651,10 @@ export function registerInit(program: Command) {
         return;
       }
 
+      if (mergeDecision?.strategy) {
+        config.mergeStrategy = mergeDecision.strategy;
+      }
+
       const configPath = path.join(workspaceRoot, 'i18n.config.json');
 
       try {
@@ -679,6 +683,8 @@ export function registerInit(program: Command) {
           console.log(chalk.yellow('Could not create source locale file automatically.'));
         }
 
+        await applyMergeStrategy(mergeDecision, config, workspaceRoot);
+
         if (answers.scaffoldAdapter && answers.scaffoldAdapterPath) {
           try {
             await scaffoldTranslationContext(answers.scaffoldAdapterPath, answers.sourceLanguage, {
@@ -816,3 +822,90 @@ async function maybePromptMergeStrategy(
   }
 }
 
+async function applyMergeStrategy(
+  mergeDecision: MergeDecision | null,
+  config: I18nConfig,
+  workspaceRoot: string
+): Promise<void> {
+  const strategy = mergeDecision?.strategy;
+  if (!strategy || strategy === 'keep-source') {
+    return;
+  }
+
+  const localesDirPath = path.join(workspaceRoot, config.localesDir || 'locales');
+  const localeStore = new LocaleStore(localesDirPath, {
+    format: config.locales?.format ?? 'auto',
+    delimiter: config.locales?.delimiter ?? '.',
+    sortKeys: config.locales?.sortKeys ?? 'alphabetical',
+  });
+
+  const sourceLocale = config.sourceLanguage ?? 'en';
+  let sourceData: Record<string, string> = {};
+  try {
+    sourceData = await localeStore.get(sourceLocale);
+  } catch {
+    sourceData = {};
+  }
+
+  const sourceKeys = Object.keys(sourceData);
+  if (!sourceKeys.length) {
+    console.log(chalk.yellow('No source locale keys found to apply merge strategy.'));
+    return;
+  }
+
+  const targetLocales = (config.targetLanguages ?? []).filter(Boolean);
+  if (!targetLocales.length) {
+    return;
+  }
+
+  let localesToOverwrite = targetLocales;
+  if (strategy === 'interactive' && process.stdout.isTTY) {
+    const { locales } = await inquirer.prompt<{ locales: string[] }>([
+      {
+        type: 'checkbox',
+        name: 'locales',
+        message: 'Select target locales to overwrite with placeholders',
+        choices: targetLocales,
+        default: targetLocales,
+      },
+    ]);
+    localesToOverwrite = locales?.length ? locales : [];
+    if (!localesToOverwrite.length) {
+      console.log(chalk.gray('No locales selected. Skipping merge overwrite.'));
+      return;
+    }
+  }
+
+  try {
+    const backup = await createBackup(localesDirPath, workspaceRoot, {}, `init --merge ${strategy}`);
+    if (backup) {
+      console.log(chalk.blue(`\n📦 ${backup.summary}`));
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`Could not create backup: ${(error as Error).message}`));
+  }
+
+  const seedValue = config.sync?.seedValue ?? '[TODO]';
+  for (const locale of localesToOverwrite) {
+    let existingData: Record<string, string> = {};
+    try {
+      existingData = await localeStore.get(locale);
+    } catch {
+      existingData = {};
+    }
+    for (const key of Object.keys(existingData)) {
+      await localeStore.remove(locale, key);
+    }
+    for (const key of sourceKeys) {
+      await localeStore.upsert(locale, key, seedValue);
+    }
+  }
+
+  await localeStore.flush();
+  console.log(
+    chalk.green(
+      `Merge strategy "${strategy}" applied to locales: ${localesToOverwrite.join(', ')}`
+    )
+  );
+}
+

package/src/commands/sync.ts

@@ -350,6 +350,11 @@ export function registerSync(program: Command) {
         if (options.exclude?.length) {
           config.exclude = options.exclude;
         }
+
+        if (!options.interactive && config.mergeStrategy === 'interactive') {
+          options.interactive = true;
+          console.log(chalk.gray('Using interactive merge strategy from i18n.config.json.'));
+        }
         // Merge --assume-globs with config
         if (options.assumeGlobs?.length) {
           config.sync = config.sync ?? {};

package/src/e2e.test.ts

@@ -284,11 +284,6 @@ describe('E2E Fixture Tests', () => {
   const saveKey = renameMap['Save'];
   expect(saveKey).toBeDefined();
 
-  expect(enLocale).toHaveProperty(helloKey!);
-  expect(frLocale).toHaveProperty(helloKey!);
-  expect(enLocale).toHaveProperty(saveKey!);
-  expect(frLocale).toHaveProperty(saveKey!);
-
   const sourceFile = await fs.readFile(path.join(fixtureDir, 'src', 'BadKeys.tsx'), 'utf8');
   expect(sourceFile).toContain(`t('${helloKey!}')`);
   expect(sourceFile).not.toContain("t('Hello World')");
@@ -457,6 +452,63 @@ describe('E2E Fixture Tests', () => {
     });
   });
 
+  describe('dynamic key coverage reporting', () => {
+    let fixtureDir: string;
+
+    beforeEach(async () => {
+      fixtureDir = await setupFixture('basic-react');
+    });
+
+    afterEach(async () => {
+      await cleanupFixture(fixtureDir);
+    });
+
+    it('includes dynamic key coverage details in check JSON', async () => {
+      const configPath = path.join(fixtureDir, 'i18n.config.json');
+      const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
+      config.dynamicKeys = {
+        expand: {
+          'workingHours.*': ['monday', 'tuesday'],
+        },
+      };
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+      const enPath = path.join(fixtureDir, 'locales', 'en.json');
+      const enLocale = JSON.parse(await fs.readFile(enPath, 'utf8'));
+      enLocale['workingHours.monday'] = 'Monday';
+      await fs.writeFile(enPath, JSON.stringify(enLocale, null, 2));
+
+      const result = runCli(['check', '--json'], { cwd: fixtureDir });
+      const parsed = extractJson<{ sync: { dynamicKeyCoverage: Array<{ pattern: string; missingByLocale: Record<string, string[]> }> } }>(result.stdout);
+
+      const coverage = parsed.sync.dynamicKeyCoverage.find((entry) => entry.pattern === 'workingHours.*');
+      expect(coverage).toBeDefined();
+      expect(coverage!.missingByLocale.en).toEqual(['workingHours.tuesday']);
+      expect(coverage!.missingByLocale.fr).toContain('workingHours.monday');
+      expect(coverage!.missingByLocale.de).toContain('workingHours.monday');
+    });
+
+    it('writes a dynamic key coverage report file', async () => {
+      const configPath = path.join(fixtureDir, 'i18n.config.json');
+      const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
+      config.dynamicKeys = {
+        expand: {
+          'workingHours.*': ['monday', 'tuesday'],
+        },
+      };
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+      const reportPath = path.join(fixtureDir, 'coverage-report.json');
+      const result = runCli(['coverage', '--report', reportPath], { cwd: fixtureDir });
+      expect(result.exitCode).toBe(0);
+
+      const payload = JSON.parse(await fs.readFile(reportPath, 'utf8')) as {
+        summary: { patterns: number; missing: number };
+      };
+      expect(payload.summary.patterns).toBeGreaterThan(0);
+    });
+  });
+
   describe('--invalidate-cache flag', () => {
     let fixtureDir: string;
 

package/src/index.ts

@@ -17,13 +17,14 @@ import { registerInstallHooks } from './commands/install-hooks.js';
 import { registerConfig } from './commands/config.js';
 import { registerReview } from './commands/review.js';
 import { registerDetect } from './commands/detect.js';
+import { registerCoverage } from './commands/coverage.js';
 
 export const program = new Command();
 
 program
   .name('i18nsmith')
   .description('Universal Automated i18n Library')
-  .version('0.4.2');
+  .version('0.4.3');
 
 registerInit(program);
 registerScaffoldAdapter(program);
@@ -42,6 +43,7 @@ registerInstallHooks(program);
 registerConfig(program);
 registerReview(program);
 registerDetect(program);
+registerCoverage(program);
 
 
 program.parse();

package/src/rename-suspicious.test.ts

@@ -92,8 +92,8 @@ describe('Rename Suspicious Keys E2E', () => {
     expect(renameDiff).toBeDefined();
     // console.log('Actual diff:', renameDiff.diff);
     expect(renameDiff.diff).toContain('-      <h1>{t(\'Hello World\')}</h1>');
-    // Key generation includes hash and file slug
-    expect(renameDiff.diff).toMatch(/\+      <h1>{t\('common\.badkeys\.hello-world\.[a-f0-9]+'\)}<\/h1>/); 
+  // Key generation preserves namespace and omits hash suffixes
+  expect(renameDiff.diff).toMatch(/\+      <h1>{t\('common\.hello-world'\)}<\/h1>/); 
   });
 
   it('should handle existing keys that are suspicious (key-equals-value or contains-spaces)', async () => {