ai-localize-cli 2.0.0 → 2.0.3

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # ai-localize-cli
 
+## 2.0.3
+
+### Minor Changes
+
+- **`keyStyle` config option** — `extract` and `full-migrate` commands now respect `keyStyle: "screaming_snake"` in `ai-localize.config.json`; all scanned hardcoded strings are extracted with UPPER_SNAKE_CASE keys matching the text value (e.g. `"Save Changes"` -> key `SAVE_CHANGES`, value `"Save Changes"`) instead of the default hierarchical path-based key style
+- **`staticKeys` config option** — `extract` and `full-migrate` commands now inject `staticKeys` entries from config into every generated locale file regardless of scanning results; useful for enum labels, status codes, and other constant strings not present as literals in source files
+
+### Patch Changes
+
+- Updated dependencies
+  - ai-localize-scanner@2.0.3
+  - ai-localize-config@2.0.3
+  - ai-localize-shared@2.0.3
+  - ai-localize-aws-cloudfront@2.0.3
+  - ai-localize-codemods@2.0.3
+  - ai-localize-framework-detectors@2.0.3
+  - ai-localize-locale-engine@2.0.3
+  - ai-localize-reporting@2.0.3
+  - ai-localize-validators@2.0.3
+
+## 2.0.2
+
+### Minor Changes
+
+- **Flat locale layout in `extract` and `full-migrate` commands** — `--locale-structure flat` flag (or `localeStructure: "flat"` in config) now writes one `<lang>.json` per language with all namespace keys merged
+- **Rich CLI report output** — `report` command now renders a structured terminal dashboard with coverage bars, top-file charts, missing-translation rankings, AST-context distribution, AI Insights, and actionable recommended next steps
+- **HTML analytics dashboard** — `report --format html` now generates a fully self-contained interactive dashboard (light/dark theme, sortable tables, SVG donut chart, CSV/JSON export, print/PDF)
+
+### Patch Changes
+
+- **Bug fix — locale key prefix** — resolved an issue where locale keys included ancestor path segments when `sourceRoot` was an absolute path
+- **Bug fix — codemods config wired through** — `codemods` block in `ai-localize.config.json` is now applied by all codemod commands instead of being silently ignored
+- Updated dependencies
+  - ai-localize-scanner@2.0.2
+  - ai-localize-config@2.0.2
+  - ai-localize-shared@2.0.2
+  - ai-localize-aws-cloudfront@2.0.2
+  - ai-localize-codemods@2.0.2
+  - ai-localize-framework-detectors@2.0.2
+  - ai-localize-locale-engine@2.0.2
+  - ai-localize-reporting@2.0.2
+  - ai-localize-validators@2.0.2
+
+## 2.0.1
+
+### Patch Changes
+
+- Fix config schema validation (aws optional/nullable, framework type), ignore className CSS values in AST scanner, add includePatterns config support for selective file scanning, add --extract-cdns flag to scan command to dump CDN URLs to a JSON file
+- Updated dependencies
+  - ai-localize-scanner@2.0.1
+  - ai-localize-config@2.0.1
+  - ai-localize-shared@2.0.1
+  - ai-localize-aws-cloudfront@2.0.1
+  - ai-localize-codemods@2.0.1
+  - ai-localize-framework-detectors@2.0.1
+  - ai-localize-locale-engine@2.0.1
+  - ai-localize-reporting@2.0.1
+  - ai-localize-validators@2.0.1
+
 ## 2.0.0
 
 ### Major Changes

package/dist/cli.js

