verbalcoding 0.2.6 → 0.2.8

package/scripts/doctor.mjs

@@ -7,6 +7,9 @@ import { checkInstanceConfigs, formatInstanceDoctor } from '../app-node/instance
 import { autoRestartVoiceBotEnabled } from '../app-node/restart_policy.mjs';
 
 const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+const args = process.argv.slice(2);
+const autoFixEnabled = !args.includes('--no-fix') && !['0', 'false', 'no', 'off'].includes(String(process.env.VERBALCODING_DOCTOR_AUTO_FIX || '1').toLowerCase());
+let autoFixAttempted = false;
 
 function readEnvFile(file) {
   try {
@@ -25,14 +28,56 @@ function mergeEnv() {
   };
 }
 
+function quoteEnv(value) {
+  return JSON.stringify(String(value ?? ''));
+}
+
+function upsertEnvFile(file, updates) {
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  const seen = new Set();
+  const lines = existing.split(/\r?\n/).map(raw => {
+    const line = raw.trim();
+    if (!line || line.startsWith('#') || !line.includes('=')) return raw;
+    const idx = line.indexOf('=');
+    const key = line.slice(0, idx).trim().replace(/^export\s+/, '');
+    if (!(key in updates)) return raw;
+    seen.add(key);
+    return `${key}=${quoteEnv(updates[key])}`;
+  });
+  for (const [key, value] of Object.entries(updates)) {
+    if (!seen.has(key)) lines.push(`${key}=${quoteEnv(value)}`);
+  }
+  const text = `${lines.filter((line, index, arr) => line !== '' || index < arr.length - 1).join('\n')}\n`;
+  fs.writeFileSync(file, text, { mode: 0o600 });
+}
+
+function isExecutable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function commandExists(command) {
   const result = spawnSync('bash', ['-lc', `command -v ${JSON.stringify(command)}`], {
     cwd: ROOT,
     encoding: 'utf8',
+    env: { ...process.env, PATH: `${path.join(ROOT, '.local', 'bin')}:${process.env.PATH || ''}` },
   });
   return result.status === 0 ? result.stdout.trim() : '';
 }
 
+function resolveCommand(command, fallbackPaths = []) {
+  const found = commandExists(command);
+  if (found) return found;
+  for (const candidate of fallbackPaths) {
+    if (isExecutable(candidate)) return candidate;
+  }
+  return '';
+}
+
 function check(label, ok, detail = '') {
   const mark = ok ? '✓' : '✗';
   console.log(`${mark} ${label}${detail ? ` — ${detail}` : ''}`);
@@ -43,7 +88,60 @@ function note(label, detail = '') {
   console.log(`• ${label}${detail ? ` — ${detail}` : ''}`);
 }
 
-const env = mergeEnv();
+function fixablePrerequisites(env) {
+  const ttsBackend = (env.TTS_BACKEND || 'edge').toLowerCase();
+  const missing = [];
+  if (!commandExists('ffmpeg')) missing.push('ffmpeg');
+  if (!resolveCommand(env.WHISPER_CPP_BIN || 'whisper-cli', [path.join(ROOT, '.local', 'bin', 'whisper-cli')])) missing.push('whisper-cli');
+  const modelPath = path.resolve(ROOT, env.WHISPER_CPP_MODEL || 'models/ggml-small-q5_1.bin');
+  if (!fs.existsSync(modelPath)) missing.push('whisper.cpp model');
+  if (ttsBackend === 'edge') {
+    const edgeCommand = env.EDGE_TTS_COMMAND || env.TTS_EDGE_COMMAND || 'edge-tts';
+    if (!resolveCommand(edgeCommand, [path.join(ROOT, '.venv-tts', 'bin', 'edge-tts')])) missing.push('edge-tts');
+  }
+  return missing;
+}
+
+function persistDiscoveredLocalHelpers(env) {
+  const updates = {};
+  const localWhisper = path.join(ROOT, '.local', 'bin', 'whisper-cli');
+  if (!commandExists(env.WHISPER_CPP_BIN || 'whisper-cli') && isExecutable(localWhisper)) {
+    updates.WHISPER_CPP_BIN = localWhisper;
+  }
+  const ttsBackend = (env.TTS_BACKEND || 'edge').toLowerCase();
+  const localEdge = path.join(ROOT, '.venv-tts', 'bin', 'edge-tts');
+  const edgeCommand = env.EDGE_TTS_COMMAND || env.TTS_EDGE_COMMAND || 'edge-tts';
+  if (ttsBackend === 'edge' && !commandExists(edgeCommand) && isExecutable(localEdge)) {
+    updates.EDGE_TTS_COMMAND = localEdge;
+  }
+  if (Object.keys(updates).length > 0) {
+    upsertEnvFile(path.join(ROOT, '.env'), updates);
+    return updates;
+  }
+  return {};
+}
+
+let env = mergeEnv();
+const missingBeforeFix = fixablePrerequisites(env);
+if (autoFixEnabled && missingBeforeFix.length > 0) {
+  console.log(`VerbalCoding doctor: missing ${missingBeforeFix.join(', ')}; running automatic prerequisite bootstrap...`);
+  const result = spawnSync('bash', [path.join(ROOT, 'scripts', 'bootstrap_prereqs.sh'), '--yes'], {
+    cwd: ROOT,
+    stdio: 'inherit',
+    env: { ...process.env, VERBALCODING_SKIP_CLI_LINK: process.env.VERBALCODING_SKIP_CLI_LINK || '1' },
+  });
+  autoFixAttempted = true;
+  const persisted = persistDiscoveredLocalHelpers(mergeEnv());
+  if (Object.keys(persisted).length > 0) {
+    console.log(`Doctor recorded local helper paths in .env: ${Object.keys(persisted).join(', ')}`);
+  }
+  if (result.status !== 0) {
+    console.log(`Doctor bootstrap exited with status ${result.status}. Continuing with checks.`);
+  }
+  console.log('');
+  env = mergeEnv();
+}
+
 const backend = (env.AGENT_BACKEND || 'hermes').toLowerCase();
 const ttsBackend = (env.TTS_BACKEND || 'edge').toLowerCase();
 let ok = true;
@@ -52,12 +150,18 @@ console.log('VerbalCoding doctor');
 console.log(`Project: ${ROOT}`);
 console.log(`Backend: ${backend}`);
 console.log(`TTS backend: ${ttsBackend}`);
+if (!autoFixEnabled) note('Automatic prerequisite bootstrap', 'off');
+if (autoFixAttempted) note('Automatic prerequisite bootstrap', 'attempted');
 console.log('');
 
-ok = check('Node.js', commandExists('node'), commandExists('node') || 'missing') && ok;
-ok = check('npm', commandExists('npm'), commandExists('npm') || 'missing') && ok;
-ok = check('ffmpeg', commandExists('ffmpeg'), commandExists('ffmpeg') || 'missing') && ok;
-ok = check('whisper-cli', commandExists(env.WHISPER_CPP_BIN || 'whisper-cli'), commandExists(env.WHISPER_CPP_BIN || 'whisper-cli') || 'missing') && ok;
+const nodeCommand = commandExists('node');
+const npmCommand = commandExists('npm');
+const ffmpegCommand = commandExists('ffmpeg');
+const whisperCommand = resolveCommand(env.WHISPER_CPP_BIN || 'whisper-cli', [path.join(ROOT, '.local', 'bin', 'whisper-cli')]);
+ok = check('Node.js', nodeCommand, nodeCommand || 'missing') && ok;
+ok = check('npm', npmCommand, npmCommand || 'missing') && ok;
+ok = check('ffmpeg', ffmpegCommand, ffmpegCommand || 'missing') && ok;
+ok = check('whisper-cli', whisperCommand, whisperCommand || 'missing') && ok;
 
 const modelPath = path.resolve(ROOT, env.WHISPER_CPP_MODEL || 'models/ggml-small-q5_1.bin');
 ok = check('whisper.cpp model', fs.existsSync(modelPath), path.relative(ROOT, modelPath)) && ok;
@@ -77,7 +181,8 @@ if (!['edge', 'openvoice', 'speechswift', 'supertonic'].includes(ttsBackend)) {
 }
 if (ttsBackend === 'edge') {
   const edgeCommand = env.EDGE_TTS_COMMAND || env.TTS_EDGE_COMMAND || 'edge-tts';
-  ok = check('edge-tts', commandExists(edgeCommand), commandExists(edgeCommand) || 'missing') && ok;
+  const edgeFound = resolveCommand(edgeCommand, [path.join(ROOT, '.venv-tts', 'bin', 'edge-tts')]);
+  ok = check('edge-tts', edgeFound, edgeFound || 'missing') && ok;
 } else if (ttsBackend === 'openvoice') {
   ok = check('Python for OpenVoice', commandExists('python3'), commandExists('python3') || 'missing') && ok;
   const openvoiceDir = path.resolve(ROOT, env.OPENVOICE_DIR || './vendor/OpenVoice');
@@ -127,8 +232,9 @@ ok = instanceResult.errors.length === 0 && ok;
 
 console.log('');
 if (ok) {
-  console.log('Doctor passed. Run ./run.sh to start VerbalCoding.');
+  console.log('Doctor passed. Run vc start to start VerbalCoding.');
 } else {
-  console.log('Doctor found missing prerequisites. Fix the ✗ items, then rerun npm run doctor.');
+  const suffix = autoFixEnabled ? 'Fix the remaining ✗ items, then rerun vc doctor.' : 'Fix the ✗ items, then rerun vc doctor.';
+  console.log(`Doctor found missing prerequisites. ${suffix}`);
   process.exitCode = 1;
 }