@nerviq/cli 0.0.1 → 0.9.0-beta.2

package/src/synergy/adaptive.js

@@ -0,0 +1,261 @@
+/**
+ * S8. Adaptive Project Configuration
+ *
+ * Detects project changes and propagates configuration updates
+ * across all active platforms automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PLATFORM_CONFIG_FILES = {
+  claude: ['CLAUDE.md', '.claude/settings.json', '.claude/commands', '.claude/rules'],
+  codex: ['AGENTS.md', 'codex.json', '.codex'],
+  gemini: ['GEMINI.md', '.gemini/settings.json'],
+  copilot: ['.github/copilot-instructions.md', '.github/copilot'],
+  cursor: ['.cursor/rules', '.cursorrules'],
+};
+
+const CHANGE_DETECTORS = [
+  {
+    type: 'new-api-route',
+    detect: (current, previous) => {
+      const currentRoutes = (current.routes || []);
+      const previousRoutes = (previous.routes || []);
+      const newRoutes = currentRoutes.filter(r => !previousRoutes.includes(r));
+      return newRoutes.length > 0 ? { newRoutes } : null;
+    },
+    impact: (data) => ({
+      description: `New API route(s): ${data.newRoutes.join(', ')}`,
+      affectedPlatforms: ['claude', 'codex', 'gemini', 'copilot', 'cursor'],
+      recommendedAction: 'Update architecture documentation in all instruction files',
+      priority: 'medium',
+    }),
+  },
+  {
+    type: 'new-dependency',
+    detect: (current, previous) => {
+      const currentDeps = Object.keys(current.dependencies || {});
+      const previousDeps = Object.keys(previous.dependencies || {});
+      const newDeps = currentDeps.filter(d => !previousDeps.includes(d));
+      return newDeps.length > 0 ? { newDeps } : null;
+    },
+    impact: (data) => ({
+      description: `New dependencies: ${data.newDeps.join(', ')}`,
+      affectedPlatforms: ['claude', 'codex', 'gemini', 'copilot', 'cursor'],
+      recommendedAction: 'Add dependency context to instruction files; check for MCP pack needs',
+      priority: 'low',
+    }),
+  },
+  {
+    type: 'new-ci-workflow',
+    detect: (current, previous) => {
+      const currentCI = (current.ciWorkflows || []);
+      const previousCI = (previous.ciWorkflows || []);
+      const newCI = currentCI.filter(w => !previousCI.includes(w));
+      return newCI.length > 0 ? { newCI } : null;
+    },
+    impact: (data) => ({
+      description: `New CI workflow(s): ${data.newCI.join(', ')}`,
+      affectedPlatforms: ['claude', 'codex', 'copilot'],
+      recommendedAction: 'Align CI review commands across platforms',
+      priority: 'medium',
+    }),
+  },
+  {
+    type: 'new-database',
+    detect: (current, previous) => {
+      const currentDBs = (current.databases || []);
+      const previousDBs = (previous.databases || []);
+      const newDBs = currentDBs.filter(db => !previousDBs.includes(db));
+      return newDBs.length > 0 ? { newDBs } : null;
+    },
+    impact: (data) => ({
+      description: `New database(s): ${data.newDBs.join(', ')}`,
+      affectedPlatforms: ['claude', 'codex', 'gemini', 'copilot', 'cursor'],
+      recommendedAction: 'Add database MCP on all platforms; update architecture docs',
+      priority: 'high',
+    }),
+  },
+  {
+    type: 'stack-change',
+    detect: (current, previous) => {
+      const currentStacks = (current.stacks || []);
+      const previousStacks = (previous.stacks || []);
+      const added = currentStacks.filter(s => !previousStacks.includes(s));
+      const removed = previousStacks.filter(s => !currentStacks.includes(s));
+      return (added.length > 0 || removed.length > 0) ? { added, removed } : null;
+    },
+    impact: (data) => ({
+      description: `Stack changes — added: ${data.added.join(', ') || 'none'}, removed: ${data.removed.join(', ') || 'none'}`,
+      affectedPlatforms: ['claude', 'codex', 'gemini', 'copilot', 'cursor'],
+      recommendedAction: 'Reconfigure domain packs and technique checks for new stack',
+      priority: 'high',
+    }),
+  },
+  {
+    type: 'config-file-change',
+    detect: (current, previous) => {
+      const currentConfigs = (current.configFiles || []);
+      const previousConfigs = (previous.configFiles || []);
+      const changed = currentConfigs.filter(c => !previousConfigs.includes(c));
+      return changed.length > 0 ? { changed } : null;
+    },
+    impact: (data) => ({
+      description: `Config file changes: ${data.changed.join(', ')}`,
+      affectedPlatforms: ['claude', 'codex', 'gemini', 'copilot', 'cursor'],
+      recommendedAction: 'Review and sync configuration changes across platforms',
+      priority: 'low',
+    }),
+  },
+];
+
+/**
+ * Build a simple canonical model of the project state for comparison.
+ */
+function buildSimpleCanon(dir) {
+  const canon = {
+    dependencies: {},
+    routes: [],
+    ciWorkflows: [],
+    databases: [],
+    stacks: [],
+    configFiles: [],
+  };
+
+  // Read package.json dependencies
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+    canon.dependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // Detect databases from dependencies
+    const dbIndicators = {
+      pg: 'postgres', mysql2: 'mysql', mongodb: 'mongodb', mongoose: 'mongodb',
+      redis: 'redis', ioredis: 'redis', sqlite3: 'sqlite', prisma: 'prisma',
+      typeorm: 'typeorm', sequelize: 'sequelize',
+    };
+    for (const dep of Object.keys(canon.dependencies)) {
+      if (dbIndicators[dep]) canon.databases.push(dbIndicators[dep]);
+    }
+  } catch { /* no package.json */ }
+
+  // Detect CI workflows
+  try {
+    const ghDir = path.join(dir, '.github', 'workflows');
+    if (fs.existsSync(ghDir)) {
+      canon.ciWorkflows = fs.readdirSync(ghDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+    }
+  } catch { /* no workflows */ }
+
+  // Detect config files
+  for (const configs of Object.values(PLATFORM_CONFIG_FILES)) {
+    for (const configPath of configs) {
+      try {
+        if (fs.existsSync(path.join(dir, configPath))) {
+          canon.configFiles.push(configPath);
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  return canon;
+}
+
+/**
+ * Detect project changes by comparing current state against previous canon.
+ *
+ * @param {string} dir - Project directory
+ * @param {Object} previousCanon - Previous canonical model (from last run)
+ * @returns {Object} Detected changes with cross-platform impact
+ */
+function detectProjectChanges(dir, previousCanon) {
+  const currentCanon = buildSimpleCanon(dir);
+  const prev = previousCanon || {};
+  const changes = [];
+
+  for (const detector of CHANGE_DETECTORS) {
+    const data = detector.detect(currentCanon, prev);
+    if (data) {
+      const impact = detector.impact(data);
+      changes.push({
+        type: detector.type,
+        ...impact,
+        data,
+      });
+    }
+  }
+
+  return {
+    changes,
+    currentCanon,
+    summary: changes.length > 0
+      ? `${changes.length} change(s) detected affecting ${new Set(changes.flatMap(c => c.affectedPlatforms)).size} platform(s)`
+      : 'No changes detected',
+  };
+}
+
+/**
+ * Generate platform-native configuration updates for detected changes.
+ *
+ * @param {Object[]} changes - Changes from detectProjectChanges
+ * @returns {Object} Platform-specific update instructions
+ */
+function generateAdaptiveUpdates(changes) {
+  if (!Array.isArray(changes) || changes.length === 0) {
+    return { updates: [], summary: 'No changes to propagate' };
+  }
+
+  const updates = [];
+
+  for (const change of changes) {
+    const platforms = change.affectedPlatforms || [];
+
+    for (const platform of platforms) {
+      const configFiles = PLATFORM_CONFIG_FILES[platform] || [];
+      const primaryConfig = configFiles[0];
+      if (!primaryConfig) continue;
+
+      let content = '';
+      let action = 'append';
+
+      switch (change.type) {
+        case 'new-api-route':
+          content = `\n## API Routes (auto-detected)\n${(change.data.newRoutes || []).map(r => `- ${r}`).join('\n')}\n`;
+          break;
+        case 'new-dependency':
+          content = `\n<!-- New dependencies: ${(change.data.newDeps || []).join(', ')} -->\n`;
+          action = 'append';
+          break;
+        case 'new-database':
+          content = `\n## Database\nThis project uses: ${(change.data.newDBs || []).join(', ')}\n`;
+          break;
+        case 'new-ci-workflow':
+          content = `\n## CI/CD\nWorkflows: ${(change.data.newCI || []).join(', ')}\n`;
+          break;
+        case 'stack-change':
+          content = `\n## Stack Update\nAdded: ${(change.data.added || []).join(', ') || 'none'}\nRemoved: ${(change.data.removed || []).join(', ') || 'none'}\n`;
+          break;
+        default:
+          content = `\n<!-- Change detected: ${change.description} -->\n`;
+      }
+
+      updates.push({
+        platform,
+        file: primaryConfig,
+        action,
+        content,
+        reason: change.description,
+        priority: change.priority || 'low',
+      });
+    }
+  }
+
+  const affectedPlatforms = new Set(updates.map(u => u.platform));
+
+  return {
+    updates,
+    summary: `${changes.length} change(s) detected, ${affectedPlatforms.size} platform(s) affected, ${updates.length} update(s) generated`,
+  };
+}
+
+module.exports = { detectProjectChanges, generateAdaptiveUpdates };

package/src/synergy/compensation.js

@@ -0,0 +1,156 @@
+/**
+ * S4. Strength/Weakness Compensation
+ *
+ * Identifies where platforms complement each other and recommends
+ * 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 WEAKNESS_THRESHOLD = 3;
+const STRENGTH_THRESHOLD = 4;
+
+/**
+ * Analyze where platforms compensate for each other's weaknesses.
+ *
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @param {Object} [platformAudits] - Optional audit results per platform
+ * @returns {Object} Compensation analysis
+ */
+function analyzeCompensation(activePlatforms, platformAudits) {
+  const platforms = (activePlatforms || []).filter(p => PLATFORM_CAPABILITIES[p]);
+  const compensations = [];
+  const uncoveredGaps = [];
+
+  // Gather all capability areas across active platforms
+  const allAreas = new Set();
+  for (const platform of platforms) {
+    for (const area of Object.keys(PLATFORM_CAPABILITIES[platform])) {
+      allAreas.add(area);
+    }
+  }
+
+  // For each platform, find weaknesses and check if another compensates
+  for (const platform of platforms) {
+    const caps = PLATFORM_CAPABILITIES[platform];
+
+    for (const area of allAreas) {
+      const score = caps[area] || 0;
+      if (score >= WEAKNESS_THRESHOLD) continue;
+
+      // This is a weakness — look for compensation
+      let bestCompensator = null;
+
+      for (const other of platforms) {
+        if (other === platform) continue;
+        const otherScore = (PLATFORM_CAPABILITIES[other] || {})[area] || 0;
+        if (otherScore >= STRENGTH_THRESHOLD) {
+          if (!bestCompensator || otherScore > bestCompensator.score) {
+            bestCompensator = { platform: other, area, score: otherScore };
+          }
+        }
+      }
+
+      if (bestCompensator) {
+        compensations.push({
+          weakness: { platform, area, score, label: AREA_LABELS[area] || area },
+          compensatedBy: {
+            platform: bestCompensator.platform,
+            area: bestCompensator.area,
+            score: bestCompensator.score,
+            label: AREA_LABELS[area] || area,
+          },
+          netBenefit: bestCompensator.score - score,
+        });
+      } else {
+        uncoveredGaps.push({
+          area,
+          label: AREA_LABELS[area] || area,
+          weakPlatforms: [{ platform, score }],
+        });
+      }
+    }
+  }
+
+  // Deduplicate uncovered gaps by area
+  const gapsByArea = {};
+  for (const gap of uncoveredGaps) {
+    if (!gapsByArea[gap.area]) {
+      gapsByArea[gap.area] = { area: gap.area, label: gap.label, weakPlatforms: [] };
+    }
+    gapsByArea[gap.area].weakPlatforms.push(...gap.weakPlatforms);
+  }
+  const dedupedGaps = Object.values(gapsByArea);
+
+  // Recommend platform additions that would fill gaps
+  const inactivePlatforms = Object.keys(PLATFORM_CAPABILITIES).filter(
+    p => !platforms.includes(p)
+  );
+  const recommendedAdditions = [];
+
+  for (const candidate of inactivePlatforms) {
+    const candidateCaps = PLATFORM_CAPABILITIES[candidate];
+    const wouldCover = [];
+    let estimatedBenefit = 0;
+
+    for (const gap of dedupedGaps) {
+      const candidateScore = candidateCaps[gap.area] || 0;
+      if (candidateScore >= STRENGTH_THRESHOLD) {
+        wouldCover.push({
+          area: gap.area,
+          label: gap.label,
+          score: candidateScore,
+        });
+        estimatedBenefit += candidateScore;
+      }
+    }
+
+    if (wouldCover.length > 0) {
+      recommendedAdditions.push({
+        platform: candidate,
+        wouldCover,
+        estimatedBenefit,
+      });
+    }
+  }
+
+  recommendedAdditions.sort((a, b) => b.estimatedBenefit - a.estimatedBenefit);
+
+  return {
+    compensations,
+    uncoveredGaps: dedupedGaps,
+    recommendedAdditions,
+  };
+}
+
+/**
+ * Get areas not well covered by any active platform.
+ *
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @returns {Object[]} Uncovered gap areas
+ */
+function getUncoveredGaps(activePlatforms) {
+  const result = analyzeCompensation(activePlatforms);
+  return result.uncoveredGaps;
+}
+
+module.exports = { analyzeCompensation, getUncoveredGaps };

package/src/synergy/evidence.js

@@ -0,0 +1,193 @@
+/**
+ * S3. Compound Evidence System
+ *
+ * Combines audit findings from multiple platforms for stronger insights.
+ * Cross-validates findings and calculates compound amplification scores.
+ */
+
+/**
+ * Normalize a finding key across platforms.
+ * Different platforms may name the same concept differently.
+ */
+function normalizeFindingKey(finding) {
+  // Use the technique key or a composite of category+name
+  return finding.key || `${finding.category || 'unknown'}:${finding.name || 'unnamed'}`;
+}
+
+/**
+ * Group findings by their normalized concept.
+ */
+function groupByConcept(platformAudits) {
+  const concepts = {};
+
+  for (const [platform, auditResult] of Object.entries(platformAudits)) {
+    if (!auditResult || !auditResult.results) continue;
+
+    for (const finding of auditResult.results) {
+      const key = normalizeFindingKey(finding);
+      if (!concepts[key]) {
+        concepts[key] = {
+          key,
+          name: finding.name,
+          category: finding.category,
+          impact: finding.impact,
+          platforms: {},
+        };
+      }
+      concepts[key].platforms[platform] = {
+        passed: finding.passed,
+        fix: finding.fix,
+      };
+    }
+  }
+
+  return concepts;
+}
+
+/**
+ * Combine audit findings from multiple platforms for stronger insights.
+ *
+ * @param {Object} platformAudits - { claude: auditResult, codex: auditResult, ... }
+ * @returns {Object} Compound audit result with cross-validation and amplification
+ */
+function compoundAudit(platformAudits) {
+  const platforms = Object.keys(platformAudits).filter(
+    p => platformAudits[p] && platformAudits[p].results
+  );
+
+  if (platforms.length === 0) {
+    return {
+      compoundScore: 0,
+      bestSingleScore: 0,
+      amplification: 0,
+      totalFindings: 0,
+      crossValidated: [],
+      platformUnique: {},
+      coverageMap: {},
+    };
+  }
+
+  const concepts = groupByConcept(platformAudits);
+  const crossValidated = [];
+  const platformUnique = {};
+  const coverageMap = {};
+
+  for (const platform of platforms) {
+    platformUnique[platform] = [];
+    coverageMap[platform] = { found: 0, unique: 0, shared: 0 };
+  }
+
+  // Analyze each concept across platforms
+  for (const [key, concept] of Object.entries(concepts)) {
+    const involvedPlatforms = Object.keys(concept.platforms);
+    const failedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === false);
+    const passedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === true);
+
+    // Track coverage
+    for (const p of involvedPlatforms) {
+      coverageMap[p].found++;
+    }
+
+    if (involvedPlatforms.length >= 2) {
+      // Cross-validated finding
+      for (const p of involvedPlatforms) {
+        coverageMap[p].shared++;
+      }
+
+      if (failedOn.length >= 2) {
+        crossValidated.push({
+          key,
+          name: concept.name,
+          category: concept.category,
+          impact: concept.impact,
+          failedOn,
+          passedOn,
+          confidence: Math.min(1, 0.5 + (failedOn.length * 0.15)),
+          verdict: failedOn.length === involvedPlatforms.length
+            ? 'universal-gap'
+            : 'partial-gap',
+        });
+      } else if (passedOn.length >= 2) {
+        crossValidated.push({
+          key,
+          name: concept.name,
+          category: concept.category,
+          impact: concept.impact,
+          failedOn,
+          passedOn,
+          confidence: Math.min(1, 0.5 + (passedOn.length * 0.15)),
+          verdict: 'cross-validated-pass',
+        });
+      }
+    } else {
+      // Platform-unique finding
+      const platform = involvedPlatforms[0];
+      coverageMap[platform].unique++;
+      platformUnique[platform].push({
+        key,
+        name: concept.name,
+        category: concept.category,
+        impact: concept.impact,
+        passed: concept.platforms[platform].passed,
+        fix: concept.platforms[platform].fix,
+      });
+    }
+  }
+
+  // Calculate scores
+  const singleScores = platforms.map(p => platformAudits[p].score || 0);
+  const bestSingleScore = Math.max(...singleScores);
+
+  // Compound score = best single + bonus from cross-validation + bonus from unique coverage
+  const crossValidationBonus = crossValidated
+    .filter(cv => cv.verdict === 'cross-validated-pass')
+    .length * 0.5;
+  const uniqueCoverageBonus = Object.values(platformUnique)
+    .reduce((sum, findings) => sum + findings.filter(f => f.passed).length, 0) * 0.3;
+  const totalUniqueFindings = Object.keys(concepts).length;
+
+  const compoundScore = Math.round(
+    Math.min(150, bestSingleScore + crossValidationBonus + uniqueCoverageBonus)
+  );
+
+  return {
+    compoundScore,
+    bestSingleScore,
+    amplification: compoundScore - bestSingleScore,
+    totalFindings: totalUniqueFindings,
+    crossValidated,
+    platformUnique,
+    coverageMap,
+  };
+}
+
+/**
+ * Calculate the amplification factor from combining multiple platforms.
+ *
+ * @param {Object} platformAudits - Per-platform audit results
+ * @returns {Object} Amplification metrics
+ */
+function calculateAmplification(platformAudits) {
+  const result = compoundAudit(platformAudits);
+  const platformCount = Object.keys(platformAudits).filter(
+    p => platformAudits[p] && platformAudits[p].results
+  ).length;
+
+  return {
+    amplification: result.amplification,
+    amplificationPercent: result.bestSingleScore > 0
+      ? Math.round((result.amplification / result.bestSingleScore) * 100)
+      : 0,
+    platformCount,
+    crossValidatedCount: result.crossValidated.length,
+    uniqueFindingsPerPlatform: Object.fromEntries(
+      Object.entries(result.platformUnique).map(([p, findings]) => [p, findings.length])
+    ),
+    verdict: result.amplification > 10 ? 'strong-synergy'
+      : result.amplification > 5 ? 'moderate-synergy'
+      : result.amplification > 0 ? 'mild-synergy'
+      : 'no-synergy',
+  };
+}
+
+module.exports = { compoundAudit, calculateAmplification };