locai 2.6.2 → 2.7.0

package/dist/utils/state-manager.d.ts

@@ -1,8 +1,8 @@
+import type { FlatTranslations, FlatTranslationValue } from "./object-transformer.js";
 export interface StateOptions {
     enabled?: boolean;
     stateFileName?: string;
     stateDir?: string;
-    [key: string]: any;
 }
 export interface StateComparison {
     deletedKeys: string[];
@@ -29,7 +29,7 @@ declare class StateManager {
     /**
      * Generate a SHA-256 hash for given text content
      */
-    _generateHash(text: string | object): string;
+    _generateHash(text: FlatTranslationValue): string;
     /**
      * Get the full path to the state file
      */
@@ -45,7 +45,16 @@ declare class StateManager {
     /**
      * Generate state object from source content by creating hashes for each key
      */
-    generateStateFromSource(sourceContent: Record<string, string>): Record<string, string>;
+    generateStateFromSource(sourceContent: FlatTranslations): Record<string, string>;
+    /**
+     * The state to save after a run: the current source hashes, except that keys whose
+     * translation did not finish keep their previous hash (or stay absent if they are new),
+     * so the next run still sees them as changed and translates them again.
+     * @param {Record<string, string>} previousState - State loaded at the start of the run.
+     * @param {Record<string, string>} currentState - Hashes of the current source.
+     * @param {Iterable<string>} unfinishedKeys - Keys that failed or were not processed.
+     */
+    stateAfterRun(previousState: Record<string, string>, currentState: Record<string, string>, unfinishedKeys: Iterable<string>): Record<string, string>;
     /**
      * Compare two states and identify changes
      */

package/dist/utils/state-manager.js

@@ -1,5 +1,5 @@
 import crypto from "crypto";
-import { FileManager } from "./file-manager.js"; // Note: Changed named import to default import based on file-manager migration
+import { FileManager } from "./file-manager.js";
 import path from "path";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -49,10 +49,12 @@ class StateManager {
         }
         catch (error) {
             // State file doesn't exist or is corrupted - return empty state
-            if (error.message.includes("File read error") || error.code === "ENOENT") {
+            const message = error instanceof Error ? error.message : String(error);
+            const code = error instanceof Error && "code" in error ? error.code : undefined;
+            if (message.includes("File read error") || code === "ENOENT") {
                 return {};
             }
-            throw new Error(`Failed to load state: ${error.message}`);
+            throw new Error(`Failed to load state: ${message}`);
         }
     }
     /**
@@ -64,20 +66,22 @@ class StateManager {
             // Ensure state directory exists
             const stateDir = path.dirname(stateFilePath);
             await FileManager.ensureDir(stateDir);
+            const packageJson = JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8"));
             // Save state with metadata
             const stateWithMetadata = {
                 ...state,
                 _metadata: {
                     lastUpdated: new Date().toISOString(),
                     version: "1.0.0",
-                    toolVersion: JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8")).version,
+                    toolVersion: packageJson.version,
                 },
             };
             await FileManager.writeJSON(stateFilePath, stateWithMetadata);
             return true;
         }
         catch (error) {
-            throw new Error(`Failed to save state: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to save state: ${message}`);
         }
     }
     /**
@@ -91,6 +95,26 @@ class StateManager {
         }
         return state;
     }
+    /**
+     * The state to save after a run: the current source hashes, except that keys whose
+     * translation did not finish keep their previous hash (or stay absent if they are new),
+     * so the next run still sees them as changed and translates them again.
+     * @param {Record<string, string>} previousState - State loaded at the start of the run.
+     * @param {Record<string, string>} currentState - Hashes of the current source.
+     * @param {Iterable<string>} unfinishedKeys - Keys that failed or were not processed.
+     */
+    stateAfterRun(previousState, currentState, unfinishedKeys) {
+        const state = { ...currentState };
+        for (const key of unfinishedKeys) {
+            if (key in previousState) {
+                state[key] = previousState[key];
+            }
+            else {
+                delete state[key];
+            }
+        }
+        return state;
+    }
     /**
      * Compare two states and identify changes
      */
@@ -151,11 +175,12 @@ class StateManager {
             return true;
         }
         catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
             // File doesn't exist - that's fine
-            if (error.message.includes("ENOENT")) {
+            if (message.includes("ENOENT")) {
                 return true;
             }
-            throw new Error(`Failed to cleanup state: ${error.message}`);
+            throw new Error(`Failed to cleanup state: ${message}`);
         }
     }
 }

package/dist/utils/statistics-manager.d.ts

@@ -1,6 +1,7 @@
 /**
  * Statistics manager to track translation progress and metrics
  */
+import type Orchestrator from "../core/orchestrator.js";
 export interface GlobalStats {
     total: number;
     byCategory: Record<string, number>;
@@ -11,10 +12,12 @@ export interface GlobalStats {
     totalTime: number;
     success: number;
     failed: number;
+    /** Keys that failed in at least one language (may repeat across languages). */
+    failedKeys: string[];
     skipped: number;
     languages: Record<string, LanguageStats>;
     startTime: string;
-    orchestrators: any[];
+    orchestrators: Orchestrator[];
 }
 export interface LanguageStats {
     processed: number;
@@ -22,7 +25,14 @@ export interface LanguageStats {
     skipped: number;
     failed: number;
     timeMs: number;
+    /** Set when the language could not be processed at all. */
+    error?: string;
 }
+/** Whether a run had failures: keys that were not translated, or languages that errored. */
+export declare const runFailures: (stats: Pick<GlobalStats, "failed" | "languages">) => {
+    failedTranslations: number;
+    failedLanguages: string[];
+};
 export declare class StatisticsManager {
     private stats;
     constructor();

package/dist/utils/statistics-manager.js

@@ -1,6 +1,13 @@
 /**
  * Statistics manager to track translation progress and metrics
  */
+/** Whether a run had failures: keys that were not translated, or languages that errored. */
+export const runFailures = (stats) => ({
+    failedTranslations: stats.failed,
+    failedLanguages: Object.entries(stats.languages)
+        .filter(([, language]) => language.error)
+        .map(([code]) => code),
+});
 export class StatisticsManager {
     stats;
     constructor() {
@@ -17,6 +24,7 @@ export class StatisticsManager {
             totalTime: 0,
             success: 0,
             failed: 0,
+            failedKeys: [],
             skipped: 0,
             languages: {},
             startTime: new Date().toISOString(),

package/dist/utils/ui-manager.d.ts

@@ -1,3 +1,4 @@
+import type { LanguageProcessResult } from "../types/index.js";
 import { GlobalStats } from "./statistics-manager.js";
 /**
  * UI Manager for handling CLI output and user interaction
@@ -15,7 +16,7 @@ export declare class UIManager {
     displayGlobalSummary(stats: GlobalStats & {
         totalDuration?: number;
     }, totalLanguages: number): Promise<void>;
-    logBatchResults(batchResults: any[]): Promise<void>;
+    logBatchResults(batchResults: LanguageProcessResult[]): Promise<void>;
 }
 declare const _default: UIManager;
 export default _default;

package/dist/utils/ui-manager.js

@@ -1,3 +1,4 @@
+import { runFailures } from "./statistics-manager.js";
 /**
  * UI Manager for handling CLI output and user interaction
  */
@@ -84,7 +85,20 @@ export class UIManager {
         // Clear completion message - only once
         await this.log("\n" + "=".repeat(60));
         const duration = stats.totalDuration || 0;
-        await this.log(`All operations completed successfully in ${duration.toFixed(1)}s`);
+        const { failedTranslations, failedLanguages } = runFailures(stats);
+        if (failedTranslations > 0 || failedLanguages.length > 0) {
+            const parts = [];
+            if (failedTranslations > 0) {
+                parts.push(`${failedTranslations} translation(s) failed`);
+            }
+            if (failedLanguages.length > 0) {
+                parts.push(`could not process: ${failedLanguages.join(", ")}`);
+            }
+            await this.log(`Finished with errors in ${duration.toFixed(1)}s: ${parts.join("; ")}`);
+        }
+        else {
+            await this.log(`All operations completed successfully in ${duration.toFixed(1)}s`);
+        }
         await this.log("=".repeat(60) + "\n");
     }
     async logBatchResults(batchResults) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "locai",
-	"version": "2.6.2",
+	"version": "2.7.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
 	"types": "dist/core/orchestrator.d.ts",
@@ -13,10 +13,10 @@
 		"localize": "./dist/cli.js"
 	},
 	"scripts": {
-		"start": "node dist/core/orchestrator.js",
-		"dev": "tsx src/core/orchestrator.js",
-		"build": "tsc",
-		"typecheck": "tsc --noEmit",
+		"start": "node dist/cli.js",
+		"dev": "tsx src/cli.ts",
+		"build": "tsc -p tsconfig.build.json",
+		"typecheck": "tsc",
 		"lint": "eslint .",
 		"lint:fix": "eslint . --fix",
 		"format": "prettier --write \"**/*.{js,json,md,jsx,ts,tsx,css}\"",
@@ -32,7 +32,8 @@
 		"translation",
 		"l10n",
 		"internationalization",
-		"automation",
+		"json",
+		"i18next",
 		"cli",
 		"llm",
 		"ai",
@@ -43,6 +44,8 @@
 		"gemini",
 		"deepseek",
 		"xai",
+		"dashscope",
+		"qwen",
 		"vector-database",
 		"semantic-search",
 		"developer-tools",
@@ -54,7 +57,7 @@
 		"url": "https://github.com/ahmetenesdur"
 	},
 	"license": "MIT",
-	"description": "Global, AI-Powered Translation CLI for every project.",
+	"description": "CLI that translates JSON locale files with AI providers (OpenAI, Anthropic, Gemini, DeepSeek, xAI, DashScope).",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/ahmetenesdur/locai.git"
@@ -64,12 +67,13 @@
 	},
 	"homepage": "https://github.com/ahmetenesdur/locai#readme",
 	"engines": {
-		"node": ">=14.13.0"
+		"node": "^20.19.0 || >=22.0.0"
 	},
 	"exports": {
 		".": "./dist/core/orchestrator.js",
 		"./orchestrator": "./dist/core/orchestrator.js",
-		"./translator": "./dist/commands/translator.js"
+		"./translator": "./dist/commands/translator.js",
+		"./config": "./dist/config/index.js"
 	},
 	"dependencies": {
 		"axios": "1.13.6",
@@ -100,6 +104,7 @@
 		"std-mocks": "^2.0.0",
 		"tsx": "^4.21.0",
 		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.72.2",
 		"vitest": "^4.1.0"
 	},
 	"files": [

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

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

package/dist/commands/interactive-review.js

@@ -1,109 +0,0 @@
-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/core/pipeline/steps/__tests__/ToneCheckStep.test.d.ts

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

package/dist/core/pipeline/steps/__tests__/ToneCheckStep.test.js

@@ -1,100 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ToneCheckStep } from "../ToneCheckStep.js";
-// Mock ToneVerifier
-vi.mock("../../../../utils/quality/tone-verifier.js", () => {
-    return {
-        ToneVerifier: class {
-            verify = vi.fn();
-        },
-    };
-});
-describe("ToneCheckStep", () => {
-    let step;
-    let mockContext;
-    let mockNext;
-    let mockVerifier;
-    beforeEach(() => {
-        // Reset mocks
-        vi.clearAllMocks();
-        step = new ToneCheckStep({ enabled: true });
-        mockContext = {
-            translatedText: "Sanal Makine",
-            sourceText: "Virtual Machine",
-            sourceLang: "en",
-            targetLang: "tr",
-            options: {
-                styleGuide: {
-                    toneOfVoice: "tech",
-                },
-            },
-            qualityResult: {
-                issues: [],
-            },
-        };
-        mockNext = vi.fn().mockResolvedValue(undefined);
-        // Get the mock instance
-        // @ts-ignore
-        mockVerifier = step.verifier;
-    });
-    it("should skip verification if disabled", async () => {
-        const disabledStep = new ToneCheckStep({ enabled: false });
-        await disabledStep.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).not.toHaveBeenCalled();
-        expect(mockNext).toHaveBeenCalled();
-    });
-    it("should skip verification if no translated text", async () => {
-        mockContext.translatedText = "";
-        await step.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).not.toHaveBeenCalled();
-        expect(mockNext).toHaveBeenCalled();
-    });
-    it("should skip verification if no tone defined", async () => {
-        mockContext.options.styleGuide.toneOfVoice = undefined;
-        await step.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).not.toHaveBeenCalled();
-        expect(mockNext).toHaveBeenCalled();
-    });
-    it("should pass configured provider to verifier", async () => {
-        mockContext.options.styleGuide.toneProvider = "gemini";
-        mockVerifier.verify.mockResolvedValue({ passed: true, score: 10 });
-        await step.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.any(String), expect.any(String), expect.any(String), "gemini", undefined);
-    });
-    it("should pass configured toneProvider and analysis options to verifier", async () => {
-        mockContext.options.styleGuide.toneProvider = "deepseek";
-        mockContext.options.styleGuide.analysisOptions = { temperature: 0.7 };
-        mockVerifier.verify.mockResolvedValue({ passed: true, score: 10 });
-        await step.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.any(String), expect.any(String), expect.any(String), "deepseek", { temperature: 0.7 });
-    });
-    it("should verify and add warning on failure", async () => {
-        mockVerifier.verify.mockResolvedValue({
-            passed: false,
-            score: 5,
-            reasoning: "Too simple",
-        });
-        await step.execute(mockContext, mockNext);
-        expect(mockVerifier.verify).toHaveBeenCalledWith("Virtual Machine", "Sanal Makine", "en", "tr", "tech", undefined, // Default provider
-        undefined // Default options
-        );
-        expect(mockContext.qualityResult.issues.length).toBe(1);
-        expect(mockContext.qualityResult.issues[0].message).toContain("Too simple");
-        expect(mockNext).toHaveBeenCalled();
-    });
-    it("should not add warning on success", async () => {
-        mockVerifier.verify.mockResolvedValue({
-            passed: true,
-            score: 9,
-        });
-        await step.execute(mockContext, mockNext);
-        expect(mockContext.qualityResult.issues.length).toBe(0);
-        expect(mockNext).toHaveBeenCalled();
-    });
-    it("should handle verifier errors gracefully", async () => {
-        mockVerifier.verify.mockRejectedValue(new Error("Network error"));
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        await step.execute(mockContext, mockNext);
-        expect(mockNext).toHaveBeenCalled();
-        consoleSpy.mockRestore();
-    });
-});

