cline-kit 0.1.0

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "cline-kit",
+  "version": "0.1.0",
+  "description": "Desktop enhancement kit for the Cline desktop app (Windows): keeps every registered project visible in the sidebar, and adds optional UI locale packs (zh-CN, zh-TW, ja, ko, vi). Runtime overlay - no binary patching.",
+  "keywords": [
+    "cline",
+    "desktop-app",
+    "sidebar",
+    "workspace",
+    "project-groups",
+    "i18n",
+    "l10n",
+    "locale",
+    "zh-CN",
+    "zh-TW",
+    "ja",
+    "ko",
+    "vi",
+    "webview2",
+    "overlay"
+  ],
+  "license": "MIT",
+  "author": "chentaoxing",
+  "notices": "See NOTICE: unofficial project; locale dictionary keys are Cline desktop UI strings (upstream cline/cline is Apache-2.0); translated values are original.",
+  "bin": {
+    "cline-kit": "src/cli.js",
+    "ckit": "src/cli.js"
+  },
+  "main": "src/cli.js",
+  "files": [
+    "src/",
+    "ckit.cmd",
+    "dictionaries/",
+    "README.md",
+    "README.zh-CN.md",
+    "SECURITY.md",
+    "NOTICE",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "scripts": {
+    "test": "node scripts/selftest.js",
+    "start": "node src/cli.js start",
+    "status": "node src/cli.js status",
+    "install-ui": "node src/cli.js install",
+    "uninstall-ui": "node src/cli.js uninstall",
+    "audit": "node src/cli.js audit",
+    "dict:update": "node src/cli.js update --force"
+  },
+  "dependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chentaoxing/Cline-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/chentaoxing/Cline-kit/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/audit.js

@@ -0,0 +1,127 @@
+"use strict";
+// Walk the Cline UI over CDP and list strings still left in English.
+// Useful after a Cline update, to find dictionary gaps. Output: <configDir>/audit-report.json
+const fs = require("fs");
+const path = require("path");
+const cfg = require("./config");
+const cdp = require("./cdp");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const COLLECT = `(() => {
+  const en = (s) => /[A-Za-z]{3}/.test(s) && !/[\\u4e00-\\u9fa5]/.test(s);
+  // A node counts as visible only if it is inside the viewport AND is the top-most element
+  // at its own centre point. This skips panels React keeps mounted but has hidden.
+  const onScreen = (el) => {
+    const r = el.getBoundingClientRect();
+    if (r.width < 1 || r.height < 1) return false;
+    if (r.bottom < 0 || r.top > innerHeight || r.right < 0 || r.left > innerWidth) return false;
+    const cs = getComputedStyle(el);
+    if (cs.visibility === 'hidden' || cs.display === 'none' || Number(cs.opacity) === 0) return false;
+    const x = Math.min(r.left + r.width / 2, innerWidth - 1);
+    const y = Math.min(r.top + r.height / 2, innerHeight - 1);
+    const hit = document.elementFromPoint(x, y);
+    if (!hit) return false;
+    return hit === el || el.contains(hit) || hit.contains(el);
+  };
+  const out = { text: [], attr: [] };
+  const seen = new Set();
+  const w = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+  let n;
+  while ((n = w.nextNode())) {
+    const t = (n.nodeValue || '').replace(/\\s+/g, ' ').trim();
+    if (!t || !en(t) || t.length > 220) continue;
+    const el = n.parentElement; if (!el) continue;
+    if (!onScreen(el)) continue;
+    if (!seen.has('T' + t)) { seen.add('T' + t); out.text.push(t); }
+  }
+  document.querySelectorAll('*').forEach((e) => {
+    for (const a of ['placeholder', 'aria-label', 'title']) {
+      const v = e.getAttribute(a);
+      if (!v || !en(v) || v.length > 220) continue;
+      if (!onScreen(e)) continue;
+      if (!seen.has('A' + a + v)) { seen.add('A' + a + v); out.attr.push(a + '::' + v); }
+    }
+  });
+  return JSON.stringify(out);
+})()`;
+
+function click(cands) {
+  return `(() => {
+    const want = ${JSON.stringify(cands)};
+    const els = [...document.querySelectorAll('button,[role=button],[role=tab],[role=combobox],a,summary,[role=menuitem]')];
+    for (const target of want) {
+      const hit = els.find((e) => {
+        const t = (e.textContent || '').replace(/\\s+/g, ' ').trim();
+        const al = e.getAttribute('aria-label') || '';
+        return t === target || al === target || t.startsWith(target + ' ') || al.startsWith(target);
+      });
+      if (hit) { hit.click(); return 'clicked:' + target; }
+    }
+    return 'MISS:' + want.join('|');
+  })()`;
+}
+
+const SCREENS = [
+  ["settings.general", ["Settings", "设置"], null],
+  ["settings.apiProviders", null, ["General", "通用"]],
+  ["settings.voice", null, ["API Providers", "API 服务商"]],
+  ["settings.import", null, ["Voice", "语音"]],
+  ["settings.remote", null, ["Import", "导入"]],
+  ["settings.account", null, ["Remote", "远程"]],
+  ["home", null, ["Account", "账户"]],
+  ["picker.workspace", ["Session", "会话"], null],
+  ["page.schedule", null, ["Schedule", "计划任务"]],
+  ["page.customize", null, ["Customize", "扩展定制"]],
+  ["home.final", null, ["Session", "会话"]]
+];
+
+async function run(port) {
+  const results = {};
+  const pages = await cdp.pageTargets(port);
+  if (!pages.length) throw new Error("no Cline page target on port " + port);
+  const ws = await cdp.open(pages[0].webSocketDebuggerUrl);
+  const api = cdp.client(ws);
+  await api.rpc("Runtime.enable");
+  const ev = async (expr) => {
+    const r = await api.rpc("Runtime.evaluate", { expression: expr, returnByValue: true });
+    return r && r.result ? r.result.value : null;
+  };
+
+  for (const [name, nav, sub] of SCREENS) {
+    if (nav) await ev(click(nav));
+    if (sub) await ev(click(sub));
+    await sleep(800);
+    const raw = await ev(COLLECT);
+    results[name] = raw ? JSON.parse(raw) : { text: [], attr: [] };
+  }
+  api.close();
+
+  cfg.ensureDirs();
+  const file = path.join(cfg.configDir(), "audit-report.json");
+  fs.writeFileSync(file, JSON.stringify(results, null, 1), "utf8");
+
+  // subtract what the dictionary already covers, so the output is only real gaps
+  const dict = require("./dict").load(cfg.read());
+  const covered = new Set(Object.keys(dict.entries));
+  const ruleRes = (dict.rules || []).map((r) => new RegExp(r.pattern));
+  const uniq = new Map();
+  for (const [screen, v] of Object.entries(results)) {
+    for (const item of [...(v.attr || []), ...(v.text || [])]) {
+      const bare = item.replace(/^(title|aria-label|placeholder)::/, "");
+      if (covered.has(bare) || ruleRes.some((re) => re.test(bare))) continue;
+      if (!uniq.has(bare)) uniq.set(bare, screen);
+    }
+  }
+  return { file, total: uniq.size, items: [...uniq.entries()] };
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  const port = Number(process.argv[2] || cfg.read().port);
+  run(port).then((r) => {
+    console.log("untranslated strings: " + r.total + "  (report: " + r.file + ")");
+    r.items.forEach(([s, where]) => console.log("  " + s + "   [" + where + "]"));
+  }).catch((e) => { console.error("audit failed: " + e.message); process.exit(1); });
+}

package/src/cdp.js

@@ -0,0 +1,85 @@
+"use strict";
+// Minimal Chrome DevTools Protocol client (Node >= 20.10: global fetch + WebSocket).
+const http = require("http");
+
+function listTargets(port) {
+  return new Promise((resolve, reject) => {
+    const req = http.get({ host: "127.0.0.1", port, path: "/json/list", timeout: 3000 }, (res) => {
+      let body = "";
+      res.on("data", (c) => { body += c; });
+      res.on("end", () => {
+        if (res.statusCode !== 200) return reject(new Error("CDP HTTP " + res.statusCode));
+        try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(new Error("CDP timeout")); });
+  });
+}
+
+function pageTargets(port) {
+  return listTargets(port).then((list) =>
+    list.filter((t) => t.type === "page" && t.webSocketDebuggerUrl));
+}
+
+function open(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const t = setTimeout(() => { try { ws.close(); } catch (e) { } reject(new Error("ws timeout")); }, 5000);
+    ws.onopen = () => { clearTimeout(t); resolve(ws); };
+    ws.onerror = () => { clearTimeout(t); reject(new Error("ws error")); };
+  });
+}
+
+function client(ws, timeoutMs) {
+  let id = 0;
+  const pending = new Map();
+  const limit = timeoutMs || 10000;
+  ws.onmessage = (ev) => {
+    let m;
+    try { m = JSON.parse(ev.data); } catch (e) { return; }
+    if (m.id && pending.has(m.id)) {
+      const p = pending.get(m.id);
+      pending.delete(m.id);
+      clearTimeout(p.timer);
+      m.error ? p.reject(new Error(m.error.message || JSON.stringify(m.error))) : p.resolve(m.result);
+    }
+  };
+  return {
+    rpc(method, params) {
+      return new Promise((resolve, reject) => {
+        const i = ++id;
+        // A wedged or navigating renderer queues commands forever; fail loudly instead of hanging
+        // the caller, so `ckit doctor` reports FAIL rather than sitting there silently.
+        const timer = setTimeout(() => {
+          if (pending.delete(i)) reject(new Error("CDP command timed out after " + limit + "ms: " + method +
+            " (is Cline mid-navigation or frozen?)"));
+        }, limit);
+        pending.set(i, { resolve, reject, timer });
+        ws.send(JSON.stringify({ id: i, method, params: params || {} }));
+      });
+    },
+    close() { try { ws.close(); } catch (e) { } }
+  };
+}
+
+// run fn(api) against every page target; returns per-target results
+async function eachPage(port, fn) {
+  const pages = await pageTargets(port);
+  const out = [];
+  for (const p of pages) {
+    let api;
+    try {
+      const ws = await open(p.webSocketDebuggerUrl);
+      api = client(ws);
+      out.push({ target: p, result: await fn(api, p) });
+    } catch (e) {
+      out.push({ target: p, error: e.message });
+    } finally {
+      if (api) api.close();
+    }
+  }
+  return out;
+}
+
+module.exports = { listTargets, pageTargets, open, client, eachPage };

package/src/cli.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+"use strict";
+// Cline-kit - desktop enhancement kit for the Cline desktop app.
+// Flagship feature: keep every registered project visible in the sidebar.
+// Optional: UI locale packs (zh-CN today; zh-TW / ja / ko / vi follow the same data format).
+const cfg = require("./config");
+
+function guard() {
+  if (typeof WebSocket !== "function") {
+    console.error("Cline-kit needs Node.js 20.10+ (global WebSocket). Current: " + process.version);
+    console.error("Install a newer Node from https://nodejs.org and retry.");
+    process.exit(1);
+  }
+}
+
+const HELP = `Cline-kit (ckit) - enhancement kit for the Cline desktop app (Windows)
+
+Usage: ckit <command> [options]
+
+  start            Launch Cline with the overlay loaded (--restart quits a running instance first)
+  stop             Stop the background injector (Cline itself is untouched)
+  status           Show the Cline path, debug port, injector and loaded payload version
+  doctor           Check the live window: does each feature exist in the DOM right now?
+  attach           Inject once into a Cline that is already running with a debug port
+  install          Point the Start Menu / Desktop Cline shortcuts at the enhanced launcher
+  uninstall        Restore the original shortcuts
+  features         List feature plugins and whether each is on
+  feature          Toggle a plugin: ckit feature enable|disable <id>
+  update           Fetch the latest locale dictionary from GitHub (skipped when offline)
+  audit            Walk the UI and list strings still without a translation
+  dict             Dictionary stats and the local override file path
+  config           View or set: --cline-path=... --port=... --auto-update=on|off
+                   --dictionary=<locale> --hide=<path> / --unhide=<path>
+
+Main feature
+  sidebar-groups   Keeps every registered project visible in the sidebar's "Projects" group.
+                   Cline natively lists only folders that already have sessions, so empty
+                   projects disappear entirely.
+
+Optional feature
+  locale packs     dictionaries/<locale>.json - whole-string replacement only, so provider names,
+                   model names and code cannot be mangled. Bundled: zh-CN (reference, 476 entries),
+                   zh-TW, ja, ko, vi. Choose one: ckit config --dictionary=ja  (ckit update then
+                   follows that locale). Only zh-CN is proofread against the running app.
+
+Examples:
+  ckit start
+  ckit install
+  ckit features
+  ckit feature disable sidebar-groups
+  ckit config --cline-path "D:\\Programs\\Cline\\cline-app.exe"
+`;
+
+function parseFlags(argv) {
+  const flags = {};
+  const rest = [];
+  for (const a of argv) {
+    const m = a.match(/^--([^=]+)(?:=(.*))?$/);
+    if (m) flags[m[1]] = m[2] === undefined ? true : m[2];
+    else rest.push(a);
+  }
+  return { flags, rest };
+}
+
+async function main() {
+  guard();
+  const argv = process.argv.slice(2);
+  const cmd = argv[0] || "help";
+  const { flags } = parseFlags(argv.slice(1));
+  const conf = cfg.read();
+
+  if (cmd === "start") {
+    const out = await require("./launcher").start({ restart: !!flags.restart });
+    if (out.needsRestart) {
+      console.log("Cline is already running without a debug port, so the overlay cannot attach.");
+      console.log("Run `ckit start --restart`, or quit Cline first and run ckit start again.");
+      process.exitCode = 1;
+      return;
+    }
+    console.log(out.debugPortAlive
+      ? `Cline is up (port ${out.port}, path from ${out.source}) and the overlay is loaded.`
+      : `Warning: Cline started but port ${out.port} is not answering; the overlay may not be loaded.`);
+    if (!out.debugPortAlive) process.exitCode = 1;
+    return;
+  }
+
+  if (cmd === "stop") {
+    const r = require("./launcher").stop();
+    console.log(r.stopped ? "Injector stopped (pid " + r.pids + ")" : "No injector was running");
+    return;
+  }
+
+  if (cmd === "status") {
+    const launcher = require("./launcher");
+    const payload = require("./payload");
+    const detect = require("./detect");
+    const found = detect.detect(conf);
+    const alive = conf.port ? await launcher.isPortAlive(conf.port) : false;
+    console.log(JSON.stringify({
+      clinePath: found.path, clinePathSource: found.source,
+      debugPort: conf.port || null, debugPortAlive: alive,
+      injector: launcher.injectorRunning() || null,
+      dictionary: payload.info(conf),
+      shortcut: conf.shortcutPath || null,
+      autoUpdate: conf.autoUpdate, updateUrl: conf.updateUrl
+    }, null, 2));
+    return;
+  }
+
+  if (cmd === "doctor") {
+    const doctor = require("./doctor");
+    const r = await doctor.run();
+    console.log(doctor.format(r));
+    process.exitCode = r.ok ? 0 : 1;
+    return;
+  }
+
+  if (cmd === "attach") {
+    const port = Number(flags.port) || conf.port;
+    if (!port) { console.error("No debug port to attach to. Pass --port=NNNNN"); process.exit(1); }
+    const src = require("./payload").build(conf);
+    const r = await require("./cdp").eachPage(port, async (api) => {
+      const res = await api.rpc("Runtime.evaluate", { expression: src });
+      if (res && res.exceptionDetails) throw new Error(res.exceptionDetails.text || "evaluate failed");
+      return "ok";
+    });
+    console.log("Injected once into " + r.length + " page(s): " +
+      r.map((x) => x.error ? "FAIL " + x.error : x.result).join(", "));
+    console.log("The resident injector is not running, so a reload (Ctrl+R) drops the overlay.");
+    return;
+  }
+
+  if (cmd === "install") {
+    const r = await require("./install-win").install(conf);
+    console.log("Shortcuts now launch Cline with the overlay:");
+    r.shortcuts.forEach((s) => console.log("  " + s));
+    console.log("Launcher: " + r.launcher);
+    console.log("Open Cline from those shortcuts from now on; `ckit uninstall` restores them.");
+    return;
+  }
+
+  if (cmd === "uninstall") {
+    require("./launcher").stop();
+    const r = await require("./install-win").uninstall(cfg.read());
+    console.log(r.restored.length ? "Restored:\n  " + r.restored.join("\n  ") : "No shortcuts needed restoring");
+    return;
+  }
+
+  if (cmd === "update") {
+    const r = await require("./dict").update(cfg.read(), { force: !!flags.force });
+    if (r.error) { console.error("Update failed (keeping the local dictionary): " + r.error); process.exitCode = 1; return; }
+    console.log(r.updated ? `Dictionary updated: v${r.from} -> v${r.to}` : "Already up to date" + (r.reason ? " (" + r.reason + ")" : ""));
+    return;
+  }
+
+  if (cmd === "audit") {
+    if (!conf.port) { console.error("Cline was not started through cline-kit; run ckit start first"); process.exit(1); }
+    const r = await require("./audit").run(conf.port);
+    console.log(`${r.total} untranslated strings, details: ${r.file}`);
+    r.items.slice(0, Number(flags.limit) || 80).forEach(([s, where]) => console.log("  " + s + "   [" + where + "]"));
+    if (r.total > (Number(flags.limit) || 80)) console.log("  ...");
+    return;
+  }
+
+  if (cmd === "features" || cmd === "feature") {
+    const features = require("./features");
+    const conf2 = cfg.read();
+    const sub = flags._ || null;
+    if (cmd === "features") {
+      const enabled = features.enabledSet(conf2);
+      for (const f of features.list()) {
+        console.log(`${enabled[f.id] ? "on " : "off"}  ${f.id}  (v${f.version})  ${f.title}`);
+      }
+      console.log("\nToggle with: ckit feature enable <id> | ckit feature disable <id>");
+      return;
+    }
+    const [action, id] = argv.slice(1).filter((a) => !a.startsWith("--"));
+    const known = features.list().map((f) => f.id);
+    if (!known.includes(id)) {
+      console.error(`Unknown feature: ${id || "(none)"}; available: ${known.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (action !== "enable" && action !== "disable") {
+      console.error("Usage: ckit feature <enable|disable> <id>");
+      process.exitCode = 1;
+      return;
+    }
+    conf2.features = Object.assign({}, conf2.features || {}, { [id]: action === "enable" });
+    cfg.write(conf2);
+    console.log(`${id} -> ${action === "enable" ? "enabled" : "disabled"} (the injector picks it up within ~4s)`);
+    return;
+  }
+
+  if (cmd === "dict") {
+    console.log(JSON.stringify(require("./payload").info(conf), null, 2));
+    console.log("Local override file (highest priority): " + cfg.localDictFile(conf.dictionary));
+    return;
+  }
+
+  if (cmd === "config") {
+    let changed = false;
+    if (flags["cline-path"]) { conf.clinePath = flags["cline-path"]; changed = true; }
+    if (flags.port) { conf.port = Number(flags.port); changed = true; }
+    if (flags["auto-update"]) { conf.autoUpdate = String(flags["auto-update"]) !== "off"; changed = true; }
+    if (flags["update-url"]) { conf.updateUrl = flags["update-url"]; changed = true; }
+    if (flags["storage-key"] !== undefined) { conf.storageKey = String(flags["storage-key"]); changed = true; }
+    if (flags.dictionary) {
+      const want = flags.dictionary;
+      const have = require("./dict").available();
+      if (!have.includes(want)) {
+        console.error(`Unknown locale "${want}". Bundled dictionaries: ${have.join(", ")}`);
+        process.exitCode = 1;
+        return;
+      }
+      conf.dictionary = want; changed = true;
+    }
+    if (flags["hide"]) {
+      const kept = (conf.featureHide || []).slice();
+      if (kept.indexOf(flags["hide"]) < 0) kept.push(flags["hide"]);
+      conf.featureHide = kept;
+      changed = true;
+    }
+    if (flags["unhide"]) {
+      conf.featureHide = (conf.featureHide || []).filter((p) => p !== flags["unhide"]);
+      changed = true;
+    }
+    if (changed) { cfg.write(conf); console.log("Wrote " + cfg.configFile()); }
+    console.log(JSON.stringify(cfg.read(), null, 2));
+    return;
+  }
+
+  console.log(HELP);
+}
+
+main().catch((e) => { console.error("Cline-kit: " + e.message); process.exit(1); });

package/src/config.js

@@ -0,0 +1,108 @@
+"use strict";
+// Config + paths. Everything lives in %APPDATA%\cline-kit (or ~/.config/cline-kit).
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const DIR_NAME = "cline-kit";
+const LEGACY_DIR_NAME = "cline-zh";   // pre-rename layout, migrated once on first run
+
+function baseDir() {
+  const appdata = process.env.APPDATA;
+  if (appdata) return appdata;
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support");
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "");
+}
+
+function configDir() { return path.join(baseDir(), DIR_NAME); }
+function legacyDir() { return path.join(baseDir(), LEGACY_DIR_NAME); }
+
+let migrated;
+function migrateLegacy() {
+  if (migrated !== undefined) return migrated;
+  migrated = false;
+  const dst = configDir();
+  const src = legacyDir();
+  try {
+    if (fs.existsSync(src) && !fs.existsSync(dst)) {
+      fs.mkdirSync(dst, { recursive: true });
+      for (const f of ["config.json"]) {
+        if (fs.existsSync(path.join(src, f))) fs.copyFileSync(path.join(src, f), path.join(dst, f));
+      }
+      for (const d of ["cache", "logs"]) {
+        copyDir(path.join(src, d), path.join(dst, d));
+      }
+      migrated = true;
+    }
+  } catch (e) { /* a failed migration just means a fresh config; never crash over it */ }
+  return migrated;
+}
+
+function copyDir(from, to) {
+  if (!fs.existsSync(from)) return;
+  fs.mkdirSync(to, { recursive: true });
+  for (const name of fs.readdirSync(from)) {
+    const a = path.join(from, name);
+    const b = path.join(to, name);
+    if (fs.statSync(a).isDirectory()) copyDir(a, b);
+    else fs.copyFileSync(a, b);
+  }
+}
+
+function configFile() { return path.join(configDir(), "config.json"); }
+function cacheDir() { return path.join(configDir(), "cache"); }
+function logDir() { return path.join(configDir(), "logs"); }
+
+const DEFAULTS = {
+  // Cline executable; null = auto-detect on each run
+  clinePath: null,
+  // 0 = pick a random free port at launch (avoids clashing with other debug servers)
+  port: 0,
+  // dictionary updates
+  autoUpdate: true,
+  updateUrl: "https://raw.githubusercontent.com/chentaoxing/Cline-kit/main/dictionaries/zh-CN.json",
+  updateIntervalMs: 24 * 60 * 60 * 1000,
+  dictionary: "zh-CN",
+  // feature id -> boolean; absent keys fall back to each feature's defaultOn
+  features: {},
+  // extra paths sidebar-groups must not list as projects (containers, scratch folders)
+  featureHide: [],
+  // override Cline's workspace-registry localStorage key; empty = detect cline.code.workspace-selection.vN
+  storageKey: "",
+  // installer state
+  shortcutPath: null,
+  autostart: false,
+  lastUpdateCheck: 0,
+  remoteVersion: null
+};
+
+function read() {
+  migrateLegacy();
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(configFile(), "utf8")); } catch (e) { data = {}; }
+  return Object.assign({}, DEFAULTS, data);
+}
+
+function write(cfg) {
+  migrateLegacy();
+  fs.mkdirSync(configDir(), { recursive: true });
+  const tmp = configFile() + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2), "utf8");
+  fs.renameSync(tmp, configFile());
+  return cfg;
+}
+
+function ensureDirs() {
+  migrateLegacy();
+  fs.mkdirSync(configDir(), { recursive: true });
+  fs.mkdirSync(cacheDir(), { recursive: true });
+  fs.mkdirSync(logDir(), { recursive: true });
+}
+
+function localDictFile(name) { return path.join(configDir(), name + ".local.json"); }
+function cachedDictFile(name) { return path.join(cacheDir(), name + ".json"); }
+
+module.exports = {
+  configDir, configFile, cacheDir, logDir, read, write, ensureDirs, DEFAULTS,
+  localDictFile, cachedDictFile, migrateLegacy, legacyDir, DIR_NAME
+};