ai-localize-cli 1.0.0 → 1.0.1

package/dist/cli.js

@@ -25,7 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var import_commander11 = require("commander");
 var import_chalk12 = __toESM(require("chalk"));
-var import_shared5 = require("@ai-localize/shared");
+var import_ai_localize_shared5 = require("ai-localize-shared");
 
 // src/commands/init.ts
 var import_commander = require("commander");
@@ -50,8 +50,8 @@ function createSpinner(text) {
 }
 
 // src/commands/init.ts
-var import_config = require("@ai-localize/config");
-var import_framework_detectors = require("@ai-localize/framework-detectors");
+var import_ai_localize_config = require("ai-localize-config");
+var import_ai_localize_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");
@@ -60,12 +60,12 @@ function initCommand() {
       const cwd = opts.cwd;
       let framework = opts.framework;
       if (!framework) {
-        framework = (0, import_framework_detectors.detectFramework)(cwd);
+        framework = (0, import_ai_localize_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);
+      const configPath = (0, import_ai_localize_config.writeDefaultConfig)(cwd, framework);
       logger.success("Config created: " + import_chalk2.default.cyan(configPath));
     } catch (err) {
       spinner.fail("Initialization failed");
@@ -79,25 +79,25 @@ function initCommand() {
 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");
+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) => {
     logger.header("ai-localize scan");
     const spinner = createSpinner("Loading configuration...").start();
     try {
       const cwd = opts.cwd;
-      const { config } = await (0, import_config2.loadConfig)(cwd);
+      const { config } = await (0, import_ai_localize_config2.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
       let files;
       if (opts.staged || opts.incremental) {
-        const git = new import_scanner.GitScanner(cwd);
+        const git = new import_ai_localize_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 scanner = new import_ai_localize_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)));
@@ -105,7 +105,7 @@ function scanCommand() {
       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);
+        (0, import_ai_localize_shared.writeJson)(outPath, result);
         logger.success("Results saved to " + import_chalk3.default.cyan(outPath));
       }
     } catch (err) {
@@ -120,24 +120,24 @@ function scanCommand() {
 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");
+var import_ai_localize_config3 = require("ai-localize-config");
+var import_ai_localize_scanner2 = require("ai-localize-scanner");
+var import_ai_localize_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);
+      const { config } = await (0, import_ai_localize_config3.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
       const ss = createSpinner("Scanning for hardcoded text...").start();
-      const scanner = new import_scanner2.ProjectScanner(config);
+      const scanner = new import_ai_localize_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);
+      const uniqueTexts = (0, import_ai_localize_locale_engine.deduplicateTexts)(scanResult.detectedTexts);
       logger.info("Unique texts: " + import_chalk4.default.cyan(String(uniqueTexts.length)));
-      const extractor = new import_locale_engine.LocaleExtractor({
+      const extractor = new import_ai_localize_locale_engine.LocaleExtractor({
         defaultLanguage: config.defaultLanguage,
         targetLanguages: config.targetLanguages,
         namespaceSplitting: true
@@ -147,7 +147,7 @@ function extractCommand() {
       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 writer = new import_ai_localize_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 {
@@ -165,18 +165,18 @@ function extractCommand() {
 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");
+var import_ai_localize_config4 = require("ai-localize-config");
+var import_ai_localize_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);
+      const { config } = await (0, import_ai_localize_config4.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
       const vs = createSpinner("Validating locale files...").start();
-      const validator = new import_validators.LocaleValidator({
+      const validator = new import_ai_localize_validators.LocaleValidator({
         localesDir: path3.resolve(cwd, config.localesDir),
         sourceDir: path3.resolve(cwd, config.sourceDir),
         defaultLanguage: config.defaultLanguage,
@@ -209,19 +209,19 @@ 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");
+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");
 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 { config } = await (0, import_ai_localize_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 validator = new import_ai_localize_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) {
@@ -236,7 +236,7 @@ function cleanupCommand() {
         for (const nsFile of nsFiles) {
           const ns = nsFile.replace(".json", "");
           const fp = path4.join(defaultDir, nsFile);
-          const entries = (0, import_shared2.readJsonSafe)(fp) || {};
+          const entries = (0, import_ai_localize_shared2.readJsonSafe)(fp) || {};
           for (const key of unusedKeys) {
             const lk = key.startsWith(ns + ".") ? key.slice(ns.length + 1) : null;
             if (lk && lk in entries) {
@@ -244,7 +244,7 @@ function cleanupCommand() {
               removed++;
             }
           }
-          (0, import_shared2.writeJson)(fp, entries);
+          (0, import_ai_localize_shared2.writeJson)(fp, entries);
         }
         logger.success("Removed " + removed + " unused keys");
       } else {
@@ -262,16 +262,16 @@ function cleanupCommand() {
 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");
+var import_ai_localize_config6 = require("ai-localize-config");
+var import_ai_localize_scanner3 = require("ai-localize-scanner");
+var import_ai_localize_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);
+      const { config } = await (0, import_ai_localize_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");
@@ -279,14 +279,14 @@ function migrateCdnCommand() {
       }
       spinner.succeed("Configuration loaded");
       const ss = createSpinner("Scanning for legacy CDN URLs...").start();
-      const scanner = new import_scanner3.ProjectScanner(config);
+      const scanner = new import_ai_localize_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 migrator = new import_ai_localize_aws_cloudfront.CdnMigrator(config.aws);
       const result = await migrator.migrate({
         sourceDir: path5.resolve(cwd, config.sourceDir),
         assetsDir: path5.resolve(cwd, opts.assetsDir),
@@ -311,22 +311,22 @@ function migrateCdnCommand() {
 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");
+var import_ai_localize_config7 = require("ai-localize-config");
+var import_ai_localize_aws_cloudfront2 = require("ai-localize-aws-cloudfront");
+var import_ai_localize_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);
+      const { config } = await (0, import_ai_localize_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 uploader = new import_ai_localize_aws_cloudfront2.S3Uploader(config.aws);
       const assetsDir = path6.resolve(cwd, opts.assetsDir);
       const uploadSpinner = createSpinner("Uploading assets...").start();
       const result = await uploader.uploadDirectory({
@@ -339,7 +339,7 @@ function uploadAssetsCommand() {
       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]);
+        (0, import_ai_localize_shared3.writeJson)(outPath, [...result.uploaded, ...result.skipped]);
         logger.success("Manifest saved to " + import_chalk8.default.cyan(outPath));
       }
     } catch (err) {
@@ -354,24 +354,24 @@ function uploadAssetsCommand() {
 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");
+var import_ai_localize_config8 = require("ai-localize-config");
+var import_ai_localize_scanner4 = require("ai-localize-scanner");
+var import_ai_localize_shared4 = require("ai-localize-shared");
+var import_ai_localize_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);
+      const { config } = await (0, import_ai_localize_config8.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
       let assets = [];
       if (opts.manifest) {
-        assets = (0, import_shared4.readJsonSafe)(path7.resolve(cwd, opts.manifest)) || [];
+        assets = (0, import_ai_localize_shared4.readJsonSafe)(path7.resolve(cwd, opts.manifest)) || [];
       }
       const ss = createSpinner("Scanning for legacy CDN URLs...").start();
-      const scanner = new import_scanner4.ProjectScanner(config);
+      const scanner = new import_ai_localize_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) {
@@ -380,7 +380,7 @@ function replaceCdnCommand() {
       }
       if (!opts.dryRun) {
         const rs = createSpinner("Replacing URLs...").start();
-        const replacedCount = await (0, import_codemods.batchReplaceCdnUrls)(
+        const replacedCount = await (0, import_ai_localize_codemods.batchReplaceCdnUrls)(
           path7.resolve(cwd, config.sourceDir),
           scanResult.legacyCdnUrls,
           assets
@@ -401,24 +401,24 @@ function replaceCdnCommand() {
 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");
+var import_ai_localize_config9 = require("ai-localize-config");
+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) => {
     logger.header("ai-localize report");
     const spinner = createSpinner("Loading configuration...").start();
     try {
       const cwd = opts.cwd;
-      const { config } = await (0, import_config9.loadConfig)(cwd);
+      const { config } = await (0, import_ai_localize_config9.loadConfig)(cwd);
       spinner.succeed("Configuration loaded");
       const ss = createSpinner("Scanning project...").start();
-      const scanner = new import_scanner5.ProjectScanner(config);
+      const scanner = new import_ai_localize_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({
+      const validator = new import_ai_localize_validators3.LocaleValidator({
         localesDir: path8.resolve(cwd, config.localesDir),
         sourceDir: path8.resolve(cwd, config.sourceDir),
         defaultLanguage: config.defaultLanguage,
@@ -428,12 +428,12 @@ function reportCommand() {
       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 });
+      const report = (0, import_ai_localize_reporting.buildReport)({ scanResult, validationResult });
       if (opts.html !== false) {
-        (0, import_reporting.generateHtmlReport)(report, outDir);
+        (0, import_ai_localize_reporting.generateHtmlReport)(report, outDir);
       }
       rs.succeed("Report generated at " + import_chalk10.default.cyan(outDir));
-      (0, import_reporting.printCliSummary)(report);
+      (0, import_ai_localize_reporting.printCliSummary)(report);
     } catch (err) {
       spinner.fail("Report generation failed");
       logger.error(String(err));
@@ -446,12 +446,12 @@ function reportCommand() {
 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");
+var import_ai_localize_config10 = require("ai-localize-config");
+var import_ai_localize_scanner6 = require("ai-localize-scanner");
+var import_ai_localize_locale_engine2 = require("ai-localize-locale-engine");
+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) => {
     logger.header("ai-localize full-migrate");
@@ -459,15 +459,15 @@ function fullMigrateCommand() {
     const dryRun = opts.dryRun;
     try {
       const cs = createSpinner("Loading configuration...").start();
-      const { config } = await (0, import_config10.loadConfig)(cwd);
+      const { config } = await (0, import_ai_localize_config10.loadConfig)(cwd);
       cs.succeed("Configuration loaded");
       const ss = createSpinner("Scanning for hardcoded text...").start();
-      const scanner = new import_scanner6.ProjectScanner(config);
+      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");
       const es = createSpinner("Extracting locale keys...").start();
-      const uniqueTexts = (0, import_locale_engine2.deduplicateTexts)(scanResult.detectedTexts);
-      const extractor = new import_locale_engine2.LocaleExtractor({
+      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
@@ -475,17 +475,17 @@ function fullMigrateCommand() {
       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 });
+        const writer = new import_ai_localize_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 runner = new import_ai_localize_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({
+      const validator = new import_ai_localize_validators4.LocaleValidator({
         localesDir: path9.resolve(cwd, config.localesDir),
         sourceDir: path9.resolve(cwd, config.sourceDir),
         defaultLanguage: config.defaultLanguage,
@@ -494,8 +494,8 @@ function fullMigrateCommand() {
       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);
+        const report = (0, import_ai_localize_reporting2.buildReport)({ scanResult, validationResult });
+        (0, import_ai_localize_reporting2.printCliSummary)(report);
       }
       logger.success("Full migration complete!");
     } catch (err) {
@@ -507,7 +507,7 @@ function fullMigrateCommand() {
 
 // 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.name("ai-localize").description(import_chalk12.default.cyan("ai-localize-core") + " \u2014 Deterministic localization + CloudFront migration platform").version(import_ai_localize_shared5.PLATFORM_VERSION, "-v, --version");
 program.addCommand(initCommand());
 program.addCommand(scanCommand());
 program.addCommand(extractCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-localize-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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-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"
+    "ai-localize-shared": "1.0.1",
+    "ai-localize-framework-detectors": "1.0.1",
+    "ai-localize-config": "1.0.1",
+    "ai-localize-codemods": "1.0.1",
+    "ai-localize-scanner": "1.0.1",
+    "ai-localize-validators": "1.0.1",
+    "ai-localize-locale-engine": "1.0.1",
+    "ai-localize-aws-cloudfront": "1.0.1",
+    "ai-localize-reporting": "1.0.1"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",

package/src/cli.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { PLATFORM_VERSION } from '@ai-localize/shared';
+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';

package/src/commands/cleanup.ts

@@ -4,9 +4,9 @@ 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';
+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')

package/src/commands/extract.ts

@@ -3,9 +3,9 @@ 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 { 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')

package/src/commands/full-migrate.ts

@@ -3,12 +3,12 @@ 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';
+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')

package/src/commands/init.ts

@@ -2,8 +2,8 @@ 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';
+import { writeDefaultConfig } from 'ai-localize-config';
+import { detectFramework } from 'ai-localize-framework-detectors';
 
 export function initCommand(): Command {
   return new Command('init')

package/src/commands/migrate-cdn.ts

@@ -3,9 +3,9 @@ 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';
+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')

package/src/commands/replace-cdn.ts

@@ -3,11 +3,11 @@ 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';
+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')

package/src/commands/report.ts

@@ -3,10 +3,10 @@ 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';
+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')

package/src/commands/scan.ts

@@ -3,9 +3,9 @@ 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';
+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')

package/src/commands/upload-assets.ts

@@ -3,9 +3,9 @@ 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';
+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')

package/src/commands/validate.ts

@@ -3,8 +3,8 @@ 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';
+import { loadConfig } from 'ai-localize-config';
+import { LocaleValidator } from 'ai-localize-validators';
 
 export function validateCommand(): Command {
   return new Command('validate')