locai 2.6.1 → 2.7.0

package/dist/providers/base-provider.js

@@ -2,7 +2,9 @@
  * Base class for translation providers
  */
 import ErrorHelper from "../utils/error-helper.js";
-import ConfidenceScorer from "../utils/confidence-scorer.js";
+function isApiErrorLike(error) {
+    return typeof error === "object" && error !== null;
+}
 class BaseProvider {
     name;
     config;
@@ -24,10 +26,10 @@ class BaseProvider {
     async translate(text, sourceLang, targetLang, _options = {}) {
         throw new Error(`translate method must be implemented by ${this.name} provider`);
     }
-    async analyze(prompt, options = {}) {
+    async analyze(_prompt, _options = {}) {
         throw new Error(`analyze method must be implemented by ${this.name} provider if supported`);
     }
-    async chat(messages, options = {}) {
+    async chat(_messages, _options = {}) {
         throw new Error(`chat method must be implemented by ${this.name} provider if supported`);
     }
     getApiKey() {
@@ -56,19 +58,20 @@ class BaseProvider {
         }
         return true;
     }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     handleApiError(error, providerName) {
-        if (error.response) {
-            const status = error.response.status;
-            const apiMessage = error.response.data?.error?.message || error.response.data?.message || null;
+        const apiErrorLike = isApiErrorLike(error) ? error : {};
+        if (apiErrorLike.response) {
+            const { response } = apiErrorLike;
+            const status = response.status;
+            const apiMessage = response.data?.error?.message || response.data?.message || null;
             // Rate limit error
             if (status === 429) {
-                const retryAfter = error.response.headers?.["retry-after"] || 60;
-                const limit = error.response.headers?.["x-ratelimit-limit"];
-                const remaining = error.response.headers?.["x-ratelimit-remaining"];
+                const retryAfter = response.headers?.["retry-after"] || 60;
+                const limit = response.headers?.["x-ratelimit-limit"];
+                const remaining = response.headers?.["x-ratelimit-remaining"];
                 throw ErrorHelper.rateLimitError(providerName, {
                     limit,
-                    current: limit ? limit - remaining : null,
+                    current: limit ? Number(limit) - Number(remaining) : null,
                     retryAfter,
                     statusCode: status,
                 });
@@ -91,19 +94,18 @@ class BaseProvider {
             throw apiError;
         }
         // Network errors
-        if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+        if (apiErrorLike.code === "ECONNREFUSED" || apiErrorLike.code === "ENOTFOUND") {
             throw ErrorHelper.networkError(providerName);
         }
         // Timeout errors
-        if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
-            throw ErrorHelper.timeoutError(providerName, error.config?.timeout);
+        if (apiErrorLike.code === "ECONNABORTED" || apiErrorLike.code === "ETIMEDOUT") {
+            throw ErrorHelper.timeoutError(providerName, apiErrorLike.config?.timeout);
         }
         // Unknown errors - preserve original for debugging
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const unknownError = new Error(`${providerName}: ${error.message}`);
-        unknownError.code = "ERR_UNKNOWN";
-        unknownError.originalError = error;
-        throw unknownError;
+        throw Object.assign(new Error(`${providerName}: ${apiErrorLike.message}`), {
+            code: "ERR_UNKNOWN",
+            originalError: error,
+        });
     }
     generatePrompt(text, sourceLang, targetLang, options = {}) {
         const context = options.detectedContext;
@@ -145,7 +147,6 @@ class BaseProvider {
             endpoint: this.getEndpoint(),
         };
     }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     extractTranslation(response, providerName) {
         // Check for error response first
         if (response.error) {
@@ -171,7 +172,7 @@ class BaseProvider {
         else if (response.text) {
             translation = response.text.trim();
         }
-        else if (response.content) {
+        else if (typeof response.content === "string" && response.content) {
             translation = response.content.trim();
         }
         else if (response.data &&
@@ -191,31 +192,6 @@ class BaseProvider {
         }
         return translation;
     }
-    /**
-     * Extract translation with confidence score
-     */
-    extractTranslationWithConfidence(
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-    response, providerName, sourceText, sourceLang, targetLang, category = "general") {
-        const translation = this.extractTranslation(response, providerName);
-        // Extract AI confidence from response
-        const aiConfidence = ConfidenceScorer.extractAIConfidence(response, providerName);
-        // Calculate comprehensive confidence score
-        const confidenceResult = ConfidenceScorer.calculateConfidence({
-            aiConfidence,
-            sourceText,
-            translation,
-            sourceLang,
-            targetLang,
-            provider: providerName,
-            category,
-        });
-        return {
-            translation,
-            confidence: confidenceResult,
-            rawResponse: response,
-        };
-    }
     sanitizeTranslation(translation) {
         if (!translation || typeof translation !== "string") {
             throw new Error("Invalid translation format");

package/dist/providers/dashscope.js

@@ -22,7 +22,6 @@ class DashScopeProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
         // Generation client for analysis
         this.generationClient = axios.create({
@@ -33,7 +32,6 @@ class DashScopeProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {

package/dist/providers/deepseek.js

@@ -21,7 +21,6 @@ class DeepSeekProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {

package/dist/providers/gemini.js

@@ -20,7 +20,6 @@ class GeminiProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {

package/dist/providers/openai.d.ts

@@ -1,4 +1,4 @@
-import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+import BaseProvider, { ChatMessage, ProviderConfig, TranslateOptions } from "./base-provider.js";
 /**
  * Provider implementation for OpenAI (GPT) models.
  */
@@ -16,13 +16,13 @@ declare class OpenAIProvider extends BaseProvider {
      */
     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>;
+    chat(messages: ChatMessage[], options?: ProviderConfig): Promise<string>;
     embed(text: string, options?: ProviderConfig): Promise<number[]>;
     embedBatch(texts: string[], options?: ProviderConfig): Promise<number[][]>;
 }
 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>;
+declare function chat(messages: ChatMessage[], options?: ProviderConfig): Promise<string>;
 declare function embed(text: string, options?: ProviderConfig): Promise<number[]>;
 declare function embedBatch(texts: string[], options?: ProviderConfig): Promise<number[][]>;
 export { translate, analyze, chat, embed, embedBatch, OpenAIProvider };

package/dist/providers/openai.js

@@ -21,7 +21,6 @@ class OpenAIProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {

package/dist/providers/xai.js

@@ -21,7 +21,6 @@ class XAIProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {

package/dist/services/embedding-provider.js

@@ -26,7 +26,8 @@ export class EmbeddingProvider {
             return [];
         }
         catch (error) {
-            console.error(`Failed to generate embedding: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to generate embedding: ${message}`);
             return [];
         }
     }
@@ -43,7 +44,8 @@ export class EmbeddingProvider {
             return [];
         }
         catch (error) {
-            console.error(`Failed to generate batch embeddings: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to generate batch embeddings: ${message}`);
             return [];
         }
     }

package/dist/services/language-processor.d.ts

@@ -1,18 +1,20 @@
+import { FlatTranslations } from "../utils/object-transformer.js";
 import Orchestrator from "../core/orchestrator.js";
+import { StateComparison } from "../utils/state-manager.js";
 import { TranslationOptions, GlobalStats, LanguageProcessResult } from "../types/index.js";
 export declare class LanguageProcessor {
     /**
      * Process a single language translation.
      * @param {string} targetLang - Target language code.
      * @param {string} sourceFile - Path to source file.
-     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {FlatTranslations} flattenedSource - Flattened source content.
      * @param {Orchestrator} orchestrator - Orchestrator instance.
      * @param {TranslationOptions} options - Translation options.
      * @param {GlobalStats} globalStats - Global statistics object.
-     * @param {any} comparison - State comparison result.
+     * @param {Pick<StateComparison, "newKeys" | "modifiedKeys">} comparison - State comparison result.
      * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
      */
-    static processLanguage(targetLang: string, sourceFile: string, flattenedSource: Record<string, any>, orchestrator: Orchestrator, options: TranslationOptions, globalStats: GlobalStats, comparison: any): Promise<LanguageProcessResult>;
+    static processLanguage(targetLang: string, sourceFile: string, flattenedSource: FlatTranslations, orchestrator: Orchestrator, options: TranslationOptions, globalStats: GlobalStats, comparison: Pick<StateComparison, "newKeys" | "modifiedKeys">): Promise<LanguageProcessResult>;
     /**
      * Check if text only contains placeholders and whitespace.
      * @param {string} text - Text to check.

package/dist/services/language-processor.js

@@ -2,6 +2,7 @@ import path from "path";
 import { FileManager } from "../utils/file-manager.js";
 import ObjectTransformer from "../utils/object-transformer.js";
 import InputValidator from "../utils/input-validator.js";
+import { targetLocaleFile } from "../utils/locale-paths.js";
 import uiManager from "../utils/ui-manager.js";
 import statisticsManager from "../utils/statistics-manager.js";
 export class LanguageProcessor {
@@ -9,11 +10,11 @@ export class LanguageProcessor {
      * Process a single language translation.
      * @param {string} targetLang - Target language code.
      * @param {string} sourceFile - Path to source file.
-     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {FlatTranslations} flattenedSource - Flattened source content.
      * @param {Orchestrator} orchestrator - Orchestrator instance.
      * @param {TranslationOptions} options - Translation options.
      * @param {GlobalStats} globalStats - Global statistics object.
-     * @param {any} comparison - State comparison result.
+     * @param {Pick<StateComparison, "newKeys" | "modifiedKeys">} comparison - State comparison result.
      * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
      */
     static async processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison) {
@@ -42,25 +43,9 @@ export class LanguageProcessor {
             let finalStatus = null;
             let savedMessage = undefined;
             statisticsManager.initLanguageStats(safeTargetLang);
-            const sourceDir = path.dirname(sourceFile);
-            // Detect structure based on source file name
-            const isNestedStructure = path.basename(sourceFile) === "translation.json";
-            let targetPath;
-            if (isNestedStructure) {
-                // Nested: locales/tr/translation.json
-                // We assume sourceDir ends with the language code (e.g. .../en)
-                // So we need to go up one level and then into target lang
-                const localesRoot = path.dirname(sourceDir);
-                const targetDir = path.join(localesRoot, safeTargetLang);
-                // Ensure target directory exists for nested structure
-                await FileManager.ensureDir(targetDir);
-                targetPath = path.join(targetDir, "translation.json");
-            }
-            else {
-                // Flat: locales/tr.json
-                const safeTargetFilename = `${safeTargetLang}.json`;
-                targetPath = InputValidator.createSafeFilePath(sourceDir, safeTargetFilename);
-            }
+            // Same layout as the source: locales/tr/translation.json or locales/tr.json
+            const targetPath = targetLocaleFile(sourceFile, safeTargetLang);
+            await FileManager.ensureDir(path.dirname(targetPath));
             let targetContent = {};
             try {
                 targetContent = await FileManager.readJSON(targetPath);
@@ -70,12 +55,13 @@ export class LanguageProcessor {
                 }
             }
             catch (err) {
-                if (err.code === "ENOENT") {
+                if (err instanceof Error && "code" in err && err.code === "ENOENT") {
                     await uiManager.log(`\ud83c\udd95 Creating new translation file for ${safeTargetLang}`);
                 }
                 else {
                     if (options.debug) {
-                        console.warn(`Error reading ${targetPath}: ${err.message}, using empty object`);
+                        const message = err instanceof Error ? err.message : String(err);
+                        console.warn(`Error reading ${targetPath}: ${message}, using empty object`);
                     }
                 }
                 targetContent = {};
@@ -88,20 +74,24 @@ export class LanguageProcessor {
                 }
             }
             catch (err) {
-                console.warn(`Error flattening target content: ${err.message}, using empty object`);
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(`Error flattening target content: ${message}, using empty object`);
                 flattenedTarget = {};
             }
             const missingKeys = [];
             let hasPlaceholderOnlyChanges = false;
-            for (const [key, sourceText] of Object.entries(flattenedSource)) {
+            for (const [key, sourceValue] of Object.entries(flattenedSource)) {
+                let sourceText;
                 try {
                     InputValidator.validateKey(key, "translation key");
-                    InputValidator.validateText(sourceText, "source text");
+                    sourceText = InputValidator.validateText(sourceValue, "source text");
                 }
                 catch (keyError) {
-                    await uiManager.log(`\u26a0\ufe0f Skipping invalid key/text: ${keyError.message}`);
+                    const message = keyError instanceof Error ? keyError.message : String(keyError);
+                    await uiManager.log(`\u26a0\ufe0f Skipping invalid key/text: ${message}`);
                     globalStats.languages[safeTargetLang].failed++;
                     globalStats.failed++;
+                    globalStats.failedKeys.push(key);
                     continue;
                 }
                 globalStats.languages[safeTargetLang].processed++;
@@ -153,12 +143,10 @@ export class LanguageProcessor {
                     }
                 }
                 catch (err) {
-                    console.error(`Error processing translations for ${safeTargetLang}: ${err.message}`);
+                    const message = err instanceof Error ? err.message : String(err);
+                    console.error(`Error processing translations for ${safeTargetLang}: ${message}`);
+                    // Counted below: every missing key without a valid result has failed.
                     results = [];
-                    if (globalStats.languages[safeTargetLang]) {
-                        globalStats.languages[safeTargetLang].failed += missingKeys.length;
-                        globalStats.failed += missingKeys.length;
-                    }
                 }
             }
             else {
@@ -173,19 +161,20 @@ export class LanguageProcessor {
                 }
             }
             catch (err) {
-                console.warn(`Error getting orchestrator status: ${err.message}`);
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(`Error getting orchestrator status: ${message}`);
             }
             let validResults = [];
             try {
                 validResults = results.filter((result) => result && result.success === true);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 validResults = validResults.filter((result) => result.key &&
                     typeof result.key === "string" &&
                     result.translated &&
                     typeof result.translated === "string");
             }
             catch (err) {
-                console.warn(`Error filtering results: ${err.message}`);
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(`Error filtering results: ${message}`);
                 validResults = [];
             }
             if (validResults.length > 0) {
@@ -195,16 +184,21 @@ export class LanguageProcessor {
                     }
                 });
             }
+            // Every missing key without a valid result failed, whether or not anything is written.
+            const translatedKeys = new Set(validResults.map((result) => result.key));
+            const failedKeys = missingKeys
+                .map((item) => item.key)
+                .filter((key) => !translatedKeys.has(key));
+            globalStats.total += validResults.length + failedKeys.length;
+            globalStats.success += validResults.length;
+            globalStats.failed += failedKeys.length;
+            globalStats.failedKeys.push(...failedKeys);
+            globalStats.languages[safeTargetLang].added += validResults.length;
+            globalStats.languages[safeTargetLang].failed += failedKeys.length;
             const hasChangesToSave = validResults.length > 0 || hasPlaceholderOnlyChanges;
             if (hasChangesToSave) {
                 const unflattened = ObjectTransformer.unflatten(flattenedTarget);
                 await FileManager.writeJSON(targetPath, unflattened);
-                globalStats.total += validResults.length;
-                globalStats.success += validResults.length;
-                globalStats.failed += results.length - validResults.length;
-                globalStats.languages[safeTargetLang].added += validResults.length;
-                globalStats.languages[safeTargetLang].failed +=
-                    results.length - validResults.length;
                 validResults.forEach((result) => {
                     if (result.context) {
                         const category = result.context.category || "general";
@@ -227,9 +221,10 @@ export class LanguageProcessor {
             return { status: finalStatus, savedMessage };
         }
         catch (error) {
-            const safeError = error.message.includes("outside working directory")
+            const message = error instanceof Error ? error.message : String(error);
+            const safeError = message.includes("outside working directory")
                 ? "Invalid file path detected"
-                : error.message;
+                : message;
             await uiManager.log(`\n\u274c Error processing ${targetLang}: ${safeError}`);
             if (globalStats.languages[targetLang]) {
                 globalStats.languages[targetLang].error = safeError;

package/dist/services/source-analyzer.d.ts

@@ -10,5 +10,29 @@ export declare class SourceCodeAnalyzer {
     private processFile;
     private processCallExpression;
     private extractContext;
+    /**
+     * The component the call is in: the nearest enclosing function, class or function-valued
+     * variable whose name starts with an uppercase letter, otherwise the nearest one of any name.
+     * A variable counts only when the call is inside a function in its initializer
+     * (`const Dialog = () => ...`), so `const label = t("key")` does not name a component.
+     */
+    private findComponent;
+    /**
+     * The JSX element the text belongs to: the one whose attribute holds the call
+     * (`<Button title={t("key")} />`) or whose child it is (`<Button>{t("key")}</Button>`).
+     * A call inside a nested function (`onClick={() => alert(t("key"))}`) belongs to none.
+     */
+    private findJsxElement;
+    /**
+     * Comments about the call, nearest first: comments right above the call's expression, JSX
+     * attribute, JSX element or statement, `{/* ... *\/}` comments right before its JSX element,
+     * and the comment above its component. Tooling directives are left out.
+     */
+    private getComments;
+    /**
+     * The code around the call with comments removed: the largest of the call, its enclosing
+     * expressions and its statement that fits in MAX_SNIPPET_LENGTH characters.
+     */
+    private getSnippet;
     getContext(key: string): CodeContext | undefined;
 }