locai 2.1.3 → 2.3.0

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;
+}

package/dist/commands/interactive-review.js

@@ -0,0 +1,109 @@
+import prompts from "prompts";
+import fs from "fs";
+import path from "path";
+import ConfidenceScorer from "../utils/confidence-scorer.js";
+export class InteractiveReviewer {
+    queue;
+    decisions;
+    constructor() {
+        this.queue = [];
+        this.decisions = {
+            accepted: [],
+            edited: [],
+            rejected: [],
+            skipped: [],
+        };
+    }
+    loadQueue() {
+        const reviewFile = path.join(process.cwd(), ".localize-cache", "review-queue.json");
+        if (!fs.existsSync(reviewFile))
+            return false;
+        try {
+            const data = JSON.parse(fs.readFileSync(reviewFile, "utf8"));
+            this.queue = data.items || [];
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async start() {
+        if (!this.loadQueue() || this.queue.length === 0) {
+            console.log("No items to review.");
+            return;
+        }
+        console.clear();
+        console.log(`\n🔍 Interactive Review Mode (${this.queue.length} items)\n`);
+        for (let i = 0; i < this.queue.length; i++) {
+            const item = this.queue[i];
+            const progress = `[${i + 1}/${this.queue.length}]`;
+            console.log(`\n${progress} ${item.language.toUpperCase()} | Key: ${item.key}`);
+            console.log(`Confidence: ${ConfidenceScorer.formatConfidence(item.confidence.score)} (${item.confidence.level})`);
+            const response = await prompts({
+                type: "select",
+                name: "action",
+                message: `Translation: "${item.translation}"\nSource:      "${item.source}"\nAction:`,
+                choices: [
+                    { title: "✅ Approve", value: "approve" },
+                    { title: "✏️  Edit", value: "edit" },
+                    { title: "⏭️  Skip", value: "skip" },
+                    { title: "🚪 Exit", value: "exit" },
+                ],
+                initial: 0,
+            });
+            if (response.action === "exit")
+                break;
+            await this.handleAction(response.action, item);
+        }
+        this.saveDecisions();
+    }
+    async handleAction(action, item) {
+        switch (action) {
+            case "approve":
+                this.decisions.accepted.push(item);
+                break;
+            case "edit":
+                const editResponse = await prompts({
+                    type: "text",
+                    name: "newTranslation",
+                    message: "Enter new translation:",
+                    initial: item.translation,
+                });
+                if (editResponse.newTranslation) {
+                    item.translation = editResponse.newTranslation;
+                    item.edited = true;
+                    this.decisions.edited.push(item);
+                }
+                else {
+                    this.decisions.skipped.push(item);
+                }
+                break;
+            case "skip":
+                this.decisions.skipped.push(item);
+                break;
+        }
+    }
+    saveDecisions() {
+        // Reuse existing ReviewCommand logic or implement save/apply logic here
+        // For now, let's save to a decision file that ReviewCommand can pick up or apply directly
+        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(`\n✅ Review complete! Decisions saved to ${decisionsFile}`);
+        console.log(`Run 'locai review --apply' to apply changes to files.`);
+        // Note: The existing CLI 'review' command applies immediately in its class.
+        // We might want to trigger apply here or ensuring ReviewCommand is used.
+    }
+}

package/dist/commands/review.d.ts

@@ -1,7 +1,3 @@
-/**
- * Interactive Review Command.
- * Allows manual review of low-confidence translations.
- */
 interface ReviewItem {
     key: string;
     language: string;
@@ -28,7 +24,6 @@ interface ReviewCommandConfig {
 declare class ReviewCommand {
     private config;
     private reviewQueue;
-    private currentIndex;
     private decisions;
     /**
      * Initialize ReviewCommand.
@@ -44,35 +39,10 @@ declare class ReviewCommand {
      * Start interactive review session.
      */
     startReview(): Promise<void>;
-    /**
-     * 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.
-     */
-    reviewItem(item: ReviewItem, current: number, total: number): Promise<string>;
     /**
      * Handle user action input.
-     * @param {string} action - User action code.
-     * @param {ReviewItem} item - Current item.
-     * @returns {Promise<string>} - Result status.
-     */
-    handleAction(action: string, item: ReviewItem): Promise<string>;
-    /**
-     * Edit translation interactively.
-     * @param {ReviewItem} item - Item to edit.
-     * @returns {Promise<ReviewItem>} - Edited item.
-     */
-    editTranslation(item: ReviewItem): Promise<ReviewItem>;
-    /**
-     * Show help information to the user.
-     */
-    showHelp(): void;
-    /**
-     * Show summary of review session.
      */
-    showSummary(): void;
+    private handleAction;
     /**
      * Save review decisions to disk and apply them.
      */
@@ -88,12 +58,6 @@ declare class ReviewCommand {
      * @param {any} value - Value to set.
      */
     setNestedValue(obj: any, path: string, value: any): void;
-    /**
-     * Get user input from terminal.
-     * @param {string} prompt - Prompt to display.
-     * @returns {Promise<string>} - User input.
-     */
-    getUserInput(prompt: string): Promise<string>;
     /**
      * Export review queue to JSON.
      * @param {string} format - Export format (json or csv).

package/dist/commands/review.js

@@ -1,15 +1,10 @@
-/**
- * Interactive Review Command.
- * Allows manual review of low-confidence translations.
- */
 import fs from "fs";
 import path from "path";
-import readline from "readline";
+import prompts from "prompts";
 import ConfidenceScorer from "../utils/confidence-scorer.js";
 class ReviewCommand {
     config;
     reviewQueue;
-    currentIndex;
     decisions;
     /**
      * Initialize ReviewCommand.
@@ -18,7 +13,6 @@ class ReviewCommand {
     constructor(config) {
         this.config = config;
         this.reviewQueue = [];
-        this.currentIndex = 0;
         this.decisions = {
             accepted: [],
             edited: [],
@@ -40,7 +34,6 @@ class ReviewCommand {
         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) {
@@ -56,159 +49,63 @@ class ReviewCommand {
             return;
         }
         if (this.reviewQueue.length === 0) {
-            console.log("\nNo items need review. All translations meet quality threshold!\n");
+            console.log("No items to review.");
             return;
         }
-        console.log("━".repeat(70));
-        console.log(`Review Queue: ${this.reviewQueue.length} translations need attention`);
-        console.log("━".repeat(70));
+        console.clear();
+        console.log(`\nInteractive Review Mode (${this.reviewQueue.length} items)\n`);
         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") {
+            const progress = `[${i + 1}/${this.reviewQueue.length}]`;
+            console.log(`\n${progress} ${item.language.toUpperCase()} | Key: ${item.key}`);
+            console.log(`Confidence: ${ConfidenceScorer.formatConfidence(item.confidence.score)} (${item.confidence.level})`);
+            const response = await prompts({
+                type: "select",
+                name: "action",
+                message: `Translation: "${item.translation}"\nSource:      "${item.source}"\nAction:`,
+                choices: [
+                    { title: "[Approve]", value: "approve" },
+                    { title: "[Edit]", value: "edit" },
+                    { title: "[Skip]", value: "skip" },
+                    { title: "[Exit]", value: "exit" },
+                ],
+                initial: 0,
+            });
+            if (response.action === "exit")
                 break;
-            }
+            await this.handleAction(response.action, item);
         }
-        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":
+            case "approve":
                 this.decisions.accepted.push(item);
-                console.log("Accepted");
-                return "continue";
+                break;
             case "edit": {
-                const edited = await this.editTranslation(item);
-                this.decisions.edited.push(edited);
-                console.log("Edited and saved");
-                return "continue";
+                const editResponse = await prompts({
+                    type: "text",
+                    name: "newTranslation",
+                    message: "Enter new translation:",
+                    initial: item.translation,
+                });
+                if (editResponse.newTranslation) {
+                    item.translation = editResponse.newTranslation;
+                    item.edited = true;
+                    this.decisions.edited.push(item);
+                }
+                else {
+                    this.decisions.skipped.push(item);
+                }
+                break;
             }
-            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;
+                break;
         }
-        // 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.
@@ -230,7 +127,7 @@ class ReviewCommand {
             },
         };
         fs.writeFileSync(decisionsFile, JSON.stringify(data, null, 2));
-        console.log(`\nDecisions saved to: ${decisionsFile}`);
+        console.log(`\nReview complete! Decisions saved to ${decisionsFile}`);
         // Apply accepted and edited translations
         this.applyDecisions();
     }
@@ -284,23 +181,6 @@ class ReviewCommand {
         }
         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).

package/dist/core/adapters/android-adapter.d.ts

@@ -0,0 +1,12 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for Android XML resources files (strings.xml)
+ */
+export declare class AndroidAdapter implements FileFormatAdapter {
+    extensions: string[];
+    private parser;
+    private builder;
+    constructor();
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>): Promise<string>;
+}

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

@@ -0,0 +1,107 @@
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+/**
+ * Adapter for Android XML resources files (strings.xml)
+ */
+export class AndroidAdapter {
+    extensions = [".xml"];
+    parser;
+    builder;
+    constructor() {
+        this.parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            isArray: (name) => name === "string" || name === "string-array" || name === "item",
+        });
+        this.builder = new XMLBuilder({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            format: true,
+            indentBy: "    ",
+        });
+    }
+    async parse(content) {
+        try {
+            const parsed = this.parser.parse(content);
+            // Extract strings resources
+            const resources = parsed.resources || {};
+            const result = {};
+            // Handle regular strings
+            if (resources.string) {
+                resources.string.forEach((item) => {
+                    const key = item["@_name"];
+                    const value = item["#text"];
+                    if (key) {
+                        result[key] = value || "";
+                    }
+                });
+            }
+            // Handle string arrays (flattened as array_name.index)
+            if (resources["string-array"]) {
+                resources["string-array"].forEach((array) => {
+                    const arrayName = array["@_name"];
+                    if (array.item) {
+                        array.item.forEach((value, index) => {
+                            result[`${arrayName}.${index}`] = value;
+                        });
+                    }
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse Android XML: ${error.message}`);
+        }
+    }
+    async serialize(data) {
+        const resources = {
+            string: [],
+            "string-array": [],
+        };
+        // Collect keys to handle arrays properly
+        const arrays = {};
+        const strings = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (key.includes(".")) {
+                const [arrayName, indexStr] = key.split(".");
+                if (!isNaN(Number(indexStr))) {
+                    if (!arrays[arrayName])
+                        arrays[arrayName] = [];
+                    arrays[arrayName][Number(indexStr)] = value;
+                    continue;
+                }
+            }
+            strings[key] = value;
+        }
+        // Add strings
+        for (const [key, value] of Object.entries(strings)) {
+            resources.string.push({
+                "@_name": key,
+                "#text": value,
+            });
+        }
+        // Add arrays
+        for (const [key, items] of Object.entries(arrays)) {
+            resources["string-array"].push({
+                "@_name": key,
+                item: items.filter((i) => i !== undefined),
+            });
+        }
+        // Sort by name for consistency
+        resources.string.sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        resources["string-array"].sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        if (resources["string-array"].length === 0)
+            delete resources["string-array"];
+        if (resources.string.length === 0)
+            delete resources.string;
+        const xmlObj = {
+            "?xml": {
+                "@_version": "1.0",
+                "@_encoding": "utf-8",
+            },
+            resources: resources,
+        };
+        return this.builder.build(xmlObj);
+    }
+}

package/dist/core/adapters/factory.js

@@ -3,6 +3,8 @@ import { JsonAdapter } from "./json-adapter.js";
 import { YamlAdapter } from "./yaml-adapter.js";
 import { PoAdapter } from "./po-adapter.js";
 import { PropertiesAdapter } from "./properties-adapter.js";
+import { AndroidAdapter } from "./android-adapter.js";
+import { IosAdapter } from "./ios-adapter.js";
 /**
  * Factory class to manage file format adapters
  */
@@ -12,6 +14,8 @@ export class FormatFactory {
         new YamlAdapter(),
         new PoAdapter(),
         new PropertiesAdapter(),
+        new AndroidAdapter(),
+        new IosAdapter(),
     ];
     /**
      * Get adapter for a specific file path

package/dist/core/adapters/ios-adapter.d.ts

@@ -0,0 +1,10 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for iOS .strings files
+ * Format: "KEY" = "VALUE";
+ */
+export declare class IosAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>): Promise<string>;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Adapter for iOS .strings files
+ * Format: "KEY" = "VALUE";
+ */
+export class IosAdapter {
+    extensions = [".strings"];
+    async parse(content) {
+        const result = {};
+        const lines = content.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (!trimmed || trimmed.startsWith("/*") || trimmed.startsWith("//")) {
+                continue;
+            }
+            // Parse "key" = "value";
+            // Handle escaped quotes in value
+            const match = trimmed.match(/^"(.+)"\s*=\s*"(.*)";$/);
+            if (match) {
+                const key = match[1];
+                let value = match[2];
+                // Unescape quotes and newlines if needed
+                value = value.replace(/\\"/g, '"').replace(/\\n/g, "\n");
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    async serialize(data) {
+        let output = "";
+        // Sort keys for deterministic output
+        const keys = Object.keys(data).sort();
+        for (const key of keys) {
+            let value = data[key];
+            if (typeof value !== "string") {
+                value = String(value);
+            }
+            // Escape quotes and newlines
+            const safeKey = key; // Keys usually don't have quotes, but simplistic handling
+            const safeValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            output += `"${safeKey}" = "${safeValue}";\n`;
+        }
+        return output;
+    }
+}

package/dist/core/provider-factory.js

@@ -1,6 +1,7 @@
 import * as deepseekProvider from "../providers/deepseek.js";
 import * as geminiProvider from "../providers/gemini.js";
 import * as openaiProvider from "../providers/openai.js";
+import * as anthropicProvider from "../providers/anthropic.js";
 import * as dashscopeProvider from "../providers/dashscope.js";
 import * as xaiProvider from "../providers/xai.js";
 import FallbackProvider from "./fallback-provider.js";
@@ -23,6 +24,7 @@ class ProviderFactory {
             dashscope: dashscopeProvider,
             xai: xaiProvider,
             openai: openaiProvider,
+            anthropic: anthropicProvider,
             deepseek: deepseekProvider,
             gemini: geminiProvider,
         };
@@ -100,6 +102,7 @@ class ProviderFactory {
             dashscope: process.env.DASHSCOPE_API_KEY,
             xai: process.env.XAI_API_KEY,
             openai: process.env.OPENAI_API_KEY,
+            anthropic: process.env.ANTHROPIC_API_KEY,
             deepseek: process.env.DEEPSEEK_API_KEY,
             gemini: process.env.GEMINI_API_KEY,
         };
@@ -129,6 +132,7 @@ class ProviderFactory {
             dashscope: "DASHSCOPE_API_KEY",
             xai: "XAI_API_KEY",
             openai: "OPENAI_API_KEY",
+            anthropic: "ANTHROPIC_API_KEY",
             deepseek: "DEEPSEEK_API_KEY",
             gemini: "GEMINI_API_KEY",
         };

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,25 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for Anthropic (Claude) models.
+ */
+declare class AnthropicProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new AnthropicProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    /**
+     * Translate text using Anthropic.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+    chat(messages: any[], options?: ProviderConfig): Promise<string>;
+    extractTranslation(response: any, providerName: string): string;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+declare function chat(messages: any[], options?: ProviderConfig): Promise<string>;
+export { translate, analyze, chat, AnthropicProvider };

package/dist/providers/anthropic.js

@@ -0,0 +1,178 @@
+import axios from "axios";
+import BaseProvider from "./base-provider.js";
+import { getPrompt, getAnalysisPrompt } from "../utils/prompt-templates.js";
+import RetryHelper from "../utils/retry-helper.js";
+/**
+ * Provider implementation for Anthropic (Claude) models.
+ */
+class AnthropicProvider extends BaseProvider {
+    client;
+    /**
+     * Create a new AnthropicProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config = {}) {
+        super("anthropic", config);
+        this.client = axios.create({
+            baseURL: "https://api.anthropic.com/v1",
+            headers: {
+                ...this.commonHeaders,
+                "x-api-key": this.getApiKey(),
+                "anthropic-version": "2023-06-01",
+            },
+            timeout: 30000,
+            maxRedirects: 0,
+            validateStatus: (status) => status < 500,
+        });
+    }
+    getApiKey() {
+        return process.env.ANTHROPIC_API_KEY;
+    }
+    getEndpoint() {
+        return "/messages";
+    }
+    /**
+     * Translate text using Anthropic.
+     */
+    async translate(text, sourceLang, targetLang, options = {}) {
+        this.validateRequest(text, sourceLang, targetLang);
+        // Prioritize user config > options config > default model
+        // Anthropic models: claude-3-5-sonnet-latest, claude-3-5-haiku-latest, claude-3-opus-latest
+        const config = this.getConfig(options.apiConfig?.anthropic);
+        const model = config.model || "claude-haiku-4-5-20251001";
+        const promptData = getPrompt("anthropic", sourceLang, targetLang, text, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: model,
+                    ...promptData, // Contains { system: "...", messages: [...] }
+                    max_tokens: config.maxTokens || 4096,
+                    temperature: config.temperature,
+                });
+                this.validateResponse(response, this.name);
+                const translation = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(translation);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.retryOptions?.maxRetries || 2,
+            initialDelay: options.retryOptions?.initialDelay || 1000,
+            context: "Anthropic Provider",
+            logContext: {
+                source: sourceLang,
+                target: targetLang,
+            },
+        });
+    }
+    async analyze(prompt, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "claude-3-5-sonnet-latest",
+            temperature: options.temperature || 0.2,
+            maxTokens: options.maxTokens || 1000,
+        });
+        const promptData = getAnalysisPrompt("anthropic", prompt, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model,
+                    ...promptData,
+                    max_tokens: config.maxTokens,
+                    temperature: config.temperature,
+                });
+                this.validateResponse(response, this.name);
+                const result = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(result);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "Anthropic Provider Analysis",
+        });
+    }
+    async chat(messages, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "claude-3-5-sonnet-latest",
+            temperature: options.temperature || 0.3,
+            maxTokens: options.maxTokens || 4096,
+        });
+        // Anthropic requires system prompt to be top-level, separate from messages array
+        // Note: This simple implementation assumes messages passed in might be mixed.
+        // Ideally, the caller should separate system prompt, but we can do a quick check here.
+        let systemPrompt = undefined;
+        const cleanMessages = messages.filter((msg) => {
+            if (msg.role === "system") {
+                systemPrompt = msg.content;
+                return false;
+            }
+            return true;
+        });
+        return RetryHelper.withRetry(async () => {
+            try {
+                const payload = {
+                    model: config.model,
+                    messages: cleanMessages,
+                    max_tokens: config.maxTokens,
+                    temperature: config.temperature,
+                };
+                if (systemPrompt) {
+                    payload.system = systemPrompt;
+                }
+                const response = await this.client.post(this.getEndpoint(), payload);
+                this.validateResponse(response, this.name);
+                const result = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(result);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "Anthropic Provider Chat",
+        });
+    }
+    // Override extractTranslation to handle Anthropic's specific response structure
+    extractTranslation(response, providerName) {
+        // Check for error response first
+        if (response.error) {
+            const errorMsg = response.error.message || response.error.error || JSON.stringify(response.error);
+            throw new Error(`api: ${providerName} - ${errorMsg}`);
+        }
+        // Anthropic format: { content: [{ type: 'text', text: '...' }] }
+        if (response.content && Array.isArray(response.content) && response.content.length > 0) {
+            const textBlock = response.content.find((block) => block.type === "text");
+            if (textBlock && textBlock.text) {
+                return textBlock.text.trim();
+            }
+        }
+        // Fallback to base implementation for other structures (though unlikely for Anthropic)
+        return super.extractTranslation(response, providerName);
+    }
+}
+// Lazy singleton - created on first use
+let anthropicProvider = null;
+function getProvider() {
+    if (!anthropicProvider) {
+        anthropicProvider = new AnthropicProvider();
+    }
+    return anthropicProvider;
+}
+// Export both class and legacy functions
+async function translate(text, sourceLang, targetLang, options = {}) {
+    return getProvider().translate(text, sourceLang, targetLang, options);
+}
+async function analyze(prompt, options = {}) {
+    return getProvider().analyze(prompt, options);
+}
+async function chat(messages, options = {}) {
+    return getProvider().chat(messages, options);
+}
+export { translate, analyze, chat, AnthropicProvider };

package/dist/providers/gemini.js

@@ -27,7 +27,7 @@ class GeminiProvider extends BaseProvider {
         return process.env.GEMINI_API_KEY;
     }
     getEndpoint(model) {
-        return `/models/${model || "gemini-2.0-flash-exp"}:generateContent`;
+        return `/models/${model || "gemini-3-flash"}:generateContent`;
     }
     /**
      * Translate text using Gemini.
@@ -35,7 +35,7 @@ class GeminiProvider extends BaseProvider {
     async translate(text, sourceLang, targetLang, options = {}) {
         this.validateRequest(text, sourceLang, targetLang);
         const config = this.getConfig(options.apiConfig?.gemini);
-        const model = config.model || "gemini-2.0-flash-exp";
+        const model = config.model || "gemini-3-flash";
         const apiKey = this.getApiKey();
         if (!apiKey) {
             throw new Error("GEMINI_API_KEY environment variable not found");
@@ -77,7 +77,7 @@ class GeminiProvider extends BaseProvider {
     }
     async analyze(prompt, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gemini-2.0-flash-exp",
+            model: options.model || "gemini-3-flash",
             temperature: options.temperature || 0.2,
             maxTokens: options.maxTokens || 1000,
         });

package/dist/utils/error-helper.js

@@ -321,6 +321,7 @@ class ErrorHelper {
             deepseek: "DEEPSEEK_API_KEY",
             dashscope: "DASHSCOPE_API_KEY",
             xai: "XAI_API_KEY",
+            anthropic: "ANTHROPIC_API_KEY",
         };
         return envMap[provider?.toLowerCase()] || `${provider?.toUpperCase()}_API_KEY`;
     }
@@ -334,6 +335,7 @@ class ErrorHelper {
             deepseek: "https://platform.deepseek.com/api-keys",
             dashscope: "https://dashscope.console.aliyun.com/",
             xai: "https://console.x.ai/",
+            anthropic: "https://console.anthropic.com/settings/keys",
         };
         return urlMap[provider?.toLowerCase()] || "provider console";
     }
@@ -341,7 +343,7 @@ class ErrorHelper {
      * Suggest fallback provider
      */
     static _suggestFallbackProvider(currentProvider) {
-        const fallbackOrder = ["openai", "gemini", "deepseek", "dashscope", "xai"];
+        const fallbackOrder = ["openai", "anthropic", "gemini", "deepseek", "dashscope", "xai"];
         const current = currentProvider?.toLowerCase();
         const index = fallbackOrder.indexOf(current);
         if (index === -1 || index === fallbackOrder.length - 1) {

package/dist/utils/input-validator.js

@@ -5,7 +5,14 @@
 import path from "path";
 class InputValidator {
     static LANGUAGE_CODE_PATTERN = /^[a-z]{2}(-[a-z]{2})?$/;
-    static VALID_PROVIDERS = ["dashscope", "xai", "openai", "deepseek", "gemini"];
+    static VALID_PROVIDERS = [
+        "dashscope",
+        "xai",
+        "openai",
+        "deepseek",
+        "gemini",
+        "anthropic",
+    ];
     static MAX_TEXT_LENGTH = 10000;
     static MAX_KEY_LENGTH = 500;
     static MAX_PATH_LENGTH = 1000;

package/dist/utils/prompt-templates.js

@@ -236,6 +236,15 @@ Original Text: "${text}"`,
             },
         ],
     }),
+    anthropic: (sourceLang, targetLang, text, options) => ({
+        system: baseTranslationPromptTemplate(sourceLang, targetLang, text, options),
+        messages: [
+            {
+                role: "user",
+                content: text,
+            },
+        ],
+    }),
     deepseek: (sourceLang, targetLang, text, options) => ({
         messages: [
             {
@@ -317,6 +326,15 @@ const analysisPrompts = {
             max_tokens: options.maxTokens || 1000,
         },
     }),
+    anthropic: (text, options) => ({
+        system: "You are a context analysis assistant that helps identify the category and context of text.",
+        messages: [
+            {
+                role: "user",
+                content: baseAnalysisPromptTemplate(text, options),
+            },
+        ],
+    }),
     deepseek: (text, options) => ({
         messages: [
             {

package/dist/utils/rate-limiter.js

@@ -59,6 +59,12 @@ class RateLimiter {
                 lastReset: performance.now(),
                 maxConcurrent: 8,
             },
+            anthropic: {
+                requestsPerMinute: 50,
+                currentRequests: 0,
+                lastReset: performance.now(),
+                maxConcurrent: 5,
+            },
         };
         this._processingLocks = {};
         Object.keys(this.providers).forEach((provider) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "locai",
-	"version": "2.1.3",
+	"version": "2.3.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
 	"types": "dist/core/orchestrator.d.ts",
@@ -69,17 +69,20 @@
 		"commander": "^14.0.2",
 		"dot-properties": "^1.1.0",
 		"dotenv": "^17.2.3",
+		"fast-xml-parser": "^5.3.3",
 		"gettext-parser": "^8.0.0",
 		"jiti": "^2.6.1",
 		"js-yaml": "^4.1.1",
 		"lru-cache": "^11.2.2",
 		"p-limit": "^7.2.0",
+		"prompts": "^2.4.2",
 		"vectra": "^0.11.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.39.1",
 		"@types/js-yaml": "^4.0.9",
 		"@types/node": "^25.0.1",
+		"@types/prompts": "^2.4.9",
 		"@vitest/coverage-v8": "^4.0.15",
 		"eslint": "^9.39.1",
 		"eslint-config-prettier": "^10.1.8",