@nerviq/cli 1.2.2 → 1.2.5

package/src/harmony/canon.js

@@ -3,7 +3,7 @@
  *
  * Reads ALL platform config files from a single project and builds a unified
  * understanding of instructions, MCP servers, trust posture, and governance
- * across Claude, Codex, Gemini, Copilot, and Cursor.
+ * across Claude, Codex, Gemini, Copilot, Cursor, Windsurf, Aider, and OpenCode.
  */
 
 const fs = require('fs');
@@ -13,10 +13,17 @@ const { CodexProjectContext } = require('../codex/context');
 const { GeminiProjectContext } = require('../gemini/context');
 const { CopilotProjectContext } = require('../copilot/context');
 const { CursorProjectContext } = require('../cursor/context');
+const { WindsurfProjectContext } = require('../windsurf/context');
+const { AiderProjectContext } = require('../aider/context');
+const { OpenCodeProjectContext } = require('../opencode/context');
 const { getCodexGovernanceSummary } = require('../codex/governance');
 const { getGeminiGovernanceSummary } = require('../gemini/governance');
 const { getCopilotGovernanceSummary } = require('../copilot/governance');
 const { getCursorGovernanceSummary } = require('../cursor/governance');
+const { getWindsurfGovernanceSummary } = require('../windsurf/governance');
+const { getAiderGovernanceSummary } = require('../aider/governance');
+const { getOpenCodeGovernanceSummary } = require('../opencode/governance');
+const { tryParseJsonc } = require('../opencode/config-parser');
 
 // ─── Platform detection signatures ──────────────────────────────────────────
 
@@ -96,6 +103,52 @@ const PLATFORM_SIGNATURES = {
     rulesDir: '.cursor/rules',
     hooksDir: null,
   },
+  windsurf: {
+    label: 'Windsurf',
+    detect: (dir) => {
+      try {
+        if (fs.existsSync(path.join(dir, '.windsurfrules'))) return true;
+        if (fs.existsSync(path.join(dir, '.windsurf'))) return true;
+        return false;
+      } catch { return false; }
+    },
+    instructionFiles: ['.windsurfrules'],
+    configFiles: ['.windsurfrules', '.windsurf/mcp.json', '.cascadeignore'],
+    mcpFiles: ['.windsurf/mcp.json'],
+    rulesDir: '.windsurf/rules',
+    hooksDir: '.windsurf/workflows',
+  },
+  aider: {
+    label: 'Aider',
+    detect: (dir) => {
+      try {
+        if (fs.existsSync(path.join(dir, '.aider.conf.yml'))) return true;
+        if (fs.existsSync(path.join(dir, '.aiderignore'))) return true;
+        return false;
+      } catch { return false; }
+    },
+    instructionFiles: ['CONVENTIONS.md', '.aider.conventions.md'],
+    configFiles: ['.aider.conf.yml', '.aider.model.settings.yml', '.aiderignore'],
+    mcpFiles: [],
+    rulesDir: null,
+    hooksDir: null,
+  },
+  opencode: {
+    label: 'OpenCode',
+    detect: (dir) => {
+      try {
+        if (fs.existsSync(path.join(dir, 'opencode.json'))) return true;
+        if (fs.existsSync(path.join(dir, 'opencode.jsonc'))) return true;
+        if (fs.existsSync(path.join(dir, '.opencode'))) return true;
+        return false;
+      } catch { return false; }
+    },
+    instructionFiles: ['AGENTS.md', 'CLAUDE.md'],
+    configFiles: ['opencode.json', 'opencode.jsonc'],
+    mcpFiles: ['opencode.json', 'opencode.jsonc'],
+    rulesDir: null,
+    hooksDir: null,
+  },
 };
 
 // ─── Context builders per platform ──────────────────────────────────────────
