verbalcoding 0.2.0

package/scripts/install.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { buildEnvFile, normalizeInstallAnswers, renderInstallSummary, SUPPORTED_HARNESSES } from '../app-node/install_config.mjs';
+
+const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+
+async function ask(question, fallback = '', options = {}) {
+  const rl = globalThis.__rl;
+  const suffixValue = options.fallbackLabel ?? fallback;
+  const suffix = suffixValue ? ` [${suffixValue}]` : '';
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || fallback;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === 'instance' || args.includes('--instance')) {
+    const { spawnSync } = await import('node:child_process');
+    const pass = args[0] === 'instance'
+      ? args.slice(1)
+      : args.filter(arg => arg !== '--instance');
+    const result = spawnSync(process.execPath, [path.join(ROOT, 'scripts', 'cli.mjs'), 'instance', 'setup', ...pass], { stdio: 'inherit', cwd: ROOT });
+    process.exitCode = result.status ?? 1;
+    return;
+  }
+  globalThis.__rl = readline.createInterface({ input, output });
+  try {
+    console.log('VerbalCoding installer');
+    console.log(`Supported harnesses: ${SUPPORTED_HARNESSES.join(', ')}`);
+    const harness = await ask('Harness/backend', 'hermes');
+    let agentCommand = '';
+    let agentLabel = '';
+    if (harness.toLowerCase() === 'custom') {
+      agentLabel = await ask('Custom harness label', 'Custom Agent');
+      agentCommand = await ask('Custom harness command, prompt appended as final argv', 'my-agent run');
+    }
+    const existingDiscordBotToken = process.env.DISCORD_BOT_TOKEN || '';
+    const discordBotToken = await ask('Discord bot token (DISCORD_BOT_TOKEN)', existingDiscordBotToken, { fallbackLabel: existingDiscordBotToken ? 'keep existing' : '' });
+    const allowedUsers = await ask('Allowed Discord user IDs, comma-separated', process.env.DISCORD_ALLOWED_USERS || '');
+    const autoJoinVoiceChannels = await ask('Auto-join voice channel names', process.env.AUTO_JOIN_VOICE_CHANNELS || '일반,General,general');
+    const transcriptChannelId = await ask('Transcript text channel/thread ID', process.env.TRANSCRIPT_CHANNEL_ID || '');
+    const language = await ask('Default voice language: ko/en/auto', process.env.VOICE_LANGUAGE || process.env.WHISPER_CPP_LANGUAGE || process.env.STT_LANGUAGE || 'ko');
+    const ttsBackend = await ask('TTS backend: edge/openvoice/speechswift/supertonic', process.env.TTS_BACKEND || 'edge');
+    const edgeTtsCommand = await ask('Edge TTS command', process.env.EDGE_TTS_COMMAND || process.env.TTS_EDGE_COMMAND || 'edge-tts');
+    const ttsVoice = await ask('TTS voice', process.env.TTS_VOICE || 'ko-KR-SunHiNeural');
+    const ttsRate = await ask('TTS rate', process.env.TTS_RATE || '+10%');
+    const ttsVolume = await ask('TTS playback volume', process.env.TTS_VOLUME || '1.0');
+    const supertonicCommand = await ask('Supertonic command', process.env.SUPERTONIC_COMMAND || 'supertonic');
+    const supertonicVoice = await ask('Supertonic voice', process.env.SUPERTONIC_VOICE || 'M1');
+    const supertonicLanguage = await ask('Supertonic language', process.env.SUPERTONIC_LANGUAGE || 'ko');
+    const supertonicSteps = await ask('Supertonic steps', process.env.SUPERTONIC_STEPS || '2');
+    const supertonicSpeed = await ask('Supertonic speed', process.env.SUPERTONIC_SPEED || '1.0');
+    const openvoiceDir = await ask('OpenVoice repo dir', process.env.OPENVOICE_DIR || './vendor/OpenVoice');
+    const openvoiceVenv = await ask('OpenVoice venv dir', process.env.OPENVOICE_VENV || './.venv-openvoice');
+    const openvoiceRefAudio = await ask('OpenVoice reference audio path', process.env.OPENVOICE_REF_AUDIO || './voice-samples/user-reference.wav');
+    const requireWake = (await ask('Require wake word? 1/0', process.env.REQUIRE_WAKE_WORD || '0')) === '1';
+    const verboseProgress = (await ask('Verbose progress by default? 1/0', process.env.AGENT_VERBOSE_PROGRESS || process.env.VERBALCODING_VERBOSE_PROGRESS || '0')) === '1';
+    const utteranceIdleMs = await ask('Utterance idle wait before STT, ms', process.env.UTTERANCE_IDLE_MS || '2000');
+    const latencyLogPath = await ask('Latency JSONL log path', process.env.LATENCY_LOG_PATH || './.logs/latency.jsonl');
+
+    const values = normalizeInstallAnswers({
+      harness,
+      agentLabel,
+      agentCommand,
+      discordBotToken,
+      allowedUsers,
+      autoJoinVoiceChannels,
+      transcriptChannelId,
+      language,
+      ttsBackend,
+      edgeTtsCommand,
+      ttsVoice,
+      ttsRate,
+      ttsVolume,
+      supertonicCommand,
+      supertonicVoice,
+      supertonicLanguage,
+      supertonicSteps,
+      supertonicSpeed,
+      openvoiceDir,
+      openvoiceVenv,
+      openvoiceRefAudio,
+      requireWakeWord: requireWake,
+      verboseProgress,
+      utteranceIdleMs,
+      latencyLogPath,
+    });
+    const envPath = path.join(ROOT, '.env');
+    if (fs.existsSync(envPath)) {
+      const backup = `${envPath}.bak-${Date.now()}`;
+      fs.copyFileSync(envPath, backup);
+      console.log(`Backed up existing .env to ${backup}`);
+    }
+    fs.writeFileSync(envPath, buildEnvFile(values), { mode: 0o600 });
+    console.log(`Wrote ${envPath}`);
+    console.log(renderInstallSummary(values));
+  } finally {
+    globalThis.__rl.close();
+  }
+}
+
+main().catch(err => {
+  console.error(err?.stack || err);
+  process.exit(1);
+});

