cctrans 0.1.0

package/src/langs.js

@@ -0,0 +1,94 @@
+'use strict';
+// Supported target languages (CJK + Russian + Hindi — non-Latin scripts only,
+// so "already in target language" detection can be done by Unicode script
+// ranges).
+//
+// Canonical codes use BCP-47 SCRIPT subtags for Chinese (zh-Hans / zh-Hant):
+// Traditional Chinese is a script, not a region — zh-TW/zh-HK are kept as
+// ALIASES for muscle memory and normalize to the script code.
+//
+// Each entry: display name (for LLM prompts), per-backend language codes, and
+// a script regex used to skip lines that are already in the target language.
+
+const LANGS = {
+  'zh-Hans': {
+    name: 'Simplified Chinese',
+    google: 'zh-CN', deepl: 'ZH-HANS', azure: 'zh-Hans',
+    script: /[一-鿿㐀-䶿]/g, // Han
+  },
+  'zh-Hant': {
+    name: 'Traditional Chinese',
+    google: 'zh-TW', deepl: 'ZH-HANT', azure: 'zh-Hant',
+    script: /[一-鿿㐀-䶿]/g, // Han
+  },
+  ja: {
+    name: 'Japanese',
+    google: 'ja', deepl: 'JA', azure: 'ja',
+    script: /[぀-ゟ゠-ヿ一-鿿]/g, // Kana + Han
+  },
+  ko: {
+    name: 'Korean',
+    google: 'ko', deepl: 'KO', azure: 'ko',
+    script: /[가-힯ᄀ-ᇿ㄰-㆏]/g, // Hangul
+  },
+  ru: {
+    name: 'Russian',
+    google: 'ru', deepl: 'RU', azure: 'ru',
+    script: /[Ѐ-ӿ]/g, // Cyrillic
+  },
+  hi: {
+    name: 'Hindi',
+    google: 'hi', deepl: 'HI', azure: 'hi',
+    script: /[ऀ-ॿ]/g, // Devanagari
+  },
+  en: {
+    name: 'English',
+    google: 'en', deepl: 'EN-US', azure: 'en',
+    script: /[A-Za-z]/g, // Latin — used by input translation (prompt -> English)
+  },
+};
+
+// Combined non-Latin script regex: "is this text written in one of the
+// supported non-English languages?" Used by the input-translation hook.
+const NON_LATIN = /[一-鿿㐀-䶿぀-ゟ゠-ヿ가-힯ᄀ-ᇿЀ-ӿऀ-ॿ]/g;
+
+function nonLatinRatio(text) {
+  const hits = (text.match(NON_LATIN) || []).length;
+  const nonspace = text.replace(/\s/g, '').length;
+  return nonspace === 0 ? 0 : hits / nonspace;
+}
+
+// Region-code (and bare-zh) aliases -> canonical script codes.
+const ALIASES = {
+  zh: 'zh-Hans',
+  'zh-CN': 'zh-Hans',
+  'zh-SG': 'zh-Hans',
+  'zh-TW': 'zh-Hant',
+  'zh-HK': 'zh-Hant',
+  'zh-MO': 'zh-Hant',
+};
+
+function normalizeLang(code) {
+  return ALIASES[code] || code;
+}
+
+function getLang(code) {
+  return LANGS[normalizeLang(code)] || null;
+}
+
+function listLangs() {
+  // 'en' is reserved for the input-translation direction (prompt -> English);
+  // it's resolvable via getLang but not advertised as an overlay target.
+  return Object.keys(LANGS).filter((k) => k !== 'en');
+}
+
+// True if the line is (mostly) already written in the target language's script.
+function isProbablyTarget(line, code) {
+  const lang = getLang(code);
+  if (!lang) return false;
+  const hits = (line.match(lang.script) || []).length;
+  const nonspace = line.replace(/\s/g, '').length;
+  return nonspace > 0 && hits / nonspace >= 0.3;
+}
+
+module.exports = { LANGS, getLang, listLangs, isProbablyTarget, normalizeLang, nonLatinRatio };

package/src/setup.js

