verbalcoding 0.2.11 → 0.2.13

package/app-node/stream_sentencer.test.mjs

@@ -0,0 +1,129 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createSentencer } from './stream_sentencer.mjs';
+
+test('emits a sentence on terminal punctuation', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Hello world. ');
+  assert.deepEqual(out, ['Hello world.']);
+});
+
+test('does not emit on partial sentence', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Reading file');
+  assert.deepEqual(out, []);
+  s.push(' main.mjs.');
+  assert.deepEqual(out, ['Reading file main.mjs.']);
+});
+
+test('strips ANSI before emitting', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('\x1b[32mDone.\x1b[0m ');
+  assert.deepEqual(out, ['Done.']);
+});
+
+test('filters VERBALCODING_PROGRESS lines', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('VERBALCODING_PROGRESS: reading files main.mjs\nAll set.');
+  s.flush();
+  assert.deepEqual(out, ['All set.']);
+});
+
+test('flush emits residual on close', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('No terminator here');
+  s.flush();
+  assert.deepEqual(out, ['No terminator here']);
+});
+
+test('strips Hermes box characters', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('│ Done.');
+  s.flush();
+  assert.deepEqual(out, ['Done.']);
+});
+
+test('emits multiple sentences in one push', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('First. Second. Third.');
+  assert.deepEqual(out, ['First.', 'Second.', 'Third.']);
+});
+
+test('does not split on common abbreviations', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Use e.g. main.mjs for the entry point. ');
+  assert.deepEqual(out, ['Use e.g. main.mjs for the entry point.']);
+});
+
+test('treats decimals as one sentence', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Version 3.14 is out. ');
+  assert.deepEqual(out, ['Version 3.14 is out.']);
+});
+
+test('drops fenced code blocks from speech', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Here is the change. ```js\nconst x = 1;\n``` Done.');
+  s.flush();
+  assert.deepEqual(out, ['Here is the change.', 'Done.']);
+});
+
+test('detects fence marker split 1+1+1 backticks across three pushes', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Open fence. `');
+  s.push('`');
+  s.push('`python\nconst x = 1\n```\nClosed.');
+  s.flush();
+  assert.deepEqual(out, ['Open fence.', 'Closed.']);
+});
+
+test('detects fence marker split across pushes', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Open fence. ``');
+  s.push('`python\nconst x = 1\n``');
+  s.push('` Closed.');
+  s.flush();
+  assert.deepEqual(out, ['Open fence.', 'Closed.']);
+});
+
+test('keeps fence state across pushes', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('Open fence. ```python\nimport os');
+  s.push('\nprint(os.getcwd())\n``` Closed.');
+  s.flush();
+  assert.deepEqual(out, ['Open fence.', 'Closed.']);
+});
+
+test('terminates on Korean closing quote', () => {
+  const out = [];
+  const s = createSentencer({ minChars: 1, maxLatencyMs: 999999 });
+  s.on('sentence', t => out.push(t));
+  s.push('그가 말했다. "안녕." ');
+  assert.deepEqual(out, ['그가 말했다.', '"안녕."']);
+});

package/app-node/streaming_tts_queue.mjs

@@ -0,0 +1,52 @@
+export function createStreamingTTSQueue({ synth, play, signal, cleanup, log = () => {}, onSynthError = null } = {}) {
+  if (typeof synth !== 'function') throw new Error('synth is required');
+  if (typeof play !== 'function') throw new Error('play is required');
+
+  const queue = [];
+  let pumping = null;
+  let droppedCount = 0;
+
+  async function pump() {
+    while (queue.length && !signal?.aborted) {
+      const text = queue.shift();
+      let file;
+      try {
+        file = await synth(text);
+      } catch (e) {
+        log('streaming tts synth failed', e?.message || e);
+        droppedCount += 1;
+        try { onSynthError?.({ text, error: e, droppedCount }); } catch {}
+        continue;
+      }
+      if (!file) continue;
+      if (signal?.aborted) {
+        try { await cleanup?.(file); } catch {}
+        return;
+      }
+      try {
+        await play(file);
+      } catch (e) {
+        if (signal?.aborted) {
+          try { await cleanup?.(file); } catch {}
+          return;
+        }
+        log('streaming tts play failed', e?.message || e);
+      }
+      try { await cleanup?.(file); } catch {}
+    }
+  }
+
+  return {
+    enqueue(text) {
+      const trimmed = String(text || '').trim();
+      if (!trimmed || signal?.aborted) return;
+      queue.push(trimmed);
+      if (!pumping) pumping = pump().finally(() => { pumping = null; });
+    },
+    async drain() {
+      while (pumping) await pumping;
+    },
+    get size() { return queue.length; },
+    get droppedCount() { return droppedCount; },
+  };
+}

