locai 2.1.1 → 2.1.3

package/dist/utils/quality/punctuation-checker.d.ts

@@ -0,0 +1,31 @@
+export interface PunctuationIssue {
+    type: "punctuation";
+    message: string;
+}
+export interface PunctuationFixResult {
+    text: string;
+    foundIssues: PunctuationIssue[];
+    appliedFixes: {
+        type: "punctuation";
+        message: string;
+    }[];
+}
+/**
+ * Punctuation Consistency Checker.
+ * Ensures end punctuation marks are preserved in translation.
+ */
+declare class PunctuationChecker {
+    /**
+     * Check for punctuation mismatches.
+     */
+    checkPunctuation(source: string, translated: string): PunctuationIssue[];
+    /**
+     * Fix missing punctuation marks.
+     */
+    fixPunctuation(source: string, translated: string): PunctuationFixResult;
+    /**
+     * Add punctuation to the end of text.
+     */
+    addPunctuation(text: string, punctuation: string): string;
+}
+export default PunctuationChecker;

package/dist/utils/quality/quote-balance-checker.d.ts

@@ -0,0 +1,37 @@
+export interface QuoteIssue {
+    type: "unbalanced-quotes" | "quote-consistency" | "quote-balance";
+    severity: "error" | "warning";
+    message: string;
+    char?: string;
+}
+export interface QuoteFixResult {
+    text: string;
+    foundIssues: QuoteIssue[];
+    appliedFixes: {
+        type: "quote-balance";
+        message: string;
+    }[];
+}
+/**
+ * Quote Balance Checker.
+ * Ensures quotes (single, double, guillemets, etc.) are balanced in translation.
+ */
+declare class QuoteBalanceChecker {
+    /**
+     * Check for unbalanced quotes.
+     */
+    checkQuoteBalance(text: string): QuoteIssue[];
+    /**
+     * Count occurrences of a quote character.
+     */
+    private _countQuotes;
+    /**
+     * Fix unbalanced quotes.
+     */
+    fixQuoteBalance(text: string): QuoteFixResult;
+    /**
+     * Validate that quotes in source and translation match in pattern.
+     */
+    validateQuoteConsistency(source: string, translated: string): QuoteIssue[];
+}
+export default QuoteBalanceChecker;

package/dist/utils/quality/special-characters-checker.d.ts

@@ -0,0 +1,66 @@
+export interface SpecialCharIssue {
+    type: "special-characters" | "special-character-substitution" | "emoji-preservation" | "missing-special-chars" | "character-substitution";
+    category?: string;
+    severity: "error" | "warning";
+    message: string;
+    details?: any;
+}
+export interface SpecialCharFixResult {
+    text: string;
+    foundIssues: SpecialCharIssue[];
+    appliedFixes: {
+        type: "critical-char-restore" | "character-substitution";
+        message: string;
+    }[];
+}
+/**
+ * Special Characters Preservation Checker.
+ * Ensures special characters, symbols, and formatting are preserved.
+ */
+declare class SpecialCharactersChecker {
+    private specialCharacterSets;
+    private criticalCharacters;
+    constructor();
+    /**
+     * Check if special characters are preserved.
+     */
+    checkSpecialCharacters(sourceText: string, translatedText: string): SpecialCharIssue[];
+    /**
+     * Check emoji preservation.
+     */
+    checkEmojiPreservation(sourceText: string, translatedText: string): SpecialCharIssue[];
+    /**
+     * Fix special character issues.
+     */
+    fixSpecialCharacters(sourceText: string, translatedText: string): SpecialCharFixResult;
+    /**
+     * Extract special characters by category.
+     */
+    extractSpecialCharacters(text: string): Record<string, string[]>;
+    /**
+     * Restore critical characters that were lost.
+     */
+    restoreCriticalCharacters(sourceText: string, translatedText: string, missingChars: string[]): {
+        text: string;
+        appliedFixes: {
+            type: "critical-char-restore";
+            message: string;
+        }[];
+    };
+    /**
+     * Fix common character substitutions.
+     */
+    fixCommonSubstitutions(sourceText: string, translatedText: string): {
+        text: string;
+        foundIssues: SpecialCharIssue[];
+        appliedFixes: {
+            type: "character-substitution";
+            message: string;
+        }[];
+    };
+    /**
+     * Check if text has special characters.
+     */
+    hasSpecialCharacters(text: string): boolean;
+}
+export default SpecialCharactersChecker;