@@ -80,11 +80,12 @@ function initCommand() {
 var import_commander2 = require("commander");
 var import_chalk3 = __toESM(require("chalk"));
 var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
 var import_ai_localize_config2 = require("ai-localize-config");
 var import_ai_localize_scanner = require("ai-localize-scanner");
 var import_ai_localize_shared = require("ai-localize-shared");
 function scanCommand() {
-  return new import_commander2.Command("scan").description("Scan project for hardcoded texts and asset references").option("--incremental", "Scan only changed files based on git diff").option("--staged", "Scan only git staged files").option("--cwd <path>", "Working directory", process.cwd()).option("--output <path>", "Output JSON file path").action(async (opts) => {
+  return new import_commander2.Command("scan").description("Scan project for hardcoded texts and asset references").option("--incremental", "Scan only changed files based on git diff").option("--staged", "Scan only git staged files").option("--cwd <path>", "Working directory", process.cwd()).option("--output <path>", "Output JSON file path for full scan results").option("--extract-cdns <path>", "Extract all discovered CDN/legacy URLs to a JSON file (e.g. cdn-urls.json)").action(async (opts) => {
     logger.header("ai-localize scan");
     const spinner = createSpinner("Loading configuration...").start();
     try {
@@ -109,6 +110,38 @@ function scanCommand() {
         (0, import_ai_localize_shared.writeJson)(outPath, result);
         logger.success("Results saved to " + import_chalk3.default.cyan(outPath));
       }
+      if (opts.extractCdns) {
+        const cdnOutPath = path.resolve(cwd, opts.extractCdns);
+        const cdnList = {
+          summary: {
+            totalLegacyCdnUrls: result.legacyCdnUrls.length,
+            totalAssetReferences: result.assets.length,
+            scannedAt: result.timestamp
+          },
+          legacyCdnUrls: result.legacyCdnUrls.map((cdn) => ({
+            url: cdn.url,
+            assetPath: cdn.assetPath,
+            filePath: cdn.filePath,
+            line: cdn.line
+          })),
+          assetReferences: result.assets.map((asset) => ({
+            assetPath: asset.assetPath,
+            assetType: asset.assetType,
+            referenceType: asset.referenceType,
+            filePath: asset.filePath,
+            line: asset.line
+          }))
+        };
+        const cdnOutDir = path.dirname(cdnOutPath);
+        if (!fs.existsSync(cdnOutDir)) {
+          fs.mkdirSync(cdnOutDir, { recursive: true });
+        }
+        fs.writeFileSync(cdnOutPath, JSON.stringify(cdnList, null, 2), "utf-8");
+        logger.success("CDN URLs extracted to " + import_chalk3.default.cyan(cdnOutPath));
+        logger.info(
+          "  Legacy CDN URLs: " + import_chalk3.default.red(String(result.legacyCdnUrls.length)) + "  Asset References: " + import_chalk3.default.blue(String(result.assets.length))
+        );
+      }
     } catch (err) {
       spinner.fail("Scan failed");
       logger.error(err.message);
@@ -132,6 +165,15 @@ function extractCommand() {
     try {
       const { config } = await (0, import_ai_localize_config3.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
+      const structure = config.localeStructure ?? "nested";
+      logger.info("Locale structure: " + import_chalk4.default.cyan(structure));
+      const staticKeys = config.staticKeys ?? {};
+      const staticKeyCount = Object.keys(staticKeys).length;
+      if (staticKeyCount > 0) {
+        logger.info(
+          "Static keys: " + import_chalk4.default.cyan(String(staticKeyCount)) + " (" + Object.keys(staticKeys).join(", ") + ")"
+        );
+      }
       const ss = createSpinner("Scanning for hardcoded text...").start();
       const scanner = new import_ai_localize_scanner2.ProjectScanner(config);
       const scanResult = await scanner.scan();
@@ -141,18 +183,35 @@ function extractCommand() {
       const extractor = new import_ai_localize_locale_engine.LocaleExtractor({
         defaultLanguage: config.defaultLanguage,
         targetLanguages: config.targetLanguages,
-        namespaceSplitting: true
+        namespaceSplitting: structure === "nested",
+        // flat mode does not need namespace splitting
+        staticKeys
       });
       const { localeFiles, keyCount, namespaces } = extractor.extract(uniqueTexts);
-      logger.info("Keys generated: " + import_chalk4.default.green(String(keyCount)));
-      logger.info("Namespaces: " + import_chalk4.default.cyan(namespaces.join(", ")));
+      logger.info(
+        "Keys generated: " + import_chalk4.default.green(String(keyCount)) + (staticKeyCount > 0 ? import_chalk4.default.dim(" (+ " + staticKeyCount + " static)") : "")
+      );
+      if (structure === "nested") {
+        logger.info("Namespaces: " + import_chalk4.default.cyan(namespaces.join(", ")));
+      }
       if (!opts.dryRun) {
         const localesDir = path2.resolve(cwd, config.localesDir);
-        const writer = new import_ai_localize_locale_engine.LocaleWriter({ localesDir, merge: opts.merge !== false });
+        const writer = new import_ai_localize_locale_engine.LocaleWriter({
+          localesDir,
+          merge: opts.merge !== false,
+          localeStructure: structure
+        });
         const { written, created, merged } = writer.write(localeFiles);
-        logger.success("Wrote " + written.length + " locale files (" + created.length + " new, " + merged.length + " merged)");
+        logger.success(
+          "Wrote " + written.length + " locale files (" + created.length + " new, " + merged.length + " merged)"
+        );
+        written.forEach((f) => logger.info("  " + import_chalk4.default.gray(f)));
       } else {
-        logger.info("Dry run - no files written");
+        logger.info("Dry run \u2014 no files written");
+        localeFiles.forEach((lf) => {
+          const label = structure === "flat" ? `${lf.language}.json` : `${lf.language}/${lf.namespace}.json`;
+          logger.info("  " + import_chalk4.default.gray(label) + " \u2014 " + Object.keys(lf.entries).length + " keys");
+        });
       }
     } catch (err) {
       spinner.fail("Extraction failed");
@@ -209,7 +268,7 @@ function validateCommand() {
 var import_commander5 = require("commander");
 var import_chalk6 = __toESM(require("chalk"));
 var path4 = __toESM(require("path"));
-var fs = __toESM(require("fs"));
+var fs2 = __toESM(require("fs"));
 var import_ai_localize_config5 = require("ai-localize-config");
 var import_ai_localize_validators2 = require("ai-localize-validators");
 var import_ai_localize_shared2 = require("ai-localize-shared");
@@ -232,7 +291,7 @@ function cleanupCommand() {
       unusedKeys.slice(0, 20).forEach((k) => logger.dim("- " + k));
       if (!opts.dryRun) {
         const defaultDir = path4.join(localesDir, config.defaultLanguage);
-        const nsFiles = fs.readdirSync(defaultDir).filter((f) => f.endsWith(".json"));
+        const nsFiles = fs2.readdirSync(defaultDir).filter((f) => f.endsWith(".json"));
         let removed = 0;
         for (const nsFile of nsFiles) {
           const ns = nsFile.replace(".json", "");
@@ -407,7 +466,7 @@ var import_ai_localize_scanner5 = require("ai-localize-scanner");
 var import_ai_localize_validators3 = require("ai-localize-validators");
 var import_ai_localize_reporting = require("ai-localize-reporting");
 function reportCommand() {
-  return new import_commander9.Command("report").description("Generate JSON and HTML localization reports").option("--cwd <path>", "Working directory", process.cwd()).option("--output-dir <path>", "Output directory for reports", ".ai-localize-reports").option("--no-html", "Skip HTML report generation").action(async (opts) => {
+  return new import_commander9.Command("report").description("Generate an HTML localization report with full details").option("--cwd <path>", "Working directory", process.cwd()).option("--output-dir <path>", "Directory where the HTML report is saved", ".ai-localize-reports").option("--filename <name>", "Report filename (default: report-<timestamp>.html)").option("--no-open", "Do not log the file path after generation").action(async (opts) => {
     logger.header("ai-localize report");
     const spinner = createSpinner("Loading configuration...").start();
     try {
@@ -417,7 +476,7 @@ function reportCommand() {
       const ss = createSpinner("Scanning project...").start();
       const scanner = new import_ai_localize_scanner5.ProjectScanner(config);
       const scanResult = await scanner.scan();
-      ss.succeed("Scanned " + scanResult.scannedFiles + " files");
+      ss.succeed("Scanned " + import_chalk10.default.cyan(String(scanResult.scannedFiles)) + " files");
       const vs = createSpinner("Validating locale files...").start();
       const validator = new import_ai_localize_validators3.LocaleValidator({
         localesDir: path8.resolve(cwd, config.localesDir),
@@ -426,15 +485,21 @@ function reportCommand() {
         targetLanguages: config.targetLanguages
       });
       const validationResult = validator.validate();
-      vs.succeed("Validation complete");
-      const outDir = path8.resolve(cwd, opts.outputDir);
+      vs.succeed(
+        validationResult.valid ? import_chalk10.default.green("Locale files valid") : import_chalk10.default.yellow(validationResult.errors.length + " errors, " + validationResult.warnings.length + " warnings")
+      );
       const rs = createSpinner("Building report...").start();
       const report = (0, import_ai_localize_reporting.buildReport)({ scanResult, validationResult });
-      if (opts.html !== false) {
-        (0, import_ai_localize_reporting.generateHtmlReport)(report, outDir);
-      }
-      rs.succeed("Report generated at " + import_chalk10.default.cyan(outDir));
+      const outDir = path8.resolve(cwd, opts.outputDir);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const filename = opts.filename || "report-" + timestamp + ".html";
+      const htmlPath = path8.join(outDir, filename);
+      (0, import_ai_localize_reporting.generateHtmlReport)(report, htmlPath);
+      rs.succeed("HTML report written to " + import_chalk10.default.cyan(htmlPath));
       (0, import_ai_localize_reporting.printCliSummary)(report);
+      logger.info(
+        "\n  Open the report in your browser:\n  " + import_chalk10.default.underline("file://" + htmlPath)
+      );
     } catch (err) {
       spinner.fail("Report generation failed");
       logger.error(String(err));
@@ -454,7 +519,7 @@ var import_ai_localize_codemods2 = require("ai-localize-codemods");
 var import_ai_localize_validators4 = require("ai-localize-validators");
 var import_ai_localize_reporting2 = require("ai-localize-reporting");
 function fullMigrateCommand() {
-  return new import_commander10.Command("full-migrate").description("Run full localization pipeline: scan -> extract -> codemod -> validate -> report").option("--cwd <path>", "Working directory", process.cwd()).option("--dry-run", "Preview changes without modifying files").option("--no-codemods", "Skip codemod phase").option("--no-report", "Skip report generation").action(async (opts) => {
+  return new import_commander10.Command("full-migrate").description("Run full localization pipeline: scan -> extract -> codemod -> validate -> report").option("--cwd <path>", "Working directory", process.cwd()).option("--dry-run", "Preview changes without modifying files").option("--no-codemods", "Skip codemod phase").option("--no-report", "Skip report generation").option("--report-dir <path>", "Directory where the HTML report is saved", ".ai-localize-reports").action(async (opts) => {
     logger.header("ai-localize full-migrate");
     const cwd = opts.cwd;
     const dryRun = opts.dryRun;
@@ -462,28 +527,38 @@ function fullMigrateCommand() {
       const cs = createSpinner("Loading configuration...").start();
       const { config } = await (0, import_ai_localize_config10.loadConfig)(cwd);
       cs.succeed("Configuration loaded");
+      const structure = config.localeStructure ?? "nested";
       const ss = createSpinner("Scanning for hardcoded text...").start();
       const scanner = new import_ai_localize_scanner6.ProjectScanner(config);
       const scanResult = await scanner.scan();
-      ss.succeed("Found " + import_chalk11.default.cyan(String(scanResult.detectedTexts.length)) + " texts in " + scanResult.scannedFiles + " files");
+      ss.succeed(
+        "Found " + import_chalk11.default.cyan(String(scanResult.detectedTexts.length)) + " texts in " + scanResult.scannedFiles + " files"
+      );
       const es = createSpinner("Extracting locale keys...").start();
       const uniqueTexts = (0, import_ai_localize_locale_engine2.deduplicateTexts)(scanResult.detectedTexts);
       const extractor = new import_ai_localize_locale_engine2.LocaleExtractor({
         defaultLanguage: config.defaultLanguage,
         targetLanguages: config.targetLanguages,
-        namespaceSplitting: true
+        // Flat layout merges all keys into one file per language — no namespace splitting
+        namespaceSplitting: structure === "nested"
       });
       const { localeFiles, keyCount } = extractor.extract(uniqueTexts);
       es.succeed("Generated " + import_chalk11.default.green(String(keyCount)) + " locale keys");
       if (!dryRun) {
-        const writer = new import_ai_localize_locale_engine2.LocaleWriter({ localesDir: path9.resolve(cwd, config.localesDir), merge: true });
+        const writer = new import_ai_localize_locale_engine2.LocaleWriter({
+          localesDir: path9.resolve(cwd, config.localesDir),
+          merge: true,
+          localeStructure: structure
+        });
         writer.write(localeFiles);
       }
       if (opts.codemods !== false) {
         const ms = createSpinner("Applying i18n codemods...").start();
-        const runner = new import_ai_localize_codemods2.CodemodRunner(config);
+        const runner = new import_ai_localize_codemods2.CodemodRunner(config, cwd);
         const codemodResult = await runner.run(uniqueTexts, { dryRun });
-        ms.succeed("Codemods: " + import_chalk11.default.green(String(codemodResult.totalReplacements)) + " replacements in " + codemodResult.changedFiles + " files");
+        ms.succeed(
+          "Codemods: " + import_chalk11.default.green(String(codemodResult.totalReplacements)) + " replacements in " + codemodResult.changedFiles + " files"
+        );
       }
       const vs = createSpinner("Validating locale files...").start();
       const validator = new import_ai_localize_validators4.LocaleValidator({
@@ -493,10 +568,23 @@ function fullMigrateCommand() {
         targetLanguages: config.targetLanguages
       });
       const validationResult = validator.validate();
-      vs.succeed(validationResult.valid ? import_chalk11.default.green("Locale files valid!") : import_chalk11.default.yellow(validationResult.errors.length + " errors, " + validationResult.warnings.length + " warnings"));
+      vs.succeed(
+        validationResult.valid ? import_chalk11.default.green("Locale files valid!") : import_chalk11.default.yellow(
+          validationResult.errors.length + " errors, " + validationResult.warnings.length + " warnings"
+        )
+      );
       if (opts.report !== false) {
+        const rs = createSpinner("Generating report...").start();
         const report = (0, import_ai_localize_reporting2.buildReport)({ scanResult, validationResult });
+        const reportDir = path9.resolve(cwd, opts.reportDir);
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const htmlPath = path9.join(reportDir, "report-" + timestamp + ".html");
+        (0, import_ai_localize_reporting2.generateHtmlReport)(report, htmlPath);
+        rs.succeed("Report saved to " + import_chalk11.default.cyan(htmlPath));
         (0, import_ai_localize_reporting2.printCliSummary)(report);
+        logger.info(
+          "\n  View report:\n  " + import_chalk11.default.underline("file://" + htmlPath)
+        );
       }
       logger.success("Full migration complete!");
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-localize-cli",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "CLI for ai-localize-core: scan, extract, validate, migrate CDN",
   "bin": {
     "ai-localize": "./dist/cli.js"
@@ -11,15 +11,15 @@
     "chalk": "^5.3.0",
     "ora": "^8.0.1",
     "inquirer": "^9.2.12",
-    "ai-localize-scanner": "2.0.0",
-    "ai-localize-config": "2.0.0",
-    "ai-localize-framework-detectors": "2.0.0",
-    "ai-localize-shared": "2.0.0",
-    "ai-localize-locale-engine": "2.0.0",
-    "ai-localize-aws-cloudfront": "2.0.0",
-    "ai-localize-validators": "2.0.0",
-    "ai-localize-codemods": "2.0.0",
-    "ai-localize-reporting": "2.0.0"
+    "ai-localize-framework-detectors": "2.0.3",
+    "ai-localize-shared": "2.0.3",
+    "ai-localize-config": "2.0.3",
+    "ai-localize-scanner": "2.0.3",
+    "ai-localize-aws-cloudfront": "2.0.3",
+    "ai-localize-validators": "2.0.3",
+    "ai-localize-locale-engine": "2.0.3",
+    "ai-localize-reporting": "2.0.3",
+    "ai-localize-codemods": "2.0.3"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",

package/src/commands/extract.ts

@@ -21,30 +21,69 @@ export function extractCommand(): Command {
         const { config } = await loadConfig(cwd);
         spinner.succeed('Configuration loaded');
 
+        // Log locale structure in use
+      const structure = config.localeStructure ?? 'nested';
+        logger.info('Locale structure: ' + chalk.cyan(structure));
+
+        // Log static keys if configured
+        const staticKeys = config.staticKeys ?? {};
+      const staticKeyCount = Object.keys(staticKeys).length;
+        if (staticKeyCount > 0) {
+     logger.info(
+          'Static keys: ' +
+         chalk.cyan(String(staticKeyCount)) +
+  ' (' +
+     Object.keys(staticKeys).join(', ') +
+    ')'
+ );
+        }
+
         const ss = createSpinner('Scanning for hardcoded text...').start();
-        const scanner = new ProjectScanner(config);
+ const scanner = new ProjectScanner(config);
         const scanResult = await scanner.scan();
-        ss.succeed('Found ' + chalk.cyan(String(scanResult.detectedTexts.length)) + ' texts in ' + scanResult.scannedFiles + ' files');
+      ss.succeed('Found ' + chalk.cyan(String(scanResult.detectedTexts.length)) + ' texts in ' + scanResult.scannedFiles + ' files');
 
-        const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
-        logger.info('Unique texts: ' + chalk.cyan(String(uniqueTexts.length)));
+      const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
+   logger.info('Unique texts: ' + chalk.cyan(String(uniqueTexts.length)));
 
         const extractor = new LocaleExtractor({
-          defaultLanguage: config.defaultLanguage,
+    defaultLanguage: config.defaultLanguage,
           targetLanguages: config.targetLanguages,
-          namespaceSplitting: true,
+    namespaceSplitting: structure === 'nested', // flat mode does not need namespace splitting
+          staticKeys,
         });
         const { localeFiles, keyCount, namespaces } = extractor.extract(uniqueTexts);
-        logger.info('Keys generated: ' + chalk.green(String(keyCount)));
-        logger.info('Namespaces: ' + chalk.cyan(namespaces.join(', ')));
+        logger.info(
+  'Keys generated: ' +
+            chalk.green(String(keyCount)) +
+   (staticKeyCount > 0
+         ? chalk.dim(' (+ ' + staticKeyCount + ' static)')
+              : '')
+ );
+ if (structure === 'nested') {
+   logger.info('Namespaces: ' + chalk.cyan(namespaces.join(', ')));
+        }
 
         if (!opts.dryRun) {
           const localesDir = path.resolve(cwd, config.localesDir);
-          const writer = new LocaleWriter({ localesDir, merge: opts.merge !== false });
-          const { written, created, merged } = writer.write(localeFiles);
-          logger.success('Wrote ' + written.length + ' locale files (' + created.length + ' new, ' + merged.length + ' merged)');
+          const writer = new LocaleWriter({
+            localesDir,
+       merge: opts.merge !== false,
+    localeStructure: structure,
+          });
+ const { written, created, merged } = writer.write(localeFiles);
+          logger.success(
+     'Wrote ' + written.length + ' locale files (' + created.length + ' new, ' + merged.length + ' merged)'
+          );
+          written.forEach((f) => logger.info('  ' + chalk.gray(f)));
         } else {
-          logger.info('Dry run - no files written');
+          logger.info('Dry run — no files written');
+          localeFiles.forEach((lf) => {
+const label = structure === 'flat'
+           ? `${lf.language}.json`
+           : `${lf.language}/${lf.namespace}.json`;
+            logger.info('  ' + chalk.gray(label) + ' — ' + Object.keys(lf.entries).length + ' keys');
+     });
         }
       } catch (err) {
         spinner.fail('Extraction failed');

package/src/commands/full-migrate.ts

@@ -17,8 +17,9 @@ export function fullMigrateCommand(): Command {
     .option('--dry-run', 'Preview changes without modifying files')
     .option('--no-codemods', 'Skip codemod phase')
     .option('--no-report', 'Skip report generation')
-    .action(async (opts) => {
-      logger.header('ai-localize full-migrate');
+    .option('--report-dir <path>', 'Directory where the HTML report is saved', '.ai-localize-reports')
+ .action(async (opts) => {
+logger.header('ai-localize full-migrate');
       const cwd = opts.cwd as string;
       const dryRun = opts.dryRun as boolean;
       try {
@@ -26,49 +27,84 @@ export function fullMigrateCommand(): Command {
         const { config } = await loadConfig(cwd);
         cs.succeed('Configuration loaded');
 
+        const structure = config.localeStructure ?? 'nested';
+
         const ss = createSpinner('Scanning for hardcoded text...').start();
         const scanner = new ProjectScanner(config);
         const scanResult = await scanner.scan();
-        ss.succeed('Found ' + chalk.cyan(String(scanResult.detectedTexts.length)) + ' texts in ' + scanResult.scannedFiles + ' files');
+        ss.succeed(
+          'Found ' + chalk.cyan(String(scanResult.detectedTexts.length)) +
+ ' texts in ' + scanResult.scannedFiles + ' files'
+        );
 
         const es = createSpinner('Extracting locale keys...').start();
-        const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
+    const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
         const extractor = new LocaleExtractor({
           defaultLanguage: config.defaultLanguage,
           targetLanguages: config.targetLanguages,
-          namespaceSplitting: true,
-        });
+          // Flat layout merges all keys into one file per language — no namespace splitting
+          namespaceSplitting: structure === 'nested',
+      });
         const { localeFiles, keyCount } = extractor.extract(uniqueTexts);
         es.succeed('Generated ' + chalk.green(String(keyCount)) + ' locale keys');
 
-        if (!dryRun) {
-          const writer = new LocaleWriter({ localesDir: path.resolve(cwd, config.localesDir), merge: true });
+   if (!dryRun) {
+      const writer = new LocaleWriter({
+        localesDir: path.resolve(cwd, config.localesDir),
+            merge: true,
+            localeStructure: structure,
+    });
           writer.write(localeFiles);
         }
 
         if (opts.codemods !== false) {
-          const ms = createSpinner('Applying i18n codemods...').start();
-          const runner = new CodemodRunner(config);
-          const codemodResult = await runner.run(uniqueTexts, { dryRun });
-          ms.succeed('Codemods: ' + chalk.green(String(codemodResult.totalReplacements)) + ' replacements in ' + codemodResult.changedFiles + ' files');
-        }
+     const ms = createSpinner('Applying i18n codemods...').start();
+          // Pass cwd so CodemodRunner can compute per-file relative import paths
+          // when codemods.importPackage is a local project path (e.g. "src/Locales/translate").
+       const runner = new CodemodRunner(config, cwd);
+const codemodResult = await runner.run(uniqueTexts, { dryRun });
+          ms.succeed(
+      'Codemods: ' + chalk.green(String(codemodResult.totalReplacements)) +
+            ' replacements in ' + codemodResult.changedFiles + ' files'
+  );
+}
 
-        const vs = createSpinner('Validating locale files...').start();
+     const vs = createSpinner('Validating locale files...').start();
         const validator = new LocaleValidator({
-          localesDir: path.resolve(cwd, config.localesDir),
+     localesDir: path.resolve(cwd, config.localesDir),
           sourceDir: path.resolve(cwd, config.sourceDir),
-          defaultLanguage: config.defaultLanguage,
-          targetLanguages: config.targetLanguages,
+      defaultLanguage: config.defaultLanguage,
+     targetLanguages: config.targetLanguages,
         });
         const validationResult = validator.validate();
-        vs.succeed(validationResult.valid ? chalk.green('Locale files valid!') : chalk.yellow(validationResult.errors.length + ' errors, ' + validationResult.warnings.length + ' warnings'));
+        vs.succeed(
+          validationResult.valid
+  ? chalk.green('Locale files valid!')
+            : chalk.yellow(
+   validationResult.errors.length + ' errors, ' +
+  validationResult.warnings.length + ' warnings'
+      )
+        );
 
-        if (opts.report !== false) {
-          const report = buildReport({ scanResult, validationResult });
-          printCliSummary(report);
-        }
+ if (opts.report !== false) {
+          const rs = createSpinner('Generating report...').start();
+   const report = buildReport({ scanResult, validationResult });
+
+   // Always write an HTML report file
+   const reportDir = path.resolve(cwd, opts.reportDir as string);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+     const htmlPath = path.join(reportDir, 'report-' + timestamp + '.html');
+          generateHtmlReport(report, htmlPath);
+          rs.succeed('Report saved to ' + chalk.cyan(htmlPath));
+
+printCliSummary(report);
+    logger.info(
+            '\n  View report:\n' +
+      '  ' + chalk.underline('file://' + htmlPath)
+);
+     }
 
-        logger.success('Full migration complete!');
+   logger.success('Full migration complete!');
       } catch (err) {
         logger.error('Migration failed: ' + String(err));
         process.exit(1);

package/src/commands/report.ts

@@ -10,10 +10,11 @@ import { buildReport, generateHtmlReport, printCliSummary } from 'ai-localize-re
 
 export function reportCommand(): Command {
   return new Command('report')
-    .description('Generate JSON and HTML localization reports')
-    .option('--cwd <path>', 'Working directory', process.cwd())
-    .option('--output-dir <path>', 'Output directory for reports', '.ai-localize-reports')
-    .option('--no-html', 'Skip HTML report generation')
+    .description('Generate an HTML localization report with full details')
+ .option('--cwd <path>', 'Working directory', process.cwd())
+.option('--output-dir <path>', 'Directory where the HTML report is saved', '.ai-localize-reports')
+    .option('--filename <name>', 'Report filename (default: report-<timestamp>.html)')
+    .option('--no-open', 'Do not log the file path after generation')
     .action(async (opts) => {
       logger.header('ai-localize report');
       const spinner = createSpinner('Loading configuration...').start();
@@ -24,10 +25,10 @@ export function reportCommand(): Command {
 
         const ss = createSpinner('Scanning project...').start();
         const scanner = new ProjectScanner(config);
-        const scanResult = await scanner.scan();
-        ss.succeed('Scanned ' + scanResult.scannedFiles + ' files');
+const scanResult = await scanner.scan();
+  ss.succeed('Scanned ' + chalk.cyan(String(scanResult.scannedFiles)) + ' files');
 
-        const vs = createSpinner('Validating locale files...').start();
+     const vs = createSpinner('Validating locale files...').start();
         const validator = new LocaleValidator({
           localesDir: path.resolve(cwd, config.localesDir),
           sourceDir: path.resolve(cwd, config.sourceDir),
@@ -35,22 +36,35 @@ export function reportCommand(): Command {
           targetLanguages: config.targetLanguages,
         });
         const validationResult = validator.validate();
-        vs.succeed('Validation complete');
+        vs.succeed(
+          validationResult.valid
+          ? chalk.green('Locale files valid')
+  : chalk.yellow(validationResult.errors.length + ' errors, ' + validationResult.warnings.length + ' warnings')
+  );
 
-        const outDir = path.resolve(cwd, opts.outputDir as string);
         const rs = createSpinner('Building report...').start();
-        const report = buildReport({ scanResult, validationResult });
+     const report = buildReport({ scanResult, validationResult });
+
+        // Resolve output path — always a .html file, never a bare directory
+        const outDir = path.resolve(cwd, opts.outputDir as string);
+ const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const filename = (opts.filename as string | undefined) || ('report-' + timestamp + '.html');
+        const htmlPath = path.join(outDir, filename);
 
-        if (opts.html !== false) {
-          generateHtmlReport(report, outDir);
-        }
-        
-        rs.succeed('Report generated at ' + chalk.cyan(outDir));
+        generateHtmlReport(report, htmlPath);
+ rs.succeed('HTML report written to ' + chalk.cyan(htmlPath));
+
+        // Print CLI summary to terminal as well
         printCliSummary(report);
-      } catch (err) {
+
+     logger.info(
+   '\n  Open the report in your browser:\n' +
+    '  ' + chalk.underline('file://' + htmlPath)
+        );
+   } catch (err) {
         spinner.fail('Report generation failed');
-        logger.error(String(err));
-        process.exit(1);
+      logger.error(String(err));
+     process.exit(1);
       }
     });
 }

package/src/commands/scan.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import * as path from 'path';
+import * as fs from 'fs';
 import { logger } from '../utils/logger.js';
 import { createSpinner } from '../utils/spinner.js';
 import { loadConfig } from 'ai-localize-config';
@@ -13,40 +14,101 @@ export function scanCommand(): Command {
     .option('--incremental', 'Scan only changed files based on git diff')
     .option('--staged', 'Scan only git staged files')
     .option('--cwd <path>', 'Working directory', process.cwd())
-    .option('--output <path>', 'Output JSON file path')
+    .option('--output <path>', 'Output JSON file path for full scan results')
+    .option('--extract-cdns <path>', 'Extract all discovered CDN/legacy URLs to a JSON file (e.g. cdn-urls.json)')
     .action(async (opts) => {
       logger.header('ai-localize scan');
-      const spinner = createSpinner('Loading configuration...').start();
+   const spinner = createSpinner('Loading configuration...').start();
       try {
         const cwd = opts.cwd as string;
         const { config } = await loadConfig(cwd);
         spinner.succeed('Configuration loaded');
 
-        let files: string[] | undefined;
+      let files: string[] | undefined;
         if (opts.staged || opts.incremental) {
-          const git = new GitScanner(cwd);
+       const git = new GitScanner(cwd);
           files = opts.staged ? git.getStagedFiles() : git.getChangedFiles();
-          logger.info('Changed files: ' + chalk.cyan(String(files.length)));
-        }
+     logger.info('Changed files: ' + chalk.cyan(String(files.length)));
+     }
 
         const scanSpinner = createSpinner('Scanning files...').start();
         const scanner = new ProjectScanner(config);
         const result = await scanner.scan({ files });
-        scanSpinner.succeed('Scanned ' + chalk.cyan(String(result.scannedFiles)) + ' files in ' + chalk.cyan(result.duration + 'ms'));
+    scanSpinner.succeed('Scanned ' + chalk.cyan(String(result.scannedFiles)) + ' files in ' + chalk.cyan(result.duration + 'ms'));
 
         logger.info('Hardcoded texts:  ' + chalk.yellow(String(result.detectedTexts.length)));
-        logger.info('Asset references: ' + chalk.blue(String(result.assets.length)));
-        logger.info('Legacy CDN URLs:  ' + chalk.red(String(result.legacyCdnUrls.length)));
+  logger.info('Asset references: ' + chalk.blue(String(result.assets.length)));
+   logger.info('Legacy CDN URLs:  ' + chalk.red(String(result.legacyCdnUrls.length)));
 
         if (opts.output) {
-          const outPath = path.resolve(cwd, opts.output as string);
-          writeJson(outPath, result);
-          logger.success('Results saved to ' + chalk.cyan(outPath));
+     const outPath = path.resolve(cwd, opts.output as string);
+ writeJson(outPath, result);
+      logger.success('Results saved to ' + chalk.cyan(outPath));
+        }
+
+        // Extract CDN URLs to a dedicated file
+        if (opts.extractCdns) {
+    const cdnOutPath = path.resolve(cwd, opts.extractCdns as string);
+
+          // Build a structured CDN list similar to locale files
+       const cdnList: {
+            summary: {
+           totalLegacyCdnUrls: number;
+      totalAssetReferences: number;
+     scannedAt: string;
+            };
+legacyCdnUrls: Array<{
+        url: string;
+ assetPath: string;
+  filePath: string;
+          line: number;
+            }>;
+        assetReferences: Array<{
+       assetPath: string;
+      assetType: string;
+    referenceType: string;
+        filePath: string;
+ line: number;
+            }>;
+          } = {
+            summary: {
+   totalLegacyCdnUrls: result.legacyCdnUrls.length,
+     totalAssetReferences: result.assets.length,
+              scannedAt: result.timestamp,
+        },
+          legacyCdnUrls: result.legacyCdnUrls.map((cdn) => ({
+       url: cdn.url,
+       assetPath: cdn.assetPath,
+          filePath: cdn.filePath,
+            line: cdn.line,
+          })),
+            assetReferences: result.assets.map((asset) => ({
+       assetPath: asset.assetPath,
+      assetType: asset.assetType,
+         referenceType: asset.referenceType,
+       filePath: asset.filePath,
+    line: asset.line,
+   })),
+          };
+
+          // Ensure output directory exists
+          const cdnOutDir = path.dirname(cdnOutPath);
+          if (!fs.existsSync(cdnOutDir)) {
+       fs.mkdirSync(cdnOutDir, { recursive: true });
+          }
+          fs.writeFileSync(cdnOutPath, JSON.stringify(cdnList, null, 2), 'utf-8');
+   logger.success('CDN URLs extracted to ' + chalk.cyan(cdnOutPath));
+logger.info(
+ '  Legacy CDN URLs: ' +
+     chalk.red(String(result.legacyCdnUrls.length)) +
+              '  Asset References: ' +
+   chalk.blue(String(result.assets.length))
+          );
         }
       } catch (err: any) {
-        spinner.fail('Scan failed');
-        logger.error(err.message);
-        process.exit(1);
+      spinner.fail('Scan failed');
+    logger.error(err.message);
+     process.exit(1);
       }
     });
 }