package/dist/utils/quality/__tests__/tone-verifier.test.d.ts

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

package/dist/utils/quality/__tests__/tone-verifier.test.js

@@ -1,91 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ToneVerifier } from "../tone-verifier.js";
-import ProviderFactory from "../../../core/provider-factory.js";
-// Mock ProviderFactory
-vi.mock("../../../core/provider-factory.js", () => {
-    const mockProvider = {
-        chat: vi.fn(),
-        analyze: vi.fn(),
-        translate: vi.fn(),
-    };
-    return {
-        default: {
-            getProvider: vi.fn(() => mockProvider),
-            getAvailableProviders: vi.fn(() => ["openai"]),
-        },
-    };
-});
-describe("ToneVerifier", () => {
-    let verifier;
-    let mockProvider;
-    beforeEach(() => {
-        verifier = new ToneVerifier();
-        mockProvider = ProviderFactory.getProvider("openai");
-        vi.clearAllMocks();
-    });
-    it("should use requested provider", async () => {
-        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
-        const result = await verifier.verify("src", "trgt", "en", "es", "formal", "gemini");
-        expect(ProviderFactory.getProvider).toHaveBeenCalledWith("gemini", true);
-    });
-    it("should use openai as default provider", async () => {
-        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
-        await verifier.verify("src", "trgt", "en", "es", "formal");
-        expect(ProviderFactory.getProvider).toHaveBeenCalledWith("openai", true);
-    });
-    it("should pass options to provider", async () => {
-        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
-        const options = { temperature: 0.1 };
-        await verifier.verify("src", "trgt", "en", "es", "formal", "openai", options);
-        expect(mockProvider.chat).toHaveBeenCalledWith(expect.any(Array), options);
-    });
-    it("should initialize provider lazily", async () => {
-        // Mock a valid response to avoid internal error
-        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
-        // Create a new instance effectively
-        const newVerifier = new ToneVerifier();
-        // initialize is private but called by verify
-        await newVerifier.verify("src", "trgt", "en", "es", "formal");
-        expect(ProviderFactory.getProvider).toHaveBeenCalled();
-    });
-    it("should return perfect score when no target tone is provided", async () => {
-        const result = await verifier.verify("src", "trgt", "en", "es", "");
-        expect(result.passed).toBe(true);
-        expect(result.score).toBe(10);
-    });
-    it("should parse valid JSON response from chat", async () => {
-        const mockResponse = JSON.stringify({
-            passed: true,
-            score: 9,
-            reasoning: "Good tone",
-            suggestions: "None",
-        });
-        mockProvider.chat.mockResolvedValue(mockResponse);
-        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
-        expect(result.passed).toBe(true);
-        expect(result.score).toBe(9);
-        expect(result.reasoning).toBe("Good tone");
-    });
-    it("should clean markdown and parse JSON response", async () => {
-        const mockResponse = "```json\n" +
-            JSON.stringify({
-                passed: false,
-                score: 4,
-                reasoning: "Too casual",
-            }) +
-            "\n```";
-        mockProvider.chat.mockResolvedValue(mockResponse);
-        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
-        expect(result.passed).toBe(false);
-        expect(result.score).toBe(4);
-    });
-    it("should fail open (return passed) when provider throws", async () => {
-        mockProvider.chat.mockRejectedValue(new Error("API Error"));
-        const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
-        expect(result.passed).toBe(true);
-        expect(result.score).toBe(0);
-        expect(result.reasoning).toContain("Verification failed");
-        consoleSpy.mockRestore();
-    });
-});