dsh-cait 1.0.4 → 1.1.3

package/lib/tools.js

@@ -21,6 +21,11 @@ function matchLabel(match) {
   return MATCH_LABELS[match?.matchType] || (match?.exact ? 'exact' : 'fuzzy')
 }
 
+function shorten(value, max = 70) {
+  const textValue = String(value ?? '').replace(/\s+/g, ' ').trim()
+  return textValue.length > max ? `${textValue.slice(0, max - 1)}…` : textValue
+}
+
 function summarizeMatches(matches) {
   if (!matches?.length) return 'TM matches: none'
   const lines = ['TM matches:']
@@ -464,6 +469,473 @@ export function registerCatTools(ctx, store) {
         }
       },
     }),
+
+    ctx.tools.register({
+      name: 'cat_pre_translate',
+      description:
+        'Pre-translate one block of segments in a CAIT document: exact translation-memory matches first, then machine translation through the route in CAIT settings. Segments that are already confirmed or already carry a target are skipped, so repeated calls never overwrite human work. Each call handles at most 32 segments (default 8); the response carries next, the offset of the following block, or null at the end of the document. Call again with from: next to continue.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          from: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Zero-based offset of the first segment in this block. Defaults to 0.',
+          },
+          count: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 32,
+            description: 'Segments per block. Defaults to 8.',
+          },
+          mode: {
+            type: 'string',
+            enum: ['mt', 'tm'],
+            description:
+              'mt (default) fills from translation memory when possible and machine translation otherwise; tm only reuses exact translation-memory matches and reports the rest as noMatch.',
+          },
+          overwrite: {
+            type: 'boolean',
+            description: 'Also replace segments that already have a target. Defaults to false.',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Pre-translation failed.'}`)
+          }
+          const ice = value.segments.filter((item) => item.ice).length
+          const lines = [
+            `CAIT pre-translate (${value.mode}) — segments ${value.from + 1}–${value.to} of ${value.progress.total}`,
+            `Filled ${value.filled}${ice ? ` (${ice} context match${ice === 1 ? '' : 'es'})` : ''} · skipped ${value.skipped.length} · no TM match ${value.noMatch.length} · failed ${value.failed.length}`,
+          ]
+          if (value.failed.length) {
+            for (const item of value.failed.slice(0, 5)) {
+              lines.push(`- segment ${item.index + 1}: ${item.code} — ${item.message}`)
+            }
+          }
+          lines.push(
+            '',
+            `Progress: ${value.progress.confirmed}/${value.progress.total} confirmed · ${value.progress.translated} awaiting review · ${value.progress.pending} pending.`,
+          )
+          lines.push(value.next === null ? 'End of document reached.' : `Next block starts at segment ${value.next + 1}.`)
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...(await store.preTranslate(args)) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'cat_get_segments',
+      description:
+        'List a bounded window of segments from a CAIT document with their source, target, status (pending, translated or confirmed), origin (tm, mt, agent or manual) and any pending suggestion. Use status to pull only the segments that still need work. The response carries next, the offset of the following window, or null at the end.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          from: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Zero-based offset of the first segment. Defaults to 0.',
+          },
+          count: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 50,
+            description: 'Segments per window. Defaults to 20.',
+          },
+          status: {
+            type: 'string',
+            enum: ['pending', 'translated', 'confirmed'],
+            description: 'Optional status filter.',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not list segments.'}`)
+          }
+          const doc = value.document
+          const lines = [
+            `CAIT — ${doc.name} (${doc.sourceLang} → ${doc.targetLang}) · ${value.progress.confirmed}/${doc.total} confirmed · ${value.progress.translated} awaiting review · ${value.progress.pending} pending`,
+            '',
+          ]
+          if (!value.segments.length) {
+            lines.push('No segments match.')
+            return text(lines.join('\n'))
+          }
+          for (const segment of value.segments) {
+            lines.push(
+              `[${segment.index + 1}] ${segment.status}${segment.origin ? ` · ${segment.origin}` : ''}${segment.suggestion ? ' · has suggestion' : ''}`,
+              `  ${segment.source}`,
+              `  → ${segment.target || '(empty)'}`,
+            )
+          }
+          lines.push('', value.next === null ? 'End of document reached.' : `Next window starts at ${value.next + 1}.`)
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.segmentsForTool(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'cat_confirm_segments',
+      description:
+        'Confirm a batch of CAIT segments that already have a target, writing each source–target pair into translation memory. Pass indices, or a from/count window. Segments without a target and segments that are already confirmed are reported as skipped instead of guessed. Use this after reviewing pre-translated text in bulk.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          indices: {
+            type: 'array',
+            items: { type: 'integer', minimum: 0 },
+            description: 'Zero-based segment indices to confirm. Takes precedence over from/count.',
+          },
+          from: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Zero-based offset of the first segment of the window. Defaults to 0.',
+          },
+          count: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 50,
+            description: 'Segments in the window. Defaults to 20.',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not confirm segments.'}`)
+          }
+          const lines = [`Confirmed ${value.confirmed.length} segment(s).`]
+          if (value.confirmed.length) lines.push(`Indices: ${value.confirmed.map((index) => index + 1).join(', ')}`)
+          if (value.skipped.length) {
+            const summary = {}
+            for (const item of value.skipped) summary[item.reason] = (summary[item.reason] || 0) + 1
+            lines.push(
+              `Skipped ${value.skipped.length}: ${Object.entries(summary)
+                .map(([reason, amount]) => `${reason} ${amount}`)
+                .join(', ')}`,
+            )
+          }
+          lines.push(
+            '',
+            `Progress: ${value.progress.confirmed}/${value.progress.total} confirmed · ${value.progress.translated} awaiting review · ${value.progress.pending} pending.`,
+          )
+          if (value.done) lines.push('Every segment is confirmed.')
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.confirmSegmentsForTool(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+    ctx.tools.register({
+      name: 'cat_propose_translation',
+      description:
+        'Propose a translation for one segment without touching its current target. The proposal is stored as a suggestion the human can adopt in the review pane; confirmed segments are refused so a decision that was already made is never silently overwritten. Use this for terminology fixes, consistency repairs and style rewrites.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          index: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Zero-based segment index. Defaults to the document cursor.',
+          },
+          target: {
+            type: 'string',
+            description: 'The proposed translation text.',
+          },
+          reason: {
+            type: 'string',
+            description: 'Optional short note shown next to the proposal, e.g. "术语统一：mode → 模式".',
+          },
+        },
+        required: ['target'],
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not propose a translation.'}`)
+          }
+          const lines = [
+            `Proposed a translation for segment ${value.segment.index + 1} (${value.segment.status}).`,
+            value.segment.target ? `Current target: ${value.segment.target}` : 'Current target: (empty)',
+            `Proposal: ${value.segment.suggestion}`,
+          ]
+          if (value.segment.suggestionReason) lines.push(`Reason: ${value.segment.suggestionReason}`)
+          lines.push('', 'The human adopts it in the review pane; the target is unchanged until then.')
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.proposeTranslation(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+    ctx.tools.register({
+      name: 'cat_align',
+      description:
+        'Align a source text with an existing translation of it and report how confident the pairing is. Pass the two texts directly (read the files first if they are on disk). Nothing is written: the result only says how many pairs are trustworthy and which rows a human should check. Writing happens in the align pane after review.',
+      parameters: {
+        type: 'object',
+        properties: {
+          sourceText: { type: 'string', description: 'Full text of the source document.' },
+          targetText: { type: 'string', description: 'Full text of the existing translation.' },
+          sourceName: { type: 'string', description: 'Optional file name for display.' },
+          targetName: { type: 'string', description: 'Optional file name for display.' },
+          minScore: {
+            type: 'number',
+            description: 'Only list rows below this score as needing review. Defaults to 0.6.',
+          },
+          limit: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 50,
+            description: 'How many doubtful rows to show. Defaults to 10.',
+          },
+        },
+        required: ['sourceText', 'targetText'],
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not align the two texts.'}`)
+          }
+          const threshold = Number.isFinite(args?.minScore) ? args.minScore : 0.6
+          const doubtful = value.pairs.filter(
+            (row) => row.score < threshold || row.confidence !== 'high',
+          )
+          const limit = Number.isFinite(args?.limit) ? args.limit : 10
+          const lines = [
+            `CAIT align: ${value.pairs.length} pair(s) from ${value.sourceSegments} source / ${value.targetSegments} target segment(s).`,
+            `High confidence ${value.high} · medium ${value.medium} · low ${value.low} · unpaired source ${value.unpairedSource} · unpaired target ${value.unpairedTarget}.`,
+          ]
+          if (value.blocked) lines.push('Large document: aligned in blocks, check the middle of the file.')
+          if (doubtful.length) {
+            lines.push('', `Rows worth a human look (first ${Math.min(limit, doubtful.length)}):`)
+            for (const row of doubtful.slice(0, limit)) {
+              lines.push(
+                `[${row.sourceIndex + 1}↔${row.targetIndex + 1}] ${row.score} · ${shorten(row.source)} → ${shorten(row.target)}`,
+              )
+            }
+          }
+          lines.push('', 'Write the reviewed pairs in the align pane; this tool never writes.')
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          const result = store.alignUploads({
+            sourceFile: { name: args.sourceName || 'source.txt', text: args.sourceText },
+            targetFile: { name: args.targetName || 'target.txt', text: args.targetText },
+          })
+          return { ok: true, ...result, rows: undefined }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+    ctx.tools.register({
+      name: 'cat_consistency_report',
+      description:
+        'List groups of segments that share the same source text but carry different translations. Use it to find inconsistencies an import or propagation left behind; then decide the right wording and use cat_propose_translation.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          limit: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 200,
+            description: 'Maximum groups to return. Defaults to 50.',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not build the consistency report.'}`)
+          }
+          if (!value.conflicts.length) {
+            return text('CAIT consistency: every repeated source uses the same translation.')
+          }
+          const lines = [`CAIT consistency: ${value.total} inconsistent group(s).`]
+          for (const conflict of value.conflicts) {
+            lines.push('', `Source: ${shorten(conflict.source, 90)}`)
+            for (const variant of conflict.variants) {
+              lines.push(
+                `  ${shorten(variant.target, 80)} — segment(s) ${variant.indices.map((index) => index + 1).join(', ')}`,
+              )
+            }
+          }
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.consistencyReport(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+    ctx.tools.register({
+      name: 'cat_term_candidates',
+      description:
+        'List terminology candidates mined from a document by counting: repeated multi-word names, capitalised compounds and repeated CJK substrings, ranked by frequency and length. Each candidate carries its occurrence count, sample sentences and any translation-memory wording that already exists. This is the short list to judge; do not re-derive terms yourself. Pick the real domain terms, translate them, then store them with cat_add_terms.',
+      parameters: {
+        type: 'object',
+        properties: {
+          documentId: {
+            type: 'string',
+            description: 'Optional CAIT document id. Defaults to the active document.',
+          },
+          limit: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 200,
+            description: 'Maximum candidates to return. Defaults to 60.',
+          },
+          minCount: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 20,
+            description: 'Minimum number of occurrences. Defaults to 2.',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not mine terminology candidates.'}`)
+          }
+          if (!value.candidates.length) {
+            return text('CAIT terms: no repeated candidate found in this document.')
+          }
+          const lines = [`CAIT terms: ${value.total} candidate(s).`]
+          for (const candidate of value.candidates) {
+            const flags = [
+              `×${candidate.count}`,
+              candidate.inLibrary ? 'in glossary' : '',
+              candidate.evidence.length ? `memory: ${candidate.evidence.map((item) => shorten(item, 40)).join(' | ')}` : '',
+            ].filter(Boolean)
+            lines.push('', `${candidate.term} — ${flags.join(' · ')}`)
+            if (candidate.examples.length) lines.push(`  e.g. ${shorten(candidate.examples[0], 100)}`)
+          }
+          return text(lines.join('\n'))
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.termCandidates(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
+    ctx.tools.register({
+      name: 'cat_add_terms',
+      description:
+        'Add accepted terminology to a glossary library in one batch. Entries already present (same source and language) are skipped rather than overwritten, so this never destroys wording the user chose. Create or pick a library with the user first when they keep separate projects.',
+      parameters: {
+        type: 'object',
+        properties: {
+          glossaryId: {
+            type: 'string',
+            description: 'Optional glossary library id. Defaults to the mounted library.',
+          },
+          entries: {
+            type: 'array',
+            description: 'Terms to add.',
+            items: {
+              type: 'object',
+              properties: {
+                source: { type: 'string', description: 'Source term.' },
+                target: { type: 'string', description: 'Translated term.' },
+                note: { type: 'string', description: 'Optional note.' },
+                sourceLang: { type: 'string', description: 'Optional source language tag.' },
+                caseSensitive: { type: 'boolean', description: 'Match this term case-sensitively.' },
+              },
+              required: ['source', 'target'],
+              additionalProperties: false,
+            },
+          },
+        },
+        required: ['entries'],
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: true },
+        render(_args, value) {
+          if (!value || value.ok === false) {
+            return text(`CAIT: ${value?.message || 'Could not add terms.'}`)
+          }
+          return text(`CAIT terms: added ${value.added}, skipped ${value.skipped} (of ${value.total}).`)
+        },
+      },
+      async execute(args = {}) {
+        try {
+          return { ok: true, ...store.addGlossaryEntries(args) }
+        } catch (error) {
+          return failure(error)
+        }
+      },
+    }),
   ]
 
   return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cait",
-  "version": "1.0.4",
+  "version": "1.1.3",
   "license": "Apache-2.0",
   "author": {
     "name": "Jovi Lecca",
@@ -17,7 +17,7 @@
   "bugs": {
     "url": "https://github.com/JoviLecca/dsh-CAIT/issues"
   },
-  "description": "CAIT — a CAT workbench for DeepSeek Harness with translation memory, glossary, document tabs, MT routes, and Office/subtitle/localization formats.",
+  "description": "CAIT — a CAT workbench for DeepSeek Harness with translation memory, glossary, document tabs, MT routes, and Office/EPUB/subtitle/localization formats.",
   "type": "module",
   "keywords": [
     "dsh-plugin",