@@ -0,0 +1,99 @@
+'use strict';
+// Interactive setup wizard: language -> backend -> API-key entry -> live
+// verification -> save. Re-runnable via `tt setup`; non-interactive with
+// flags (--lang, --backend, --key, --yes). Keys go to keys.json only — the
+// shell environment is never read.
+
+const readline = require('node:readline/promises');
+const { getState, setState } = require('./config');
+const { listLangs, getLang, normalizeLang } = require('./langs');
+const { listBackends, getBackend } = require('./backends');
+const keys = require('./keys');
+const { buildDisplayContent } = require('./interleave');
+
+const C = {
+  dim: (s) => '\x1b[2m' + s + '\x1b[0m',
+  cyan: (s) => '\x1b[36m' + s + '\x1b[0m',
+  green: (s) => '\x1b[32m' + s + '\x1b[0m',
+  red: (s) => '\x1b[31m' + s + '\x1b[0m',
+  bold: (s) => '\x1b[1m' + s + '\x1b[0m',
+};
+
+async function runSetup(opts) {
+  opts = opts || {};
+  const interactive = !opts.yes && process.stdin.isTTY;
+  const rl = interactive
+    ? readline.createInterface({ input: process.stdin, output: process.stdout })
+    : null;
+  const ask = async (q, def) => {
+    if (!rl) return def;
+    const a = (await rl.question(q + (def ? C.dim(' [' + def + '] ') : ' '))).trim();
+    return a || def;
+  };
+
+  try {
+    console.log(C.bold('cctranslate setup') + C.dim('  (re-run anytime: tt setup)'));
+
+    // 1. Target language
+    let lang = opts.lang;
+    if (!lang) {
+      const codes = listLangs();
+      console.log('\n' + C.bold('Target language') + ' — translations appear under each English line:');
+      codes.forEach((c, i) => console.log('  ' + (i + 1) + '. ' + c.padEnd(8) + C.dim(getLang(c).name)));
+      const cur = getState().target;
+      const a = await ask('Pick a number or code', cur);
+      lang = /^\d+$/.test(a) ? codes[parseInt(a, 10) - 1] : a;
+    }
+    if (!getLang(lang)) { console.error(C.red('unsupported language: ' + lang)); return false; }
+    lang = normalizeLang(lang);
+
+    // 2. Backend
+    let backend = opts.backend;
+    if (!backend) {
+      console.log('\n' + C.bold('Translation backend') + ':');
+      for (const b of listBackends()) {
+        console.log('  ' + b.id.padEnd(12) + (b.available() ? C.green('ready  ') : C.red('no key ')) + C.dim(b.needs));
+      }
+      const def = getState().backend && getBackend(getState().backend) && getBackend(getState().backend).available()
+        ? getState().backend
+        : (getBackend('openai').available() ? 'openai' : 'google');
+      backend = await ask('Pick a backend', def);
+    }
+    const b = getBackend(backend);
+    if (!b) { console.error(C.red('unknown backend: ' + backend)); return false; }
+
+    // 3. Key entry for the chosen backend, if missing (keys live ONLY in
+    //    keys.json — shell env vars are never read)
+    if (!b.available() && keys.KEY_IDS.includes(b.id)) {
+      const v = opts.key || (await ask('Paste your ' + b.id + ' API key (enter to skip)', ''));
+      if (v) { keys.setKey(b.id, v); console.log(C.green('✓') + ' key saved to ' + keys.KEYS_FILE + C.dim(' (chmod 600)')); }
+      if (b.id === 'azure' && !keys.getKey('azure-region')) {
+        const r = await ask('Azure region (enter to skip)', '');
+        if (r) keys.setKey('azure-region', r);
+      }
+    }
+
+    // 4. Save config
+    setState({ target: lang, backend });
+    console.log('\n' + C.green('✓') + ' saved: lang=' + lang + ' (' + getLang(lang).name + '), backend=' + backend +
+      (b.available() ? '' : C.red('  (no key yet — will fall back to google)')));
+
+    // 5. Live verification
+    process.stdout.write(C.dim('verifying… '));
+    try {
+      const { displayContent } = await buildDisplayContent('Setup verification: translation works.\n', {
+        target: lang, backend, timeoutMs: 12000,
+      });
+      console.log('\n' + (displayContent || C.red('(nothing translated — check the backend)')));
+    } catch (e) {
+      console.log(C.red('verification failed: ' + e.message));
+    }
+
+    console.log(C.dim('\nNext: restart Claude Code (new session). Toggle with `!tt off` / `!tt on`; input translation: `tt input on`.'));
+    return true;
+  } finally {
+    if (rl) rl.close();
+  }
+}
+
+module.exports = { runSetup };

