cctrans 0.2.1 → 0.4.0

package/src/interleave.js

@@ -16,6 +16,22 @@ function looksLikeCodeish(s) {
   return false;
 }
 
+// Leading BLOCK markdown (heading / list marker / blockquote) must be split
+// off before translation: fed to an MT backend it gets kept or mangled, and
+// re-rendered mid-line after the ↳ marker it shows up as literal "##" / "-" /
+// ">" (the translated line no longer starts with the prefix, so the renderer
+// treats it as text). Translate the content only; re-apply structure when
+// building the translated line.
+function splitBlockPrefix(line) {
+  let m = line.match(/^(\s{0,3}#{1,6}\s+)(.*)$/); // heading
+  if (m) return { prefix: m[1], content: m[2], block: 'heading' };
+  m = line.match(/^(\s*(?:[-*+]|\d{1,3}[.)])\s+)(.*)$/); // list item
+  if (m) return { prefix: m[1], content: m[2], block: 'list' };
+  m = line.match(/^(\s*(?:>\s*)+)(.*)$/); // blockquote (possibly nested)
+  if (m) return { prefix: m[1], content: m[2], block: 'quote' };
+  return { prefix: '', content: line, block: null };
+}
+
 // A code fence (```), and therefore "are we inside a code block?", can span
 // multiple MessageDisplay deltas. The caller threads the ending fence state of
 // one delta into the next (keyed by message_id), so classify takes an initial
@@ -30,17 +46,34 @@ function classify(lines, inFenceInit, target) {
     if (line.trim() === '') { plan.push({ line, kind: 'blank' }); continue; }
     if (isProbablyTarget(line, target)) { plan.push({ line, kind: 'target' }); continue; }
     if (looksLikeCodeish(line)) { plan.push({ line, kind: 'code' }); continue; }
-    plan.push({ line, kind: 'prose' });
+    const { prefix, content, block } = splitBlockPrefix(line);
+    if (looksLikeCodeish(content)) { plan.push({ line, kind: 'code' }); continue; } // e.g. "- /path/to/file"
+    plan.push({ line, kind: 'prose', prefix, content, block });
   }
   return { plan, inFence };
 }
 
-// How to place the Chinese line under the English line.
+// The translated line mirrors the English line's block structure:
+//   heading "## T"  -> "## ↳ 译"   (same heading style)
+//   quote   "> T"   -> "> ↳ 译"    (stays inside the quote)
+//   list    "- T"   -> "  ↳ 译"    (same-width indent — a re-applied "- " would
+//                                   render a second bullet)
+//   plain   "T"     -> "↳ 译"
+// demoteStructure drops the heading/quote prefix (plain "↳ 译"): in a grouped
+// section block displaced from its English line, a re-applied "## "/"> " would
+// render a REAL heading / fresh blockquote detached from what it translates.
+function zhLineFor(p, zh, marker, demoteStructure) {
+  if (p.block === 'list') return ' '.repeat(p.prefix.length) + marker + zh;
+  if (demoteStructure && (p.block === 'heading' || p.block === 'quote')) return marker + zh;
+  return p.prefix + marker + zh;
+}
+
+// How to place the Chinese line under the English line (line mode).
 // hardBreak=true uses a CommonMark hard line break (two trailing spaces) so the
 // two lines stay separate even if displayContent is markdown-rendered.
