@holdyourvoice/hyv 2.8.6 → 2.8.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "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

@@ -1,5 +1,5 @@
 /**
- * postinstall-lib.js — testable agent copy helpers (used by postinstall.js)
+ * postinstall-lib.js — agent setup helpers (postinstall + doctor --fix-agents)
  */
 const fs = require('fs');
 const path = require('path');
@@ -31,22 +31,25 @@ function shouldUpgradeAgent(destFile, markerPath, pkgVersion) {
   }
 }
 
-function copyAgent(src, dest, markerPath, pkgVersion) {
+function copyAgent(src, dest, markerPath, pkgVersion, transform) {
   if (!fs.existsSync(src)) return { copied: false, reason: 'missing-src' };
   if (!shouldUpgradeAgent(dest, markerPath, pkgVersion) && fs.existsSync(dest)) {
     return { copied: false, reason: 'up-to-date' };
   }
   fs.mkdirSync(path.dirname(dest), { recursive: true });
-  fs.copyFileSync(src, dest);
+  const raw = fs.readFileSync(src, 'utf-8');
+  const content = typeof transform === 'function' ? transform(raw) : raw;
+  fs.writeFileSync(dest, content);
   return { copied: true, reason: fs.existsSync(dest) ? 'upgraded' : 'created' };
 }
 
 function writeAgentsMarker(hyvDir, pkgVersion) {
   const markerPath = path.join(hyvDir, 'agents-version.json');
-  if (!fs.existsSync(hyvDir)) fs.mkdirSync(hyvDir, { recursive: true });
+  if (!fs.existsSync(hyvDir)) fs.mkdirSync(hyvDir, { recursive: true, mode: 0o700 });
   fs.writeFileSync(
     markerPath,
-    JSON.stringify({ version: pkgVersion, updated_at: new Date().toISOString() }, null, 2)
+    JSON.stringify({ version: pkgVersion, updated_at: new Date().toISOString() }, null, 2),
+    { mode: 0o600 }
   );
   return markerPath;
 }
@@ -64,13 +67,229 @@ function hasCompletedOnboarding(hyvDir) {
 }
 
 function markOnboardingComplete(hyvDir, pkgVersion) {
-  if (!fs.existsSync(hyvDir)) fs.mkdirSync(hyvDir, { recursive: true });
+  if (!fs.existsSync(hyvDir)) fs.mkdirSync(hyvDir, { recursive: true, mode: 0o700 });
   fs.writeFileSync(
     onboardingPath(hyvDir),
-    JSON.stringify({ version: pkgVersion, completed_at: new Date().toISOString() }, null, 2)
+    JSON.stringify({ version: pkgVersion, completed_at: new Date().toISOString() }, null, 2),
+    { mode: 0o600 }
   );
 }
 
+function resolveHyvMcpCommand(pkgDir) {
+  const entry = path.join(pkgDir, 'dist', 'index.js');
+  if (fs.existsSync(entry)) {
+    return { command: process.execPath, args: [entry, 'mcp'] };
+  }
+  return { command: 'hyv', args: ['mcp'] };
+}
+
+function mergeJsonConfigFile(configFile, mutator, { backup = true } = {}) {
+  fs.mkdirSync(path.dirname(configFile), { recursive: true });
+  let config = {};
+  if (fs.existsSync(configFile)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+    } catch (err) {
+      return { ok: false, reason: 'parse-error', error: err.message };
+    }
+  }
+  const next = mutator(config) || config;
+  if (backup && fs.existsSync(configFile)) {
+    try {
+      fs.copyFileSync(configFile, `${configFile}.hyv.bak`);
+    } catch {
+      // non-fatal
+    }
+  }
+  fs.writeFileSync(configFile, JSON.stringify(next, null, 2));
+  return { ok: true };
+}
+
+function toCursorMdc(content) {
+  if (content.startsWith('---')) return content;
+  return [
+    '---',
+    'description: Hold Your Voice — scan and rewrite drafts for brand voice consistency',
+    'alwaysApply: true',
+    '---',
+    '',
+    content.trim(),
+    '',
+  ].join('\n');
+}
+
+function toWindsurfRule(content) {
+  if (content.startsWith('---')) return content;
+  return ['---', 'trigger: always_on', '---', '', content.trim(), ''].join('\n');
+}
+
+function mergeAgentsMd(existing, addition, title) {
+  const marker = `<!-- hyv:${title} -->`;
+  if (existing.includes(marker)) {
+    const start = existing.indexOf(marker);
+    const end = existing.indexOf('<!-- /hyv -->', start);
+    if (end !== -1) {
+      return existing.slice(0, start) + marker + '\n' + addition.trim() + '\n<!-- /hyv -->\n' + existing.slice(end + '<!-- /hyv -->'.length);
+    }
+  }
+  const block = `${marker}\n${addition.trim()}\n<!-- /hyv -->\n`;
+  return existing.trim() ? `${existing.trim()}\n\n${block}` : block;
+}
+
+function claudeDesktopDir(home, isWin) {
+  if (isWin) return path.join(home, 'AppData', 'Roaming', 'Claude');
+  if (process.platform === 'linux') return path.join(home, '.config', 'Claude');
+  return path.join(home, 'Library', 'Application Support', 'Claude');
+}
+
+/**
+ * Configure MCP + agent instructions for detected IDEs.
+ * @returns {{ configured: string[], warnings: string[], pkgVersion: string }}
+ */
+function setupAgents({ pkgDir, home = require('os').homedir(), quiet = false }) {
+  const configured = [];
+  const warnings = [];
+  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';
+
+  if (!autoConfigure) {
+    return { configured, warnings: ['HYV_AUTO_CONFIGURE_AGENTS=0 — skipped agent setup'], pkgVersion };
+  }
+
+  function installAgent(src, dest, transform) {
+    const result = copyAgent(src, dest, agentsMarker, pkgVersion, transform);
+    return result.copied;
+  }
+
+  function setupMcpJson(configFile, label) {
+    const result = mergeJsonConfigFile(configFile, (config) => {
+      if (!config.mcpServers) config.mcpServers = {};
+      if (!config.mcpServers.hyv) {
+        config.mcpServers.hyv = { command: mcpCmd.command, args: mcpCmd.args };
+        configured.push(`${label} mcp`);
+      }
+      return config;
+    });
+    if (!result.ok) warnings.push(`${label}: could not update MCP config (${result.reason})`);
+    return result.ok;
+  }
+
+  // Claude Desktop MCP
+  try {
+    const claudeDir = claudeDesktopDir(home, isWin);
+    const configFile = path.join(claudeDir, 'claude_desktop_config.json');
+    if (fs.existsSync(claudeDir) || autoConfigure) {
+      setupMcpJson(configFile, 'claude desktop');
+    }
+  } catch (err) {
+    warnings.push(`claude desktop: ${err.message}`);
+  }
+
+  // Cursor — global MCP + always-on rule (.mdc)
+  try {
+    const cursorDir = path.join(home, '.cursor');
+    fs.mkdirSync(cursorDir, { recursive: true });
+    const mcpFile = path.join(cursorDir, 'mcp.json');
+    setupMcpJson(mcpFile, 'cursor');
+    const rulesFile = path.join(cursorDir, 'rules', 'hyv.mdc');
+    const src = path.join(pkgDir, 'agents', 'cursor.md');
+    if (installAgent(src, rulesFile, toCursorMdc)) configured.push('cursor');
+    // legacy .md (upgrade path)
+    const legacy = path.join(cursorDir, 'rules', 'hyv.md');
+    if (fs.existsSync(legacy)) {
+      try { fs.unlinkSync(legacy); } catch { /* ignore */ }
+    }
+  } catch (err) {
+    warnings.push(`cursor: ${err.message}`);
+  }
+
+  // Claude Code — slash command + skill
+  try {
+    const cmdDir = path.join(home, '.claude', 'commands');
+    const skillDir = path.join(home, '.claude', 'skills', 'hold-your-voice');
+    fs.mkdirSync(cmdDir, { recursive: true });
+    fs.mkdirSync(skillDir, { recursive: true });
+    const cmdFile = path.join(cmdDir, 'hyv.md');
+    const skillFile = path.join(skillDir, 'SKILL.md');
+    const cmdSrc = path.join(pkgDir, 'agents', 'claude-code.md');
+    const skillSrc = path.join(pkgDir, 'skills', 'hold-your-voice', 'SKILL.md');
+    if (installAgent(cmdSrc, cmdFile)) configured.push('claude code');
+    if (fs.existsSync(skillSrc) && installAgent(skillSrc, skillFile)) configured.push('claude code skill');
+  } catch (err) {
+    warnings.push(`claude code: ${err.message}`);
+  }
+
+  // Windsurf — rules with frontmatter
+  try {
+    const wsDirs = [
+      isWin ? path.join(home, 'AppData', 'Roaming', 'Windsurf') : path.join(home, '.windsurf'),
+      isWin ? null : path.join(home, 'Library', 'Application Support', 'Windsurf'),
+    ].filter(Boolean);
+    const src = path.join(pkgDir, 'agents', 'windsurf.md');
+    for (const wsDir of wsDirs) {
+      fs.mkdirSync(wsDir, { recursive: true });
+      const rulesFile = path.join(wsDir, 'rules', 'hyv.md');
+      if (installAgent(src, rulesFile, toWindsurfRule)) {
+        configured.push('windsurf');
+        break;
+      }
+    }
+  } catch (err) {
+    warnings.push(`windsurf: ${err.message}`);
+  }
+
+  // Codex — ~/.codex/AGENTS.md
+  try {
+    const codexDir = path.join(home, '.codex');
+    fs.mkdirSync(codexDir, { recursive: true });
+    const agentsFile = path.join(codexDir, 'AGENTS.md');
+    const src = path.join(pkgDir, 'agents', 'codex.md');
+    let existing = '';
+    if (fs.existsSync(agentsFile)) existing = fs.readFileSync(agentsFile, 'utf-8');
+    const addition = fs.existsSync(src) ? fs.readFileSync(src, 'utf-8') : '';
+    if (addition && shouldUpgradeAgent(agentsFile, agentsMarker, pkgVersion)) {
+      const merged = mergeAgentsMd(existing, addition, 'hold-your-voice');
+      fs.writeFileSync(agentsFile, merged);
+      configured.push('codex');
+    } else if (!fs.existsSync(agentsFile) && fs.existsSync(src)) {
+      fs.writeFileSync(agentsFile, addition.trim() + '\n');
+      configured.push('codex');
+    }
+  } catch (err) {
+    warnings.push(`codex: ${err.message}`);
+  }
+
+  // Command Code skill
+  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');
+    const skillDest = path.join(ccSkillDir, 'SKILL.md');
+    if (fs.existsSync(skillSrc) && installAgent(skillSrc, skillDest)) configured.push('command code');
+  } catch (err) {
+    warnings.push(`command code: ${err.message}`);
+  }
+
+  // Generic reference copy
+  try {
+    const genericSrc = path.join(pkgDir, 'agents', 'generic.md');
+    const genericDest = path.join(hyvDir, 'agents', 'generic.md');
+    if (fs.existsSync(genericSrc)) installAgent(genericSrc, genericDest);
+  } catch {
+    // non-fatal
+  }
+
+  writeAgentsMarker(hyvDir, pkgVersion);
+  if (!quiet && warnings.length) {
+    for (const w of warnings) process.stderr.write(`[hyv postinstall] warning: ${w}\n`);
+  }
+  return { configured: [...new Set(configured)], warnings, pkgVersion };
+}
+
 module.exports = {
   readPkgVersion,
   readAgentsMarker,
@@ -80,4 +299,10 @@ module.exports = {
   onboardingPath,
   hasCompletedOnboarding,
   markOnboardingComplete,
+  resolveHyvMcpCommand,
+  mergeJsonConfigFile,
+  toCursorMdc,
+  toWindsurfRule,
+  setupAgents,
+  claudeDesktopDir,
 };

package/scripts/postinstall.js

@@ -2,30 +2,16 @@
 /**
  * postinstall.js — auto-configure MCP + agent instructions after npm install.
  */
-const fs = require('fs');
 const path = require('path');
-const os = require('os');
-const home = os.homedir();
-const isWin = process.platform === 'win32';
 const pkgDir = path.resolve(__dirname, '..');
 const quiet = process.env.HYV_POSTINSTALL_QUIET === '1' || process.argv.includes('--quiet');
-const hyvDir = path.join(home, '.hyv');
-const agentsMarker = path.join(hyvDir, 'agents-version.json');
+const hyvDir = require('path').join(require('os').homedir(), '.hyv');
 const {
-  readPkgVersion,
-  copyAgent,
-  writeAgentsMarker,
+  setupAgents,
   hasCompletedOnboarding,
   markOnboardingComplete,
 } = require('./postinstall-lib');
 
-const pkgVersion = readPkgVersion(pkgDir);
-
-function installAgent(src, dest) {
-  const result = copyAgent(src, dest, agentsMarker, pkgVersion);
-  return result.copied;
-}
-
 function print(msg) {
   if (!quiet) console.log(msg);
 }
@@ -35,87 +21,17 @@ print('  ✓ hold your voice installed — free local scan ready');
 print('  next: hyv scan draft.md  |  hyv init  |  hyv mcp --setup');
 print('');
 
-const configured = [];
-
-// ── Claude Desktop ─────────────────────────────────────────────────────────
-try {
-  const claudeDir = isWin
-    ? path.join(home, 'AppData', 'Roaming', 'Claude')
-    : path.join(home, 'Library', 'Application Support', 'Claude');
-  const configFile = path.join(claudeDir, 'claude_desktop_config.json');
-
-  if (fs.existsSync(claudeDir)) {
-    let config = {};
-    if (fs.existsSync(configFile)) {
-      try { config = JSON.parse(fs.readFileSync(configFile, 'utf-8')); } catch {}
-    }
-    if (!config.mcpServers) config.mcpServers = {};
-    if (!config.mcpServers.hyv) {
-      config.mcpServers.hyv = { command: 'hyv', args: ['mcp'] };
-      fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
-      configured.push('claude desktop');
-    }
-  }
-} catch {}
-
-// ── Claude Code ──────────────────────────────────────────────────────────────
-try {
-  const cmdDir = path.join(home, '.claude', 'commands');
-  if (fs.existsSync(path.dirname(cmdDir))) {
-    fs.mkdirSync(cmdDir, { recursive: true });
-    const cmdFile = path.join(cmdDir, 'hyv.md');
-    const src = path.join(pkgDir, 'agents', 'claude-code.md');
-    if (installAgent(src, cmdFile)) configured.push('claude code');
-  }
-} catch {}
-
-// ── Cursor ─────────────────────────────────────────────────────────────────
-try {
-  const cursorDir = path.join(home, '.cursor');
-  if (fs.existsSync(cursorDir)) {
-    const rulesFile = path.join(cursorDir, 'rules', 'hyv.md');
-    fs.mkdirSync(path.dirname(rulesFile), { recursive: true });
-    const src = path.join(pkgDir, 'agents', 'cursor.md');
-    if (installAgent(src, rulesFile)) configured.push('cursor');
-  }
-} catch {}
-
-// ── Windsurf ───────────────────────────────────────────────────────────────
-try {
-  const wsDirs = [
-    isWin ? path.join(home, 'AppData', 'Roaming', 'Windsurf') : path.join(home, '.windsurf'),
-    isWin ? null : path.join(home, 'Library', 'Application Support', 'Windsurf'),
-  ].filter(Boolean);
-  for (const wsDir of wsDirs) {
-    if (fs.existsSync(wsDir)) {
-      const rulesFile = path.join(wsDir, 'rules', 'hyv.md');
-      fs.mkdirSync(path.dirname(rulesFile), { recursive: true });
-      const src = path.join(pkgDir, 'agents', 'windsurf.md');
-      if (installAgent(src, rulesFile)) {
-        configured.push('windsurf');
-        break;
-      }
-    }
-  }
-} catch {}
-
-// ── ChatGPT ──────────────────────────────────────────────────────────────────
-try {
-  const chatgptDir = path.join(home, '.chatgpt');
-  if (!fs.existsSync(chatgptDir)) fs.mkdirSync(chatgptDir, { recursive: true });
-  const instrFile = path.join(chatgptDir, 'hyv-instructions.txt');
-  const src = path.join(pkgDir, 'agents', 'chatgpt.md');
-  if (installAgent(src, instrFile)) configured.push('chatgpt');
-} catch {}
-
-writeAgentsMarker(hyvDir, pkgVersion);
+const { configured, warnings } = setupAgents({ pkgDir, quiet });
 
 if (configured.length > 0) {
   print('  ✓ auto-configured: ' + configured.join(', '));
   print('');
 }
+if (warnings.length > 0 && !quiet) {
+  print('  ! setup notes: ' + warnings.join('; '));
+  print('');
+}
 
-// First install → onboarding during install when npm shows script output; else first `hyv` runs it
 const canShowOnboarding =
   process.stdout.isTTY || process.env.npm_config_foreground_scripts === 'true';
 
@@ -129,7 +45,7 @@ if (!quiet && !hasCompletedOnboarding(hyvDir) && canShowOnboarding) {
       stdio: 'inherit',
       env: { ...process.env, HYV_POSTINSTALL_ONBOARDING: '1' },
     });
