locai 2.1.1 → 2.1.3

package/dist/utils/logger.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Advanced Logging System.
+ * Implements saveErrorLogs, logDirectory, logRotation, and other logging features.
+ */
+export interface LogRotationConfig {
+    enabled: boolean;
+    maxFiles: number;
+    maxSize: number;
+}
+export interface LoggerConfig {
+    verbose?: boolean;
+    diagnosticsLevel?: "minimal" | "normal" | "detailed";
+    outputFormat?: "pretty" | "json" | "simple";
+    saveErrorLogs?: boolean;
+    logDirectory?: string;
+    includeTimestamps?: boolean;
+    logRotation?: Partial<LogRotationConfig>;
+}
+interface InternalLoggerConfig extends Required<Omit<LoggerConfig, "logRotation">> {
+    logRotation: LogRotationConfig;
+}
+interface LogStats {
+    size: number;
+    sizeFormatted: string;
+    modified: Date | null;
+}
+declare class Logger {
+    config: InternalLoggerConfig;
+    logFiles: Record<string, string>;
+    currentLogSizes: Record<string, number>;
+    private initialized;
+    /**
+     * Create a new Logger instance.
+     * @param config - Logger configuration.
+     */
+    constructor(config?: LoggerConfig);
+    /**
+     * Initialize logger (create directories, check rotation).
+     */
+    initialize(): Promise<void>;
+    /**
+     * Parse size string (e.g., "10MB") to bytes.
+     * @param sizeStr - Size string to parse.
+     */
+    parseSize(sizeStr: any): number;
+    /**
+     * Check and rotate logs if needed.
+     */
+    checkAndRotateLogs(): Promise<void>;
+    /**
+     * Rotate a log file.
+     * @param logPath - Path to the log file.
+     */
+    rotateLog(logPath: string): Promise<void>;
+    /**
+     * Clean up old log files.
+     * @param dir - Directory containing log files.
+     * @param basename - Basename of the log file.
+     */
+    cleanupOldLogs(dir: string, basename: string): Promise<void>;
+    /**
+     * Format log message.
+     * @param level - Log level.
+     * @param message - Log message.
+     * @param data - Additional data to log.
+     */
+    formatMessage(level: string, message: string, data?: any): string;
+    /**
+     * Write to log file.
+     * @param level - Log level.
+     * @param message - Log message.
+     * @param data - Additional data to log.
+     */
+    writeToFile(level: string, message: string, data?: any): Promise<void>;
+    /**
+     * Simple console log with debug awareness.
+     * @param message - Message to log
+     * @param debugOnly - Only log if debug mode is enabled
+     */
+    log(message: string, debugOnly?: boolean): Promise<void>;
+    /**
+     * Log error.
+     * @param message - Error message.
+     * @param data - Additional data.
+     */
+    error(message: string, data?: any): Promise<void>;
+    /**
+     * Log warning.
+     * @param message - Warning message.
+     * @param data - Additional data.
+     */
+    warn(message: string, data?: any): Promise<void>;
+    /**
+     * Log info.
+     * @param message - Info message.
+     * @param data - Additional data.
+     */
+    info(message: string, data?: any): Promise<void>;
+    /**
+     * Log debug.
+     * @param message - Debug message.
+     * @param data - Additional data.
+     */
+    debug(message: string, data?: any): Promise<void>;
+    /**
+     * Log based on diagnostics level.
+     * @param level - Log level.
+     * @param message - Log message.
+     * @param data - Additional data.
+     */
+    diagnostics(level: string, message: string, data?: any): Promise<void>;
+    /**
+     * Get log statistics.
+     * @returns Object containing log stats.
+     */
+    getLogStats(): Promise<Record<string, LogStats>>;
+    /**
+     * Format size to human-readable.
+     * @param bytes - Size in bytes.
+     */
+    formatSize(bytes: number): string;
+    /**
+     * Clear all logs.
+     */
+    clearLogs(): Promise<void>;
+}
+export declare function getLogger(config?: LoggerConfig | null): Logger;
+/**
+ * Quick debug-aware logging helper.
+ * @param message - Message to log.
+ * @param debugOnly - Only log in debug/verbose mode.
+ */
+export declare function log(message: string, debugOnly?: boolean): void;
+export default Logger;