-function pair(enLine, zhLine, marker, hardBreak) {
+function pair(p, zh, marker, hardBreak) {
   const br = hardBreak ? '  \n' : '\n';
-  return enLine + br + marker + zhLine;
+  return p.line + br + zhLineFor(p, zh, marker, false);
 }
 
 // Returns { displayContent, inFence }:
@@ -64,7 +97,7 @@ async function buildDisplayContent(rawDelta, opts) {
   const proseIdx = [];
   const proseLines = [];
   for (let i = 0; i < plan.length; i++) {
-    if (plan[i].kind === 'prose') { proseIdx.push(i); proseLines.push(plan[i].line); }
+    if (plan[i].kind === 'prose') { proseIdx.push(i); proseLines.push(plan[i].content); }
   }
   if (proseLines.length === 0) return { displayContent: null, inFence }; // nothing to translate
 
@@ -79,7 +112,7 @@ async function buildDisplayContent(rawDelta, opts) {
     const p = plan[i];
     if (p.kind === 'prose') {
       const t = zhFor[i];
-      if (t && t.trim() && t.trim() !== p.line.trim()) out.push(pair(p.line, t, marker, hardBreak));
+      if (t && t.trim() && t.trim() !== p.content.trim()) out.push(pair(p, t, marker, hardBreak));
       else out.push(p.line);
     } else {
       out.push(p.line);
@@ -90,4 +123,124 @@ async function buildDisplayContent(rawDelta, opts) {
   return { displayContent: dc, inFence };
 }
 
-module.exports = { buildDisplayContent, classify, looksLikeCodeish };
+// ---------------------------------------------------------------------------
+// Section mode: English streams untouched; a section's translation is spliced
+// in as one grouped "↳" block when the section closes.
+//
+// A section = a maximal run of consecutive prose lines. Boundaries are
+// properties of the TEXT, never of delta chunking (deltas batch arbitrarily —
+// the same reply can arrive as 3 deltas in one run and 5 in another), which is
+// what makes a full repaint (replay from index 0) reproduce identical output:
+//   - a real blank line (the last split element '' merely encodes the delta's
+//     trailing "\n" — a continuing block, not a blank);
+//   - any code/fence/target-language line;
+//   - a heading, which closes the run before it AND itself: a displaced
+//     "## ↳ 译" would render as a real heading below the block it titles;
+//   - the soft buffer cap (deferred past list items so a forced splice never
+//     lands mid-list, with a hard ceiling as backstop);
+//   - final:true.
+
+const SECTION_CAP = 6000; // soft cap on buffered EN chars before a forced flush
+const SECTION_HARD_CAP = 9000; // flush even mid-list past this
+
+// Pure, synchronous segmentation — no I/O, no await, so the hook can persist
+// the resulting buffer BEFORE translation starts (at-most-once flush: a crash
+// or timeout after the save can only drop a section's translation, never
+// replay it at a wrong position).
+// opts: {inFence, buf (pending entries from prior deltas), target, final}
+// Returns:
+//   out      — the delta's own lines, verbatim (splice skeleton)
+//   flushes  — [{pos, entries}]: closed sections and where in `out` their ZH
+//              block goes (right after the section's last English line)
+//   buf      — entries still pending (the open section), to persist
+//   inFence  — fence state at end of delta, to persist
+function planSections(rawDelta, opts) {
+  opts = opts || {};
+  const lines = String(rawDelta).split('\n');
+  const { plan, inFence } = classify(lines, opts.inFence, opts.target || 'zh-Hans');
+  const out = [];
+  const flushes = [];
+  let pending = (opts.buf || []).slice();
+  let pendingChars = pending.reduce((n, e) => n + e.content.length, 0);
+  const flush = () => {
+    if (pending.length) { flushes.push({ pos: out.length, entries: pending }); pending = []; pendingChars = 0; }
+  };
+  for (let i = 0; i < plan.length; i++) {
+    const p = plan[i];
+    if (p.kind === 'prose') {
+      if (p.block === 'heading') flush(); // close the run before the heading
+      out.push(p.line);
+      pending.push({ line: p.line, prefix: p.prefix, content: p.content, block: p.block });
+      pendingChars += p.content.length;
+      if (p.block === 'heading') flush(); // ...and the heading itself
+      else if (pendingChars > SECTION_CAP && (p.block !== 'list' || pendingChars > SECTION_HARD_CAP)) flush();
+      continue;
+    }
+    if (p.kind === 'blank') {
+      const terminalArtifact = i === plan.length - 1 && p.line === '';
+      if (!terminalArtifact) flush();
+      out.push(p.line);
+      continue;
+    }
+    flush(); // code/fence/target line interrupts the section, then passes through
+    out.push(p.line);
+  }
+  if (opts.final) flush();
+  return { out, flushes, buf: pending, inFence };
+}
+
+// Translate all flushed sections (one batch call) and splice each grouped ZH
+// block into the out-skeleton. Returns the displayContent string, or null for
+// "leave this delta as the original English" (nothing survived translation, or
+// over the cap). Translation is per-LINE (prefix-stripped), so the sha1 cache
+// is shared with line mode and the backends' line contracts hold unchanged.
+async function renderSections(planned, opts) {
+  opts = opts || {};
+  const marker = opts.marker || '↳ ';
+  const cap = opts.cap || 9000;
+  if (!planned.flushes.length) return null;
+
+  const contents = [];
+  for (const f of planned.flushes) for (const e of f.entries) contents.push(e.content);
+  const zh = await translateLines(contents, {
+    target: opts.target, backend: opts.backend, model: opts.model, timeoutMs: opts.timeoutMs,
+  });
+
+  let k = 0;
+  const blocks = [];
+  for (const f of planned.flushes) {
+    // Single-line sections keep line-mode structure; a uniform quote run keeps
+    // its "> " (the block continues the same blockquote). Only mixed grouped
+    // blocks demote structure prefixes.
+    const grouped = f.entries.length > 1;
+    const allQuote = grouped && f.entries.every((e) => e.block === 'quote');
+    const blockLines = [];
+    for (const e of f.entries) {
+      const t = zh[k++];
+      if (t && t.trim() && t.trim() !== e.content.trim()) blockLines.push(zhLineFor(e, t, marker, grouped && !allQuote));
+    }
+    if (blockLines.length) blocks.push({ pos: f.pos, lines: blockLines });
+  }
+  if (!blocks.length) return null;
+
+  const splice = () => {
+    const merged = planned.out.slice();
+    for (let i = blocks.length - 1; i >= 0; i--) merged.splice(blocks[i].pos, 0, ...blocks[i].lines);
+    return merged.join('\n');
+  };
+  let dc = splice();
+  // Over the cap: shed whole ZH blocks (largest first) instead of dropping the
+  // delta's entire translation — their sections are already committed out of
+  // the buffer, so a shed block is simply lost, never repositioned.
+  while (dc.length > cap && blocks.length) {
+    let big = 0;
+    for (let i = 1; i < blocks.length; i++) {
+      if (blocks[i].lines.join('\n').length > blocks[big].lines.join('\n').length) big = i;
+    }
+    blocks.splice(big, 1);
+    dc = blocks.length ? splice() : null;
+  }
+  return dc;
+}
+
+module.exports = { buildDisplayContent, classify, looksLikeCodeish, planSections, renderSections };

package/src/langs.js

@@ -52,10 +52,10 @@ const LANGS = {
 // 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;
+// Absolute count, not a ratio: coding prompts are full of Latin paths and
+// identifiers that would dilute any ratio below a usable threshold.
+function nonLatinCount(text) {
+  return (text.match(NON_LATIN) || []).length;
 }
 
 // Region-code (and bare-zh) aliases -> canonical script codes.
@@ -91,4 +91,4 @@ function isProbablyTarget(line, code) {
   return nonspace > 0 && hits / nonspace >= 0.3;
 }
 
-module.exports = { LANGS, getLang, listLangs, isProbablyTarget, normalizeLang, nonLatinRatio };
+module.exports = { LANGS, getLang, listLangs, isProbablyTarget, normalizeLang, nonLatinCount };

package/src/setup.js

@@ -1,11 +1,12 @@
 'use strict';
-// Interactive setup wizard: language -> backend -> API-key entry -> live
-// verification -> save. Re-runnable via `cctrans setup`; non-interactive with
-// flags (--lang, --backend, --key, --yes). Keys go to keys.json only — the
-// shell environment is never read.
+// Interactive setup wizard: language -> display mode -> backend -> API-key
+// entry -> input translation (beta) -> live verification -> save. Re-runnable
+// via `cctrans setup`; non-interactive with flags (--lang, --mode, --backend,
+// --key, --input, --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 { getState, setState, MODES } = require('./config');
 const { listLangs, getLang, normalizeLang } = require('./langs');
 const { listBackends, getBackend } = require('./backends');
 const keys = require('./keys');
@@ -38,7 +39,7 @@ async function runSetup(opts) {
     let lang = opts.lang;
     if (!lang) {
       const codes = listLangs();
-      console.log('\n' + C.bold('Target language') + ' — translations appear under each English line:');
+      console.log('\n' + C.bold('Target language') + ' — replies show English + your language inline:');
       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);
@@ -47,7 +48,18 @@ async function runSetup(opts) {
     if (!getLang(lang)) { console.error(C.red('unsupported language: ' + lang)); return false; }
     lang = normalizeLang(lang);
 
-    // 2. Backend
+    // 2. Display mode
+    let mode = opts.mode;
+    if (!mode) {
+      console.log('\n' + C.bold('Display mode') + ':');
+      console.log('  1. line     ' + C.dim('translation under each English line, as it streams'));
+      console.log('  2. section  ' + C.dim('English block first, then its translation — appears when the block completes'));
+      const a = await ask('Pick a number or name', getState().mode);
+      mode = a === '1' ? 'line' : a === '2' ? 'section' : a;
+    }
+    if (!MODES.includes(mode)) { console.error(C.red('unknown mode: ' + mode + ' (available: ' + MODES.join(', ') + ')')); return false; }
+
+    // 3. Backend
     let backend = opts.backend;
     if (!backend) {
       console.log('\n' + C.bold('Translation backend') + ':');
@@ -62,7 +74,7 @@ async function runSetup(opts) {
     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
+    // 4. 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)', ''));
@@ -73,12 +85,24 @@ async function runSetup(opts) {
       }
     }
 
-    // 4. Save config
-    setState({ target: lang, backend });
-    console.log('\n' + C.green('✓') + ' saved: lang=' + lang + ' (' + getLang(lang).name + '), backend=' + backend +
+    // 5. Input translation (beta, opt-in): prompt -> English as context
+    let inputEn = typeof opts.input === 'string' ? opts.input === 'on' : getState().inputEn;
+    if (opts.input === undefined && rl) {
+      console.log('\n' + C.bold('Input translation') + ' ' + C.dim('(beta)') +
+        ' — type prompts in your language; an English translation is\n' +
+        'attached as context and the model is asked to reply in English (the original\n' +
+        'prompt stays in your history; adds ~0.5–1.5s per non-English prompt).');
+      const a = await ask('Enable input translation? (y/N)', inputEn ? 'y' : 'n');
+      inputEn = /^y(es)?$/i.test(a);
+    }
+
+    // 6. Save config
+    setState({ target: lang, mode, backend, inputEn });
+    console.log('\n' + C.green('✓') + ' saved: lang=' + lang + ' (' + getLang(lang).name + '), mode=' + mode +
+      ', backend=' + backend + ', input=' + (inputEn ? 'on' : 'off') +
       (b.available() ? '' : C.red('  (no key yet — will fall back to google)')));
 
-    // 5. Live verification
+    // 7. Live verification
     process.stdout.write(C.dim('verifying… '));
     try {
       const { displayContent } = await buildDisplayContent('Setup verification: translation works.\n', {
@@ -89,7 +113,10 @@ async function runSetup(opts) {
       console.log(C.red('verification failed: ' + e.message));
     }
 
-    console.log(C.dim('\nNext: restart Claude Code (new session). Toggle with `!cctrans off` / `!cctrans on`; input translation: `cctrans input on`.'));
+    console.log(C.dim('\nNext: restart Claude Code (new session). Toggle with `!cctrans off` / `!cctrans on`. ' +
+      (inputEn
+        ? 'Input translation (beta) is ON — disable: `cctrans input off`.'
+        : 'Input translation (beta): `cctrans input on`.')));
     return true;
   } finally {
     if (rl) rl.close();