@@ -106,6 +159,9 @@ const CONTEXT_BUILDERS = {
   gemini: (dir) => new GeminiProjectContext(dir),
   copilot: (dir) => new CopilotProjectContext(dir),
   cursor: (dir) => new CursorProjectContext(dir),
+  windsurf: (dir) => new WindsurfProjectContext(dir),
+  aider: (dir) => new AiderProjectContext(dir),
+  opencode: (dir) => new OpenCodeProjectContext(dir),
 };
 
 const GOVERNANCE_GETTERS = {
@@ -113,6 +169,9 @@ const GOVERNANCE_GETTERS = {
   gemini: getGeminiGovernanceSummary,
   copilot: getCopilotGovernanceSummary,
   cursor: getCursorGovernanceSummary,
+  windsurf: getWindsurfGovernanceSummary,
+  aider: getAiderGovernanceSummary,
+  opencode: getOpenCodeGovernanceSummary,
 };
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
@@ -133,6 +192,11 @@ function safeParseJson(content) {
   }
 }
 
+function safeParseJsonc(content) {
+  const parsed = tryParseJsonc(content);
+  return parsed.ok ? parsed.data : null;
+}
+
 /**
  * Extract instruction text from a platform's instruction files.
  * Returns array of { file, content } for each found file.
@@ -177,6 +241,17 @@ function extractMcpFromMcpJson(content) {
   }));
 }
 
+function extractMcpFromOpenCodeConfig(content) {
+  const json = safeParseJsonc(content);
+  if (!json) return [];
+  const servers = json.mcpServers || json.servers || {};
+  return Object.keys(servers).map(name => ({
+    name,
+    command: servers[name].command || null,
+    args: servers[name].args || [],
+  }));
+}
+
 /**
  * Extract MCP server names from Gemini settings.json.
  */
@@ -205,6 +280,8 @@ function readMcpServers(dir, platform, mcpFiles) {
       extracted = extractMcpFromClaudeSettings(content);
     } else if (platform === 'gemini') {
       extracted = extractMcpFromGeminiSettings(content);
+    } else if (platform === 'opencode') {
+      extracted = extractMcpFromOpenCodeConfig(content);
     } else {
       extracted = extractMcpFromMcpJson(content);
     }
@@ -268,6 +345,27 @@ function detectTrustPosture(platform, ctx) {
     return 'no-sandbox';
   }
 
+  if (platform === 'windsurf') {
+    if (ctx.fileContent('.cascadeignore')) return 'guarded';
+    if (ctx.fileContent('.windsurf/mcp.json')) return 'team-managed';
+    return 'foreground';
+  }
+
+  if (platform === 'aider') {
+    const config = ctx.configContent ? (ctx.configContent() || '') : '';
+    if (/^\s*(yes|yes-always)\s*:\s*true\b/m.test(config)) return 'full-auto';
+    if (/^\s*auto-commits\s*:\s*true\b/m.test(config)) return 'git-guarded';
+    return 'manual-review';
+  }
+
+  if (platform === 'opencode') {
+    const config = ctx.configContent ? (ctx.configContent() || '') : '';
+    if (/"\*"\s*:\s*"allow"/.test(config)) return 'unrestricted';
+    if (/"(?:bash|edit|task|external_directory)"\s*:\s*"deny"/.test(config)) return 'locked-down';
+    if (/"(?:bash|edit|task|external_directory)"\s*:\s*"ask"/.test(config)) return 'prompted';
+    return 'standard';
+  }
+
   return 'unknown';
 }
 

package/src/harmony/cli.js

@@ -68,6 +68,27 @@ function collectPlatformAudits(dir) {
     if (result) results.push({ platform: 'cursor', ...result });
   } catch (_e) { /* platform not available */ }
 
+  // Try Windsurf audit
+  try {
+    const { audit } = require('../audit');
+    const result = audit({ dir, silent: true, platform: 'windsurf' });
+    if (result) results.push({ platform: 'windsurf', ...result });
+  } catch (_e) { /* platform not available */ }
+
+  // Try Aider audit
+  try {
+    const { audit } = require('../audit');
+    const result = audit({ dir, silent: true, platform: 'aider' });
+    if (result) results.push({ platform: 'aider', ...result });
+  } catch (_e) { /* platform not available */ }
+
+  // Try OpenCode audit
+  try {
+    const { audit } = require('../audit');
+    const result = audit({ dir, silent: true, platform: 'opencode' });
+    if (result) results.push({ platform: 'opencode', ...result });
+  } catch (_e) { /* platform not available */ }
+
   return results;
 }
 

