i18nsmith 0.4.3 → 0.6.0

package/dist/services/index.d.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';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClF,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/services/transform-service.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview
+ * CLI Transform Service - Implements ITransformService for CLI usage
+ *
+ * This service wraps @i18nsmith/transformer's Transformer class and provides
+ * the ITransformService interface. It lives in CLI because:
+ * - @i18nsmith/core should NOT depend on @i18nsmith/transformer
+ * - CLI depends on both packages, making this the natural location
+ *
+ * @module @i18nsmith/cli/services/transform-service
+ */
+import { type I18nConfig, type ITransformService, type TransformOptions, type TransformSummaryBase, type ScanCandidate, type Result } from '@i18nsmith/core';
+/**
+ * Configuration for the CLI transform service.
+ */
+export interface CliTransformServiceConfig {
+    /** Workspace root directory */
+    readonly workspaceRoot: string;
+}
+/**
+ * CLI implementation of ITransformService.
+ *
+ * Wraps the @i18nsmith/transformer Transformer class with the standard
+ * Result-based error handling pattern used across the service layer.
+ */
+export declare class CliTransformService implements ITransformService {
+    private readonly workspaceRoot;
+    constructor(config: CliTransformServiceConfig);
+    /**
+     * Transforms source files to use translation functions.
+     */
+    transform(config: I18nConfig, options?: TransformOptions): Promise<Result<TransformSummaryBase>>;
+    /**
+     * Transforms specific candidates (from a previous scan).
+     *
+     * Note: The current Transformer doesn't have a direct method for this,
+     * so we run a full transform with targets limited to the candidate files.
+     */
+    transformCandidates(config: I18nConfig, candidates: readonly ScanCandidate[], options?: TransformOptions): Promise<Result<TransformSummaryBase>>;
+    /**
+     * Generates a preview of transformation without applying.
+     */
+    preview(config: I18nConfig, options?: Omit<TransformOptions, 'write'>): Promise<Result<TransformSummaryBase>>;
+}
+/**
+ * Creates a CLI transform service instance.
+ *
+ * @param workspaceRoot - The workspace root directory
+ * @returns ITransformService instance
+ *
+ * @example
+ * ```typescript
+ * import { getTransformService } from '../services/transform-service.js';
+ *
+ * const transformService = getTransformService(projectRoot);
+ * const result = await transformService.transform(config, { write: true });
+ *
+ * if (!result.success) {
+ *   throw new CliError(result.error.message);
+ * }
+ * ```
+ */
+export declare function getTransformService(workspaceRoot: string): ITransformService;
+//# sourceMappingURL=transform-service.d.ts.map

package/dist/services/transform-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-service.d.ts","sourceRoot":"","sources":["../../src/services/transform-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,MAAM,EAIZ,MAAM,iBAAiB,CAAC;AAMzB;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,+BAA+B;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAqDD;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,MAAM,EAAE,yBAAyB;IAI7C;;OAEG;IACG,SAAS,CACb,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;IAuBxC;;;;;OAKG;IACG,mBAAmB,CACvB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,SAAS,aAAa,EAAE,EACpC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;IA0BxC;;OAEG;IACG,OAAO,CACX,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GACxC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;CAGzC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,iBAAiB,CAE5E"}

