verbalcoding 0.2.0

package/app-node/restart_notice.mjs

@@ -0,0 +1,57 @@
+export function restartNoticeLanguage(ttsVoice = '') {
+  const voice = String(ttsVoice || '').toLowerCase();
+  if (voice.startsWith('en-')) return 'en';
+  return 'ko';
+}
+
+export function cleanRestartDetail(detail = '', ttsVoice = '') {
+  const raw = String(detail || '').replace(/\s+/g, ' ').trim();
+  if (!raw) return '';
+  if (restartNoticeLanguage(ttsVoice) === 'en') {
+    return raw
+      .replace(/\b(restarting now|i'?ll restart now)\b[.!?\s]*/ig, '')
+      .replace(/\bvoice may cut out briefly\b[.!?\s]*/ig, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+  return raw
+    .replace(/이제\s*재시작할게[.!?。！？\s]*/gu, '')
+    .replace(/잠깐\s*음성이\s*끊길\s*수\s*있어[.!?。！？\s]*/gu, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function formatRestartCompleteNotice(detail = '', ttsVoice = '') {
+  const cleanDetail = cleanRestartDetail(detail, ttsVoice);
+  if (restartNoticeLanguage(ttsVoice) === 'en') {
+    return {
+      text: cleanDetail
+        ? `✅ Restart complete. I am back online. Applied: ${cleanDetail}`
+        : '✅ Restart complete. I am back online.',
+      speech: cleanDetail
+        ? `Restart complete. I am back online. ${cleanDetail}`
+        : 'Restart complete. I am back online.',
+    };
+  }
+  return {
+    text: cleanDetail
+      ? `✅ 재시작 완료. 다시 온라인이야. 적용 내용: ${cleanDetail}`
+      : '✅ 재시작 완료. 다시 온라인이야.',
+    speech: cleanDetail
+      ? `재시작 완료. 다시 온라인이야. ${cleanDetail}`
+      : '재시작 완료. 다시 온라인이야.',
+  };
+}
+
+export function formatRestartShutdownNotice(detail = '', ttsVoice = '') {
+  const cleanDetail = cleanRestartDetail(detail, ttsVoice);
+  const detailNoPeriod = cleanDetail.replace(/[.!?。！？]+$/u, '');
+  if (restartNoticeLanguage(ttsVoice) === 'en') {
+    return detailNoPeriod
+      ? `I applied this change: ${detailNoPeriod}. Restarting now. Voice may cut out briefly.`
+      : 'Restarting now. Voice may cut out briefly.';
+  }
+  return detailNoPeriod
+    ? `방금 한 작업은 ${detailNoPeriod}. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.`
+    : '방금 변경사항을 적용했어. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.';
+}

package/app-node/restart_notice.test.mjs

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { cleanRestartDetail, formatRestartCompleteNotice, formatRestartShutdownNotice } from './restart_notice.mjs';
+
+test('restart complete notice follows English TTS voice so Edge can synthesize it', () => {
+  const notice = formatRestartCompleteNotice('English speech detection fixed.', 'en-US-GuyNeural');
+  assert.equal(notice.text, '✅ Restart complete. I am back online. Applied: English speech detection fixed.');
+  assert.equal(notice.speech, 'Restart complete. I am back online. English speech detection fixed.');
+});
+
+test('restart complete notice stays Korean for Korean TTS voice', () => {
+  const notice = formatRestartCompleteNotice('영어 STT 정리 버그 수정.', 'ko-KR-SunHiNeural');
+  assert.equal(notice.text, '✅ 재시작 완료. 다시 온라인이야. 적용 내용: 영어 STT 정리 버그 수정.');
+  assert.equal(notice.speech, '재시작 완료. 다시 온라인이야. 영어 STT 정리 버그 수정.');
+});
+
+test('shutdown restart notice follows English TTS voice', () => {
+  assert.equal(
+    formatRestartShutdownNotice('English speech detection fixed.', 'en-US-GuyNeural'),
+    'I applied this change: English speech detection fixed. Restarting now. Voice may cut out briefly.',
+  );
+});
+
+test('restart detail strips restart boilerplate before formatting', () => {
+  assert.equal(
+    cleanRestartDetail('에이전트 안내 고쳤어. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.', 'ko-KR-InJoonNeural'),
+    '에이전트 안내 고쳤어.',
+  );
+  assert.equal(
+    formatRestartShutdownNotice('에이전트 안내 고쳤어. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.', 'ko-KR-InJoonNeural'),
+    '방금 한 작업은 에이전트 안내 고쳤어. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.',
+  );
+  assert.equal(
+    formatRestartCompleteNotice('에이전트 안내 고쳤어. 이제 재시작할게. 잠깐 음성이 끊길 수 있어.', 'ko-KR-InJoonNeural').speech,
+    '재시작 완료. 다시 온라인이야. 에이전트 안내 고쳤어.',
+  );
+});

package/app-node/restart_policy.mjs

@@ -0,0 +1,27 @@
+export const AUTO_RESTART_ENV_KEY = 'VERBALCODING_AUTO_RESTART_VOICE_BOT';
+
+export function parseBooleanFlag(value, defaultValue = false) {
+  if (value === undefined || value === null || String(value).trim() === '') return Boolean(defaultValue);
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on', 'enable', 'enabled'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'off', 'disable', 'disabled'].includes(normalized)) return false;
+  return Boolean(defaultValue);
+}
+
+export function autoRestartVoiceBotEnabled(env = process.env) {
+  return parseBooleanFlag(env[AUTO_RESTART_ENV_KEY], false);
+}
+
+export function normalizeAutoRestartCommand(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (['on', 'true', '1', 'yes', 'enable', 'enabled', '켜', '켜줘'].includes(normalized)) return '1';
+  if (['off', 'false', '0', 'no', 'disable', 'disabled', '꺼', '꺼줘'].includes(normalized)) return '0';
+  return null;
+}
+
+export function autoRestartStatusText(env = process.env, language = 'ko') {
+  const enabled = autoRestartVoiceBotEnabled(env);
+  const english = /^en/i.test(String(language || ''));
+  if (english) return `Auto restart voice bot after commits: ${enabled ? 'on' : 'off'}.`;
+  return `커밋 후 음성봇 자동 재시작: ${enabled ? '켜짐' : '꺼짐'}.`;
+}

package/app-node/restart_policy.test.mjs

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  AUTO_RESTART_ENV_KEY,
+  autoRestartStatusText,
+  autoRestartVoiceBotEnabled,
+  normalizeAutoRestartCommand,
+  parseBooleanFlag,
+} from './restart_policy.mjs';
+
+test('auto restart defaults off unless explicitly enabled', () => {
+  assert.equal(autoRestartVoiceBotEnabled({}), false);
+  assert.equal(autoRestartVoiceBotEnabled({ [AUTO_RESTART_ENV_KEY]: '' }), false);
+  assert.equal(autoRestartVoiceBotEnabled({ [AUTO_RESTART_ENV_KEY]: '0' }), false);
+  assert.equal(autoRestartVoiceBotEnabled({ [AUTO_RESTART_ENV_KEY]: 'off' }), false);
+  assert.equal(autoRestartVoiceBotEnabled({ [AUTO_RESTART_ENV_KEY]: '1' }), true);
+  assert.equal(autoRestartVoiceBotEnabled({ [AUTO_RESTART_ENV_KEY]: 'on' }), true);
+});
+
+test('normalizes user auto restart commands', () => {
+  assert.equal(normalizeAutoRestartCommand('on'), '1');
+  assert.equal(normalizeAutoRestartCommand('켜'), '1');
+  assert.equal(normalizeAutoRestartCommand('off'), '0');
+  assert.equal(normalizeAutoRestartCommand('꺼'), '0');
+  assert.equal(normalizeAutoRestartCommand('maybe'), null);
+});
+
+test('auto restart status text is explicit', () => {
+  assert.equal(autoRestartStatusText({}, 'ko'), '커밋 후 음성봇 자동 재시작: 꺼짐.');
+  assert.equal(autoRestartStatusText({ [AUTO_RESTART_ENV_KEY]: '1' }, 'en'), 'Auto restart voice bot after commits: on.');
+  assert.equal(parseBooleanFlag('enabled'), true);
+});

package/app-node/text_routing.mjs

@@ -0,0 +1,8 @@
+export function shouldRouteDiscordTextToAgent({ content = '', channelId = '', transcriptChannelId = '' } = {}) {
+  const text = String(content || '').trim();
+  if (!text) return false;
+  if (text.startsWith('!')) return false;
+  const target = String(transcriptChannelId || '').trim();
+  if (!target) return true;
+  return String(channelId || '') === target;
+}

package/app-node/text_routing.test.mjs

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { shouldRouteDiscordTextToAgent } from './text_routing.mjs';
+
+test('routes normal transcript-channel text to the shared agent session', () => {
+  assert.equal(shouldRouteDiscordTextToAgent({
+    content: '이 작업 이어서 해줘',
+    channelId: 'transcript',
+    transcriptChannelId: 'transcript',
+  }), true);
+});
+
+test('does not route commands or other channels to the shared agent session', () => {
+  assert.equal(shouldRouteDiscordTextToAgent({ content: '!ping', channelId: 'transcript', transcriptChannelId: 'transcript' }), false);
+  assert.equal(shouldRouteDiscordTextToAgent({ content: '다른 채널 말', channelId: 'other', transcriptChannelId: 'transcript' }), false);
+  assert.equal(shouldRouteDiscordTextToAgent({ content: '   ', channelId: 'transcript', transcriptChannelId: 'transcript' }), false);
+});

package/app-node/tts_backends.mjs

@@ -0,0 +1,251 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function uniquePath(tmpdir, prefix, ext) {
+  return path.join(tmpdir, `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}.${ext}`);
+}
+
+function validateOutput(file, fsApi) {
+  if (!fsApi.existsSync(file) || fsApi.statSync(file).size <= 0) {
+    throw new Error(`TTS backend produced empty output: ${file}`);
+  }
+  return file;
+}
+
+function execOptions(base, signal) {
+  return signal ? { ...base, signal } : base;
+}
+
+function openVoicePython(openvoice, existsSync = fs.existsSync) {
+  const venvPython = path.join(openvoice.venv, 'bin', 'python');
+  if (existsSync(venvPython)) return venvPython;
+  return 'python3';
+}
+
+function speechSwiftArgs(text, out, speechswift) {
+  const args = ['speak', text, '--engine', speechswift.engine, '--output', out];
+  if (speechswift.language) args.push('--language', speechswift.language);
+  if (speechswift.stream) args.push('--stream');
+  if (speechswift.refAudio) args.push('--voice-sample', speechswift.refAudio);
+  if (speechswift.engine === 'cosyvoice' && speechswift.modelId) args.push('--model-id', speechswift.modelId);
+  if (speechswift.engine === 'qwen3') {
+    if (speechswift.model) args.push('--model', speechswift.model);
+    if (speechswift.speaker) args.push('--speaker', speechswift.speaker);
+    if (speechswift.instruct) args.push('--instruct', speechswift.instruct);
+  }
+  return args;
+}
+
+function supertonicArgs(text, out, supertonic) {
+  const args = ['tts', text, '-o', out, '--lang', supertonic.language];
+  if (supertonic.customStylePath) args.push('--custom-style-path', supertonic.customStylePath);
+  else if (supertonic.voice) args.push('--voice', supertonic.voice);
+  if (supertonic.steps) args.push('--steps', String(supertonic.steps));
+  if (supertonic.speed) args.push('--speed', String(supertonic.speed));
+  if (supertonic.maxChunkLength) args.push('--max-chunk-length', String(supertonic.maxChunkLength));
+  if (supertonic.silenceDuration != null) args.push('--silence-duration', String(supertonic.silenceDuration));
+  return args;
+}
+
+function supertonicEnv(baseEnv, supertonic) {
+  const env = { ...baseEnv };
+  if (supertonic.cacheDir) env.SUPERTONIC_CACHE_DIR = supertonic.cacheDir;
+  if (supertonic.intraOpThreads) env.SUPERTONIC_INTRA_OP_THREADS = String(supertonic.intraOpThreads);
+  if (supertonic.interOpThreads) env.SUPERTONIC_INTER_OP_THREADS = String(supertonic.interOpThreads);
+  return env;
+}
+
+async function speechSwiftServerRequest({ fetchImpl, speechswift, text, signal }) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), speechswift.timeoutMs);
+  const abortFromCaller = () => controller.abort(signal.reason);
+  if (signal?.aborted) controller.abort(signal.reason);
+  else signal?.addEventListener?.('abort', abortFromCaller, { once: true });
+  try {
+    const response = await fetchImpl(`${speechswift.serverUrl}/speak`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        text,
+        engine: speechswift.engine,
+        language: speechswift.language,
+      }),
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      const detail = typeof response.text === 'function' ? await response.text().catch(() => '') : '';
+      throw new Error(`audio-server /speak failed ${response.status} ${response.statusText}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  } finally {
+    clearTimeout(timeout);
+    signal?.removeEventListener?.('abort', abortFromCaller);
+  }
+}
+
+export function createEdgeTtsBackend(settings, deps = {}) {
+  const execFileAsync = deps.execFileAsync;
+  if (!execFileAsync) throw new Error('execFileAsync dependency is required');
+  const fsApi = {
+    existsSync: deps.existsSync || fs.existsSync,
+    statSync: deps.statSync || fs.statSync,
+  };
+  const tmpdir = deps.tmpdir || os.tmpdir();
+  const edge = settings.edge || {};
+  const voiceProvider = deps.voiceProvider || (() => edge.voice);
+  const currentVoice = () => voiceProvider() || edge.voice;
+  const edgeCommand = edge.command || 'edge-tts';
+  return {
+    name: 'edge',
+    outputExtension: 'mp3',
+    cacheKeyParts() {
+      return ['edge', currentVoice(), edge.rate];
+    },
+    async synthesize(text, { signal } = {}) {
+      const out = uniquePath(tmpdir, 'verbalcoding-edge', 'mp3');
+      await execFileAsync(edgeCommand, ['-v', currentVoice(), '--rate', edge.rate, '-t', text, '--write-media', out], execOptions({
+        timeout: 60000,
+        maxBuffer: 2 * 1024 * 1024,
+      }, signal));
+      return validateOutput(out, fsApi);
+    },
+  };
+}
+
+export function createOpenVoiceBackend(settings, deps = {}) {
+  const execFileAsync = deps.execFileAsync;
+  if (!execFileAsync) throw new Error('execFileAsync dependency is required');
+  const tmpdir = deps.tmpdir || os.tmpdir();
+  const warn = deps.warn || (() => {});
+  const fsApi = {
+    existsSync: deps.existsSync || fs.existsSync,
+    statSync: deps.statSync || fs.statSync,
+  };
+  const edge = createEdgeTtsBackend(settings, deps);
+  const openvoice = settings.openvoice;
+  return {
+    name: 'openvoice',
+    outputExtension: openvoice.useForProgress ? 'wav' : 'mp3',
+    cacheKeyParts() {
+      return ['openvoice', openvoice.refAudio, openvoice.language, openvoice.style];
+    },
+    async synthesize(text, { signal, kind = 'final' } = {}) {
+      if (kind === 'progress' && !openvoice.useForProgress) {
+        return edge.synthesize(text, { signal, kind });
+      }
+      const out = uniquePath(tmpdir, 'verbalcoding-openvoice', 'wav');
+      const script = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'scripts', 'openvoice_synth.py');
+      const args = [
+        script,
+        '--openvoice-dir', openvoice.dir,
+        '--ref-audio', openvoice.refAudio,
+        '--text', text,
+        '--language', openvoice.language,
+        '--style', openvoice.style,
+        '--output', out,
+      ];
+      try {
+        await execFileAsync(openVoicePython(openvoice, fsApi.existsSync), args, execOptions({
+          timeout: openvoice.timeoutMs,
+          maxBuffer: 2 * 1024 * 1024,
+        }, signal));
+        return validateOutput(out, fsApi);
+      } catch (error) {
+        fs.rm(out, { force: true }, () => {});
+        warn('openvoice failed; falling back to edge', error?.message || error);
+        return edge.synthesize(text, { signal, kind });
+      }
+    },
+  };
+}
+
+export function createSpeechSwiftBackend(settings, deps = {}) {
+  const execFileAsync = deps.execFileAsync;
+  const tmpdir = deps.tmpdir || os.tmpdir();
+  const warn = deps.warn || (() => {});
+  const fsApi = {
+    existsSync: deps.existsSync || fs.existsSync,
+    statSync: deps.statSync || fs.statSync,
+  };
+  const fetchImpl = deps.fetch || globalThis.fetch;
+  const writeFileAsync = deps.writeFileAsync || fs.promises.writeFile;
+  const edge = createEdgeTtsBackend(settings, deps);
+  const speechswift = settings.speechswift;
+  return {
+    name: 'speechswift',
+    outputExtension: speechswift.useForProgress ? 'wav' : 'mp3',
+    cacheKeyParts() {
+      return ['speechswift', speechswift.mode, speechswift.serverUrl, speechswift.engine, speechswift.refAudio, speechswift.language, speechswift.modelId, speechswift.model, speechswift.speaker, speechswift.instruct];
+    },
+    async synthesize(text, { signal, kind = 'final' } = {}) {
+      if (kind === 'progress' && !speechswift.useForProgress) {
+        return edge.synthesize(text, { signal, kind });
+      }
+      const out = uniquePath(tmpdir, speechswift.mode === 'server' ? 'verbalcoding-speechswift-server' : 'verbalcoding-speechswift', 'wav');
+      try {
+        if (speechswift.mode === 'server') {
+          if (!fetchImpl) throw new Error('fetch is not available for speech-swift server mode');
+          const wavBytes = await speechSwiftServerRequest({ fetchImpl, speechswift, text, signal });
+          await writeFileAsync(out, wavBytes);
+        } else {
+          if (!execFileAsync) throw new Error('execFileAsync dependency is required');
+          await execFileAsync(speechswift.command, speechSwiftArgs(text, out, speechswift), execOptions({
+            timeout: speechswift.timeoutMs,
+            maxBuffer: 4 * 1024 * 1024,
+          }, signal));
+        }
+        return validateOutput(out, fsApi);
+      } catch (error) {
+        fs.rm(out, { force: true }, () => {});
+        warn('speech-swift failed; falling back to edge', error?.message || error);
+        return edge.synthesize(text, { signal, kind });
+      }
+    },
+  };
+}
+
+export function createSupertonicBackend(settings, deps = {}) {
+  const execFileAsync = deps.execFileAsync;
+  if (!execFileAsync) throw new Error('execFileAsync dependency is required');
+  const tmpdir = deps.tmpdir || os.tmpdir();
+  const warn = deps.warn || (() => {});
+  const fsApi = {
+    existsSync: deps.existsSync || fs.existsSync,
+    statSync: deps.statSync || fs.statSync,
+  };
+  const edge = createEdgeTtsBackend(settings, deps);
+  const supertonic = settings.supertonic;
+  return {
+    name: 'supertonic',
+    outputExtension: supertonic.useForProgress ? 'wav' : 'mp3',
+    cacheKeyParts() {
+      return ['supertonic', supertonic.command, supertonic.voice, supertonic.language, supertonic.steps, supertonic.speed, supertonic.maxChunkLength, supertonic.silenceDuration, supertonic.customStylePath];
+    },
+    async synthesize(text, { signal, kind = 'final' } = {}) {
+      if (kind === 'progress' && !supertonic.useForProgress) {
+        return edge.synthesize(text, { signal, kind });
+      }
+      const out = uniquePath(tmpdir, 'verbalcoding-supertonic', 'wav');
+      try {
+        await execFileAsync(supertonic.command, supertonicArgs(text, out, supertonic), execOptions({
+          timeout: supertonic.timeoutMs,
+          maxBuffer: 4 * 1024 * 1024,
+          env: supertonicEnv(process.env, supertonic),
+        }, signal));
+        return validateOutput(out, fsApi);
+      } catch (error) {
+        fs.rm(out, { force: true }, () => {});
+        warn('supertonic failed; falling back to edge', error?.message || error);
+        return edge.synthesize(text, { signal, kind });
+      }
+    },
+  };
+}
+
+export function createTtsBackend(settings, deps = {}) {
+  if (settings.backend === 'openvoice') return createOpenVoiceBackend(settings, deps);
+  if (settings.backend === 'speechswift') return createSpeechSwiftBackend(settings, deps);
+  if (settings.backend === 'supertonic') return createSupertonicBackend(settings, deps);
+  return createEdgeTtsBackend(settings, deps);
+}