docs-i18n 0.1.0

package/dist/chunk-XEOYZUHS.js

@@ -0,0 +1,396 @@
+// src/core/cache.ts
+import fs from "fs";
+import path from "path";
+
+// src/core/sqlite.ts
+import { createRequire } from "module";
+var isBun = typeof globalThis.Bun !== "undefined";
+function openDatabase(filepath) {
+  if (isBun) {
+    const req2 = createRequire(import.meta.url);
+    const mod = req2("bun:sqlite");
+    const Database2 = mod.Database ?? mod.default ?? mod;
+    const raw = new Database2(filepath);
+    return {
+      prepare: (sql) => {
+        const stmt = raw.query(sql);
+        return {
+          run: (...params) => stmt.run(...params),
+          get: (...params) => stmt.get(...params),
+          all: (...params) => stmt.all(...params)
+        };
+      },
+      exec: (sql) => raw.run(sql),
+      pragma: (p) => raw.run(`PRAGMA ${p}`),
+      transaction: (fn) => raw.transaction(fn),
+      close: () => raw.close()
+    };
+  }
+  const req = createRequire(import.meta.url);
+  const Database = req("better-sqlite3");
+  return new Database(filepath);
+}
+
+// src/core/cache.ts
+var TranslationCache = class {
+  db;
+  cacheDir;
+  // Prepared statements (lazily initialized)
+  _stmts;
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const dbPath = path.join(cacheDir, "translations.db");
+    this.db = openDatabase(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sources (
+        key   TEXT PRIMARY KEY NOT NULL,
+        text  TEXT NOT NULL,
+        type  TEXT NOT NULL DEFAULT 'paragraph'
+      ) WITHOUT ROWID;
+
+      CREATE TABLE IF NOT EXISTS source_files (
+        key     TEXT    NOT NULL,
+        file    TEXT    NOT NULL,
+        line    INTEGER NOT NULL,
+        version TEXT    NOT NULL DEFAULT 'latest',
+        PRIMARY KEY (version, key, file, line)
+      ) WITHOUT ROWID;
+
+      CREATE TABLE IF NOT EXISTS translations (
+        lang       TEXT    NOT NULL,
+        key        TEXT    NOT NULL,
+        value      TEXT    NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        PRIMARY KEY (lang, key)
+      ) WITHOUT ROWID;
+
+      CREATE INDEX IF NOT EXISTS idx_translations_lang ON translations(lang);
+      CREATE INDEX IF NOT EXISTS idx_source_files_version ON source_files(version);
+      CREATE INDEX IF NOT EXISTS idx_source_files_file ON source_files(version, file);
+    `);
+  }
+  get stmts() {
+    if (!this._stmts) {
+      this._stmts = {
+        getTranslation: this.db.prepare(
+          "SELECT value FROM translations WHERE lang = ? AND key = ?"
+        ),
+        setTranslation: this.db.prepare(`
+          INSERT INTO translations (lang, key, value)
+          VALUES (?, ?, ?)
+          ON CONFLICT(lang, key) DO UPDATE SET value = excluded.value, updated_at = unixepoch()
+        `),
+        deleteTranslation: this.db.prepare(
+          "DELETE FROM translations WHERE lang = ? AND key = ?"
+        ),
+        countByLang: this.db.prepare(
+          "SELECT COUNT(*) as count FROM translations WHERE lang = ?"
+        ),
+        allByLang: this.db.prepare(
+          "SELECT key, value FROM translations WHERE lang = ?"
+        ),
+        keysByLang: this.db.prepare(
+          "SELECT key FROM translations WHERE lang = ?"
+        ),
+        setSource: this.db.prepare(`
+          INSERT INTO sources (key, text, type) VALUES (?, ?, ?)
+          ON CONFLICT(key) DO UPDATE SET text = excluded.text, type = excluded.type
+        `),
+        getSource: this.db.prepare(
+          "SELECT text, type FROM sources WHERE key = ?"
+        ),
+        clearSourceFiles: this.db.prepare(
+          "DELETE FROM source_files WHERE version = ?"
+        ),
+        upsertSourceFile: this.db.prepare(`
+          INSERT OR IGNORE INTO source_files (key, file, line, version) VALUES (?, ?, ?, ?)
+        `),
+        deleteSourceFilesByLang: this.db.prepare(
+          "DELETE FROM source_files WHERE version = ?"
+        )
+      };
+    }
+    return this._stmts;
+  }
+  // ── Public API (backward-compatible with JSONL version) ──
+  /**
+   * Load cache for a language. No-op for SQLite (data is always available).
+   * Kept for API compatibility.
+   */
+  load(_lang) {
+  }
+  /**
+   * Save cache for a language. No-op for SQLite (writes are immediate).
+   * Kept for API compatibility.
+   */
+  save(_lang) {
+  }
+  /** Get a cached translation */
+  get(lang, md5) {
+    const row = this.stmts.getTranslation.get(lang, md5);
+    return row?.value;
+  }
+  /** Set a cached translation (writes immediately to disk) */
+  set(lang, md5, translation) {
+    this.stmts.setTranslation.run(lang, md5, translation);
+  }
+  /**
+   * Set a cached translation with its EN source text.
+   * This also stores the source in the `sources` table for dashboard use.
+   */
+  setWithSource(lang, md5, translation, sourceText, sourceType = "paragraph") {
+    this.db.transaction(() => {
+      this.stmts.setSource.run(md5, sourceText, sourceType);
+      this.stmts.setTranslation.run(lang, md5, translation);
+    })();
+  }
+  /** Delete a cached translation */
+  delete(lang, md5) {
+    const result = this.stmts.deleteTranslation.run(lang, md5);
+    return result.changes > 0;
+  }
+  /** Iterate all entries for a language */
+  *entries(lang) {
+    const rows = this.stmts.allByLang.all(lang);
+    for (const row of rows) {
+      yield [row.key, { v: row.value, src: [] }];
+    }
+  }
+  /** Get all cached keys for a language as a Set (fast for coverage checks) */
+  keys(lang) {
+    const rows = this.stmts.keysByLang.all(lang);
+    return new Set(rows.map((r) => r.key));
+  }
+  /** Remove entries not in the provided set of md5s */
+  prune(lang, usedMd5s) {
+    const allKeys = this.keys(lang);
+    let removed = 0;
+    const deleteStmt = this.stmts.deleteTranslation;
+    this.db.transaction(() => {
+      for (const md5 of allKeys) {
+        if (!usedMd5s.has(md5)) {
+          deleteStmt.run(lang, md5);
+          removed++;
+        }
+      }
+    })();
+    return removed;
+  }
+  /** Get cache stats for a language */
+  stats(lang) {
+    const row = this.stmts.countByLang.get(lang);
+    return { size: row?.count ?? 0 };
+  }
+  // ── Source tracking ──
+  /**
+   * Update source locations for a md5 hash.
+   * In SQLite mode, this inserts into source_files table.
+   */
+  updateSource(_lang, md5, filePath, line, version = "latest") {
+    this.stmts.upsertSourceFile.run(md5, filePath, line, version);
+  }
+  /** Clear all source file mappings for a version (call before a full rebuild) */
+  clearSources(_lang, version = "latest") {
+    this.stmts.clearSourceFiles.run(version);
+  }
+  /** Store an EN source text in the sources table */
+  setSource(md5, text, type = "paragraph") {
+    this.stmts.setSource.run(md5, text, type);
+  }
+  /** Get an EN source text from the sources table */
+  getSource(md5) {
+    const row = this.stmts.getSource.get(md5);
+    return row ?? void 0;
+  }
+  /**
+   * Get all untranslated source keys for a language and version.
+   * Returns keys with their EN source text and type.
+   */
+  untranslatedKeys(lang, version = "latest", limit = 0, files) {
+    let fileFilter = "";
+    const params = [lang, version];
+    if (files && files.length > 0) {
+      fileFilter = ` AND sf.file IN (${files.map(() => "?").join(",")})`;
+      params.push(...files);
+    }
+    const sql = `
+      SELECT DISTINCT s.key, s.text, s.type
+      FROM source_files sf
+      JOIN sources s ON s.key = sf.key
+      LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+      WHERE sf.version = ? AND t.key IS NULL${fileFilter}
+      ${limit > 0 ? `LIMIT ${limit}` : ""}
+    `;
+    return this.db.prepare(sql).all(...params);
+  }
+  // ── Dashboard queries ──
+  /** Get translation stats for all languages */
+  allLangStats() {
+    return this.db.prepare("SELECT lang, COUNT(*) as count FROM translations GROUP BY lang").all();
+  }
+  /**
+   * Get file-level coverage for a version and language.
+   * Returns how many source nodes each file has and how many are translated.
+   */
+  fileCoverage(version, lang) {
+    return this.db.prepare(
+      `
+      SELECT
+        sf.file,
+        COUNT(DISTINCT sf.key) as total,
+        COUNT(DISTINCT t.key) as translated
+      FROM source_files sf
+      LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+      WHERE sf.version = ?
+      GROUP BY sf.file
+      ORDER BY sf.file
+    `
+    ).all(lang, version);
+  }
+  /**
+   * Get node-level detail for a specific file: EN source + translation side by side.
+   */
+  fileDetail(version, lang, file) {
+    return this.db.prepare(
+      `
+      SELECT
+        s.key,
+        s.text as source,
+        s.type,
+        t.value as translation,
+        sf.line
+      FROM source_files sf
+      JOIN sources s ON s.key = sf.key
+      LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+      WHERE sf.version = ? AND sf.file = ?
+      ORDER BY sf.line
+    `
+    ).all(lang, version, file);
+  }
+  /** Get total source node count for a version */
+  sourceCount(version) {
+    const row = this.db.prepare(
+      "SELECT COUNT(DISTINCT key) as count FROM source_files WHERE version = ?"
+    ).get(version);
+    return row?.count ?? 0;
+  }
+  /**
+   * Get section-level stats for a version and language.
+   * Section is derived from file path prefix (docs/, blog/, learn/).
+   */
+  sectionStats(version, lang) {
+    return this.db.prepare(
+      `
+      WITH file_coverage AS (
+        SELECT
+          sf.file,
+          CASE
+            WHEN sf.file LIKE 'docs/%' THEN 'docs'
+            WHEN sf.file LIKE 'blog/%' THEN 'blog'
+            WHEN sf.file LIKE 'learn/%' THEN 'learn'
+            ELSE 'other'
+          END as section,
+          COUNT(DISTINCT sf.key) as total_nodes,
+          COUNT(DISTINCT t.key) as translated_nodes
+        FROM source_files sf
+        LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+        WHERE sf.version = ?
+        GROUP BY sf.file
+      )
+      SELECT
+        section,
+        COUNT(*) as totalFiles,
+        SUM(CASE WHEN translated_nodes = total_nodes THEN 1 ELSE 0 END) as translatedFiles,
+        SUM(total_nodes) as totalNodes,
+        SUM(translated_nodes) as translatedNodes
+      FROM file_coverage
+      GROUP BY section
+      ORDER BY section
+    `
+    ).all(lang, version);
+  }
+  // ── Export / Import ──
+  /** Export cache to JSONL format (for backward compatibility / git tracking) */
+  exportJsonl(lang, outputPath) {
+    const rows = this.db.prepare(
+      "SELECT key, value FROM translations WHERE lang = ? ORDER BY key"
+    ).all(lang);
+    const lines = [];
+    for (const row of rows) {
+      const srcs = this.db.prepare(
+        "SELECT file || ':' || line as loc FROM source_files WHERE key = ? ORDER BY file, line"
+      ).all(row.key);
+      const entry = { k: row.key, v: row.value };
+      if (srcs.length > 0) {
+        entry.src = srcs.map((s) => s.loc);
+      }
+      lines.push(JSON.stringify(entry));
+    }
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, `${lines.join("\n")}
+`, "utf8");
+    return rows.length;
+  }
+  /** Import translations from a JSONL file */
+  importJsonl(lang, inputPath) {
+    if (!fs.existsSync(inputPath)) return 0;
+    const lines = fs.readFileSync(inputPath, "utf8").split("\n");
+    let count = 0;
+    this.db.transaction(() => {
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const entry = JSON.parse(trimmed);
+        this.stmts.setTranslation.run(lang, entry.k, entry.v);
+        count++;
+      }
+    })();
+    return count;
+  }
+  /** Export a readable markdown index for IDE navigation */
+  exportIndex(lang) {
+    const indexPath = path.join(this.cacheDir, `${lang}.index.md`);
+    const rows = this.db.prepare(
+      `
+      SELECT t.key, t.value,
+             GROUP_CONCAT(sf.file || ':' || sf.line, char(10)) as sources
+      FROM translations t
+      LEFT JOIN source_files sf ON sf.key = t.key
+      WHERE t.lang = ?
+      GROUP BY t.key
+      HAVING sources IS NOT NULL
+      ORDER BY t.key
+    `
+    ).all(lang);
+    const lines = [`# Translation Index (${lang})`, ""];
+    for (const row of rows) {
+      if (!row.sources) continue;
+      const preview = row.value.split("\n")[0].substring(0, 80);
+      lines.push(`## \`${row.key}\` ${preview}`);
+      lines.push("");
+      for (const src of row.sources.split("\n")) {
+        const [filePath] = src.split(":");
+        lines.push(
+          `- [${src}](../content/en/${filePath}#L${src.split(":")[1]})`
+        );
+      }
+      lines.push("");
+    }
+    fs.writeFileSync(indexPath, lines.join("\n"), "utf8");
+  }
+  /** Close the database connection */
+  close() {
+    this._stmts = void 0;
+    this.db.close();
+  }
+};
+
+export {
+  TranslationCache
+};

