verbalcoding 0.2.12 → 0.2.13

package/app-node/session_ontology.test.mjs

@@ -0,0 +1,130 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createSessionOntology, buildExtractionPrompt, parseExtractionJson } from './session_ontology.mjs';
+
+const __tempRoots = [];
+test.after(() => {
+  for (const root of __tempRoots) try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+});
+
+function tmpDir(label) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `vc-onto-${label}-`));
+  __tempRoots.push(root);
+  return root;
+}
+
+test('add inserts nodes and dedupes by (type, lowercase name)', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('dedup'), channelKey: 'voice/1' });
+  ontology.add({ nodes: [{ t: 'D', n: 'OAUTH_PROVIDER=github' }, { t: 'D', n: 'oauth_provider=github' }] });
+  assert.equal(ontology.nodeCount, 1);
+});
+
+test('add applies supersede edges without deleting old node', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('supersede'), channelKey: 'voice/2' });
+  ontology.add({
+    nodes: [
+      { id: 'a', t: 'D', n: 'session_store=memory' },
+      { id: 'b', t: 'D', n: 'session_store=redis' },
+    ],
+    supersedes: [{ old: 'a', new: 'b' }],
+  });
+  assert.equal(ontology.nodeCount, 2);
+  const md = ontology.serializeForHandoff({ language: 'en' });
+  assert.match(md, /session_store=redis/);
+  assert.doesNotMatch(md, /session_store=memory/);
+});
+
+test('LRU eviction keeps decisions sticky', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('lru'), channelKey: 'voice/3', maxNodes: 3 });
+  ontology.add({ nodes: [{ t: 'D', n: 'a=1' }, { t: 'F', n: 'app.mjs' }, { t: 'F', n: 'lib.mjs' }] });
+  assert.equal(ontology.nodeCount, 3);
+  ontology.add({ nodes: [{ t: 'F', n: 'main.mjs' }] });
+  assert.equal(ontology.nodeCount, 3);
+  const snap = ontology.snapshot();
+  assert.ok(snap.nodes.some(n => n.t === 'D'), 'decision survives eviction');
+});
+
+test('entitiesFromText extracts files, tools, decisions', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('extract'), channelKey: 'voice/4' });
+  const out = ontology.entitiesFromText(
+    'Updated app/main.mjs and ran npm test. We settled oauth_provider=github.',
+    { by: 'claude' },
+  );
+  const types = out.nodes.map(n => n.t).sort();
+  assert.ok(types.includes('F'), 'has file node');
+  assert.ok(types.includes('T'), 'has tool node');
+  assert.ok(types.includes('D'), 'has decision node');
+  const decision = out.nodes.find(n => n.t === 'D');
+  assert.match(decision.n, /oauth_provider=github/);
+});
+
+test('serializeForHandoff returns empty marker on empty ontology', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('empty'), channelKey: 'voice/5' });
+  assert.match(ontology.serializeForHandoff({ language: 'en' }), /no prior session context/);
+  assert.match(ontology.serializeForHandoff({ language: 'ko' }), /이전 세션 컨텍스트 없음/);
+});
+
+test('serializeForHandoff groups decisions, files, tools, results', () => {
+  const ontology = createSessionOntology({ rootDir: tmpDir('serialize'), channelKey: 'voice/6' });
+  const { nodes, edges } = ontology.entitiesFromText(
+    'Touched app-node/main.mjs with git commit. oauth_provider=github decided.',
+    { by: 'claude' },
+  );
+  ontology.add({ nodes, edges });
+  ontology.add({ nodes: [{ t: 'R', n: 'OAuth wired up successfully', by: 'codex' }] });
+  const md = ontology.serializeForHandoff({ language: 'en' });
+  assert.match(md, /Active decisions/);
+  assert.match(md, /oauth_provider=github/);
+  assert.match(md, /Relevant files/);
+  assert.match(md, /main\.mjs/);
+  assert.match(md, /Recent results/);
+});
+
+test('buildExtractionPrompt mentions the schema and the message body', () => {
+  const p = buildExtractionPrompt({ text: 'Routed to codex for the auth refactor', language: 'en' });
+  assert.match(p, /JSON of shape/);
+  assert.match(p, /D=Decision/);
+  assert.match(p, /auth refactor/);
+});
+
+test('parseExtractionJson recovers JSON from fenced output', () => {
+  const raw = '```json\n{"nodes":[{"t":"D","n":"db=postgres"}],"edges":[]}\n```';
+  const out = parseExtractionJson(raw);
+  assert.equal(out.nodes.length, 1);
+  assert.equal(out.nodes[0].t, 'D');
+  assert.equal(out.nodes[0].n, 'db=postgres');
+});
+
+test('parseExtractionJson tolerates surrounding prose', () => {
+  const raw = 'Sure, here is the graph: {"nodes":[{"t":"F","n":"app.mjs"}],"edges":[]} let me know if you need more.';
+  const out = parseExtractionJson(raw);
+  assert.equal(out.nodes.length, 1);
+});
+
+test('parseExtractionJson resolves edge endpoints by name to canonical node ids', () => {
+  const raw = '{"nodes":[{"t":"D","n":"db=postgres"},{"t":"F","n":"schema.sql"}],"edges":[{"s":"db=postgres","p":"t","o":"schema.sql"}]}';
+  const out = parseExtractionJson(raw);
+  assert.equal(out.nodes.length, 2);
+  assert.equal(out.edges.length, 1);
+  assert.equal(out.edges[0].s, 'e_D_db=postgres');
+  assert.equal(out.edges[0].o, 'e_F_schema.sql');
+});
+
+test('parseExtractionJson returns empty on garbage input', () => {
+  const out = parseExtractionJson('totally not json');
+  assert.deepEqual(out, { nodes: [], edges: [] });
+});
+
+test('save/load round-trips state to disk', () => {
+  const root = tmpDir('persist');
+  const ontology = createSessionOntology({ rootDir: root, channelKey: 'voice/7' });
+  ontology.add({ nodes: [{ t: 'D', n: 'db=postgres', by: 'claude' }] });
+  assert.ok(ontology.save());
+  const restored = createSessionOntology({ rootDir: root, channelKey: 'voice/7' });
+  assert.ok(restored.load());
+  assert.equal(restored.nodeCount, 1);
+  assert.match(restored.serializeForHandoff({ language: 'en' }), /db=postgres/);
+});

