@nerviq/cli 1.20.0 → 1.21.0

package/src/synergy/patterns.js

@@ -1,227 +1,227 @@
-/**
- * S5. Cross-Platform Pattern Discovery
- *
- * Finds patterns only visible from a cross-platform perspective:
- * recurring failures, platform-specific successes, sequence effects,
- * and diminishing returns.
- */
-
-const { PLATFORM_CAPABILITIES } = require('./routing');
-
-/**
- * Detect recurring failures across platforms (root cause is project, not platform).
- */
-function detectRecurringFailures(harmonyHistory) {
-  const patterns = [];
-  const failureCounts = {};
-
-  for (const entry of harmonyHistory) {
-    if (!entry.findings) continue;
-    for (const finding of entry.findings) {
-      if (finding.passed === false) {
-        const key = finding.key || finding.name;
-        if (!failureCounts[key]) {
-          failureCounts[key] = { key, name: finding.name, category: finding.category, platforms: new Set() };
-        }
-        failureCounts[key].platforms.add(entry.platform);
-      }
-    }
-  }
-
-  for (const [key, data] of Object.entries(failureCounts)) {
-    if (data.platforms.size >= 3) {
-      patterns.push({
-        type: 'recurring-failure',
-        description: `"${data.name || key}" fails on ${data.platforms.size} platforms — root cause is project-level, not platform-specific`,
-        key: data.key,
-        affectedPlatforms: [...data.platforms],
-        severity: data.platforms.size >= 4 ? 'high' : 'medium',
-      });
-    }
-  }
-
-  return patterns;
-}
-
-/**
- * Detect platform-specific successes (recommendation only works on one platform).
- */
-function detectPlatformSpecificSuccess(harmonyHistory) {
-  const patterns = [];
-  const outcomesByKey = {};
-
-  for (const entry of harmonyHistory) {
-    if (!entry.findings) continue;
-    for (const finding of entry.findings) {
-      const key = finding.key || finding.name;
-      if (!outcomesByKey[key]) outcomesByKey[key] = {};
-      outcomesByKey[key][entry.platform] = finding.passed;
-    }
-  }
-
-  for (const [key, platforms] of Object.entries(outcomesByKey)) {
-    const entries = Object.entries(platforms);
-    if (entries.length < 2) continue;
-
-    const passed = entries.filter(([, v]) => v === true);
-    const failed = entries.filter(([, v]) => v === false);
-
-    if (passed.length === 1 && failed.length >= 2) {
-      patterns.push({
-        type: 'platform-specific-success',
-        description: `"${key}" only passes on ${passed[0][0]} — fails on ${failed.map(f => f[0]).join(', ')}`,
-        key,
-        successPlatform: passed[0][0],
-        failPlatforms: failed.map(f => f[0]),
-      });
-    }
-  }
-
-  return patterns;
-}
-
-/**
- * Analyze sequence effects (order of platform setup matters).
- */
-function analyzeSequenceEffects(harmonyHistory) {
-  const patterns = [];
-  const sequenceScores = {};
-
-  // Group history entries by timestamp to detect sequences
-  const sorted = [...harmonyHistory].sort((a, b) =>
-    new Date(a.timestamp || 0) - new Date(b.timestamp || 0)
-  );
-
-  // Look at consecutive pairs
-  for (let i = 0; i < sorted.length - 1; i++) {
-    const first = sorted[i];
-    const second = sorted[i + 1];
-    if (!first.platform || !second.platform || first.platform === second.platform) continue;
-
-    const seqKey = `${first.platform}→${second.platform}`;
-    if (!sequenceScores[seqKey]) {
-      sequenceScores[seqKey] = { scores: [], firstScores: [], secondScores: [] };
-    }
-
-    if (second.score !== undefined) {
-      sequenceScores[seqKey].secondScores.push(second.score);
-    }
-    if (first.score !== undefined) {
-      sequenceScores[seqKey].firstScores.push(first.score);
-    }
-  }
-
-  for (const [seq, data] of Object.entries(sequenceScores)) {
-    if (data.secondScores.length < 2) continue;
-    const avgSecond = data.secondScores.reduce((a, b) => a + b, 0) / data.secondScores.length;
-
-    // Check if reverse sequence exists and compare
-    const [first, second] = seq.split('→');
-    const reverseKey = `${second}→${first}`;
-    const reverseData = sequenceScores[reverseKey];
-
-    if (reverseData && reverseData.secondScores.length >= 2) {
-      const avgReverse = reverseData.secondScores.reduce((a, b) => a + b, 0) / reverseData.secondScores.length;
-      if (Math.abs(avgSecond - avgReverse) > 5) {
-        const better = avgSecond > avgReverse ? seq : reverseKey;
-        patterns.push({
-          type: 'sequence-effect',
-          description: `Setup order "${better}" produces better results (${Math.round(Math.max(avgSecond, avgReverse))} vs ${Math.round(Math.min(avgSecond, avgReverse))})`,
-          bestSequence: better,
-          scoreDifference: Math.round(Math.abs(avgSecond - avgReverse)),
-        });
-      }
-    }
-  }
-
-  return patterns;
-}
-
-/**
- * Detect diminishing returns from adding more platforms.
- */
-function detectDiminishingReturns(harmonyHistory) {
-  const patterns = [];
-
-  // Group by project (dir) and count platforms vs score improvement
-  const byProject = {};
-  for (const entry of harmonyHistory) {
-    const dir = entry.dir || 'unknown';
-    if (!byProject[dir]) byProject[dir] = [];
-    byProject[dir].push(entry);
-  }
-
-  for (const [dir, entries] of Object.entries(byProject)) {
-    const platformScores = {};
-    for (const entry of entries) {
-      if (entry.platform && entry.score !== undefined) {
-        platformScores[entry.platform] = entry.score;
-      }
-    }
-
-    const platforms = Object.keys(platformScores);
-    if (platforms.length < 3) continue;
-
-    // Sort by score descending to see marginal value of each addition
-    const sorted = Object.entries(platformScores).sort((a, b) => b[1] - a[1]);
-    const marginals = [];
-    let cumulative = 0;
-
-    for (let i = 0; i < sorted.length; i++) {
-      const marginal = i === 0 ? sorted[i][1] : Math.max(0, sorted[i][1] - cumulative / i);
-      marginals.push({ platform: sorted[i][0], score: sorted[i][1], marginalValue: Math.round(marginal) });
-      cumulative += sorted[i][1];
-    }
-
-    // Check if last platforms add significantly less
-    if (marginals.length >= 3) {
-      const firstMarginal = marginals[0].marginalValue;
-      const lastMarginal = marginals[marginals.length - 1].marginalValue;
-
-      if (firstMarginal > 0 && lastMarginal < firstMarginal * 0.3) {
-        patterns.push({
-          type: 'diminishing-returns',
-          description: `Platform #${marginals.length} (${marginals[marginals.length - 1].platform}) adds ${lastMarginal} marginal value vs ${firstMarginal} from #1 (${marginals[0].platform})`,
-          marginals,
-          dir,
-        });
-      }
-    }
-  }
-
-  return patterns;
-}
-
-/**
- * Discover all cross-platform patterns from harmony history.
- *
- * @param {Object[]} harmonyHistory - Array of audit/harmony run entries
- * @returns {Object} Discovered patterns by type
- */
-function discoverPatterns(harmonyHistory) {
-  if (!Array.isArray(harmonyHistory) || harmonyHistory.length === 0) {
-    return { patterns: [] };
-  }
-
-  const patterns = [
-    ...detectRecurringFailures(harmonyHistory),
-    ...detectPlatformSpecificSuccess(harmonyHistory),
-    ...analyzeSequenceEffects(harmonyHistory),
-    ...detectDiminishingReturns(harmonyHistory),
-  ];
-
-  return { patterns };
-}
-
-/**
- * Focused analysis of sequence effects only.
- *
- * @param {Object[]} harmonyHistory - Array of audit/harmony run entries
- * @returns {Object[]} Sequence effect patterns
- */
-function analyzeSequenceEffectsOnly(harmonyHistory) {
-  if (!Array.isArray(harmonyHistory)) return [];
-  return analyzeSequenceEffects(harmonyHistory);
-}
-
-module.exports = { discoverPatterns, analyzeSequenceEffects: analyzeSequenceEffectsOnly };
+/**
+ * S5. Cross-Platform Pattern Discovery
+ *
+ * Finds patterns only visible from a cross-platform perspective:
+ * recurring failures, platform-specific successes, sequence effects,
+ * and diminishing returns.
+ */
+
+const { PLATFORM_CAPABILITIES } = require('./routing');
+
+/**
+ * Detect recurring failures across platforms (root cause is project, not platform).
+ */
+function detectRecurringFailures(harmonyHistory) {
+  const patterns = [];
+  const failureCounts = {};
+
+  for (const entry of harmonyHistory) {
+    if (!entry.findings) continue;
+    for (const finding of entry.findings) {
+      if (finding.passed === false) {
+        const key = finding.key || finding.name;
+        if (!failureCounts[key]) {
+          failureCounts[key] = { key, name: finding.name, category: finding.category, platforms: new Set() };
+        }
+        failureCounts[key].platforms.add(entry.platform);
+      }
+    }
+  }
+
+  for (const [key, data] of Object.entries(failureCounts)) {
+    if (data.platforms.size >= 3) {
+      patterns.push({
+        type: 'recurring-failure',
+        description: `"${data.name || key}" fails on ${data.platforms.size} platforms — root cause is project-level, not platform-specific`,
+        key: data.key,
+        affectedPlatforms: [...data.platforms],
+        severity: data.platforms.size >= 4 ? 'high' : 'medium',
+      });
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Detect platform-specific successes (recommendation only works on one platform).
+ */
+function detectPlatformSpecificSuccess(harmonyHistory) {
+  const patterns = [];
+  const outcomesByKey = {};
+
+  for (const entry of harmonyHistory) {
+    if (!entry.findings) continue;
+    for (const finding of entry.findings) {
+      const key = finding.key || finding.name;
+      if (!outcomesByKey[key]) outcomesByKey[key] = {};
+      outcomesByKey[key][entry.platform] = finding.passed;
+    }
+  }
+
+  for (const [key, platforms] of Object.entries(outcomesByKey)) {
+    const entries = Object.entries(platforms);
+    if (entries.length < 2) continue;
+
+    const passed = entries.filter(([, v]) => v === true);
+    const failed = entries.filter(([, v]) => v === false);
+
+    if (passed.length === 1 && failed.length >= 2) {
+      patterns.push({
+        type: 'platform-specific-success',
+        description: `"${key}" only passes on ${passed[0][0]} — fails on ${failed.map(f => f[0]).join(', ')}`,
+        key,
+        successPlatform: passed[0][0],
+        failPlatforms: failed.map(f => f[0]),
+      });
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Analyze sequence effects (order of platform setup matters).
+ */
+function analyzeSequenceEffects(harmonyHistory) {
+  const patterns = [];
+  const sequenceScores = {};
+
+  // Group history entries by timestamp to detect sequences
+  const sorted = [...harmonyHistory].sort((a, b) =>
+    new Date(a.timestamp || 0) - new Date(b.timestamp || 0)
+  );
+
+  // Look at consecutive pairs
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const first = sorted[i];
+    const second = sorted[i + 1];
+    if (!first.platform || !second.platform || first.platform === second.platform) continue;
+
+    const seqKey = `${first.platform}→${second.platform}`;
+    if (!sequenceScores[seqKey]) {
+      sequenceScores[seqKey] = { scores: [], firstScores: [], secondScores: [] };
+    }
+
+    if (second.score !== undefined) {
+      sequenceScores[seqKey].secondScores.push(second.score);
+    }
+    if (first.score !== undefined) {
+      sequenceScores[seqKey].firstScores.push(first.score);
+    }
+  }
+
+  for (const [seq, data] of Object.entries(sequenceScores)) {
+    if (data.secondScores.length < 2) continue;
+    const avgSecond = data.secondScores.reduce((a, b) => a + b, 0) / data.secondScores.length;
+
+    // Check if reverse sequence exists and compare
+    const [first, second] = seq.split('→');
+    const reverseKey = `${second}→${first}`;
+    const reverseData = sequenceScores[reverseKey];
+
+    if (reverseData && reverseData.secondScores.length >= 2) {
+      const avgReverse = reverseData.secondScores.reduce((a, b) => a + b, 0) / reverseData.secondScores.length;
+      if (Math.abs(avgSecond - avgReverse) > 5) {
+        const better = avgSecond > avgReverse ? seq : reverseKey;
+        patterns.push({
+          type: 'sequence-effect',
+          description: `Setup order "${better}" produces better results (${Math.round(Math.max(avgSecond, avgReverse))} vs ${Math.round(Math.min(avgSecond, avgReverse))})`,
+          bestSequence: better,
+          scoreDifference: Math.round(Math.abs(avgSecond - avgReverse)),
+        });
+      }
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Detect diminishing returns from adding more platforms.
+ */
+function detectDiminishingReturns(harmonyHistory) {
+  const patterns = [];
+
+  // Group by project (dir) and count platforms vs score improvement
+  const byProject = {};
+  for (const entry of harmonyHistory) {
+    const dir = entry.dir || 'unknown';
+    if (!byProject[dir]) byProject[dir] = [];
+    byProject[dir].push(entry);
+  }
+
+  for (const [dir, entries] of Object.entries(byProject)) {
+    const platformScores = {};
+    for (const entry of entries) {
+      if (entry.platform && entry.score !== undefined) {
+        platformScores[entry.platform] = entry.score;
+      }
+    }
+
+    const platforms = Object.keys(platformScores);
+    if (platforms.length < 3) continue;
+
+    // Sort by score descending to see marginal value of each addition
+    const sorted = Object.entries(platformScores).sort((a, b) => b[1] - a[1]);
+    const marginals = [];
+    let cumulative = 0;
+
+    for (let i = 0; i < sorted.length; i++) {
+      const marginal = i === 0 ? sorted[i][1] : Math.max(0, sorted[i][1] - cumulative / i);
+      marginals.push({ platform: sorted[i][0], score: sorted[i][1], marginalValue: Math.round(marginal) });
+      cumulative += sorted[i][1];
+    }
+
+    // Check if last platforms add significantly less
+    if (marginals.length >= 3) {
+      const firstMarginal = marginals[0].marginalValue;
+      const lastMarginal = marginals[marginals.length - 1].marginalValue;
+
+      if (firstMarginal > 0 && lastMarginal < firstMarginal * 0.3) {
+        patterns.push({
+          type: 'diminishing-returns',
+          description: `Platform #${marginals.length} (${marginals[marginals.length - 1].platform}) adds ${lastMarginal} marginal value vs ${firstMarginal} from #1 (${marginals[0].platform})`,
+          marginals,
+          dir,
+        });
+      }
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Discover all cross-platform patterns from harmony history.
+ *
+ * @param {Object[]} harmonyHistory - Array of audit/harmony run entries
+ * @returns {Object} Discovered patterns by type
+ */
+function discoverPatterns(harmonyHistory) {
+  if (!Array.isArray(harmonyHistory) || harmonyHistory.length === 0) {
+    return { patterns: [] };
+  }
+
+  const patterns = [
+    ...detectRecurringFailures(harmonyHistory),
+    ...detectPlatformSpecificSuccess(harmonyHistory),
+    ...analyzeSequenceEffects(harmonyHistory),
+    ...detectDiminishingReturns(harmonyHistory),
+  ];
+
+  return { patterns };
+}
+
+/**
+ * Focused analysis of sequence effects only.
+ *
+ * @param {Object[]} harmonyHistory - Array of audit/harmony run entries
+ * @returns {Object[]} Sequence effect patterns
+ */
+function analyzeSequenceEffectsOnly(harmonyHistory) {
+  if (!Array.isArray(harmonyHistory)) return [];
+  return analyzeSequenceEffects(harmonyHistory);
+}
+
+module.exports = { discoverPatterns, analyzeSequenceEffects: analyzeSequenceEffectsOnly };

package/src/synergy/ranking.js

@@ -1,83 +1,83 @@
-/**
- * S6. Unified Recommendation Ranking
- *
- * Ranks recommendations by cross-platform impact, boosting those that
- * apply broadly, have evidence from other platforms, or fill gaps.
- */
-
-/**
- * Calculate synergy score for a single recommendation.
- *
- * @param {Object} recommendation - A recommendation object
- * @param {string[]} activePlatforms - Currently active platforms
- * @param {Object} [context] - Optional context with evidence and compensation data
- * @returns {number} Synergy score
- */
-function calculateSynergyScore(recommendation, activePlatforms, context) {
-  let score = recommendation.baseScore || recommendation.score || 1;
-  const ctx = context || {};
-
-  // Cross-platform boost: applies to N platforms → x1.2 per additional
-  const applicablePlatforms = (recommendation.applicablePlatforms || [])
-    .filter(p => activePlatforms.includes(p));
-  if (applicablePlatforms.length > 1) {
-    score *= Math.pow(1.2, applicablePlatforms.length - 1);
-  }
-
-  // Evidence boost: validated on another platform → x1.3
-  if (recommendation.validatedOn && recommendation.validatedOn.length > 0) {
-    const externalValidations = recommendation.validatedOn.filter(
-      p => p !== recommendation.sourcePlatform
-    );
-    if (externalValidations.length > 0) {
-      score *= 1.3;
-    }
-  }
-
-  // Compensation boost: fills a gap → x1.5
-  if (recommendation.fillsGap || recommendation.isCompensation) {
-    score *= 1.5;
-  }
-
-  // Cross-learning boost: learned from another platform → x1.2
-  if (recommendation.crossLearningSource) {
-    score *= 1.2;
-  }
-
-  // Impact multiplier
-  const impactMultipliers = { critical: 2.0, high: 1.5, medium: 1.0, low: 0.7 };
-  const impactMult = impactMultipliers[recommendation.impact] || 1.0;
-  score *= impactMult;
-
-  // Historical success boost from context
-  if (ctx.successRate !== undefined && ctx.successRate > 0) {
-    score *= (1 + ctx.successRate * 0.3);
-  }
-
-  return Math.round(score * 100) / 100;
-}
-
-/**
- * Rank recommendations by cross-platform synergy impact.
- *
- * @param {Object[]} recommendations - Array of recommendation objects
- * @param {string[]} activePlatforms - Currently active platforms
- * @param {Object} [context] - Optional context with evidence and compensation data
- * @returns {Object[]} Sorted recommendations with synergyScore attached
- */
-function rankRecommendations(recommendations, activePlatforms, context) {
-  if (!Array.isArray(recommendations) || recommendations.length === 0) {
-    return [];
-  }
-
-  const platforms = activePlatforms || [];
-
-  return recommendations
-    .map(rec => ({
-      ...rec,
-      synergyScore: calculateSynergyScore(rec, platforms, context),
-    }))
-    .sort((a, b) => b.synergyScore - a.synergyScore);
-}
-
-module.exports = { rankRecommendations, calculateSynergyScore };
+/**
+ * S6. Unified Recommendation Ranking
+ *
+ * Ranks recommendations by cross-platform impact, boosting those that
+ * apply broadly, have evidence from other platforms, or fill gaps.
+ */
+
+/**
+ * Calculate synergy score for a single recommendation.
+ *
+ * @param {Object} recommendation - A recommendation object
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @param {Object} [context] - Optional context with evidence and compensation data
+ * @returns {number} Synergy score
+ */
+function calculateSynergyScore(recommendation, activePlatforms, context) {
+  let score = recommendation.baseScore || recommendation.score || 1;
+  const ctx = context || {};
+
+  // Cross-platform boost: applies to N platforms → x1.2 per additional
+  const applicablePlatforms = (recommendation.applicablePlatforms || [])
+    .filter(p => activePlatforms.includes(p));
+  if (applicablePlatforms.length > 1) {
+    score *= Math.pow(1.2, applicablePlatforms.length - 1);
+  }
+
+  // Evidence boost: validated on another platform → x1.3
+  if (recommendation.validatedOn && recommendation.validatedOn.length > 0) {
+    const externalValidations = recommendation.validatedOn.filter(
+      p => p !== recommendation.sourcePlatform
+    );
+    if (externalValidations.length > 0) {
+      score *= 1.3;
+    }
+  }
+
+  // Compensation boost: fills a gap → x1.5
+  if (recommendation.fillsGap || recommendation.isCompensation) {
+    score *= 1.5;
+  }
+
+  // Cross-learning boost: learned from another platform → x1.2
+  if (recommendation.crossLearningSource) {
+    score *= 1.2;
+  }
+
+  // Impact multiplier
+  const impactMultipliers = { critical: 2.0, high: 1.5, medium: 1.0, low: 0.7 };
+  const impactMult = impactMultipliers[recommendation.impact] || 1.0;
+  score *= impactMult;
+
+  // Historical success boost from context
+  if (ctx.successRate !== undefined && ctx.successRate > 0) {
+    score *= (1 + ctx.successRate * 0.3);
+  }
+
+  return Math.round(score * 100) / 100;
+}
+
+/**
+ * Rank recommendations by cross-platform synergy impact.
+ *
+ * @param {Object[]} recommendations - Array of recommendation objects
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @param {Object} [context] - Optional context with evidence and compensation data
+ * @returns {Object[]} Sorted recommendations with synergyScore attached
+ */
+function rankRecommendations(recommendations, activePlatforms, context) {
+  if (!Array.isArray(recommendations) || recommendations.length === 0) {
+    return [];
+  }
+
+  const platforms = activePlatforms || [];
+
+  return recommendations
+    .map(rec => ({
+      ...rec,
+      synergyScore: calculateSynergyScore(rec, platforms, context),
+    }))
+    .sort((a, b) => b.synergyScore - a.synergyScore);
+}
+
+module.exports = { rankRecommendations, calculateSynergyScore };