groove-dev 0.8.0

package/packages/daemon/src/adaptive.js

@@ -0,0 +1,237 @@
+// GROOVE — Adaptive Rotation Threshold System
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+const DEFAULT_THRESHOLD = 0.75;
+const NUDGE_UP = 0.02;   // Good session → allow more context
+const NUDGE_DOWN = 0.05;  // Bad session → rotate sooner
+const MIN_THRESHOLD = 0.40;
+const MAX_THRESHOLD = 0.95;
+const CONVERGENCE_WINDOW = 10; // Stable if last N adjustments < 1%
+
+export class AdaptiveThresholds {
+  constructor(grooveDir) {
+    this.path = resolve(grooveDir, 'rotation-profiles.json');
+    this.profiles = {}; // key: `${provider}:${role}` -> { threshold, history[], converged }
+    this.load();
+  }
+
+  load() {
+    if (existsSync(this.path)) {
+      try {
+        this.profiles = JSON.parse(readFileSync(this.path, 'utf8'));
+      } catch {
+        this.profiles = {};
+      }
+    }
+  }
+
+  save() {
+    writeFileSync(this.path, JSON.stringify(this.profiles, null, 2));
+  }
+
+  profileKey(provider, role) {
+    return `${provider}:${role}`;
+  }
+
+  getProfile(provider, role) {
+    const key = this.profileKey(provider, role);
+    if (!this.profiles[key]) {
+      this.profiles[key] = {
+        threshold: DEFAULT_THRESHOLD,
+        history: [],
+        converged: false,
+        adjustmentCount: 0,
+      };
+    }
+    return this.profiles[key];
+  }
+
+  getThreshold(provider, role) {
+    return this.getProfile(provider, role).threshold;
+  }
+
+  // Score a completed session and adjust the threshold
+  recordSession(provider, role, signals) {
+    const profile = this.getProfile(provider, role);
+    const score = this.scoreSession(signals);
+
+    const oldThreshold = profile.threshold;
+    let newThreshold;
+
+    if (score >= 70) {
+      // Good session — nudge threshold up (allow more context before rotating)
+      newThreshold = Math.min(profile.threshold + NUDGE_UP, MAX_THRESHOLD);
+    } else if (score < 40) {
+      // Bad session — nudge threshold down (rotate sooner)
+      newThreshold = Math.max(profile.threshold - NUDGE_DOWN, MIN_THRESHOLD);
+    } else {
+      // Neutral — no change
+      newThreshold = profile.threshold;
+    }
+
+    profile.threshold = newThreshold;
+    profile.adjustmentCount++;
+
+    const record = {
+      score,
+      oldThreshold,
+      newThreshold,
+      signals,
+      timestamp: new Date().toISOString(),
+    };
+
+    profile.history.push(record);
+    if (profile.history.length > 100) profile.history = profile.history.slice(-100);
+
+    // Check convergence
+    profile.converged = this.checkConvergence(profile);
+
+    this.save();
+    return { score, threshold: newThreshold, converged: profile.converged };
+  }
+
+  scoreSession(signals) {
+    // Score 0-100 based on quality signals.
+    // Low score → rotate sooner (threshold decreases)
+    // High score → allow more context (threshold increases)
+    let score = 70; // Baseline: decent session
+
+    // Error rate: each error costs 5 points
+    const errorCount = signals.errorCount || 0;
+    score -= errorCount * 5;
+
+    // Repetitions: each detected repetition costs 8 points (agent repeating itself)
+    const repetitions = signals.repetitions || 0;
+    score -= repetitions * 8;
+
+    // Out-of-scope access: each violation costs 10 points
+    const scopeViolations = signals.scopeViolations || 0;
+    score -= scopeViolations * 10;
+
+    // Tool call success rate: bonus for high success, penalty for failures
+    const toolCalls = signals.toolCalls || 0;
+    const toolFailures = signals.toolFailures || 0;
+    if (toolCalls > 0) {
+      const successRate = (toolCalls - toolFailures) / toolCalls;
+      score += Math.round((successRate - 0.8) * 20); // Bonus/penalty around 80%
+    }
+
+    // File churn: editing same file 3+ times signals circular refactoring
+    const fileChurn = signals.fileChurn || 0;
+    score -= fileChurn * 12;
+
+    // Error trend: increasing errors in second half = degradation
+    const errorTrend = signals.errorTrend || 0;
+    if (errorTrend > 0) score -= errorTrend * 6;  // getting worse
+    if (errorTrend < 0) score += 3;                // getting better (small bonus)
+
+    // Files written: productivity signal
+    const filesWritten = signals.filesWritten || 0;
+    score += Math.min(filesWritten * 2, 10); // Cap at +10
+
+    // Clamp to 0-100
+    return Math.max(0, Math.min(100, score));
+  }
+
+  checkConvergence(profile) {
+    const history = profile.history;
+    if (history.length < CONVERGENCE_WINDOW) return false;
+
+    const recent = history.slice(-CONVERGENCE_WINDOW);
+    const maxDelta = Math.max(
+      ...recent.map((r) => Math.abs(r.newThreshold - r.oldThreshold))
+    );
+
+    return maxDelta < 0.01; // All recent adjustments < 1%
+  }
+
+  // Extract quality signals from classifier events and filtered log entries.
+  // These signals drive the scoring model that adapts rotation thresholds.
+  extractSignals(entries, agentScope) {
+    const signals = {
+      errorCount: 0,
+      repetitions: 0,
+      scopeViolations: 0,
+      toolCalls: 0,
+      toolFailures: 0,
+      filesWritten: 0,
+      fileChurn: 0,         // same file written 3+ times → possible circular refactoring
+      errorTrend: 0,        // errors increasing in recent window → degradation signal
+    };
+
+    const recentTools = [];
+    const writtenFiles = new Set();
+    const fileWriteCounts = {}; // track how many times each file is written
+    const errorTimestamps = [];
+
+    for (const entry of entries) {
+      if (entry.type === 'error') {
+        signals.errorCount++;
+        errorTimestamps.push(entry.timestamp || Date.now());
+      }
+
+      if (entry.type === 'tool') {
+        signals.toolCalls++;
+
+        // Track file writes and churn
+        if (entry.tool === 'Write' || entry.tool === 'Edit') {
+          if (entry.input) {
+            writtenFiles.add(entry.input);
+            fileWriteCounts[entry.input] = (fileWriteCounts[entry.input] || 0) + 1;
+          }
+        }
+
+        // Track tool failures — errors that follow tool calls indicate failure
+        // (stream-json emits tool_use then tool_result with is_error)
+        if (entry.type === 'tool' && entry.isError) {
+          signals.toolFailures++;
+        }
+
+        // Detect repetitions: same tool+input within last 5 calls
+        const key = `${entry.tool}:${entry.input}`;
+        if (recentTools.includes(key)) {
+          signals.repetitions++;
+        }
+        recentTools.push(key);
+        if (recentTools.length > 5) recentTools.shift();
+
+        // Detect scope violations (simplified check)
+        if (agentScope && agentScope.length > 0 && entry.input) {
+          const file = entry.input;
+          if (entry.tool === 'Write' || entry.tool === 'Edit') {
+            const inScope = agentScope.some((pattern) =>
+              file.includes(pattern.replace('/**', '').replace('**/', ''))
+            );
+            if (!inScope) signals.scopeViolations++;
+          }
+        }
+      }
+    }
+
+    signals.filesWritten = writtenFiles.size;
+
+    // File churn: count files written 3+ times (circular refactoring signal)
+    for (const count of Object.values(fileWriteCounts)) {
+      if (count >= 3) signals.fileChurn++;
+    }
+
+    // Error trend: compare error rate in first half vs second half of session
+    // Increasing errors = degradation signal
+    if (entries.length >= 6) {
+      const mid = Math.floor(entries.length / 2);
+      const firstHalfErrors = entries.slice(0, mid).filter((e) => e.type === 'error').length;
+      const secondHalfErrors = entries.slice(mid).filter((e) => e.type === 'error').length;
+      // Positive = errors increasing (bad), negative = errors decreasing (good)
+      signals.errorTrend = secondHalfErrors - firstHalfErrors;
+    }
+
+    return signals;
+  }
+
+  getAllProfiles() {
+    return this.profiles;
+  }
+}