package/dist/utils/quality/style-guide-checker.d.ts

@@ -0,0 +1,71 @@
+import { ProviderConfig } from "../../providers/base-provider.js";
+export interface StyleGuideConfig {
+    formality?: string;
+    toneOfVoice?: string;
+    toneProvider?: string;
+    analysisOptions?: ProviderConfig;
+    enforceTone?: boolean;
+    conventions?: {
+        useOxfordComma?: boolean;
+        useSentenceCase?: boolean;
+        [key: string]: any;
+    };
+}
+export interface StyleIssue {
+    type: "oxford-comma" | "sentence-case";
+    severity: "warning" | "info";
+    message: string;
+    suggestion?: string;
+}
+export interface StyleFixResult {
+    text: string;
+    foundIssues: StyleIssue[];
+    appliedFixes: {
+        type: "oxford-comma" | "sentence-case";
+        message: string;
+    }[];
+}
+/**
+ * Style Guide Checker.
+ * Enforces style guide conventions like Oxford comma and sentence case.
+ */
+declare class StyleGuideChecker {
+    private styleGuide;
+    constructor(styleGuide?: StyleGuideConfig);
+    /**
+     * Check if text follows style guide conventions.
+     */
+    checkStyleGuide(_sourceText: string, translatedText: string): StyleIssue[];
+    /**
+     * Check for Oxford comma usage in lists.
+     */
+    checkOxfordComma(text: string): StyleIssue[];
+    /**
+     * Check sentence case for headings/titles.
+     */
+    checkSentenceCase(text: string): StyleIssue[];
+    /**
+     * Fix style guide issues.
+     */
+    fixStyleGuide(sourceText: string, translatedText: string): StyleFixResult;
+    /**
+     * Fix missing Oxford commas.
+     */
+    fixOxfordComma(text: string): StyleFixResult;
+    /**
+     * Fix sentence case issues.
+     */
+    fixSentenceCase(text: string): {
+        text: string;
+        foundIssues: StyleIssue[];
+        appliedFixes: {
+            type: "sentence-case";
+            message: string;
+        }[];
+    };
+    /**
+     * Convert text to sentence case.
+     */
+    convertToSentenceCase(text: string): string;
+}
+export default StyleGuideChecker;

package/dist/utils/quality/text-sanitizer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Text Sanitizer.
+ * Cleans up translated text by removing AI artifacts, think tags, and unwanted formatting.
+ */
+declare class TextSanitizer {
+    /**
+     * Sanitize text by applying a sequence of cleaning rules.
+     */
+    sanitize(text: string): string;
+    /**
+     * Apply a list of rules to text.
+     */
+    applyRules(text: string, rules: ((text: string) => string)[]): string;
+    /**
+     * Remove <think> tags and their content.
+     */
+    removeThinkTags: (text: string) => string;
+    /**
+     * Remove bold/italic markdown formatting.
+     */
+    removeMarkdownFormatting: (text: string) => string;
+    /**
+     * Remove leading/trailing quotes.
+     */
+    removeQuotes: (text: string) => string;
+    /**
+     * Remove bullet points at the start.
+     */
+    removeBulletPoints: (text: string) => string;
+    /**
+     * Remove explanatory text and metadata.
+     */
+    removeExplanations: (text: string) => string;
+    /**
+     * Remove common AI conversational artifacts.
+     */
+    removeAIArtifacts: (text: string) => string;
+    /**
+     * Trim special characters from ends.
+     */
+    trimSpecialChars: (text: string) => string;
+    /**
+     * Normalize whitespace and remove duplicate lines.
+     */
+    normalizeWhitespace: (text: string) => string;
+    /**
+     * Aggressive cleanup of all artifacts.
+     */
+    removeAllArtifacts: (text: string) => string;
+}
+export default TextSanitizer;

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

