@nerviq/cli 1.6.2 → 1.6.4

package/bin/cli.js

@@ -762,6 +762,13 @@ async function main() {
         console.log('');
       }
     } else if (normalizedCommand === 'apply') {
+      if (flags.includes('--rollback')) {
+        console.error('\n  Error: --rollback is not yet supported as a flag.');
+        console.error('  Why: Rollback artifacts are saved in .nerviq/rollbacks/ but automatic rollback is not implemented yet.');
+        console.error('  Fix: Manually delete the files listed in .nerviq/rollbacks/<latest>.json, or use `nerviq apply --dry-run` to preview before applying.');
+        console.error('  Docs: https://github.com/nerviq/nerviq#rollback\n');
+        process.exit(1);
+      }
       const result = await applyProposalBundle(options);
       printApplyResult(result, options);
     } else if (normalizedCommand === 'governance') {
@@ -1138,6 +1145,40 @@ async function main() {
 
       // Step 2: Determine which checks to fix
       const { TECHNIQUES } = require('../src/techniques');
+      const fs = require('fs');
+      const pathMod = require('path');
+
+      // Inline fixers for checks without templates but with trivial auto-fixes
+      const INLINE_FIXERS = {
+        gitIgnoreEnv: (dir) => {
+          const gitignorePath = pathMod.join(dir, '.gitignore');
+          const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+          if (!existing.includes('.env')) {
+            const lines = existing.endsWith('\n') || existing === '' ? '' : '\n';
+            fs.appendFileSync(gitignorePath, `${lines}.env\n.env.*\n`, 'utf8');
+            return true;
+          }
+          return false;
+        },
+        secretsProtection: (dir) => {
+          const settingsPath = pathMod.join(dir, '.claude', 'settings.json');
+          const settingsDir = pathMod.join(dir, '.claude');
+          if (!fs.existsSync(settingsDir)) fs.mkdirSync(settingsDir, { recursive: true });
+          let settings = {};
+          if (fs.existsSync(settingsPath)) {
+            try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
+          }
+          if (!settings.permissions) settings.permissions = {};
+          if (!settings.permissions.deny) settings.permissions.deny = [];
+          const denyEntries = ['.env', '.env.*', '**/.env', '**/*.pem', '**/secrets/**'];
+          for (const entry of denyEntries) {
+            if (!settings.permissions.deny.includes(entry)) settings.permissions.deny.push(entry);
+          }
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+          return true;
+        },
+      };
+
       let targetKeys = [];
 
       if (fixKey) {
@@ -1161,8 +1202,9 @@ async function main() {
         }
       } else {
         // No key specified — show fixable checks and exit
-        const fixable = failedResults.filter(r => TECHNIQUES[r.key] && TECHNIQUES[r.key].template);
-        const nonFixable = failedResults.filter(r => !TECHNIQUES[r.key] || !TECHNIQUES[r.key].template);
+        const INLINE_FIX_KEYS = new Set(Object.keys(INLINE_FIXERS));
+        const fixable = failedResults.filter(r => (TECHNIQUES[r.key] && TECHNIQUES[r.key].template) || INLINE_FIX_KEYS.has(r.key));
+        const nonFixable = failedResults.filter(r => !(TECHNIQUES[r.key] && TECHNIQUES[r.key].template) && !INLINE_FIX_KEYS.has(r.key));
         console.log('');
         console.log(`  nerviq fix — ${failedResults.length} failed checks\n`);
         if (fixable.length > 0) {
@@ -1193,7 +1235,7 @@ async function main() {
         process.exit(0);
       }
 
-      // Step 3: For each target, either use template or show manual instructions
+      // Step 3: For each target, either use template, inline fix, or show manual instructions
       const preScore = auditResult.score;
       let fixed = 0;
       let manual = 0;
@@ -1212,6 +1254,19 @@ async function main() {
             console.log(`  ✅ Fixed: ${failedCheck.name}`);
             fixed++;
           }
+        } else if (INLINE_FIXERS[key]) {
+          if (options.dryRun) {
+            console.log(`  [dry-run] Would fix: ${failedCheck.name} (${key})`);
+            fixed++;
+          } else {
+            const didFix = INLINE_FIXERS[key](options.dir);
+            if (didFix) {
+              console.log(`  ✅ Fixed: ${failedCheck.name}`);
+              fixed++;
+            } else {
+              console.log(`  ⏭️  Already fixed: ${failedCheck.name}`);
+            }
+          }
         } else {
           console.log(`  📋 ${failedCheck.name} (manual fix needed)`);
           console.log(`     ${failedCheck.fix}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerviq/cli",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "The intelligent nervous system for AI coding agents — 2,431 checks across 8 platforms, 10 languages, and 62 domain packs. Audit, align, and amplify.",
   "main": "src/index.js",
   "bin": {

package/src/activity.js

@@ -283,11 +283,14 @@ function formatHistory(dir) {
 
   const lines = ['Score history (most recent first):', ''];
   for (const entry of history) {
-    const date = entry.createdAt?.split('T')[0] || 'unknown';
+    const dateStr = entry.createdAt || 'unknown';
+    const date = dateStr.split('T')[0] || 'unknown';
+    const time = dateStr.includes('T') ? dateStr.split('T')[1]?.substring(0, 5) || '' : '';
+    const dateDisplay = time ? `${date} ${time}` : date;
     const score = entry.summary?.score ?? '?';
     const passed = entry.summary?.passed ?? '?';
     const total = entry.summary?.checkCount ?? '?';
-    lines.push(`  ${date}  ${score}/100  (${passed}/${total} passing)`);
+    lines.push(`  ${dateDisplay}  ${score}/100  (${passed}/${total} passing)`);
   }
 
   const comparison = compareLatest(dir);

package/src/audit.js

@@ -769,9 +769,10 @@ function inferSuggestedNextCommand(result) {
   }
 
   const actionKeys = new Set((result.topNextActions || []).map(item => item.key));
+  const platFlag = result.platform && result.platform !== 'claude' ? ` --platform ${result.platform}` : '';
 
   if (result.failed === 0) {
-    return 'npx nerviq augment';
+    return `npx nerviq${platFlag} augment`;
   }
 
   if (
@@ -781,14 +782,14 @@ function inferSuggestedNextCommand(result) {
     actionKeys.has('settingsPermissions') ||
     actionKeys.has('permissionDeny')
   ) {
-    return 'npx nerviq setup';
+    return `npx nerviq${platFlag} setup`;
   }
 
   if (result.score < 80) {
-    return 'npx nerviq suggest-only';
+    return `npx nerviq${platFlag} suggest-only`;
   }
 
-  return 'npx nerviq augment';
+  return `npx nerviq${platFlag} augment`;
 }
 
 function getPlatformScopeNote(spec, ctx) {
@@ -876,7 +877,11 @@ function printLiteAudit(result, dir) {
   console.log(colorize('  ═══════════════════════════════════════', 'dim'));
   console.log(colorize(`  Scanning: ${dir}`, 'dim'));
   console.log('');
-  console.log(`  Score: ${colorize(`${result.score}/100`, 'bold')}`);
+  if (result.detectedConfigFiles && result.detectedConfigFiles.length > 0) {
+    console.log(colorize(`  Found: ${result.detectedConfigFiles.join(', ')}`, 'dim'));
+  }
+  console.log('');
+  console.log(`  Score: ${colorize(`${result.score}/100`, 'bold')}  (${result.passed}/${result.passed + result.failed} checks passing)`);
   if (result.platformScopeNote) {
     console.log(colorize(`  Scope: ${result.platformScopeNote.message}`, 'dim'));
   }
@@ -1128,6 +1133,22 @@ async function audit(options) {
     platformCaveats,
     recommendedDomainPacks,
   };
+  // Detect which AI config files are present
+  const configFiles = [];
+  const configChecks = [
+    ['CLAUDE.md', 'CLAUDE.md'], ['.claude/settings.json', '.claude/settings.json'],
+    ['AGENTS.md', 'AGENTS.md'], ['.cursorrules', '.cursorrules'],
+    ['.cursor/rules', '.cursor/rules/'], ['GEMINI.md', 'GEMINI.md'],
+    ['.windsurfrules', '.windsurfrules'], ['.aider.conf.yml', '.aider.conf.yml'],
+    ['opencode.json', 'opencode.json'], ['.mcp.json', '.mcp.json'],
+  ];
+  for (const [file, label] of configChecks) {
+    try {
+      if (require('fs').existsSync(require('path').join(options.dir, file))) configFiles.push(label);
+    } catch {}
+  }
+  result.detectedConfigFiles = configFiles;
+
   result.suggestedNextCommand = inferSuggestedNextCommand(result);
   result.liteSummary = {
     topNextActions: topNextActions.slice(0, 3),

package/src/doctor.js

@@ -120,15 +120,18 @@ function checkFreshnessGates() {
     try {
       const freshness = require(modulePath);
       const gate = freshness.checkReleaseGate({});
+      const staleCount = (gate.stale || []).length;
+      const freshCount = (gate.fresh || []).length;
+      const totalCount = (gate.results || []).length;
       results.push({
         platform,
-        status: gate.stale.length === 0 ? 'pass' : 'warn',
-        fresh: gate.fresh.length,
-        total: gate.results.length,
-        stale: gate.stale.length,
-        detail: gate.stale.length === 0
-          ? `All ${gate.results.length} P0 sources fresh`
-          : `${gate.stale.length}/${gate.results.length} P0 sources unverified/stale`,
+        status: staleCount === 0 ? 'pass' : 'warn',
+        fresh: freshCount,
+        total: totalCount,
+        stale: staleCount,
+        detail: staleCount === 0
+          ? `All ${totalCount} P0 sources fresh`
+          : `${staleCount}/${totalCount} P0 sources unverified/stale`,
       });
     } catch (e) {
       results.push({ platform, status: 'error', detail: e.message });

package/src/harmony/cli.js

@@ -10,7 +10,7 @@
 const path = require('path');
 const { generateStrategicAdvice, PLATFORM_STRENGTHS } = require('./advisor');
 const { startHarmonyWatch, buildHarmonyWatchPlan } = require('./watch');
-const { saveHarmonyState, loadHarmonyState, getHarmonyHistory, recordPlatformScore } = require('./memory');
+const { saveHarmonyState, loadHarmonyState, getHarmonyHistory, recordPlatformScore, recordDrift } = require('./memory');
 const { getHarmonyGovernanceSummary, formatHarmonyGovernanceReport } = require('./governance');
 
 const COLORS = {
@@ -30,9 +30,34 @@ function resolveDir(options) {
  * Collect audit results from all detectable platforms.
  * Runs audit() for each platform in sequence (audit is async).
  */
+/**
+ * Detect which platforms have config files present in the directory.
+ * Only these platforms will be audited in harmony commands.
+ */
+function detectPresentPlatforms(dir) {
+  const fs = require('fs');
+  const pathMod = require('path');
+  const exists = (f) => fs.existsSync(pathMod.join(dir, f));
+
+  const detected = [];
+  if (exists('CLAUDE.md') || exists('.claude/settings.json') || exists('.claude/CLAUDE.md')) detected.push('claude');
+  if (exists('AGENTS.md') || exists('.codex/config.toml')) detected.push('codex');
+  if (exists('GEMINI.md') || exists('.gemini/settings.json')) detected.push('gemini');
+  if (exists('.github/copilot-instructions.md')) detected.push('copilot');
+  if (exists('.cursorrules') || exists('.cursor/rules')) detected.push('cursor');
+  if (exists('.windsurfrules') || exists('.windsurf/rules')) detected.push('windsurf');
+  if (exists('.aider.conf.yml') || exists('.aiderignore')) detected.push('aider');
+  if (exists('opencode.json') || exists('.opencode')) detected.push('opencode');
+
+  // AGENTS.md is shared by codex, copilot, and opencode — only add if not already detected via platform-specific file
+  if (exists('AGENTS.md') && !detected.includes('codex')) detected.push('codex');
+
+  return detected.length > 0 ? detected : ['claude']; // default to claude if nothing found
+}
+
 async function collectPlatformAudits(dir) {
   const { audit } = require('../audit');
-  const platforms = ['claude', 'codex', 'gemini', 'copilot', 'cursor', 'windsurf', 'aider', 'opencode'];
+  const platforms = detectPresentPlatforms(dir);
   const results = [];
 
   for (const platform of platforms) {
@@ -84,6 +109,29 @@ async function runHarmonyAudit(options) {
     } catch (_e) { /* memory write optional */ }
   }
 
+  // Detect drift: compare current scores to last recorded scores
+  try {
+    const state = loadHarmonyState(dir);
+    const prevScores = state.platformScores || [];
+    for (const audit of platformAudits) {
+      const prevEntries = (prevScores || []).filter(e => e.platform === audit.platform);
+      if (prevEntries.length >= 2) {
+        // Compare to the second-to-last entry (last is what we just recorded)
+        const prev = prevEntries[prevEntries.length - 2];
+        const delta = audit.score - (prev.score || 0);
+        if (Math.abs(delta) >= 5) {
+          recordDrift(dir, {
+            platform: audit.platform,
+            driftScore: delta,
+            driftedFields: [`score: ${prev.score} → ${audit.score}`],
+          });
+          const sign = delta > 0 ? '+' : '';
+          console.log(c(`  ${audit.platform}: ${sign}${delta} since last audit`, delta > 0 ? 'green' : 'red'));
+        }
+      }
+    }
+  } catch (_e) { /* drift recording is optional */ }
+
   // Average score
   const avgScore = Math.round(platformAudits.reduce((sum, a) => sum + (a.score || 0), 0) / platformAudits.length);
   const avgColor = avgScore >= 70 ? 'green' : avgScore >= 40 ? 'yellow' : 'red';

package/src/migrate.js

@@ -248,7 +248,7 @@ async function runMigrate({ dir = process.cwd(), platform, from: fromVersion, to
 
   const platformMigrations = MIGRATIONS[platform];
   if (!platformMigrations) {
-    throw new Error(`No migrations available for platform '${platform}'. Supported: ${Object.keys(MIGRATIONS).join(', ')}`);
+    throw new Error(`No migrations available for platform '${platform}'. Supported: ${Object.keys(MIGRATIONS).join(', ')}.\nUsage: nerviq migrate --platform <platform> [--from <version> --to <version>]`);
   }
 
   // Determine migration key

package/src/setup.js

@@ -1242,7 +1242,10 @@ async function setup(options) {
     log(`  \x1b[2m  ${skipped} files already exist and were preserved.\x1b[0m`);
     log('  \x1b[2m  We never overwrite your existing config — your setup is kept.\x1b[0m');
   } else if (created > 0) {
-    log(`  \x1b[1m${created} files created.\x1b[0m`);
+    log(`  \x1b[1m${created} files created:\x1b[0m`);
+    for (const f of writtenFiles) {
+      log(`  \x1b[32m  + ${f}\x1b[0m`);
+    }
     if (skipped > 0) {
       log(`  \x1b[2m${skipped} existing files preserved (not overwritten).\x1b[0m`);
     }