package/app-node/smart_progress.mjs

@@ -23,7 +23,7 @@ export function createSmartProgressSummarizer({
   }
 
   async function summarize(events) {
-    const key = events.join('|');
+    const key = `${language}::${events.join('|')}`;
     const cached = cache.get(key);
     if (cached && Date.now() - cached.t < cacheMs) return cached.text;
     const ctl = new AbortController();

package/app-node/stream_sentencer.mjs

@@ -3,7 +3,7 @@ import { EventEmitter } from 'node:events';
 const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
 const BOX_RE = /[╭╮╰╯│┊─]/g;
 const PROGRESS_LINE_RE = /^VERBALCODING_PROGRESS\s*:.*$/i;
-const TERMINAL_RE = /[.!?。！？…]+(?=[\s"'\)\]\}]|$)/;
+const TERMINAL_RE = /(?<!\b(?:e\.g|i\.e|etc|cf|Mr|Mrs|Dr|Sr|Jr|St|Mt|vs|approx|al|aka|fig|eqn|inc|ltd|co))[.!?。！？…]+["'\)\]\}」』]*(?=\s|$)/;
 
 function clean(text) {
   return String(text || '')
@@ -18,6 +18,8 @@ function clean(text) {
 export function createSentencer({ minChars = 40, maxLatencyMs = 800 } = {}) {
   const ee = new EventEmitter();
   let buffer = '';
+  let inFence = false;
+  let pendingFenceTail = '';
   let lastEmit = Date.now();
 
   function emit(text) {
@@ -27,6 +29,31 @@ export function createSentencer({ minChars = 40, maxLatencyMs = 800 } = {}) {
     lastEmit = Date.now();
   }
 
+  function trailingBackticks(text) {
+    let n = 0;
+    for (let i = text.length - 1; i >= 0 && text[i] === '`' && n < 2; i -= 1) n += 1;
+    return n;
+  }
+
+  function ingest(text) {
+    let remaining = pendingFenceTail + text;
+    pendingFenceTail = '';
+    while (remaining.length > 0) {
+      const fence = remaining.indexOf('```');
+      if (fence === -1) {
+        const heldCount = trailingBackticks(remaining);
+        const safe = heldCount > 0 ? remaining.slice(0, remaining.length - heldCount) : remaining;
+        pendingFenceTail = heldCount > 0 ? remaining.slice(remaining.length - heldCount) : '';
+        if (!inFence) buffer += safe;
+        return;
+      }
+      const before = remaining.slice(0, fence);
+      if (!inFence) buffer += before;
+      inFence = !inFence;
+      remaining = remaining.slice(fence + 3);
+    }
+  }
+
   function scan() {
     while (true) {
       const match = buffer.match(TERMINAL_RE);
@@ -50,12 +77,15 @@ export function createSentencer({ minChars = 40, maxLatencyMs = 800 } = {}) {
     push(text) {
       const cleaned = clean(text);
       if (!cleaned) return;
-      buffer += cleaned;
+      ingest(cleaned);
       scan();
     },
     flush() {
+      if (!inFence) buffer += pendingFenceTail;
+      pendingFenceTail = '';
       emit(buffer);
       buffer = '';
+      inFence = false;
     },
   };
 }

package/app-node/stream_sentencer.test.mjs

@@ -62,3 +62,68 @@ test('emits multiple sentences in one push', () => {
   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

@@ -1,9 +1,10 @@
-export function createStreamingTTSQueue({ synth, play, signal, cleanup, log = () => {} } = {}) {
+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) {
@@ -13,6 +14,8 @@ export function createStreamingTTSQueue({ synth, play, signal, cleanup, log = ()
         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;
@@ -44,5 +47,6 @@ export function createStreamingTTSQueue({ synth, play, signal, cleanup, log = ()
       while (pumping) await pumping;
     },
     get size() { return queue.length; },
+    get droppedCount() { return droppedCount; },
   };
 }

package/app-node/streaming_tts_queue.test.mjs

@@ -40,16 +40,22 @@ test('cleanup runs after play', async () => {
   assert.deepEqual(cleaned, ['f-A.']);
 });
 
-test('synth error skips that sentence but continues', async () => {
+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', () => {

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

@@ -7,12 +7,14 @@ export function shouldRouteDiscordTextToAgent({ content = '', channelId = '', tr
   return String(channelId || '') === target;
 }
 
-export function appendRecentDiscordText(state, { channelId = '', authorLabel = 'user', content = '', now = Date.now(), maxEntries = 12 } = {}) {
+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) || [];
-  entries.push({ at: Number(now) || Date.now(), authorLabel: String(authorLabel || 'user'), content: text.slice(0, 500) });
+  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));
 }