locai 2.1.0

package/dist/commands/review.js

@@ -0,0 +1,357 @@
+/**
+ * Interactive Review Command.
+ * Allows manual review of low-confidence translations.
+ */
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import ConfidenceScorer from "../utils/confidence-scorer.js";
+class ReviewCommand {
+    config;
+    reviewQueue;
+    currentIndex;
+    decisions;
+    /**
+     * Initialize ReviewCommand.
+     * @param {ReviewCommandConfig} config - Configuration object.
+     */
+    constructor(config) {
+        this.config = config;
+        this.reviewQueue = [];
+        this.currentIndex = 0;
+        this.decisions = {
+            accepted: [],
+            edited: [],
+            rejected: [],
+            skipped: [],
+        };
+    }
+    /**
+     * Load review queue from cache file.
+     * @returns {boolean} - True if loaded successfully, else false.
+     */
+    loadReviewQueue() {
+        const reviewFile = path.join(process.cwd(), ".localize-cache", "review-queue.json");
+        if (!fs.existsSync(reviewFile)) {
+            console.log("\nNo review queue found.");
+            console.log("   Run translation with confidence scoring first: localize translate --min-confidence 0.8");
+            return false;
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(reviewFile, "utf8"));
+            this.reviewQueue = data.items || [];
+            console.log(`\nLoaded ${this.reviewQueue.length} items for review\n`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error loading review queue: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Start interactive review session.
+     */
+    async startReview() {
+        if (!this.loadReviewQueue()) {
+            return;
+        }
+        if (this.reviewQueue.length === 0) {
+            console.log("\nNo items need review. All translations meet quality threshold!\n");
+            return;
+        }
+        console.log("━".repeat(70));
+        console.log(`Review Queue: ${this.reviewQueue.length} translations need attention`);
+        console.log("━".repeat(70));
+        for (let i = 0; i < this.reviewQueue.length; i++) {
+            this.currentIndex = i;
+            const item = this.reviewQueue[i];
+            const decision = await this.reviewItem(item, i + 1, this.reviewQueue.length);
+            if (decision === "quit") {
+                break;
+            }
+        }
+        this.showSummary();
+        this.saveDecisions();
+    }
+    /**
+     * Review a single translation item.
+     * @param {ReviewItem} item - Translation item to review.
+     * @param {number} current - Current item index (1-based).
+     * @param {number} total - Total items.
+     * @returns {Promise<string>} - Decision result.
+     */
+    async reviewItem(item, current, total) {
+        console.log(`\n[${current}/${total}] Translation Review`);
+        console.log("━".repeat(70));
+        console.log(`Key:        ${item.key}`);
+        console.log(`Language:   ${item.language}`);
+        const score = item.confidence?.score || 0;
+        const level = item.confidence?.level || "unknown";
+        console.log(`Confidence: ${ConfidenceScorer.formatConfidence(score)} (${level})`);
+        console.log(`Category:   ${item.category || "general"}`);
+        console.log(`\nSource:`);
+        console.log(`  "${item.source}"`);
+        console.log(`\nTranslation:`);
+        console.log(`  "${item.translation}"`);
+        // Show issues if any
+        if (item.confidence?.issues && item.confidence.issues.length > 0) {
+            console.log(`\nIssues Detected:`);
+            item.confidence.issues.forEach((issue) => {
+                const icon = issue.severity === "critical" ? "[!]" : "[*]";
+                console.log(`  ${icon} ${issue.message}`);
+            });
+        }
+        console.log(`\nActions:`);
+        console.log(`  [A] Accept    [E] Edit    [R] Reject    [S] Skip`);
+        console.log(`  [N] Next      [Q] Quit    [?] Help`);
+        const action = await this.getUserInput("\nYour choice: ");
+        return this.handleAction(action.toLowerCase(), item);
+    }
+    /**
+     * Handle user action input.
+     * @param {string} action - User action code.
+     * @param {ReviewItem} item - Current item.
+     * @returns {Promise<string>} - Result status.
+     */
+    async handleAction(action, item) {
+        switch (action) {
+            case "a":
+            case "accept":
+                this.decisions.accepted.push(item);
+                console.log("Accepted");
+                return "continue";
+            case "edit": {
+                const edited = await this.editTranslation(item);
+                this.decisions.edited.push(edited);
+                console.log("Edited and saved");
+                return "continue";
+            }
+            case "r":
+            case "reject":
+                this.decisions.rejected.push(item);
+                console.log("Rejected - will be retranslated");
+                return "continue";
+            case "s":
+            case "skip":
+                this.decisions.skipped.push(item);
+                console.log("Skipped");
+                return "continue";
+            case "n":
+            case "next":
+                return "continue";
+            case "q":
+            case "quit":
+                console.log("\n👋 Exiting review session...");
+                return "quit";
+            case "?":
+            case "help":
+                this.showHelp();
+                return this.handleAction(await this.getUserInput("\nYour choice: "), item);
+            default:
+                console.log("Invalid action. Try again.");
+                return this.handleAction(await this.getUserInput("\nYour choice: "), item);
+        }
+    }
+    /**
+     * Edit translation interactively.
+     * @param {ReviewItem} item - Item to edit.
+     * @returns {Promise<ReviewItem>} - Edited item.
+     */
+    async editTranslation(item) {
+        console.log(`\nCurrent: "${item.translation}"`);
+        const newTranslation = await this.getUserInput("New translation: ");
+        if (newTranslation.trim() === "") {
+            console.log("Warning: Empty translation, keeping original");
+            return item;
+        }
+        // Recalculate confidence for edited translation
+        const newConfidence = ConfidenceScorer.calculateConfidence({
+            aiConfidence: 1.0, // Manual edit gets high confidence
+            sourceText: item.source,
+            translation: newTranslation,
+            sourceLang: item.sourceLang || this.config.source,
+            targetLang: item.language,
+            provider: "manual",
+            category: item.category,
+        });
+        return {
+            ...item,
+            translation: newTranslation,
+            confidence: newConfidence,
+            edited: true,
+            editedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Show help information to the user.
+     */
+    showHelp() {
+        console.log("\n━━━ Help ━━━");
+        console.log("A (Accept):  Approve translation as-is");
+        console.log("E (Edit):    Modify the translation manually");
+        console.log("R (Reject):  Mark for retranslation");
+        console.log("S (Skip):    Skip for now, review later");
+        console.log("N (Next):    Skip to next item");
+        console.log("Q (Quit):    Exit review session");
+        console.log("? (Help):    Show this help message");
+        console.log("━".repeat(70));
+    }
+    /**
+     * Show summary of review session.
+     */
+    showSummary() {
+        console.log("\n━".repeat(70));
+        console.log("Review Summary");
+        console.log("━".repeat(70));
+        console.log(`Accepted:  ${this.decisions.accepted.length}`);
+        console.log(`Edited:    ${this.decisions.edited.length}`);
+        console.log(`Rejected:  ${this.decisions.rejected.length}`);
+        console.log(`Skipped:   ${this.decisions.skipped.length}`);
+        console.log(`Total:     ${this.decisions.accepted.length + this.decisions.edited.length + this.decisions.rejected.length + this.decisions.skipped.length}/${this.reviewQueue.length}`);
+        console.log("━".repeat(70));
+    }
+    /**
+     * Save review decisions to disk and apply them.
+     */
+    saveDecisions() {
+        const cacheDir = path.join(process.cwd(), ".localize-cache");
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const decisionsFile = path.join(cacheDir, "review-decisions.json");
+        const data = {
+            timestamp: new Date().toISOString(),
+            decisions: this.decisions,
+            stats: {
+                accepted: this.decisions.accepted.length,
+                edited: this.decisions.edited.length,
+                rejected: this.decisions.rejected.length,
+                skipped: this.decisions.skipped.length,
+            },
+        };
+        fs.writeFileSync(decisionsFile, JSON.stringify(data, null, 2));
+        console.log(`\nDecisions saved to: ${decisionsFile}`);
+        // Apply accepted and edited translations
+        this.applyDecisions();
+    }
+    /**
+     * Apply accepted and edited translations to locale files.
+     */
+    applyDecisions() {
+        const toApply = [...this.decisions.accepted, ...this.decisions.edited];
+        if (toApply.length === 0) {
+            console.log("   No changes to apply");
+            return;
+        }
+        console.log(`\nApplying ${toApply.length} approved translations...`);
+        const byLanguage = {};
+        toApply.forEach((item) => {
+            if (!byLanguage[item.language]) {
+                byLanguage[item.language] = [];
+            }
+            byLanguage[item.language].push(item);
+        });
+        Object.entries(byLanguage).forEach(([lang, items]) => {
+            const localeFile = path.join(this.config.localesDir, `${lang}.json`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let localeData = {};
+            if (fs.existsSync(localeFile)) {
+                localeData = JSON.parse(fs.readFileSync(localeFile, "utf8"));
+            }
+            items.forEach((item) => {
+                this.setNestedValue(localeData, item.key, item.translation);
+            });
+            fs.writeFileSync(localeFile, JSON.stringify(localeData, null, 2) + "\n");
+            console.log(`   Updated ${lang}.json (${items.length} translations)`);
+        });
+        console.log("\nAll approved translations applied!");
+    }
+    /**
+     * Set nested value in object using dot notation.
+     * @param {any} obj - Object to modify.
+     * @param {string} path - Dot notation path.
+     * @param {any} value - Value to set.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setNestedValue(obj, path, value) {
+        const keys = path.split(".");
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]]) {
+                current[keys[i]] = {};
+            }
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    /**
+     * Get user input from terminal.
+     * @param {string} prompt - Prompt to display.
+     * @returns {Promise<string>} - User input.
+     */
+    getUserInput(prompt) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(prompt, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    /**
+     * Export review queue to JSON.
+     * @param {string} format - Export format (json or csv).
+     */
+    exportReviewQueue(format = "json") {
+        if (this.reviewQueue.length === 0 && !this.loadReviewQueue()) {
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/:/g, "-").split(".")[0];
+        const filename = `review-queue-${timestamp}.${format}`;
+        if (format === "json") {
+            fs.writeFileSync(filename, JSON.stringify(this.reviewQueue, null, 2));
+            console.log(`\nReview queue exported to: ${filename}`);
+        }
+        else if (format === "csv") {
+            const csv = this.convertToCSV(this.reviewQueue);
+            fs.writeFileSync(filename, csv);
+            console.log(`\nReview queue exported to: ${filename}`);
+        }
+    }
+    /**
+     * Convert review queue to CSV format.
+     * @param {ReviewItem[]} items - Items to convert.
+     * @returns {string} - CSV content.
+     */
+    convertToCSV(items) {
+        const headers = [
+            "Key",
+            "Language",
+            "Source",
+            "Translation",
+            "Confidence",
+            "Level",
+            "Category",
+            "Issues",
+        ];
+        const rows = items.map((item) => [
+            item.key,
+            item.language,
+            item.source,
+            item.translation,
+            item.confidence.score.toFixed(3),
+            item.confidence.level,
+            item.category || "general",
+            item.confidence.issues.map((i) => i.message).join("; "),
+        ]);
+        const csvContent = [
+            headers.join(","),
+            ...rows.map((row) => row.map((cell) => `"${cell}"`).join(",")),
+        ].join("\n");
+        return csvContent;
+    }
+}
+export default ReviewCommand;

package/dist/commands/translator.js

@@ -0,0 +1,29 @@
+import translationService from "../services/translation-service.js";
+/**
+ * Main translator function to process source file and create translations.
+ * @param {string} file - Source file path.
+ * @param {TranslationOptions} options - Translation options.
+ * @returns {Promise<GlobalStats>} - Translation result.
+ */
+async function translateFile(file, options) {
+    return await translationService.translateFile(file, options);
+}
+/**
+ * Find locale files based on source language.
+ * @param {string} localesDir - Locales directory.
+ * @param {string} sourceLang - Source language code.
+ * @returns {Promise<Array<string>>} - Array of locale file paths.
+ */
+async function findLocaleFiles(localesDir, sourceLang) {
+    return await translationService.findLocaleFiles(localesDir, sourceLang);
+}
+/**
+ * Validate and fix existing translations that have length issues.
+ * @param {string} file - File path to validate.
+ * @param {TranslationOptions} options - Validation options.
+ * @returns {Promise<void>}
+ */
+async function validateAndFixExistingTranslations(file, options) {
+    return await translationService.validateAndFixExistingTranslations(file, options);
+}
+export { translateFile, findLocaleFiles, validateAndFixExistingTranslations };

package/dist/config/index.js

@@ -0,0 +1,52 @@
+import { loadConfig as c12LoadConfig } from "c12";
+/**
+ * Type-safe configuration helper
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Load configuration using c12
+ */
+export async function loadConfig(cwd = process.cwd()) {
+    const { config, configFile, layers } = await c12LoadConfig({
+        name: "localize",
+        configFile: "localize.config",
+        rcFile: ".localizerc",
+        dotenv: true,
+        cwd,
+        defaults: {
+            source: "en",
+            targets: [],
+            localesDir: "./locales",
+            concurrencyLimit: 5,
+            cacheEnabled: true,
+            retryOptions: {
+                maxRetries: 2,
+                initialDelay: 1000,
+                maxDelay: 10000,
+            },
+            context: {
+                enabled: true,
+                detection: { threshold: 2, minConfidence: 0.6 },
+                useAI: false,
+                minTextLength: 50,
+                categories: {},
+                fallback: {
+                    category: "general",
+                    prompt: "Provide a natural translation",
+                },
+            },
+            apiConfig: {},
+            fileOperations: {
+                format: "json",
+                fileStructure: "flat",
+            },
+        },
+    });
+    return {
+        config: config || {},
+        configFile,
+        layers,
+    };
+}

package/dist/core/adapters/base-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/core/adapters/factory.js

@@ -0,0 +1,44 @@
+import path from "path";
+import { JsonAdapter } from "./json-adapter.js";
+import { YamlAdapter } from "./yaml-adapter.js";
+import { PoAdapter } from "./po-adapter.js";
+import { PropertiesAdapter } from "./properties-adapter.js";
+/**
+ * Factory class to manage file format adapters
+ */
+export class FormatFactory {
+    static adapters = [
+        new JsonAdapter(),
+        new YamlAdapter(),
+        new PoAdapter(),
+        new PropertiesAdapter(),
+    ];
+    /**
+     * Get adapter for a specific file path
+     * @param filePath - Path to file
+     */
+    static getAdapter(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const adapter = this.adapters.find((a) => a.extensions.includes(ext));
+        if (!adapter) {
+            // Default to JSON if unknown, or throw error?
+            // For robustness, maybe throw or default to JSON but warn.
+            // Let's default to JSON for .arb or weird unknown formats if they look like json,
+            // but strict checking is establishing explicitly.
+            // Fallback to JSON for now as it's the safest bet for web.
+            return new JsonAdapter();
+        }
+        return adapter;
+    }
+    /**
+     * Get adapter by format name (json, yaml, etc.)
+     */
+    static getAdapterByFormat(format) {
+        const formatted = format.startsWith(".") ? format : `.${format}`;
+        const adapter = this.adapters.find((a) => a.extensions.includes(formatted));
+        if (!adapter) {
+            throw new Error(`Unsupported format: ${format}`);
+        }
+        return adapter;
+    }
+}

package/dist/core/adapters/json-adapter.js

@@ -0,0 +1,20 @@
+/**
+ * Adapter for JSON files
+ */
+export class JsonAdapter {
+    extensions = [".json", ".arb"];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parse(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`JSON parse error: ${error.message}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async serialize(data, options = {}) {
+        const indent = options.indent || 4;
+        return JSON.stringify(data, null, indent);
+    }
+}

package/dist/core/adapters/po-adapter.js

@@ -0,0 +1,50 @@
+import gettextParser from "gettext-parser";
+/**
+ * Adapter for Gettext PO files
+ */
+export class PoAdapter {
+    extensions = [".po", ".pot"];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parse(content) {
+        try {
+            const po = gettextParser.po.parse(content);
+            const result = {};
+            // Convert PO structure to flat key-value pair
+            // msgid -> msgstr[0]
+            for (const context in po.translations) {
+                for (const msgid in po.translations[context]) {
+                    if (msgid === "")
+                        continue; // Skip header
+                    const entry = po.translations[context][msgid];
+                    result[msgid] = entry.msgstr[0];
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`PO parse error: ${error.message}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async serialize(data, options = {}) {
+        const translations = {
+            "": {},
+        };
+        // Convert flat object back to PO structure
+        for (const [key, value] of Object.entries(data)) {
+            translations[""][key] = {
+                msgid: key,
+                msgstr: [value],
+            };
+        }
+        return gettextParser.po
+            .compile({
+            charset: "utf-8",
+            headers: {
+                "content-type": "text/plain; charset=utf-8",
+            },
+            translations,
+        })
+            .toString();
+    }
+}

package/dist/core/adapters/properties-adapter.js

@@ -0,0 +1,31 @@
+import dotProperties from "dot-properties";
+/**
+ * Adapter for Java .properties files
+ */
+export class PropertiesAdapter {
+    extensions = [".properties"];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parse(content) {
+        try {
+            return dotProperties.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Properties parse error: ${error.message}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async serialize(data, options = {}) {
+        // dot-properties doesn't have a standardized stringify, simple implementation
+        // or used a different library, but let's do a simple one for now or use the lib if it supports it.
+        // Checking docs: dot-properties is mostly a parser. 'properties' npm package is better for writing but we installed dot-properties.
+        // Let's implement a robust serializer manually as it's simple enough for standard usage.
+        return Object.entries(data)
+            .map(([key, value]) => {
+            // Escape special characters
+            const escapedKey = key.replace(/([=:])/g, "\\$1").replace(/ /g, "\\ ");
+            const escapedValue = String(value).replace(/\n/g, "\\n");
+            return `${escapedKey}=${escapedValue}`;
+        })
+            .join("\n");
+    }
+}

package/dist/core/adapters/yaml-adapter.js

@@ -0,0 +1,24 @@
+import yaml from "js-yaml";
+/**
+ * Adapter for YAML files
+ */
+export class YamlAdapter {
+    extensions = [".yaml", ".yml"];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parse(content) {
+        try {
+            return yaml.load(content) || {};
+        }
+        catch (error) {
+            throw new Error(`YAML parse error: ${error.message}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async serialize(data, options = {}) {
+        return yaml.dump(data, {
+            indent: options.indent || 2,
+            lineWidth: -1, // Disable line wrapping
+            noRefs: true,
+        });
+    }
+}