-    markOnboardingComplete(hyvDir, pkgVersion);
+    markOnboardingComplete(hyvDir, require('./postinstall-lib').readPkgVersion(pkgDir));
   } catch {
     print('  finish setup: hyv welcome');
     print('');

package/assets/ai-eliminator-skill.md

@@ -1,63 +0,0 @@
----
-name: ai-writing-eliminator
-description: Use when the user wants to remove AI writing patterns, humanize a draft, make prose less generic, scan for AI cadence, or rewrite only the lines that sound synthetic.
----
-
-# AI Writing Eliminator (v2)
-
-This skill removes machine-shaped writing without destroying the draft. The
-algorithm now detects 220+ named AI writing patterns across 31 composite regex
-rules, plus 9 structural/rhythmic signals (burstiness, paragraph uniformity,
-contraction density, formal hedging, intensifier overuse, fragment ratio,
-staccato detection, over-structured lists, uniform sentence rhythm).
-
-## Non-Negotiables
-
-- Fix flagged lines only unless the user asks for a full rewrite.
-- Preserve the original argument and local meaning.
-- Do not add praise, summaries, preambles, CTAs, or extra sections.
-- Do not replace specific roughness with smooth generic prose.
-- After editing, rescan the result.
-
-## Scan
-
-- Fix flagged lines only unless the user asks for a full rewrite.
-- Preserve the original argument and local meaning.
-- Do not add praise, summaries, preambles, CTAs, or extra sections.
-- Do not replace specific roughness with smooth generic prose.
-- After editing, rescan the result.
-
-## Scan
-
-Use the helper script when a draft is in a file:
-
-```bash
-hyv scan <draft path>
-```
-
-For pasted text, apply the same rules manually from
-`assets/ai-eliminator-rules.md`.
-
-## Repair Prompt
-
-When a model rewrite is needed, generate a line-level prompt:
-
-```bash
-hyv rewrite-prompt \
-  --profile .hold-your-voice/voice-profile.json \
-  <draft path>
-```
-
-If there is no profile, still repair the AI patterns, but do not claim the
-result is voice-matched.
-
-## Bad Fixes
-
-Reject fixes that:
-
-- turn the draft into a tidy founder post
-- make every paragraph land as a lesson
-- replace a concrete scene with an abstract principle
-- use dramatic line breaks to fake rhythm
-- make the writer sound more professional but less specific
-

package/assets/claude-code-skill.md

@@ -1,24 +0,0 @@
-## Hold Your Voice — automated voice rewriting
-
-when the user asks to "write in my voice", "rewrite this in my voice", or "make this sound like me":
-
-1. read their voice profile at `~/.hyv/voice.md`
-2. run `hyv rewrite --text "<their text>"` to generate a structured rewrite prompt
-3. execute the prompt — rewrite the text yourself using your own llm
-4. present the rewritten text
-5. when the user accepts it, run `hyv reinforce original.md edited.md` to teach the system
-
-### available commands
-
-- `hyv scan <file>` — check a draft for voice drift and ai patterns
-- `hyv rewrite <file>` — generate a rewrite prompt for your llm
-- `hyv validate <file>` — verify a rewrite matches the voice profile
-- `hyv reinforce <original> <edited>` — teach the system what was accepted
-- `hyv sync` — refresh cached profiles and rules
-- `hyv status` — show auth and plan info
-
-### important
-
-- hyv never calls an llm. it generates prompts you execute yourself.
-- voice profiles live at `~/.hyv/voice.md`
-- always call `hyv validate` after rewriting to verify the result

package/assets/cursor-rules.md

@@ -1,12 +0,0 @@
-# Hold Your Voice — Cursor Rules
-
-when writing or rewriting content, match the voice profile below. do not use AI-slop words (delve, leverage, tapestry, in today's fast-paced, not just X but Y, etc.). match rhythm, vocabulary, and sentence patterns from the profile.
-
-your voice profile is at `~/.hyv/voice.md`. load it and use it as your writing guide.
-
-when the user says "rewrite in my voice", "make this sound like me", or similar:
-
-1. run: `hyv rewrite --text "<text>"`
-2. the cli generates a structured rewrite prompt
-3. execute the prompt yourself — rewrite the text matching the voice profile
-4. present the result