package/src/transcript.js

@@ -0,0 +1,166 @@
+'use strict';
+// Locate and parse the active Claude Code session transcript (JSONL).
+// Claude Code writes one transcript per session at:
+//   ~/.claude/projects/<cwd-slug>/<sessionId>.jsonl
+// where <cwd-slug> is the working dir with every non-alphanumeric char -> '-'.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function projectsRoot() {
+  return path.join(os.homedir(), '.claude', 'projects');
+}
+
+// Replicate Claude Code's directory-slug rule for a cwd.
+// e.g. /home/roy/terminal-translate -> -home-roy-terminal-translate
+function slugForCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+function newestJsonlIn(dir) {
+  let best = null;
+  let bestMtime = -1;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (e) {
+    return null;
+  }
+  for (const name of entries) {
+    if (!name.endsWith('.jsonl')) continue;
+    const fp = path.join(dir, name);
+    let st;
+    try {
+      st = fs.statSync(fp);
+    } catch (e) {
+      continue;
+    }
+    if (st.mtimeMs > bestMtime) {
+      bestMtime = st.mtimeMs;
+      best = fp;
+    }
+  }
+  return best;
+}
+
+// Find the transcript file for the current session.
+// Strategy: 1) explicit override; 2) newest .jsonl in the cwd-slug dir;
+// 3) globally newest .jsonl across all projects (the active session is
+//    almost always the most recently written one).
+function findTranscript(cwd) {
+  if (process.env.TT_TRANSCRIPT) return process.env.TT_TRANSCRIPT;
+
+  const root = projectsRoot();
+  const dir = path.join(root, slugForCwd(cwd || process.cwd()));
+  const local = newestJsonlIn(dir);
+  if (local) return local;
+
+  // Fallback: scan every project dir for the globally newest transcript.
+  let best = null;
+  let bestMtime = -1;
+  let projectDirs;
+  try {
+    projectDirs = fs.readdirSync(root);
+  } catch (e) {
+    return null;
+  }
+  for (const d of projectDirs) {
+    const candidate = newestJsonlIn(path.join(root, d));
+    if (!candidate) continue;
+    const m = fs.statSync(candidate).mtimeMs;
+    if (m > bestMtime) {
+      bestMtime = m;
+      best = candidate;
+    }
+  }
+  return best;
+}
+
+// A "real" user prompt = something the human typed (a turn boundary),
+// as opposed to a tool_result or a meta/system event.
+function isRealUserPrompt(o) {
+  if (!o || o.type !== 'user') return false;
+  if (o.isMeta) return false;
+  const c = o.message && o.message.content;
+  if (typeof c === 'string') return c.trim().length > 0;
+  if (Array.isArray(c)) {
+    if (c.some((b) => b && b.type === 'tool_result')) return false;
+    return c.some((b) => b && b.type === 'text' && b.text && b.text.trim().length > 0);
+  }
+  return false;
+}
+
+function readEvents(file) {
+  const raw = fs.readFileSync(file, 'utf8').split('\n');
+  const events = [];
+  for (const ln of raw) {
+    if (!ln) continue;
+    try {
+      events.push(JSON.parse(ln));
+    } catch (e) {
+      /* ignore partial/corrupt lines */
+    }
+  }
+  return events;
+}
+
+// Indices (into events) of every real user-prompt turn boundary.
+function boundaryIndices(events) {
+  const out = [];
+  for (let i = 0; i < events.length; i++) {
+    if (isRealUserPrompt(events[i])) out.push(i);
+  }
+  return out;
+}
+
+// Concatenate the assistant's natural-language text (text blocks only;
+// thinking + tool_use excluded) for the reply that follows a given boundary,
+// up to the next boundary.
+function assistantTextBetween(events, startIdx, endIdx) {
+  const texts = [];
+  for (let i = startIdx + 1; i < endIdx; i++) {
+    const o = events[i];
+    if (!o || o.type !== 'assistant') continue;
+    const c = o.message && o.message.content;
+    if (Array.isArray(c)) {
+      for (const b of c) {
+        if (b && b.type === 'text' && typeof b.text === 'string') texts.push(b.text);
+      }
+    } else if (typeof c === 'string') {
+      texts.push(c);
+    }
+  }
+  return texts.join('\n').trim();
+}
+
+// Extract an assistant reply. back=0 -> most recent reply, back=1 -> the one
+// before it, etc. Returns { text, total, index } where index is 0-based from
+// the latest.
+function extractReply(file, back) {
+  back = back || 0;
+  const events = readEvents(file);
+  const bounds = boundaryIndices(events);
+  if (bounds.length === 0) {
+    // No human prompt found; treat the whole file as one reply.
+    return { text: assistantTextBetween(events, -1, events.length), total: 1, index: 0 };
+  }
+  const pick = bounds.length - 1 - back;
+  if (pick < 0) return { text: '', total: bounds.length, index: back };
+  const start = bounds[pick];
+  const end = pick + 1 < bounds.length ? bounds[pick + 1] : events.length;
+  return {
+    text: assistantTextBetween(events, start, end),
+    total: bounds.length,
+    index: back,
+  };
+}
+
+module.exports = {
+  projectsRoot,
+  slugForCwd,
+  findTranscript,
+  readEvents,
+  isRealUserPrompt,
+  extractReply,
+};

