voxflow 1.15.0 → 1.15.2

package/lib/commands/asr/azure-transcribe.js

@@ -0,0 +1,336 @@
+/**
+ * ASR command — Azure Batch pipeline.
+ *
+ * Handles R2 upload → /api/asr/jobs → poll → finalize output.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getMediaInfo, extractAudioForAsr } = require('../../core/audio-extract');
+const { uploadToR2 } = require('../../core/asr-r2-upload');
+const azureClient = require('../../core/asr-jobs-client');
+const azureStore = require('../../core/asr-jobs-store');
+const { formatSrt, formatPlainText, formatJson } = require('../../core/srt');
+const { FORMAT_EXTENSIONS, formatDuration, formatSize } = require('./helpers');
+
+// ─── Language mapping ───────────────────────────────────────────────────────
+
+// Map Tencent-style codes (16k_zh, 16k_ja) to BCP-47 (zh-CN, ja-JP) so
+// users can keep using --lang the same way across engines.
+const TENCENT_TO_BCP47 = {
+  '16k_zh':         'zh-CN',
+  '16k_zh_en':      'zh-CN',
+  '16k_zh_dialect': 'zh-CN',
+  '8k_zh':          'zh-CN',
+  '16k_en':         'en-US',
+  '8k_en':          'en-US',
+  '16k_ja':         'ja-JP',
+  '16k_ko':         'ko-KR',
+};
+
+function toBcp47(lang) {
+  if (!lang || lang === 'auto') return 'auto';
+  return TENCENT_TO_BCP47[lang] || lang;
+}
+
+// ─── Word-level caption splitting ───────────────────────────────────────────
+
+const MAX_CAPTION_SEC = 8;
+const MIN_SPLIT_SEC   = 2.5;
+const ZH_SENT_END     = /[。！？]/;
+const ANY_SENT_END    = /[.!?。！？]/;
+const CJK_CHAR = /[぀-ヿ㐀-䶿一-鿿＀-￯]/;
+
+/**
+ * Join words with appropriate spacing depending on CJK context.
+ */
+function joinWords(words) {
+  let out = '';
+  for (let i = 0; i < words.length; i++) {
+    const cur = words[i];
+    if (i === 0) { out = cur; continue; }
+    const prev = words[i - 1];
+    const needSpace = !CJK_CHAR.test(prev.slice(-1)) && !CJK_CHAR.test(cur.slice(0, 1));
+    out += (needSpace ? ' ' : '') + cur;
+  }
+  return out;
+}
+
+function splitSegmentByWords(seg) {
+  const words = seg.words;
+  if (!words || words.length === 0) {
+    return [{ start: seg.start, end: seg.end, text: seg.text, speaker: seg.speaker }];
+  }
+
+  const captions = [];
+  let buf = [];
+  let bufStart = null;
+
+  const flush = (endSec) => {
+    if (buf.length === 0) return;
+    captions.push({
+      start: bufStart,
+      end: endSec,
+      text: joinWords(buf.map(w => w.word)),
+      speaker: seg.speaker || null,
+    });
+    buf = [];
+    bufStart = null;
+  };
+
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    if (bufStart === null) bufStart = w.start;
+    buf.push(w);
+    const dur = w.end - bufStart;
+    const isLast = i === words.length - 1;
+    const hasSentEnd = ZH_SENT_END.test(w.word) || ANY_SENT_END.test(w.word);
+
+    if (isLast || dur >= MAX_CAPTION_SEC || (hasSentEnd && dur >= MIN_SPLIT_SEC)) {
+      flush(w.end);
+    }
+  }
+
+  return captions;
+}
+
+/**
+ * Format Azure's normalized transcript into our captions[] shape.
+ */
+function azureSegmentsToCaptions(segments = []) {
+  const flat = [];
+  for (const seg of segments) {
+    for (const c of splitSegmentByWords(seg)) {
+      flat.push(c);
+    }
+  }
+  return flat.map((c, i) => ({
+    id: i + 1,
+    startMs: Math.round(c.start * 1000),
+    endMs:   Math.round(c.end   * 1000),
+    text:    c.text,
+    speakerId: c.speaker || null,
+  }));
+}
+
+// ─── Main Azure pipeline ───────────────────────────────────────────────────
+
+async function asrAzure({ apiBase, token, input, lang, format, output: userOutput, opts, tempFiles }) {
+  if (!input) {
+    throw new Error(
+      'Azure engine requires --input <file>. URL and microphone input ' +
+      'will be supported in a follow-up.'
+    );
+  }
+  let localFile = path.resolve(input);
+  if (!fs.existsSync(localFile)) throw new Error(`Input file not found: ${localFile}`);
+
+  console.log('\n=== VoxFlow ASR (Azure Batch) ===');
+  console.log(`Input:    ${path.basename(localFile)}`);
+
+  const bcp47 = toBcp47(lang);
+  console.log(`Language: ${bcp47}`);
+  console.log(`Format:   ${format}`);
+
+  // Probe duration
+  const info = await getMediaInfo(localFile);
+  if (!info.hasAudio) throw new Error('Input file has no audio track.');
+  const durationSec = Math.max(1, Math.round(info.durationMs / 1000));
+  const sourceFilename = path.basename(localFile);
+  let sourceSize = fs.statSync(localFile).size;
+  console.log(`Duration: ${formatDuration(info.durationMs)}`);
+  console.log(`Size:     ${formatSize(sourceSize)}`);
+
+  // Extract to 16k mono WAV
+  try {
+    console.log(`\n[1/4] Extract audio (16kHz mono WAV)...`);
+    const extracted = await extractAudioForAsr(localFile);
+    tempFiles.push(extracted.wavPath);
+    localFile = extracted.wavPath;
+    sourceSize = fs.statSync(localFile).size;
+    console.log(`    OK (${formatSize(sourceSize)})`);
+  } catch (err) {
+    console.log(`    ffmpeg unavailable, uploading original (${err.message})`);
+  }
+
+  // Upload to R2
+  console.log(`\n[2/4] Upload to Cloudflare R2...`);
+  let lastPercent = -1;
+  const { key, mode } = await uploadToR2({
+    filePath: localFile, apiBase, token,
+    onProgress: ({ uploaded, total, partNumber, partCount }) => {
+      const pct = Math.floor((uploaded / total) * 100);
+      if (pct !== lastPercent) {
+        process.stdout.write(`\r    ${pct}% (${formatSize(uploaded)}/${formatSize(total)}, part ${partNumber}/${partCount})  `);
+        lastPercent = pct;
+      }
+    }
+  });
+  process.stdout.write('\n');
+  console.log(`    OK (${mode}, key=${key})`);
+
+  // Create job
+  console.log(`\n[3/4] Create transcription job...`);
+  let job = await azureClient.createJob({
+    apiBase, token,
+    sourceKey: key,
+    sourceFilename,
+    sourceSize,
+    durationSec,
+    language: bcp47,
+    options: {
+      wordTimestamps: true,
+      diarize: !!opts.diarize,
+      speakerCount: opts.speakerNumber || undefined
+    }
+  });
+  console.log(`    OK (jobId=${job.id})`);
+
+  // Persist locally
+  azureStore.saveJob(job.id, {
+    createdAt: job.created_at,
+    status: job.status,
+    source: { path: input, filename: sourceFilename, durationSec },
+    language: bcp47
+  });
+  try { azureStore.pruneTerminal(); } catch { /* ignore */ }
+
+  // Poll until terminal
+  console.log(`\n[4/4] Wait for transcription (Ctrl+C is safe — job persists)`);
+  const startTime = Date.now();
+  let lastStatus = null;
+  job = await azureClient.waitForTerminal({
+    apiBase, token, jobId: job.id,
+    onProgress: (j) => {
+      azureStore.saveJob(j.id, {
+        createdAt: j.created_at,
+        status: j.status,
+        source: { path: input, filename: sourceFilename, durationSec },
+        language: bcp47
+      });
+      if (j.status !== lastStatus || j.progress !== job.progress) {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        process.stdout.write(`\r    ${j.status} ${j.progress || 0}% (${elapsed}s)        `);
+        lastStatus = j.status;
+        job = j;
+      }
+    }
+  });
+  process.stdout.write('\n');
+
+  if (job.status !== 'succeeded') {
+    azureStore.saveJob(job.id, {
+      createdAt: job.created_at,
+      status: job.status,
+      source: { path: input, filename: sourceFilename, durationSec },
+      language: bcp47
+    });
+    throw new Error(
+      `Job ${job.status}: ${job.error_message || job.error_code || 'unknown error'}`
+    );
+  }
+
+  return finalizeAzureOutput({
+    job, input, format, output: userOutput, durationMs: info.durationMs
+  });
+}
+
+// ─── Resume existing Azure job ─────────────────────────────────────────────
+
+async function asrAzureResume({ apiBase, token, jobId, format, output }) {
+  console.log(`\n=== VoxFlow ASR — Resume Azure Job ===`);
+  console.log(`Job ID:   ${jobId}`);
+  const startTime = Date.now();
+  let lastStatus = null;
+  const job = await azureClient.waitForTerminal({
+    apiBase, token, jobId,
+    onProgress: (j) => {
+      if (j.status !== lastStatus) {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        process.stdout.write(`\r  ${j.status} ${j.progress || 0}% (${elapsed}s)        `);
+        lastStatus = j.status;
+      }
+    }
+  });
+  process.stdout.write('\n');
+  if (job.status !== 'succeeded') {
+    throw new Error(
+      `Job ${job.status}: ${job.error_message || job.error_code || 'unknown error'}`
+    );
+  }
+  azureStore.saveJob(job.id, {
+    createdAt: job.created_at, status: job.status,
+    source: { filename: job.source_filename }, language: job.language
+  });
+  return finalizeAzureOutput({ job, format, output });
+}
+
+// ─── Finalize Azure output ─────────────────────────────────────────────────
+
+function finalizeAzureOutput({ job, input, format, output: userOutput, durationMs }) {
+  const captions = azureSegmentsToCaptions(job.result_json?.segments || []);
+  let outputContent;
+  switch (format) {
+    case 'srt':  outputContent = formatSrt(captions); break;
+    case 'txt':  outputContent = formatPlainText(captions, { includeSpeakers: true }); break;
+    case 'json': outputContent = formatJson(captions); break;
+    default:     throw new Error(`Unknown format: ${format}`);
+  }
+
+  const ext = FORMAT_EXTENSIONS[format] || '.txt';
+  let outputPath;
+  if (userOutput) {
+    outputPath = path.resolve(userOutput);
+  } else if (input) {
+    const base = path.basename(input, path.extname(input));
+    const fname = base + ext;
+    outputPath = path.resolve(path.dirname(input), fname);
+  } else {
+    const fname = 'asr-' + job.id + ext;
+    outputPath = path.resolve(fname);
+  }
+  fs.writeFileSync(outputPath, outputContent, 'utf8');
+
+  const realDuration = job.result_duration_sec
+    ? Math.round(job.result_duration_sec * 1000)
+    : durationMs || 0;
+
+  console.log(`\n=== Done ===`);
+  console.log(`Output:     ${outputPath}`);
+  console.log(`Captions:   ${captions.length}`);
+  console.log(`Duration:   ${formatDuration(realDuration)}`);
+  console.log(`Engine:     azure`);
+  console.log(`Job ID:     ${job.id}`);
+  console.log(`Quota:      ${job.quota_charged} charged`);
+
+  if (captions.length > 0 && format !== 'json') {
+    console.log(`\n--- Preview ---`);
+    for (const cap of captions.slice(0, 3)) {
+      const ts = formatDuration(cap.startMs);
+      const speaker = cap.speakerId ? `[${cap.speakerId}] ` : '';
+      const snippet = cap.text.length > 60 ? `${cap.text.slice(0, 57)}...` : cap.text;
+      console.log(`  ${ts}  ${speaker}${snippet}`);
+    }
+    if (captions.length > 3) console.log(`  ... (${captions.length - 3} more)`);
+  }
+
+  return {
+    outputPath,
+    mode: 'azure',
+    duration: realDuration / 1000,
+    captionCount: captions.length,
+    jobId: job.id,
+    quotaUsed: job.quota_charged || 0
+  };
+}
+
+module.exports = {
+  asrAzure,
+  asrAzureResume,
+  finalizeAzureOutput,
+  azureSegmentsToCaptions,
+  joinWords,
+  splitSegmentByWords,
+};