package/scripts/install.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+RUN_WIZARD=1
+BOOTSTRAP_ARGS=()
+INSTALL_ARGS=()
+for arg in "$@"; do
+  case "$arg" in
+    --no-wizard) RUN_WIZARD=0 ;;
+    --skip-bootstrap) export VERBALCODING_SKIP_BOOTSTRAP=1 ;;
+    --yes|--skip-system|--skip-model|--skip-edge-tts) BOOTSTRAP_ARGS+=("$arg") ;;
+    *) INSTALL_ARGS+=("$arg") ;;
+  esac
+done
+
+if [ "${VERBALCODING_SKIP_BOOTSTRAP:-0}" != "1" ]; then
+  ./scripts/bootstrap_prereqs.sh "${BOOTSTRAP_ARGS[@]}"
+elif [ ! -d node_modules ]; then
+  if ! command -v node >/dev/null 2>&1; then
+    echo "node is required. Install Node.js first, or rerun without VERBALCODING_SKIP_BOOTSTRAP=1." >&2
+    exit 1
+  fi
+  npm install
+fi
+
+if [ -x "./.venv-tts/bin/edge-tts" ] && ! command -v edge-tts >/dev/null 2>&1; then
+  export EDGE_TTS_COMMAND="$(pwd)/.venv-tts/bin/edge-tts"
+fi
+
+if [ "${VERBALCODING_SKIP_CLI_LINK:-0}" != "1" ]; then
+  if npm link >/dev/null 2>&1; then
+    echo "Installed shell CLI: vc"
+  else
+    echo "Warning: could not install shell CLI with npm link." >&2
+    echo "Run this later from the project root: npm link" >&2
+  fi
+fi
+
+if [ "$RUN_WIZARD" = "1" ]; then
+  node scripts/install.mjs "${INSTALL_ARGS[@]}"
+else
+  echo "Skipped interactive .env wizard. Run ./scripts/install.sh later or copy .env.example to .env."
+fi

