locai 2.2.0 → 2.4.0

package/dist/cli.js

@@ -1,147 +1,22 @@
 #!/usr/bin/env node
-import dotenv from "dotenv";
-import { promises as fs } from "fs";
-import path from "path";
-import os from "os";
 import { createRequire } from "module";
 import { program } from "commander";
-import { translateFile, findLocaleFiles, validateAndFixExistingTranslations, } from "./commands/translator.js";
-import ProviderFactory from "./core/provider-factory.js";
-import { FileManager } from "./utils/file-manager.js";
-import rateLimiter from "./utils/rate-limiter.js";
-import Orchestrator from "./core/orchestrator.js";
-import InputValidator from "./utils/input-validator.js";
 import ErrorHelper from "./utils/error-helper.js";
-import { getLogger } from "./utils/logger.js";
-import { FrameworkDetector } from "./core/detection/framework-detector.js";
-import { StructureDetector, LocaleStructure } from "./core/detection/structure-detector.js";
-import { loadConfig } from "./config/index.js";
+import { loadConfig, validateEnvironment } from "./config/index.js";
+import { loadEnvironmentVariables, configureComponents } from "./config/setup.js";
+import { autoDetectConfig, runCommand } from "./cli/helpers.js";
+import InputValidator from "./utils/input-validator.js";
 // Use createRequire to load package.json in ESM context
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
-/**
- * Load environment variables from .env files.
- * Prioritizes .env.local over .env.
- */
-const loadEnvironmentVariables = async () => {
-    // Load environment files in priority order
-    // First load .env (base defaults), then .env.local (local overrides)
-    // This ensures .env.local values take precedence over .env values
-    const envFiles = [
-        { file: ".env", override: false },
-        { file: ".env.local", override: true },
-    ];
-    let loadedCount = 0;
-    for (const { file: envFile, override } of envFiles) {
-        const envPath = path.resolve(process.cwd(), envFile);
-        try {
-            await fs.access(envPath);
-            const result = dotenv.config({ path: envPath, override });
-            if (!result.error) {
-                loadedCount++;
-                // Only log in verbose/debug mode to reduce noise
-                if (process.env.VERBOSE || process.env.DEBUG) {
-                    console.log(`Loaded environment variables from ${envFile}`);
-                }
-            }
-        }
-        catch (error) {
-            // ENOENT is expected when files don't exist - silently skip
-            if (error.code !== "ENOENT") {
-                console.warn(`Warning: Could not load ${envFile}: ${error.message}`);
-            }
-        }
-    }
-    // Informative message only if verbose/debug and at least one file was loaded
-    if ((process.env.VERBOSE || process.env.DEBUG) && loadedCount > 0) {
-        console.log(`Environment: ${loadedCount} file(s) loaded`);
-    }
-};
-// Local config loader replaced by src/config/index.ts
-/**
- * Configure global components (logger, rate limiter, etc.).
- * @param {any} config - Configuration object.
- */
-const configureComponents = (config) => {
-    // Configure FileManager with config settings
-    if (config.fileOperations) {
-        FileManager.configure(config.fileOperations);
-    }
-    // Initialize logger with config
-    if (config.logging) {
-        const logger = getLogger(config.logging);
-        if (config.logging.verbose || config.debug) {
-            logger.info("Logger initialized", {
-                saveErrorLogs: config.logging.saveErrorLogs,
-                logDirectory: config.logging.logDirectory,
-                rotationEnabled: config.logging.logRotation?.enabled,
-            });
-        }
-    }
-    if (config.rateLimiter) {
-        rateLimiter.updateConfig({
-            queueStrategy: config.rateLimiter.queueStrategy || "priority",
-            queueTimeout: config.rateLimiter.queueTimeout || 30000,
-            adaptiveThrottling: config.rateLimiter.adaptiveThrottling !== false,
-            providerLimits: config.rateLimiter.providerLimits,
-        });
-    }
-    if (config.advanced?.debug) {
-        process.env.DEBUG = "true";
-    }
-    if (config.logging?.verbose) {
-        process.env.VERBOSE = "true";
-    }
-};
-/**
- * Configure and run the CLI program.
- * @param {any} defaultConfig - Default configuration.
- * @returns {Promise<any>} - Final configuration.
- */
-const configureCLI = async (defaultConfig) => {
-    // Auto-detect framework and configuration if not explicitly set
-    // This makes the tool framework-agnostic
-    const detected = await FrameworkDetector.detect(process.cwd());
-    if (detected) {
-        // Set locales directory if not configured
-        if (!defaultConfig.localesDir && detected.localesDir) {
-            defaultConfig.localesDir = detected.localesDir;
-            if (process.env.VERBOSE) {
-                console.log(`Auto-detected locales directory: ${detected.localesDir}`);
-            }
-        }
-        // Set file format if not configured
-        if (!defaultConfig.fileOperations)
-            defaultConfig.fileOperations = {};
-        if ((!defaultConfig.fileOperations.format ||
-            defaultConfig.fileOperations.format === "auto") &&
-            detected.fileFormat) {
-            defaultConfig.fileOperations.format = detected.fileFormat;
-            if (process.env.VERBOSE) {
-                console.log(`Auto-detected file format: ${detected.fileFormat}`);
-            }
-        }
-    }
-    // Auto-detect file structure (flat vs nested)
-    if (!defaultConfig.fileOperations)
-        defaultConfig.fileOperations = {};
-    if (!defaultConfig.fileOperations.fileStructure ||
-        defaultConfig.fileOperations.fileStructure === "auto") {
-        const targetDir = defaultConfig.localesDir || "./locales";
-        const structure = await StructureDetector.detect(targetDir);
-        if (structure !== LocaleStructure.UNKNOWN) {
-            defaultConfig.fileOperations.fileStructure = structure;
-            if (process.env.VERBOSE) {
-                console.log(`Auto-detected file structure: ${structure}`);
-            }
-        }
-        else {
-            // Default to flat if unknown
-            defaultConfig.fileOperations.fileStructure = LocaleStructure.FLAT;
-        }
-    }
+const main = async () => {
+    await loadEnvironmentVariables();
+    // Load configuration
+    const loaded = await loadConfig();
+    let defaultConfig = loaded.config || {};
+    defaultConfig = await autoDetectConfig(defaultConfig);
     configureComponents(defaultConfig);
-    // Use config version if available, otherwise use package.json version
+    validateEnvironment(defaultConfig);
     const toolVersion = defaultConfig.version || version;
     program
         .name("locai")
@@ -161,278 +36,6 @@ const configureCLI = async (defaultConfig) => {
         process.env.VERBOSE = "true";
         console.log("Verbose mode: ENABLED (detailed diagnostics)");
     });
-    const runCommand = async (options, commandOptions, commandName) => {
-        try {
-            const validCommands = ["translate", "fix", "analyze", "advanced"];
-            if (!validCommands.includes(commandName)) {
-                throw new Error(`Invalid command: ${commandName}`);
-            }
-            const globalOpts = program.opts();
-            if (globalOpts.debug) {
-                const safeGlobalOpts = { ...globalOpts };
-                const safeCommandOptions = { ...commandOptions };
-                if (safeGlobalOpts.targets) {
-                    safeGlobalOpts.targets = `[${safeGlobalOpts.targets.length} languages]`;
-                }
-                if (safeGlobalOpts.localesDir) {
-                    safeGlobalOpts.localesDir = "[directory_path]";
-                }
-                if (safeCommandOptions.provider) {
-                    safeCommandOptions.provider = "[provider_name]";
-                }
-                console.log("CLI Command:", commandName);
-                console.log("Global Options:", JSON.stringify(safeGlobalOpts, null, 2));
-                console.log("Command Options:", JSON.stringify(safeCommandOptions, null, 2));
-            }
-            const sanitizedGlobalOpts = { ...globalOpts };
-            const sanitizedCommandOptions = { ...commandOptions };
-            if (sanitizedGlobalOpts.source) {
-                sanitizedGlobalOpts.source = InputValidator.validateLanguageCode(sanitizedGlobalOpts.source, "source language");
-            }
-            if (sanitizedGlobalOpts.targets && Array.isArray(sanitizedGlobalOpts.targets)) {
-                sanitizedGlobalOpts.targets = InputValidator.validateLanguageCodes(sanitizedGlobalOpts.targets, "target languages");
-            }
-            if (sanitizedGlobalOpts.localesDir) {
-                sanitizedGlobalOpts.localesDir = InputValidator.validateDirectoryPath(sanitizedGlobalOpts.localesDir, "locales directory");
-            }
-            if (sanitizedCommandOptions.provider) {
-                sanitizedCommandOptions.provider = InputValidator.validateProvider(sanitizedCommandOptions.provider, "API provider");
-            }
-            if (sanitizedCommandOptions.concurrency !== undefined) {
-                const concurrency = parseInt(sanitizedCommandOptions.concurrency);
-                if (isNaN(concurrency) || concurrency < 1 || concurrency > 20) {
-                    throw new Error("Concurrency must be a number between 1 and 20");
-                }
-                sanitizedCommandOptions.concurrency = concurrency;
-            }
-            if (sanitizedCommandOptions.contextThreshold !== undefined) {
-                const threshold = parseInt(sanitizedCommandOptions.contextThreshold);
-                if (isNaN(threshold) || threshold < 1 || threshold > 10) {
-                    throw new Error("Context threshold must be a number between 1 and 10");
-                }
-                sanitizedCommandOptions.contextThreshold = threshold;
-            }
-            if (sanitizedCommandOptions.contextConfidence !== undefined) {
-                const confidence = parseFloat(sanitizedCommandOptions.contextConfidence);
-                if (isNaN(confidence) || confidence < 0 || confidence > 1) {
-                    throw new Error("Context confidence must be a number between 0 and 1");
-                }
-                sanitizedCommandOptions.contextConfidence = confidence;
-            }
-            if (sanitizedCommandOptions.length) {
-                const validLengthModes = ["strict", "flexible", "exact", "relaxed", "smart"];
-                if (!validLengthModes.includes(sanitizedCommandOptions.length)) {
-                    throw new Error(`Invalid length mode: ${sanitizedCommandOptions.length}. Valid modes: ${validLengthModes.join(", ")}`);
-                }
-            }
-            const mergedOpts = {
-                source: defaultConfig.source,
-                targets: defaultConfig.targets,
-                localesDir: defaultConfig.localesDir,
-                apiProvider: defaultConfig.apiProvider,
-                ...(sanitizedGlobalOpts.source && { source: sanitizedGlobalOpts.source }),
-                ...(sanitizedGlobalOpts.targets && { targets: sanitizedGlobalOpts.targets }),
-                ...(sanitizedGlobalOpts.localesDir && {
-                    localesDir: sanitizedGlobalOpts.localesDir,
-                }),
-                ...sanitizedCommandOptions,
-            };
-            let concurrencyLimit = parseInt(mergedOpts.concurrency) || defaultConfig.concurrencyLimit || 5;
-            if (mergedOpts.autoOptimize) {
-                const cpuCount = os.cpus().length;
-                const memoryGB = Math.floor(os.totalmem() / (1024 * 1024 * 1024));
-                if (memoryGB < 4) {
-                    concurrencyLimit = Math.min(3, cpuCount);
-                }
-                else if (memoryGB < 8) {
-                    concurrencyLimit = Math.min(5, Math.ceil(cpuCount * 0.5));
-                }
-                else {
-                    concurrencyLimit = Math.min(10, Math.ceil(cpuCount * 0.75));
-                }
-                console.log(`Auto-optimized settings for your system (${cpuCount} CPUs, ${memoryGB}GB RAM):`);
-                console.log(`   - Concurrency: ${concurrencyLimit}`);
-            }
-            if (concurrencyLimit < 1 || concurrencyLimit > 20) {
-                throw new Error("Invalid concurrency limit after optimization");
-            }
-            const finalConfig = {
-                ...defaultConfig,
-                command: commandName,
-                source: mergedOpts.source,
-                targets: mergedOpts.targets,
-                localesDir: mergedOpts.localesDir,
-                apiProvider: mergedOpts.provider || defaultConfig.apiProvider,
-                concurrencyLimit: concurrencyLimit,
-                cacheEnabled: mergedOpts.noCache === undefined
-                    ? defaultConfig.cacheEnabled
-                    : !mergedOpts.noCache,
-                debug: mergedOpts.debug,
-                verbose: mergedOpts.verbose || defaultConfig.logging?.verbose || false,
-                forceUpdate: mergedOpts.force || false,
-                showDetailedStats: mergedOpts.stats || false,
-                autoOptimize: mergedOpts.autoOptimize || defaultConfig.advanced?.autoOptimize || false,
-                fixLength: commandName === "fix",
-                apiConfig: defaultConfig.apiConfig || {},
-                styleGuide: defaultConfig.styleGuide,
-                qualityChecks: defaultConfig.qualityChecks,
-                lengthControl: {
-                    ...defaultConfig.lengthControl,
-                    mode: mergedOpts.length || defaultConfig.lengthControl?.mode || "smart",
-                },
-                retryOptions: {
-                    ...defaultConfig.retryOptions,
-                    maxRetries: mergedOpts.maxRetries || defaultConfig.retryOptions?.maxRetries || 2,
-                    initialDelay: mergedOpts.initialDelay || defaultConfig.retryOptions?.initialDelay || 1000,
-                    maxDelay: mergedOpts.maxDelay || defaultConfig.retryOptions?.maxDelay || 10000,
-                    jitter: defaultConfig.retryOptions?.jitter !== false,
-                },
-                context: {
-                    ...defaultConfig.context,
-                    enabled: true,
-                    debug: mergedOpts.contextDebug || defaultConfig.context.debug || false,
-                    useAI: mergedOpts.useAi ||
-                        mergedOpts.contextProvider !== undefined ||
-                        defaultConfig.context.useAI ||
-                        false,
-                    aiProvider: mergedOpts.contextProvider || defaultConfig.context.aiProvider,
-                    minTextLength: mergedOpts.minTextLength || defaultConfig.context.minTextLength,
-                    allowNewCategories: mergedOpts.allowNewCategories !== undefined
-                        ? mergedOpts.allowNewCategories
-                        : defaultConfig.context.allowNewCategories,
-                    detection: {
-                        threshold: mergedOpts.contextThreshold ||
-                            defaultConfig.context.detection?.threshold ||
-                            2,
-                        minConfidence: mergedOpts.contextConfidence ||
-                            defaultConfig.context.detection?.minConfidence ||
-                            0.6,
-                    },
-                },
-                advanced: {
-                    ...defaultConfig.advanced,
-                    timeoutMs: mergedOpts.timeout || defaultConfig.advanced?.timeoutMs || 60000,
-                    maxKeyLength: defaultConfig.advanced?.maxKeyLength || 10000,
-                    maxBatchSize: defaultConfig.advanced?.maxBatchSize || 50,
-                    autoOptimize: mergedOpts.autoOptimize || defaultConfig.advanced?.autoOptimize || false,
-                    debug: mergedOpts.debug || defaultConfig.advanced?.debug || false,
-                },
-                rateLimiter: {
-                    ...defaultConfig.rateLimiter,
-                    enabled: defaultConfig.rateLimiter?.enabled !== false,
-                },
-                fileOperations: defaultConfig.fileOperations || {},
-                logging: {
-                    ...defaultConfig.logging,
-                    verbose: mergedOpts.verbose || defaultConfig.logging?.verbose || false,
-                },
-            };
-            try {
-                InputValidator.validateConfig(finalConfig);
-                if (finalConfig.debug || finalConfig.verbose) {
-                    console.log("Configuration validated successfully");
-                }
-            }
-            catch (configError) {
-                const error = ErrorHelper.configValidationError(configError.message.includes("validation failed")
-                    ? configError.message.split("\n").slice(1)
-                    : [configError.message]);
-                console.error(ErrorHelper.formatError(error, { showDebug: globalOpts.debug }));
-                process.exit(1);
-            }
-            configureComponents(finalConfig);
-            validateEnvironment();
-            if (finalConfig.debug) {
-                console.log("\nConfiguration details:");
-                const safeConfig = {
-                    ...finalConfig,
-                    apiConfig: Object.keys(finalConfig.apiConfig || {}).reduce((acc, provider) => {
-                        acc[provider] = {
-                            model: finalConfig.apiConfig[provider]?.model || "configured",
-                            temperature: finalConfig.apiConfig[provider]?.temperature,
-                            maxTokens: finalConfig.apiConfig[provider]?.maxTokens,
-                        };
-                        return acc;
-                    }, {}),
-                    advanced: {
-                        ...finalConfig.advanced,
-                        timeoutMs: finalConfig.advanced?.timeoutMs,
-                        maxKeyLength: finalConfig.advanced?.maxKeyLength,
-                        maxBatchSize: finalConfig.advanced?.maxBatchSize,
-                        autoOptimize: finalConfig.advanced?.autoOptimize,
-                        debug: finalConfig.advanced?.debug,
-                    },
-                };
-                delete safeConfig.apiProvider; // Could leak preferred provider info
-                delete safeConfig.localesDir; // Could leak file system structure
-                console.log(JSON.stringify(safeConfig, null, 2));
-            }
-            await displayPerformanceTips(finalConfig);
-            const localesDir = path.resolve(finalConfig.localesDir);
-            console.log(`\nLooking for source files in: ${localesDir}`);
-            const files = await findLocaleFiles(localesDir, finalConfig.source);
-            if (!files || !files.length) {
-                const error = ErrorHelper.fileNotFoundError(`${localesDir}/${finalConfig.source}.json`, `${finalConfig.source}.json`);
-                console.error(ErrorHelper.formatError(error, {
-                    showDebug: finalConfig.debug,
-                    showContext: true,
-                }));
-                process.exit(1);
-            }
-            switch (commandName) {
-                case "fix":
-                    console.log("\nRunning in FIX mode");
-                    await Promise.all(files.map((file) => validateAndFixExistingTranslations(file, finalConfig)));
-                    break;
-                case "analyze":
-                    console.log("\nRunning in ANALYZE mode");
-                    console.log("Context analysis mode is not fully implemented yet.");
-                    break;
-                case "advanced":
-                    console.log("\nRunning ADVANCED configuration");
-                // Fall through to translate
-                case "translate":
-                default:
-                    console.log("\nRunning in TRANSLATION mode");
-                    if (finalConfig.context.useAI) {
-                        console.log(`AI Context Analysis: ENABLED (Provider: ${finalConfig.context.aiProvider || finalConfig.apiProvider})`);
-                        if (finalConfig.context.allowNewCategories) {
-                            console.log("New category suggestions: ENABLED");
-                        }
-                    }
-                    console.log(`Performance settings:`);
-                    console.log(`   - Concurrency: ${finalConfig.concurrencyLimit} parallel operations`);
-                    console.log(`   - Caching: ${finalConfig.cacheEnabled ? "Enabled" : "Disabled"}`);
-                    console.log(`   - Retries: ${finalConfig.retryOptions.maxRetries} max retries`);
-                    if (finalConfig.rateLimiter?.adaptiveThrottling) {
-                        console.log(`   - Adaptive Rate Limiting: Enabled`);
-                    }
-                    if (finalConfig.forceUpdate) {
-                        console.log(`Warning: Force update mode ENABLED (will update existing translations)`);
-                    }
-                    for (const file of files) {
-                        await translateFile(file, finalConfig);
-                    }
-                    // Exit after successful translation in CLI mode
-                    // This allows translateFile to be used as library without forcing exit
-                    process.exit(0);
-                    break;
-            }
-            // Other commands (fix, analyze) handle their own completion
-        }
-        catch (validationError) {
-            if (validationError.message.includes("Configuration validation")) {
-                // Already handled above with better formatting
-                return;
-            }
-            console.error(`\nInput validation error: ${validationError.message}`);
-            if (validationError.stack && process.env.DEBUG) {
-                console.error("\nStack trace:");
-                console.error(validationError.stack);
-            }
-            process.exit(1);
-        }
-    };
     program
         .command("translate")
         .description("Translate missing strings (default command)")
@@ -447,10 +50,9 @@ const configureCLI = async (defaultConfig) => {
         .option("--save-review-queue", "Save low-confidence items for manual review", false)
         .action(async (options) => {
         try {
-            await runCommand(program.opts(), options, "translate");
+            await runCommand(defaultConfig, options, "translate");
         }
         catch (error) {
-            // Handle errors with better formatting
             if (error.code && error.code.startsWith("ERR_")) {
                 console.error(ErrorHelper.formatError(error, {
                     showDebug: process.env.DEBUG === "true",
@@ -473,7 +75,7 @@ const configureCLI = async (defaultConfig) => {
         .option("--length", "Fix length issues in existing translations", true)
         .action(async (options) => {
         try {
-            await runCommand(program.opts(), options, "fix");
+            await runCommand(defaultConfig, options, "fix");
         }
         catch (error) {
             if (error.code && error.code.startsWith("ERR_")) {
@@ -491,12 +93,12 @@ const configureCLI = async (defaultConfig) => {
     program
         .command("analyze")
         .description("Analyze context patterns")
-        .option("--use-ai", "Enable AI-based context analysis", defaultConfig.context.useAI)
-        .option("--context-provider <provider>", "AI provider for analysis", defaultConfig.context.aiProvider)
-        .option("--context-threshold <number>", "Minimum match count", Number, defaultConfig.context.detection.threshold)
+        .option("--use-ai", "Enable AI-based context analysis", defaultConfig.context?.useAI)
+        .option("--context-provider <provider>", "AI provider for analysis", defaultConfig.context?.aiProvider)
+        .option("--context-threshold <number>", "Minimum match count", Number, defaultConfig.context?.detection?.threshold)
         .action(async (options) => {
         try {
-            await runCommand(program.opts(), options, "analyze");
+            await runCommand(defaultConfig, options, "analyze");
         }
         catch (error) {
             if (error.code && error.code.startsWith("ERR_")) {
@@ -514,14 +116,14 @@ const configureCLI = async (defaultConfig) => {
     program
         .command("advanced")
         .description("Access advanced configuration options")
-        .option("--context-confidence <number>", "Minimum confidence score", Number, defaultConfig.context.detection.minConfidence)
-        .option("--context-debug", "Show context details", defaultConfig.context.debug)
-        .option("--min-text-length <number>", "Minimum text length for AI analysis", Number, defaultConfig.context.minTextLength)
-        .option("--allow-new-categories", "Allow AI to suggest new categories", defaultConfig.context.allowNewCategories)
+        .option("--context-confidence <number>", "Minimum confidence score", Number, defaultConfig.context?.detection?.minConfidence)
+        .option("--context-debug", "Show context details", defaultConfig.context?.debug)
+        .option("--min-text-length <number>", "Minimum text length for AI analysis", Number, defaultConfig.context?.minTextLength)
+        .option("--allow-new-categories", "Allow AI to suggest new categories", defaultConfig.context?.allowNewCategories)
         .option("--max-retries <number>", "Maximum number of retries for API calls", Number, defaultConfig.retryOptions?.maxRetries || 2)
         .action(async (options) => {
         try {
-            await runCommand(program.opts(), options, "advanced");
+            await runCommand(defaultConfig, options, "advanced");
         }
         catch (error) {
             if (error.code && error.code.startsWith("ERR_")) {
@@ -559,7 +161,7 @@ const configureCLI = async (defaultConfig) => {
                     console.log(`   Version: ${defaultConfig.version}`);
                 }
                 console.log(`   Source: ${defaultConfig.source}`);
-                console.log(`   Targets: ${defaultConfig.targets.length} languages (${defaultConfig.targets.slice(0, 5).join(", ")}${defaultConfig.targets.length > 5 ? "..." : ""})`);
+                console.log(`   Targets: ${(defaultConfig.targets || []).length} languages (${(defaultConfig.targets || []).slice(0, 5).join(", ")}${(defaultConfig.targets || []).length > 5 ? "..." : ""})`);
                 console.log(`   API Provider: ${defaultConfig.apiProvider || "auto-detect"}`);
                 console.log(`   Concurrency: ${defaultConfig.concurrencyLimit || 5} parallel operations`);
                 console.log(`   Cache: ${defaultConfig.cacheEnabled !== false ? "Enabled" : "Disabled"}`);
@@ -593,8 +195,16 @@ const configureCLI = async (defaultConfig) => {
         .option("--export <format>", "Export review queue (json|csv)")
         .action(async (options) => {
         try {
-            const ReviewCommand = (await import("../src/commands/review.js")).default;
-            const review = new ReviewCommand(defaultConfig);
+            const ReviewCommand = (await import("./commands/review.js")).default;
+            // Ensure config matches expectations of ReviewCommand
+            // ReviewCommand expects ConfigLayer/LocalizeConfig, need to ensure mandatory fields or cast
+            // ReviewCommandConfig requires localesDir and source to be strings (not undefined)
+            const reviewConfig = {
+                ...defaultConfig,
+                localesDir: defaultConfig.localesDir || "./locales",
+                source: defaultConfig.source || "en",
+            };
+            const review = new ReviewCommand(reviewConfig);
             if (options.export) {
                 review.exportReviewQueue(options.export);
             }
@@ -612,107 +222,16 @@ const configureCLI = async (defaultConfig) => {
     });
     program.action(async () => {
         try {
-            await runCommand(program.opts(), {}, "translate");
+            await runCommand(defaultConfig, {}, "translate");
         }
         catch (error) {
             console.error(`\nError: ${error.message}`);
-            if (error.stack && process.env.DEBUG) {
-                console.error(error.stack);
-            }
             process.exit(1);
         }
     });
-    program.parse(process.argv);
-    return defaultConfig;
-};
-/**
- * Validate that necessary environment variables are set.
- * @returns {Array<string>} - List of available providers.
- */
-const validateEnvironment = () => {
-    try {
-        // Check that ProviderFactory can validate providers
-        const availableProviders = ProviderFactory.validateProviders();
-        console.log(`\nAvailable API providers: ${availableProviders.join(", ")}`);
-        return availableProviders;
-    }
-    catch (error) {
-        console.error("\nError: " + error.message);
-        console.error("Please set at least one of the following environment variables:");
-        const possibleProviders = [
-            "DASHSCOPE_API_KEY",
-            "OPENAI_API_KEY",
-            "DEEPSEEK_API_KEY",
-            "GEMINI_API_KEY",
-            "XAI_API_KEY",
-        ];
-        possibleProviders.forEach((key) => console.error(`  - ${key}`));
-        process.exit(1);
-    }
+    await program.parseAsync(process.argv);
 };
-/**
- * Display performance optimizations and tips.
- * @param {any} options - Configuration options.
- */
-const displayPerformanceTips = async (options) => {
-    if (!options.debug)
-        return;
-    try {
-        const cpuCount = os.cpus().length;
-        const cpuModel = os.cpus()[0]?.model || "Unknown CPU";
-        const memoryGB = Math.floor(os.totalmem() / (1024 * 1024 * 1024));
-        const freememGB = Math.floor(os.freemem() / (1024 * 1024 * 1024));
-        const orchestrator = new Orchestrator(options);
-        const cacheStats = orchestrator.getCacheStats();
-        console.log("\nPerformance Information:");
-        console.log(`   - CPU: ${cpuModel} (${cpuCount} cores)`);
-        console.log(`   - Memory: ${freememGB}GB free of ${memoryGB}GB total`);
-        console.log(`   - Concurrency: ${options.concurrencyLimit} parallel operations`);
-        console.log(`   - Cache: ${options.cacheEnabled ? "Enabled" : "Disabled"} (${cacheStats.size} items cached)`);
-        // Provide tips
-        console.log("\nPerformance Tips:");
-        if (cpuCount > options.concurrencyLimit * 2) {
-            console.log(`   - Increase concurrency with --concurrency ${Math.min(cpuCount, 10)} to better utilize your CPU`);
-        }
-        if (!options.cacheEnabled) {
-            console.log(`   - Enable caching to improve repeated runs speed`);
-        }
-        if (memoryGB < 4) {
-            console.log(`   - Your system has limited memory (${memoryGB}GB). Consider reducing concurrency if you experience issues.`);
-        }
-    }
-    catch (error) {
-        console.log("Warning: Could not calculate performance tips", error);
-    }
-};
-try {
-    await loadEnvironmentVariables();
-    let defaultConfig;
-    try {
-        const { config, configFile } = await loadConfig();
-        defaultConfig = config;
-        if (configFile) {
-            console.log(`Loaded config from: ${path.relative(process.cwd(), configFile)}`);
-        }
-        else {
-            console.log("No config file found, using defaults");
-        }
-    }
-    catch (err) {
-        console.warn(`Warning: Could not load config: ${err.message}`);
-        // Fallback defaults if logic fails totally (shouldn't with c12 defaults)
-        defaultConfig = {
-            source: "en",
-            targets: [],
-            concurrencyLimit: 5,
-        };
-    }
-    await configureCLI(defaultConfig);
-}
-catch (error) {
-    console.error(`\nError: ${error.message}`);
-    if (error.stack && process.env.DEBUG) {
-        console.error(error.stack);
-    }
+main().catch((err) => {
+    console.error(err);
     process.exit(1);
-}
+});

package/dist/commands/interactive-review.d.ts

@@ -0,0 +1,9 @@
+export declare class InteractiveReviewer {
+    private queue;
+    private decisions;
+    constructor();
+    loadQueue(): boolean;
+    start(): Promise<void>;
+    private handleAction;
+    private saveDecisions;
+}