@@ -0,0 +1,14 @@
+import { ProviderConfig } from "../../providers/base-provider.js";
+export interface ToneVerificationResult {
+    passed: boolean;
+    score: number;
+    reasoning: string;
+    suggestions?: string;
+}
+export declare class ToneVerifier {
+    private provider;
+    private initialized;
+    constructor();
+    private initProvider;
+    verify(sourceText: string, translatedText: string, sourceLang: string, targetLang: string, targetTone: string, providerName?: string, options?: ProviderConfig): Promise<ToneVerificationResult>;
+}

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,73 @@
+export interface RateLimiterConfig {
+    queueStrategy?: "fifo" | "priority";
+    queueTimeout?: number;
+    adaptiveThrottling?: boolean;
+    providerLimits?: Record<string, {
+        rpm?: number;
+        concurrency?: number;
+    }>;
+}
+/**
+ * Handles API rate limiting and request throttling.
+ * Supports provider-specific limits and adaptive throttling.
+ */
+declare class RateLimiter {
+    private queues;
+    private processing;
+    private config;
+    private metrics;
+    private providers;
+    private _processingLocks;
+    /**
+     * Create a new RateLimiter.
+     * @param config - Rate limiter configuration.
+     */
+    constructor(config?: RateLimiterConfig);
+    /**
+     * Update rate limiter configuration.
+     * @param config - Configuration updates.
+     */
+    updateConfig(config: RateLimiterConfig): void;
+    /**
+     * Enqueue a task for execution with rate limiting.
+     * @param provider - Provider name.
+     * @param task - Async task to execute.
+     * @param priority - Task priority (higher is better).
+     * @returns Task result.
+     */
+    enqueue<T>(provider: string, task: () => Promise<T>, priority?: number): Promise<T>;
+    /**
+     * Process the queue for a specific provider.
+     * @param provider - Provider name.
+     */
+    private _processQueue;
+    private _trackResponseTime;
+    private _trackErrorRate;
+    private _adjustThrottling;
+    private _shouldThrottle;
+    private _calculateWaitTime;
+    private _resetCounters;
+    /**
+     * Get current queue size for a provider.
+     * @param provider - Provider name.
+     * @returns Queue size.
+     */
+    getQueueSize(provider: string): number;
+    /**
+     * Get complete rate limiter status.
+     * @returns Status object including active metrics.
+     */
+    getStatus(): Record<string, any>;
+    /**
+     * Get current configuration.
+     * @returns Configuration object.
+     */
+    getConfig(): RateLimiterConfig;
+    /**
+     * Clear all pending queues.
+     */
+    clearAllQueues(): void;
+    private _cleanupMetrics;
+}
+declare const _default: RateLimiter;
+export default _default;

package/dist/utils/retry-helper.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Retry helper for API operations with exponential backoff
+ */
+export interface RetryOptions {
+    provider?: string;
+    perProviderRetry?: Record<string, Partial<RetryConfig>>;
+    retryableErrors?: string[];
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    context?: string;
+    logContext?: Record<string, any>;
+    retryCondition?: (error: any, attempts: number, maxRetries: number) => boolean | Promise<boolean>;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    initialDelay: number;
+    maxDelay: number;
+}
+export interface RetryStats {
+    attempts: number;
+    totalTime: number;
+    provider?: string;
+    success?: boolean;
+}
+/**
+ * Retry helper for API operations with exponential backoff.
+ */
+declare class RetryHelper {
+    /**
+     * Retry an operation with configurable backoff strategy.
+     * Supports per-provider retry configuration.
+     */
+    static withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    /**
+     * Calculate exponential backoff with jitter.
+     */
+    static calculateBackoff(attempt: number, initialDelay: number, maxDelay: number): number;
+    /**
+     * Default retry condition based on error type.
+     * Checks against retryableErrors list.
+     */
+    static defaultRetryCondition(error: any, retryableErrors?: string[]): boolean;
+    /**
+     * Promise-based delay.
+     */
+    static delay(ms: number): Promise<void>;
+}
+export default RetryHelper;

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

