@llm-translate/cli 1.0.0-next.1

package/dist/cli/index.js

@@ -0,0 +1,4494 @@
+#!/usr/bin/env node
+import { cosmiconfig } from 'cosmiconfig';
+import { z } from 'zod';
+import { access, writeFile, readFile, readdir, mkdir } from 'fs/promises';
+import chalk from 'chalk';
+import 'unified';
+import 'remark-parse';
+import 'remark-stringify';
+import 'remark-gfm';
+import 'unist-util-visit';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { generateText, streamText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { resolve, relative, join, dirname, extname, basename } from 'path';
+import { Command } from 'commander';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+import { HTTPException } from 'hono/http-exception';
+import { createMiddleware } from 'hono/factory';
+import { zValidator } from '@hono/zod-validator';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/options.ts
+var defaults;
+var init_options = __esm({
+  "src/cli/options.ts"() {
+    defaults = {
+      quality: 85,
+      maxIterations: 4,
+      chunkSize: 1024,
+      parallel: 3,
+      provider: "claude"
+    };
+  }
+});
+
+// src/errors.ts
+function formatErrorMessage(code, details) {
+  let message = errorMessages[code] ?? errorMessages["UNKNOWN_ERROR" /* UNKNOWN_ERROR */];
+  if (details) {
+    for (const [key, value] of Object.entries(details)) {
+      message = message.replace(`{${key}}`, String(value));
+    }
+  }
+  return message;
+}
+function getExitCode(error) {
+  switch (error.code) {
+    case "FILE_NOT_FOUND" /* FILE_NOT_FOUND */:
+    case "CONFIG_NOT_FOUND" /* CONFIG_NOT_FOUND */:
+    case "GLOSSARY_NOT_FOUND" /* GLOSSARY_NOT_FOUND */:
+      return ExitCode.FILE_NOT_FOUND;
+    case "CONFIG_INVALID" /* CONFIG_INVALID */:
+    case "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */:
+      return ExitCode.INVALID_ARGUMENTS;
+    case "QUALITY_THRESHOLD_NOT_MET" /* QUALITY_THRESHOLD_NOT_MET */:
+      return ExitCode.QUALITY_THRESHOLD_NOT_MET;
+    case "PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */:
+    case "PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */:
+    case "PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */:
+    case "PROVIDER_ERROR" /* PROVIDER_ERROR */:
+      return ExitCode.PROVIDER_ERROR;
+    case "GLOSSARY_INVALID" /* GLOSSARY_INVALID */:
+      return ExitCode.GLOSSARY_VALIDATION_FAILED;
+    default:
+      return ExitCode.GENERAL_ERROR;
+  }
+}
+var errorMessages, TranslationError, ExitCode;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    errorMessages = {
+      ["CONFIG_NOT_FOUND" /* CONFIG_NOT_FOUND */]: "Configuration file not found. Run `llm-translate init` to create one.",
+      ["CONFIG_INVALID" /* CONFIG_INVALID */]: "Configuration file is invalid. Please check the format and required fields.",
+      ["GLOSSARY_NOT_FOUND" /* GLOSSARY_NOT_FOUND */]: "Glossary file not found at the specified path.",
+      ["GLOSSARY_INVALID" /* GLOSSARY_INVALID */]: "Glossary file is invalid. Please check the JSON format and structure.",
+      ["PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */]: "The specified LLM provider is not available. Supported providers: claude, openai, ollama.",
+      ["PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */]: "Authentication failed. Check your API key in environment variables.",
+      ["PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */]: "Rate limited by the LLM provider. Please wait and try again.",
+      ["PROVIDER_ERROR" /* PROVIDER_ERROR */]: "An error occurred while communicating with the LLM provider.",
+      ["QUALITY_THRESHOLD_NOT_MET" /* QUALITY_THRESHOLD_NOT_MET */]: "Translation quality ({score}) did not meet threshold ({threshold}). Use --quality to adjust or --max-iterations to allow more refinement.",
+      ["GLOSSARY_COMPLIANCE_FAILED" /* GLOSSARY_COMPLIANCE_FAILED */]: "Glossary compliance failed. Missing terms: {missed}. Use --no-strict-glossary to allow partial compliance.",
+      ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: "The specified file was not found.",
+      ["FILE_READ_ERROR" /* FILE_READ_ERROR */]: "Failed to read the file.",
+      ["FILE_WRITE_ERROR" /* FILE_WRITE_ERROR */]: "Failed to write to the output file.",
+      ["UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */]: "The file format is not supported. Supported formats: markdown, html, text.",
+      ["CHUNK_TOO_LARGE" /* CHUNK_TOO_LARGE */]: "A chunk exceeds the maximum token limit and cannot be processed.",
+      ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: "An unexpected error occurred."
+    };
+    TranslationError = class _TranslationError extends Error {
+      code;
+      details;
+      constructor(code, details, customMessage) {
+        const message = customMessage ?? formatErrorMessage(code, details);
+        super(message);
+        this.name = "TranslationError";
+        this.code = code;
+        this.details = details;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _TranslationError);
+        }
+      }
+      /**
+       * Create a JSON representation of the error
+       */
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          details: this.details
+        };
+      }
+    };
+    ExitCode = {
+      SUCCESS: 0,
+      GENERAL_ERROR: 1,
+      INVALID_ARGUMENTS: 2,
+      FILE_NOT_FOUND: 3,
+      QUALITY_THRESHOLD_NOT_MET: 4,
+      PROVIDER_ERROR: 5,
+      GLOSSARY_VALIDATION_FAILED: 6
+    };
+  }
+});
+async function loadConfig(options = {}) {
+  const { configPath, cwd = process.cwd() } = options;
+  let result;
+  try {
+    if (configPath) {
+      result = await explorer.load(configPath);
+    } else {
+      result = await explorer.search(cwd);
+    }
+  } catch (error) {
+    throw new TranslationError("CONFIG_NOT_FOUND" /* CONFIG_NOT_FOUND */, {
+      path: configPath ?? cwd,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!result || result.isEmpty) {
+    return defaultConfig;
+  }
+  const parseResult = configSchema.safeParse(result.config);
+  if (!parseResult.success) {
+    throw new TranslationError("CONFIG_INVALID" /* CONFIG_INVALID */, {
+      path: result.filepath,
+      errors: parseResult.error.errors.map((e) => ({
+        path: e.path.join("."),
+        message: e.message
+      }))
+    });
+  }
+  return parseResult.data;
+}
+function mergeConfig(config2, overrides) {
+  const merged = { ...config2 };
+  if (overrides.sourceLang) {
+    merged.languages = { ...merged.languages, source: overrides.sourceLang };
+  }
+  if (overrides.targetLang) {
+    merged.languages = {
+      ...merged.languages,
+      targets: [overrides.targetLang]
+    };
+  }
+  if (overrides.provider) {
+    merged.provider = { ...merged.provider, default: overrides.provider };
+  }
+  if (overrides.model) {
+    merged.provider = { ...merged.provider, model: overrides.model };
+  }
+  if (overrides.quality !== void 0) {
+    merged.quality = { ...merged.quality, threshold: overrides.quality };
+  }
+  if (overrides.maxIterations !== void 0) {
+    merged.quality = {
+      ...merged.quality,
+      maxIterations: overrides.maxIterations
+    };
+  }
+  if (overrides.chunkSize !== void 0) {
+    merged.chunking = { ...merged.chunking, maxTokens: overrides.chunkSize };
+  }
+  if (overrides.glossary) {
+    merged.glossary = {
+      path: overrides.glossary,
+      strict: merged.glossary?.strict ?? false
+    };
+  }
+  if (overrides.output) {
+    merged.paths = { ...merged.paths, output: overrides.output };
+  }
+  if (overrides.noCache) {
+    merged.paths = { ...merged.paths, cache: void 0 };
+  }
+  return merged;
+}
+var providerNameSchema, configSchema, defaultConfig, explorer;
+var init_config = __esm({
+  "src/services/config.ts"() {
+    init_errors();
+    providerNameSchema = z.enum(["claude", "openai", "ollama", "custom"]);
+    configSchema = z.object({
+      version: z.string(),
+      project: z.object({
+        name: z.string(),
+        description: z.string(),
+        purpose: z.string()
+      }).optional(),
+      languages: z.object({
+        source: z.string(),
+        targets: z.array(z.string()),
+        styles: z.record(z.string(), z.string()).optional()
+      }),
+      provider: z.object({
+        default: providerNameSchema,
+        model: z.string().optional(),
+        fallback: z.array(providerNameSchema).optional(),
+        apiKeys: z.record(providerNameSchema, z.string()).optional()
+      }),
+      quality: z.object({
+        threshold: z.number().min(0).max(100),
+        maxIterations: z.number().min(1).max(10),
+        evaluationMethod: z.enum(["llm", "embedding", "hybrid"])
+      }),
+      chunking: z.object({
+        maxTokens: z.number().min(100).max(8e3),
+        overlapTokens: z.number().min(0),
+        preserveStructure: z.boolean()
+      }),
+      glossary: z.object({
+        path: z.string(),
+        strict: z.boolean()
+      }).optional(),
+      paths: z.object({
+        output: z.string(),
+        cache: z.string().optional()
+      }),
+      ignore: z.array(z.string()).optional()
+    });
+    defaultConfig = {
+      version: "1.0",
+      languages: {
+        source: "en",
+        targets: []
+      },
+      provider: {
+        default: "claude"
+      },
+      quality: {
+        threshold: 85,
+        maxIterations: 4,
+        evaluationMethod: "llm"
+      },
+      chunking: {
+        maxTokens: 1024,
+        overlapTokens: 150,
+        preserveStructure: true
+      },
+      paths: {
+        output: "./{lang}"
+      }
+    };
+    explorer = cosmiconfig("translate", {
+      searchPlaces: [
+        ".translaterc",
+        ".translaterc.json",
+        ".translaterc.yaml",
+        ".translaterc.yml",
+        "translate.config.js",
+        "translate.config.mjs"
+      ]
+    });
+  }
+});
+
+// src/types/mqm.ts
+function calculateMQMScore(errors) {
+  const totalPenalty = errors.reduce(
+    (sum, err) => sum + MQM_SEVERITY_WEIGHTS[err.severity],
+    0
+  );
+  return Math.max(0, 100 - totalPenalty);
+}
+function calculateMQMBreakdown(errors) {
+  return {
+    accuracy: errors.filter((e) => e.type.startsWith("accuracy/")).length,
+    fluency: errors.filter((e) => e.type.startsWith("fluency/")).length,
+    style: errors.filter((e) => e.type.startsWith("style/")).length
+  };
+}
+function parseMQMResponse(response) {
+  try {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return null;
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    const errors = parsed.errors ?? [];
+    const score = parsed.score ?? calculateMQMScore(errors);
+    return {
+      errors,
+      score,
+      summary: parsed.summary ?? "",
+      breakdown: calculateMQMBreakdown(errors)
+    };
+  } catch {
+    return null;
+  }
+}
+function formatMQMErrorsForPrompt(errors) {
+  if (errors.length === 0) {
+    return "No errors identified.";
+  }
+  return errors.map((err, i) => {
+    const severity = err.severity.toUpperCase();
+    return `${i + 1}. [${severity}] ${err.type}
+   Text: "${err.span}"
+   Fix: "${err.suggestion}"${err.explanation ? `
+   Reason: ${err.explanation}` : ""}`;
+  }).join("\n\n");
+}
+var MQM_SEVERITY_WEIGHTS;
+var init_mqm = __esm({
+  "src/types/mqm.ts"() {
+    MQM_SEVERITY_WEIGHTS = {
+      minor: 1,
+      // Noticeable but doesn't affect understanding
+      major: 5,
+      // Affects understanding or usability
+      critical: 25
+      // Completely wrong or unusable
+    };
+  }
+});
+
+// src/types/analysis.ts
+function parseAnalysisResponse(response) {
+  try {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return null;
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      keyTerms: parsed.keyTerms ?? [],
+      ambiguousPhrases: parsed.ambiguousPhrases ?? [],
+      preserveExact: parsed.preserveExact ?? [],
+      challenges: parsed.challenges ?? [],
+      domain: parsed.domain ?? "general",
+      registerRecommendation: parsed.registerRecommendation ?? "neutral"
+    };
+  } catch {
+    return null;
+  }
+}
+function formatAnalysisForPrompt(analysis) {
+  const sections = [];
+  if (analysis.keyTerms.length > 0) {
+    const terms = analysis.keyTerms.map((t) => {
+      const translation = t.suggestedTranslation ? ` \u2192 ${t.suggestedTranslation}` : "";
+      const source = t.fromGlossary ? " (glossary)" : "";
+      return `- "${t.term}"${translation}${source}: ${t.context}`;
+    }).join("\n");
+    sections.push(`**Key Terms:**
+${terms}`);
+  }
+  if (analysis.ambiguousPhrases.length > 0) {
+    const phrases = analysis.ambiguousPhrases.map((p) => `- "${p.phrase}": Use interpretation "${p.recommendation}"`).join("\n");
+    sections.push(`**Ambiguous Phrases (use these interpretations):**
+${phrases}`);
+  }
+  if (analysis.preserveExact.length > 0) {
+    sections.push(
+      `**Do NOT translate (keep exactly as-is):**
+${analysis.preserveExact.map((s) => `- ${s}`).join("\n")}`
+    );
+  }
+  sections.push(
+    `**Content Type:** ${analysis.domain}
+**Tone:** ${analysis.registerRecommendation}`
+  );
+  return sections.join("\n\n");
+}
+function createEmptyAnalysis() {
+  return {
+    keyTerms: [],
+    ambiguousPhrases: [],
+    preserveExact: [],
+    challenges: [],
+    domain: "general",
+    registerRecommendation: "neutral"
+  };
+}
+var init_analysis = __esm({
+  "src/types/analysis.ts"() {
+  }
+});
+
+// src/types/modes.ts
+function getModeConfig(mode, overrides) {
+  const preset = MODE_PRESETS[mode];
+  {
+    return preset;
+  }
+}
+var MODE_PRESETS;
+var init_modes = __esm({
+  "src/types/modes.ts"() {
+    MODE_PRESETS = {
+      /**
+       * Fast mode: Single pass, no evaluation
+       * Best for: Quick drafts, large batches, local models
+       * Speed: ~1x (fastest)
+       */
+      fast: {
+        enableAnalysis: false,
+        useMQMEvaluation: false,
+        maxIterations: 1,
+        qualityThreshold: 0
+        // Skip threshold check
+      },
+      /**
+       * Balanced mode: TEaR with MQM evaluation
+       * Best for: General use, good quality with reasonable speed
+       * Speed: ~2-3x
+       */
+      balanced: {
+        enableAnalysis: false,
+        useMQMEvaluation: true,
+        maxIterations: 2,
+        qualityThreshold: 75
+      },
+      /**
+       * Quality mode: Full MAPS + TEaR pipeline
+       * Best for: Production content, critical documents
+       * Speed: ~4-5x
+       */
+      quality: {
+        enableAnalysis: true,
+        useMQMEvaluation: true,
+        maxIterations: 4,
+        qualityThreshold: 85
+      }
+    };
+  }
+});
+async function loadGlossary(path) {
+  let content;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch (error) {
+    throw new TranslationError("GLOSSARY_NOT_FOUND" /* GLOSSARY_NOT_FOUND */, {
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new TranslationError("GLOSSARY_INVALID" /* GLOSSARY_INVALID */, {
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function resolveGlossary(glossary, targetLang) {
+  return {
+    metadata: {
+      name: glossary.metadata.name,
+      sourceLang: glossary.metadata.sourceLang,
+      targetLang,
+      version: glossary.metadata.version,
+      domain: glossary.metadata.domain
+    },
+    terms: glossary.terms.map((term) => resolveGlossaryTerm(term, targetLang)).filter((term) => term !== null)
+  };
+}
+function resolveGlossaryTerm(term, targetLang) {
+  const target = resolveTarget(term, targetLang);
+  if (target === void 0) {
+    return null;
+  }
+  return {
+    source: term.source,
+    target,
+    context: term.context,
+    caseSensitive: term.caseSensitive ?? false,
+    doNotTranslate: resolveDoNotTranslate(term, targetLang)
+  };
+}
+function resolveTarget(term, targetLang) {
+  if (term.doNotTranslate) {
+    return term.source;
+  }
+  if (term.doNotTranslateFor?.includes(targetLang)) {
+    return term.source;
+  }
+  const translation = term.targets[targetLang];
+  if (translation) {
+    return translation;
+  }
+  return void 0;
+}
+function resolveDoNotTranslate(term, targetLang) {
+  return term.doNotTranslate === true || term.doNotTranslateFor?.includes(targetLang) === true;
+}
+function createGlossaryLookup(glossary) {
+  const termMap = /* @__PURE__ */ new Map();
+  const caseSensitiveTerms = [];
+  const caseInsensitiveTerms = [];
+  for (const term of glossary.terms) {
+    if (term.caseSensitive) {
+      termMap.set(term.source, term);
+      caseSensitiveTerms.push(term);
+    } else {
+      termMap.set(term.source.toLowerCase(), term);
+      caseInsensitiveTerms.push(term);
+    }
+  }
+  return {
+    find(text) {
+      const exact = termMap.get(text);
+      if (exact) return exact;
+      return termMap.get(text.toLowerCase());
+    },
+    findAll(text) {
+      const matches = [];
+      for (const term of caseSensitiveTerms) {
+        if (text.includes(term.source)) {
+          matches.push(term);
+        }
+      }
+      const lowerText = text.toLowerCase();
+      for (const term of caseInsensitiveTerms) {
+        if (lowerText.includes(term.source.toLowerCase())) {
+          matches.push(term);
+        }
+      }
+      return matches;
+    },
+    getTerms() {
+      return glossary.terms;
+    },
+    formatForPrompt() {
+      const lines = [];
+      for (const term of glossary.terms) {
+        const flags = [];
+        if (term.caseSensitive) {
+          flags.push("case-sensitive");
+        } else {
+          flags.push("case-insensitive");
+        }
+        if (term.context) {
+          flags.push(`context: ${term.context}`);
+        }
+        const flagStr = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        if (term.doNotTranslate) {
+          lines.push(`- "${term.source}" \u2192 [DO NOT TRANSLATE, keep as-is]${flagStr}`);
+        } else {
+          lines.push(`- "${term.source}" \u2192 "${term.target}"${flagStr}`);
+        }
+      }
+      return lines.join("\n");
+    }
+  };
+}
+var init_glossary = __esm({
+  "src/services/glossary.ts"() {
+    init_errors();
+  }
+});
+function configureLogger(options) {
+  config = { ...config, ...options };
+}
+function shouldLog(level) {
+  if (config.quiet && level !== "error") {
+    return false;
+  }
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[config.level];
+}
+function formatMessage(level, message, data) {
+  if (config.json) {
+    return JSON.stringify({
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...data
+    });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  const prefix = `[${timestamp}]`;
+  switch (level) {
+    case "debug":
+      return chalk.gray(`${prefix} ${message}`);
+    case "info":
+      return `${prefix} ${message}`;
+    case "warn":
+      return chalk.yellow(`${prefix} \u26A0 ${message}`);
+    case "error":
+      return chalk.red(`${prefix} \u2717 ${message}`);
+  }
+}
+function createTimer() {
+  const start = performance.now();
+  return {
+    elapsed() {
+      return performance.now() - start;
+    },
+    format() {
+      const ms = this.elapsed();
+      if (ms < 1e3) {
+        return `${ms.toFixed(0)}ms`;
+      }
+      return `${(ms / 1e3).toFixed(1)}s`;
+    }
+  };
+}
+var LOG_LEVEL_PRIORITY, config, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    LOG_LEVEL_PRIORITY = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    config = {
+      level: "info",
+      quiet: false,
+      json: false
+    };
+    logger = {
+      debug(message, data) {
+        if (shouldLog("debug")) {
+          console.log(formatMessage("debug", message, data));
+        }
+      },
+      info(message, data) {
+        if (shouldLog("info")) {
+          console.log(formatMessage("info", message, data));
+        }
+      },
+      warn(message, data) {
+        if (shouldLog("warn")) {
+          console.warn(formatMessage("warn", message, data));
+        }
+      },
+      error(message, data) {
+        if (shouldLog("error")) {
+          console.error(formatMessage("error", message, data));
+        }
+      },
+      success(message) {
+        if (!config.quiet) {
+          console.log(chalk.green(`\u2713 ${message}`));
+        }
+      },
+      progress(current, total, message) {
+        if (!config.quiet && !config.json) {
+          const percent = Math.round(current / total * 100);
+          const bar = "\u2588".repeat(Math.round(percent / 5)) + "\u2591".repeat(20 - Math.round(percent / 5));
+          process.stdout.write(`\r[${bar}] ${percent}% ${message}`);
+          if (current === total) {
+            console.log();
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/agent.ts
+function buildSystemInstructions(sourceLang, targetLang) {
+  return `You are a professional translator specializing in ${sourceLang} to ${targetLang} translation.
+
+## Rules:
+1. Apply glossary terms exactly as specified
+2. Preserve all formatting (markdown, HTML tags, code blocks)
+3. Maintain the same tone and style
+4. Do not translate content inside code blocks
+5. Keep URLs, file paths, and technical identifiers unchanged
+6. Keep placeholders like __CODE_BLOCK_0__ unchanged`;
+}
+function buildGlossarySection(glossaryText) {
+  return `## Glossary (MUST use these exact translations):
+${glossaryText || "No glossary provided."}`;
+}
+function buildTranslationContent(sourceText, context) {
+  const styleSection = context?.styleInstruction ? `Style: ${context.styleInstruction}
+` : "";
+  return `## Document Context:
+Purpose: ${context?.documentPurpose ?? "General translation"}
+${styleSection}Previous content: ${context?.previousContext ?? "None"}
+
+## Source Text:
+${sourceText}
+
+Provide ONLY the translated text below, with no additional commentary or headers:`;
+}
+function buildCacheableTranslationMessage(sourceText, sourceLang, targetLang, glossaryText, context) {
+  const systemInstructions = buildSystemInstructions(sourceLang, targetLang);
+  const glossarySection = buildGlossarySection(glossaryText);
+  const translationContent = buildTranslationContent(sourceText, context);
+  const contentParts = [
+    {
+      type: "text",
+      text: systemInstructions,
+      cacheControl: { type: "ephemeral" }
+    },
+    {
+      type: "text",
+      text: glossarySection,
+      cacheControl: { type: "ephemeral" }
+    },
+    {
+      type: "text",
+      text: translationContent
+      // No cache control - this is dynamic per request
+    }
+  ];
+  return {
+    role: "user",
+    content: contentParts
+  };
+}
+function buildInitialTranslationPrompt(sourceText, sourceLang, targetLang, glossaryText, context) {
+  const styleSection = context?.styleInstruction ? `Style: ${context.styleInstruction}
+` : "";
+  return `You are a professional translator. Translate the following ${sourceLang} text to ${targetLang}.
+
+## Glossary (MUST use these exact translations):
+${glossaryText || "No glossary provided."}
+
+## Document Context:
+Purpose: ${context?.documentPurpose ?? "General translation"}
+${styleSection}Previous content: ${context?.previousContext ?? "None"}
+
+## Rules:
+1. Apply glossary terms exactly as specified
+2. Preserve all formatting (markdown, HTML tags, code blocks)
+3. Maintain the same tone and style
+4. Do not translate content inside code blocks
+5. Keep URLs, file paths, and technical identifiers unchanged
+6. Keep placeholders like __CODE_BLOCK_0__ unchanged
+
+## Source Text:
+${sourceText}
+
+Provide ONLY the translated text below, with no additional commentary or headers:`;
+}
+function buildReflectionPrompt(sourceText, translatedText, sourceLang, targetLang, glossaryText) {
+  return `Review this translation and provide specific improvement suggestions.
+
+## Source (${sourceLang}):
+${sourceText}
+
+## Translation (${targetLang}):
+${translatedText}
+
+## Glossary Requirements:
+${glossaryText || "No glossary provided."}
+
+## Evaluate and suggest improvements for:
+1. **Accuracy**: Does the translation convey the exact meaning?
+2. **Glossary Compliance**: Are all glossary terms applied correctly?
+3. **Fluency**: Does it read naturally in ${targetLang}?
+4. **Formatting**: Is the structure preserved?
+5. **Consistency**: Are terms translated consistently?
+
+Provide a numbered list of specific, actionable suggestions:`;
+}
+function buildImprovementPrompt(sourceText, currentTranslation, suggestions, glossaryText) {
+  return `Improve this translation based on the following suggestions.
+
+## Source Text:
+${sourceText}
+
+## Current Translation:
+${currentTranslation}
+
+## Improvement Suggestions:
+${suggestions}
+
+## Glossary (MUST apply):
+${glossaryText || "No glossary provided."}
+
+Provide ONLY the improved translation below, with no additional commentary or headers:`;
+}
+function buildQualityEvaluationPrompt(sourceText, translatedText, sourceLang, targetLang) {
+  return `Rate this translation's quality from 0 to 100.
+
+## Source (${sourceLang}):
+${sourceText}
+
+## Translation (${targetLang}):
+${translatedText}
+
+## Evaluation Criteria:
+- Semantic accuracy (40 points)
+- Fluency and naturalness (25 points)
+- Glossary compliance (20 points)
+- Format preservation (15 points)
+
+Respond with only a JSON object:
+{"score": <number>, "breakdown": {"accuracy": <n>, "fluency": <n>, "glossary": <n>, "format": <n>}, "issues": ["issue1", "issue2"]}`;
+}
+function buildMQMEvaluationPrompt(sourceText, translatedText, sourceLang, targetLang, glossaryText) {
+  return `Evaluate this translation using MQM (Multidimensional Quality Metrics) framework.
+
+## Source (${sourceLang}):
+${sourceText}
+
+## Translation (${targetLang}):
+${translatedText}
+
+## Glossary Terms (must be applied exactly):
+${glossaryText || "No glossary provided."}
+
+## MQM Error Categories:
+- accuracy/mistranslation: Incorrect meaning
+- accuracy/omission: Missing content from source
+- accuracy/addition: Extra content not in source
+- accuracy/untranslated: Source text left unchanged
+- fluency/grammar: Grammatical errors
+- fluency/spelling: Spelling/typos
+- fluency/register: Inappropriate formality
+- fluency/inconsistency: Inconsistent terminology
+- style/awkward: Unnatural phrasing
+- style/unidiomatic: Non-native expressions
+
+## Severity Weights:
+- "minor" (1 point): Noticeable but doesn't affect understanding
+- "major" (5 points): Affects understanding or usability
+- "critical" (25 points): Completely wrong or unusable
+
+## Instructions:
+1. Identify all translation errors
+2. Classify each by type and severity
+3. Provide the span and suggested fix
+4. Calculate score: 100 - sum(weights)
+
+Respond with only a JSON object:
+{
+  "errors": [
+    {"type": "accuracy/mistranslation", "severity": "major", "span": "affected text", "suggestion": "corrected text", "explanation": "reason"}
+  ],
+  "score": <100 - sum of weights>,
+  "summary": "brief overall assessment"
+}`;
+}
+function buildMQMRefinementPrompt(sourceText, currentTranslation, errors, glossaryText) {
+  const errorList = formatMQMErrorsForPrompt(errors);
+  return `Fix the following translation errors.
+
+## Source Text:
+${sourceText}
+
+## Current Translation:
+${currentTranslation}
+
+## Errors to Fix:
+${errorList}
+
+## Glossary (MUST apply):
+${glossaryText || "No glossary provided."}
+
+Apply ONLY the fixes listed above. Do not make other changes.
+Provide ONLY the corrected translation, with no additional commentary:`;
+}
+function buildPreAnalysisPrompt(sourceText, sourceLang, targetLang, glossaryText) {
+  return `Analyze this ${sourceLang} text before translating to ${targetLang}.
+
+## Source Text:
+${sourceText}
+
+## Available Glossary Terms:
+${glossaryText || "No glossary provided."}
+
+## Analyze and extract:
+1. **Key Terms**: Important domain-specific terms needing careful translation
+2. **Ambiguous Phrases**: Phrases with multiple possible interpretations
+3. **Preserve Exact**: Code, URLs, names that should NOT be translated
+4. **Challenges**: Specific difficulties for ${sourceLang}\u2192${targetLang}
+
+Respond with only a JSON object:
+{
+  "keyTerms": [{"term": "...", "context": "...", "suggestedTranslation": "...", "fromGlossary": true/false}],
+  "ambiguousPhrases": [{"phrase": "...", "interpretations": ["..."], "recommendation": "..."}],
+  "preserveExact": ["code snippets", "URLs", "names"],
+  "challenges": ["challenge 1", "challenge 2"],
+  "domain": "technical|marketing|legal|medical|general",
+  "registerRecommendation": "formal|informal|neutral"
+}`;
+}
+function createTranslationAgent(options) {
+  return new TranslationAgent(options);
+}
+var TranslationAgent;
+var init_agent = __esm({
+  "src/core/agent.ts"() {
+    init_mqm();
+    init_analysis();
+    init_modes();
+    init_glossary();
+    init_logger();
+    init_errors();
+    TranslationAgent = class {
+      provider;
+      qualityThreshold;
+      maxIterations;
+      verbose;
+      strictQuality;
+      enableCaching;
+      enableAnalysis;
+      useMQMEvaluation;
+      constructor(options) {
+        this.provider = options.provider;
+        this.verbose = options.verbose ?? false;
+        this.strictQuality = options.strictQuality ?? false;
+        const modeConfig = getModeConfig(options.mode ?? "balanced");
+        this.qualityThreshold = options.qualityThreshold ?? modeConfig.qualityThreshold;
+        this.maxIterations = options.maxIterations ?? modeConfig.maxIterations;
+        this.enableAnalysis = options.enableAnalysis ?? modeConfig.enableAnalysis;
+        this.useMQMEvaluation = options.useMQMEvaluation ?? modeConfig.useMQMEvaluation;
+        this.enableCaching = options.enableCaching ?? options.provider.name === "claude";
+        if (this.verbose) {
+          logger.info(`Translation mode: ${options.mode ?? "balanced"}`);
+          logger.info(`  - Analysis: ${this.enableAnalysis ? "enabled" : "disabled"}`);
+          logger.info(`  - MQM evaluation: ${this.useMQMEvaluation ? "enabled" : "disabled"}`);
+          logger.info(`  - Quality threshold: ${this.qualityThreshold}`);
+          logger.info(`  - Max iterations: ${this.maxIterations}`);
+        }
+      }
+      /**
+       * Translate content using Self-Refine loop with optional MAPS analysis and MQM evaluation
+       */
+      async translate(request) {
+        const timer = createTimer();
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalCacheReadTokens = 0;
+        let totalCacheWriteTokens = 0;
+        let iterations = 0;
+        const glossaryText = request.glossary ? createGlossaryLookup(
+          request.glossary
+        ).formatForPrompt() : "";
+        let analysis = null;
+        if (this.enableAnalysis) {
+          if (this.verbose) {
+            logger.info("Analyzing source text (MAPS)...");
+          }
+          analysis = await this.analyzeSource(
+            request.content,
+            request.sourceLang,
+            request.targetLang,
+            glossaryText
+          );
+          if (this.verbose && analysis) {
+            logger.info(`  - Domain: ${analysis.domain}`);
+            logger.info(`  - Key terms: ${analysis.keyTerms.length}`);
+            logger.info(`  - Challenges: ${analysis.challenges.length}`);
+          }
+        }
+        if (this.verbose) {
+          logger.info("Starting initial translation...");
+        }
+        const initialResult = await this.generateInitialTranslation(
+          request.content,
+          request.sourceLang,
+          request.targetLang,
+          glossaryText,
+          request.context,
+          analysis
+        );
+        let currentTranslation = initialResult.content;
+        iterations++;
+        totalInputTokens += initialResult.usage.inputTokens;
+        totalOutputTokens += initialResult.usage.outputTokens;
+        totalCacheReadTokens += initialResult.usage.cacheReadTokens ?? 0;
+        totalCacheWriteTokens += initialResult.usage.cacheWriteTokens ?? 0;
+        if (this.maxIterations <= 1 && this.qualityThreshold <= 0) {
+          if (this.verbose) {
+            logger.info("Fast mode: Skipping evaluation and refinement");
+          }
+          return {
+            content: currentTranslation,
+            metadata: {
+              qualityScore: 0,
+              qualityThreshold: 0,
+              thresholdMet: true,
+              iterations,
+              tokensUsed: {
+                input: totalInputTokens,
+                output: totalOutputTokens,
+                cacheRead: totalCacheReadTokens,
+                cacheWrite: totalCacheWriteTokens
+              },
+              duration: timer.elapsed(),
+              provider: this.provider.name,
+              model: "default"
+            },
+            glossaryCompliance: request.glossary ? this.checkGlossaryCompliance(
+              request.content,
+              currentTranslation,
+              request.glossary
+            ) : void 0
+          };
+        }
+        let qualityScore = 0;
+        let lastEvaluation = null;
+        let lastMQMEvaluation = null;
+        while (iterations < this.maxIterations) {
+          if (this.verbose) {
+            logger.info(
+              `Evaluating translation quality (iteration ${iterations})...`
+            );
+          }
+          if (this.useMQMEvaluation) {
+            lastMQMEvaluation = await this.evaluateQualityMQM(
+              request.content,
+              currentTranslation,
+              request.sourceLang,
+              request.targetLang,
+              glossaryText
+            );
+            qualityScore = lastMQMEvaluation.score;
+            if (this.verbose) {
+              logger.info(`MQM score: ${qualityScore}/${this.qualityThreshold}`);
+              if (lastMQMEvaluation.errors.length > 0) {
+                logger.info(`  - Errors: ${lastMQMEvaluation.errors.length} (${lastMQMEvaluation.breakdown.accuracy} accuracy, ${lastMQMEvaluation.breakdown.fluency} fluency, ${lastMQMEvaluation.breakdown.style} style)`);
+              }
+            }
+          } else {
+            lastEvaluation = await this.evaluateQuality(
+              request.content,
+              currentTranslation,
+              request.sourceLang,
+              request.targetLang
+            );
+            qualityScore = lastEvaluation.score;
+            if (this.verbose) {
+              logger.info(`Quality score: ${qualityScore}/${this.qualityThreshold}`);
+            }
+          }
+          if (qualityScore >= this.qualityThreshold) {
+            if (this.verbose) {
+              logger.success(
+                `Quality threshold met after ${iterations} iterations`
+              );
+            }
+            break;
+          }
+          if (this.verbose) {
+            logger.info("Refining translation...");
+          }
+          let improveResult;
+          if (this.useMQMEvaluation && lastMQMEvaluation && lastMQMEvaluation.errors.length > 0) {
+            improveResult = await this.refineWithMQM(
+              request.content,
+              currentTranslation,
+              lastMQMEvaluation.errors,
+              glossaryText
+            );
+          } else {
+            const suggestions = await this.generateReflection(
+              request.content,
+              currentTranslation,
+              request.sourceLang,
+              request.targetLang,
+              glossaryText
+            );
+            improveResult = await this.improveTranslation(
+              request.content,
+              currentTranslation,
+              suggestions,
+              glossaryText
+            );
+          }
+          currentTranslation = improveResult.content;
+          iterations++;
+          totalInputTokens += improveResult.usage.inputTokens;
+          totalOutputTokens += improveResult.usage.outputTokens;
+          totalCacheReadTokens += improveResult.usage.cacheReadTokens ?? 0;
+          totalCacheWriteTokens += improveResult.usage.cacheWriteTokens ?? 0;
+        }
+        if (this.useMQMEvaluation) {
+          if (!lastMQMEvaluation || iterations === this.maxIterations) {
+            lastMQMEvaluation = await this.evaluateQualityMQM(
+              request.content,
+              currentTranslation,
+              request.sourceLang,
+              request.targetLang,
+              glossaryText
+            );
+            qualityScore = lastMQMEvaluation.score;
+          }
+        } else {
+          if (!lastEvaluation || iterations === this.maxIterations) {
+            lastEvaluation = await this.evaluateQuality(
+              request.content,
+              currentTranslation,
+              request.sourceLang,
+              request.targetLang
+            );
+            qualityScore = lastEvaluation.score;
+          }
+        }
+        const thresholdMet = qualityScore >= this.qualityThreshold;
+        if (!thresholdMet && this.strictQuality) {
+          throw new TranslationError("QUALITY_THRESHOLD_NOT_MET" /* QUALITY_THRESHOLD_NOT_MET */, {
+            score: qualityScore,
+            threshold: this.qualityThreshold,
+            iterations,
+            maxIterations: this.maxIterations,
+            issues: lastEvaluation?.issues ?? lastMQMEvaluation?.errors.map((e) => `${e.type}: ${e.span}`) ?? []
+          });
+        }
+        if (!thresholdMet && this.verbose) {
+          logger.warn(
+            `Quality threshold not met: ${qualityScore}/${this.qualityThreshold} after ${iterations} iterations`
+          );
+        }
+        if (this.verbose && (totalCacheReadTokens > 0 || totalCacheWriteTokens > 0)) {
+          const cacheHitRate = totalCacheReadTokens > 0 ? (totalCacheReadTokens / (totalCacheReadTokens + totalInputTokens) * 100).toFixed(1) : "0";
+          logger.info(
+            `Cache stats: ${totalCacheReadTokens} read, ${totalCacheWriteTokens} written (${cacheHitRate}% hit rate)`
+          );
+        }
+        return {
+          content: currentTranslation,
+          metadata: {
+            qualityScore,
+            qualityThreshold: this.qualityThreshold,
+            thresholdMet,
+            iterations,
+            tokensUsed: {
+              input: totalInputTokens,
+              output: totalOutputTokens,
+              cacheRead: totalCacheReadTokens,
+              cacheWrite: totalCacheWriteTokens
+            },
+            duration: timer.elapsed(),
+            provider: this.provider.name,
+            model: "default"
+          },
+          glossaryCompliance: request.glossary ? this.checkGlossaryCompliance(
+            request.content,
+            currentTranslation,
+            request.glossary
+          ) : void 0
+        };
+      }
+      // ============================================================================
+      // Private Methods
+      // ============================================================================
+      async generateInitialTranslation(sourceText, sourceLang, targetLang, glossaryText, context, analysis) {
+        let messages;
+        const analysisContext = analysis ? formatAnalysisForPrompt(analysis) : "";
+        const enrichedContext = {
+          documentPurpose: context?.documentPurpose,
+          styleInstruction: context?.styleInstruction,
+          previousContext: context?.previousChunks?.slice(-2).join("\n")
+        };
+        if (this.enableCaching) {
+          const baseMessage = buildCacheableTranslationMessage(
+            sourceText,
+            sourceLang,
+            targetLang,
+            glossaryText,
+            enrichedContext
+          );
+          if (analysisContext && Array.isArray(baseMessage.content)) {
+            const contentParts = baseMessage.content;
+            contentParts.splice(2, 0, {
+              type: "text",
+              text: `
+## Pre-Translation Analysis:
+${analysisContext}
+`
+            });
+          }
+          messages = [baseMessage];
+        } else {
+          let prompt = buildInitialTranslationPrompt(
+            sourceText,
+            sourceLang,
+            targetLang,
+            glossaryText,
+            enrichedContext
+          );
+          if (analysisContext) {
+            prompt = prompt.replace(
+              "## Source Text:",
+              `## Pre-Translation Analysis:
+${analysisContext}
+
+## Source Text:`
+            );
+          }
+          messages = [{ role: "user", content: prompt }];
+        }
+        const response = await this.provider.chat({ messages });
+        const cleanedContent = this.cleanTranslationOutput(response.content);
+        return {
+          content: this.preserveWhitespace(sourceText, cleanedContent),
+          usage: {
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+            cacheReadTokens: response.usage.cacheReadTokens,
+            cacheWriteTokens: response.usage.cacheWriteTokens
+          }
+        };
+      }
+      async generateReflection(sourceText, translatedText, sourceLang, targetLang, glossaryText) {
+        const prompt = buildReflectionPrompt(
+          sourceText,
+          translatedText,
+          sourceLang,
+          targetLang,
+          glossaryText
+        );
+        const messages = [{ role: "user", content: prompt }];
+        const response = await this.provider.chat({ messages });
+        return response.content.trim();
+      }
+      async improveTranslation(sourceText, currentTranslation, suggestions, glossaryText) {
+        let messages;
+        if (this.enableCaching) {
+          const contentParts = [
+            {
+              type: "text",
+              text: `Improve this translation based on the following suggestions.
+
+## Glossary (MUST apply):
+${glossaryText || "No glossary provided."}`,
+              cacheControl: { type: "ephemeral" }
+            },
+            {
+              type: "text",
+              text: `## Source Text:
+${sourceText}
+
+## Current Translation:
+${currentTranslation}
+
+## Improvement Suggestions:
+${suggestions}
+
+Provide ONLY the improved translation below, with no additional commentary or headers:`
+            }
+          ];
+          messages = [{ role: "user", content: contentParts }];
+        } else {
+          const prompt = buildImprovementPrompt(
+            sourceText,
+            currentTranslation,
+            suggestions,
+            glossaryText
+          );
+          messages = [{ role: "user", content: prompt }];
+        }
+        const response = await this.provider.chat({ messages });
+        const cleanedContent = this.cleanTranslationOutput(response.content);
+        return {
+          content: this.preserveWhitespace(sourceText, cleanedContent),
+          usage: {
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+            cacheReadTokens: response.usage.cacheReadTokens,
+            cacheWriteTokens: response.usage.cacheWriteTokens
+          }
+        };
+      }
+      async evaluateQuality(sourceText, translatedText, sourceLang, targetLang) {
+        const prompt = buildQualityEvaluationPrompt(
+          sourceText,
+          translatedText,
+          sourceLang,
+          targetLang
+        );
+        const messages = [{ role: "user", content: prompt }];
+        const response = await this.provider.chat({ messages });
+        try {
+          const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+          if (!jsonMatch) {
+            throw new Error("No JSON found in response");
+          }
+          const evaluation = JSON.parse(jsonMatch[0]);
+          return {
+            score: evaluation.score,
+            breakdown: evaluation.breakdown,
+            issues: evaluation.issues
+          };
+        } catch {
+          return {
+            score: 75,
+            // Default score
+            breakdown: {
+              accuracy: 30,
+              fluency: 20,
+              glossary: 15,
+              format: 10
+            },
+            issues: ["Failed to parse quality evaluation response"]
+          };
+        }
+      }
+      /**
+       * Pre-translation analysis using MAPS-style approach
+       * Identifies key terms, ambiguous phrases, and translation challenges
+       */
+      async analyzeSource(sourceText, sourceLang, targetLang, glossaryText) {
+        const prompt = buildPreAnalysisPrompt(
+          sourceText,
+          sourceLang,
+          targetLang,
+          glossaryText
+        );
+        const messages = [{ role: "user", content: prompt }];
+        try {
+          const response = await this.provider.chat({ messages });
+          return parseAnalysisResponse(response.content);
+        } catch (error) {
+          if (this.verbose) {
+            logger.warn(`Pre-analysis failed: ${error}`);
+          }
+          return createEmptyAnalysis();
+        }
+      }
+      /**
+       * Evaluate translation quality using MQM framework
+       * Returns structured error annotations for targeted refinement
+       */
+      async evaluateQualityMQM(sourceText, translatedText, sourceLang, targetLang, glossaryText) {
+        const prompt = buildMQMEvaluationPrompt(
+          sourceText,
+          translatedText,
+          sourceLang,
+          targetLang,
+          glossaryText
+        );
+        const messages = [{ role: "user", content: prompt }];
+        try {
+          const response = await this.provider.chat({ messages });
+          const evaluation = parseMQMResponse(response.content);
+          if (evaluation) {
+            return evaluation;
+          }
+          return {
+            errors: [],
+            score: 75,
+            summary: "Failed to parse MQM evaluation",
+            breakdown: { accuracy: 0, fluency: 0, style: 0 }
+          };
+        } catch {
+          return {
+            errors: [],
+            score: 75,
+            summary: "MQM evaluation failed",
+            breakdown: { accuracy: 0, fluency: 0, style: 0 }
+          };
+        }
+      }
+      /**
+       * Refine translation based on MQM error annotations
+       * Applies targeted fixes for identified errors
+       */
+      async refineWithMQM(sourceText, currentTranslation, errors, glossaryText) {
+        const prompt = buildMQMRefinementPrompt(
+          sourceText,
+          currentTranslation,
+          errors,
+          glossaryText
+        );
+        const messages = [{ role: "user", content: prompt }];
+        const response = await this.provider.chat({ messages });
+        const cleanedContent = this.cleanTranslationOutput(response.content);
+        return {
+          content: this.preserveWhitespace(sourceText, cleanedContent),
+          usage: {
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+            cacheReadTokens: response.usage.cacheReadTokens,
+            cacheWriteTokens: response.usage.cacheWriteTokens
+          }
+        };
+      }
+      /**
+       * Clean up translation output by removing prompt artifacts
+       * Uses guardrails to detect and remove any trailing prompt-like content
+       */
+      cleanTranslationOutput(text) {
+        let cleaned = text.trim();
+        const trailingHeaderPattern = /\n+##\s+[A-Z][^:\n]*:\s*$/;
+        cleaned = cleaned.replace(trailingHeaderPattern, "");
+        const incompletePromptPattern = /:\s*$/;
+        if (incompletePromptPattern.test(cleaned)) {
+          const lines = cleaned.split("\n");
+          while (lines.length > 0 && incompletePromptPattern.test(lines[lines.length - 1]?.trim() ?? "")) {
+            lines.pop();
+          }
+          cleaned = lines.join("\n");
+        }
+        const evaluationListPattern = /\n+\d+\.\s*\*\*[^*]+\*\*[\s\S]*$/;
+        if (evaluationListPattern.test(cleaned)) {
+          cleaned = cleaned.replace(evaluationListPattern, "");
+        }
+        return cleaned.trim();
+      }
+      /**
+       * Preserve leading/trailing whitespace from source text in translated text
+       * This ensures document structure (line breaks between sections) is maintained
+       */
+      preserveWhitespace(sourceText, translatedText) {
+        const leadingMatch = sourceText.match(/^(\s*)/);
+        const leadingWhitespace = leadingMatch ? leadingMatch[1] : "";
+        const trailingMatch = sourceText.match(/(\s*)$/);
+        const trailingWhitespace = trailingMatch ? trailingMatch[1] : "";
+        return leadingWhitespace + translatedText + trailingWhitespace;
+      }
+      checkGlossaryCompliance(sourceText, translatedText, glossary) {
+        const lookup = createGlossaryLookup(glossary);
+        const sourceTerms = lookup.findAll(sourceText);
+        const applied = [];
+        const missed = [];
+        for (const term of sourceTerms) {
+          const targetInTranslation = term.caseSensitive ? translatedText.includes(term.target) : translatedText.toLowerCase().includes(term.target.toLowerCase());
+          if (targetInTranslation) {
+            applied.push(term.source);
+          } else {
+            missed.push(term.source);
+          }
+        }
+        return { applied, missed };
+      }
+    };
+  }
+});
+
+// src/utils/tokens.ts
+function estimateTokens(text) {
+  if (!text) return 0;
+  let latinChars = 0;
+  let cjkChars = 0;
+  let otherChars = 0;
+  for (const char of text) {
+    const code = char.charCodeAt(0);
+    if (code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+    code >= 13312 && code <= 19903 || // CJK Extension A
+    code >= 44032 && code <= 55215 || // Hangul Syllables
+    code >= 12352 && code <= 12447 || // Hiragana
+    code >= 12448 && code <= 12543) {
+      cjkChars++;
+    } else if (code >= 65 && code <= 90 || // A-Z
+    code >= 97 && code <= 122 || // a-z
+    code >= 48 && code <= 57) {
+      latinChars++;
+    } else {
+      otherChars++;
+    }
+  }
+  const latinTokens = latinChars / 4;
+  const cjkTokens = cjkChars / 1.5;
+  const otherTokens = otherChars / 3;
+  return Math.ceil(latinTokens + cjkTokens + otherTokens);
+}
+var init_tokens = __esm({
+  "src/utils/tokens.ts"() {
+  }
+});
+
+// src/core/chunker.ts
+function chunkContent(content, options = {}) {
+  if (!content.trim()) {
+    return [];
+  }
+  const config2 = {
+    ...DEFAULT_CONFIG,
+    maxTokens: options.maxTokens ?? DEFAULT_CONFIG.maxTokens,
+    overlapTokens: options.overlapTokens ?? DEFAULT_CONFIG.overlapTokens
+  };
+  const headerHierarchy = extractHeaderHierarchy(content);
+  const { segments } = extractPreservedSections(content);
+  const chunks = [];
+  let previousChunkContent;
+  for (const segment of segments) {
+    const segmentHeaders = getHeadersForPosition(
+      headerHierarchy,
+      segment.startOffset
+    );
+    if (segment.type === "preserve") {
+      chunks.push({
+        id: `chunk-${chunks.length}`,
+        content: segment.content,
+        type: "preserve",
+        startOffset: segment.startOffset,
+        endOffset: segment.endOffset,
+        metadata: {
+          headerHierarchy: segmentHeaders
+        }
+      });
+    } else {
+      const textChunks = splitIntoChunks(
+        segment.content,
+        config2,
+        segment.startOffset
+      );
+      for (let idx = 0; idx < textChunks.length; idx++) {
+        const chunk = textChunks[idx];
+        if (!chunk) continue;
+        const chunkHeaders = getHeadersForPosition(
+          headerHierarchy,
+          chunk.startOffset
+        );
+        chunks.push({
+          ...chunk,
+          id: `chunk-${chunks.length}`,
+          metadata: {
+            headerHierarchy: chunkHeaders.length > 0 ? chunkHeaders : segmentHeaders,
+            previousContext: previousChunkContent
+          }
+        });
+        previousChunkContent = truncateForContext(chunk.content, 200);
+      }
+    }
+  }
+  return chunks;
+}
+function extractHeaderHierarchy(content) {
+  const headers = [];
+  const headerRegex = /^(#{1,6})\s+(.+)$/gm;
+  let match;
+  while ((match = headerRegex.exec(content)) !== null) {
+    const hashMarks = match[1];
+    if (hashMarks) {
+      headers.push({
+        level: hashMarks.length,
+        text: match[0],
+        offset: match.index
+      });
+    }
+  }
+  return headers;
+}
+function getHeadersForPosition(headers, position) {
+  const relevantHeaders = [];
+  const currentLevels = /* @__PURE__ */ new Map();
+  for (const header of headers) {
+    if (header.offset > position) break;
+    for (const [level] of currentLevels) {
+      if (level >= header.level) {
+        currentLevels.delete(level);
+      }
+    }
+    currentLevels.set(header.level, header.text);
+  }
+  for (let level = 1; level <= 6; level++) {
+    const headerText = currentLevels.get(level);
+    if (headerText) {
+      relevantHeaders.push(headerText);
+    }
+  }
+  return relevantHeaders;
+}
+function truncateForContext(content, maxChars) {
+  if (content.length <= maxChars) return content;
+  const truncated = content.slice(-maxChars);
+  const firstSpace = truncated.indexOf(" ");
+  if (firstSpace > 0 && firstSpace < 50) {
+    return "..." + truncated.slice(firstSpace + 1);
+  }
+  return "..." + truncated;
+}
+function extractPreservedSections(content) {
+  const preservedRanges = [];
+  const codeBlockRegex = /```[\s\S]*?```/g;
+  let match;
+  while ((match = codeBlockRegex.exec(content)) !== null) {
+    preservedRanges.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      content: match[0]
+    });
+  }
+  preservedRanges.sort((a, b) => a.start - b.start);
+  const segments = [];
+  let lastEnd = 0;
+  for (const range of preservedRanges) {
+    if (range.start > lastEnd) {
+      const translatableContent = content.slice(lastEnd, range.start);
+      if (translatableContent.length > 0) {
+        segments.push({
+          content: translatableContent,
+          type: translatableContent.trim() ? "translatable" : "preserve",
+          startOffset: lastEnd,
+          endOffset: range.start
+        });
+      }
+    }
+    segments.push({
+      content: range.content,
+      type: "preserve",
+      startOffset: range.start,
+      endOffset: range.end
+    });
+    lastEnd = range.end;
+  }
+  if (lastEnd < content.length) {
+    const remainingContent = content.slice(lastEnd);
+    if (remainingContent.length > 0) {
+      segments.push({
+        content: remainingContent,
+        type: remainingContent.trim() ? "translatable" : "preserve",
+        startOffset: lastEnd,
+        endOffset: content.length
+      });
+    }
+  }
+  if (segments.length === 0) {
+    segments.push({
+      content,
+      type: "translatable",
+      startOffset: 0,
+      endOffset: content.length
+    });
+  }
+  return { segments };
+}
+function splitIntoChunks(text, config2, baseOffset) {
+  const chunks = [];
+  const tokenCount = estimateTokens(text);
+  if (tokenCount <= config2.maxTokens) {
+    return [
+      {
+        id: "",
+        content: text,
+        type: "translatable",
+        startOffset: baseOffset,
+        endOffset: baseOffset + text.length
+      }
+    ];
+  }
+  const parts = text.split(/(\n\n+)/);
+  let currentChunk = "";
+  let chunkStartOffset = baseOffset;
+  let textOffset = baseOffset;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === void 0) continue;
+    const potentialChunk = currentChunk + part;
+    const potentialTokens = estimateTokens(potentialChunk);
+    if (potentialTokens > config2.maxTokens && currentChunk) {
+      chunks.push({
+        id: "",
+        content: currentChunk,
+        type: "translatable",
+        startOffset: chunkStartOffset,
+        endOffset: textOffset
+      });
+      currentChunk = part;
+      chunkStartOffset = textOffset;
+    } else {
+      currentChunk = potentialChunk;
+    }
+    textOffset += part.length;
+  }
+  if (currentChunk.length > 0) {
+    chunks.push({
+      id: "",
+      content: currentChunk,
+      type: "translatable",
+      startOffset: chunkStartOffset,
+      endOffset: baseOffset + text.length
+    });
+  }
+  return chunks;
+}
+function getChunkStats(chunks) {
+  const translatableChunks = chunks.filter((c) => c.type === "translatable");
+  const preservedChunks = chunks.filter((c) => c.type === "preserve");
+  const totalTokens = chunks.reduce(
+    (sum, chunk) => sum + estimateTokens(chunk.content),
+    0
+  );
+  return {
+    totalChunks: chunks.length,
+    translatableChunks: translatableChunks.length,
+    preservedChunks: preservedChunks.length,
+    totalTokens,
+    averageTokens: chunks.length > 0 ? Math.round(totalTokens / chunks.length) : 0
+  };
+}
+var DEFAULT_CONFIG;
+var init_chunker = __esm({
+  "src/core/chunker.ts"() {
+    init_tokens();
+    DEFAULT_CONFIG = {
+      maxTokens: 1024,
+      overlapTokens: 150,
+      separators: ["\n\n", "\n", ". ", " "],
+      preservePatterns: [
+        /```[\s\S]*?```/g,
+        // Code blocks
+        /`[^`]+`/g,
+        // Inline code
+        /\[.*?\]\(.*?\)/g
+        // Links
+      ]
+    };
+  }
+});
+function extractTextForTranslation(content) {
+  const preservedSections = /* @__PURE__ */ new Map();
+  let placeholderIndex = 0;
+  let text = content.replace(/^[ \t]*```[^\n]*\n[\s\S]*?^[ \t]*```[ \t]*$/gm, (match) => {
+    const placeholder = `__CODE_BLOCK_${placeholderIndex++}__`;
+    preservedSections.set(placeholder, match);
+    return placeholder;
+  });
+  text = text.replace(/(`{2,})(?:[^`\n]|`(?!\1))*?\1/g, (match) => {
+    const placeholder = `__INLINE_CODE_${placeholderIndex++}__`;
+    preservedSections.set(placeholder, match);
+    return placeholder;
+  });
+  text = text.replace(/`[^`\n]+`/g, (match) => {
+    const placeholder = `__INLINE_CODE_${placeholderIndex++}__`;
+    preservedSections.set(placeholder, match);
+    return placeholder;
+  });
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, linkText, url) => {
+    const placeholder = `__LINK_URL_${placeholderIndex++}__`;
+    preservedSections.set(placeholder, url);
+    return `[${linkText}](${placeholder})`;
+  });
+  return { text, preservedSections };
+}
+function restorePreservedSections(translatedText, preservedSections) {
+  let result = translatedText;
+  const sortedEntries = [...preservedSections.entries()].sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  for (const [placeholder, original] of sortedEntries) {
+    const match = placeholder.match(/^__(.+)__$/);
+    if (match && match[1]) {
+      const identifier = match[1];
+      const escapedId = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const flexiblePattern = new RegExp(
+        `[ \\t]*_*_*[ \\t]*${escapedId}(?!\\d)[ \\t]*_*_*[ \\t]*`,
+        "gi"
+      );
+      result = result.replace(flexiblePattern, () => original);
+    } else {
+      result = result.split(placeholder).join(original);
+    }
+  }
+  result = ensureInlineCodeSpacing(result);
+  return result;
+}
+function ensureInlineCodeSpacing(text) {
+  let result = text.replace(
+    /([\w\u3000-\u9fff\uac00-\ud7af])(`+[^`\n]+`+)/g,
+    "$1 $2"
+  );
+  result = result.replace(
+    /(\d+\.)(`+[^`\n]+`+)/g,
+    "$1 $2"
+  );
+  result = result.replace(
+    /(`+[^`\n]+`+)([\w\u3000-\u9fff\uac00-\ud7af])/g,
+    "$1 $2"
+  );
+  return result;
+}
+var init_markdown = __esm({
+  "src/parsers/markdown.ts"() {
+  }
+});
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+    case "end_turn":
+      return "stop";
+    case "length":
+    case "max_tokens":
+      return "length";
+    default:
+      return "error";
+  }
+}
+function createClaudeProvider(config2 = {}) {
+  return new ClaudeProvider(config2);
+}
+var MODEL_INFO, DEFAULT_MODEL, ClaudeProvider;
+var init_claude = __esm({
+  "src/providers/claude.ts"() {
+    init_errors();
+    init_tokens();
+    MODEL_INFO = {
+      // Latest Claude 4.5 models
+      "claude-sonnet-4-5-20250929": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 3e-3,
+        costPer1kOutput: 0.015
+      },
+      "claude-opus-4-5-20251101": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 0.015,
+        costPer1kOutput: 0.075
+      },
+      "claude-haiku-4-5-20251001": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 1e-3,
+        costPer1kOutput: 5e-3
+      },
+      // Claude 4 models (previous generation)
+      "claude-sonnet-4-20250514": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 3e-3,
+        costPer1kOutput: 0.015
+      },
+      "claude-opus-4-20250514": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 0.015,
+        costPer1kOutput: 0.075
+      },
+      // Claude 3.5 models
+      "claude-3-5-haiku-20241022": {
+        maxContextTokens: 2e5,
+        supportsStreaming: true,
+        costPer1kInput: 1e-3,
+        costPer1kOutput: 5e-3
+      }
+    };
+    DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+    ClaudeProvider = class {
+      name = "claude";
+      defaultModel;
+      client;
+      constructor(config2 = {}) {
+        const apiKey = config2.apiKey ?? process.env["ANTHROPIC_API_KEY"];
+        if (!apiKey) {
+          throw new TranslationError("PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */, {
+            provider: "claude",
+            message: "ANTHROPIC_API_KEY environment variable is not set"
+          });
+        }
+        this.client = createAnthropic({
+          apiKey,
+          baseURL: config2.baseUrl
+        });
+        this.defaultModel = config2.defaultModel ?? DEFAULT_MODEL;
+      }
+      async chat(request) {
+        const model = request.model ?? this.defaultModel;
+        try {
+          const messages = this.convertMessages(request.messages);
+          const result = await generateText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          const anthropicMeta = result.providerMetadata?.anthropic;
+          return {
+            content: result.text,
+            usage: {
+              inputTokens: result.usage?.promptTokens ?? 0,
+              outputTokens: result.usage?.completionTokens ?? 0,
+              cacheReadTokens: anthropicMeta?.cacheReadInputTokens,
+              cacheWriteTokens: anthropicMeta?.cacheCreationInputTokens
+            },
+            model,
+            finishReason: mapFinishReason(result.finishReason)
+          };
+        } catch (error) {
+          throw this.handleError(error);
+        }
+      }
+      /**
+       * Convert messages to Vercel AI SDK format with cache control support
+       */
+      convertMessages(messages) {
+        return messages.map((msg) => {
+          if (typeof msg.content === "string") {
+            return { role: msg.role, content: msg.content };
+          }
+          const parts = msg.content.map((part) => ({
+            type: "text",
+            text: part.text,
+            ...part.cacheControl && {
+              providerOptions: {
+                anthropic: { cacheControl: part.cacheControl }
+              }
+            }
+          }));
+          return { role: msg.role, content: parts };
+        });
+      }
+      async *stream(request) {
+        const model = request.model ?? this.defaultModel;
+        try {
+          const messages = this.convertMessages(request.messages);
+          const result = streamText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          for await (const chunk of result.textStream) {
+            yield chunk;
+          }
+        } catch (error) {
+          throw this.handleError(error);
+        }
+      }
+      countTokens(text) {
+        return estimateTokens(text);
+      }
+      getModelInfo(model) {
+        const modelName = model ?? this.defaultModel;
+        return MODEL_INFO[modelName] ?? {
+          maxContextTokens: 2e5,
+          supportsStreaming: true
+        };
+      }
+      handleError(error) {
+        if (error instanceof TranslationError) {
+          return error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("rate_limit") || errorMessage.includes("429")) {
+          return new TranslationError("PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */, {
+            provider: "claude",
+            message: errorMessage
+          });
+        }
+        if (errorMessage.includes("authentication") || errorMessage.includes("401") || errorMessage.includes("invalid_api_key")) {
+          return new TranslationError("PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */, {
+            provider: "claude",
+            message: errorMessage
+          });
+        }
+        return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+          provider: "claude",
+          message: errorMessage
+        });
+      }
+    };
+  }
+});
+function mapFinishReason2(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+    case "max_tokens":
+      return "length";
+    default:
+      return "error";
+  }
+}
+function createOpenAIProvider(config2 = {}) {
+  return new OpenAIProvider(config2);
+}
+var MODEL_INFO2, DEFAULT_MODEL2, OpenAIProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    init_errors();
+    init_tokens();
+    MODEL_INFO2 = {
+      // GPT-4o models (latest)
+      "gpt-4o": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 25e-4,
+        costPer1kOutput: 0.01
+      },
+      "gpt-4o-2024-11-20": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 25e-4,
+        costPer1kOutput: 0.01
+      },
+      "gpt-4o-2024-08-06": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 25e-4,
+        costPer1kOutput: 0.01
+      },
+      // GPT-4o mini (cost-effective)
+      "gpt-4o-mini": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 15e-5,
+        costPer1kOutput: 6e-4
+      },
+      "gpt-4o-mini-2024-07-18": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 15e-5,
+        costPer1kOutput: 6e-4
+      },
+      // GPT-4 Turbo
+      "gpt-4-turbo": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 0.01,
+        costPer1kOutput: 0.03
+      },
+      "gpt-4-turbo-2024-04-09": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true,
+        costPer1kInput: 0.01,
+        costPer1kOutput: 0.03
+      },
+      // GPT-4 (original)
+      "gpt-4": {
+        maxContextTokens: 8192,
+        supportsStreaming: true,
+        costPer1kInput: 0.03,
+        costPer1kOutput: 0.06
+      },
+      // GPT-3.5 Turbo
+      "gpt-3.5-turbo": {
+        maxContextTokens: 16385,
+        supportsStreaming: true,
+        costPer1kInput: 5e-4,
+        costPer1kOutput: 15e-4
+      },
+      // o1 models (reasoning)
+      "o1": {
+        maxContextTokens: 2e5,
+        supportsStreaming: false,
+        costPer1kInput: 0.015,
+        costPer1kOutput: 0.06
+      },
+      "o1-preview": {
+        maxContextTokens: 128e3,
+        supportsStreaming: false,
+        costPer1kInput: 0.015,
+        costPer1kOutput: 0.06
+      },
+      "o1-mini": {
+        maxContextTokens: 128e3,
+        supportsStreaming: false,
+        costPer1kInput: 3e-3,
+        costPer1kOutput: 0.012
+      }
+    };
+    DEFAULT_MODEL2 = "gpt-4o-mini";
+    OpenAIProvider = class {
+      name = "openai";
+      defaultModel;
+      client;
+      constructor(config2 = {}) {
+        const apiKey = config2.apiKey ?? process.env["OPENAI_API_KEY"];
+        if (!apiKey) {
+          throw new TranslationError("PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */, {
+            provider: "openai",
+            message: "OPENAI_API_KEY environment variable is not set"
+          });
+        }
+        this.client = createOpenAI({
+          apiKey,
+          baseURL: config2.baseUrl
+        });
+        this.defaultModel = config2.defaultModel ?? DEFAULT_MODEL2;
+      }
+      async chat(request) {
+        const model = request.model ?? this.defaultModel;
+        try {
+          const messages = this.convertMessages(request.messages);
+          const result = await generateText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          return {
+            content: result.text,
+            usage: {
+              inputTokens: result.usage?.promptTokens ?? 0,
+              outputTokens: result.usage?.completionTokens ?? 0
+            },
+            model,
+            finishReason: mapFinishReason2(result.finishReason)
+          };
+        } catch (error) {
+          throw this.handleError(error);
+        }
+      }
+      /**
+       * Convert messages to Vercel AI SDK format
+       * OpenAI doesn't support cache control like Claude, so we simplify content
+       */
+      convertMessages(messages) {
+        return messages.map((msg) => {
+          if (Array.isArray(msg.content)) {
+            return {
+              role: msg.role,
+              content: msg.content.map((part) => part.text).join("")
+            };
+          }
+          return { role: msg.role, content: msg.content };
+        });
+      }
+      async *stream(request) {
+        const model = request.model ?? this.defaultModel;
+        const modelInfo = this.getModelInfo(model);
+        if (!modelInfo.supportsStreaming) {
+          const response = await this.chat(request);
+          yield response.content;
+          return;
+        }
+        try {
+          const messages = this.convertMessages(request.messages);
+          const result = streamText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          for await (const chunk of result.textStream) {
+            yield chunk;
+          }
+        } catch (error) {
+          throw this.handleError(error);
+        }
+      }
+      countTokens(text) {
+        return estimateTokens(text);
+      }
+      getModelInfo(model) {
+        const modelName = model ?? this.defaultModel;
+        return MODEL_INFO2[modelName] ?? {
+          maxContextTokens: 128e3,
+          supportsStreaming: true
+        };
+      }
+      handleError(error) {
+        if (error instanceof TranslationError) {
+          return error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("rate_limit") || errorMessage.includes("429") || errorMessage.includes("Rate limit")) {
+          return new TranslationError("PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */, {
+            provider: "openai",
+            message: errorMessage
+          });
+        }
+        if (errorMessage.includes("authentication") || errorMessage.includes("401") || errorMessage.includes("invalid_api_key") || errorMessage.includes("Incorrect API key")) {
+          return new TranslationError("PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */, {
+            provider: "openai",
+            message: errorMessage
+          });
+        }
+        if (errorMessage.includes("quota") || errorMessage.includes("insufficient_quota")) {
+          return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+            provider: "openai",
+            message: "API quota exceeded. Please check your billing settings."
+          });
+        }
+        if (errorMessage.includes("context_length_exceeded") || errorMessage.includes("maximum context length")) {
+          return new TranslationError("CHUNK_TOO_LARGE" /* CHUNK_TOO_LARGE */, {
+            provider: "openai",
+            message: errorMessage
+          });
+        }
+        return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+          provider: "openai",
+          message: errorMessage
+        });
+      }
+    };
+  }
+});
+function mapFinishReason3(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+    case "max_tokens":
+      return "length";
+    default:
+      return "error";
+  }
+}
+function createOllamaProvider(config2 = {}) {
+  return new OllamaProvider(config2);
+}
+var MODEL_INFO3, DEFAULT_MODEL3, DEFAULT_BASE_URL, OllamaProvider;
+var init_ollama = __esm({
+  "src/providers/ollama.ts"() {
+    init_errors();
+    init_tokens();
+    MODEL_INFO3 = {
+      // Llama 3.x models
+      "llama3.3": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      "llama3.2": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      "llama3.1": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      "llama3": {
+        maxContextTokens: 8192,
+        supportsStreaming: true
+      },
+      // Llama 2 models
+      llama2: {
+        maxContextTokens: 4096,
+        supportsStreaming: true
+      },
+      "llama2:13b": {
+        maxContextTokens: 4096,
+        supportsStreaming: true
+      },
+      "llama2:70b": {
+        maxContextTokens: 4096,
+        supportsStreaming: true
+      },
+      // Mistral models
+      mistral: {
+        maxContextTokens: 32768,
+        supportsStreaming: true
+      },
+      "mistral-nemo": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      mixtral: {
+        maxContextTokens: 32768,
+        supportsStreaming: true
+      },
+      // Qwen models
+      qwen2: {
+        maxContextTokens: 32768,
+        supportsStreaming: true
+      },
+      "qwen2.5": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      "qwen2.5-coder": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      // Gemma models
+      gemma2: {
+        maxContextTokens: 8192,
+        supportsStreaming: true
+      },
+      gemma: {
+        maxContextTokens: 8192,
+        supportsStreaming: true
+      },
+      // Phi models
+      phi3: {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      "phi3:mini": {
+        maxContextTokens: 128e3,
+        supportsStreaming: true
+      },
+      // Code models
+      codellama: {
+        maxContextTokens: 16384,
+        supportsStreaming: true
+      },
+      "deepseek-coder": {
+        maxContextTokens: 16384,
+        supportsStreaming: true
+      },
+      // Other popular models
+      "neural-chat": {
+        maxContextTokens: 8192,
+        supportsStreaming: true
+      },
+      vicuna: {
+        maxContextTokens: 2048,
+        supportsStreaming: true
+      }
+    };
+    DEFAULT_MODEL3 = "llama3.2";
+    DEFAULT_BASE_URL = "http://localhost:11434";
+    OllamaProvider = class {
+      name = "ollama";
+      defaultModel;
+      client;
+      baseUrl;
+      constructor(config2 = {}) {
+        this.baseUrl = config2.baseUrl ?? process.env["OLLAMA_BASE_URL"] ?? DEFAULT_BASE_URL;
+        this.client = createOpenAI({
+          apiKey: "ollama",
+          // Ollama doesn't require an API key
+          baseURL: `${this.baseUrl}/v1`
+        });
+        this.defaultModel = config2.defaultModel ?? DEFAULT_MODEL3;
+      }
+      async chat(request) {
+        const model = request.model ?? this.defaultModel;
+        try {
+          await this.ensureModelAvailable(model);
+          const messages = this.convertMessages(request.messages);
+          const result = await generateText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          return {
+            content: result.text,
+            usage: {
+              inputTokens: result.usage?.promptTokens ?? 0,
+              outputTokens: result.usage?.completionTokens ?? 0
+            },
+            model,
+            finishReason: mapFinishReason3(result.finishReason)
+          };
+        } catch (error) {
+          throw this.handleError(error, model);
+        }
+      }
+      /**
+       * Convert messages to Vercel AI SDK format
+       * Ollama doesn't support cache control, so we simplify content
+       */
+      convertMessages(messages) {
+        return messages.map((msg) => {
+          if (Array.isArray(msg.content)) {
+            return {
+              role: msg.role,
+              content: msg.content.map((part) => part.text).join("")
+            };
+          }
+          return { role: msg.role, content: msg.content };
+        });
+      }
+      async *stream(request) {
+        const model = request.model ?? this.defaultModel;
+        try {
+          await this.ensureModelAvailable(model);
+          const messages = this.convertMessages(request.messages);
+          const result = streamText({
+            model: this.client(model),
+            messages,
+            temperature: request.temperature ?? 0,
+            maxTokens: request.maxTokens ?? 4096
+          });
+          for await (const chunk of result.textStream) {
+            yield chunk;
+          }
+        } catch (error) {
+          throw this.handleError(error, model);
+        }
+      }
+      countTokens(text) {
+        return estimateTokens(text);
+      }
+      getModelInfo(model) {
+        const modelName = model ?? this.defaultModel;
+        if (MODEL_INFO3[modelName]) {
+          return MODEL_INFO3[modelName];
+        }
+        const baseModel = modelName.split(":")[0] ?? modelName;
+        if (baseModel && MODEL_INFO3[baseModel]) {
+          return MODEL_INFO3[baseModel];
+        }
+        return {
+          maxContextTokens: 4096,
+          supportsStreaming: true
+        };
+      }
+      /**
+       * Check if the Ollama server is running and the model is available
+       */
+      async ensureModelAvailable(model) {
+        try {
+          const response = await fetch(`${this.baseUrl}/api/tags`);
+          if (!response.ok) {
+            throw new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+              provider: "ollama",
+              message: `Ollama server not responding at ${this.baseUrl}`
+            });
+          }
+          const data = await response.json();
+          const models = data.models ?? [];
+          const modelNames = models.map((m) => m.name);
+          const modelExists = modelNames.some(
+            (name) => name === model || name.startsWith(`${model}:`)
+          );
+          if (!modelExists) {
+            throw new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+              provider: "ollama",
+              model,
+              availableModels: modelNames.slice(0, 10),
+              // Show first 10
+              message: `Model "${model}" not found. Pull it with: ollama pull ${model}`
+            });
+          }
+        } catch (error) {
+          if (error instanceof TranslationError) {
+            throw error;
+          }
+          throw new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+            provider: "ollama",
+            baseUrl: this.baseUrl,
+            message: `Cannot connect to Ollama server at ${this.baseUrl}. Is Ollama running?`
+          });
+        }
+      }
+      handleError(error, model) {
+        if (error instanceof TranslationError) {
+          return error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("ECONNREFUSED") || errorMessage.includes("fetch failed") || errorMessage.includes("network")) {
+          return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+            provider: "ollama",
+            baseUrl: this.baseUrl,
+            message: `Cannot connect to Ollama server at ${this.baseUrl}. Is Ollama running?`
+          });
+        }
+        if (errorMessage.includes("model") && errorMessage.includes("not found")) {
+          return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+            provider: "ollama",
+            model,
+            message: `Model "${model}" not found. Pull it with: ollama pull ${model}`
+          });
+        }
+        if (errorMessage.includes("context") || errorMessage.includes("too long")) {
+          return new TranslationError("CHUNK_TOO_LARGE" /* CHUNK_TOO_LARGE */, {
+            provider: "ollama",
+            model,
+            message: errorMessage
+          });
+        }
+        if (errorMessage.includes("out of memory") || errorMessage.includes("OOM")) {
+          return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+            provider: "ollama",
+            model,
+            message: "Out of memory. Try a smaller model or reduce chunk size."
+          });
+        }
+        return new TranslationError("PROVIDER_ERROR" /* PROVIDER_ERROR */, {
+          provider: "ollama",
+          message: errorMessage
+        });
+      }
+    };
+  }
+});
+
+// src/providers/registry.ts
+function registerProvider(name, factory) {
+  providers.set(name, factory);
+}
+function getProvider(name, config2 = {}) {
+  const factory = providers.get(name);
+  if (!factory) {
+    throw new TranslationError("PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */, {
+      provider: name,
+      available: Array.from(providers.keys())
+    });
+  }
+  return factory(config2);
+}
+function getAvailableProviders() {
+  return Array.from(providers.keys());
+}
+function getProviderConfigFromEnv(name) {
+  switch (name) {
+    case "claude":
+      return {
+        apiKey: process.env["ANTHROPIC_API_KEY"]
+        // defaultModel is handled by the provider itself
+      };
+    case "openai":
+      return {
+        apiKey: process.env["OPENAI_API_KEY"],
+        defaultModel: "gpt-4o"
+      };
+    case "ollama":
+      return {
+        baseUrl: process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434",
+        defaultModel: "llama3.2"
+        // Better multilingual support than llama2
+      };
+    case "custom":
+      return {
+        apiKey: process.env["LLM_API_KEY"],
+        baseUrl: process.env["LLM_BASE_URL"]
+      };
+    default:
+      return {};
+  }
+}
+var providers;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    init_errors();
+    init_claude();
+    init_openai();
+    init_ollama();
+    providers = /* @__PURE__ */ new Map();
+    registerProvider("claude", createClaudeProvider);
+    registerProvider("openai", createOpenAIProvider);
+    registerProvider("ollama", createOllamaProvider);
+  }
+});
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex").slice(0, 16);
+}
+function generateCacheKey(key) {
+  const contentHash = hashContent(key.content);
+  const glossaryHash = key.glossary ? hashContent(key.glossary) : "none";
+  return `${contentHash}_${key.sourceLang}_${key.targetLang}_${glossaryHash}_${key.provider}_${key.model}`;
+}
+function createCacheManager(options) {
+  return new CacheManager(options);
+}
+function createNullCacheManager() {
+  const nullManager = {
+    isNull: true,
+    get: () => ({ hit: false }),
+    set: () => {
+    },
+    has: () => false,
+    delete: () => false,
+    clear: () => {
+    },
+    getStats: () => ({ entries: 0, sizeBytes: 0, version: CACHE_VERSION }),
+    getAllEntries: () => ({}),
+    updateMetadata: () => {
+    },
+    getMetadata: () => ({}),
+    applyPolicies: () => 0,
+    invalidateMatching: () => 0,
+    addPolicy: () => {
+    },
+    removePolicy: () => false,
+    getPolicies: () => []
+  };
+  return nullManager;
+}
+var CACHE_VERSION, INDEX_FILE, ENTRIES_DIR, CacheManager;
+var init_cache = __esm({
+  "src/services/cache.ts"() {
+    init_logger();
+    CACHE_VERSION = "1.0";
+    INDEX_FILE = "index.json";
+    ENTRIES_DIR = "entries";
+    CacheManager = class {
+      cacheDir;
+      indexPath;
+      entriesDir;
+      metadataPath;
+      verbose;
+      index = null;
+      policies;
+      metadata = null;
+      constructor(options) {
+        this.cacheDir = options.cacheDir;
+        this.indexPath = join(this.cacheDir, INDEX_FILE);
+        this.entriesDir = join(this.cacheDir, ENTRIES_DIR);
+        this.metadataPath = join(this.cacheDir, "metadata.json");
+        this.verbose = options.verbose ?? false;
+        this.policies = options.invalidationPolicies ?? [];
+      }
+      /**
+       * Initialize cache directory and load index
+       */
+      ensureInitialized() {
+        if (this.index !== null) return;
+        if (!existsSync(this.cacheDir)) {
+          mkdirSync(this.cacheDir, { recursive: true });
+        }
+        if (!existsSync(this.entriesDir)) {
+          mkdirSync(this.entriesDir, { recursive: true });
+        }
+        if (existsSync(this.indexPath)) {
+          try {
+            const data = readFileSync(this.indexPath, "utf-8");
+            this.index = JSON.parse(data);
+            if (this.index.version !== CACHE_VERSION) {
+              if (this.verbose) {
+                logger.warn(`Cache version mismatch (${this.index.version} vs ${CACHE_VERSION}), clearing cache`);
+              }
+              this.clearSync();
+              this.index = { version: CACHE_VERSION, entries: {} };
+            }
+          } catch {
+            if (this.verbose) {
+              logger.warn("Failed to load cache index, creating new one");
+            }
+            this.index = { version: CACHE_VERSION, entries: {} };
+          }
+        } else {
+          this.index = { version: CACHE_VERSION, entries: {} };
+        }
+        this.loadMetadata();
+      }
+      /**
+       * Load cache metadata from disk
+       */
+      loadMetadata() {
+        if (existsSync(this.metadataPath)) {
+          try {
+            const data = readFileSync(this.metadataPath, "utf-8");
+            this.metadata = JSON.parse(data);
+          } catch {
+            this.metadata = {};
+          }
+        } else {
+          this.metadata = {};
+        }
+      }
+      /**
+       * Save cache metadata to disk
+       */
+      saveMetadata() {
+        if (!this.metadata) return;
+        try {
+          writeFileSync(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
+        } catch (error) {
+          if (this.verbose) {
+            logger.error(`Failed to save cache metadata: ${error}`);
+          }
+        }
+      }
+      /**
+       * Update cache metadata
+       */
+      updateMetadata(updates) {
+        this.ensureInitialized();
+        this.metadata = { ...this.metadata, ...updates };
+        this.saveMetadata();
+      }
+      /**
+       * Get current cache metadata
+       */
+      getMetadata() {
+        this.ensureInitialized();
+        return { ...this.metadata };
+      }
+      /**
+       * Apply all configured invalidation policies
+       * @returns Number of entries invalidated
+       */
+      applyPolicies(context) {
+        this.ensureInitialized();
+        if (this.policies.length === 0) {
+          return 0;
+        }
+        let totalInvalidated = 0;
+        for (const policy of this.policies) {
+          const result = policy.check({
+            ...context,
+            previousGlossaryHash: this.metadata?.glossaryHash,
+            currentTime: context.currentTime ?? /* @__PURE__ */ new Date()
+          });
+          if (!result.shouldInvalidate) {
+            continue;
+          }
+          if (this.verbose) {
+            logger.info(`Applying ${policy.name}: ${result.reason}`);
+          }
+          if (result.scope === "all") {
+            const count = Object.keys(this.index.entries).length;
+            this.clear();
+            totalInvalidated += count;
+            break;
+          }
+          if (result.scope === "matching" && result.filter) {
+            const invalidated = this.invalidateMatching(result.filter);
+            totalInvalidated += invalidated;
+          }
+        }
+        if (context.glossaryHash) {
+          this.metadata.glossaryHash = context.glossaryHash;
+        }
+        if (context.provider) {
+          this.metadata.provider = context.provider;
+        }
+        if (context.model) {
+          this.metadata.model = context.model;
+        }
+        if (totalInvalidated > 0) {
+          this.metadata.lastInvalidation = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        this.saveMetadata();
+        return totalInvalidated;
+      }
+      /**
+       * Invalidate entries matching a filter function
+       * @returns Number of entries invalidated
+       */
+      invalidateMatching(filter) {
+        this.ensureInitialized();
+        const keysToDelete = [];
+        for (const [key, entry] of Object.entries(this.index.entries)) {
+          if (filter(entry, key)) {
+            keysToDelete.push(key);
+          }
+        }
+        for (const key of keysToDelete) {
+          const entryPath = join(this.entriesDir, `${key}.json`);
+          try {
+            if (existsSync(entryPath)) {
+              rmSync(entryPath);
+            }
+          } catch {
+          }
+          delete this.index.entries[key];
+        }
+        if (keysToDelete.length > 0) {
+          this.saveIndex();
+          if (this.verbose) {
+            logger.info(`Invalidated ${keysToDelete.length} cache entries`);
+          }
+        }
+        return keysToDelete.length;
+      }
+      /**
+       * Add an invalidation policy at runtime
+       */
+      addPolicy(policy) {
+        this.policies.push(policy);
+      }
+      /**
+       * Remove an invalidation policy by name
+       */
+      removePolicy(name) {
+        const index = this.policies.findIndex((p) => p.name === name);
+        if (index !== -1) {
+          this.policies.splice(index, 1);
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Get all configured policies
+       */
+      getPolicies() {
+        return [...this.policies];
+      }
+      /**
+       * Save index to disk
+       */
+      saveIndex() {
+        if (!this.index) return;
+        try {
+          const dir = dirname(this.indexPath);
+          if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+          }
+          writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2), "utf-8");
+        } catch (error) {
+          if (this.verbose) {
+            logger.error(`Failed to save cache index: ${error}`);
+          }
+        }
+      }
+      /**
+       * Get cached translation if available
+       */
+      get(key) {
+        this.ensureInitialized();
+        const cacheKey = generateCacheKey(key);
+        const entry = this.index.entries[cacheKey];
+        if (entry) {
+          const entryPath = join(this.entriesDir, `${cacheKey}.json`);
+          if (existsSync(entryPath)) {
+            if (this.verbose) {
+              logger.info(`Cache hit: ${cacheKey.slice(0, 20)}...`);
+            }
+            return { hit: true, entry };
+          } else {
+            delete this.index.entries[cacheKey];
+            this.saveIndex();
+          }
+        }
+        if (this.verbose) {
+          logger.debug(`Cache miss: ${cacheKey.slice(0, 20)}...`);
+        }
+        return { hit: false };
+      }
+      /**
+       * Store translation in cache
+       */
+      set(key, translation, qualityScore) {
+        this.ensureInitialized();
+        const cacheKey = generateCacheKey(key);
+        const contentHash = hashContent(key.content);
+        const glossaryHash = key.glossary ? hashContent(key.glossary) : "";
+        const entry = {
+          sourceHash: contentHash,
+          sourceLang: key.sourceLang,
+          targetLang: key.targetLang,
+          glossaryHash,
+          translation,
+          qualityScore,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          provider: key.provider,
+          model: key.model
+        };
+        const entryPath = join(this.entriesDir, `${cacheKey}.json`);
+        try {
+          writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf-8");
+          this.index.entries[cacheKey] = entry;
+          this.saveIndex();
+          if (this.verbose) {
+            logger.info(`Cached: ${cacheKey.slice(0, 20)}...`);
+          }
+        } catch (error) {
+          if (this.verbose) {
+            logger.error(`Failed to cache entry: ${error}`);
+          }
+        }
+      }
+      /**
+       * Check if entry exists in cache
+       */
+      has(key) {
+        return this.get(key).hit;
+      }
+      /**
+       * Remove entry from cache
+       */
+      delete(key) {
+        this.ensureInitialized();
+        const cacheKey = generateCacheKey(key);
+        if (this.index.entries[cacheKey]) {
+          const entryPath = join(this.entriesDir, `${cacheKey}.json`);
+          try {
+            if (existsSync(entryPath)) {
+              rmSync(entryPath);
+            }
+          } catch {
+          }
+          delete this.index.entries[cacheKey];
+          this.saveIndex();
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Clear entire cache (synchronous)
+       */
+      clearSync() {
+        try {
+          if (existsSync(this.entriesDir)) {
+            rmSync(this.entriesDir, { recursive: true, force: true });
+          }
+          if (existsSync(this.indexPath)) {
+            rmSync(this.indexPath);
+          }
+          mkdirSync(this.entriesDir, { recursive: true });
+        } catch {
+        }
+      }
+      /**
+       * Clear entire cache
+       */
+      clear() {
+        this.clearSync();
+        this.index = { version: CACHE_VERSION, entries: {} };
+        this.saveIndex();
+        if (this.verbose) {
+          logger.info("Cache cleared");
+        }
+      }
+      /**
+       * Get cache statistics
+       */
+      getStats() {
+        this.ensureInitialized();
+        let sizeBytes = 0;
+        if (existsSync(this.entriesDir)) {
+          try {
+            const files = readdirSync(this.entriesDir);
+            for (const file of files) {
+              const filePath = join(this.entriesDir, file);
+              try {
+                const stat = statSync(filePath);
+                sizeBytes += stat.size;
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        if (existsSync(this.indexPath)) {
+          try {
+            const stat = statSync(this.indexPath);
+            sizeBytes += stat.size;
+          } catch {
+          }
+        }
+        return {
+          entries: Object.keys(this.index?.entries ?? {}).length,
+          sizeBytes,
+          version: CACHE_VERSION
+        };
+      }
+      /**
+       * Get all cached entries (for debugging)
+       */
+      getAllEntries() {
+        this.ensureInitialized();
+        return { ...this.index.entries };
+      }
+    };
+  }
+});
+
+// src/core/engine.ts
+function createTranslationEngine(options) {
+  return new TranslationEngine(options);
+}
+var TranslationEngine;
+var init_engine = __esm({
+  "src/core/engine.ts"() {
+    init_agent();
+    init_chunker();
+    init_markdown();
+    init_glossary();
+    init_registry();
+    init_logger();
+    init_errors();
+    init_cache();
+    TranslationEngine = class {
+      config;
+      provider;
+      verbose;
+      cache;
+      cacheHits = 0;
+      cacheMisses = 0;
+      constructor(options) {
+        this.config = options.config;
+        this.verbose = options.verbose ?? false;
+        if (options.provider) {
+          this.provider = options.provider;
+        } else {
+          const providerConfig = getProviderConfigFromEnv(this.config.provider.default);
+          if (this.config.provider.model) {
+            providerConfig.defaultModel = this.config.provider.model;
+          }
+          this.provider = getProvider(this.config.provider.default, providerConfig);
+        }
+        const cacheDisabled = options.noCache || !this.config.paths?.cache;
+        if (cacheDisabled) {
+          this.cache = createNullCacheManager();
+          if (this.verbose && options.noCache) {
+            logger.info("Cache disabled (--no-cache)");
+          }
+        } else {
+          this.cache = createCacheManager({
+            cacheDir: this.config.paths.cache,
+            verbose: this.verbose
+          });
+          if (this.verbose) {
+            const stats = this.cache.getStats();
+            logger.info(`Cache initialized: ${stats.entries} entries`);
+          }
+        }
+      }
+      /**
+       * Translate a single file/content
+       */
+      async translateContent(options) {
+        const timer = createTimer();
+        const format = options.format ?? this.detectFormat(options.content);
+        if (this.verbose) {
+          logger.info(`Translating content (${format} format)`);
+          logger.info(`Source: ${options.sourceLang} \u2192 Target: ${options.targetLang}`);
+        }
+        let glossary;
+        if (options.glossaryPath) {
+          try {
+            const rawGlossary = await loadGlossary(options.glossaryPath);
+            glossary = resolveGlossary(rawGlossary, options.targetLang);
+            if (this.verbose) {
+              logger.info(`Loaded glossary: ${glossary.terms.length} terms`);
+            }
+          } catch (error) {
+            if (this.verbose) {
+              logger.warn(`Failed to load glossary: ${error}`);
+            }
+          }
+        } else if (this.config.glossary?.path) {
+          try {
+            const rawGlossary = await loadGlossary(this.config.glossary.path);
+            glossary = resolveGlossary(rawGlossary, options.targetLang);
+            if (this.verbose) {
+              logger.info(`Loaded glossary from config: ${glossary.terms.length} terms`);
+            }
+          } catch {
+          }
+        }
+        let result;
+        switch (format) {
+          case "markdown":
+            result = await this.translateMarkdown(options, glossary);
+            break;
+          case "html":
+            result = await this.translatePlainText(options, glossary);
+            break;
+          case "text":
+          default:
+            result = await this.translatePlainText(options, glossary);
+            break;
+        }
+        result.metadata.totalDuration = timer.elapsed();
+        if (glossary && glossary.terms.length > 0) {
+          const compliance = this.checkDocumentGlossaryCompliance(
+            options.content,
+            result.content,
+            glossary
+          );
+          result.glossaryCompliance = compliance;
+          if (this.verbose) {
+            logger.info(`Glossary compliance: ${compliance.applied.length}/${compliance.applied.length + compliance.missed.length} terms applied`);
+            if (compliance.missed.length > 0) {
+              logger.warn(`Missed glossary terms: ${compliance.missed.join(", ")}`);
+            }
+          }
+          if (options.strictGlossary && !compliance.compliant) {
+            throw new TranslationError("GLOSSARY_COMPLIANCE_FAILED" /* GLOSSARY_COMPLIANCE_FAILED */, {
+              missed: compliance.missed.join(", "),
+              applied: compliance.applied,
+              total: glossary.terms.length
+            });
+          }
+        }
+        if (this.verbose) {
+          logger.success(`Translation complete in ${timer.format()}`);
+          logger.info(`Average quality: ${result.metadata.averageQuality.toFixed(1)}/100`);
+        }
+        return result;
+      }
+      /**
+       * Check glossary compliance for the entire document
+       */
+      checkDocumentGlossaryCompliance(sourceContent, translatedContent, glossary) {
+        const applied = [];
+        const missed = [];
+        const sourceLower = sourceContent.toLowerCase();
+        const translatedLower = translatedContent.toLowerCase();
+        for (const term of glossary.terms) {
+          const sourceInContent = term.caseSensitive ? sourceContent.includes(term.source) : sourceLower.includes(term.source.toLowerCase());
+          if (!sourceInContent) {
+            continue;
+          }
+          const targetInTranslation = term.caseSensitive ? translatedContent.includes(term.target) : translatedLower.includes(term.target.toLowerCase());
+          if (targetInTranslation) {
+            applied.push(term.source);
+          } else {
+            missed.push(term.source);
+          }
+        }
+        return {
+          applied,
+          missed,
+          compliant: missed.length === 0
+        };
+      }
+      // ============================================================================
+      // Format-Specific Translation
+      // ============================================================================
+      async translateMarkdown(options, glossary) {
+        const { text, preservedSections } = extractTextForTranslation(options.content);
+        const chunks = chunkContent(text, {
+          maxTokens: this.config.chunking.maxTokens,
+          overlapTokens: this.config.chunking.overlapTokens
+        });
+        if (this.verbose) {
+          const stats = getChunkStats(chunks);
+          logger.info(`Chunked into ${stats.translatableChunks} translatable sections`);
+        }
+        const agent = createTranslationAgent({
+          provider: this.provider,
+          qualityThreshold: options.qualityThreshold ?? this.config.quality.threshold,
+          maxIterations: options.maxIterations ?? this.config.quality.maxIterations,
+          verbose: this.verbose,
+          strictQuality: options.strictQuality
+        });
+        const chunkResults = [];
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalIterations = 0;
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i];
+          if (!chunk) continue;
+          if (chunk.type === "preserve") {
+            chunkResults.push({
+              original: chunk.content,
+              translated: chunk.content,
+              startOffset: chunk.startOffset,
+              endOffset: chunk.endOffset,
+              qualityScore: 100
+            });
+            continue;
+          }
+          if (this.verbose) {
+            logger.info(`Translating chunk ${i + 1}/${chunks.length}...`);
+          }
+          const result = await this.translateChunk(chunk, options, glossary, agent);
+          chunkResults.push(result);
+          if (result.tokensUsed) {
+            totalInputTokens += result.tokensUsed.input;
+            totalOutputTokens += result.tokensUsed.output;
+          }
+          if (result.iterations) {
+            totalIterations += result.iterations;
+          }
+        }
+        const translatedText = chunkResults.map((r) => r.translated).join("");
+        const finalContent = restorePreservedSections(translatedText, preservedSections);
+        const qualityScores = chunkResults.filter((r) => r.qualityScore > 0).map((r) => r.qualityScore);
+        const averageQuality = qualityScores.length > 0 ? qualityScores.reduce((a, b) => a + b, 0) / qualityScores.length : 0;
+        const cacheHits = chunkResults.filter((r) => r.cached).length;
+        const cacheMisses = chunkResults.filter((r) => !r.cached && r.qualityScore > 0).length;
+        return {
+          content: finalContent,
+          chunks: chunkResults,
+          metadata: {
+            totalTokensUsed: totalInputTokens + totalOutputTokens,
+            totalDuration: 0,
+            // Will be set by caller
+            averageQuality,
+            provider: this.provider.name,
+            model: this.config.provider.model ?? this.provider.defaultModel,
+            totalIterations,
+            tokensUsed: {
+              input: totalInputTokens,
+              output: totalOutputTokens
+            },
+            cache: {
+              hits: cacheHits,
+              misses: cacheMisses
+            }
+          }
+        };
+      }
+      async translatePlainText(options, glossary) {
+        const chunks = chunkContent(options.content, {
+          maxTokens: this.config.chunking.maxTokens,
+          overlapTokens: this.config.chunking.overlapTokens
+        });
+        const agent = createTranslationAgent({
+          provider: this.provider,
+          qualityThreshold: options.qualityThreshold ?? this.config.quality.threshold,
+          maxIterations: options.maxIterations ?? this.config.quality.maxIterations,
+          verbose: this.verbose,
+          strictQuality: options.strictQuality
+        });
+        const chunkResults = [];
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalIterations = 0;
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i];
+          if (!chunk) continue;
+          if (chunk.type === "preserve") {
+            chunkResults.push({
+              original: chunk.content,
+              translated: chunk.content,
+              startOffset: chunk.startOffset,
+              endOffset: chunk.endOffset,
+              qualityScore: 100
+            });
+            continue;
+          }
+          if (this.verbose) {
+            logger.info(`Translating chunk ${i + 1}/${chunks.length}...`);
+          }
+          const result = await this.translateChunk(chunk, options, glossary, agent);
+          chunkResults.push(result);
+          if (result.tokensUsed) {
+            totalInputTokens += result.tokensUsed.input;
+            totalOutputTokens += result.tokensUsed.output;
+          }
+          if (result.iterations) {
+            totalIterations += result.iterations;
+          }
+        }
+        const translatedContent = chunkResults.map((r) => r.translated).join("");
+        const qualityScores = chunkResults.filter((r) => r.qualityScore > 0).map((r) => r.qualityScore);
+        const averageQuality = qualityScores.length > 0 ? qualityScores.reduce((a, b) => a + b, 0) / qualityScores.length : 0;
+        const cacheHits = chunkResults.filter((r) => r.cached).length;
+        const cacheMisses = chunkResults.filter((r) => !r.cached && r.qualityScore > 0).length;
+        return {
+          content: translatedContent,
+          chunks: chunkResults,
+          metadata: {
+            totalTokensUsed: totalInputTokens + totalOutputTokens,
+            totalDuration: 0,
+            averageQuality,
+            provider: this.provider.name,
+            model: this.config.provider.model ?? this.provider.defaultModel,
+            totalIterations,
+            tokensUsed: {
+              input: totalInputTokens,
+              output: totalOutputTokens
+            },
+            cache: {
+              hits: cacheHits,
+              misses: cacheMisses
+            }
+          }
+        };
+      }
+      async translateChunk(chunk, options, glossary, agent) {
+        const glossaryString = glossary ? JSON.stringify(glossary.terms.map((t) => ({ s: t.source, t: t.target }))) : void 0;
+        const cacheKey = {
+          content: chunk.content,
+          sourceLang: options.sourceLang,
+          targetLang: options.targetLang,
+          glossary: glossaryString,
+          provider: this.provider.name,
+          model: this.config.provider.model ?? this.provider.defaultModel
+        };
+        const cacheResult = this.cache.get(cacheKey);
+        if (cacheResult.hit && cacheResult.entry) {
+          this.cacheHits++;
+          if (this.verbose) {
+            logger.info(`  \u21B3 Cache hit (quality: ${cacheResult.entry.qualityScore})`);
+          }
+          return {
+            original: chunk.content,
+            translated: cacheResult.entry.translation,
+            startOffset: chunk.startOffset,
+            endOffset: chunk.endOffset,
+            qualityScore: cacheResult.entry.qualityScore,
+            iterations: 0,
+            tokensUsed: { input: 0, output: 0, cacheRead: 1 },
+            cached: true
+          };
+        }
+        this.cacheMisses++;
+        const resolvedStyleInstruction = options.styleInstruction ?? this.config.languages.styles?.[options.targetLang];
+        const context = {
+          documentPurpose: options.context,
+          styleInstruction: resolvedStyleInstruction
+        };
+        if (chunk.metadata?.headerHierarchy && chunk.metadata.headerHierarchy.length > 0) {
+          context.documentSummary = `Current section: ${chunk.metadata.headerHierarchy.join(" > ")}`;
+        }
+        if (chunk.metadata?.previousContext) {
+          context.previousChunks = [chunk.metadata.previousContext];
+        }
+        const request = {
+          content: chunk.content,
+          sourceLang: options.sourceLang,
+          targetLang: options.targetLang,
+          format: options.format ?? "text",
+          glossary,
+          context
+        };
+        try {
+          const result = await agent.translate(request);
+          this.cache.set(cacheKey, result.content, result.metadata.qualityScore);
+          return {
+            original: chunk.content,
+            translated: result.content,
+            startOffset: chunk.startOffset,
+            endOffset: chunk.endOffset,
+            qualityScore: result.metadata.qualityScore,
+            iterations: result.metadata.iterations,
+            tokensUsed: result.metadata.tokensUsed
+          };
+        } catch (error) {
+          logger.error(`Failed to translate chunk: ${error}`);
+          return {
+            original: chunk.content,
+            translated: chunk.content,
+            // Fallback to original
+            startOffset: chunk.startOffset,
+            endOffset: chunk.endOffset,
+            qualityScore: 0,
+            iterations: 0,
+            tokensUsed: { input: 0, output: 0 }
+          };
+        }
+      }
+      // ============================================================================
+      // Utility Methods
+      // ============================================================================
+      detectFormat(content) {
+        if (content.includes("# ") || content.includes("## ") || content.includes("```") || content.includes("- ") || content.match(/\[.+\]\(.+\)/)) {
+          return "markdown";
+        }
+        if (content.includes("<html") || content.includes("<body") || content.includes("<div") || content.includes("<p>")) {
+          return "html";
+        }
+        return "text";
+      }
+    };
+  }
+});
+
+// src/cli/commands/file.ts
+var file_exports = {};
+__export(file_exports, {
+  fileCommand: () => fileCommand,
+  handleStdinTranslation: () => handleStdinTranslation
+});
+async function handleStdinTranslation(options) {
+  try {
+    configureLogger({
+      level: "error",
+      quiet: true,
+      json: false
+    });
+    if (!options.sourceLang) {
+      console.error("Error: Source language (-s, --source-lang) is required");
+      process.exit(2);
+    }
+    if (!options.targetLang) {
+      console.error("Error: Target language (-t, --target-lang) is required");
+      process.exit(2);
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const content = Buffer.concat(chunks).toString("utf-8");
+    if (!content.trim()) {
+      console.error("Error: No input provided");
+      process.exit(2);
+    }
+    const baseConfig = await loadConfig({ configPath: options.config });
+    const config2 = mergeConfig(baseConfig, {
+      sourceLang: options.sourceLang,
+      targetLang: options.targetLang,
+      provider: options.provider,
+      model: options.model,
+      quality: options.quality ? parseInt(options.quality, 10) : void 0,
+      maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+      glossary: options.glossary
+    });
+    const engine = createTranslationEngine({
+      config: config2,
+      verbose: false,
+      noCache: options.cache === false
+    });
+    const result = await engine.translateContent({
+      content,
+      sourceLang: options.sourceLang,
+      targetLang: options.targetLang,
+      format: mapFormat(options.format),
+      glossaryPath: options.glossary,
+      qualityThreshold: options.quality ? parseInt(options.quality, 10) : void 0,
+      maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+      context: options.context
+    });
+    process.stdout.write(result.content);
+  } catch (error) {
+    if (error instanceof TranslationError) {
+      console.error(`Error: ${error.message}`);
+      process.exit(getExitCode(error));
+    }
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+function determineOutputPath(inputPath, targetLang) {
+  const dir = dirname(inputPath);
+  const ext = extname(inputPath);
+  const base = basename(inputPath, ext);
+  return resolve(dir, `${base}.${targetLang}${ext}`);
+}
+function mapFormat(format) {
+  if (!format) return void 0;
+  switch (format.toLowerCase()) {
+    case "md":
+    case "markdown":
+      return "markdown";
+    case "html":
+      return "html";
+    case "txt":
+    case "text":
+      return "text";
+    default:
+      return void 0;
+  }
+}
+var fileCommand;
+var init_file = __esm({
+  "src/cli/commands/file.ts"() {
+    init_options();
+    init_config();
+    init_engine();
+    init_logger();
+    init_errors();
+    fileCommand = new Command("file").description("Translate a single file").argument("<input>", "Input file path").argument("[output]", "Output file path (optional)").option("-s, --source-lang <lang>", "Source language code").option("-t, --target-lang <lang>", "Target language code").option("-g, --glossary <path>", "Path to glossary file").option(
+      "-p, --provider <name>",
+      "LLM provider (claude|openai|ollama)",
+      defaults.provider
+    ).option("-m, --model <name>", "Model name").option(
+      "--quality <0-100>",
+      "Quality threshold",
+      String(defaults.quality)
+    ).option(
+      "--max-iterations <n>",
+      "Max refinement iterations",
+      String(defaults.maxIterations)
+    ).option("-o, --output <path>", "Output path").option("-f, --format <fmt>", "Force output format (md|html|txt)").option("--dry-run", "Show what would be translated").option("--json", "Output results as JSON").option(
+      "--chunk-size <tokens>",
+      "Max tokens per chunk",
+      String(defaults.chunkSize)
+    ).option("--no-cache", "Disable translation cache").option("--context <text>", "Additional context for translation").option("--strict-quality", "Fail if quality threshold is not met").option("--strict-glossary", "Fail if glossary terms are not applied").option("-v, --verbose", "Enable verbose logging").option("-q, --quiet", "Suppress non-error output").action(async (input, output, options) => {
+      try {
+        configureLogger({
+          level: options.verbose ? "debug" : "info",
+          quiet: options.quiet ?? false,
+          json: options.json ?? false
+        });
+        if (!options.sourceLang) {
+          console.error("Error: Source language (-s, --source-lang) is required");
+          process.exit(2);
+        }
+        if (!options.targetLang) {
+          console.error("Error: Target language (-t, --target-lang) is required");
+          process.exit(2);
+        }
+        const baseConfig = await loadConfig({ configPath: options.config });
+        const config2 = mergeConfig(baseConfig, {
+          sourceLang: options.sourceLang,
+          targetLang: options.targetLang,
+          provider: options.provider,
+          model: options.model,
+          quality: options.quality ? parseInt(options.quality, 10) : void 0,
+          maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+          chunkSize: options.chunkSize ? parseInt(options.chunkSize, 10) : void 0,
+          glossary: options.glossary,
+          noCache: options.cache === false
+        });
+        const inputPath = resolve(input);
+        let content;
+        try {
+          content = await readFile(inputPath, "utf-8");
+        } catch (error) {
+          console.error(`Error: Could not read file '${inputPath}'`);
+          process.exit(3);
+        }
+        if (!options.quiet) {
+          logger.info(`Reading: ${inputPath}`);
+          logger.info(`Translating: ${options.sourceLang} \u2192 ${options.targetLang}`);
+          if (options.glossary) {
+            logger.info(`Glossary: ${resolve(options.glossary)}`);
+          }
+        }
+        if (options.dryRun) {
+          console.log("Dry run mode - no translation will be performed");
+          console.log(`Input: ${inputPath}`);
+          console.log(`Output: ${output ?? determineOutputPath(inputPath, options.targetLang)}`);
+          console.log(`Source language: ${options.sourceLang}`);
+          console.log(`Target language: ${options.targetLang}`);
+          console.log(`Content length: ${content.length} characters`);
+          return;
+        }
+        const engine = createTranslationEngine({
+          config: config2,
+          verbose: options.verbose,
+          noCache: options.cache === false
+        });
+        const result = await engine.translateContent({
+          content,
+          sourceLang: options.sourceLang,
+          targetLang: options.targetLang,
+          format: mapFormat(options.format),
+          glossaryPath: options.glossary,
+          qualityThreshold: options.quality ? parseInt(options.quality, 10) : void 0,
+          maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+          context: options.context,
+          strictQuality: options.strictQuality,
+          strictGlossary: options.strictGlossary
+        });
+        const outputPath = output ?? options.output ?? determineOutputPath(inputPath, options.targetLang);
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, result.content, "utf-8");
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: true,
+            input: inputPath,
+            output: outputPath,
+            sourceLang: options.sourceLang,
+            targetLang: options.targetLang,
+            quality: result.metadata.averageQuality,
+            duration: result.metadata.totalDuration,
+            chunks: result.chunks.length,
+            provider: result.metadata.provider,
+            model: result.metadata.model,
+            iterations: result.metadata.totalIterations,
+            tokensUsed: result.metadata.tokensUsed
+          }, null, 2));
+        } else if (!options.quiet) {
+          logger.success(`Written to ${outputPath}`);
+          console.log("");
+          console.log("  Translation Summary:");
+          console.log(`  - Model: ${result.metadata.provider}/${result.metadata.model}`);
+          console.log(`  - Quality: ${result.metadata.averageQuality.toFixed(0)}/100`);
+          console.log(`  - Chunks: ${result.chunks.length}`);
+          console.log(`  - Iterations: ${result.metadata.totalIterations}`);
+          console.log(`  - Tokens: ${result.metadata.tokensUsed.input.toLocaleString()} input / ${result.metadata.tokensUsed.output.toLocaleString()} output`);
+          console.log(`  - Duration: ${(result.metadata.totalDuration / 1e3).toFixed(1)}s`);
+        }
+      } catch (error) {
+        if (error instanceof TranslationError) {
+          console.error(`Error: ${error.message}`);
+          process.exit(getExitCode(error));
+        }
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/cli/index.ts
+init_file();
+
+// src/cli/commands/dir.ts
+init_options();
+init_config();
+init_engine();
+init_logger();
+init_errors();
+var dirCommand = new Command("dir").description("Translate all files in a directory").argument("<input>", "Input directory path").argument("<output>", "Output directory path").option("-s, --source-lang <lang>", "Source language code").option("-t, --target-lang <lang>", "Target language code").option("-g, --glossary <path>", "Path to glossary file").option(
+  "-p, --provider <name>",
+  "LLM provider (claude|openai|ollama)",
+  defaults.provider
+).option("-m, --model <name>", "Model name").option(
+  "--quality <0-100>",
+  "Quality threshold",
+  String(defaults.quality)
+).option(
+  "--max-iterations <n>",
+  "Max refinement iterations",
+  String(defaults.maxIterations)
+).option("-f, --format <fmt>", "Force output format (md|html|txt)").option("--dry-run", "Show what would be translated").option("--json", "Output results as JSON").option(
+  "--chunk-size <tokens>",
+  "Max tokens per chunk",
+  String(defaults.chunkSize)
+).option(
+  "--parallel <n>",
+  "Parallel file processing",
+  String(defaults.parallel)
+).option("--no-cache", "Disable translation cache").option("--context <text>", "Additional context for translation").option("--include <patterns>", "File patterns to include (comma-separated)", "*.md,*.markdown").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option("-v, --verbose", "Enable verbose logging").option("-q, --quiet", "Suppress non-error output").action(async (input, output, options) => {
+  try {
+    configureLogger({
+      level: options.verbose ? "debug" : "info",
+      quiet: options.quiet ?? false,
+      json: options.json ?? false
+    });
+    if (!options.targetLang) {
+      console.error("Error: Target language (-t, --target-lang) is required");
+      process.exit(2);
+    }
+    const inputDir = resolve(input);
+    const outputDir = resolve(output);
+    const includePatterns = options.include?.split(",").map((p) => p.trim()) ?? ["*.md", "*.markdown"];
+    const excludePatterns = options.exclude?.split(",").map((p) => p.trim()) ?? [];
+    const files = await findFiles(inputDir, includePatterns, excludePatterns, outputDir);
+    if (files.length === 0) {
+      console.log("No files found matching the specified patterns");
+      return;
+    }
+    if (!options.quiet) {
+      logger.info(`Found ${files.length} file(s) to translate`);
+      logger.info(`Input: ${inputDir}`);
+      logger.info(`Output: ${outputDir}`);
+      logger.info(`Target language: ${options.targetLang}`);
+      if (options.glossary) {
+        logger.info(`Glossary: ${resolve(options.glossary)}`);
+      }
+    }
+    if (options.dryRun) {
+      console.log("\nDry run mode - no translation will be performed\n");
+      console.log("Files to translate:");
+      for (const file of files) {
+        const relativePath = relative(inputDir, file);
+        const outputPath = join(outputDir, relativePath);
+        console.log(`  ${relativePath} \u2192 ${relative(process.cwd(), outputPath)}`);
+      }
+      console.log(`
+Total: ${files.length} file(s)`);
+      return;
+    }
+    const baseConfig = await loadConfig({ configPath: options.config });
+    const config2 = mergeConfig(baseConfig, {
+      sourceLang: options.sourceLang,
+      targetLang: options.targetLang,
+      provider: options.provider,
+      model: options.model,
+      quality: options.quality ? parseInt(options.quality, 10) : void 0,
+      maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+      chunkSize: options.chunkSize ? parseInt(options.chunkSize, 10) : void 0,
+      glossary: options.glossary,
+      noCache: options.cache === false
+    });
+    const engine = createTranslationEngine({
+      config: config2,
+      verbose: options.verbose,
+      noCache: options.cache === false
+    });
+    const parallelCount = typeof options.parallel === "string" ? parseInt(options.parallel, 10) : options.parallel ?? defaults.parallel;
+    if (!options.quiet) {
+      logger.info(`Parallel processing: ${parallelCount} file(s) at a time`);
+    }
+    const results = await processFiles(
+      files,
+      inputDir,
+      outputDir,
+      engine,
+      options,
+      parallelCount
+    );
+    outputResults(results, options);
+  } catch (error) {
+    if (error instanceof TranslationError) {
+      console.error(`Error: ${error.message}`);
+      process.exit(getExitCode(error));
+    }
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+async function findFiles(dir, includePatterns, excludePatterns, outputDir) {
+  const files = [];
+  const outputRelative = outputDir ? relative(dir, outputDir) : null;
+  const isOutputInsideInput = outputRelative && !outputRelative.startsWith("..");
+  async function scan(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      const relativePath = relative(dir, fullPath);
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (isOutputInsideInput && relativePath === outputRelative) {
+          continue;
+        }
+        if (/^[a-z]{2}(-[A-Z]{2})?$/.test(entry.name)) {
+          continue;
+        }
+        if (!matchesPatterns(relativePath + "/", excludePatterns)) {
+          await scan(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (matchesPatterns(entry.name, includePatterns) && !matchesPatterns(relativePath, excludePatterns)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  await scan(dir);
+  return files.sort();
+}
+function matchesPatterns(path, patterns) {
+  for (const pattern of patterns) {
+    if (matchGlob(path, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchGlob(path, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLESTAR}}/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+async function processFiles(files, inputDir, outputDir, engine, options, parallelCount) {
+  const startTime2 = Date.now();
+  const results = new Array(files.length);
+  let completed = 0;
+  let nextIndex = 0;
+  const processFile = async (inputPath, _index) => {
+    const relativePath = relative(inputDir, inputPath);
+    const outputPath = join(outputDir, relativePath);
+    const fileStartTime = Date.now();
+    try {
+      const content = await readFile(inputPath, "utf-8");
+      const result = await engine.translateContent({
+        content,
+        sourceLang: options.sourceLang,
+        targetLang: options.targetLang,
+        format: mapFormat2(options.format),
+        glossaryPath: options.glossary,
+        qualityThreshold: options.quality ? parseInt(options.quality, 10) : void 0,
+        maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : void 0,
+        context: options.context
+      });
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, result.content, "utf-8");
+      completed++;
+      if (!options.quiet && !options.json) {
+        const progress = `[${completed}/${files.length}]`;
+        logger.success(`${progress} ${relativePath}`);
+      }
+      return {
+        inputPath,
+        outputPath,
+        relativePath,
+        success: true,
+        result,
+        duration: Date.now() - fileStartTime
+      };
+    } catch (error) {
+      completed++;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (!options.quiet && !options.json) {
+        const progress = `[${completed}/${files.length}]`;
+        logger.error(`${progress} ${relativePath}: ${errorMessage}`);
+      }
+      return {
+        inputPath,
+        outputPath,
+        relativePath,
+        success: false,
+        error: errorMessage,
+        duration: Date.now() - fileStartTime
+      };
+    }
+  };
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= files.length) break;
+      const inputPath = files[index];
+      if (!inputPath) break;
+      const result = await processFile(inputPath);
+      results[index] = result;
+    }
+  };
+  const workerCount = Math.min(parallelCount, files.length);
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  const successResults = results.filter((r) => r.success && r.result);
+  const totalTokensInput = successResults.reduce((sum, r) => sum + (r.result?.metadata.tokensUsed.input ?? 0), 0);
+  const totalTokensOutput = successResults.reduce((sum, r) => sum + (r.result?.metadata.tokensUsed.output ?? 0), 0);
+  const totalCacheRead = successResults.reduce((sum, r) => sum + (r.result?.metadata.tokensUsed.cacheRead ?? 0), 0);
+  const totalCacheWrite = successResults.reduce((sum, r) => sum + (r.result?.metadata.tokensUsed.cacheWrite ?? 0), 0);
+  return {
+    files: results,
+    totalDuration: Date.now() - startTime2,
+    successCount: results.filter((r) => r.success).length,
+    failCount: results.filter((r) => !r.success).length,
+    totalTokensInput,
+    totalTokensOutput,
+    totalCacheRead,
+    totalCacheWrite
+  };
+}
+function outputResults(results, options) {
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: results.failCount === 0,
+      totalFiles: results.files.length,
+      successCount: results.successCount,
+      failCount: results.failCount,
+      totalDuration: results.totalDuration,
+      tokensUsed: {
+        input: results.totalTokensInput,
+        output: results.totalTokensOutput,
+        cacheRead: results.totalCacheRead,
+        cacheWrite: results.totalCacheWrite
+      },
+      files: results.files.map((f) => ({
+        input: f.relativePath,
+        output: f.outputPath,
+        success: f.success,
+        error: f.error,
+        duration: f.duration,
+        quality: f.result?.metadata.averageQuality ?? 0,
+        tokens: f.result ? {
+          input: f.result.metadata.tokensUsed.input,
+          output: f.result.metadata.tokensUsed.output
+        } : void 0
+      }))
+    }, null, 2));
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  console.log("");
+  console.log("\u2500".repeat(60));
+  console.log("  Translation Summary");
+  console.log("\u2500".repeat(60));
+  console.log(`  Files:      ${results.successCount} succeeded, ${results.failCount} failed`);
+  console.log(`  Duration:   ${(results.totalDuration / 1e3).toFixed(1)}s`);
+  console.log(`  Tokens:     ${results.totalTokensInput.toLocaleString()} input / ${results.totalTokensOutput.toLocaleString()} output`);
+  if (results.totalCacheRead > 0 || results.totalCacheWrite > 0) {
+    console.log(`  Cache:      ${results.totalCacheRead.toLocaleString()} read / ${results.totalCacheWrite.toLocaleString()} write`);
+  }
+  if (results.failCount > 0) {
+    console.log("");
+    console.log("  Failed files:");
+    for (const file of results.files.filter((f) => !f.success)) {
+      console.log(`    - ${file.relativePath}: ${file.error}`);
+    }
+  }
+  console.log("\u2500".repeat(60));
+}
+function mapFormat2(format) {
+  if (!format) return void 0;
+  switch (format.toLowerCase()) {
+    case "md":
+    case "markdown":
+      return "markdown";
+    case "html":
+      return "html";
+    case "txt":
+    case "text":
+      return "text";
+    default:
+      return void 0;
+  }
+}
+var defaultConfig2 = {
+  version: "1.0",
+  project: {
+    name: "My Project",
+    description: "Project description",
+    purpose: "Technical documentation translation"
+  },
+  languages: {
+    source: "en",
+    targets: ["ko"]
+  },
+  provider: {
+    default: "claude",
+    model: "claude-sonnet-4-20250514"
+  },
+  quality: {
+    threshold: 85,
+    maxIterations: 4,
+    evaluationMethod: "llm"
+  },
+  chunking: {
+    maxTokens: 1024,
+    overlapTokens: 150,
+    preserveStructure: true
+  },
+  paths: {
+    output: "./docs/{lang}",
+    cache: "./.translate-cache"
+  },
+  ignore: ["**/node_modules/**", "**/*.test.md"]
+};
+var initCommand = new Command("init").description("Initialize project configuration").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
+  const configPath = join(process.cwd(), ".translaterc.json");
+  if (!options.force) {
+    try {
+      await access(configPath);
+      console.error(
+        "Configuration file already exists. Use --force to overwrite."
+      );
+      process.exit(1);
+    } catch {
+    }
+  }
+  try {
+    await writeFile(configPath, JSON.stringify(defaultConfig2, null, 2));
+    console.log("Created .translaterc.json");
+    console.log("\nNext steps:");
+    console.log("1. Edit .translaterc.json to configure your project");
+    console.log("2. Set your API key: export ANTHROPIC_API_KEY=your-key");
+    console.log("3. Run: llm-translate file <input> -s en -t ko");
+  } catch (error) {
+    console.error("Failed to create configuration file:", error);
+    process.exit(1);
+  }
+});
+var glossaryCommand = new Command("glossary").description("Manage glossary (add, remove, list, validate)");
+glossaryCommand.command("list").description("List all terms in a glossary").argument("<path>", "Path to glossary file").option("--lang <lang>", "Filter by target language").action(async (path, options) => {
+  try {
+    const glossary = await loadGlossary2(path);
+    console.log(`Glossary: ${glossary.metadata.name}`);
+    console.log(`Source: ${glossary.metadata.sourceLang}`);
+    console.log(`Targets: ${glossary.metadata.targetLangs.join(", ")}`);
+    console.log(`Terms: ${glossary.terms.length}`);
+    console.log("---");
+    for (const term of glossary.terms) {
+      if (term.doNotTranslate) {
+        console.log(`  ${term.source} \u2192 [do not translate]`);
+      } else if (options.lang && term.targets[options.lang]) {
+        console.log(`  ${term.source} \u2192 ${term.targets[options.lang]}`);
+      } else if (!options.lang) {
+        const translations = Object.entries(term.targets).map(([lang, val]) => `${lang}: ${val}`).join(", ");
+        console.log(`  ${term.source} \u2192 ${translations || "[no translations]"}`);
+      }
+    }
+  } catch (error) {
+    console.error("Failed to load glossary:", error);
+    process.exit(1);
+  }
+});
+glossaryCommand.command("validate").description("Validate a glossary file").argument("<path>", "Path to glossary file").action(async (path) => {
+  try {
+    const glossary = await loadGlossary2(path);
+    const errors = validateGlossary(glossary);
+    if (errors.length === 0) {
+      console.log("Glossary is valid!");
+      console.log(`  Name: ${glossary.metadata.name}`);
+      console.log(`  Terms: ${glossary.terms.length}`);
+      console.log(`  Source: ${glossary.metadata.sourceLang}`);
+      console.log(`  Targets: ${glossary.metadata.targetLangs.join(", ")}`);
+    } else {
+      console.error("Glossary validation failed:");
+      for (const error of errors) {
+        console.error(`  - ${error}`);
+      }
+      process.exit(6);
+    }
+  } catch (error) {
+    console.error("Failed to load glossary:", error);
+    process.exit(1);
+  }
+});
+glossaryCommand.command("add").description("Add a term to the glossary").argument("<path>", "Path to glossary file").argument("<source>", "Source term").option("--target <lang:value...>", "Target translations (e.g., ko:\uBC88\uC5ED)").option("--context <text>", "Usage context").option("--do-not-translate", "Mark as do not translate").action(
+  async (path, source, options) => {
+    try {
+      const glossary = await loadGlossary2(path);
+      const existing = glossary.terms.find(
+        (t) => t.source.toLowerCase() === source.toLowerCase()
+      );
+      if (existing) {
+        console.error(`Term "${source}" already exists in glossary.`);
+        process.exit(1);
+      }
+      const targets = {};
+      if (options.target) {
+        for (const t of options.target) {
+          const [lang, ...rest] = t.split(":");
+          if (lang && rest.length > 0) {
+            targets[lang] = rest.join(":");
+          }
+        }
+      }
+      const newTerm = {
+        source,
+        targets,
+        context: options.context,
+        doNotTranslate: options.doNotTranslate
+      };
+      glossary.terms.push(newTerm);
+      await writeFile(path, JSON.stringify(glossary, null, 2));
+      console.log(`Added term: ${source}`);
+    } catch (error) {
+      console.error("Failed to add term:", error);
+      process.exit(1);
+    }
+  }
+);
+glossaryCommand.command("remove").description("Remove a term from the glossary").argument("<path>", "Path to glossary file").argument("<source>", "Source term to remove").action(async (path, source) => {
+  try {
+    const glossary = await loadGlossary2(path);
+    const index = glossary.terms.findIndex(
+      (t) => t.source.toLowerCase() === source.toLowerCase()
+    );
+    if (index === -1) {
+      console.error(`Term "${source}" not found in glossary.`);
+      process.exit(1);
+    }
+    glossary.terms.splice(index, 1);
+    await writeFile(path, JSON.stringify(glossary, null, 2));
+    console.log(`Removed term: ${source}`);
+  } catch (error) {
+    console.error("Failed to remove term:", error);
+    process.exit(1);
+  }
+});
+async function loadGlossary2(path) {
+  const content = await readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+function validateGlossary(glossary) {
+  const errors = [];
+  if (!glossary.metadata) {
+    errors.push("Missing metadata section");
+  } else {
+    if (!glossary.metadata.name) {
+      errors.push("Missing metadata.name");
+    }
+    if (!glossary.metadata.sourceLang) {
+      errors.push("Missing metadata.sourceLang");
+    }
+    if (!glossary.metadata.targetLangs || glossary.metadata.targetLangs.length === 0) {
+      errors.push("Missing or empty metadata.targetLangs");
+    }
+  }
+  if (!glossary.terms || !Array.isArray(glossary.terms)) {
+    errors.push("Missing or invalid terms array");
+  } else {
+    const seenSources = /* @__PURE__ */ new Set();
+    for (let i = 0; i < glossary.terms.length; i++) {
+      const term = glossary.terms[i];
+      if (!term) continue;
+      if (!term.source) {
+        errors.push(`Term at index ${i}: missing source`);
+        continue;
+      }
+      const normalizedSource = term.source.toLowerCase();
+      if (seenSources.has(normalizedSource)) {
+        errors.push(`Duplicate term: "${term.source}"`);
+      }
+      seenSources.add(normalizedSource);
+      if (!term.doNotTranslate && Object.keys(term.targets).length === 0) {
+        if (!term.doNotTranslateFor || term.doNotTranslateFor.length === 0) {
+          errors.push(
+            `Term "${term.source}": no translations and not marked as do-not-translate`
+          );
+        }
+      }
+    }
+  }
+  return errors;
+}
+function createAuthMiddleware(config2) {
+  return createMiddleware(async (c, next) => {
+    if (!config2.enabled) {
+      return next();
+    }
+    const expectedKey = config2.apiKey ?? process.env.TRANSLATE_API_KEY;
+    if (!expectedKey) {
+      return next();
+    }
+    let providedKey = c.req.header("X-API-Key");
+    if (!providedKey) {
+      const authHeader = c.req.header("Authorization");
+      if (authHeader?.startsWith("Bearer ")) {
+        providedKey = authHeader.slice(7);
+      }
+    }
+    if (!providedKey) {
+      throw new HTTPException(401, {
+        message: "API key required. Provide via X-API-Key header or Authorization: Bearer <token>"
+      });
+    }
+    if (!timingSafeEqual(providedKey, expectedKey)) {
+      throw new HTTPException(401, {
+        message: "Invalid API key"
+      });
+    }
+    return next();
+  });
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) {
+    let result2 = 1;
+    const maxLen = Math.max(a.length, b.length);
+    for (let i = 0; i < maxLen; i++) {
+      result2 |= (a.charCodeAt(i % a.length) || 0) ^ (b.charCodeAt(i % b.length) || 0);
+    }
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+function createLoggerMiddleware(config2) {
+  return createMiddleware(async (c, next) => {
+    const start = Date.now();
+    const requestId = generateRequestId();
+    c.set("requestId", requestId);
+    const method = c.req.method;
+    const path = c.req.path;
+    await next();
+    const duration = Date.now() - start;
+    const status = c.res.status;
+    if (config2.json) {
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        method,
+        path,
+        status,
+        duration,
+        userAgent: c.req.header("User-Agent")
+      };
+      console.log(JSON.stringify(entry));
+    } else {
+      const statusColor = getStatusColor(status);
+      console.log(`${statusColor}${status}\x1B[0m ${method} ${path} - ${duration}ms`);
+    }
+  });
+}
+function generateRequestId() {
+  return Math.random().toString(36).substring(2, 10);
+}
+function getStatusColor(status) {
+  if (status >= 500) {
+    return "\x1B[31m";
+  }
+  if (status >= 400) {
+    return "\x1B[33m";
+  }
+  if (status >= 300) {
+    return "\x1B[36m";
+  }
+  return "\x1B[32m";
+}
+
+// src/server/routes/health.ts
+init_registry();
+var healthRouter = new Hono();
+var startTime = Date.now();
+healthRouter.get("/", async (c) => {
+  const providers2 = getAvailableProviders();
+  const providerStatus = providers2.map((name) => {
+    const config2 = getProviderConfigFromEnv(name);
+    let available = false;
+    if (name === "ollama") {
+      available = true;
+    } else {
+      available = !!config2.apiKey;
+    }
+    return { name, available };
+  });
+  const anyProviderAvailable = providerStatus.some((p) => p.available);
+  const response = {
+    status: anyProviderAvailable ? "healthy" : "degraded",
+    version: process.env["npm_package_version"] ?? "0.1.0",
+    uptime: Math.floor((Date.now() - startTime) / 1e3),
+    providers: providerStatus
+  };
+  const status = anyProviderAvailable ? 200 : 503;
+  return c.json(response, status);
+});
+healthRouter.get("/live", (c) => {
+  return c.json({ status: "ok" });
+});
+healthRouter.get("/ready", async (c) => {
+  const providers2 = getAvailableProviders();
+  const hasConfiguredProvider = providers2.some((name) => {
+    if (name === "ollama") return true;
+    const config2 = getProviderConfigFromEnv(name);
+    return !!config2.apiKey;
+  });
+  if (hasConfiguredProvider) {
+    return c.json({ status: "ready" });
+  }
+  return c.json({ status: "not_ready", reason: "No providers configured" }, 503);
+});
+var TranslationModeSchema = z.enum(["fast", "balanced", "quality"]);
+var InlineGlossaryTermSchema = z.object({
+  source: z.string().min(1, "Source term is required"),
+  target: z.string().min(1, "Target term is required"),
+  context: z.string().optional(),
+  caseSensitive: z.boolean().optional(),
+  doNotTranslate: z.boolean().optional()
+});
+var TranslateRequestSchema = z.object({
+  content: z.string().min(1, "Content is required"),
+  sourceLang: z.string().min(2, "Source language code must be at least 2 characters").max(10, "Source language code must be at most 10 characters"),
+  targetLang: z.string().min(2, "Target language code must be at least 2 characters").max(10, "Target language code must be at most 10 characters"),
+  format: z.enum(["markdown", "html", "text"]).optional().default("text"),
+  glossary: z.array(InlineGlossaryTermSchema).optional(),
+  provider: z.enum(["claude", "openai", "ollama"]).optional(),
+  model: z.string().optional(),
+  mode: TranslationModeSchema.optional().default("balanced"),
+  qualityThreshold: z.number().min(0).max(100).optional(),
+  maxIterations: z.number().min(1).max(10).optional(),
+  context: z.string().optional()
+});
+var MODE_PRESETS2 = {
+  fast: { qualityThreshold: 0, maxIterations: 1 },
+  balanced: { qualityThreshold: 75, maxIterations: 2 },
+  quality: { qualityThreshold: 85, maxIterations: 4 }
+};
+
+// src/server/routes/translate.ts
+init_engine();
+init_config();
+init_errors();
+var translateRouter = new Hono();
+translateRouter.post(
+  "/",
+  zValidator("json", TranslateRequestSchema, (result, c) => {
+    if (!result.success) {
+      const errors = result.error.errors.map((e) => ({
+        field: e.path.join("."),
+        message: e.message
+      }));
+      return c.json(
+        {
+          error: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: { errors }
+        },
+        400
+      );
+    }
+    return void 0;
+  }),
+  async (c) => {
+    const body = c.req.valid("json");
+    const requestId = c.get("requestId") ?? "unknown";
+    const startTime2 = Date.now();
+    try {
+      const baseConfig = await loadConfig();
+      const modeConfig = MODE_PRESETS2[body.mode ?? "balanced"];
+      const config2 = {
+        ...baseConfig,
+        languages: {
+          ...baseConfig.languages,
+          source: body.sourceLang,
+          targets: [body.targetLang]
+        },
+        provider: {
+          ...baseConfig.provider,
+          default: body.provider ?? baseConfig.provider.default,
+          model: body.model ?? baseConfig.provider.model
+        },
+        quality: {
+          ...baseConfig.quality,
+          threshold: body.qualityThreshold ?? modeConfig.qualityThreshold,
+          maxIterations: body.maxIterations ?? modeConfig.maxIterations
+        }
+      };
+      const engine = createTranslationEngine({
+        config: config2,
+        verbose: false,
+        noCache: true
+      });
+      if (body.glossary && body.glossary.length > 0) {
+        convertInlineGlossary(body.glossary, body.sourceLang, body.targetLang);
+      }
+      const result = await engine.translateContent({
+        content: body.content,
+        sourceLang: body.sourceLang,
+        targetLang: body.targetLang,
+        format: body.format,
+        qualityThreshold: config2.quality.threshold,
+        maxIterations: config2.quality.maxIterations,
+        context: body.context
+      });
+      const duration = Date.now() - startTime2;
+      const response = {
+        translated: result.content,
+        quality: result.metadata.averageQuality,
+        iterations: result.metadata.totalIterations,
+        tokensUsed: {
+          input: result.metadata.tokensUsed.input,
+          output: result.metadata.tokensUsed.output
+        },
+        glossaryCompliance: result.glossaryCompliance ? {
+          applied: result.glossaryCompliance.applied,
+          missed: result.glossaryCompliance.missed
+        } : void 0,
+        duration,
+        provider: result.metadata.provider,
+        model: result.metadata.model
+      };
+      return c.json(response, 200);
+    } catch (error) {
+      return handleTranslationError(c, error, requestId);
+    }
+  }
+);
+function convertInlineGlossary(terms, sourceLang, targetLang) {
+  return {
+    metadata: {
+      name: "inline",
+      sourceLang,
+      targetLang,
+      version: "1.0"
+    },
+    terms: terms.map(
+      (term) => ({
+        source: term.source,
+        target: term.doNotTranslate ? term.source : term.target,
+        context: term.context,
+        caseSensitive: term.caseSensitive ?? false,
+        doNotTranslate: term.doNotTranslate ?? false
+      })
+    )
+  };
+}
+function handleTranslationError(c, error, requestId) {
+  if (error instanceof TranslationError) {
+    const statusMap = {
+      ["PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */]: 401,
+      ["PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */]: 429,
+      ["PROVIDER_ERROR" /* PROVIDER_ERROR */]: 502,
+      ["PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */]: 400,
+      ["QUALITY_THRESHOLD_NOT_MET" /* QUALITY_THRESHOLD_NOT_MET */]: 422,
+      ["GLOSSARY_INVALID" /* GLOSSARY_INVALID */]: 400,
+      ["GLOSSARY_NOT_FOUND" /* GLOSSARY_NOT_FOUND */]: 400,
+      ["CONFIG_INVALID" /* CONFIG_INVALID */]: 400,
+      ["UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */]: 400
+    };
+    const status = statusMap[error.code] ?? 500;
+    return c.json(
+      {
+        error: error.message,
+        code: error.code,
+        details: error.details
+      },
+      status
+    );
+  }
+  console.error(`[${requestId}] Translation error:`, error);
+  return c.json(
+    {
+      error: "Internal server error",
+      code: "INTERNAL_ERROR"
+    },
+    500
+  );
+}
+
+// src/server/index.ts
+function createApp(options) {
+  const app = new Hono();
+  app.use("*", createLoggerMiddleware({
+    json: options.jsonLogging ?? false
+  }));
+  if (options.enableCors) {
+    app.use("*", cors({
+      origin: "*",
+      allowMethods: ["GET", "POST", "OPTIONS"],
+      allowHeaders: ["Content-Type", "Authorization", "X-API-Key"],
+      exposeHeaders: ["X-Request-Id"],
+      maxAge: 86400
+    }));
+  }
+  app.route("/health", healthRouter);
+  app.use("/translate/*", createAuthMiddleware({
+    enabled: options.enableAuth,
+    apiKey: options.apiKey
+  }));
+  app.use("/translate", createAuthMiddleware({
+    enabled: options.enableAuth,
+    apiKey: options.apiKey
+  }));
+  app.route("/translate", translateRouter);
+  app.onError((error, c) => {
+    if (error instanceof HTTPException) {
+      return c.json(
+        {
+          error: error.message,
+          code: "HTTP_ERROR"
+        },
+        error.status
+      );
+    }
+    console.error("Unhandled error:", error);
+    return c.json(
+      {
+        error: "Internal server error",
+        code: "INTERNAL_ERROR"
+      },
+      500
+    );
+  });
+  app.notFound((c) => {
+    return c.json(
+      {
+        error: "Not found",
+        code: "NOT_FOUND"
+      },
+      404
+    );
+  });
+  return app;
+}
+function startServer(options) {
+  const app = createApp(options);
+  const server = serve({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host
+  });
+  console.log(`
+llm-translate server started`);
+  console.log(`  - Address: http://${options.host}:${options.port}`);
+  console.log(`  - Health: http://${options.host}:${options.port}/health`);
+  console.log(`  - Translate: http://${options.host}:${options.port}/translate`);
+  console.log(`  - Auth: ${options.enableAuth ? "enabled" : "disabled"}`);
+  console.log(`  - CORS: ${options.enableCors ? "enabled" : "disabled"}`);
+  console.log("");
+  const shutdown = (signal) => {
+    console.log(`
+Received ${signal}, shutting down gracefully...`);
+    server.close((err) => {
+      if (err) {
+        console.error("Error during shutdown:", err);
+        process.exit(1);
+      }
+      console.log("Server closed");
+      process.exit(0);
+    });
+    setTimeout(() => {
+      console.error("Forced shutdown after timeout");
+      process.exit(1);
+    }, 1e4);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  return server;
+}
+
+// src/cli/commands/serve.ts
+var serveCommand = new Command("serve").description("Start the translation API server").option(
+  "-p, --port <number>",
+  "Server port (env: TRANSLATE_PORT)",
+  process.env["TRANSLATE_PORT"] ?? "3000"
+).option("-H, --host <string>", "Host to bind", "0.0.0.0").option("--no-auth", "Disable API key authentication").option("--cors", "Enable CORS for browser clients").option("--json", "Use JSON logging format (for containers)").action((options) => {
+  const port = parseInt(options.port ?? "3000", 10);
+  const host = options.host ?? "0.0.0.0";
+  if (isNaN(port) || port < 1 || port > 65535) {
+    console.error("Error: Invalid port number. Must be between 1 and 65535.");
+    process.exit(2);
+  }
+  const enableAuth = options.auth !== false;
+  if (enableAuth && !process.env["TRANSLATE_API_KEY"]) {
+    console.warn(
+      "Warning: TRANSLATE_API_KEY not set. API key authentication is disabled."
+    );
+    console.warn(
+      "Set TRANSLATE_API_KEY environment variable to enable authentication.\n"
+    );
+  }
+  startServer({
+    port,
+    host,
+    enableAuth,
+    enableCors: options.cors ?? false,
+    apiKey: process.env["TRANSLATE_API_KEY"],
+    jsonLogging: options.json ?? false
+  });
+});
+
+// src/cli/index.ts
+var program = new Command();
+program.name("llm-translate").description(
+  "CLI-based document translation tool powered by LLMs with glossary enforcement"
+).version("0.1.0").enablePositionalOptions().passThroughOptions();
+program.option("-s, --source-lang <lang>", "Source language code").option("-t, --target-lang <lang>", "Target language code").option(
+  "-c, --config <path>",
+  "Path to config file (default: .translaterc.json)"
+).option("-v, --verbose", "Enable verbose logging").option("-q, --quiet", "Suppress non-error output");
+program.addCommand(fileCommand);
+program.addCommand(dirCommand);
+program.addCommand(initCommand);
+program.addCommand(glossaryCommand);
+program.addCommand(serveCommand);
+program.action(async (options) => {
+  if (!process.stdin.isTTY) {
+    const { handleStdinTranslation: handleStdinTranslation2 } = await Promise.resolve().then(() => (init_file(), file_exports));
+    await handleStdinTranslation2(options);
+  } else {
+    program.help();
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error("Error:", error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map