package/app-node/streaming_tts_queue.test.mjs

@@ -0,0 +1,64 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createStreamingTTSQueue } from './streaming_tts_queue.mjs';
+
+test('synths and plays in enqueue order', async () => {
+  const order = [];
+  const q = createStreamingTTSQueue({
+    synth: async (t) => { order.push(`synth:${t}`); return `f-${t}`; },
+    play: async (f) => { order.push(`play:${f}`); },
+  });
+  q.enqueue('A.');
+  q.enqueue('B.');
+  await q.drain();
+  assert.deepEqual(order, ['synth:A.', 'play:f-A.', 'synth:B.', 'play:f-B.']);
+});
+
+test('abort stops further playback', async () => {
+  const ctrl = new AbortController();
+  const order = [];
+  const q = createStreamingTTSQueue({
+    synth: async (t) => `f-${t}`,
+    play: async (f) => { order.push(`play:${f}`); if (f === 'f-A.') ctrl.abort(); },
+    signal: ctrl.signal,
+  });
+  q.enqueue('A.');
+  q.enqueue('B.');
+  await q.drain();
+  assert.deepEqual(order, ['play:f-A.']);
+});
+
+test('cleanup runs after play', async () => {
+  const cleaned = [];
+  const q = createStreamingTTSQueue({
+    synth: async (t) => `f-${t}`,
+    play: async () => {},
+    cleanup: async (f) => { cleaned.push(f); },
+  });
+  q.enqueue('A.');
+  await q.drain();
+  assert.deepEqual(cleaned, ['f-A.']);
+});
+
+test('synth error skips that sentence but continues, and reports dropped count + onSynthError', async () => {
+  const played = [];
+  const errors = [];
+  const q = createStreamingTTSQueue({
+    synth: async (t) => { if (t === 'A.') throw new Error('boom'); return `f-${t}`; },
+    play: async (f) => { played.push(f); },
+    onSynthError: ev => errors.push(ev),
+  });
+  q.enqueue('A.');
+  q.enqueue('B.');
+  await q.drain();
+  assert.deepEqual(played, ['f-B.']);
+  assert.equal(q.droppedCount, 1);
+  assert.equal(errors.length, 1);
+  assert.equal(errors[0].text, 'A.');
+  assert.match(errors[0].error.message, /boom/);
+});
+
+test('throws when synth or play missing', () => {
+  assert.throws(() => createStreamingTTSQueue({ play: async () => {} }), /synth is required/);
+  assert.throws(() => createStreamingTTSQueue({ synth: async () => {} }), /play is required/);
+});

package/app-node/stt_whisper.mjs

@@ -0,0 +1,24 @@
+export const DEFAULT_WHISPER_TIMEOUT_MS = 90000;
+
+export function parsePositiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+
+export function whisperTimeoutMs(env = process.env) {
+  return parsePositiveInt(env.WHISPER_CPP_TIMEOUT_MS || env.WHISPER_TIMEOUT_MS, DEFAULT_WHISPER_TIMEOUT_MS);
+}
+
+export function whisperFailureMessage(error) {
+  const signal = error?.signal ? `signal ${error.signal}` : '';
+  const code = error?.code !== undefined && error?.code !== null ? `code ${error.code}` : '';
+  const killed = error?.killed ? 'killed' : '';
+  const message = String(error?.message || '').trim();
+  const stderr = String(error?.stderr || '').trim();
+  const stdout = String(error?.stdout || '').trim();
+  const detail = stderr || stdout || message || 'unknown error';
+  const tail = detail.length > 1400 ? detail.slice(-1400) : detail;
+  const prefix = [killed, signal, code].filter(Boolean).join(' ');
+  return prefix ? `${prefix}: ${tail}` : tail;
+}