package/src/translate.js

@@ -0,0 +1,76 @@
+'use strict';
+// Translation orchestrator: content-addressed cache + backend fallback chain.
+// Backends live in src/backends/ (openai, anthropic, deepl, azure, google,
+// claude-code). On primary failure/timeout the chain falls through (free
+// Google last); on total failure a line echoes its source so the caller still
+// shows the English.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { CACHE_DIR, ensureDirs } = require('./config');
+const { fallbackChain } = require('./backends');
+const { normalizeLang } = require('./langs');
+
+function cacheKey(line, target, backend) {
+  return crypto.createHash('sha1').update(backend + '|' + target + '|' + line).digest('hex');
+}
+function cacheGet(key) {
+  try { return fs.readFileSync(path.join(CACHE_DIR, key + '.txt'), 'utf8'); } catch (e) { return null; }
+}
+function cacheSet(key, val) {
+  try {
+    ensureDirs();
+    const f = path.join(CACHE_DIR, key + '.txt');
+    const tmp = f + '.' + process.pid + '.tmp';
+    fs.writeFileSync(tmp, val);
+    fs.renameSync(tmp, f);
+  } catch (e) {}
+}
+
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error('timeout')), ms);
+    promise.then((v) => { clearTimeout(t); resolve(v); }, (e) => { clearTimeout(t); reject(e); });
+  });
+}
+
+// Translate source lines -> translations, in order, using cache + the chosen
+// backend with fallback. opts: {target, backend, model, timeoutMs}
+async function translateLines(lines, opts) {
+  opts = opts || {};
+  // Normalize aliases (zh-CN -> zh-Hans, zh-TW -> zh-Hant) so cache keys are
+  // canonical regardless of how the user spelled the code.
+  const target = normalizeLang(opts.target || 'zh-Hans');
+  const primary = opts.backend || 'google';
+  const timeoutMs = opts.timeoutMs || 8000;
+
+  const out = new Array(lines.length);
+  const need = [];
+  const needIdx = [];
+  for (let i = 0; i < lines.length; i++) {
+    const c = cacheGet(cacheKey(lines[i], target, primary));
+    if (c !== null) out[i] = c;
+    else { need.push(lines[i]); needIdx.push(i); }
+  }
+  if (need.length === 0) return out;
+
+  let fresh = null;
+  for (const backend of fallbackChain(primary)) {
+    try {
+      fresh = await withTimeout(backend.translate(need, target, opts), timeoutMs);
+      break;
+    } catch (e) {
+      fresh = null; // try next in chain
+    }
+  }
+  if (!fresh) fresh = need.slice(); // give up -> echo source
+
+  for (let j = 0; j < needIdx.length; j++) {
+    out[needIdx[j]] = fresh[j];
+    if (fresh[j] !== need[j]) cacheSet(cacheKey(need[j], target, primary), fresh[j]);
+  }
+  return out;
+}
+
+module.exports = { translateLines, cacheKey };