verbalcoding 0.2.12 → 0.2.13

package/app-node/discord_command_router.mjs

@@ -0,0 +1,204 @@
+// Discord text-channel command dispatcher. Replaces the big inline
+// `client.on('messageCreate', ...)` body that used to live in main.mjs.
+//
+// Phase 6b extraction. The dispatcher is a single async function that
+// recognises the `!`-prefixed control commands (ping, verbose, notify,
+// smart-progress, sensitivity, session, latency, join/leave, say,
+// voice-test, voice-clone, ask) and falls through to either the
+// project-session router or the agent-text path.
+//
+// Commands are expressed as a small ordered table; adding a new command
+// is a table edit, not a new `if` branch in main.mjs.
+
+import { appendRecentDiscordText, shouldRouteDiscordTextToAgent } from './text_routing.mjs';
+import { parseProjectSessionCommand } from './project_sessions.mjs';
+
+export function createDiscordCommandRouter(deps) {
+  const {
+    bridge,
+    settings,
+    warn,
+    path,
+    ROOT,
+    isAllowed,
+    handleProjectSessionCommand,
+    handleTextAgentMessage,
+    resolveProjectSessionForChannel,
+    // Status & toggles
+    verboseStatusText,
+    setVerboseProgress,
+    notifyStatusText,
+    smartProgressStatusText,
+    sensitivityStatusText,
+    setSensitivityMode,
+    // Latency metrics
+    summarizeLatencyRecords,
+    readJsonlRecords,
+    formatLatencySummary,
+    // Voice channel control
+    connectTo,
+    // TTS / audio helpers
+    synthTTS,
+    playAudio,
+    speakText,
+    // Voice clone capture state
+    voiceCloneCapture,
+  } = deps;
+
+  // Build the command table once. Entries are matched in order; the first
+  // matching entry consumes the message. Each `match` is either a string,
+  // an array of strings (case-insensitive), or a function (content => bool).
+  // Each handler is `async (msg, content) => void`.
+  const commands = [
+    { match: '!ping', handler: async msg => { await msg.reply('pong'); } },
+
+    { match: '!verbose', handler: async msg => { await msg.reply(verboseStatusText()); } },
+    { match: ['!verbose on', '!verbose true', '!verbose 1', '!verbose 켜', '!verbose 켜줘'],
+      handler: async msg => { setVerboseProgress(true, 'discord-command'); await msg.reply(verboseStatusText()); } },
+    { match: ['!verbose off', '!verbose false', '!verbose 0', '!verbose 꺼', '!verbose 꺼줘'],
+      handler: async msg => { setVerboseProgress(false, 'discord-command'); await msg.reply(verboseStatusText()); } },
+
+    { match: '!notify', handler: async msg => { await msg.reply(notifyStatusText()); } },
+    { match: ['!notify on', '!notify always', '!notify 1'],
+      handler: async msg => { bridge.notifyUserOptIn = true; await msg.reply(notifyStatusText()); } },
+    { match: ['!notify off', '!notify auto', '!notify 0'],
+      handler: async msg => { bridge.notifyUserOptIn = false; await msg.reply(notifyStatusText()); } },
+
+    { match: c => c === '!smart-progress' || c === '!smart_progress',
+      handler: async msg => { await msg.reply(smartProgressStatusText()); } },
+    { match: ['!smart-progress on', '!smart-progress true', '!smart-progress 1', '!smart_progress on'],
+      handler: async msg => { bridge.smartProgressEnabled = true; await msg.reply(smartProgressStatusText()); } },
+    { match: ['!smart-progress off', '!smart-progress false', '!smart-progress 0', '!smart_progress off'],
+      handler: async msg => { bridge.smartProgressEnabled = false; await msg.reply(smartProgressStatusText()); } },
+
+    { match: '!sensitivity', handler: async msg => { await msg.reply(sensitivityStatusText()); } },
+    { match: '!sensitivity conservative',
+      handler: async msg => { setSensitivityMode('conservative', 'discord-command'); await msg.reply(sensitivityStatusText()); } },
+    { match: '!sensitivity normal',
+      handler: async msg => { setSensitivityMode('normal', 'discord-command'); await msg.reply(sensitivityStatusText()); } },
+
+    { match: c => c === '!latency' || c === '!metrics',
+      handler: async msg => {
+        const summary = summarizeLatencyRecords(readJsonlRecords(settings.latencyLogPath, { limit: 200 }));
+        await msg.reply(`최근 latency 요약 (${settings.latencyLogPath}):\n${formatLatencySummary(summary)}`.slice(0, 1900));
+      } },
+
+    { match: '!session', handler: async msg => { await handleProjectSessionCommand(msg, { action: 'status' }); } },
+    { match: '!reset-session', handler: async msg => { await handleProjectSessionCommand(msg, { action: 'reset' }); } },
+
+    { match: '!join',
+      handler: async msg => {
+        const ch = msg.member?.voice?.channel;
+        if (!ch) { await msg.reply('먼저 음성 채널에 들어가줘.'); return; }
+        await connectTo(ch);
+        await msg.reply('들어왔어. Node receiver로 듣는 중.');
+      } },
+    { match: '!leave',
+      handler: async msg => {
+        try { bridge.connection?.destroy(); } catch {}
+        bridge.connection = null;
+        bridge.activeVoiceChannelId = '';
+        await msg.reply('나갈게.');
+      } },
+
+    { match: c => c.startsWith('!say '),
+      handler: async (_msg, content) => {
+        const text = content.slice(5).trim();
+        const mp3 = await synthTTS(text);
+        await playAudio(mp3);
+      } },
+
+    { match: c => c.startsWith('!voice-test '),
+      handler: async (msg, content) => {
+        const text = content.slice('!voice-test '.length).trim();
+        if (!text) { await msg.reply('테스트할 문장을 붙여줘.'); return; }
+        const started = Date.now();
+        try {
+          await msg.reply(`TTS 백엔드 ${bridge.ttsBackend.name}로 음성 테스트할게.`);
+          await speakText(text);
+          await msg.channel.send(`음성 테스트 완료: ${bridge.ttsBackend.name}, ${Date.now() - started}ms`);
+        } catch (e) {
+          warn('voice-test failed', e?.stack || e);
+          await msg.channel.send(`음성 테스트 실패: ${String(e?.message || e).slice(0, 700)}`);
+        }
+      } },
+
+    { match: c => c === '!voice-clone' || c === '!voice-clone status',
+      handler: async msg => {
+        const current = voiceCloneCapture.current();
+        if (current?.userId === String(msg.author.id)) {
+          await msg.reply(`다음 유효한 음성을 ${path.relative(ROOT, current.targetPath)}에 저장할게.`);
+          return;
+        }
+        await msg.reply('대기 중인 보이스 클로닝 샘플 캡처가 없어. `!voice-clone capture`로 시작해.');
+      } },
+    { match: '!voice-clone cancel',
+      handler: async msg => {
+        const cancelled = voiceCloneCapture.cancel(msg.author.id);
+        await msg.reply(cancelled ? '보이스 클로닝 샘플 캡처를 취소했어.' : '대기 중인 캡처가 없어.');
+      } },
+    { match: '!voice-clone capture',
+      handler: async msg => {
+        const armed = voiceCloneCapture.arm({ userId: msg.author.id, source: 'discord-command' });
+        await msg.reply(`다음 유효한 음성을 ${path.relative(ROOT, armed.targetPath)}에 저장할게. 음성 채널에서 10~30초 정도 말해줘.`);
+      } },
+
+    { match: c => c.startsWith('!ask '),
+      handler: async (msg, content) => {
+        const text = content.slice(5).trim();
+        if (!text) { await msg.reply('물어볼 내용을 붙여줘.'); return; }
+        await handleTextAgentMessage(msg, text, { speakResponse: true });
+      } },
+  ];
+
+  function matches(rule, lowered, raw) {
+    if (typeof rule === 'string') return raw === rule;
+    if (Array.isArray(rule)) return rule.includes(lowered);
+    if (typeof rule === 'function') return rule(raw);
+    return false;
+  }
+
+  async function handleDiscordMessage(msg) {
+    const content = msg.content.trim();
+    if (msg.author.bot && !content.startsWith('!say ')) return;
+    if (!msg.author.bot && !isAllowed(msg.author.id)) return;
+    appendRecentDiscordText(bridge.recentDiscordTextByChannel, {
+      channelId: msg.channelId,
+      authorLabel: msg.member?.displayName || msg.author?.username || 'user',
+      content,
+      messageId: msg.id,
+    });
+
+    // Project-session commands (e.g. !session attach-voice ...) take priority.
+    const projectSessionCommand = parseProjectSessionCommand(content);
+    if (projectSessionCommand) {
+      try {
+        await handleProjectSessionCommand(msg, projectSessionCommand);
+      } catch (e) {
+        warn('project session command failed', e?.stack || e);
+        await msg.reply(String(e?.message || e).slice(0, 700));
+      }
+      return;
+    }
+
+    const lowered = content.toLowerCase();
+    for (const cmd of commands) {
+      if (matches(cmd.match, lowered, content)) {
+        await cmd.handler(msg, content);
+        return;
+      }
+    }
+
+    // Fallback: route to the agent if the heuristic says so OR if the
+    // channel is bound to a project session.
+    if (shouldRouteDiscordTextToAgent({
+      content,
+      channelId: msg.channelId,
+      transcriptChannelId: settings.transcriptChannelId,
+    }) || resolveProjectSessionForChannel(msg.channelId)) {
+      await handleTextAgentMessage(msg, content, { speakResponse: false });
+    }
+  }
+
+  return { handleDiscordMessage };
+}