package/dist/utils/bootstrap.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview
+ * CLI Bootstrap - Service Container Setup for CLI
+ *
+ * This module provides a pre-configured ServiceContainer with Node.js
+ * platform adapters. CLI commands can import this to use the service layer.
+ *
+ * Following Hexagonal Architecture:
+ * - The ServiceContainer is the "Application Layer"
+ * - This bootstrap module configures "Adapters" for CLI (Node.js) environment
+ *
+ * @example
+ * ```typescript
+ * import { getServiceContainer } from '../utils/bootstrap.js';
+ *
+ * async function myCommand() {
+ *   const container = getServiceContainer();
+ *   const result = await container.scanner.scan(config);
+ *   // ...
+ * }
+ * ```
+ *
+ * @module @i18nsmith/cli/utils/bootstrap
+ */
+import { ServiceContainer, type ServiceContainerConfig } from '@i18nsmith/core';
+import type { ILogger, LogLevel, ILoggerFactory } from '@i18nsmith/core';
+/**
+ * CLI-specific logger that outputs with chalk formatting.
+ */
+declare class CliLogger implements ILogger {
+    private currentLevel;
+    private readonly scope;
+    private readonly levelOrder;
+    constructor(scope?: string, level?: LogLevel);
+    private shouldLog;
+    trace(message: string, data?: Record<string, unknown>): void;
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, error?: Error, data?: Record<string, unknown>): void;
+    child(scope: string): ILogger;
+    getLevel(): LogLevel;
+    setLevel(level: LogLevel): void;
+}
+/**
+ * Factory for creating CLI loggers.
+ */
+declare class CliLoggerFactory implements ILoggerFactory {
+    private readonly level;
+    private readonly rootLogger;
+    constructor(level?: LogLevel);
+    createLogger(scope: string): ILogger;
+    getRootLogger(): ILogger;
+    setGlobalLevel(level: LogLevel): void;
+}
+/**
+ * Sets the global log level for CLI operations.
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * Gets the global service container, creating it if needed.
+ *
+ * @param options - Optional configuration overrides
+ * @returns Configured ServiceContainer
+ */
+export declare function getServiceContainer(options?: {
+    workspaceRoot?: string;
+    logLevel?: LogLevel;
+}): ServiceContainer;
+/**
+ * Creates a fresh service container (useful for testing or scoped operations).
+ *
+ * @param config - Container configuration
+ * @returns New ServiceContainer instance
+ */
+export declare function createCliServiceContainer(config?: ServiceContainerConfig): ServiceContainer;
+/**
+ * Resets the global container (useful for testing).
+ */
+export declare function resetServiceContainer(): void;
+export { CliLogger, CliLoggerFactory };
+export type { LogLevel };
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/utils/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/utils/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EACL,gBAAgB,EAIhB,KAAK,sBAAsB,EAE5B,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMzE;;GAEG;AACH,cAAM,SAAU,YAAW,OAAO;IAChC,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAMzB;gBAEU,KAAK,GAAE,MAAc,EAAE,KAAK,GAAE,QAAiB;IAK3D,OAAO,CAAC,SAAS;IAIjB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM3D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM3D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAY3E,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI7B,QAAQ,IAAI,QAAQ;IAIpB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;CAGhC;AAED;;GAEG;AACH,cAAM,gBAAiB,YAAW,cAAc;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;gBAE3B,KAAK,GAAE,QAAiB;IAKpC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIpC,aAAa,IAAI,OAAO;IAIxB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;CAGtC;AASD;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAMjD;AAYD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,GAAG,gBAAgB,CAgBnB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,CAAC,EAAE,sBAAsB,GAAG,gBAAgB,CAQ3F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAMD,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC;AACvC,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/package.json

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

package/src/commands/backup.ts

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { listBackups, restoreBackup } from '@i18nsmith/core';
 import { CliError, withErrorHandling } from '../utils/errors.js';