package/app-node/stt_whisper.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { DEFAULT_WHISPER_TIMEOUT_MS, parsePositiveInt, whisperFailureMessage, whisperTimeoutMs } from './stt_whisper.mjs';
+
+test('whisperTimeoutMs defaults high enough for cold Metal startup plus transcription', () => {
+  assert.equal(DEFAULT_WHISPER_TIMEOUT_MS, 90000);
+  assert.equal(whisperTimeoutMs({}), 90000);
+});
+
+test('whisperTimeoutMs accepts explicit positive env override', () => {
+  assert.equal(whisperTimeoutMs({ WHISPER_CPP_TIMEOUT_MS: '120000' }), 120000);
+  assert.equal(whisperTimeoutMs({ WHISPER_TIMEOUT_MS: '45000' }), 45000);
+});
+
+test('parsePositiveInt rejects invalid timeout values', () => {
+  assert.equal(parsePositiveInt('0', 7), 7);
+  assert.equal(parsePositiveInt('-1', 7), 7);
+  assert.equal(parsePositiveInt('nope', 7), 7);
+  assert.equal(parsePositiveInt('12.8', 7), 12);
+});
+
+test('whisperFailureMessage keeps concise tail instead of dumping full backend log', () => {
+  const err = new Error('Command failed');
+  err.killed = true;
+  err.signal = 'SIGTERM';
+  err.stderr = `${'load_backend\n'.repeat(300)}final useful line`;
+  const msg = whisperFailureMessage(err);
+  assert.match(msg, /killed signal SIGTERM/);
+  assert.match(msg, /final useful line/);
+  assert.ok(msg.length < 1500);
+});

package/app-node/text_routing.mjs

@@ -6,3 +6,25 @@ export function shouldRouteDiscordTextToAgent({ content = '', channelId = '', tr
   if (!target) return true;
   return String(channelId || '') === target;
 }
+
+export function appendRecentDiscordText(state, { channelId = '', authorLabel = 'user', content = '', now = Date.now(), maxEntries = 12, messageId = '' } = {}) {
+  const id = String(channelId || '').trim();
+  const text = String(content || '').trim();
+  if (!id || !text || text.startsWith('!')) return;
+  const entries = state.get(id) || [];
+  const mid = String(messageId || '').trim();
+  if (mid && entries.some(entry => entry.messageId === mid)) return;
+  entries.push({ at: Number(now) || Date.now(), authorLabel: String(authorLabel || 'user'), content: text.slice(0, 500), messageId: mid || undefined });
+  state.set(id, entries.slice(-maxEntries));
+}
+
+export function formatRecentDiscordContext(state, { channelId = '', now = Date.now(), maxAgeMs = 10 * 60 * 1000, maxEntries = 6 } = {}) {
+  const id = String(channelId || '').trim();
+  if (!id) return '';
+  const cutoff = (Number(now) || Date.now()) - maxAgeMs;
+  const entries = (state.get(id) || [])
+    .filter(entry => Number(entry.at) >= cutoff)
+    .slice(-maxEntries);
+  if (!entries.length) return '';
+  return ['최근 텍스트 채널 메시지:', ...entries.map(entry => `- ${entry.authorLabel}: ${entry.content}`)].join('\n');
+}

package/app-node/text_routing.test.mjs

@@ -1,7 +1,11 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { shouldRouteDiscordTextToAgent } from './text_routing.mjs';
+import {
+  appendRecentDiscordText,
+  formatRecentDiscordContext,
+  shouldRouteDiscordTextToAgent,
+} from './text_routing.mjs';
 
 test('routes normal transcript-channel text to the shared agent session', () => {
   assert.equal(shouldRouteDiscordTextToAgent({
@@ -16,3 +20,21 @@ test('does not route commands or other channels to the shared agent session', ()
   assert.equal(shouldRouteDiscordTextToAgent({ content: '다른 채널 말', channelId: 'other', transcriptChannelId: 'transcript' }), false);
   assert.equal(shouldRouteDiscordTextToAgent({ content: '   ', channelId: 'transcript', transcriptChannelId: 'transcript' }), false);
 });
+
+test('formats recent Discord text context for voice turns without commands', () => {
+  const state = new Map();
+  appendRecentDiscordText(state, { channelId: 'thread', authorLabel: 'user', content: '음성채널에서만 나가줘', now: 1000 });
+  appendRecentDiscordText(state, { channelId: 'thread', authorLabel: 'user', content: '!ping', now: 1100 });
+  appendRecentDiscordText(state, { channelId: 'thread', authorLabel: 'assistant', content: '알겠어', now: 1200 });
+
+  const context = formatRecentDiscordContext(state, {
+    channelId: 'thread',
+    now: 2000,
+    maxAgeMs: 5000,
+  });
+
+  assert.match(context, /최근 텍스트 채널 메시지/);
+  assert.match(context, /user: 음성채널에서만 나가줘/);
+  assert.doesNotMatch(context, /!ping/);
+  assert.match(context, /assistant: 알겠어/);
+});