package/dist/utils/object-transformer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Utility class for object manipulation.
+ */
+export interface TransformedObject {
+    [key: string]: any;
+}
+declare class ObjectTransformer {
+    /**
+     * Flatten a nested object into a single-level object with dot notation keys.
+     * @param obj - The object to flatten.
+     * @param prefix - Prefix for keys (used internally).
+     * @param maxDepth - Maximum recursion depth.
+     * @returns Flattened object.
+     */
+    static flatten(obj: TransformedObject, prefix?: string, maxDepth?: number): Record<string, string | number | boolean | null>;
+    /**
+     * Unflatten an object with dot notation keys into a nested object.
+     * @param obj - The flattened object.
+     * @returns Nested object.
+     */
+    static unflatten(obj: Record<string, any>): TransformedObject;
+    /**
+     * Create a deep copy of an object.
+     * @param obj - The object to clone.
+     * @param seen - Internal set to track circular references.
+     * @returns Deep copy of the object.
+     */
+    static deepClone<T>(obj: T, seen?: WeakSet<object>): T;
+    /**
+     * deeply merge two objects.
+     * @param target - The target object.
+     * @param source - The source object.
+     * @param overwriteArrays - Whether to overwrite arrays or merge them.
+     * @returns Merged object.
+     */
+    static mergeObjects(target: TransformedObject, source: TransformedObject, overwriteArrays?: boolean): TransformedObject;
+}
+export default ObjectTransformer;

package/dist/utils/progress-tracker.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Progress tracking for translation operations
+ */
+export interface ProgressOptions {
+    logToConsole?: boolean;
+    logFrequency?: number;
+}
+export interface ProgressStatistics {
+    avgTimePerItem: number;
+    recentAvgTimePerItem?: number;
+    totalTime: number;
+    estimatedTimeRemaining: number;
+    itemsPerSecond: number;
+    percentComplete: number;
+    successRate: number;
+    startTime?: string;
+    estimatedEndTime?: string;
+}
+export interface ProgressStatus {
+    total: number;
+    completed: number;
+    success: number;
+    failed: number;
+    language: string | null;
+    inProgress: boolean;
+    statistics: ProgressStatistics;
+}
+declare class ProgressTracker {
+    private logToConsole;
+    private logFrequency;
+    private _isUpdating;
+    private _pendingUpdates;
+    private _spinnerInterval;
+    private _spinnerIndex;
+    private _spinnerFrames;
+    private total;
+    private completed;
+    private success;
+    private failed;
+    private startTime;
+    private endTime;
+    private lastUpdateTime;
+    private recentOperationTimes;
+    private language;
+    private isCompleted;
+    private statistics;
+    constructor(options?: ProgressOptions);
+    reset(): void;
+    start(total: number, language?: string | null): void;
+    increment(type?: string): void;
+    private _processUpdate;
+    private _ensureDataConsistency;
+    private _processPendingUpdates;
+    private _shouldLog;
+    private _startSpinner;
+    private _stopSpinner;
+    private _renderProgress;
+    private _updateStatistics;
+    private _finalReport;
+    getStatus(): ProgressStatus;
+    setLogToConsole(value: boolean): void;
+}
+export default ProgressTracker;

