locai 2.6.1 → 2.7.0

package/dist/services/translation-service.js

@@ -2,12 +2,16 @@ import path from "path";
 import { FileManager } from "../utils/file-manager.js";
 import ObjectTransformer from "../utils/object-transformer.js";
 import Orchestrator from "../core/orchestrator.js";
+import ProviderFactory, { NoProviderError } from "../core/provider-factory.js";
+import ConfidenceScorer from "../utils/confidence-scorer.js";
+import { updateReviewQueue } from "../utils/review-queue.js";
 import QualityChecker from "../utils/quality/index.js";
 import StateManager from "../utils/state-manager.js";
 import InputValidator from "../utils/input-validator.js";
+import { targetLocaleFile } from "../utils/locale-paths.js";
 import gracefulShutdown from "../utils/graceful-shutdown.js";
 import uiManager from "../utils/ui-manager.js";
-import statisticsManager from "../utils/statistics-manager.js";
+import statisticsManager, { runFailures } from "../utils/statistics-manager.js";
 import { LanguageProcessor } from "./language-processor.js";
 import { SourceCodeAnalyzer } from "./source-analyzer.js";
 /**
@@ -24,6 +28,8 @@ class TranslationService {
      * @throws {Error} If validation fails or translation process errors.
      */
     async translateFile(file, options) {
+        // Stop before reading or changing anything when no provider could translate a key.
+        ProviderFactory.assertProviderAvailable(options.apiProvider, options.useFallback !== false);
         await uiManager.log(`\nProcessing File: "${path.basename(file)}"`);
         try {
             const resolvedFile = await this.validateTranslationInputs(file, options);
@@ -32,40 +38,51 @@ class TranslationService {
             const flattenedSource = ObjectTransformer.flatten(sourceContent);
             const totalKeys = Object.keys(flattenedSource).length;
             await uiManager.log(`Source file contains ${totalKeys} translation keys`);
-            const { stateManager, projectRoot, currentState, comparison } = await this.initializeTranslationState(resolvedFile, flattenedSource, options);
-            gracefulShutdown.registerCallback(async () => {
+            const { stateManager, projectRoot, previousState, currentState, comparison } = await this.initializeTranslationState(resolvedFile, flattenedSource, options);
+            // Interrupted (Ctrl-C): changed keys may not be translated yet, so keep them changed.
+            const saveStateOnShutdown = async () => {
                 try {
-                    await stateManager.saveState(projectRoot, currentState);
+                    await stateManager.saveState(projectRoot, stateManager.stateAfterRun(previousState, currentState, [
+                        ...comparison.newKeys,
+                        ...comparison.modifiedKeys,
+                    ]));
                     console.log("State saved during shutdown");
                 }
                 catch (error) {
-                    console.error("Failed to save state during shutdown:", error.message);
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error("Failed to save state during shutdown:", message);
                 }
-            });
+            };
+            gracefulShutdown.registerCallback(saveStateOnShutdown);
             statisticsManager.reset();
             const globalStats = statisticsManager.getStats();
             try {
                 await this.processAllLanguages(resolvedFile, flattenedSource, options, globalStats, comparison);
-                await this.finalizeTranslation(stateManager, projectRoot, currentState, globalStats, startTime, options);
+                await this.finalizeTranslation(stateManager, projectRoot, previousState, currentState, comparison, globalStats, startTime, options);
                 return globalStats;
             }
             catch (error) {
-                await uiManager.log(`\nTranslation error: ${error.message}`);
+                const message = error instanceof Error ? error.message : String(error);
+                await uiManager.log(`\nTranslation error: ${message}`);
                 globalStats.error = {
-                    message: error.message,
+                    message,
                     time: new Date().toISOString(),
-                    stack: process.env.DEBUG ? error.stack : undefined,
+                    stack: process.env.DEBUG && error instanceof Error ? error.stack : undefined,
                 };
                 throw error;
             }
             finally {
+                gracefulShutdown.unregisterCallback(saveStateOnShutdown);
                 if (process.env.DEBUG) {
                     await uiManager.log("\nCache statistics:");
                 }
             }
         }
         catch (validationError) {
-            await uiManager.log(`\nInput validation error: ${validationError.message}`);
+            const message = validationError instanceof Error
+                ? validationError.message
+                : String(validationError);
+            await uiManager.log(`\nInput validation error: ${message}`);
             throw validationError;
         }
     }
@@ -102,7 +119,7 @@ class TranslationService {
     /**
      * Initialize translation state and sync analysis.
      * @param {string} resolvedFile - Path to resolved source file.
-     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {FlatTranslations} flattenedSource - Flattened source content.
      * @param {TranslationOptions} options - Translation options.
      * @returns {Promise<Object>} - Initialized state components.
      */
@@ -138,15 +155,15 @@ class TranslationService {
         else {
             await uiManager.log(`First run - will process all keys`);
         }
-        return { stateManager, projectRoot, currentState, comparison };
+        return { stateManager, projectRoot, previousState, currentState, comparison };
     }
     /**
      * Process all target languages with concurrency.
      * @param {string} resolvedFile - Path to source file.
-     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {FlatTranslations} flattenedSource - Flattened source content.
      * @param {TranslationOptions} options - Translation options.
      * @param {GlobalStats} globalStats - Global statistics object to update.
-     * @param {any} comparison - State comparison result.
+     * @param {StateComparison} comparison - State comparison result.
      */
     async processAllLanguages(resolvedFile, flattenedSource, options, globalStats, comparison) {
         const languageConcurrency = options.concurrencyLimit || 3;
@@ -155,7 +172,10 @@ class TranslationService {
         // Initialize shared SourceCodeAnalyzer
         console.log("Initializing Locai Engine...");
         const sharedAnalyzer = new SourceCodeAnalyzer();
-        sharedAnalyzer.initialize();
+        // Scan the source code only for deep context; disabled, the analyzer stays empty
+        if (options.deepContext !== false) {
+            sharedAnalyzer.initialize();
+        }
         // Create shared orchestrators array to collect review queues
         const orchestrators = [];
         for (let i = 0; i < targetLanguages.length; i += languageConcurrency) {
@@ -186,11 +206,11 @@ class TranslationService {
      * 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 {StateComparison} comparison - State comparison result.
      * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
      */
     async processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison) {
@@ -200,44 +220,81 @@ class TranslationService {
      * Finalize translation process and save state.
      * @param {StateManager} stateManager - State manager instance.
      * @param {string} projectRoot - Project root directory.
-     * @param {any} currentState - Current state object.
+     * @param {Record<string, string>} previousState - State loaded at the start of the run.
+     * @param {Record<string, string>} currentState - Current state (key → content hash).
+     * @param {StateComparison} comparison - New, modified and deleted keys of this run.
      * @param {GlobalStats} globalStats - Global statistics object.
      * @param {number} startTime - Process start timestamp.
      * @param {TranslationOptions} options - Translation options.
      */
-    async finalizeTranslation(stateManager, projectRoot, currentState, globalStats, startTime, options) {
+    async finalizeTranslation(stateManager, projectRoot, previousState, currentState, comparison, globalStats, startTime, options) {
         globalStats.endTime = new Date().toISOString();
         globalStats.totalDuration = (Date.now() - startTime) / 1000;
         globalStats.totalTime = globalStats.totalDuration;
         await uiManager.displayGlobalSummary(globalStats, (options.targets || []).length);
-        // Save review queue if confidence scoring was enabled
-        if (options.saveReviewQueue || options.minConfidence !== undefined) {
-            if (globalStats.orchestrators && globalStats.orchestrators.length > 0) {
-                // Collect all review queues from all orchestrators
-                const allReviewItems = [];
-                globalStats.orchestrators.forEach((orchestrator) => {
-                    if (orchestrator.confidenceSettings &&
-                        orchestrator.confidenceSettings.reviewQueue) {
-                        allReviewItems.push(...orchestrator.confidenceSettings.reviewQueue);
-                    }
-                });
-                // If we have items to review, save them
-                if (allReviewItems.length > 0) {
-                    // Use first orchestrator to save, but update its review queue
-                    const orchestrator = globalStats.orchestrators[0];
-                    orchestrator.confidenceSettings.reviewQueue = allReviewItems;
-                    orchestrator.saveReviewQueue();
-                }
+        await this.reportConfidence(globalStats.orchestrators);
+        // Keys that failed in any language (or every changed key, if a whole language failed)
+        // keep their previous hash, so the next run still treats them as changed.
+        const unfinishedKeys = new Set(globalStats.failedKeys);
+        if (runFailures(globalStats).failedLanguages.length > 0) {
+            for (const key of [...comparison.newKeys, ...comparison.modifiedKeys]) {
+                unfinishedKeys.add(key);
             }
         }
         try {
-            await stateManager.saveState(projectRoot, currentState);
+            await stateManager.saveState(projectRoot, stateManager.stateAfterRun(previousState, currentState, unfinishedKeys));
             if (options.debug) {
                 await uiManager.log(`State saved for future sync operations`);
             }
         }
         catch (error) {
-            await uiManager.log(`Warning: Could not save state: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            await uiManager.log(`Warning: Could not save state: ${message}`);
+        }
+    }
+    /**
+     * Print the confidence scores of the run and, when the review queue is enabled, add the
+     * flagged translations to `.localize-cache/review-queue.json`.
+     * @param {Orchestrator[]} orchestrators - The run's orchestrators (they share the settings).
+     */
+    async reportConfidence(orchestrators) {
+        const settings = orchestrators[0]?.confidenceSettings;
+        if (!settings?.enabled) {
+            return;
+        }
+        const scored = orchestrators.flatMap((o) => o.confidenceSettings.scored);
+        const flagged = orchestrators.flatMap((o) => o.confidenceSettings.reviewQueue);
+        const rejected = flagged.filter((item) => item.rejected).length;
+        const autoApproved = orchestrators.reduce((sum, o) => sum + o.confidenceSettings.autoApprovedCount, 0);
+        if (scored.length > 0) {
+            await uiManager.log(`\nConfidence scores: ${scored.length} translations scored`);
+            await uiManager.log(`   Auto-approved (score >= ${settings.autoApproveThreshold}): ${autoApproved}`);
+            await uiManager.log(`   Need review (score < ${settings.reviewThreshold}): ${flagged.length - rejected}`);
+            await uiManager.log(`   Rejected, not written (score < ${settings.rejectThreshold}): ${rejected}`);
+        }
+        if (!settings.saveReviewQueue) {
+            if (flagged.length > 0) {
+                const listed = 20;
+                for (const item of flagged.slice(0, listed)) {
+                    await uiManager.log(`   ${item.language} ${item.key}: ${ConfidenceScorer.formatConfidence(item.confidence.score)}${item.rejected ? " (rejected)" : ""}`);
+                }
+                if (flagged.length > listed) {
+                    await uiManager.log(`   ...and ${flagged.length - listed} more`);
+                }
+                await uiManager.log("   Save them for 'locai review' with --save-review-queue");
+            }
+            return;
+        }
+        try {
+            const { file, size } = updateReviewQueue(scored, flagged);
+            await uiManager.log(`Review queue: ${size} items in ${file}`);
+            if (size > 0) {
+                await uiManager.log("   Run 'locai review' to approve or edit them");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await uiManager.log(`Warning: Failed to save review queue: ${message}`);
         }
     }
     /**
@@ -247,25 +304,11 @@ class TranslationService {
      * @param {TranslationOptions} options - Translation options.
      */
     async removeDeletedKeysFromTargets(sourceFile, deletedKeys, options) {
-        const sourceDir = path.dirname(sourceFile);
-        // Detect structure based on source file name
-        const isNestedStructure = path.basename(sourceFile) === "translation.json";
         let totalRemoved = 0;
         let filesProcessed = 0;
         for (const targetLang of options.targets || []) {
             try {
-                let targetPath;
-                if (isNestedStructure) {
-                    // Nested: locales/tr/translation.json
-                    const localesRoot = path.dirname(sourceDir);
-                    const targetDir = path.join(localesRoot, targetLang);
-                    targetPath = path.join(targetDir, "translation.json");
-                }
-                else {
-                    // Flat: locales/tr.json
-                    const safeTargetFilename = `${targetLang}.json`;
-                    targetPath = InputValidator.createSafeFilePath(sourceDir, safeTargetFilename);
-                }
+                const targetPath = targetLocaleFile(sourceFile, targetLang);
                 // Check if target file exists
                 const fileExists = await FileManager.exists(targetPath);
                 if (!fileExists) {
@@ -296,7 +339,8 @@ class TranslationService {
                 filesProcessed++;
             }
             catch (error) {
-                await uiManager.log(`   \u274c Error processing ${targetLang}: ${error.message}`);
+                const message = error instanceof Error ? error.message : String(error);
+                await uiManager.log(`   \u274c Error processing ${targetLang}: ${message}`);
             }
         }
         await uiManager.log(`Cleanup Summary: Removed ${totalRemoved} keys from ${filesProcessed} files\n`);
@@ -305,6 +349,7 @@ class TranslationService {
      * Validate and fix existing translations that have length issues.
      * @param {string} file - Path to source file.
      * @param {TranslationOptions} options - Translation options.
+     * @returns {Promise<FixSummary>} - How many length issues were found and fixed.
      * @throws {Error} If validation process fails.
      */
     async validateAndFixExistingTranslations(file, options) {
@@ -312,29 +357,21 @@ class TranslationService {
         const sourceContent = await FileManager.readJSON(file);
         const flattenedSource = ObjectTransformer.flatten(sourceContent);
         const orchestrator = new Orchestrator(options);
-        const sourceDir = path.dirname(file);
-        const isNestedStructure = path.basename(file) === "translation.json";
         const languageResults = await Promise.all((options.targets || []).map(async (targetLang) => {
             try {
-                let targetPath;
-                if (isNestedStructure) {
-                    const localesRoot = path.dirname(sourceDir);
-                    targetPath = path.join(localesRoot, targetLang, "translation.json");
-                }
-                else {
-                    targetPath = path.join(sourceDir, `${targetLang}.json`);
-                }
+                const targetPath = targetLocaleFile(file, targetLang);
                 const targetContent = await FileManager.readJSON(targetPath);
                 return { targetLang, targetPath, content: targetContent, success: true };
             }
             catch (err) {
-                await uiManager.log(`Could not read ${targetLang}: ${err.message}`);
+                const message = err instanceof Error ? err.message : String(err);
+                await uiManager.log(`Could not read ${targetLang}: ${message}`);
                 return {
                     targetLang,
                     targetPath: "",
                     content: {},
                     success: false,
-                    error: err.message,
+                    error: message,
                 };
             }
         }));
@@ -346,7 +383,6 @@ class TranslationService {
                 styleGuide: options.styleGuide,
                 context: options.context,
                 lengthControl: options.lengthControl,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 ...(options.qualityChecks?.rules || {}),
                 enabled: true,
             });
@@ -379,6 +415,8 @@ class TranslationService {
                 if (invalidItems.length > 0) {
                     totalIssues += invalidItems.length;
                     await uiManager.log(`Found ${invalidItems.length} length issues in ${targetLang}`);
+                    // Re-translating needs a provider; stop before the first request if none has a key.
+                    ProviderFactory.assertProviderAvailable(options.apiProvider, options.useFallback !== false);
                     // Batch process fixes to improve performance
                     const results = await orchestrator.processTranslations(invalidItems);
                     const fixedCount = results.filter((r) => r.success).length;
@@ -402,9 +440,15 @@ class TranslationService {
             else {
                 await uiManager.log(`\nNo length issues found in any language`);
             }
+            await this.reportConfidence([orchestrator]);
+            return { issues: totalIssues, fixed: totalFixed };
         }
         catch (error) {
-            await uiManager.log(`\nValidation error: ${error.message}`);
+            // The CLI prints a missing-provider error once; don't log it here as well.
+            if (!(error instanceof NoProviderError)) {
+                const message = error instanceof Error ? error.message : String(error);
+                await uiManager.log(`\nValidation error: ${message}`);
+            }
             throw error;
         }
     }
@@ -416,7 +460,8 @@ class TranslationService {
             return await FileManager.findLocaleFiles(localesDir, sourceLang);
         }
         catch (error) {
-            await uiManager.log(`Error finding locale files: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            await uiManager.log(`Error finding locale files: ${message}`);
             return [];
         }
     }

package/dist/services/vector-store.d.ts

@@ -1,16 +1,27 @@
+import { MetadataTypes } from "vectra";
 export interface VectorStoreConfig {
     enabled: boolean;
     vectorDbPath: string;
     similarityThreshold?: number;
     exactMatchThreshold?: number;
 }
+/** Extra metadata callers attach to a stored translation (e.g. key, category). */
+export type VectorItemMetadata = Record<string, MetadataTypes>;
+/** Metadata persisted with every vector: the translation pair plus caller metadata. */
+export type TranslationMemoryMetadata = VectorItemMetadata & {
+    text: string;
+    translation: string;
+    sourceLang: string;
+    targetLang: string;
+    timestamp: number;
+};
 export interface SearchResult {
     item: {
         text: string;
         translation: string;
         sourceLang: string;
         targetLang: string;
-        metadata?: any;
+        metadata?: TranslationMemoryMetadata;
     };
     score: number;
 }
@@ -21,6 +32,8 @@ export declare class VectorStore {
     private readonly DIMENSION;
     constructor(config: VectorStoreConfig);
     initialize(): Promise<void>;
-    addItem(text: string, translation: string, sourceLang: string, targetLang: string, embedding: number[], metadata?: any): Promise<void>;
+    addItem(text: string, translation: string, sourceLang: string, targetLang: string, embedding: number[], 
+    /** Undefined values are dropped when vectra serializes the index. */
+    metadata?: Partial<VectorItemMetadata>): Promise<void>;
     search(embedding: number[], targetLang: string, limit?: number): Promise<SearchResult[]>;
 }

package/dist/services/vector-store.js

@@ -27,11 +27,14 @@ export class VectorStore {
             // log(`Vector store initialized at ${dbPath}`, true);
         }
         catch (error) {
-            console.error(`Failed to initialize vector store: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to initialize vector store: ${message}`);
             this.config.enabled = false; // Disable if init fails
         }
     }
-    async addItem(text, translation, sourceLang, targetLang, embedding, metadata = {}) {
+    async addItem(text, translation, sourceLang, targetLang, embedding, 
+    /** Undefined values are dropped when vectra serializes the index. */
+    metadata = {}) {
         if (!this.initialized || !this.index)
             return;
         try {
@@ -48,19 +51,19 @@ export class VectorStore {
             });
         }
         catch (error) {
-            console.warn(`Failed to add item to vector store: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to add item to vector store: ${message}`);
         }
     }
     async search(embedding, targetLang, limit = 3) {
         if (!this.initialized || !this.index)
             return [];
         try {
-            // @ts-ignore - Vectra types might be mismatched in this version
-            const results = await this.index.queryItems(embedding, limit);
-            // Filter by target language and map to result format
-            return results
-                .filter((result) => result.item.metadata.targetLang === targetLang)
-                .map((result) => ({
+            // Filter by target language before ranking so `limit` counts only matching items.
+            const results = await this.index.queryItems(embedding, "", limit, {
+                targetLang: { $eq: targetLang },
+            });
+            return results.map((result) => ({
                 item: {
                     text: result.item.metadata.text,
                     translation: result.item.metadata.translation,
@@ -72,7 +75,8 @@ export class VectorStore {
             }));
         }
         catch (error) {
-            console.warn(`Vector search failed: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Vector search failed: ${message}`);
             return [];
         }
     }

package/dist/types/index.d.ts

@@ -1,58 +1,56 @@
-import { OrchestratorOptions } from "../core/orchestrator.js";
-import { ContextConfig } from "../core/context-processor.js";
-export interface TranslationOptions extends Omit<OrchestratorOptions, "context"> {
-    source: string;
+import type { OrchestratorOptions } from "../core/orchestrator.js";
+import type { FlatTranslationValue } from "../utils/object-transformer.js";
+import type { ProgressStatus } from "../utils/progress-tracker.js";
+import type { QualityIssue } from "../utils/quality/base-checker.js";
+import type { StateOptions } from "../utils/state-manager.js";
+import type { GlobalStats as CollectedStats, LanguageStats as LanguageCounters } from "../utils/statistics-manager.js";
+/** The `syncOptions` configuration section: keeping target files in sync with the source. */
+export interface SyncOptions {
+    enabled?: boolean;
+    removeDeletedKeys?: boolean;
+    retranslateModified?: boolean;
+    stateTracking?: StateOptions;
+}
+/** Options of a translate or fix run: the orchestrator options plus file and sync settings. */
+export interface TranslationOptions extends OrchestratorOptions {
     targets?: string[];
     localesDir?: string;
     debug?: boolean;
     forceUpdate?: boolean;
-    syncOptions?: {
-        enabled?: boolean;
-        removeDeletedKeys?: boolean;
-    };
-    concurrencyLimit?: number;
-    saveReviewQueue?: boolean;
-    minConfidence?: number;
+    syncOptions?: SyncOptions;
     fileExtensions?: string[];
-    progressOptions?: any;
-    qualityChecks?: any;
-    styleGuide?: any;
-    context?: ContextConfig;
-    lengthControl?: any;
 }
-export interface GlobalStats {
-    total: number;
-    success: number;
-    failed: number;
-    skipped: number;
-    languages: Record<string, any>;
-    byCategory: Record<string, number>;
-    details: Record<string, {
-        totalConfidence: number;
-        samples: number;
-    }>;
+/** Per-language counters, plus the error message when the language failed as a whole. */
+export interface LanguageStats extends LanguageCounters {
+    error?: string;
+}
+/** Statistics of a translate run, completed by the translation service. */
+export interface GlobalStats extends CollectedStats {
+    languages: Record<string, LanguageStats>;
     error?: {
         message: string;
         time: string;
         stack?: string;
     };
-    orchestrators: any[];
     endTime?: string;
     totalDuration?: number;
-    totalTime: number;
-    startTime: string;
 }
+/** A source key that needs translating (or re-translating) into one target language. */
 export interface MissingKey {
     key: string;
     text: string;
     targetLang: string;
-    existingTranslation?: string;
+    /** Current value of the key in the target file, if any. */
+    existingTranslation?: FlatTranslationValue;
     isModified: boolean;
     isNew: boolean;
-    issueDetails?: any;
+    /** The quality issue that requires the existing translation to be redone. */
+    issueDetails?: QualityIssue;
 }
+/** Outcome of translating one target language. */
 export interface LanguageProcessResult {
-    status: any;
+    /** Final progress counters; null when the language failed. */
+    status: Pick<ProgressStatus, "completed" | "total" | "language"> | null;
     savedMessage?: string;
     error?: string;
 }

package/dist/utils/ai-context-analyzer.d.ts

@@ -3,16 +3,22 @@ export interface AnalysisResult {
     confidence: number;
     keywords: string[];
     explanation: string;
-    prompt: string;
+    /** Category prompt; undefined when neither the category nor the fallback defines one */
+    prompt?: string;
     method?: string;
 }
+export interface ContextCategory {
+    keywords?: string[];
+    prompt?: string;
+    weight?: number;
+}
 export interface ContextConfig {
     enabled?: boolean;
     useAI?: boolean;
     minTextLength?: number;
     cacheSize?: number;
     cacheTTL?: number;
-    categories?: Record<string, any>;
+    categories?: Record<string, ContextCategory>;
     detection?: {
         threshold?: number;
         minConfidence?: number;
@@ -23,11 +29,14 @@ export interface ContextConfig {
         prompt?: string;
     };
     analysisOptions?: {
+        model?: string;
+        temperature?: number;
         maxTokens?: number;
         timeout?: number;
         retries?: number;
     };
-    [key: string]: any;
+    /** Provider fallback chain used for analysis calls */
+    fallbackOrder?: string[];
 }
 export interface Stats {
     totalAnalyzed: number;

package/dist/utils/ai-context-analyzer.js

@@ -90,7 +90,8 @@ class AIContextAnalyzer {
                 }
             }
             catch (error) {
-                console.error("Batch AI analysis failed:", error.message);
+                const message = error instanceof Error ? error.message : String(error);
+                console.error("Batch AI analysis failed:", message);
             }
         }
         return results;
@@ -106,18 +107,23 @@ class AIContextAnalyzer {
             return [];
         this.stats.totalAnalyzed += texts.length;
         this.stats.aiCalls++; // Only one API call for the batch
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const provider = ProviderFactory.getProvider(apiProvider, true, this.config);
         if (!provider) {
             throw new Error("AI provider not available for context analysis");
         }
         const batchPrompt = this._createBatchAnalysisPrompt(texts);
-        const result = await rateLimiter.enqueue(apiProvider.toLowerCase(), () => provider.analyze(batchPrompt, {
-            ...this.config.analysisOptions,
-            maxTokens: Math.min(4000, this.config.analysisOptions?.maxTokens || 2000),
-            timeout: this.config.analysisOptions?.timeout || 10000,
-            retries: this.config.analysisOptions?.retries || 2,
-        }));
+        const result = await rateLimiter.enqueue(apiProvider.toLowerCase(), () => {
+            if (!provider.analyze) {
+                throw new TypeError("provider.analyze is not a function");
+            }
+            const analysisOptions = {
+                ...this.config.analysisOptions,
+                maxTokens: Math.min(4000, this.config.analysisOptions?.maxTokens || 2000),
+                timeout: this.config.analysisOptions?.timeout || 10000,
+                retries: this.config.analysisOptions?.retries || 2,
+            };
+            return provider.analyze(batchPrompt, analysisOptions);
+        });
         return this._parseBatchAnalysisResult(result, texts.length);
     }
     // Create batch analysis prompt for multiple texts
@@ -252,7 +258,8 @@ RESPONSE FORMAT:
             return results;
         }
         catch (error) {
-            console.error("Error parsing batch AI analysis result:", error.message);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error("Error parsing batch AI analysis result:", message);
             return new Array(expectedCount).fill(null);
         }
     }
@@ -295,7 +302,8 @@ RESPONSE FORMAT:
             };
         }
         catch (error) {
-            console.error("Error parsing AI analysis result:", error.message);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error("Error parsing AI analysis result:", message);
             return null;
         }
     }