package/src/harmony/drift.js

@@ -97,7 +97,7 @@ function detectMcpDrift(model) {
   const drifts = [];
   const allPlatforms = model.activePlatforms.map(p => p.platform);
   const mcpCapablePlatforms = allPlatforms.filter(p =>
-    p === 'claude' || p === 'gemini' || p === 'copilot' || p === 'cursor'
+    p === 'claude' || p === 'gemini' || p === 'copilot' || p === 'cursor' || p === 'windsurf' || p === 'opencode'
   );
 
   if (mcpCapablePlatforms.length < 2) return drifts;
@@ -150,7 +150,7 @@ function detectRuleDrift(model) {
 
   // Platforms that support rules: claude (.claude/rules), copilot (.github/instructions), cursor (.cursor/rules)
   const ruleCapable = allPlatforms.filter(p =>
-    p === 'claude' || p === 'copilot' || p === 'cursor'
+    p === 'claude' || p === 'copilot' || p === 'cursor' || p === 'windsurf'
   );
 
   if (ruleCapable.length < 2) return drifts;

package/src/harmony/memory.js

@@ -1,7 +1,7 @@
 /**
  * H7. Shared Memory / Knowledge Layer
  *
- * Cross-platform knowledge storage in .claudex/harmony/ directory.
+ * Cross-platform knowledge storage in .nerviq/harmony/ directory.
  * Persists canonical models, drift history, platform scores,
  * recommendation outcomes, and routing history.
  *
@@ -10,8 +10,12 @@
 
 const fs = require('fs');
 const path = require('path');
+const {
+  resolveHarmonyStateReadPath,
+  ensureHarmonyStateDir,
+} = require('../state-paths');
 
-const HARMONY_DIR = '.claudex/harmony';
+const HARMONY_DIR = '.nerviq/harmony';
 
 const STATE_FILES = {
   canon: 'canon.json',
@@ -24,9 +28,7 @@ const STATE_FILES = {
 // ─── File I/O helpers ─────────────────────────────────────────────────────────
 
 function ensureHarmonyDir(dir) {
-  const harmonyPath = path.join(dir, HARMONY_DIR);
-  fs.mkdirSync(harmonyPath, { recursive: true });
-  return harmonyPath;
+  return ensureHarmonyStateDir(dir);
 }
 
 function readJsonSafe(filePath) {
@@ -78,11 +80,10 @@ function saveHarmonyState(dir, state) {
  * @returns {Object} State object with all available keys populated
  */
 function loadHarmonyState(dir) {
-  const harmonyPath = path.join(dir, HARMONY_DIR);
   const state = {};
 
   for (const [key, filename] of Object.entries(STATE_FILES)) {
-    const filePath = path.join(harmonyPath, filename);
+    const filePath = resolveHarmonyStateReadPath(dir, filename);
     const data = readJsonSafe(filePath);
     if (data !== null) {
       state[key] = data;
@@ -90,7 +91,7 @@ function loadHarmonyState(dir) {
   }
 
   // Load manifest for metadata
-  const manifest = readJsonSafe(path.join(harmonyPath, 'manifest.json'));
+  const manifest = readJsonSafe(resolveHarmonyStateReadPath(dir, 'manifest.json'));
   if (manifest) {
     state._manifest = manifest;
   }

package/src/insights.js

@@ -21,7 +21,7 @@
 const https = require('https');
 const os = require('os');
 
-const INSIGHTS_ENDPOINT = 'https://claudex-insights.claudex.workers.dev/v1/report';
+const INSIGHTS_ENDPOINT = 'https://insights.nerviq.net/v1/report';
 const TIMEOUT_MS = 3000;
 
 function shouldCollect() {

package/src/opencode/activity.js

@@ -5,7 +5,7 @@
  * Provides: history, compare, trend, watch, feedback, insights.
  *
  * OpenCode snapshots are stored alongside Claude snapshots in
- * .claude/claudex-setup/snapshots/ but filtered by platform='opencode'.
+ * .nerviq/snapshots/ (legacy: .claude/claudex-setup/snapshots/) but filtered by platform='opencode'.
  */
 
 const path = require('path');

package/src/opencode/patch.js

@@ -142,7 +142,7 @@ function applyPatch(dir, filePath, patchFn, options = {}) {
     return { success: true, reason: 'dry run', preview, unchanged: false };
   }
 
-  const backupPath = fullPath + '.claudex-backup';
+  const backupPath = fullPath + '.nerviq-backup';
   fs.writeFileSync(backupPath, original, 'utf8');
   fs.writeFileSync(fullPath, patched, 'utf8');
 

package/src/opencode/techniques.js

@@ -21,11 +21,12 @@
  */
 
 const os = require('os');
-const path = require('path');
-const { EMBEDDED_SECRET_PATTERNS, containsEmbeddedSecret } = require('../secret-patterns');
-const { attachSourceUrls } = require('../source-urls');
-const { buildStackChecks } = require('../stack-checks');
-const { isApiProject, isDatabaseProject, isAuthProject, isMonitoringRelevant } = require('../supplemental-checks');
+const path = require('path');
+const { EMBEDDED_SECRET_PATTERNS, containsEmbeddedSecret } = require('../secret-patterns');
+const { attachSourceUrls } = require('../source-urls');
+const { buildStackChecks } = require('../stack-checks');
+const { isApiProject, isDatabaseProject, isAuthProject, isMonitoringRelevant } = require('../supplemental-checks');
+const { resolveProjectStateReadPath } = require('../state-paths');
 
 const DEFAULT_PROJECT_DOC_MAX_BYTES = 32768;
 
@@ -1458,14 +1459,15 @@ const OPENCODE_TECHNIQUES = {
     line: () => null,
   },
 
-  opencodePilotEvidence: {
-    id: 'OC-M03',
-    name: 'OpenCode setup has been audited at least once',
-    check: (ctx) => {
-      // Check for nerviq activity artifacts
-      const hasArtifacts = ctx.hasDir('.claude/claudex-setup');
-      return hasArtifacts ? true : null;
-    },
+  opencodePilotEvidence: {
+    id: 'OC-M03',
+    name: 'OpenCode setup has been audited at least once',
+    check: (ctx) => {
+      // Check for nerviq activity artifacts
+      const fs = require('fs');
+      const hasArtifacts = fs.existsSync(resolveProjectStateReadPath(ctx.dir));
+      return hasArtifacts ? true : null;
+    },
     impact: 'low',
     rating: 2,
     category: 'governance',

package/src/shared/capabilities.js

@@ -0,0 +1,194 @@
+/**
+ * Canonical Platform Capability Matrix
+ *
+ * Single source of truth for platform strengths/weaknesses.
+ * Used by: harmony/advisor.js, synergy/routing.js, synergy/compensation.js
+ *
+ * Scale: 1 (weak) to 5 (best-in-class)
+ * All keys use camelCase for consistency.
+ */
+
+const PLATFORM_CAPABILITIES = {
+  claude: {
+    label: 'Claude Code',
+    reasoning: 5,
+    refactoring: 5,
+    debugging: 5,
+    review: 5,
+    architecture: 5,
+    ci: 2,
+    ide: 2,
+    ui: 1,
+    async: 3,
+    inline: 3,
+    context: 4,
+    automation: 4,
+    sandbox: 3,
+    cloudTasks: 3,
+    cloudAgent: 2,
+    background: 3,
+    governance: 4,
+  },
+  codex: {
+    label: 'Codex',
+    reasoning: 4,
+    refactoring: 4,
+    debugging: 3,
+    review: 4,
+    architecture: 3,
+    ci: 5,
+    ide: 3,
+    ui: 2,
+    async: 5,
+    inline: 2,
+    context: 3,
+    automation: 4,
+    sandbox: 4,
+    cloudTasks: 5,
+    cloudAgent: 4,
+    background: 4,
+    governance: 3,
+  },
+  gemini: {
+    label: 'Gemini CLI',
+    reasoning: 4,
+    refactoring: 3,
+    debugging: 3,
+    review: 3,
+    architecture: 3,
+    ci: 3,
+    ide: 3,
+    ui: 2,
+    async: 4,
+    inline: 2,
+    context: 5,
+    automation: 3,
+    sandbox: 5,
+    cloudTasks: 4,
+    cloudAgent: 3,
+    background: 3,
+    governance: 2,
+  },
+  copilot: {
+    label: 'GitHub Copilot',
+    reasoning: 3,
+    refactoring: 3,
+    debugging: 3,
+    review: 3,
+    architecture: 2,
+    ci: 4,
+    ide: 4,
+    ui: 3,
+    async: 3,
+    inline: 5,
+    context: 3,
+    automation: 3,
+    sandbox: 2,
+    cloudTasks: 4,
+    cloudAgent: 4,
+    background: 3,
+    governance: 3,
+  },
+  cursor: {
+    label: 'Cursor',
+    reasoning: 3,
+    refactoring: 4,
+    debugging: 4,
+    review: 3,
+    architecture: 3,
+    ci: 2,
+    ide: 5,
+    ui: 5,
+    async: 2,
+    inline: 4,
+    context: 3,
+    automation: 4,
+    sandbox: 2,
+    cloudTasks: 2,
+    cloudAgent: 2,
+    background: 4,
+    governance: 2,
+  },
+  windsurf: {
+    label: 'Windsurf',
+    reasoning: 4,
+    refactoring: 4,
+    debugging: 4,
+    review: 3,
+    architecture: 3,
+    ci: 2,
+    ide: 5,
+    ui: 4,
+    async: 3,
+    inline: 4,
+    context: 3,
+    automation: 4,
+    sandbox: 2,
+    cloudTasks: 2,
+    cloudAgent: 2,
+    background: 2,
+    governance: 3,
+  },
+  aider: {
+    label: 'Aider',
+    reasoning: 4,
+    refactoring: 5,
+    debugging: 4,
+    review: 3,
+    architecture: 3,
+    ci: 4,
+    ide: 1,
+    ui: 1,
+    async: 2,
+    inline: 1,
+    context: 2,
+    automation: 2,
+    sandbox: 1,
+    cloudTasks: 1,
+    cloudAgent: 1,
+    background: 1,
+    governance: 2,
+  },
+  opencode: {
+    label: 'OpenCode',
+    reasoning: 4,
+    refactoring: 4,
+    debugging: 4,
+    review: 4,
+    architecture: 4,
+    ci: 4,
+    ide: 3,
+    ui: 2,
+    async: 4,
+    inline: 2,
+    context: 4,
+    automation: 4,
+    sandbox: 4,
+    cloudTasks: 3,
+    cloudAgent: 3,
+    background: 3,
+    governance: 4,
+  },
+};
+
+const CAPABILITY_LABELS = {
+  reasoning: 'Complex reasoning & analysis',
+  refactoring: 'Code refactoring',
+  debugging: 'Bug diagnosis & debugging',
+  review: 'Code review',
+  architecture: 'Architecture design',
+  ci: 'CI/CD pipeline integration',
+  ide: 'IDE integration',
+  ui: 'UI/frontend work',
+  async: 'Async/background tasks',
+  inline: 'Inline code completion',
+  context: 'Large context handling',
+  automation: 'Workflow automation',
+  sandbox: 'Sandboxed execution',
+  cloudTasks: 'Cloud-based tasks',
+  cloudAgent: 'Cloud agent mode',
+  background: 'Background processing',
+  governance: 'Governance & permissions',
+};
+
+module.exports = { PLATFORM_CAPABILITIES, CAPABILITY_LABELS };

package/src/state-paths.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_STATE_ROOT = ['.nerviq'];
+const LEGACY_PROJECT_STATE_ROOT = ['.claude', 'claudex-setup'];
+const HARMONY_STATE_ROOT = ['.nerviq', 'harmony'];
+const LEGACY_HARMONY_STATE_ROOT = ['.claudex', 'harmony'];
+const GEMINI_STATE_ROOT = ['.gemini', '.nerviq'];
+const LEGACY_GEMINI_STATE_ROOT = ['.gemini', '.claudex'];
+
+function buildPath(dir, rootSegments, segments) {
+  return path.join(dir, ...rootSegments, ...segments);
+}
+
+function resolveReadablePath(dir, preferredRoot, legacyRoot, ...segments) {
+  const preferredPath = buildPath(dir, preferredRoot, segments);
+  if (fs.existsSync(preferredPath)) return preferredPath;
+
+  const legacyPath = buildPath(dir, legacyRoot, segments);
+  if (fs.existsSync(legacyPath)) return legacyPath;
+
+  return preferredPath;
+}
+
+function ensureWritableDir(dir, rootSegments, ...segments) {
+  const targetPath = buildPath(dir, rootSegments, segments);
+  fs.mkdirSync(targetPath, { recursive: true });
+  return targetPath;
+}
+
+function resolveProjectStatePath(dir, ...segments) {
+  return buildPath(dir, PROJECT_STATE_ROOT, segments);
+}
+
+function resolveProjectStateReadPath(dir, ...segments) {
+  return resolveReadablePath(dir, PROJECT_STATE_ROOT, LEGACY_PROJECT_STATE_ROOT, ...segments);
+}
+
+function ensureProjectStateDir(dir, ...segments) {
+  return ensureWritableDir(dir, PROJECT_STATE_ROOT, ...segments);
+}
+
+function resolveHarmonyStatePath(dir, ...segments) {
+  return buildPath(dir, HARMONY_STATE_ROOT, segments);
+}
+
+function resolveHarmonyStateReadPath(dir, ...segments) {
+  return resolveReadablePath(dir, HARMONY_STATE_ROOT, LEGACY_HARMONY_STATE_ROOT, ...segments);
+}
+
+function ensureHarmonyStateDir(dir, ...segments) {
+  return ensureWritableDir(dir, HARMONY_STATE_ROOT, ...segments);
+}
+
+function resolveGeminiStatePath(dir, ...segments) {
+  return buildPath(dir, GEMINI_STATE_ROOT, segments);
+}
+
+function resolveGeminiStateReadPath(dir, ...segments) {
+  return resolveReadablePath(dir, GEMINI_STATE_ROOT, LEGACY_GEMINI_STATE_ROOT, ...segments);
+}
+
+function ensureGeminiStateDir(dir, ...segments) {
+  return ensureWritableDir(dir, GEMINI_STATE_ROOT, ...segments);
+}
+
+module.exports = {
+  PROJECT_STATE_ROOT,
+  LEGACY_PROJECT_STATE_ROOT,
+  HARMONY_STATE_ROOT,
+  LEGACY_HARMONY_STATE_ROOT,
+  GEMINI_STATE_ROOT,
+  LEGACY_GEMINI_STATE_ROOT,
+  resolveReadablePath,
+  ensureWritableDir,
+  resolveProjectStatePath,
+  resolveProjectStateReadPath,
+  ensureProjectStateDir,
+  resolveHarmonyStatePath,
+  resolveHarmonyStateReadPath,
+  ensureHarmonyStateDir,
+  resolveGeminiStatePath,
+  resolveGeminiStateReadPath,
+  ensureGeminiStateDir,
+};

package/src/synergy/compensation.js

@@ -5,26 +5,7 @@
  * platform additions to fill coverage gaps.
  */
 
-const { PLATFORM_CAPABILITIES } = require('./routing');
-
-const AREA_LABELS = {
-  reasoning: 'Complex reasoning & analysis',
-  refactoring: 'Code refactoring',
-  debugging: 'Bug diagnosis & debugging',
-  CI: 'CI/CD pipeline integration',
-  IDE: 'IDE integration',
-  UI: 'UI/frontend work',
-  async: 'Async/background tasks',
-  review: 'Code review',
-  architecture: 'Architecture design',
-  inline: 'Inline code completion',
-  cloudTasks: 'Cloud-based tasks',
-  context: 'Large context handling',
-  sandbox: 'Sandboxed execution',
-  cloudAgent: 'Cloud agent mode',
-  background: 'Background processing',
-  automation: 'Workflow automation',
-};
+const { PLATFORM_CAPABILITIES, CAPABILITY_LABELS: AREA_LABELS } = require('../shared/capabilities');
 
 const WEAKNESS_THRESHOLD = 3;
 const STRENGTH_THRESHOLD = 4;