ai-localize-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,521 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander11 = require("commander");
+var import_chalk12 = __toESM(require("chalk"));
+var import_shared5 = require("@ai-localize/shared");
+
+// src/commands/init.ts
+var import_commander = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var logger = {
+  info: (msg) => console.log(import_chalk.default.blue("i"), msg),
+  success: (msg) => console.log(import_chalk.default.green("v"), msg),
+  warn: (msg) => console.log(import_chalk.default.yellow("!"), msg),
+  error: (msg) => console.error(import_chalk.default.red("x"), msg),
+  step: (msg) => console.log(import_chalk.default.cyan(">"), msg),
+  dim: (msg) => console.log(import_chalk.default.dim(msg)),
+  header: (msg) => console.log("\n" + import_chalk.default.bold.cyan(msg) + "\n")
+};
+
+// src/utils/spinner.ts
+var import_ora = __toESM(require("ora"));
+function createSpinner(text) {
+  return (0, import_ora.default)({ text, color: "cyan" });
+}
+
+// src/commands/init.ts
+var import_config = require("@ai-localize/config");
+var import_framework_detectors = require("@ai-localize/framework-detectors");
+function initCommand() {
+  return new import_commander.Command("init").description("Initialize ai-localize configuration in the current project").option("-f, --framework <type>", "Override framework detection").option("--cwd <path>", "Working directory", process.cwd()).action(async (opts) => {
+    logger.header("ai-localize init");
+    const spinner = createSpinner("Detecting framework...").start();
+    try {
+      const cwd = opts.cwd;
+      let framework = opts.framework;
+      if (!framework) {
+        framework = (0, import_framework_detectors.detectFramework)(cwd);
+        spinner.succeed("Detected framework: " + import_chalk2.default.cyan(framework));
+      } else {
+        spinner.succeed("Using framework: " + import_chalk2.default.cyan(framework));
+      }
+      const configPath = (0, import_config.writeDefaultConfig)(cwd, framework);
+      logger.success("Config created: " + import_chalk2.default.cyan(configPath));
+    } catch (err) {
+      spinner.fail("Initialization failed");
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/scan.ts
+var import_commander2 = require("commander");
+var import_chalk3 = __toESM(require("chalk"));
+var path = __toESM(require("path"));
+var import_config2 = require("@ai-localize/config");
+var import_scanner = require("@ai-localize/scanner");
+var import_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) => {
+    logger.header("ai-localize scan");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config2.loadConfig)(cwd);
+      spinner.succeed("Configuration loaded");
+      let files;
+      if (opts.staged || opts.incremental) {
+        const git = new import_scanner.GitScanner(cwd);
+        files = opts.staged ? git.getStagedFiles() : git.getChangedFiles();
+        logger.info("Changed files: " + import_chalk3.default.cyan(String(files.length)));
+      }
+      const scanSpinner = createSpinner("Scanning files...").start();
+      const scanner = new import_scanner.ProjectScanner(config);
+      const result = await scanner.scan({ files });
+      scanSpinner.succeed("Scanned " + import_chalk3.default.cyan(String(result.scannedFiles)) + " files in " + import_chalk3.default.cyan(result.duration + "ms"));
+      logger.info("Hardcoded texts:  " + import_chalk3.default.yellow(String(result.detectedTexts.length)));
+      logger.info("Asset references: " + import_chalk3.default.blue(String(result.assets.length)));
+      logger.info("Legacy CDN URLs:  " + import_chalk3.default.red(String(result.legacyCdnUrls.length)));
+      if (opts.output) {
+        const outPath = path.resolve(cwd, opts.output);
+        (0, import_shared.writeJson)(outPath, result);
+        logger.success("Results saved to " + import_chalk3.default.cyan(outPath));
+      }
+    } catch (err) {
+      spinner.fail("Scan failed");
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/extract.ts
+var import_commander3 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var path2 = __toESM(require("path"));
+var import_config3 = require("@ai-localize/config");
+var import_scanner2 = require("@ai-localize/scanner");
+var import_locale_engine = require("@ai-localize/locale-engine");
+function extractCommand() {
+  return new import_commander3.Command("extract").description("Extract hardcoded text to locale JSON files").option("--cwd <path>", "Working directory", process.cwd()).option("--dry-run", "Preview changes without modifying files").option("--no-merge", "Overwrite existing keys").action(async (opts) => {
+    logger.header("ai-localize extract");
+    const cwd = opts.cwd;
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const { config } = await (0, import_config3.loadConfig)(cwd);
+      spinner.succeed("Configuration loaded");
+      const ss = createSpinner("Scanning for hardcoded text...").start();
+      const scanner = new import_scanner2.ProjectScanner(config);
+      const scanResult = await scanner.scan();
+      ss.succeed("Found " + import_chalk4.default.cyan(String(scanResult.detectedTexts.length)) + " texts in " + scanResult.scannedFiles + " files");
+      const uniqueTexts = (0, import_locale_engine.deduplicateTexts)(scanResult.detectedTexts);
+      logger.info("Unique texts: " + import_chalk4.default.cyan(String(uniqueTexts.length)));
+      const extractor = new import_locale_engine.LocaleExtractor({
+        defaultLanguage: config.defaultLanguage,
+        targetLanguages: config.targetLanguages,
+        namespaceSplitting: true
+      });
+      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(", ")));
+      if (!opts.dryRun) {
+        const localesDir = path2.resolve(cwd, config.localesDir);
+        const writer = new import_locale_engine.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)");
+      } else {
+        logger.info("Dry run - no files written");
+      }
+    } catch (err) {
+      spinner.fail("Extraction failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/validate.ts
+var import_commander4 = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
+var path3 = __toESM(require("path"));
+var import_config4 = require("@ai-localize/config");
+var import_validators = require("@ai-localize/validators");
+function validateCommand() {
+  return new import_commander4.Command("validate").description("Validate locale files for missing/duplicate/unused keys").option("--cwd <path>", "Working directory", process.cwd()).option("--no-unused", "Skip unused key check").option("--no-duplicates", "Skip duplicate key check").option("--no-placeholders", "Skip placeholder check").option("--fail-on-warning", "Exit with error if warnings exist").action(async (opts) => {
+    logger.header("ai-localize validate");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config4.loadConfig)(cwd);
+      spinner.succeed("Configuration loaded");
+      const vs = createSpinner("Validating locale files...").start();
+      const validator = new import_validators.LocaleValidator({
+        localesDir: path3.resolve(cwd, config.localesDir),
+        sourceDir: path3.resolve(cwd, config.sourceDir),
+        defaultLanguage: config.defaultLanguage,
+        targetLanguages: config.targetLanguages,
+        checkUnused: opts.unused !== false,
+        checkDuplicates: opts.duplicates !== false,
+        checkPlaceholders: opts.placeholders !== false
+      });
+      const result = validator.validate();
+      if (result.valid) {
+        vs.succeed(import_chalk5.default.green("Locale files are valid!"));
+      } else {
+        vs.fail(import_chalk5.default.red(`Validation failed with ${result.errors.length} errors and ${result.warnings.length} warnings.`));
+      }
+      result.errors.forEach((err) => logger.error(`[${err.type}] ${err.message}`));
+      result.warnings.forEach((warn) => logger.warn(`[${warn.type}] ${warn.message}`));
+      if (!result.valid || opts.failOnWarning && result.warnings.length > 0) {
+        process.exit(1);
+      }
+    } catch (err) {
+      spinner.fail("Validation failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/cleanup.ts
+var import_commander5 = require("commander");
+var import_chalk6 = __toESM(require("chalk"));
+var path4 = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_config5 = require("@ai-localize/config");
+var import_validators2 = require("@ai-localize/validators");
+var import_shared2 = require("@ai-localize/shared");
+function cleanupCommand() {
+  return new import_commander5.Command("cleanup").description("Remove unused locale keys from translation files").option("--cwd <path>", "Working directory", process.cwd()).option("--dry-run", "Preview changes without modifying files").action(async (opts) => {
+    logger.header("ai-localize cleanup");
+    const spinner = createSpinner("Validating keys...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config5.loadConfig)(cwd);
+      const localesDir = path4.resolve(cwd, config.localesDir);
+      const sourceDir = path4.resolve(cwd, config.sourceDir);
+      const validator = new import_validators2.UnusedKeyValidator(localesDir, sourceDir, config.defaultLanguage);
+      const { unusedKeys } = validator.validate();
+      spinner.succeed("Found " + import_chalk6.default.yellow(String(unusedKeys.length)) + " unused keys");
+      if (unusedKeys.length === 0) {
+        logger.success("No unused keys found!");
+        return;
+      }
+      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"));
+        let removed = 0;
+        for (const nsFile of nsFiles) {
+          const ns = nsFile.replace(".json", "");
+          const fp = path4.join(defaultDir, nsFile);
+          const entries = (0, import_shared2.readJsonSafe)(fp) || {};
+          for (const key of unusedKeys) {
+            const lk = key.startsWith(ns + ".") ? key.slice(ns.length + 1) : null;
+            if (lk && lk in entries) {
+              delete entries[lk];
+              removed++;
+            }
+          }
+          (0, import_shared2.writeJson)(fp, entries);
+        }
+        logger.success("Removed " + removed + " unused keys");
+      } else {
+        logger.info("Dry run - " + unusedKeys.length + " keys would be removed");
+      }
+    } catch (err) {
+      spinner.fail("Cleanup failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/migrate-cdn.ts
+var import_commander6 = require("commander");
+var import_chalk7 = __toESM(require("chalk"));
+var path5 = __toESM(require("path"));
+var import_config6 = require("@ai-localize/config");
+var import_scanner3 = require("@ai-localize/scanner");
+var import_aws_cloudfront = require("@ai-localize/aws-cloudfront");
+function migrateCdnCommand() {
+  return new import_commander6.Command("migrate-cdn").description("Migrate legacy CDN URLs to CloudFront").option("--cwd <path>", "Working directory", process.cwd()).option("--assets-dir <path>", "Local assets directory to upload").option("--dry-run", "Preview changes without executing").option("--invalidate", "Invalidate CloudFront cache after upload").action(async (opts) => {
+    logger.header("ai-localize migrate-cdn");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config6.loadConfig)(cwd);
+      if (!config.aws?.bucket) {
+        spinner.fail("AWS configuration missing");
+        logger.error("Set aws.bucket and aws.distributionId in ai-localize.config.json");
+        process.exit(1);
+      }
+      spinner.succeed("Configuration loaded");
+      const ss = createSpinner("Scanning for legacy CDN URLs...").start();
+      const scanner = new import_scanner3.ProjectScanner(config);
+      const scanResult = await scanner.scan();
+      ss.succeed("Found " + import_chalk7.default.yellow(String(scanResult.legacyCdnUrls.length)) + " legacy CDN URLs");
+      if (scanResult.legacyCdnUrls.length === 0) {
+        logger.success("No legacy CDN URLs found!");
+        return;
+      }
+      const migrator = new import_aws_cloudfront.CdnMigrator(config.aws);
+      const result = await migrator.migrate({
+        sourceDir: path5.resolve(cwd, config.sourceDir),
+        assetsDir: path5.resolve(cwd, opts.assetsDir),
+        legacyCdnUrls: scanResult.legacyCdnUrls,
+        dryRun: opts.dryRun,
+        invalidateCache: opts.invalidate,
+        onProgress: (step) => logger.step(step)
+      });
+      logger.success("Migration complete in " + result.duration + "ms");
+      logger.info("  Assets uploaded: " + import_chalk7.default.green(String(result.uploadedAssets.length)));
+      logger.info("  URLs replaced:   " + import_chalk7.default.green(String(result.replacedUrls)));
+      if (result.invalidationId) logger.info("  Invalidation ID: " + import_chalk7.default.cyan(result.invalidationId));
+    } catch (err) {
+      spinner.fail("CDN migration failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/upload-assets.ts
+var import_commander7 = require("commander");
+var import_chalk8 = __toESM(require("chalk"));
+var path6 = __toESM(require("path"));
+var import_config7 = require("@ai-localize/config");
+var import_aws_cloudfront2 = require("@ai-localize/aws-cloudfront");
+var import_shared3 = require("@ai-localize/shared");
+function uploadAssetsCommand() {
+  return new import_commander7.Command("upload-assets").description("Upload local assets to AWS S3").option("--cwd <path>", "Working directory", process.cwd()).option("--assets-dir <path>", "Directory containing assets to upload").option("--force", "Force upload even if file already exists with same hash").option("--output <path>", "Output manifest JSON path").action(async (opts) => {
+    logger.header("ai-localize upload-assets");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config7.loadConfig)(cwd);
+      if (!config.aws?.bucket) {
+        spinner.fail("AWS configuration missing");
+        process.exit(1);
+      }
+      spinner.succeed("Configuration loaded");
+      const uploader = new import_aws_cloudfront2.S3Uploader(config.aws);
+      const assetsDir = path6.resolve(cwd, opts.assetsDir);
+      const uploadSpinner = createSpinner("Uploading assets...").start();
+      const result = await uploader.uploadDirectory({
+        assetsDir,
+        force: opts.force,
+        onProgress: (_a, done, total) => {
+          uploadSpinner.text = "Uploading " + done + "/" + total;
+        }
+      });
+      uploadSpinner.succeed("Uploaded " + import_chalk8.default.green(String(result.uploaded.length)) + " (" + result.skipped.length + " skipped)");
+      if (opts.output) {
+        const outPath = path6.resolve(cwd, opts.output);
+        (0, import_shared3.writeJson)(outPath, [...result.uploaded, ...result.skipped]);
+        logger.success("Manifest saved to " + import_chalk8.default.cyan(outPath));
+      }
+    } catch (err) {
+      spinner.fail("Upload failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/replace-cdn.ts
+var import_commander8 = require("commander");
+var import_chalk9 = __toESM(require("chalk"));
+var path7 = __toESM(require("path"));
+var import_config8 = require("@ai-localize/config");
+var import_scanner4 = require("@ai-localize/scanner");
+var import_shared4 = require("@ai-localize/shared");
+var import_codemods = require("@ai-localize/codemods");
+function replaceCdnCommand() {
+  return new import_commander8.Command("replace-cdn").description("Replace legacy CDN URLs with CloudFront URLs in source files").option("--cwd <path>", "Working directory", process.cwd()).option("--manifest <path>", "Path to upload manifest JSON").option("--dry-run", "Preview changes without executing").action(async (opts) => {
+    logger.header("ai-localize replace-cdn");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config8.loadConfig)(cwd);
+      spinner.succeed("Configuration loaded");
+      let assets = [];
+      if (opts.manifest) {
+        assets = (0, import_shared4.readJsonSafe)(path7.resolve(cwd, opts.manifest)) || [];
+      }
+      const ss = createSpinner("Scanning for legacy CDN URLs...").start();
+      const scanner = new import_scanner4.ProjectScanner(config);
+      const scanResult = await scanner.scan();
+      ss.succeed("Found " + import_chalk9.default.yellow(String(scanResult.legacyCdnUrls.length)) + " legacy CDN URLs");
+      if (scanResult.legacyCdnUrls.length === 0) {
+        logger.success("No legacy CDN URLs found!");
+        return;
+      }
+      if (!opts.dryRun) {
+        const rs = createSpinner("Replacing URLs...").start();
+        const replacedCount = await (0, import_codemods.batchReplaceCdnUrls)(
+          path7.resolve(cwd, config.sourceDir),
+          scanResult.legacyCdnUrls,
+          assets
+        );
+        rs.succeed("Replaced " + import_chalk9.default.green(String(replacedCount)) + " URLs");
+      } else {
+        logger.info("Dry run - no URLs replaced");
+      }
+    } catch (err) {
+      spinner.fail("CDN replacement failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/report.ts
+var import_commander9 = require("commander");
+var import_chalk10 = __toESM(require("chalk"));
+var path8 = __toESM(require("path"));
+var import_config9 = require("@ai-localize/config");
+var import_scanner5 = require("@ai-localize/scanner");
+var import_validators3 = require("@ai-localize/validators");
+var import_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) => {
+    logger.header("ai-localize report");
+    const spinner = createSpinner("Loading configuration...").start();
+    try {
+      const cwd = opts.cwd;
+      const { config } = await (0, import_config9.loadConfig)(cwd);
+      spinner.succeed("Configuration loaded");
+      const ss = createSpinner("Scanning project...").start();
+      const scanner = new import_scanner5.ProjectScanner(config);
+      const scanResult = await scanner.scan();
+      ss.succeed("Scanned " + scanResult.scannedFiles + " files");
+      const vs = createSpinner("Validating locale files...").start();
+      const validator = new import_validators3.LocaleValidator({
+        localesDir: path8.resolve(cwd, config.localesDir),
+        sourceDir: path8.resolve(cwd, config.sourceDir),
+        defaultLanguage: config.defaultLanguage,
+        targetLanguages: config.targetLanguages
+      });
+      const validationResult = validator.validate();
+      vs.succeed("Validation complete");
+      const outDir = path8.resolve(cwd, opts.outputDir);
+      const rs = createSpinner("Building report...").start();
+      const report = (0, import_reporting.buildReport)({ scanResult, validationResult });
+      if (opts.html !== false) {
+        (0, import_reporting.generateHtmlReport)(report, outDir);
+      }
+      rs.succeed("Report generated at " + import_chalk10.default.cyan(outDir));
+      (0, import_reporting.printCliSummary)(report);
+    } catch (err) {
+      spinner.fail("Report generation failed");
+      logger.error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/full-migrate.ts
+var import_commander10 = require("commander");
+var import_chalk11 = __toESM(require("chalk"));
+var path9 = __toESM(require("path"));
+var import_config10 = require("@ai-localize/config");
+var import_scanner6 = require("@ai-localize/scanner");
+var import_locale_engine2 = require("@ai-localize/locale-engine");
+var import_codemods2 = require("@ai-localize/codemods");
+var import_validators4 = require("@ai-localize/validators");
+var import_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) => {
+    logger.header("ai-localize full-migrate");
+    const cwd = opts.cwd;
+    const dryRun = opts.dryRun;
+    try {
+      const cs = createSpinner("Loading configuration...").start();
+      const { config } = await (0, import_config10.loadConfig)(cwd);
+      cs.succeed("Configuration loaded");
+      const ss = createSpinner("Scanning for hardcoded text...").start();
+      const scanner = new import_scanner6.ProjectScanner(config);
+      const scanResult = await scanner.scan();
+      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_locale_engine2.deduplicateTexts)(scanResult.detectedTexts);
+      const extractor = new import_locale_engine2.LocaleExtractor({
+        defaultLanguage: config.defaultLanguage,
+        targetLanguages: config.targetLanguages,
+        namespaceSplitting: true
+      });
+      const { localeFiles, keyCount } = extractor.extract(uniqueTexts);
+      es.succeed("Generated " + import_chalk11.default.green(String(keyCount)) + " locale keys");
+      if (!dryRun) {
+        const writer = new import_locale_engine2.LocaleWriter({ localesDir: path9.resolve(cwd, config.localesDir), merge: true });
+        writer.write(localeFiles);
+      }
+      if (opts.codemods !== false) {
+        const ms = createSpinner("Applying i18n codemods...").start();
+        const runner = new import_codemods2.CodemodRunner(config);
+        const codemodResult = await runner.run(uniqueTexts, { dryRun });
+        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_validators4.LocaleValidator({
+        localesDir: path9.resolve(cwd, config.localesDir),
+        sourceDir: path9.resolve(cwd, config.sourceDir),
+        defaultLanguage: config.defaultLanguage,
+        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"));
+      if (opts.report !== false) {
+        const report = (0, import_reporting2.buildReport)({ scanResult, validationResult });
+        (0, import_reporting2.printCliSummary)(report);
+      }
+      logger.success("Full migration complete!");
+    } catch (err) {
+      logger.error("Migration failed: " + String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli.ts
+var program = new import_commander11.Command();
+program.name("ai-localize").description(import_chalk12.default.cyan("ai-localize-core") + " \u2014 Deterministic localization + CloudFront migration platform").version(import_shared5.PLATFORM_VERSION, "-v, --version");
+program.addCommand(initCommand());
+program.addCommand(scanCommand());
+program.addCommand(extractCommand());
+program.addCommand(validateCommand());
+program.addCommand(cleanupCommand());
+program.addCommand(migrateCdnCommand());
+program.addCommand(uploadAssetsCommand());
+program.addCommand(replaceCdnCommand());
+program.addCommand(reportCommand());
+program.addCommand(fullMigrateCommand());
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "ai-localize-cli",
+  "version": "1.0.0",
+  "description": "CLI for ai-localize-core: scan, extract, validate, migrate CDN",
+  "bin": {
+    "ai-localize": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "inquirer": "^9.2.12",
+    "ai-localize-codemods": "1.0.0",
+    "ai-localize-shared": "1.0.0",
+    "ai-localize-config": "1.0.0",
+    "ai-localize-framework-detectors": "1.0.0",
+    "ai-localize-scanner": "1.0.0",
+    "ai-localize-aws-cloudfront": "1.0.0",
+    "ai-localize-reporting": "1.0.0",
+    "ai-localize-validators": "1.0.0",
+    "ai-localize-locale-engine": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format cjs --env.NODE_ENV production",
+    "dev": "tsup src/cli.ts --format cjs --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src --ext .ts"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { PLATFORM_VERSION } from '@ai-localize/shared';
+import { initCommand } from './commands/init.js';
+import { scanCommand } from './commands/scan.js';
+import { extractCommand } from './commands/extract.js';
+import { validateCommand } from './commands/validate.js';
+import { cleanupCommand } from './commands/cleanup.js';
+import { migrateCdnCommand } from './commands/migrate-cdn.js';
+import { uploadAssetsCommand } from './commands/upload-assets.js';
+import { replaceCdnCommand } from './commands/replace-cdn.js';
+import { reportCommand } from './commands/report.js';
+import { fullMigrateCommand } from './commands/full-migrate.js';
+
+const program = new Command();
+
+program
+  .name('ai-localize')
+  .description(chalk.cyan('ai-localize-core') + ' — Deterministic localization + CloudFront migration platform')
+  .version(PLATFORM_VERSION, '-v, --version');
+
+program.addCommand(initCommand());
+program.addCommand(scanCommand());
+program.addCommand(extractCommand());
+program.addCommand(validateCommand());
+program.addCommand(cleanupCommand());
+program.addCommand(migrateCdnCommand());
+program.addCommand(uploadAssetsCommand());
+program.addCommand(replaceCdnCommand());
+program.addCommand(reportCommand());
+program.addCommand(fullMigrateCommand());
+
+program.parse(process.argv);

package/src/commands/cleanup.ts

@@ -0,0 +1,56 @@
+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';
+import { UnusedKeyValidator } from '@ai-localize/validators';
+import { readJsonSafe, writeJson } from '@ai-localize/shared';
+
+export function cleanupCommand(): Command {
+  return new Command('cleanup')
+    .description('Remove unused locale keys from translation files')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--dry-run', 'Preview changes without modifying files')
+    .action(async (opts) => {
+      logger.header('ai-localize cleanup');
+      const spinner = createSpinner('Validating keys...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        const localesDir = path.resolve(cwd, config.localesDir);
+        const sourceDir = path.resolve(cwd, config.sourceDir);
+
+        const validator = new UnusedKeyValidator(localesDir, sourceDir, config.defaultLanguage);
+        const { unusedKeys } = validator.validate();
+        spinner.succeed('Found ' + chalk.yellow(String(unusedKeys.length)) + ' unused keys');
+
+        if (unusedKeys.length === 0) { logger.success('No unused keys found!'); return; }
+        unusedKeys.slice(0, 20).forEach((k) => logger.dim('- ' + k));
+
+        if (!opts.dryRun) {
+          const defaultDir = path.join(localesDir, config.defaultLanguage);
+          const nsFiles = fs.readdirSync(defaultDir).filter((f) => f.endsWith('.json'));
+          let removed = 0;
+          for (const nsFile of nsFiles) {
+            const ns = nsFile.replace('.json', '');
+            const fp = path.join(defaultDir, nsFile);
+            const entries = readJsonSafe<Record<string, string>>(fp) || {};
+            for (const key of unusedKeys) {
+              const lk = key.startsWith(ns + '.') ? key.slice(ns.length + 1) : null;
+              if (lk && lk in entries) { delete entries[lk]; removed++; }
+            }
+            writeJson(fp, entries);
+          }
+          logger.success('Removed ' + removed + ' unused keys');
+        } else {
+          logger.info('Dry run - ' + unusedKeys.length + ' keys would be removed');
+        }
+      } catch (err) {
+        spinner.fail('Cleanup failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/extract.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner } from '@ai-localize/scanner';
+import { deduplicateTexts, LocaleExtractor, LocaleWriter } from '@ai-localize/locale-engine';
+
+export function extractCommand(): Command {
+  return new Command('extract')
+    .description('Extract hardcoded text to locale JSON files')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--dry-run', 'Preview changes without modifying files')
+    .option('--no-merge', 'Overwrite existing keys')
+    .action(async (opts) => {
+      logger.header('ai-localize extract');
+      const cwd = opts.cwd as string;
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const { config } = await loadConfig(cwd);
+        spinner.succeed('Configuration loaded');
+
+        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');
+
+        const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
+        logger.info('Unique texts: ' + chalk.cyan(String(uniqueTexts.length)));
+
+        const extractor = new LocaleExtractor({
+          defaultLanguage: config.defaultLanguage,
+          targetLanguages: config.targetLanguages,
+          namespaceSplitting: true,
+        });
+        const { localeFiles, keyCount, namespaces } = extractor.extract(uniqueTexts);
+        logger.info('Keys generated: ' + chalk.green(String(keyCount)));
+        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)');
+        } else {
+          logger.info('Dry run - no files written');
+        }
+      } catch (err) {
+        spinner.fail('Extraction failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/full-migrate.ts

@@ -0,0 +1,77 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner } from '@ai-localize/scanner';
+import { deduplicateTexts, LocaleExtractor, LocaleWriter } from '@ai-localize/locale-engine';
+import { CodemodRunner } from '@ai-localize/codemods';
+import { LocaleValidator } from '@ai-localize/validators';
+import { buildReport, generateHtmlReport, printCliSummary } from '@ai-localize/reporting';
+
+export function fullMigrateCommand(): Command {
+  return new 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) => {
+      logger.header('ai-localize full-migrate');
+      const cwd = opts.cwd as string;
+      const dryRun = opts.dryRun as boolean;
+      try {
+        const cs = createSpinner('Loading configuration...').start();
+        const { config } = await loadConfig(cwd);
+        cs.succeed('Configuration loaded');
+
+        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');
+
+        const es = createSpinner('Extracting locale keys...').start();
+        const uniqueTexts = deduplicateTexts(scanResult.detectedTexts);
+        const extractor = new LocaleExtractor({
+          defaultLanguage: config.defaultLanguage,
+          targetLanguages: config.targetLanguages,
+          namespaceSplitting: true,
+        });
+        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 });
+          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 vs = createSpinner('Validating locale files...').start();
+        const validator = new LocaleValidator({
+          localesDir: path.resolve(cwd, config.localesDir),
+          sourceDir: path.resolve(cwd, config.sourceDir),
+          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'));
+
+        if (opts.report !== false) {
+          const report = buildReport({ scanResult, validationResult });
+          printCliSummary(report);
+        }
+
+        logger.success('Full migration complete!');
+      } catch (err) {
+        logger.error('Migration failed: ' + String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/init.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { writeDefaultConfig } from '@ai-localize/config';
+import { detectFramework } from '@ai-localize/framework-detectors';
+
+export function initCommand(): Command {
+  return new Command('init')
+    .description('Initialize ai-localize configuration in the current project')
+    .option('-f, --framework <type>', 'Override framework detection')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .action(async (opts) => {
+      logger.header('ai-localize init');
+      const spinner = createSpinner('Detecting framework...').start();
+      try {
+        const cwd = opts.cwd as string;
+        let framework = opts.framework as string;
+        if (!framework) {
+          framework = detectFramework(cwd);
+          spinner.succeed('Detected framework: ' + chalk.cyan(framework));
+        } else {
+          spinner.succeed('Using framework: ' + chalk.cyan(framework));
+        }
+        const configPath = writeDefaultConfig(cwd, framework);
+        logger.success('Config created: ' + chalk.cyan(configPath));
+      } catch (err: any) {
+        spinner.fail('Initialization failed');
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/migrate-cdn.ts

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner } from '@ai-localize/scanner';
+import { CdnMigrator } from '@ai-localize/aws-cloudfront';
+
+export function migrateCdnCommand(): Command {
+  return new Command('migrate-cdn')
+    .description('Migrate legacy CDN URLs to CloudFront')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--assets-dir <path>', 'Local assets directory to upload')
+    .option('--dry-run', 'Preview changes without executing')
+    .option('--invalidate', 'Invalidate CloudFront cache after upload')
+    .action(async (opts) => {
+      logger.header('ai-localize migrate-cdn');
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        if (!config.aws?.bucket) {
+          spinner.fail('AWS configuration missing');
+          logger.error('Set aws.bucket and aws.distributionId in ai-localize.config.json');
+          process.exit(1);
+        }
+        spinner.succeed('Configuration loaded');
+
+        const ss = createSpinner('Scanning for legacy CDN URLs...').start();
+        const scanner = new ProjectScanner(config);
+        const scanResult = await scanner.scan();
+        ss.succeed('Found ' + chalk.yellow(String(scanResult.legacyCdnUrls.length)) + ' legacy CDN URLs');
+
+        if (scanResult.legacyCdnUrls.length === 0) { logger.success('No legacy CDN URLs found!'); return; }
+
+        const migrator = new CdnMigrator(config.aws!);
+        const result = await migrator.migrate({
+          sourceDir: path.resolve(cwd, config.sourceDir),
+          assetsDir: path.resolve(cwd, opts.assetsDir as string),
+          legacyCdnUrls: scanResult.legacyCdnUrls,
+          dryRun: opts.dryRun as boolean,
+          invalidateCache: opts.invalidate as boolean,
+          onProgress: (step) => logger.step(step),
+        });
+
+        logger.success('Migration complete in ' + result.duration + 'ms');
+        logger.info('  Assets uploaded: ' + chalk.green(String(result.uploadedAssets.length)));
+        logger.info('  URLs replaced:   ' + chalk.green(String(result.replacedUrls)));
+        if (result.invalidationId) logger.info('  Invalidation ID: ' + chalk.cyan(result.invalidationId));
+      } catch (err) {
+        spinner.fail('CDN migration failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/replace-cdn.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner } from '@ai-localize/scanner';
+import { readJsonSafe } from '@ai-localize/shared';
+import type { CloudFrontAsset } from '@ai-localize/shared';
+import { batchReplaceCdnUrls } from '@ai-localize/codemods';
+
+export function replaceCdnCommand(): Command {
+  return new Command('replace-cdn')
+    .description('Replace legacy CDN URLs with CloudFront URLs in source files')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--manifest <path>', 'Path to upload manifest JSON')
+    .option('--dry-run', 'Preview changes without executing')
+    .action(async (opts) => {
+      logger.header('ai-localize replace-cdn');
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        spinner.succeed('Configuration loaded');
+
+        let assets: CloudFrontAsset[] = [];
+        if (opts.manifest) {
+          assets = readJsonSafe<CloudFrontAsset[]>(path.resolve(cwd, opts.manifest as string)) || [];
+        }
+
+        const ss = createSpinner('Scanning for legacy CDN URLs...').start();
+        const scanner = new ProjectScanner(config);
+        const scanResult = await scanner.scan();
+        ss.succeed('Found ' + chalk.yellow(String(scanResult.legacyCdnUrls.length)) + ' legacy CDN URLs');
+
+        if (scanResult.legacyCdnUrls.length === 0) { logger.success('No legacy CDN URLs found!'); return; }
+
+        if (!opts.dryRun) {
+          const rs = createSpinner('Replacing URLs...').start();
+          const replacedCount = await batchReplaceCdnUrls(
+            path.resolve(cwd, config.sourceDir),
+            scanResult.legacyCdnUrls,
+            assets
+          );
+          rs.succeed('Replaced ' + chalk.green(String(replacedCount)) + ' URLs');
+        } else {
+          logger.info('Dry run - no URLs replaced');
+        }
+      } catch (err) {
+        spinner.fail('CDN replacement failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/report.ts

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner } from '@ai-localize/scanner';
+import { LocaleValidator } from '@ai-localize/validators';
+import { buildReport, generateHtmlReport, printCliSummary } from '@ai-localize/reporting';
+
+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')
+    .action(async (opts) => {
+      logger.header('ai-localize report');
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        spinner.succeed('Configuration loaded');
+
+        const ss = createSpinner('Scanning project...').start();
+        const scanner = new ProjectScanner(config);
+        const scanResult = await scanner.scan();
+        ss.succeed('Scanned ' + scanResult.scannedFiles + ' files');
+
+        const vs = createSpinner('Validating locale files...').start();
+        const validator = new LocaleValidator({
+          localesDir: path.resolve(cwd, config.localesDir),
+          sourceDir: path.resolve(cwd, config.sourceDir),
+          defaultLanguage: config.defaultLanguage,
+          targetLanguages: config.targetLanguages,
+        });
+        const validationResult = validator.validate();
+        vs.succeed('Validation complete');
+
+        const outDir = path.resolve(cwd, opts.outputDir as string);
+        const rs = createSpinner('Building report...').start();
+        const report = buildReport({ scanResult, validationResult });
+
+        if (opts.html !== false) {
+          generateHtmlReport(report, outDir);
+        }
+        
+        rs.succeed('Report generated at ' + chalk.cyan(outDir));
+        printCliSummary(report);
+      } catch (err) {
+        spinner.fail('Report generation failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/scan.ts

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { ProjectScanner, GitScanner } from '@ai-localize/scanner';
+import { writeJson } from '@ai-localize/shared';
+
+export function scanCommand(): Command {
+  return new 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) => {
+      logger.header('ai-localize scan');
+      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;
+        if (opts.staged || opts.incremental) {
+          const git = new GitScanner(cwd);
+          files = opts.staged ? git.getStagedFiles() : git.getChangedFiles();
+          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'));
+
+        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)));
+
+        if (opts.output) {
+          const outPath = path.resolve(cwd, opts.output as string);
+          writeJson(outPath, result);
+          logger.success('Results saved to ' + chalk.cyan(outPath));
+        }
+      } catch (err: any) {
+        spinner.fail('Scan failed');
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/upload-assets.ts

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { S3Uploader } from '@ai-localize/aws-cloudfront';
+import { writeJson } from '@ai-localize/shared';
+
+export function uploadAssetsCommand(): Command {
+  return new Command('upload-assets')
+    .description('Upload local assets to AWS S3')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--assets-dir <path>', 'Directory containing assets to upload')
+    .option('--force', 'Force upload even if file already exists with same hash')
+    .option('--output <path>', 'Output manifest JSON path')
+    .action(async (opts) => {
+      logger.header('ai-localize upload-assets');
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        if (!config.aws?.bucket) {
+          spinner.fail('AWS configuration missing');
+          process.exit(1);
+        }
+        spinner.succeed('Configuration loaded');
+
+        const uploader = new S3Uploader(config.aws!);
+        const assetsDir = path.resolve(cwd, opts.assetsDir as string);
+        const uploadSpinner = createSpinner('Uploading assets...').start();
+        const result = await uploader.uploadDirectory({
+          assetsDir,
+          force: opts.force as boolean,
+          onProgress: (_a, done, total) => { uploadSpinner.text = 'Uploading ' + done + '/' + total; },
+        });
+        uploadSpinner.succeed('Uploaded ' + chalk.green(String(result.uploaded.length)) + ' (' + result.skipped.length + ' skipped)');
+
+        if (opts.output) {
+          const outPath = path.resolve(cwd, opts.output as string);
+          writeJson(outPath, [...result.uploaded, ...result.skipped]);
+          logger.success('Manifest saved to ' + chalk.cyan(outPath));
+        }
+      } catch (err) {
+        spinner.fail('Upload failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/validate.ts

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { createSpinner } from '../utils/spinner.js';
+import { loadConfig } from '@ai-localize/config';
+import { LocaleValidator } from '@ai-localize/validators';
+
+export function validateCommand(): Command {
+  return new Command('validate')
+    .description('Validate locale files for missing/duplicate/unused keys')
+    .option('--cwd <path>', 'Working directory', process.cwd())
+    .option('--no-unused', 'Skip unused key check')
+    .option('--no-duplicates', 'Skip duplicate key check')
+    .option('--no-placeholders', 'Skip placeholder check')
+    .option('--fail-on-warning', 'Exit with error if warnings exist')
+    .action(async (opts) => {
+      logger.header('ai-localize validate');
+      const spinner = createSpinner('Loading configuration...').start();
+      try {
+        const cwd = opts.cwd as string;
+        const { config } = await loadConfig(cwd);
+        spinner.succeed('Configuration loaded');
+
+        const vs = createSpinner('Validating locale files...').start();
+        const validator = new LocaleValidator({
+          localesDir: path.resolve(cwd, config.localesDir),
+          sourceDir: path.resolve(cwd, config.sourceDir),
+          defaultLanguage: config.defaultLanguage,
+          targetLanguages: config.targetLanguages,
+          checkUnused: opts.unused !== false,
+          checkDuplicates: opts.duplicates !== false,
+          checkPlaceholders: opts.placeholders !== false,
+        });
+
+        const result = validator.validate();
+
+        if (result.valid) {
+          vs.succeed(chalk.green('Locale files are valid!'));
+        } else {
+          vs.fail(chalk.red(`Validation failed with ${result.errors.length} errors and ${result.warnings.length} warnings.`));
+        }
+
+        result.errors.forEach((err) => logger.error(`[${err.type}] ${err.message}`));
+        result.warnings.forEach((warn) => logger.warn(`[${warn.type}] ${warn.message}`));
+
+        if (!result.valid || (opts.failOnWarning && result.warnings.length > 0)) {
+          process.exit(1);
+        }
+      } catch (err) {
+        spinner.fail('Validation failed');
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/utils/logger.ts

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg: string) => console.log(chalk.blue('i'), msg),
+  success: (msg: string) => console.log(chalk.green('v'), msg),
+  warn: (msg: string) => console.log(chalk.yellow('!'), msg),
+  error: (msg: string) => console.error(chalk.red('x'), msg),
+  step: (msg: string) => console.log(chalk.cyan('>'), msg),
+  dim: (msg: string) => console.log(chalk.dim(msg)),
+  header: (msg: string) => console.log('\n' + chalk.bold.cyan(msg) + '\n'),
+};

package/src/utils/spinner.ts

@@ -0,0 +1,5 @@
+import ora, { type Ora } from 'ora';
+
+export function createSpinner(text: string): Ora {
+  return ora({ text, color: 'cyan' });
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
+"include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}