package/scripts/mcp-server.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createVerbalCodingMcpTools, toolResultContent } from '../app-node/mcp_tools.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { toolDefs, tools } = createVerbalCodingMcpTools({ root: ROOT });
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  input += chunk;
+  let idx;
+  while ((idx = input.indexOf('\n')) >= 0) {
+    const line = input.slice(0, idx).trim();
+    input = input.slice(idx + 1);
+    if (line) void handleLine(line);
+  }
+});
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function sendResult(id, result) {
+  if (id === undefined || id === null) return;
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function sendError(id, code, message) {
+  if (id === undefined || id === null) return;
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+async function handleLine(line) {
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (e) {
+    sendError(null, -32700, 'Parse error');
+    return;
+  }
+  const { id, method, params = {} } = request;
+  try {
+    if (method === 'initialize') {
+      sendResult(id, {
+        protocolVersion: params.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'verbalcoding', version: '0.1.0' },
+      });
+      return;
+    }
+    if (method === 'notifications/initialized') return;
+    if (method === 'ping') {
+      sendResult(id, {});
+      return;
+    }
+    if (method === 'tools/list') {
+      sendResult(id, {
+        tools: toolDefs.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
+      });
+      return;
+    }
+    if (method === 'tools/call') {
+      const name = params.name;
+      const tool = tools.get(name);
+      if (!tool) {
+        sendError(id, -32602, `Unknown tool: ${name}`);
+        return;
+      }
+      try {
+        const result = await tool.handler(params.arguments || {});
+        sendResult(id, { content: toolResultContent(result), isError: false });
+      } catch (e) {
+        sendResult(id, { content: toolResultContent({ error: String(e?.message || e) }), isError: true });
+      }
+      return;
+    }
+    sendError(id, -32601, `Method not found: ${method}`);
+  } catch (e) {
+    sendError(id, -32603, String(e?.message || e));
+  }
+}

package/scripts/openvoice_smoke.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Small OpenVoice smoke-test helper for VerbalCoding."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import subprocess
+import sys
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run a short Korean OpenVoice smoke test")
+    parser.add_argument("--openvoice-dir", default="./vendor/OpenVoice")
+    parser.add_argument("--ref-audio", default="./voice-samples/user-reference.wav")
+    parser.add_argument("--output", default="/tmp/verbalcoding-openvoice-smoke.wav")
+    parser.add_argument("--text", default="안녕하세요. 버벌코딩 목소리 복제 테스트입니다.")
+    args = parser.parse_args()
+    script = Path(__file__).with_name("openvoice_synth.py")
+    cmd = [
+        sys.executable,
+        str(script),
+        "--openvoice-dir", args.openvoice_dir,
+        "--ref-audio", args.ref_audio,
+        "--text", args.text,
+        "--language", "KR",
+        "--style", "default",
+        "--output", args.output,
+    ]
+    return subprocess.call(cmd)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/openvoice_synth.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Synthesize speech with OpenVoice V2 for VerbalCoding.
+
+This wrapper intentionally imports OpenVoice lazily inside main(), so --help and
+basic argument validation work before the optional OpenVoice environment is set up.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+import tempfile
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="OpenVoice V2 synthesis wrapper for VerbalCoding")
+    parser.add_argument("--openvoice-dir", required=True, help="Path to cloned myshell-ai/OpenVoice repo")
+    parser.add_argument("--ref-audio", required=True, help="User-owned reference voice sample")
+    parser.add_argument("--text", required=True, help="Text to synthesize")
+    parser.add_argument("--language", default="KR", help="MeloTTS language code, e.g. KR")
+    parser.add_argument("--style", default="default", help="Reserved style label for future OpenVoice control")
+    parser.add_argument("--output", required=True, help="Output WAV path")
+    parser.add_argument("--speed", type=float, default=1.0, help="Base TTS speed")
+    return parser.parse_args()
+
+
+def fail(message: str, code: int = 2) -> None:
+    print(f"openvoice_synth: {message}", file=sys.stderr)
+    raise SystemExit(code)
+
+
+def main() -> int:
+    args = parse_args()
+    openvoice_dir = Path(args.openvoice_dir).expanduser().resolve()
+    ref_audio = Path(args.ref_audio).expanduser().resolve()
+    output = Path(args.output).expanduser().resolve()
+
+    if not openvoice_dir.exists():
+        fail(f"OpenVoice directory not found: {openvoice_dir}")
+    if not ref_audio.exists():
+        fail(f"reference audio not found: {ref_audio}")
+    if not args.text.strip():
+        fail("text is empty")
+
+    sys.path.insert(0, str(openvoice_dir))
+    try:
+        import torch  # type: ignore
+        from melo.api import TTS  # type: ignore
+        from openvoice.api import ToneColorConverter  # type: ignore
+    except Exception as exc:  # pragma: no cover - depends on optional env
+        fail(
+            "OpenVoice/MeloTTS import failed. Run scripts/setup_openvoice.sh "
+            f"and install checkpoints first. Detail: {exc}",
+            code=3,
+        )
+
+    ckpt_converter = openvoice_dir / "checkpoints_v2" / "converter"
+    config = ckpt_converter / "config.json"
+    checkpoint = ckpt_converter / "checkpoint.pth"
+    if not config.exists() or not checkpoint.exists():
+        fail("OpenVoice V2 checkpoints missing under vendor/OpenVoice/checkpoints_v2/converter", code=4)
+
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+    if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        # The OpenVoice demo disables MPS for parts of MeloTTS; CPU is more predictable on macOS.
+        device = "cpu"
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="verbalcoding-openvoice-") as tmp:
+        tmp_wav = Path(tmp) / "base.wav"
+        tone_color_converter = ToneColorConverter(str(config), device=device)
+        tone_color_converter.watermark_model = None
+        tone_color_converter.load_ckpt(str(checkpoint))
+        target_se = tone_color_converter.extract_se([str(ref_audio)])
+
+        model = TTS(language=args.language, device=device)
+        speaker_ids = model.hps.data.spk2id
+        speaker_key = next(iter(speaker_ids.keys()))
+        speaker_id = speaker_ids[speaker_key]
+        speaker_file_key = speaker_key.lower().replace("_", "-")
+        source_se_path = openvoice_dir / "checkpoints_v2" / "base_speakers" / "ses" / f"{speaker_file_key}.pth"
+        if not source_se_path.exists():
+            fail(f"source speaker embedding missing: {source_se_path}", code=4)
+        source_se = torch.load(str(source_se_path), map_location=device)
+
+        model.tts_to_file(args.text, speaker_id, str(tmp_wav), speed=args.speed)
+        tone_color_converter.convert(
+            audio_src_path=str(tmp_wav),
+            src_se=source_se,
+            tgt_se=target_se,
+            output_path=str(output),
+            message="@VerbalCoding",
+        )
+
+    if not output.exists() or output.stat().st_size <= 0:
+        fail("OpenVoice produced empty output", code=5)
+    print(f"openvoice_synth: wrote {output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/setup_openvoice.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+OPENVOICE_DIR="${OPENVOICE_DIR:-vendor/OpenVoice}"
+OPENVOICE_VENV="${OPENVOICE_VENV:-.venv-openvoice}"
+
+mkdir -p "$(dirname "$OPENVOICE_DIR")" voice-samples
+if [ ! -d "$OPENVOICE_DIR/.git" ]; then
+  git clone https://github.com/myshell-ai/OpenVoice "$OPENVOICE_DIR"
+else
+  echo "OpenVoice repo already exists: $OPENVOICE_DIR"
+fi
+
+if [ ! -x "$OPENVOICE_VENV/bin/python" ]; then
+  python3 -m venv "$OPENVOICE_VENV"
+fi
+# shellcheck disable=SC1091
+. "$OPENVOICE_VENV/bin/activate"
+python -m pip install --upgrade pip setuptools wheel
+python -m pip install -e "$OPENVOICE_DIR"
+python -m pip install git+https://github.com/myshell-ai/MeloTTS.git
+python -m unidic download || true
+
+cat <<'MSG'
+OpenVoice Python environment is installed.
+Next manual steps:
+1. Download OpenVoice V2 checkpoints from:
+   https://myshell-public-repo-host.s3.amazonaws.com/openvoice/checkpoints_v2_0417.zip
+2. Extract them under vendor/OpenVoice/checkpoints_v2/
+3. Put a permitted reference sample at voice-samples/user-reference.wav
+4. Run: python3 scripts/openvoice_smoke.py
+5. Set TTS_BACKEND=openvoice in .env and restart VerbalCoding.
+MSG

package/scripts/setup_supertonic.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VENV="${SUPERTONIC_VENV:-$ROOT/.venv-supertonic}"
+CACHE_DIR="${SUPERTONIC_CACHE_DIR:-$ROOT/.cache/supertonic}"
+
+python3 -m venv "$VENV"
+"$VENV/bin/python" -m pip install --upgrade pip wheel setuptools
+"$VENV/bin/python" -m pip install supertonic
+mkdir -p "$CACHE_DIR"
+
+# Pre-download the model when the installed CLI supports it. If the command is
+# unavailable in an older package build, leave download to the first synth call.
+SUPERTONIC_CACHE_DIR="$CACHE_DIR" "$VENV/bin/supertonic" download || true
+
+echo "Supertonic installed: $VENV/bin/supertonic"
+echo "Set SUPERTONIC_COMMAND=\"$VENV/bin/supertonic\" and TTS_BACKEND=\"supertonic\" to use it."