package/app-node/discord_command_router.test.mjs

@@ -0,0 +1,311 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createDiscordCommandRouter } from './discord_command_router.mjs';
+import { createBridge } from './bridge_context.mjs';
+
+const noop = () => {};
+const noopAsync = async () => {};
+
+// Construct a minimal `msg` stand-in. Each test passes the `content` it
+// wants to dispatch and inspects what handlers were called.
+function makeMsg({ content, authorId = 'allowed-user', bot = false, channelId = 'tx-ch' } = {}) {
+  const replies = [];
+  const sends = [];
+  return {
+    content,
+    author: { id: authorId, bot, username: 'tester' },
+    member: { displayName: 'Tester', voice: { channel: null } },
+    channelId,
+    id: 'msg-1',
+    channel: { send: async t => { sends.push(t); } },
+    reply: async t => { replies.push(t); },
+    guild: null,
+    _replies: replies,
+    _sends: sends,
+  };
+}
+
+function makeRouter(overrides = {}) {
+  const bridge = createBridge();
+  // !voice-test reads `bridge.ttsBackend.name` in its reply template, so the
+  // bridge needs a non-null ttsBackend stub for tests that exercise that path.
+  bridge.ttsBackend = { name: 'fake' };
+  const calls = {
+    handleProjectSessionCommand: [],
+    handleTextAgentMessage: [],
+    setVerboseProgress: [],
+    setSensitivityMode: [],
+    connectTo: [],
+    synthTTS: [],
+    playAudio: [],
+    speakText: [],
+    voiceCloneArm: [],
+    voiceCloneCancel: [],
+  };
+  const deps = {
+    bridge,
+    settings: { transcriptChannelId: 'tx-ch', latencyLogPath: '/tmp/lat.jsonl' },
+    log: noop, warn: noop,
+    path: { relative: (_root, p) => p, join: (...a) => a.join('/') },
+    ROOT: '/tmp/vc',
+    isAllowed: () => true,
+    handleProjectSessionCommand: async (msg, cmd) => { calls.handleProjectSessionCommand.push(cmd); },
+    handleTextAgentMessage: async (msg, text, opts) => { calls.handleTextAgentMessage.push({ text, opts }); },
+    resolveProjectSessionForChannel: () => null,
+    verboseStatusText: () => 'verbose=off',
+    setVerboseProgress: (v, reason) => { calls.setVerboseProgress.push({ v, reason }); },
+    notifyStatusText: () => 'notify-status',
+    smartProgressStatusText: () => 'smart-progress=off',
+    sensitivityStatusText: () => 'sensitivity=normal',
+    setSensitivityMode: (mode, reason) => { calls.setSensitivityMode.push({ mode, reason }); return { mode }; },
+    summarizeLatencyRecords: () => ({ ok: 0 }),
+    readJsonlRecords: () => [],
+    formatLatencySummary: () => 'no data',
+    connectTo: async ch => { calls.connectTo.push(ch); },
+    synthTTS: async t => { calls.synthTTS.push(t); return '/tmp/x.wav'; },
+    playAudio: async f => { calls.playAudio.push(f); },
+    speakText: async t => { calls.speakText.push(t); },
+    voiceCloneCapture: {
+      current: () => null,
+      arm: ({ userId, source }) => { calls.voiceCloneArm.push({ userId, source }); return { targetPath: '/tmp/sample.wav' }; },
+      cancel: uid => { calls.voiceCloneCancel.push(uid); return false; },
+    },
+    ...overrides,
+  };
+  const router = createDiscordCommandRouter(deps);
+  return { router, bridge, calls, deps };
+}
+
+test('createDiscordCommandRouter exposes handleDiscordMessage', () => {
+  const { router } = makeRouter();
+  assert.equal(typeof router.handleDiscordMessage, 'function');
+});
+
+test('ignores bot messages (except !say) and disallowed users', async () => {
+  const { router, calls } = makeRouter({ isAllowed: () => false });
+  await router.handleDiscordMessage(makeMsg({ content: '!ping', authorId: 'x' }));
+  assert.equal(calls.handleProjectSessionCommand.length, 0);
+  // Now allow the user; bot=true means we still skip non-!say messages.
+  const { router: r2, calls: c2 } = makeRouter();
+  const m = makeMsg({ content: 'hello there', bot: true });
+  await r2.handleDiscordMessage(m);
+  assert.equal(c2.handleTextAgentMessage.length, 0);
+});
+
+test('!ping replies pong', async () => {
+  const { router } = makeRouter();
+  const msg = makeMsg({ content: '!ping' });
+  await router.handleDiscordMessage(msg);
+  assert.deepEqual(msg._replies, ['pong']);
+});
+
+test('!verbose status and toggles', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!verbose' }));
+  await router.handleDiscordMessage(makeMsg({ content: '!verbose on' }));
+  await router.handleDiscordMessage(makeMsg({ content: '!verbose off' }));
+  await router.handleDiscordMessage(makeMsg({ content: '!verbose 켜줘' }));
+  await router.handleDiscordMessage(makeMsg({ content: '!verbose 꺼' }));
+  assert.deepEqual(calls.setVerboseProgress, [
+    { v: true, reason: 'discord-command' },
+    { v: false, reason: 'discord-command' },
+    { v: true, reason: 'discord-command' },
+    { v: false, reason: 'discord-command' },
+  ]);
+});
+
+test('!notify toggles bridge.notifyUserOptIn', async () => {
+  const { router, bridge } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!notify on' }));
+  assert.equal(bridge.notifyUserOptIn, true);
+  await router.handleDiscordMessage(makeMsg({ content: '!notify off' }));
+  assert.equal(bridge.notifyUserOptIn, false);
+  await router.handleDiscordMessage(makeMsg({ content: '!notify 1' }));
+  assert.equal(bridge.notifyUserOptIn, true);
+});
+
+test('!smart-progress toggles bridge.smartProgressEnabled', async () => {
+  const { router, bridge } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!smart-progress on' }));
+  assert.equal(bridge.smartProgressEnabled, true);
+  await router.handleDiscordMessage(makeMsg({ content: '!smart_progress off' }));
+  assert.equal(bridge.smartProgressEnabled, false);
+});
+
+test('!sensitivity conservative/normal call setSensitivityMode', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!sensitivity conservative' }));
+  await router.handleDiscordMessage(makeMsg({ content: '!sensitivity normal' }));
+  assert.deepEqual(calls.setSensitivityMode, [
+    { mode: 'conservative', reason: 'discord-command' },
+    { mode: 'normal', reason: 'discord-command' },
+  ]);
+});
+
+test('!join calls connectTo with the member voice channel', async () => {
+  const { router, calls } = makeRouter();
+  const ch = { id: 'vc-1', guild: { name: 'g' }, name: 'general' };
+  const msg = makeMsg({ content: '!join' });
+  msg.member.voice.channel = ch;
+  await router.handleDiscordMessage(msg);
+  assert.equal(calls.connectTo.length, 1);
+  assert.equal(calls.connectTo[0], ch);
+});
+
+test('!join without member voice channel replies a hint', async () => {
+  const { router, calls } = makeRouter();
+  const msg = makeMsg({ content: '!join' });
+  await router.handleDiscordMessage(msg);
+  assert.equal(calls.connectTo.length, 0);
+  assert.match(msg._replies[0], /음성 채널/);
+});
+
+test('!leave destroys the active voice connection', async () => {
+  const { router, bridge } = makeRouter();
+  let destroyed = false;
+  bridge.connection = { destroy: () => { destroyed = true; } };
+  bridge.activeVoiceChannelId = 'vc-1';
+  await router.handleDiscordMessage(makeMsg({ content: '!leave' }));
+  assert.equal(destroyed, true);
+  assert.equal(bridge.connection, null);
+  assert.equal(bridge.activeVoiceChannelId, '');
+});
+
+test('!say synths + plays the trailing text', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!say hello world' }));
+  assert.deepEqual(calls.synthTTS, ['hello world']);
+  assert.deepEqual(calls.playAudio, ['/tmp/x.wav']);
+});
+
+test('!voice-clone capture arms the capture state', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!voice-clone capture', authorId: 'u1' }));
+  assert.equal(calls.voiceCloneArm.length, 1);
+  assert.equal(calls.voiceCloneArm[0].userId, 'u1');
+});
+
+test('!voice-clone cancel calls cancel(userId)', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!voice-clone cancel', authorId: 'u1' }));
+  assert.deepEqual(calls.voiceCloneCancel, ['u1']);
+});
+
+test('!ask routes trailing text to handleTextAgentMessage with speakResponse:true', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!ask what time is it' }));
+  assert.equal(calls.handleTextAgentMessage.length, 1);
+  assert.equal(calls.handleTextAgentMessage[0].text, 'what time is it');
+  assert.equal(calls.handleTextAgentMessage[0].opts.speakResponse, true);
+});
+
+test('project-session command takes priority over !-prefixed commands', async () => {
+  // parseProjectSessionCommand is imported by the router from
+  // ./project_sessions.mjs; we can't easily monkey-patch the import here,
+  // but we can prove the priority by checking that a command pattern
+  // recognised as a session command never reaches !ping.
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!session' }));
+  // !session is handled as a !-command via the table (handleProjectSessionCommand
+  // with action=status). Either way the project session handler is called.
+  assert.equal(calls.handleProjectSessionCommand.length, 1);
+  assert.equal(calls.handleProjectSessionCommand[0].action, 'status');
+});
+
+test('fallback routes plain text to handleTextAgentMessage when channel is project-bound', async () => {
+  const { router, calls } = makeRouter({
+    resolveProjectSessionForChannel: () => ({ slug: 'my-project' }),
+  });
+  await router.handleDiscordMessage(makeMsg({ content: 'hello agent' }));
+  assert.equal(calls.handleTextAgentMessage.length, 1);
+  assert.equal(calls.handleTextAgentMessage[0].text, 'hello agent');
+  assert.equal(calls.handleTextAgentMessage[0].opts.speakResponse, false);
+});
+
+test('fallback does NOT route non-project text without an explicit trigger', async () => {
+  const { router, calls } = makeRouter();
+  // Use a channel that is neither the transcript channel nor project-bound,
+  // so neither leg of the routing heuristic triggers.
+  await router.handleDiscordMessage(makeMsg({ content: 'just some chatter', channelId: 'unrelated-channel' }));
+  assert.equal(calls.handleTextAgentMessage.length, 0, 'no agent dispatch for non-bound channel');
+});
+
+test('!latency / !metrics build a summary from the jsonl log', async () => {
+  let summarizeArg = null;
+  let formatted = null;
+  const { router } = makeRouter({
+    readJsonlRecords: () => [{ status: 'ok' }],
+    summarizeLatencyRecords: rs => { summarizeArg = rs; return { ok: rs.length }; },
+    formatLatencySummary: s => { formatted = s; return 'summary text'; },
+  });
+  const msg = makeMsg({ content: '!latency' });
+  await router.handleDiscordMessage(msg);
+  assert.equal(summarizeArg.length, 1, 'summarize ran on the parsed records');
+  assert.deepEqual(formatted, { ok: 1 });
+  assert.match(msg._replies[0], /summary text/);
+
+  const msg2 = makeMsg({ content: '!metrics' });
+  await router.handleDiscordMessage(msg2);
+  assert.match(msg2._replies[0], /summary text/, '!metrics is an alias for !latency');
+});
+
+test('!reset-session dispatches to project session handler with action=reset', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!reset-session' }));
+  assert.deepEqual(calls.handleProjectSessionCommand, [{ action: 'reset' }]);
+});
+
+test('!voice-test logs a success line on happy path', async () => {
+  const { router } = makeRouter();
+  const msg = makeMsg({ content: '!voice-test 안녕하세요' });
+  await router.handleDiscordMessage(msg);
+  // First reply announces the test; then a send confirms completion.
+  assert.ok(msg._replies.some(t => /TTS 백엔드.*음성 테스트/.test(t)));
+  assert.ok(msg._sends.some(t => /음성 테스트 완료/.test(t)));
+});
+
+test('!voice-test reports failure to the channel when speakText throws', async () => {
+  const warnCalls = [];
+  const { router } = makeRouter({
+    warn: (...args) => warnCalls.push(args),
+    speakText: async () => { throw new Error('synth boom'); },
+  });
+  const msg = makeMsg({ content: '!voice-test fail-me' });
+  await router.handleDiscordMessage(msg);
+  assert.ok(msg._sends.some(t => /음성 테스트 실패.*synth boom/.test(t)));
+  assert.ok(warnCalls.some(args => /voice-test failed/.test(args[0])));
+});
+
+// Note on the !voice-test "empty text" branch: handleDiscordMessage does
+// `content = msg.content.trim()` before matching, so `!voice-test ` collapses
+// to `!voice-test` which fails the `c.startsWith('!voice-test ')` predicate.
+// The empty-text branch inside the handler is therefore unreachable; the
+// behaviour predates the refactor (HEAD 575870b had the same shape). Not
+// covered by a test on purpose.
+
+test('bot author can still trigger !say (carve-out)', async () => {
+  const { router, calls } = makeRouter();
+  await router.handleDiscordMessage(makeMsg({ content: '!say hi from bot', bot: true }));
+  assert.deepEqual(calls.synthTTS, ['hi from bot']);
+  assert.deepEqual(calls.playAudio, ['/tmp/x.wav']);
+});
+
+test('bare !voice-clone with no active capture replies a hint', async () => {
+  const { router } = makeRouter();
+  const msg = makeMsg({ content: '!voice-clone' });
+  await router.handleDiscordMessage(msg);
+  assert.match(msg._replies[0], /대기 중인 보이스 클로닝 샘플 캡처가 없어/);
+});
+
+test('!voice-clone status with an active capture reports the target path', async () => {
+  const { router } = makeRouter({
+    voiceCloneCapture: {
+      current: () => ({ userId: 'u1', targetPath: '/tmp/me.wav' }),
+      arm: () => ({ targetPath: '/tmp/me.wav' }),
+      cancel: () => false,
+    },
+  });
+  const msg = makeMsg({ content: '!voice-clone status', authorId: 'u1' });
+  await router.handleDiscordMessage(msg);
+  assert.match(msg._replies[0], /\/tmp\/me\.wav/);
+});