+import { getServiceContainer } from '../utils/bootstrap.js';
 
 /**
  * Registers backup-related commands (backup-list, backup-restore)
@@ -13,10 +13,16 @@ export function registerBackup(program: Command): void {
     .description('List available locale file backups')
     .option('--backup-dir <path>', 'Custom backup directory (default: .i18nsmith-backup)')
     .action(
-      withErrorHandling(async (options: { backupDir?: string }) => {
+      withErrorHandling(async (_options: { backupDir?: string }) => {
         try {
-          const workspaceRoot = process.cwd();
-          const backups = await listBackups(workspaceRoot, { backupDir: options.backupDir });
+          const container = getServiceContainer();
+          const result = await container.backup.list();
+
+          if (!result.success) {
+            throw new CliError(`Error listing backups: ${result.error.message}`);
+          }
+
+          const backups = result.data;
 
           if (backups.length === 0) {
             console.log(chalk.yellow('No backups found.'));
@@ -34,6 +40,7 @@ export function registerBackup(program: Command): void {
 
           console.log(chalk.gray(`\nRestore a backup with: i18nsmith backup-restore <timestamp>`));
         } catch (error) {
+          if (error instanceof CliError) throw error;
           const message = error instanceof Error ? error.message : String(error);
           throw new CliError(`Error listing backups: ${message}`);
         }
@@ -46,10 +53,16 @@ export function registerBackup(program: Command): void {
     .argument('<timestamp>', 'Backup timestamp (from backup-list) or "latest" for most recent')
     .option('--backup-dir <path>', 'Custom backup directory (default: .i18nsmith-backup)')
     .action(
-      withErrorHandling(async (timestamp: string, options: { backupDir?: string }) => {
+      withErrorHandling(async (timestamp: string, _options: { backupDir?: string }) => {
         try {
-          const workspaceRoot = process.cwd();
-          const backups = await listBackups(workspaceRoot, { backupDir: options.backupDir });
+          const container = getServiceContainer();
+          const listResult = await container.backup.list();
+
+          if (!listResult.success) {
+            throw new CliError(`Error listing backups: ${listResult.error.message}`);
+          }
+
+          const backups = listResult.data;
 
           if (backups.length === 0) {
             throw new CliError('No backups found.');
@@ -85,13 +98,18 @@ export function registerBackup(program: Command): void {
             return;
           }
 
-          const result = await restoreBackup(targetBackup.path, workspaceRoot);
+          const result = await container.backup.restore(targetBackup.path);
+
+          if (!result.success) {
+            throw new CliError(`Error restoring backup: ${result.error.message}`);
+          }
 
-          console.log(chalk.green(`\n✅ ${result.summary}`));
-          for (const file of result.restored) {
+          console.log(chalk.green(`\n✅ ${result.data.summary}`));
+          for (const file of result.data.restored) {
             console.log(chalk.gray(`   Restored: ${file}`));
           }
         } catch (error) {
+          if (error instanceof CliError) throw error;
           const message = error instanceof Error ? error.message : String(error);
           throw new CliError(`Error restoring backup: ${message}`);
         }

package/src/commands/check.ts

@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import type { Command } from 'commander';
-import { loadConfigWithMeta, CheckRunner, isPackageResolvable } from '@i18nsmith/core';
+import { loadConfigWithMeta, 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';
@@ -14,6 +14,7 @@ import {
   type LocaleAuditSummary,
 } from '../utils/locale-audit.js';
 import { CliError, withErrorHandling } from '../utils/errors.js';
+import { getServiceContainer } from '../utils/bootstrap.js';
 
 interface CheckCommandOptions {
   config?: string;
@@ -186,7 +187,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);
 
@@ -218,8 +223,9 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
       console.log(chalk.yellow('   Some Vue template references may be skipped.'));
     }
 
-    const runner = new CheckRunner(config, { workspaceRoot: projectRoot });
-    const summary = await runner.run({
+    // Use ServiceContainer for check service
+    const container = getServiceContainer({ workspaceRoot: projectRoot });
+    const checkResult = await container.check.run(config, {
       assumedKeys: options.assume,
       validateInterpolations: options.validateInterpolations,
       emptyValuePolicy: options.emptyValues === false ? 'fail' : undefined,
@@ -228,6 +234,12 @@ export async function runCheck(options: CheckCommandOptions): Promise<void> {
       invalidateCache: options.invalidateCache,
     });
 
+    if (!checkResult.success) {
+      throw new CliError(`Health check failed: ${checkResult.error.message}`);
+    }
+
+    const summary = checkResult.data;
+
     let localeAudit: LocaleAuditSummary | undefined;
     if (auditEnabled) {
       const auditLocales = options.auditLocales?.filter(Boolean) ?? [];

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/coverage.ts

@@ -2,9 +2,10 @@ 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 { loadConfigWithMeta } from '@i18nsmith/core';
 import type { DynamicKeyCoverage, I18nConfig } from '@i18nsmith/core';
 import { CliError, withErrorHandling } from '../utils/errors.js';
+import { getServiceContainer } from '../utils/bootstrap.js';
 
 interface CoverageCommandOptions {
   config?: string;
@@ -69,14 +70,20 @@ export function registerCoverage(program: Command) {
 
 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({
+  
+  // Use ServiceContainer for sync operations
+  const container = getServiceContainer({ workspaceRoot: projectRoot });
+  const syncResult = await container.sync.sync(config, {
     write: false,
     targets: options.target,
     invalidateCache: options.invalidateCache,
   });
 
+  if (!syncResult.success) {
+    throw new CliError(`Coverage analysis failed: ${syncResult.error.message}`);
+  }
+
+  const summary = syncResult.data;
   const coverage = summary.dynamicKeyCoverage ?? [];
   const report = buildCoverageReport(coverage, config, projectRoot, configPath);
 

package/src/commands/detect.ts

@@ -3,11 +3,11 @@ import path from 'path';
 import chalk from 'chalk';
 import type { Command } from 'commander';
 import {
-  ProjectIntelligenceService,
   type ProjectIntelligence,
   type ConfidenceLevel,
 } from '@i18nsmith/core';
-import { withErrorHandling } from '../utils/errors.js';
+import { withErrorHandling, CliError } from '../utils/errors.js';
+import { getServiceContainer } from '../utils/bootstrap.js';
 
 interface DetectOptions {
   json?: boolean;
@@ -304,8 +304,15 @@ export function registerDetect(program: Command) {
         console.log(chalk.blue('🔍 Analyzing project...'));
         console.log(chalk.gray(`   Working directory: ${workspaceRoot}\n`));
 
-        const service = new ProjectIntelligenceService();
-        const result = await service.analyze({ workspaceRoot });
+        // Use ServiceContainer for project intelligence
+        const container = getServiceContainer({ workspaceRoot });
+        const analyzeResult = await container.projectIntelligence.analyze({ workspaceRoot });
+
+        if (!analyzeResult.success) {
+          throw new CliError(`Project analysis failed: ${analyzeResult.error.message}`);
+        }
+
+        const result = analyzeResult.data;
 
         // JSON output
         if (options.json) {

package/src/commands/diagnose.ts

@@ -2,10 +2,11 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import type { Command } from 'commander';
-import { loadConfig, diagnoseWorkspace } from '@i18nsmith/core';
+import { loadConfig } from '@i18nsmith/core';
 import type { DiagnosisReport } from '@i18nsmith/core';
 import { getDiagnosisExitSignal } from '../utils/diagnostics-exit.js';
 import { CliError, withErrorHandling } from '../utils/errors.js';
+import { getServiceContainer } from '../utils/bootstrap.js';
 
 interface DiagnoseCommandOptions {
   config?: string;
@@ -109,7 +110,16 @@ export function registerDiagnose(program: Command) {
         console.log(chalk.blue('Running repository diagnostics...'));
         try {
           const config = await loadConfig(options.config);
-          const report = await diagnoseWorkspace(config);
+          
+          // Use ServiceContainer for diagnostics
+          const container = getServiceContainer();
+          const diagnoseResult = await container.diagnostics.diagnose(config);
+
+          if (!diagnoseResult.success) {
+            throw new CliError(`Diagnose failed: ${diagnoseResult.error.message}`);
+          }
+
+          const report = diagnoseResult.data;
 
           if (options.report) {
             const outputPath = path.resolve(process.cwd(), options.report);

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', () => {