package/dist/utils/prompt-templates.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Prompt template utilities for translation and analysis
+ */
+export interface PromptOptions {
+    mode?: "smart" | "strict" | "flexible" | "exact" | "relaxed";
+    lengthControl?: any;
+    targetLang?: string;
+    detectedContext?: {
+        category?: string;
+        confidence?: number;
+        prompt?: string;
+        existingTranslation?: string;
+        similarTranslation?: {
+            source: string;
+            target: string;
+            similarity: number;
+        };
+    };
+    styleGuide?: {
+        formality?: string;
+        toneOfVoice?: string;
+    };
+    categories?: Record<string, any>;
+    allowNewCategories?: boolean;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+/**
+ * Get translation prompt
+ */
+declare const getPrompt: (provider: string, sourceLang: string, targetLang: string, text: string, options?: PromptOptions) => any;
+/**
+ * Get analysis prompt
+ */
+declare const getAnalysisPrompt: (provider: string, text: string, options?: PromptOptions) => any;
+export { getPrompt, getAnalysisPrompt };

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

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

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

@@ -0,0 +1,79 @@
+/**
+ * Base Quality Checker.
+ * Common infrastructure for all quality checkers.
+ */
+export interface CheckerOptions {
+    placeholderConsistency?: boolean;
+    htmlTagsConsistency?: boolean;
+    punctuationCheck?: boolean;
+    lengthValidation?: boolean;
+    sanitizeOutput?: boolean;
+    rules?: Record<string, any>;
+    styleGuide?: {
+        formality?: string;
+        toneOfVoice?: string;
+    };
+    context?: Record<string, any>;
+    [key: string]: any;
+}
+export interface Issue {
+    type: string;
+    message: string;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface Fix {
+    type: string;
+    message: string;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    issues: Issue[];
+    source?: string;
+    translated?: string;
+    context?: Record<string, any>;
+}
+export interface FixResult {
+    originalText: string;
+    fixedText: string;
+    isModified: boolean;
+    issues: Issue[];
+    fixes: Fix[];
+    metadata?: {
+        sourceLength: number;
+        originalLength: number;
+        fixedLength: number;
+        timestamp: string;
+    };
+}
+declare class BaseChecker {
+    protected rules: Record<string, boolean | any>;
+    protected styleGuide: {
+        formality: string;
+        toneOfVoice: string;
+    };
+    /**
+     * Create a new BaseChecker.
+     * @param {CheckerOptions} [options={}] - Configuration options.
+     */
+    constructor(options?: CheckerOptions);
+    /**
+     * Create an issue object.
+     */
+    createIssue(type: string, message: string, details?: Record<string, any>): Issue;
+    /**
+     * Create a fix object.
+     */
+    createFix(type: string, message: string, details?: Record<string, any>): Fix;
+    /**
+     * Validate translation.
+     */
+    validate(_sourceText: string, _translatedText: string, _options?: any): ValidationResult;
+    /**
+     * Validate and fix translation.
+     */
+    validateAndFix(sourceText: string, translatedText: string): FixResult;
+}
+export default BaseChecker;

package/dist/utils/quality/code-block-checker.d.ts

@@ -0,0 +1,64 @@
+export interface CodeBlockIssue {
+    type: "code-block-count" | "code-block-modified" | "code-block-restore";
+    severity: "error" | "critical";
+    message: string;
+    details?: any;
+}
+export interface CodeBlockFixResult {
+    text: string;
+    foundIssues: CodeBlockIssue[];
+    appliedFixes: {
+        type: "code-block-restore";
+        message: string;
+    }[];
+}
+export interface CodeBlock {
+    type: "fenced" | "inline" | "html-code" | "html-pre";
+    full: string;
+    code: string;
+    position: number;
+}
+/**
+ * Code Block Preservation Checker.
+ * Ensures code blocks are preserved exactly during translation.
+ */
+declare class CodeBlockChecker {
+    private codePatterns;
+    constructor();
+    /**
+     * Check if code blocks are preserved.
+     */
+    checkCodeBlockPreservation(sourceText: string, translatedText: string): CodeBlockIssue[];
+    /**
+     * Extract all code blocks from text.
+     */
+    extractCodeBlocks(text: string): CodeBlock[];
+    /**
+     * Fix code block preservation issues.
+     */
+    fixCodeBlockPreservation(sourceText: string, translatedText: string): CodeBlockFixResult;
+    /**
+     * Restore missing code blocks from source.
+     */
+    restoreCodeBlocks(sourceText: string, translatedText: string, sourceCodeBlocks: CodeBlock[]): {
+        text: string;
+        appliedFixes: any[];
+    };
+    /**
+     * Protect code blocks before translation.
+     * Replaces code blocks with tokens to prevent translation.
+     */
+    protectCodeBlocks(text: string): {
+        protectedText: string;
+        tokenMap: Map<string, string>;
+    };
+    /**
+     * Restore code blocks after translation.
+     */
+    restoreCodeBlocksFromTokens(text: string, tokenMap: Map<string, string>): string;
+    /**
+     * Check if text contains code blocks.
+     */
+    hasCodeBlocks(text: string): boolean;
+}
+export default CodeBlockChecker;

package/dist/utils/quality/html-tag-checker.d.ts

@@ -0,0 +1,33 @@
+export interface HtmlTagIssue {
+    type: "htmlTag";
+    message: string;
+    source?: string[];
+    translated?: string[];
+}
+export interface HtmlTagFixResult {
+    text: string;
+    foundIssues: HtmlTagIssue[];
+    appliedFixes: {
+        type: "htmlTag";
+        message: string;
+    }[];
+}
+/**
+ * HTML Tag Consistency Checker.
+ * Ensures HTML tags are preserved and correctly nested in translations.
+ */
+declare class HtmlTagChecker {
+    /**
+     * Check for HTML tag mismatches between source and translation.
+     */
+    checkHtmlTags(source: string, translated: string): HtmlTagIssue[];
+    /**
+     * Fix missing HTML tags in translated text.
+     */
+    fixHtmlTags(source: string, translated: string): HtmlTagFixResult;
+    /**
+     * Insert HTML tag into text.
+     */
+    insertHtmlTag(text: string, tag: string): string;
+}
+export default HtmlTagChecker;

package/dist/utils/quality/index.d.ts

@@ -0,0 +1,39 @@
+import BaseChecker, { CheckerOptions, FixResult, ValidationResult } from "./base-checker.js";
+/**
+ * Main Quality Checker Class.
+ * Orchestrates various quality checks and fixes for translated text.
+ */
+declare class QualityChecker extends BaseChecker {
+    private placeholderChecker;
+    private htmlTagChecker;
+    private punctuationChecker;
+    private lengthChecker;
+    private textSanitizer;
+    private quoteBalanceChecker;
+    private styleGuideChecker;
+    private markdownChecker;
+    private codeBlockChecker;
+    private specialCharactersChecker;
+    private context;
+    /**
+     * Initialize QualityChecker with options.
+     */
+    constructor(options?: CheckerOptions);
+    /**
+     * Initialize all individual checkers.
+     */
+    initializeCheckers(): void;
+    /**
+     * Validate translated text against source text.
+     */
+    validate(sourceText: string, translatedText: string, options?: Record<string, any>): ValidationResult;
+    /**
+     * Validate and attempt to fix translated text.
+     */
+    validateAndFix(sourceText: string, translatedText: string): FixResult;
+    /**
+     * Sanitize translated text using multiple passes.
+     */
+    sanitizeTranslation(text: string): string;
+}
+export default QualityChecker;

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

@@ -0,0 +1,70 @@
+export interface LengthConfig {
+    mode: "strict" | "flexible" | "exact" | "relaxed" | "smart";
+    maxDeviation: number;
+    minDeviation: number;
+    targetLang?: string;
+    context?: string;
+}
+export interface LengthIssue {
+    type: "length";
+    severity: "critical" | "warning" | "error";
+    message: string;
+    details: {
+        mode?: string;
+        context?: string;
+        targetLang?: string;
+        sourceLength?: number;
+        translatedLength?: number;
+        ratio?: number;
+        allowedRange?: {
+            min: number;
+            max: number;
+        };
+        deviation?: number;
+        error?: string;
+    };
+}
+/**
+ * Length Validation Checker.
+ * Checks if translated text length is within acceptable bounds relative to source text.
+ */
+declare class LengthChecker {
+    private defaultConfig;
+    constructor();
+    /**
+     * Check if translated text length is acceptable.
+     */
+    checkLength(source: string, translated: string, options?: any): LengthIssue[];
+    /**
+     * Calculate length of text ignoring whitespace.
+     */
+    calculateLength(text: string): number;
+    /**
+     * Get configuration for length check.
+     */
+    getConfig(options: any): LengthConfig;
+    /**
+     * Get configuration for smart mode.
+     */
+    getSmartModeConfig(lengthControl: any, targetLang: string, context: string): LengthConfig;
+    /**
+     * Get configuration for standard mode.
+     */
+    getStandardModeConfig(lengthControl: any, mode: any, targetLang: string, context: string): LengthConfig;
+    /**
+     * Calculate allowed length ratio range.
+     */
+    calculateAllowedRange(config: LengthConfig): {
+        minRatio: number;
+        maxRatio: number;
+    };
+    /**
+     * Determine severity of length mismatch.
+     */
+    determineSeverity(ratio: number, minRatio: number, maxRatio: number): "critical" | "warning";
+    /**
+     * Generate error message for length mismatch.
+     */
+    generateErrorMessage(ratio: number, config: LengthConfig): string;
+}
+export default LengthChecker;

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

@@ -0,0 +1,63 @@
+export interface MarkdownIssue {
+    type: "markdown-preservation" | "markdown-link" | "markdown-missing";
+    severity: "error" | "warning" | "critical";
+    message: string;
+    pattern?: string;
+    details?: any;
+}
+export interface MarkdownFixResult {
+    text: string;
+    foundIssues: MarkdownIssue[];
+    appliedFixes: {
+        type: "markdown-link";
+        message: string;
+    }[];
+}
+/**
+ * Markdown Preservation Checker.
+ * Ensures markdown formatting is preserved during translation.
+ */
+declare class MarkdownChecker {
+    private markdownPatterns;
+    constructor();
+    /**
+     * Check if markdown is preserved between source and translation.
+     */
+    checkMarkdownPreservation(sourceText: string, translatedText: string): MarkdownIssue[];
+    /**
+     * Check for broken markdown links.
+     */
+    checkBrokenMarkdownLinks(text: string): MarkdownIssue[];
+    /**
+     * Fix markdown preservation issues.
+     */
+    fixMarkdownPreservation(sourceText: string, translatedText: string): MarkdownFixResult;
+    /**
+     * Extract markdown elements from text.
+     */
+    extractMarkdownElements(text: string): Record<string, any[]>;
+    /**
+     * Restore markdown elements that were lost in translation.
+     */
+    restoreMarkdownElements(text: string, elements: any[], type: string): {
+        text: string;
+        foundIssues: MarkdownIssue[];
+        appliedFixes: any[];
+    };
+    /**
+     * Fix broken markdown links.
+     */
+    fixBrokenLinks(text: string): {
+        text: string;
+        foundIssues: MarkdownIssue[];
+        appliedFixes: {
+            type: "markdown-link";
+            message: string;
+        }[];
+    };
+    /**
+     * Check if text contains markdown.
+     */
+    hasMarkdown(text: string): boolean;
+}
+export default MarkdownChecker;

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

@@ -0,0 +1,42 @@
+export interface PlaceholderIssue {
+    type: "placeholder";
+    message: string;
+    source?: string[] | string;
+    translated?: string[] | string;
+    corrupted?: string;
+}
+export interface PlaceholderFixResult {
+    text: string;
+    foundIssues: PlaceholderIssue[];
+    appliedFixes: {
+        type: "placeholder";
+        message: string;
+    }[];
+}
+/**
+ * Placeholder Consistency Checker.
+ * Ensures placeholders like {name}, ${value}, %s are preserved correctly.
+ */
+declare class PlaceholderChecker {
+    /**
+     * Check for placeholder mismatches or corruptions.
+     */
+    checkPlaceholders(source: string, translated: string): PlaceholderIssue[];
+    /**
+     * Fix corrupted or missing placeholders in translated text.
+     */
+    fixPlaceholders(source: string, translated: string): PlaceholderFixResult;
+    /**
+     * Find a corrupted version of a placeholder in translated text.
+     */
+    findCorruptedPlaceholder(translated: string, sourcePlaceholder: string): string | null;
+    /**
+     * Find best position to insert a missing placeholder.
+     */
+    findBestPlaceholderPosition(translated: string, source: string, placeholder: string): number;
+    /**
+     * Insert placeholder into text at specified position.
+     */
+    insertPlaceholder(text: string, placeholder: string, position: number): string;
+}
+export default PlaceholderChecker;