@@ -0,0 +1,62 @@
+export interface StateOptions {
+    enabled?: boolean;
+    stateFileName?: string;
+    stateDir?: string;
+    [key: string]: any;
+}
+export interface StateComparison {
+    deletedKeys: string[];
+    modifiedKeys: string[];
+    newKeys: string[];
+    hasChanges: boolean;
+}
+export interface StateComparisonStats {
+    totalChanges: number;
+    deletedCount: number;
+    modifiedCount: number;
+    newCount: number;
+    hasChanges: boolean;
+}
+/**
+ * StateManager - Tracks changes in source locale files using hash-based state management
+ * This enables detection of deleted/modified keys to synchronize target locale files
+ */
+declare class StateManager {
+    private options;
+    constructor(options?: StateOptions | {
+        stateTracking: StateOptions;
+    });
+    /**
+     * Generate a SHA-256 hash for given text content
+     */
+    _generateHash(text: string | object): string;
+    /**
+     * Get the full path to the state file
+     */
+    _getStateFilePath(projectRoot: string): string;
+    /**
+     * Load previous state from state file
+     */
+    loadState(projectRoot: string): Promise<Record<string, string>>;
+    /**
+     * Save current state to state file
+     */
+    saveState(projectRoot: string, state: Record<string, string>): Promise<boolean>;
+    /**
+     * Generate state object from source content by creating hashes for each key
+     */
+    generateStateFromSource(sourceContent: Record<string, string>): Record<string, string>;
+    /**
+     * Compare two states and identify changes
+     */
+    compareStates(previousState: Record<string, string>, currentState: Record<string, string>): StateComparison;
+    /**
+     * Get statistics about the state comparison
+     */
+    getComparisonStats(comparison: StateComparison): StateComparisonStats;
+    /**
+     * Clean up old state files (maintenance utility)
+     */
+    cleanupState(projectRoot: string): Promise<boolean>;
+}
+export default StateManager;

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

@@ -0,0 +1,47 @@
+/**
+ * Statistics manager to track translation progress and metrics
+ */
+export interface GlobalStats {
+    total: number;
+    byCategory: Record<string, number>;
+    details: Record<string, {
+        samples: number;
+        totalConfidence: number;
+    }>;
+    totalTime: number;
+    success: number;
+    failed: number;
+    skipped: number;
+    languages: Record<string, LanguageStats>;
+    startTime: string;
+    orchestrators: any[];
+}
+export interface LanguageStats {
+    processed: number;
+    added: number;
+    skipped: number;
+    failed: number;
+    timeMs: number;
+}
+export declare class StatisticsManager {
+    private stats;
+    constructor();
+    /**
+     * Initialize global statistics structure
+     */
+    initializeGlobalStats(): GlobalStats;
+    /**
+     * Reset statistics
+     */
+    reset(): void;
+    /**
+     * Get current stats
+     */
+    getStats(): GlobalStats;
+    /**
+     * Initialize language stats
+     */
+    initLanguageStats(langCode: string): void;
+}
+declare const _default: StatisticsManager;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { GlobalStats } from "./statistics-manager.js";
+/**
+ * UI Manager for handling CLI output and user interaction
+ */
+export declare class UIManager {
+    private consoleLock;
+    constructor();
+    /**
+     * Log a message safely preventing overlap
+     */
+    log(message: string): Promise<void>;
+    /**
+     * Display global summary of translation
+     */
+    displayGlobalSummary(stats: GlobalStats & {
+        totalDuration?: number;
+    }, totalLanguages: number): Promise<void>;
+    logBatchResults(batchResults: any[]): Promise<void>;
+}
+declare const _default: UIManager;
+export default _default;

package/package.json

@@ -1,8 +1,9 @@
 {
 	"name": "locai",
-	"version": "2.1.1",
+	"version": "2.1.3",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
+	"types": "dist/core/orchestrator.d.ts",
 	"directories": {
 		"src": "src",
 		"dist": "dist"
@@ -30,16 +31,30 @@
 		"localization",
 		"i18n",
 		"nextjs",
-		"ai-translation"
+		"ai-translation",
+		"cli",
+		"automation",
+		"llm",
+		"openai",
+		"gemini",
+		"deepseek",
+		"developer-tools"
 	],
 	"author": {
 		"name": "Ahmet Enes Dur",
 		"email": "ahmetenesdur@gmail.com",
 		"url": "https://github.com/ahmetenesdur"
 	},
-	"license": "ISC",
+	"license": "MIT",
 	"description": "Global, AI-Powered Translation CLI for every project.",
-	"homepage": "https://github.com/ahmetenesdur/locai",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ahmetenesdur/locai.git"
+	},
+	"bugs": {
+		"url": "https://github.com/ahmetenesdur/locai/issues"
+	},
+	"homepage": "https://github.com/ahmetenesdur/locai#readme",
 	"engines": {
 		"node": ">=14.13.0"
 	},