@llm-translate/cli 1.0.0-next.1

package/dist/index.js

@@ -0,0 +1,3841 @@
+import { cosmiconfig } from 'cosmiconfig';
+import { z } from 'zod';
+import { readFile } from 'fs/promises';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import chalk from 'chalk';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { generateText, streamText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkStringify from 'remark-stringify';
+import remarkGfm from 'remark-gfm';
+import { visit } from 'unist-util-visit';
+
+// src/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["CONFIG_NOT_FOUND"] = "CONFIG_NOT_FOUND";
+  ErrorCode2["CONFIG_INVALID"] = "CONFIG_INVALID";
+  ErrorCode2["GLOSSARY_NOT_FOUND"] = "GLOSSARY_NOT_FOUND";
+  ErrorCode2["GLOSSARY_INVALID"] = "GLOSSARY_INVALID";
+  ErrorCode2["PROVIDER_NOT_FOUND"] = "PROVIDER_NOT_FOUND";
+  ErrorCode2["PROVIDER_AUTH_FAILED"] = "PROVIDER_AUTH_FAILED";
+  ErrorCode2["PROVIDER_RATE_LIMITED"] = "PROVIDER_RATE_LIMITED";
+  ErrorCode2["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+  ErrorCode2["QUALITY_THRESHOLD_NOT_MET"] = "QUALITY_THRESHOLD_NOT_MET";
+  ErrorCode2["GLOSSARY_COMPLIANCE_FAILED"] = "GLOSSARY_COMPLIANCE_FAILED";
+  ErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+  ErrorCode2["FILE_READ_ERROR"] = "FILE_READ_ERROR";
+  ErrorCode2["FILE_WRITE_ERROR"] = "FILE_WRITE_ERROR";
+  ErrorCode2["UNSUPPORTED_FORMAT"] = "UNSUPPORTED_FORMAT";
+  ErrorCode2["CHUNK_TOO_LARGE"] = "CHUNK_TOO_LARGE";
+  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return ErrorCode2;
+})(ErrorCode || {});
+var 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."
+};
+var 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
+    };
+  }
+};
+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 isTranslationError(error) {
+  return error instanceof TranslationError;
+}
+function isErrorCode(error, code) {
+  return isTranslationError(error) && error.code === code;
+}
+var 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
+};
+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 providerNameSchema = z.enum(["claude", "openai", "ollama", "custom"]);
+var 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()
+});
+var 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}"
+  }
+};
+var explorer = cosmiconfig("translate", {
+  searchPlaces: [
+    ".translaterc",
+    ".translaterc.json",
+    ".translaterc.yaml",
+    ".translaterc.yml",
+    "translate.config.js",
+    "translate.config.mjs"
+  ]
+});
+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;
+}
+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");
+    }
+  };
+}
+function 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);
+    }
+  }
+  const total = sourceTerms.length;
+  const score = total > 0 ? applied.length / total * 100 : 100;
+  return { applied, missed, score };
+}
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var config = {
+  level: "info",
+  quiet: false,
+  json: false
+};
+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}`);
+  }
+}
+var 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();
+      }
+    }
+  }
+};
+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`;
+    }
+  };
+}
+
+// src/services/cache.ts
+var CACHE_VERSION = "1.0";
+var INDEX_FILE = "index.json";
+var ENTRIES_DIR = "entries";
+var GlossaryChangePolicy = class {
+  name = "GlossaryChangePolicy";
+  mode;
+  /**
+   * @param mode - 'all' invalidates entire cache, 'matching' only entries with old glossary hash
+   */
+  constructor(mode = "all") {
+    this.mode = mode;
+  }
+  check(context) {
+    const { glossaryHash, previousGlossaryHash } = context;
+    if (!glossaryHash || !previousGlossaryHash) {
+      return { shouldInvalidate: false, scope: "none" };
+    }
+    if (glossaryHash === previousGlossaryHash) {
+      return { shouldInvalidate: false, scope: "none" };
+    }
+    if (this.mode === "all") {
+      return {
+        shouldInvalidate: true,
+        reason: `Glossary changed (${previousGlossaryHash.slice(0, 8)} \u2192 ${glossaryHash.slice(0, 8)})`,
+        scope: "all"
+      };
+    }
+    return {
+      shouldInvalidate: true,
+      reason: `Glossary changed, invalidating matching entries`,
+      scope: "matching",
+      filter: (entry) => entry.glossaryHash === previousGlossaryHash
+    };
+  }
+};
+var TTLPolicy = class _TTLPolicy {
+  name = "TTLPolicy";
+  ttlMs;
+  /**
+   * @param ttlMs - Time-to-live in milliseconds
+   */
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  /**
+   * Create policy with TTL in hours
+   */
+  static hours(hours) {
+    return new _TTLPolicy(hours * 60 * 60 * 1e3);
+  }
+  /**
+   * Create policy with TTL in days
+   */
+  static days(days) {
+    return new _TTLPolicy(days * 24 * 60 * 60 * 1e3);
+  }
+  check(context) {
+    const currentTime = context.currentTime ?? /* @__PURE__ */ new Date();
+    const ttlMs = this.ttlMs;
+    return {
+      shouldInvalidate: true,
+      reason: `TTL check (${this.ttlMs}ms)`,
+      scope: "matching",
+      filter: (entry) => {
+        const createdAt = new Date(entry.createdAt);
+        const age = currentTime.getTime() - createdAt.getTime();
+        return age > ttlMs;
+      }
+    };
+  }
+};
+var ProviderChangePolicy = class {
+  name = "ProviderChangePolicy";
+  checkModel;
+  /**
+   * @param checkModel - If true, also invalidate when model changes within same provider
+   */
+  constructor(checkModel = true) {
+    this.checkModel = checkModel;
+  }
+  check(context) {
+    const { provider, model } = context;
+    if (!provider) {
+      return { shouldInvalidate: false, scope: "none" };
+    }
+    return {
+      shouldInvalidate: true,
+      reason: `Provider/model mismatch check`,
+      scope: "matching",
+      filter: (entry) => {
+        if (entry.provider !== provider) return true;
+        if (this.checkModel && model && entry.model !== model) return true;
+        return false;
+      }
+    };
+  }
+};
+var QualityThresholdPolicy = class {
+  name = "QualityThresholdPolicy";
+  threshold;
+  /**
+   * @param threshold - Minimum quality score (0-100)
+   */
+  constructor(threshold) {
+    this.threshold = threshold;
+  }
+  check(_context) {
+    const threshold = this.threshold;
+    return {
+      shouldInvalidate: true,
+      reason: `Quality below threshold (${threshold})`,
+      scope: "matching",
+      filter: (entry) => entry.qualityScore < threshold
+    };
+  }
+};
+var CompositePolicy = class {
+  name = "CompositePolicy";
+  policies;
+  mode;
+  /**
+   * @param policies - Array of policies to combine
+   * @param mode - 'any' triggers if any policy matches, 'all' requires all policies to match
+   */
+  constructor(policies, mode = "any") {
+    this.policies = policies;
+    this.mode = mode;
+  }
+  check(context) {
+    const results = this.policies.map((p) => ({
+      policy: p,
+      result: p.check(context)
+    }));
+    const activeResults = results.filter((r) => r.result.shouldInvalidate);
+    if (activeResults.length === 0) {
+      return { shouldInvalidate: false, scope: "none" };
+    }
+    const allScope = activeResults.find((r) => r.result.scope === "all");
+    if (allScope) {
+      return {
+        shouldInvalidate: true,
+        reason: `${allScope.policy.name}: ${allScope.result.reason}`,
+        scope: "all"
+      };
+    }
+    const filters = activeResults.filter((r) => r.result.filter).map((r) => r.result.filter);
+    if (filters.length === 0) {
+      return { shouldInvalidate: false, scope: "none" };
+    }
+    const reasons = activeResults.map((r) => `${r.policy.name}`).join(", ");
+    if (this.mode === "any") {
+      return {
+        shouldInvalidate: true,
+        reason: `Composite (any): ${reasons}`,
+        scope: "matching",
+        filter: (entry, key) => filters.some((f) => f(entry, key))
+      };
+    } else {
+      return {
+        shouldInvalidate: true,
+        reason: `Composite (all): ${reasons}`,
+        scope: "matching",
+        filter: (entry, key) => filters.every((f) => f(entry, key))
+      };
+    }
+  }
+};
+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}`;
+}
+var 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 };
+  }
+};
+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;
+}
+function createDefaultPolicies() {
+  return [
+    new GlossaryChangePolicy("all"),
+    TTLPolicy.days(30)
+  ];
+}
+function createStrictPolicies(qualityThreshold = 85) {
+  return [
+    new GlossaryChangePolicy("all"),
+    new ProviderChangePolicy(true),
+    new QualityThresholdPolicy(qualityThreshold),
+    TTLPolicy.days(7)
+  ];
+}
+function createMinimalPolicies() {
+  return [
+    new GlossaryChangePolicy("matching")
+  ];
+}
+
+// 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);
+}
+function exceedsTokenLimit(text, limit) {
+  return estimateTokens(text) > limit;
+}
+function truncateToTokenLimit(text, limit) {
+  const estimated = estimateTokens(text);
+  if (estimated <= limit) {
+    return text;
+  }
+  const avgCharsPerToken = text.length / estimated;
+  const targetChars = Math.floor(limit * avgCharsPerToken * 0.95);
+  return text.slice(0, targetChars) + "...";
+}
+
+// src/providers/claude.ts
+var 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
+  }
+};
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+var 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 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_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
+  }
+};
+var DEFAULT_MODEL2 = "gpt-4o-mini";
+var 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 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_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
+  }
+};
+var DEFAULT_MODEL3 = "llama3.2";
+var DEFAULT_BASE_URL = "http://localhost:11434";
+var 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
+    });
+  }
+};
+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);
+}
+
+// src/providers/registry.ts
+var providers = /* @__PURE__ */ new Map();
+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 hasProvider(name) {
+  return providers.has(name);
+}
+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 {};
+  }
+}
+registerProvider("claude", createClaudeProvider);
+registerProvider("openai", createOpenAIProvider);
+registerProvider("ollama", createOllamaProvider);
+function canUseProvider(name, config2) {
+  if (!hasProvider(name)) {
+    return false;
+  }
+  if (name === "ollama") {
+    return true;
+  }
+  return !!config2.apiKey;
+}
+function createProviderWithFallback(options) {
+  const { primary, fallback = [], config: config2 = {} } = options;
+  const primaryConfig = {
+    ...getProviderConfigFromEnv(primary),
+    ...config2[primary]
+  };
+  if (canUseProvider(primary, primaryConfig)) {
+    return getProvider(primary, primaryConfig);
+  }
+  for (const fallbackName of fallback) {
+    const fallbackConfig = {
+      ...getProviderConfigFromEnv(fallbackName),
+      ...config2[fallbackName]
+    };
+    if (canUseProvider(fallbackName, fallbackConfig)) {
+      return getProvider(fallbackName, fallbackConfig);
+    }
+  }
+  throw new TranslationError("PROVIDER_AUTH_FAILED" /* PROVIDER_AUTH_FAILED */, {
+    primary,
+    fallback,
+    message: "No API key found for any configured provider"
+  });
+}
+
+// src/core/chunker.ts
+var DEFAULT_CONFIG = {
+  maxTokens: 1024,
+  overlapTokens: 150};
+function chunkContent(content, options = {}) {
+  if (!content.trim()) {
+    return [];
+  }
+  const config2 = {
+    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 reassembleChunks(chunks) {
+  const sorted = [...chunks].sort((a, b) => a.startOffset - b.startOffset);
+  return sorted.map((chunk) => chunk.content).join("");
+}
+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
+  };
+}
+
+// src/types/mqm.ts
+var MQM_SEVERITY_WEIGHTS = {
+  minor: 1,
+  // Noticeable but doesn't affect understanding
+  major: 5,
+  // Affects understanding or usability
+  critical: 25
+  // Completely wrong or unusable
+};
+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");
+}
+
+// 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"
+  };
+}
+
+// src/types/modes.ts
+var 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
+  }
+};
+function getModeConfig(mode, overrides) {
+  const preset = MODE_PRESETS[mode];
+  {
+    return preset;
+  }
+}
+
+// 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"
+}`;
+}
+var 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 };
+  }
+};
+function createTranslationAgent(options) {
+  return new TranslationAgent(options);
+}
+async function parseMarkdown(content) {
+  const processor = unified().use(remarkParse).use(remarkGfm);
+  const ast = processor.parse(content);
+  const textNodes = extractTextNodes(ast);
+  return {
+    original: content,
+    ast,
+    textNodes
+  };
+}
+async function applyTranslations(document, translations) {
+  const ast = structuredClone(document.ast);
+  for (const textNode of document.textNodes) {
+    if (!textNode.translatable) continue;
+    const translation = translations[textNode.id];
+    if (!translation) continue;
+    const node = getNodeAtPath(ast, textNode.path);
+    if (node && "value" in node) {
+      node.value = translation;
+    }
+  }
+  const processor = unified().use(remarkGfm).use(remarkStringify, {
+    bullet: "-",
+    emphasis: "*",
+    strong: "*",
+    fence: "`",
+    fences: true,
+    listItemIndent: "one"
+  });
+  const result = processor.stringify(ast);
+  return String(result);
+}
+function extractTextNodes(ast) {
+  const textNodes = [];
+  let nodeId = 0;
+  visit(ast, (node, index, parent) => {
+    if (node.type === "code" || node.type === "inlineCode") {
+      textNodes.push({
+        id: `node-${nodeId++}`,
+        content: node.value,
+        type: node.type,
+        position: node.position,
+        path: getNodePath(ast, node, index, parent),
+        translatable: false
+      });
+      return;
+    }
+    if (node.type === "text") {
+      const textContent = node.value;
+      if (!textContent.trim()) return;
+      textNodes.push({
+        id: `node-${nodeId++}`,
+        content: textContent,
+        type: node.type,
+        position: node.position,
+        path: getNodePath(ast, node, index, parent),
+        translatable: true
+      });
+    }
+  });
+  return textNodes;
+}
+function getNodePath(_root, _node, index, parent) {
+  const path = [];
+  let currentParent = parent;
+  let currentIndex = index;
+  while (currentParent && currentIndex !== void 0) {
+    path.unshift(currentIndex);
+    break;
+  }
+  if (index !== void 0) {
+    path.push(index);
+  }
+  return path;
+}
+function getNodeAtPath(ast, path) {
+  let current = ast;
+  for (const index of path) {
+    if ("children" in current && Array.isArray(current.children)) {
+      const child = current.children[index];
+      if (!child) return null;
+      current = child;
+    } else {
+      return null;
+    }
+  }
+  return current;
+}
+function getTranslatableText(document) {
+  return document.textNodes.filter((node) => node.translatable).map((node) => node.content);
+}
+function createTranslationMap(document, translations) {
+  const translatableNodes = document.textNodes.filter((node) => node.translatable);
+  const map = {};
+  for (let i = 0; i < translatableNodes.length && i < translations.length; i++) {
+    const node = translatableNodes[i];
+    if (node) {
+      map[node.id] = translations[i] ?? node.content;
+    }
+  }
+  return map;
+}
+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;
+}
+async function translateMarkdownContent(content, translateFn) {
+  const { text, preservedSections } = extractTextForTranslation(content);
+  const translatedText = await translateFn(text);
+  return restorePreservedSections(translatedText, preservedSections);
+}
+
+// src/core/engine.ts
+var 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";
+  }
+};
+function createTranslationEngine(options) {
+  return new TranslationEngine(options);
+}
+async function translateText(content, sourceLang, targetLang, options) {
+  const defaultConfig2 = {
+    version: "1.0",
+    languages: { source: sourceLang, targets: [targetLang] },
+    provider: { default: "claude" },
+    quality: {
+      threshold: options?.qualityThreshold ?? 85,
+      maxIterations: options?.maxIterations ?? 4,
+      evaluationMethod: "llm"
+    },
+    chunking: {
+      maxTokens: 1024,
+      overlapTokens: 150,
+      preserveStructure: true
+    },
+    paths: { output: "./" }
+  };
+  const engine = createTranslationEngine({
+    config: defaultConfig2,
+    provider: options?.provider,
+    verbose: options?.verbose
+  });
+  const result = await engine.translateContent({
+    content,
+    sourceLang,
+    targetLang,
+    glossaryPath: options?.glossaryPath,
+    qualityThreshold: options?.qualityThreshold,
+    maxIterations: options?.maxIterations
+  });
+  return result.content;
+}
+var DEFAULT_LABELS = {
+  en: "English",
+  ko: "\uD55C\uAD6D\uC5B4",
+  ja: "\u65E5\u672C\u8A9E",
+  zh: "\u4E2D\u6587",
+  es: "Espa\xF1ol",
+  fr: "Fran\xE7ais",
+  de: "Deutsch",
+  pt: "Portugu\xEAs",
+  ru: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+  it: "Italiano"
+};
+var DEFAULT_LANG_CODES = {
+  en: "en-US",
+  ko: "ko-KR",
+  ja: "ja-JP",
+  zh: "zh-CN",
+  es: "es-ES",
+  fr: "fr-FR",
+  de: "de-DE",
+  pt: "pt-BR",
+  ru: "ru-RU",
+  it: "it-IT"
+};
+var DEFAULT_TRANSLATIONS = {
+  ko: {
+    editLinkText: "GitHub\uC5D0\uC11C \uC774 \uD398\uC774\uC9C0 \uD3B8\uC9D1\uD558\uAE30",
+    docFooter: { prev: "\uC774\uC804 \uD398\uC774\uC9C0", next: "\uB2E4\uC74C \uD398\uC774\uC9C0" },
+    outline: { label: "\uBAA9\uCC28" },
+    lastUpdated: { text: "\uCD5C\uC885 \uC5C5\uB370\uC774\uD2B8" },
+    returnToTopLabel: "\uB9E8 \uC704\uB85C",
+    sidebarMenuLabel: "\uBA54\uB274",
+    darkModeSwitchLabel: "\uB2E4\uD06C \uBAA8\uB4DC"
+  },
+  ja: {
+    editLinkText: "GitHub\u3067\u3053\u306E\u30DA\u30FC\u30B8\u3092\u7DE8\u96C6\u3059\u308B",
+    docFooter: { prev: "\u524D\u306E\u30DA\u30FC\u30B8", next: "\u6B21\u306E\u30DA\u30FC\u30B8" },
+    outline: { label: "\u76EE\u6B21" },
+    lastUpdated: { text: "\u6700\u7D42\u66F4\u65B0" },
+    returnToTopLabel: "\u30C8\u30C3\u30D7\u3078\u623B\u308B",
+    sidebarMenuLabel: "\u30E1\u30CB\u30E5\u30FC",
+    darkModeSwitchLabel: "\u30C0\u30FC\u30AF\u30E2\u30FC\u30C9"
+  },
+  zh: {
+    editLinkText: "\u5728 GitHub \u4E0A\u7F16\u8F91\u6B64\u9875",
+    docFooter: { prev: "\u4E0A\u4E00\u9875", next: "\u4E0B\u4E00\u9875" },
+    outline: { label: "\u76EE\u5F55" },
+    lastUpdated: { text: "\u6700\u540E\u66F4\u65B0" },
+    returnToTopLabel: "\u8FD4\u56DE\u9876\u90E8",
+    sidebarMenuLabel: "\u83DC\u5355",
+    darkModeSwitchLabel: "\u6DF1\u8272\u6A21\u5F0F"
+  }
+};
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function getSubdirectories(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((entry) => isDirectory(join(dir, entry))).filter((entry) => !entry.startsWith(".") && !entry.startsWith("_"));
+}
+function getTitleFromFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const frontmatterMatch = content.match(/^---\s*\n[\s\S]*?title:\s*['"]?([^'"\n]+)['"]?\s*\n[\s\S]*?---/);
+    if (frontmatterMatch?.[1]) {
+      return frontmatterMatch[1].trim();
+    }
+    const headingMatch = content.match(/^#\s+(.+)$/m);
+    if (headingMatch?.[1]) {
+      return headingMatch[1].trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function fileNameToTitle(fileName) {
+  return fileName.replace(/\.md$/, "").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function generateSidebarItems(dir, options) {
+  const { basePath, localePrefix, useTitleFromHeading } = options;
+  const items = [];
+  if (!existsSync(dir)) return items;
+  const entries = readdirSync(dir).sort((a, b) => {
+    if (a === "index.md") return -1;
+    if (b === "index.md") return 1;
+    return a.localeCompare(b);
+  });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const relativePath = relative(basePath, fullPath);
+    if (isDirectory(fullPath)) {
+      const subItems = generateSidebarItems(fullPath, options);
+      if (subItems.length > 0) {
+        const indexFile = join(fullPath, "index.md");
+        const title = existsSync(indexFile) && useTitleFromHeading ? getTitleFromFile(indexFile) || fileNameToTitle(entry) : fileNameToTitle(entry);
+        items.push({
+          text: title,
+          items: subItems
+        });
+      }
+    } else if (entry.endsWith(".md")) {
+      const title = useTitleFromHeading ? getTitleFromFile(fullPath) || fileNameToTitle(entry) : fileNameToTitle(entry);
+      const link = `${localePrefix}/${relativePath.replace(/\.md$/, "").replace(/\/index$/, "/")}`;
+      items.push({
+        text: title,
+        link
+      });
+    }
+  }
+  return items;
+}
+function generateSidebar(docsDir, sidebarDirs, localePrefix, useTitleFromHeading) {
+  const sidebar = {};
+  for (const dir of sidebarDirs) {
+    const fullDir = join(docsDir, dir);
+    if (!existsSync(fullDir)) continue;
+    const items = generateSidebarItems(fullDir, {
+      basePath: docsDir,
+      localePrefix,
+      useTitleFromHeading
+    });
+    if (items.length > 0) {
+      const sidebarPath = `${localePrefix}/${dir}/`;
+      sidebar[sidebarPath] = [
+        {
+          text: fileNameToTitle(dir),
+          items
+        }
+      ];
+    }
+  }
+  return sidebar;
+}
+function generateNav(docsDir, sidebarDirs, localePrefix, useTitleFromHeading) {
+  const nav = [];
+  for (const dir of sidebarDirs) {
+    const fullDir = join(docsDir, dir);
+    if (!existsSync(fullDir)) continue;
+    const indexFile = join(fullDir, "index.md");
+    const title = existsSync(indexFile) && useTitleFromHeading ? getTitleFromFile(indexFile) || fileNameToTitle(dir) : fileNameToTitle(dir);
+    nav.push({
+      text: title,
+      link: `${localePrefix}/${dir}/`,
+      activeMatch: `${localePrefix}/${dir}/`
+    });
+  }
+  return nav;
+}
+function detectLocales(docsDir, defaultLocale = "en") {
+  const subdirs = getSubdirectories(docsDir);
+  const localeDirs = subdirs.filter(
+    (dir) => /^[a-z]{2}(-[A-Z]{2})?$/.test(dir) && dir !== defaultLocale
+  );
+  return localeDirs;
+}
+function detectSidebarDirs(docsDir) {
+  const subdirs = getSubdirectories(docsDir);
+  const excludePatterns = [
+    /^[a-z]{2}(-[A-Z]{2})?$/,
+    // locale dirs
+    /^public$/,
+    /^\.vitepress$/,
+    /^assets?$/,
+    /^images?$/
+  ];
+  return subdirs.filter((dir) => !excludePatterns.some((pattern) => pattern.test(dir)));
+}
+function generateLocale(docsDir, locale, options = {}) {
+  const {
+    defaultLocale = "en",
+    labels = DEFAULT_LABELS,
+    langCodes = DEFAULT_LANG_CODES,
+    descriptions = {},
+    sidebarDirs = detectSidebarDirs(docsDir),
+    useTitleFromHeading = true,
+    translations = DEFAULT_TRANSLATIONS
+  } = options;
+  const isDefault = locale === defaultLocale;
+  const localeDir = isDefault ? docsDir : join(docsDir, locale);
+  const localePrefix = isDefault ? "" : `/${locale}`;
+  const nav = generateNav(localeDir, sidebarDirs, localePrefix, useTitleFromHeading);
+  const sidebar = generateSidebar(localeDir, sidebarDirs, localePrefix, useTitleFromHeading);
+  const localeTranslations = translations[locale] || {};
+  const config2 = {
+    label: labels[locale] || locale,
+    lang: langCodes[locale] || locale,
+    description: descriptions[locale],
+    themeConfig: {
+      nav,
+      sidebar
+    }
+  };
+  if (!isDefault && localeTranslations && config2.themeConfig) {
+    if (localeTranslations.docFooter) {
+      config2.themeConfig.docFooter = localeTranslations.docFooter;
+    }
+    if (localeTranslations.outline) {
+      config2.themeConfig.outline = localeTranslations.outline;
+    }
+    if (localeTranslations.lastUpdated) {
+      config2.themeConfig.lastUpdated = localeTranslations.lastUpdated;
+    }
+    if (localeTranslations.returnToTopLabel) {
+      config2.themeConfig.returnToTopLabel = localeTranslations.returnToTopLabel;
+    }
+    if (localeTranslations.sidebarMenuLabel) {
+      config2.themeConfig.sidebarMenuLabel = localeTranslations.sidebarMenuLabel;
+    }
+    if (localeTranslations.darkModeSwitchLabel) {
+      config2.themeConfig.darkModeSwitchLabel = localeTranslations.darkModeSwitchLabel;
+    }
+  }
+  return config2;
+}
+function generateLocaleConfig(docsDir, options = {}) {
+  const { defaultLocale = "en", locales = detectLocales(docsDir, defaultLocale) } = options;
+  const config2 = {};
+  config2.root = generateLocale(docsDir, defaultLocale, options);
+  for (const locale of locales) {
+    config2[locale] = generateLocale(docsDir, locale, options);
+  }
+  return config2;
+}
+function generateSidebarConfig(docsDir, options = {}) {
+  const {
+    defaultLocale = "en",
+    locales = detectLocales(docsDir, defaultLocale),
+    sidebarDirs = detectSidebarDirs(docsDir),
+    useTitleFromHeading = true
+  } = options;
+  const config2 = {};
+  config2.root = generateSidebar(docsDir, sidebarDirs, "", useTitleFromHeading);
+  for (const locale of locales) {
+    const localeDir = join(docsDir, locale);
+    config2[locale] = generateSidebar(localeDir, sidebarDirs, `/${locale}`, useTitleFromHeading);
+  }
+  return config2;
+}
+
+export { CacheManager, ClaudeProvider, CompositePolicy, ErrorCode, ExitCode, GlossaryChangePolicy, ProviderChangePolicy, QualityThresholdPolicy, TTLPolicy, TranslationAgent, TranslationEngine, TranslationError, applyTranslations, checkGlossaryCompliance, chunkContent, configureLogger, createCacheManager, createClaudeProvider, createDefaultPolicies, createGlossaryLookup, createMinimalPolicies, createNullCacheManager, createProviderWithFallback, createStrictPolicies, createTimer, createTranslationAgent, createTranslationEngine, createTranslationMap, detectLocales, detectSidebarDirs, estimateTokens, exceedsTokenLimit, extractTextForTranslation, generateCacheKey, generateLocale, generateLocaleConfig, generateSidebarConfig, getAvailableProviders, getChunkStats, getExitCode, getProvider, getProviderConfigFromEnv, getTranslatableText, hasProvider, hashContent, isErrorCode, isTranslationError, loadConfig, loadGlossary, logger, mergeConfig, parseMarkdown, reassembleChunks, registerProvider, resolveGlossary, restorePreservedSections, translateMarkdownContent, translateText, truncateToTokenLimit };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map