package/dist/cli.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import {
+  loadConfig
+} from "./chunk-3YNFMSJH.js";
+import "./chunk-AKLW2MUS.js";
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function getOpt(name, def = "") {
+  const idx = args.indexOf(`--${name}`);
+  return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : def;
+}
+function hasFlag(name) {
+  return args.includes(`--${name}`);
+}
+async function main() {
+  if (!command || command === "--help" || command === "-h") {
+    console.log(`
+docs-i18n \u2014 Universal documentation translation engine
+
+Commands:
+  translate    Translate content to target language(s)
+  assemble     Assemble translated files from EN + cache
+  rescan       Rescan source files and clean orphans
+  status       Show translation coverage
+  admin        Start admin dashboard
+
+Options:
+  --lang <code>         Target language (e.g., zh-hans)
+  --project <id>        Filter by project
+  --version <ver>       Filter by version
+  --config <path>       Config file (default: docs-i18n.config.ts)
+  --max <n>             Max API calls
+  --concurrency <n>     Parallel API calls (default: 3)
+  --model <model>       Override LLM model
+  --max-tokens <n>      Max output tokens (default: 16384)
+  --context-length <n>  Model context window (default: 32768)
+  --dry-run             Preview without making changes
+  --port <n>            Admin dashboard port (default: 3456)
+`);
+    return;
+  }
+  const configPath = getOpt("config") || void 0;
+  const config = await loadConfig(configPath);
+  switch (command) {
+    case "translate": {
+      const lang = getOpt("lang");
+      if (!lang) {
+        console.error("Error: --lang is required");
+        process.exit(1);
+      }
+      const { translate } = await import("./translate-F3AQFN6X.js");
+      await translate(config, {
+        lang,
+        project: getOpt("project") || void 0,
+        version: getOpt("version") || void 0,
+        files: getOpt("files") ? getOpt("files").split(",") : void 0,
+        max: getOpt("max") ? Number(getOpt("max")) : void 0,
+        concurrency: getOpt("concurrency") ? Number(getOpt("concurrency")) : void 0,
+        dryRun: hasFlag("dry-run"),
+        model: getOpt("model") || void 0,
+        maxTokens: getOpt("max-tokens") ? Number(getOpt("max-tokens")) : void 0,
+        contextLength: getOpt("context-length") ? Number(getOpt("context-length")) : void 0
+      });
+      break;
+    }
+    case "assemble": {
+      const { assembleAll } = await import("./assemble-IOHQYYHI.js");
+      await assembleAll(config, {
+        project: getOpt("project") || void 0,
+        version: getOpt("version") || void 0,
+        lang: getOpt("lang") || void 0
+      });
+      break;
+    }
+    case "rescan": {
+      const { rescan } = await import("./rescan-VB2PILB2.js");
+      await rescan(config, {
+        project: getOpt("project") || void 0,
+        version: getOpt("version") || void 0
+      });
+      break;
+    }
+    case "status": {
+      const { status } = await import("./status-EWQEACVF.js");
+      await status(config, { lang: getOpt("lang") || void 0 });
+      break;
+    }
+    case "admin": {
+      const port = Number(getOpt("port", "3456"));
+      const { startAdmin } = await import("./server-ER56DGPR.js");
+      await startAdmin(config, port);
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("\u274C", err.message ?? err);
+  process.exit(1);
+});

package/dist/dist-6C32URTL.js

@@ -0,0 +1,19 @@
+import {
+  RUNTIME_MODULE_ID,
+  RolldownMagicString,
+  VERSION,
+  build,
+  defineConfig,
+  rolldown,
+  watch
+} from "./chunk-VKKNQBDN.js";
+import "./chunk-AKLW2MUS.js";
+export {
+  RUNTIME_MODULE_ID,
+  RolldownMagicString,
+  VERSION,
+  build,
+  defineConfig,
+  rolldown,
+  watch
+};