@holdyourvoice/hyv 2.9.14 → 2.9.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "2.9.14",
+  "version": "2.9.15",
   "description": "Free local AI writing scan for cursor & claude. MCP server, 220+ pattern detection, voice profiles. npx @holdyourvoice/hyv welcome",
   "main": "dist/index.js",
   "bin": {

package/scripts/postinstall-lib.js

@@ -89,6 +89,18 @@ function resolveHyvMcpCommandArray(pkgDir) {
   return [command, ...args];
 }
 
+function mcpJsonEntriesMatch(existing, desired) {
+  if (!existing || typeof existing !== 'object') return false;
+  const a = existing.args || [];
+  const b = desired.args || [];
+  return existing.command === desired.command && JSON.stringify(a) === JSON.stringify(b);
+}
+
+function mcpCommandArrayMatches(existing, desired) {
+  if (!Array.isArray(existing) || !Array.isArray(desired)) return false;
+  return JSON.stringify(existing) === JSON.stringify(desired);
+}
+
 function parseJsonc(text) {
   const noBlock = text.replace(/\/\*[\s\S]*?\*\//g, '');
   const noLine = noBlock.replace(/^\s*\/\/.*$/gm, '');
@@ -151,6 +163,226 @@ function chatgptHelperDir(home) {
   return path.join(home, '.chatgpt');
 }
 
+function macAppInstalled(appName, home) {
+  if (process.platform !== 'darwin') return false;
+  const roots = ['/Applications', path.join(home, 'Applications')];
+  return roots.some((root) => fs.existsSync(path.join(root, `${appName}.app`)));
+}
+
+function dirExists(dir) {
+  try {
+    return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function fileExists(file) {
+  try {
+    return fs.existsSync(file);
+  } catch {
+    return false;
+  }
+}
+
+function commandOnPath(cmd) {
+  const pathVar = process.env.PATH || '';
+  const exts = process.platform === 'win32' ? (process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';') : [''];
+  for (const entry of pathVar.split(path.delimiter)) {
+    if (!entry) continue;
+    for (const ext of exts) {
+      const candidate = path.join(entry, process.platform === 'win32' ? `${cmd}${ext}` : cmd);
+      try {
+        if (fs.existsSync(candidate)) return true;
+      } catch {
+        // ignore
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Detect locally installed AI apps that hyv can integrate with.
+ * @returns {{ id: string, label: string, reason: string, integration: 'mcp'|'rules'|'manual' }[]}
+ */
+function detectInstalledAgents(home = require('os').homedir(), isWin = process.platform === 'win32') {
+  const detected = [];
+
+  const claudeDir = claudeDesktopDir(home, isWin);
+  if (
+    dirExists(claudeDir) ||
+    fileExists(path.join(claudeDir, 'claude_desktop_config.json')) ||
+    macAppInstalled('Claude', home)
+  ) {
+    detected.push({
+      id: 'claude-desktop',
+      label: 'claude desktop',
+      reason: dirExists(claudeDir) ? 'config directory found' : 'claude desktop app found',
+      integration: 'mcp',
+    });
+  }
+
+  const cursorDir = path.join(home, '.cursor');
+  if (dirExists(cursorDir) || macAppInstalled('Cursor', home)) {
+    detected.push({
+      id: 'cursor',
+      label: 'cursor',
+      reason: dirExists(cursorDir) ? '~/.cursor found' : 'cursor app found',
+      integration: 'mcp',
+    });
+  }
+
+  const claudeCodeDir = path.join(home, '.claude');
+  if (dirExists(claudeCodeDir) || commandOnPath('claude')) {
+    detected.push({
+      id: 'claude-code',
+      label: 'claude code',
+      reason: dirExists(claudeCodeDir) ? '~/.claude found' : 'claude cli on path',
+      integration: 'rules',
+    });
+  }
+
+  const windsurfDirs = [
+    path.join(home, '.windsurf'),
+    isWin ? path.join(home, 'AppData', 'Roaming', 'Windsurf') : path.join(home, 'Library', 'Application Support', 'Windsurf'),
+  ].filter(Boolean);
+  if (windsurfDirs.some(dirExists) || macAppInstalled('Windsurf', home)) {
+    detected.push({
+      id: 'windsurf',
+      label: 'windsurf',
+      reason: windsurfDirs.some(dirExists) ? 'windsurf config found' : 'windsurf app found',
+      integration: 'rules',
+    });
+  }
+
+  if (dirExists(path.join(home, '.codex')) || commandOnPath('codex')) {
+    detected.push({
+      id: 'codex',
+      label: 'codex',
+      reason: dirExists(path.join(home, '.codex')) ? '~/.codex found' : 'codex cli on path',
+      integration: 'rules',
+    });
+  }
+
+  if (dirExists(path.join(home, '.commandcode'))) {
+    detected.push({
+      id: 'command-code',
+      label: 'command code',
+      reason: '~/.commandcode found',
+      integration: 'rules',
+    });
+  }
+
+  const agDir = path.dirname(antigravityMcpConfigPath(home, isWin));
+  if (dirExists(agDir) || macAppInstalled('Antigravity', home)) {
+    detected.push({
+      id: 'antigravity',
+      label: 'antigravity',
+      reason: dirExists(agDir) ? '~/.gemini/config found' : 'antigravity app found',
+      integration: 'mcp',
+    });
+  }
+
+  const ocDir = opencodeConfigDir(home, isWin);
+  if (dirExists(ocDir) || commandOnPath('opencode')) {
+    detected.push({
+      id: 'opencode',
+      label: 'opencode',
+      reason: dirExists(ocDir) ? 'opencode config found' : 'opencode cli on path',
+      integration: 'mcp',
+    });
+  }
+
+  const chatgptDir = chatgptHelperDir(home);
+  if (dirExists(chatgptDir) || macAppInstalled('ChatGPT', home)) {
+    detected.push({
+      id: 'chatgpt',
+      label: 'chatgpt desktop',
+      reason: dirExists(chatgptDir) ? '~/.chatgpt found' : 'chatgpt app found',
+      integration: 'manual',
+    });
+  }
+
+  return detected;
+}
+
+function agentIdForConfiguredLabel(label) {
+  const map = {
+    'claude desktop': 'claude-desktop',
+    'claude desktop mcp': 'claude-desktop',
+    cursor: 'cursor',
+    'cursor mcp': 'cursor',
+    'claude code': 'claude-code',
+    'claude code skill': 'claude-code',
+    windsurf: 'windsurf',
+    codex: 'codex',
+    'command code': 'command-code',
+    'antigravity mcp': 'antigravity',
+    'opencode mcp': 'opencode',
+    'opencode agents': 'opencode',
+    'chatgpt connector guide': 'chatgpt',
+  };
+  return map[label] || null;
+}
+
+function isAgentIdEnabled(agentId, onlyDetected, detectedIds) {
+  if (!onlyDetected) return true;
+  return detectedIds.includes(agentId);
+}
+
+function readMcpHyvEntry(configFile) {
+  if (!fileExists(configFile)) return null;
+  try {
+    const cfg = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+    return cfg?.mcpServers?.hyv || null;
+  } catch {
+    return null;
+  }
+}
+
+function isAgentIntegrated(agentId, home = require('os').homedir(), isWin = process.platform === 'win32') {
+  switch (agentId) {
+    case 'claude-desktop':
+      return Boolean(readMcpHyvEntry(path.join(claudeDesktopDir(home, isWin), 'claude_desktop_config.json')));
+    case 'cursor':
+      return Boolean(readMcpHyvEntry(path.join(home, '.cursor', 'mcp.json')))
+        && fileExists(path.join(home, '.cursor', 'rules', 'hyv.mdc'));
+    case 'claude-code':
+      return fileExists(path.join(home, '.claude', 'commands', 'hyv.md'))
+        && fileExists(path.join(home, '.claude', 'skills', 'hold-your-voice', 'SKILL.md'));
+    case 'windsurf': {
+      const dirs = [
+        path.join(home, '.windsurf'),
+        isWin ? path.join(home, 'AppData', 'Roaming', 'Windsurf') : path.join(home, 'Library', 'Application Support', 'Windsurf'),
+      ].filter(Boolean);
+      return dirs.some((dir) => fileExists(path.join(dir, 'rules', 'hyv.md')));
+    }
+    case 'codex': {
+      const agents = path.join(home, '.codex', 'AGENTS.md');
+      return fileExists(agents) && fs.readFileSync(agents, 'utf-8').includes('hyv');
+    }
+    case 'command-code':
+      return fileExists(path.join(home, '.commandcode', 'skills', 'hyv', 'SKILL.md'));
+    case 'antigravity':
+      return Boolean(readMcpHyvEntry(antigravityMcpConfigPath(home, isWin)));
+    case 'opencode': {
+      const ocFile = path.join(opencodeConfigDir(home, isWin), 'opencode.jsonc');
+      if (!fileExists(ocFile)) return false;
+      try {
+        const cfg = parseJsonc(fs.readFileSync(ocFile, 'utf-8'));
+        return Boolean(cfg.mcp?.hyv);
+      } catch {
+        return false;
+      }
+    }
+    case 'chatgpt':
+      return fileExists(path.join(chatgptHelperDir(home), 'hyv-mcp-connector.txt'));
+    default:
+      return false;
+  }
+}
+
 function mergeJsonConfigFile(configFile, mutator, { backup = true } = {}) {
   fs.mkdirSync(path.dirname(configFile), { recursive: true });
   const read = readJsonObjectFromFile(configFile, (text) => JSON.parse(text));
@@ -207,20 +439,35 @@ function claudeDesktopDir(home, isWin) {
 
 /**
  * Configure MCP + agent instructions for detected IDEs.
- * @returns {{ configured: string[], warnings: string[], pkgVersion: string }}
+ * @returns {{ configured: string[], warnings: string[], pkgVersion: string, detected: object[], skipped: string[] }}
  */
-function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false }) {
+function setupAgents({
+  pkgDir,
+  home = require('os').homedir(),
+  quiet = false,
+  onlyDetected = false,
+  force = false,
+} = {}) {
   const configured = [];
   const warnings = [];
+  const skipped = [];
   const isWin = process.platform === 'win32';
   const hyvDir = path.join(home, '.hyv');
   const agentsMarker = path.join(hyvDir, 'agents-version.json');
   const pkgVersion = readPkgVersion(pkgDir);
   const mcpCmd = resolveHyvMcpCommand(pkgDir);
   const autoConfigure = process.env.HYV_AUTO_CONFIGURE_AGENTS !== '0';
+  const detected = detectInstalledAgents(home, isWin);
+  const detectedIds = detected.map((entry) => entry.id);
 
   if (!autoConfigure) {
-    return { configured, warnings: ['HYV_AUTO_CONFIGURE_AGENTS=0 — skipped agent setup'], pkgVersion };
+    return {
+      configured,
+      warnings: ['HYV_AUTO_CONFIGURE_AGENTS=0 — skipped agent setup'],
+      pkgVersion,
+      detected,
+      skipped: detectedIds,
+    };
   }
 
   function installAgent(src, dest, transform) {
@@ -229,11 +476,16 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   function setupMcpJson(configFile, label) {
+    const desired = { command: mcpCmd.command, args: mcpCmd.args };
     const result = mergeJsonConfigFile(configFile, (config) => {
       if (!config.mcpServers) config.mcpServers = {};
-      if (!config.mcpServers.hyv) {
-        config.mcpServers.hyv = { command: mcpCmd.command, args: mcpCmd.args };
+      const existing = config.mcpServers.hyv;
+      if (!existing) {
+        config.mcpServers.hyv = desired;
         configured.push(`${label} mcp`);
+      } else if (force || !mcpJsonEntriesMatch(existing, desired)) {
+        config.mcpServers.hyv = desired;
+        configured.push(`${label} mcp (updated)`);
       }
       return config;
     });
@@ -242,18 +494,22 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Claude Desktop MCP
-  try {
-    const claudeDir = claudeDesktopDir(home, isWin);
-    const configFile = path.join(claudeDir, 'claude_desktop_config.json');
-    if (fs.existsSync(claudeDir) || autoConfigure) {
+  if (isAgentIdEnabled('claude-desktop', onlyDetected, detectedIds)) {
+    try {
+      const claudeDir = claudeDesktopDir(home, isWin);
+      const configFile = path.join(claudeDir, 'claude_desktop_config.json');
       setupMcpJson(configFile, 'claude desktop');
+    } catch (err) {
+      warnings.push(`claude desktop: ${err.message}`);
     }
-  } catch (err) {
-    warnings.push(`claude desktop: ${err.message}`);
+  } else if (onlyDetected) {
+    skipped.push('claude-desktop');
   }
 
   // Cursor — global MCP + always-on rule (.mdc)
-  try {
+  if (!isAgentIdEnabled('cursor', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('cursor');
+  } else try {
     const cursorDir = path.join(home, '.cursor');
     fs.mkdirSync(cursorDir, { recursive: true });
     const mcpFile = path.join(cursorDir, 'mcp.json');
@@ -271,7 +527,9 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Claude Code — slash command + skill
-  try {
+  if (!isAgentIdEnabled('claude-code', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('claude-code');
+  } else try {
     const cmdDir = path.join(home, '.claude', 'commands');
     const skillDir = path.join(home, '.claude', 'skills', 'hold-your-voice');
     fs.mkdirSync(cmdDir, { recursive: true });
@@ -287,7 +545,9 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Windsurf — rules with frontmatter
-  try {
+  if (!isAgentIdEnabled('windsurf', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('windsurf');
+  } else try {
     const wsDirs = [
       isWin ? path.join(home, 'AppData', 'Roaming', 'Windsurf') : path.join(home, '.windsurf'),
       isWin ? null : path.join(home, 'Library', 'Application Support', 'Windsurf'),
@@ -306,7 +566,9 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Codex — ~/.codex/AGENTS.md
-  try {
+  if (!isAgentIdEnabled('codex', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('codex');
+  } else try {
     const codexDir = path.join(home, '.codex');
     fs.mkdirSync(codexDir, { recursive: true });
     const agentsFile = path.join(codexDir, 'AGENTS.md');
@@ -327,7 +589,9 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Command Code skill
-  try {
+  if (!isAgentIdEnabled('command-code', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('command-code');
+  } else try {
     const ccSkillDir = path.join(home, '.commandcode', 'skills', 'hyv');
     fs.mkdirSync(ccSkillDir, { recursive: true });
     const skillSrc = path.join(pkgDir, 'skills', 'hold-your-voice', 'SKILL.md');
@@ -338,14 +602,21 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // Antigravity — ~/.gemini/config/mcp_config.json (absolute paths for GUI launch)
-  try {
+  if (!isAgentIdEnabled('antigravity', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('antigravity');
+  } else try {
     const agFile = antigravityMcpConfigPath(home, isWin);
     const mcpCmd = resolveHyvMcpCommand(pkgDir);
+    const desired = { command: mcpCmd.command, args: mcpCmd.args };
     const result = mergeJsonConfigFile(agFile, (config) => {
       if (!config.mcpServers) config.mcpServers = {};
-      if (!config.mcpServers.hyv) {
-        config.mcpServers.hyv = { command: mcpCmd.command, args: mcpCmd.args };
+      const existing = config.mcpServers.hyv;
+      if (!existing) {
+        config.mcpServers.hyv = desired;
         configured.push('antigravity mcp');
+      } else if (force || !mcpJsonEntriesMatch(existing, desired)) {
+        config.mcpServers.hyv = desired;
+        configured.push('antigravity mcp (updated)');
       }
       return config;
     });
@@ -355,15 +626,22 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // OpenCode — ~/.config/opencode/opencode.jsonc + AGENTS.md
-  try {
+  if (!isAgentIdEnabled('opencode', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('opencode');
+  } else try {
     const ocDir = opencodeConfigDir(home, isWin);
     const ocFile = path.join(ocDir, 'opencode.jsonc');
     const cmdArr = resolveHyvMcpCommandArray(pkgDir);
     const ocResult = mergeJsoncConfigFile(ocFile, (config) => {
       if (!config.mcp) config.mcp = {};
-      if (!config.mcp.hyv) {
-        config.mcp.hyv = { type: 'local', command: cmdArr, enabled: true };
+      const existing = config.mcp.hyv;
+      const desired = { type: 'local', command: cmdArr, enabled: true };
+      if (!existing) {
+        config.mcp.hyv = desired;
         configured.push('opencode mcp');
+      } else if (force || !mcpCommandArrayMatches(existing.command, cmdArr)) {
+        config.mcp.hyv = { ...existing, ...desired, command: cmdArr };
+        configured.push('opencode mcp (updated)');
       }
       return config;
     });
@@ -389,7 +667,9 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   }
 
   // ChatGPT — connector helper (UI has no config file; write exact values for manual add)
-  try {
+  if (!isAgentIdEnabled('chatgpt', onlyDetected, detectedIds)) {
+    if (onlyDetected) skipped.push('chatgpt');
+  } else try {
     const cgDir = chatgptHelperDir(home);
     fs.mkdirSync(cgDir, { recursive: true });
     const mcpCmd = resolveHyvMcpCommand(pkgDir);
@@ -424,7 +704,7 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
     warnings.push(`chatgpt: ${err.message}`);
   }
 
-  // Generic reference copy
+  // Generic reference copy (always when auto-configure runs)
   try {
     const genericSrc = path.join(pkgDir, 'agents', 'generic.md');
     const genericDest = path.join(hyvDir, 'agents', 'generic.md');
@@ -437,7 +717,31 @@ function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false })
   if (!quiet && warnings.length) {
     for (const w of warnings) process.stderr.write(`[hyv postinstall] warning: ${w}\n`);
   }
-  return { configured: [...new Set(configured)], warnings, pkgVersion };
+  return {
+    configured: [...new Set(configured)],
+    warnings,
+    pkgVersion,
+    detected,
+    skipped: [...new Set(skipped)],
+  };
+}
+
+/**
+ * Detect installed apps and configure hyv MCP/rules for each one.
+ * @returns {{ detected: object[], configured: string[], warnings: string[], skipped: string[] }}
+ */
+function integrateDetectedAgents({ pkgDir, home = require('os').homedir(), quiet = false, force = false } = {}) {
+  const detected = detectInstalledAgents(home);
+  if (detected.length === 0) {
+    return { detected, configured: [], warnings: [], skipped: [] };
+  }
+  const result = setupAgents({ pkgDir, home, quiet, onlyDetected: true, force });
+  return {
+    detected: result.detected || detected,
+    configured: result.configured || [],
+    warnings: result.warnings || [],
+    skipped: result.skipped || [],
+  };
 }
 
 module.exports = {
@@ -457,6 +761,10 @@ module.exports = {
   toCursorMdc,
   toWindsurfRule,
   setupAgents,
+  detectInstalledAgents,
+  integrateDetectedAgents,
+  agentIdForConfiguredLabel,
+  isAgentIntegrated,
   claudeDesktopDir,
   antigravityMcpConfigPath,
   opencodeConfigDir,