i18nsmith 0.4.3 → 0.6.0

package/src/commands/sync.ts

@@ -4,9 +4,9 @@ import inquirer, { type CheckboxQuestion } from "inquirer";
 import { promises as fs } from "fs";
 import path from "path";
 import {
+  // Legacy imports - kept for complex interactive flows
+  // TODO: Migrate interactive sync to use ISyncService when it supports passing syncer instance
   Syncer,
-  KeyRenamer,
-  LocaleStore,
   loadConfig,
   loadConfigWithMeta,
   generateRenameProposals,
@@ -15,6 +15,7 @@ import {
   type KeyRenameBatchSummary,
   type SyncSelection,
 } from "@i18nsmith/core";
+import { getServiceContainer } from "../utils/bootstrap.js";
 import {
   printLocaleDiffs,
   writeLocaleDiffPatches,
@@ -22,7 +23,7 @@ import {
 import { applyPreviewFile, writePreviewFile } from "../utils/preview.js";
 import { SYNC_EXIT_CODES } from "../utils/exit-codes.js";
 import { runCheck } from "./check.js";
-import { withErrorHandling } from "../utils/errors.js";
+import { withErrorHandling, CliError } from "../utils/errors.js";
 
 interface SyncCommandOptions {
   config?: string;
@@ -48,7 +49,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 +194,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 +329,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(
@@ -467,11 +475,16 @@ export function registerSync(program: Command) {
             process.cwd(),
             config.localesDir ?? "locales"
           );
-          const localeStore = new LocaleStore(localesDir, {
+          const localeContainer = getServiceContainer({ workspaceRoot: projectRoot });
+          const localeStore = localeContainer.localeStoreFactory.create(localesDir, {
             sortKeys: config.locales?.sortKeys ?? "alphabetical",
           });
           const sourceLocale = config.sourceLanguage ?? "en";
-          const sourceData = await localeStore.get(sourceLocale);
+          const sourceResult = await localeStore.get(sourceLocale);
+          if (!sourceResult.success) {
+            throw new CliError(`Failed to read source locale: ${sourceResult.error.message}`);
+          }
+          const sourceData = sourceResult.data;
           const existingKeys = new Set(Object.keys(sourceData));
 
           const namingConvention = options.namingConvention ?? "kebab-case";
@@ -480,6 +493,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) {
@@ -488,15 +503,17 @@ export function registerSync(program: Command) {
               to: proposal.proposedKey,
             }));
 
-            const renamer = new KeyRenamer(config, {
-              workspaceRoot: projectRoot,
-            });
+            const renameContainer = getServiceContainer({ workspaceRoot: projectRoot });
             // Run rename batch in dry-run mode with diffs
-            const batchSummary = await renamer.renameBatch(mappings, {
+            const renameResult = await renameContainer.keyRenamer.renameBatch(config, mappings, {
               write: false,
               diff: true,
               allowConflicts: true,
             });
+            if (!renameResult.success) {
+              throw new CliError(`Rename analysis failed: ${renameResult.error.message}`);
+            }
+            const batchSummary = renameResult.data;
 
             // Merge rename diffs into summary
             summary.renameDiffs = batchSummary.diffs;
@@ -575,7 +592,7 @@ export function registerSync(program: Command) {
           options.rewriteShape &&
           (options.rewriteShape === "flat" || options.rewriteShape === "nested")
         ) {
-          await handleRewriteShape(options, config);
+          await handleRewriteShape(options, config, projectRoot);
         }
 
         const shouldFailPlaceholders =
@@ -769,6 +786,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:"));
@@ -873,18 +902,43 @@ async function handleAutoRenameSuspicious(
     process.cwd(),
     config.localesDir ?? "locales"
   );
-  const localeStore = new LocaleStore(localesDir, {
+  const container = getServiceContainer({ workspaceRoot: projectRoot });
+  const localeStore = container.localeStoreFactory.create(localesDir, {
     sortKeys: config.locales?.sortKeys ?? "alphabetical",
   });
   const sourceLocale = config.sourceLanguage ?? "en";
-  const sourceData = await localeStore.get(sourceLocale);
+  const sourceResult = await localeStore.get(sourceLocale);
+  if (!sourceResult.success) {
+    throw new CliError(`Failed to read source locale: ${sourceResult.error.message}`);
+  }
+  const sourceData = sourceResult.data;
   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") {
+    const storedLocalesResult = await localeStore.getStoredLocales();
+    if (storedLocalesResult.success) {
+      const allKeys = new Set<string>();
+      for (const locale of storedLocalesResult.data) {
+        const localeResult = await localeStore.get(locale);
+        if (localeResult.success) {
+          Object.keys(localeResult.data).forEach(key => allKeys.add(key));
+        }
+      }
+      allExistingKeys = Array.from(allKeys);
+      console.log(`  Auto-detected naming convention from ${allKeys.size} existing keys`);
+    } else {
+      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,
   });
 
@@ -980,12 +1034,16 @@ async function handleAutoRenameSuspicious(
         to: proposal.proposedKey,
       }));
 
-      const renamer = new KeyRenamer(config, { workspaceRoot: projectRoot });
-      const applySummary = await renamer.renameBatch(mappings, {
+      const renameContainer = getServiceContainer({ workspaceRoot: projectRoot });
+      const renameResult = await renameContainer.keyRenamer.renameBatch(config, mappings, {
         write: true,
         diff: Boolean(options.diff),
         allowConflicts: true,
       });
+      if (!renameResult.success) {
+        throw new CliError(`Batch rename failed: ${renameResult.error.message}`);
+      }
+      const applySummary = renameResult.data;
       printRenameBatchSummary(applySummary);
 
       if (!options.renameMapFile && hasMappings) {
@@ -1024,12 +1082,16 @@ async function handleAutoRenameSuspicious(
       to: proposal.proposedKey,
     }));
 
-    const renamer = new KeyRenamer(config, { workspaceRoot: projectRoot });
-    const diffSummary = await renamer.renameBatch(mappings, {
+    const renameContainer = getServiceContainer({ workspaceRoot: projectRoot });
+    const diffResult = await renameContainer.keyRenamer.renameBatch(config, mappings, {
       write: false,
       diff: true,
       allowConflicts: true,
     });
+    if (!diffResult.success) {
+      throw new CliError(`Diff generation failed: ${diffResult.error.message}`);
+    }
+    const diffSummary = diffResult.data;
 
     return diffSummary.diffs;
   }
@@ -1037,7 +1099,8 @@ async function handleAutoRenameSuspicious(
 
 async function handleRewriteShape(
   options: SyncCommandOptions,
-  config: Awaited<ReturnType<typeof loadConfig>>
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  projectRoot: string
 ) {
   const targetFormat = options.rewriteShape as "flat" | "nested";
   const delimiter = options.shapeDelimiter ?? ".";
@@ -1050,7 +1113,8 @@ async function handleRewriteShape(
     process.cwd(),
     config.localesDir ?? "locales"
   );
-  const localeStore = new LocaleStore(localesDir, {
+  const container = getServiceContainer({ workspaceRoot: projectRoot });
+  const localeStore = container.localeStoreFactory.create(localesDir, {
     delimiter,
     sortKeys: config.locales?.sortKeys ?? "alphabetical",
   });
@@ -1065,7 +1129,11 @@ async function handleRewriteShape(
   }
 
   // Rewrite all locales to the target format
-  const stats = await localeStore.rewriteShape(targetFormat, { delimiter });
+  const rewriteResult = await localeStore.rewriteShape(targetFormat, { delimiter });
+  if (!rewriteResult.success) {
+    throw new CliError(`Failed to rewrite locales: ${rewriteResult.error.message}`);
+  }
+  const stats = rewriteResult.data;
 
   if (stats.length === 0) {
     console.log(chalk.yellow("  No locale files found to rewrite."));

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.6.0');
 
 registerInit(program);
 registerScaffoldAdapter(program);

package/src/integration.test.ts

@@ -23,16 +23,25 @@ function runCli(
   args: string[],
   options: { cwd?: string } = {}
 ): { stdout: string; stderr: string; output: string; exitCode: number } {
+  // Clear known debug env vars so the test output is deterministic even when
+  // developer environments set DEBUG_* flags. Preserve essential env vars.
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    CI: 'true',
+    NO_COLOR: '1',
+    FORCE_COLOR: '0',
+  };
+  // Remove any DEBUG_* flags that may leak into the spawned CLI process
+  delete env.DEBUG_VUE_PARSER;
+  delete env.DEBUG_REFEXT;
+  delete env.DEBUG_SYNC_REF;
+  delete env.DEBUG_VUE_MUTATE;
+
   const result = spawnSync('node', [CLI_PATH, ...args], {
     cwd: options.cwd ?? process.cwd(),
     encoding: 'utf8',
     timeout: 30000,
-    env: {
-      ...process.env,
-      CI: 'true',
-      NO_COLOR: '1',
-      FORCE_COLOR: '0',
-    },
+    env,
   });
 
   // Log errors for debugging
@@ -53,11 +62,48 @@ function runCli(
 
 // Helper to extract JSON from CLI output (may contain log messages before JSON)
 function extractJson<T>(output: string): T {
-  const jsonMatch = output.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
+  // Use brace-counting to find all complete top-level JSON objects in the output.
+  // This correctly handles nested braces (arrays/objects inside the top-level object).
+  const candidates: string[] = [];
+  let i = 0;
+  while (i < output.length) {
+    if (output[i] === '{') {
+      let depth = 0;
+      let inString = false;
+      let escape = false;
+      let j = i;
+      for (; j < output.length; j++) {
+        const ch = output[j];
+        if (escape) { escape = false; continue; }
+        if (ch === '\\' && inString) { escape = true; continue; }
+        if (ch === '"') { inString = !inString; continue; }
+        if (inString) continue;
+        if (ch === '{') depth++;
+        else if (ch === '}') {
+          depth--;
+          if (depth === 0) { candidates.push(output.slice(i, j + 1)); break; }
+        }
+      }
+      i = j + 1;
+    } else {
+      i++;
+    }
+  }
+
+  if (!candidates.length) {
     throw new Error(`No JSON found in output: ${output.slice(0, 200)}...`);
   }
-  return JSON.parse(jsonMatch[0]);
+
+  // Prefer the largest candidate (most likely the top-level summary).
+  candidates.sort((a, b) => b.length - a.length);
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch (_err) {
+      // try next candidate
+    }
+  }
+  throw new Error(`No valid JSON block found in output: ${output.slice(0, 400)}...`);
 }
 
 describe('CLI Integration Tests', () => {
@@ -188,7 +234,7 @@ export function App() {
       );
 
       const result = runCli(['scan', '--json'], { cwd: tmpDir });
-      const parsed = extractJson<{ filesScanned: number; candidates: unknown[] }>(result.stdout);
+  const parsed = extractJson<{ filesScanned: number; candidates: unknown[] }>(result.output);
 
       expect(parsed).toHaveProperty('filesScanned');
       expect(parsed).toHaveProperty('candidates');
@@ -333,6 +379,61 @@ export function App() {
       expect(backupExists).toBe(true);
     });
 
+    it('CLI end-to-end: detects nested $t inside template object args (I18nDemo.vue)', async () => {
+      // Setup Vue SFC that uses a nested $t(...) inside an interpolation object
+      const vue = `
+<template>
+  <p v-if="name">{{ $t('common.components.i18ndemo.arg0-name.4ac48a', { arg0: $t('demo.card.greeting'), name }) }}</p>
+</template>
+`;
+
+      await fs.mkdir(path.join(tmpDir, 'src', 'components'), { recursive: true });
+      await fs.writeFile(path.join(tmpDir, 'src', 'components', 'I18nDemo.vue'), vue);
+
+      const en = {
+        common: { components: { i18ndemo: { 'arg0-name': '{arg0} {name}' } } },
+        demo: { card: { greeting: 'Hello' } }
+      };
+      const es = {
+        common: { components: { i18ndemo: { 'arg0-name': '{arg0} {name}' } } },
+        demo: { card: { greeting: 'Hola' } }
+      };
+
+      await fs.writeFile(path.join(tmpDir, 'locales', 'en.json'), JSON.stringify(en, null, 2));
+      await fs.writeFile(path.join(tmpDir, 'locales', 'fr.json'), JSON.stringify(es, null, 2));
+
+      // Update config to include .vue files for this test
+      const cfgPath = path.join(tmpDir, 'i18n.config.json');
+      const cfg = JSON.parse(await fs.readFile(cfgPath, 'utf8'));
+      cfg.include = ['src/**/*.vue', 'src/**/*.{ts,js,tsx}'];
+      await fs.writeFile(cfgPath, JSON.stringify(cfg, null, 2));
+
+  const result = runCli(['sync', '--json'], { cwd: tmpDir });
+  expect(result.exitCode).toBe(0);
+
+  // Sanity check: CLI output should contain the quoted key somewhere so
+  // editors/CI that scan the output can detect the reference even when
+  // there are additional log lines present.
+  expect(result.output).toContain('"demo.card.greeting"');
+
+      // Also try to parse JSON summary if possible and validate references.
+      // If parsing fails during CI or debugging, print raw output for diagnosis.
+      try {
+        const parsed = extractJson<any>(result.output);
+        const referenced = parsed.references.map((r: any) => r.key);
+        const unused = parsed.unusedKeys.map((u: any) => u.key);
+
+        expect(referenced).toContain('demo.card.greeting');
+        expect(unused).not.toContain('demo.card.greeting');
+      } catch (err) {
+        // Dump output for debugging in test logs then rethrow so CI shows failure
+        // (this helps capture the raw CLI output when test fails).
+        // eslint-disable-next-line no-console
+        console.error('CLI raw output (truncated):', result.output.slice(0, 4000));
+        throw err;
+      }
+    });
+
     it('should skip backup with --no-backup', async () => {
       await fs.writeFile(
         path.join(tmpDir, 'src', 'App.tsx'),
@@ -427,6 +528,38 @@ export function App() {
       expect(result.output).toContain('Planning transform (dry-run)');
       expect(result.exitCode).toBe(0);
     });
+
+    it('extraction should not include structural opening punctuation (Items ({count}) case)', async () => {
+      const content = `export function App() {
+  const count = 5;
+  const items = ['a','b'];
+  return (
+    <>
+      <p>Items ({count}): {items.join(', ')}</p>
+      <p>{'Items (' + count + ')'}</p>
+    </>
+  );
+}`;
+
+      await fs.writeFile(path.join(tmpDir, 'src', 'App.tsx'), content);
+
+      const result = runCli(['transform', '--json'], { cwd: tmpDir });
+      expect(result.exitCode).toBe(0);
+      const parsed = extractJson<any>(result.output);
+      const candidates = parsed.candidates || [];
+
+      // No candidate text should include the structural '(' token before the placeholder
+      const hasBadText = candidates.some((c: any) => typeof c.text === 'string' && c.text.includes('Items ('));
+      expect(hasBadText).toBe(false);
+
+      // Find the Items-related candidate and assert its suggestedKey is derived from the static "Items"
+      const itemsCandidate = candidates.find((c: any) => typeof c.text === 'string' && /Items/.test(c.text));
+      expect(itemsCandidate).toBeDefined();
+      expect(itemsCandidate.text).not.toContain('(');
+      if (itemsCandidate.interpolation) {
+        expect(itemsCandidate.interpolation.template).not.toMatch(/Items \(/);
+      }
+    });
   });
 
   describe('check command', () => {
@@ -477,7 +610,7 @@ export function App() {
       );
 
       const result = runCli(['check', '--json'], { cwd: tmpDir });
-      const parsed = extractJson<{ diagnostics: unknown; sync: unknown }>(result.stdout);
+  const parsed = extractJson<{ diagnostics: unknown; sync: unknown }>(result.output);
 
       expect(parsed).toHaveProperty('diagnostics');
       expect(parsed).toHaveProperty('sync');
@@ -524,7 +657,7 @@ export function App() {
       );
 
       const result = runCli(['check', '--audit', '--json'], { cwd: tmpDir });
-      const parsed = extractJson<{ audit?: { totalQualityIssues: number } }>(result.stdout);
+  const parsed = extractJson<{ audit?: { totalQualityIssues: number } }>(result.output);
 
       expect(parsed).toHaveProperty('audit');
       expect(parsed.audit?.totalQualityIssues ?? 0).toBeGreaterThan(0);

package/src/services/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview
+ * CLI Services Module
+ * 
+ * CLI-level service implementations that cannot live in @i18nsmith/core
+ * due to dependency constraints.
+ * 
+ * @module @i18nsmith/cli/services
+ */
+
+export { CliTransformService, getTransformService } from './transform-service.js';
+export type { CliTransformServiceConfig } from './transform-service.js';