@evomap/evolver 1.29.0

package/src/gep/hubSearch.js

@@ -0,0 +1,237 @@
+// Hub Search-First Evolution: query evomap-hub for reusable solutions before local solve.
+//
+// Flow: extractSignals() -> hubSearch(signals) -> if hit: reuse; if miss: normal evolve
+// Two modes: direct (skip local reasoning) | reference (inject into prompt as strong hint)
+//
+// Two-phase search-then-fetch to minimize credit cost:
+//   Phase 1: POST /a2a/fetch with signals + search_only=true (free, metadata only)
+//   Phase 2: POST /a2a/fetch with asset_ids=[selected] (pays for 1 asset only)
+
+const { getNodeId, buildFetch, getHubNodeSecret } = require('./a2aProtocol');
+const { logAssetCall } = require('./assetCallLog');
+
+const DEFAULT_MIN_REUSE_SCORE = 0.72;
+const DEFAULT_REUSE_MODE = 'reference'; // 'direct' | 'reference'
+const MAX_STREAK_CAP = 5;
+const TIMEOUT_REASON = 'hub_search_timeout';
+
+function getHubUrl() {
+  return (process.env.A2A_HUB_URL || '').replace(/\/+$/, '');
+}
+
+function getReuseMode() {
+  const m = String(process.env.EVOLVER_REUSE_MODE || DEFAULT_REUSE_MODE).toLowerCase();
+  return m === 'direct' ? 'direct' : 'reference';
+}
+
+function getMinReuseScore() {
+  const n = Number(process.env.EVOLVER_MIN_REUSE_SCORE);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MIN_REUSE_SCORE;
+}
+
+/**
+ * Score a hub asset for local reuse quality.
+ * rank = confidence * min(max(success_streak, 1), MAX_STREAK_CAP) * (reputation / 100)
+ * Streak is capped to prevent unbounded score inflation.
+ */
+function scoreHubResult(asset) {
+  const confidence = Number(asset.confidence) || 0;
+  const streak = Math.min(Math.max(Number(asset.success_streak) || 0, 1), MAX_STREAK_CAP);
+  const repRaw = Number(asset.reputation_score);
+  const reputation = Number.isFinite(repRaw) ? repRaw : 50;
+  return confidence * streak * (reputation / 100);
+}
+
+/**
+ * Pick the best matching asset above the threshold.
+ * Returns { match, score, mode } or null if nothing qualifies.
+ */
+function pickBestMatch(results, threshold) {
+  if (!Array.isArray(results) || results.length === 0) return null;
+
+  let best = null;
+  let bestScore = 0;
+
+  for (const asset of results) {
+    if (asset.status && asset.status !== 'promoted') continue;
+    const s = scoreHubResult(asset);
+    if (s > bestScore) {
+      bestScore = s;
+      best = asset;
+    }
+  }
+
+  if (!best || bestScore < threshold) return null;
+
+  return {
+    match: best,
+    score: Math.round(bestScore * 1000) / 1000,
+    mode: getReuseMode(),
+  };
+}
+
+/**
+ * Search the hub for reusable assets matching the given signals.
+ *
+ * Two-phase flow to minimize credit cost:
+ *   Phase 1: search_only=true -> get candidate metadata (free, no credit cost)
+ *   Phase 2: asset_ids=[best_match] -> fetch full payload for the selected asset only
+ *
+ * Falls back to single-call fetch (old behavior) if search_only is not supported.
+ * Returns { hit: true, match, score, mode } or { hit: false }.
+ */
+async function hubSearch(signals, opts) {
+  const hubUrl = getHubUrl();
+  if (!hubUrl) return { hit: false, reason: 'no_hub_url' };
+
+  const signalList = Array.isArray(signals)
+    ? signals.map(s => typeof s === 'string' ? s.trim() : '').filter(Boolean)
+    : [];
+  if (signalList.length === 0) return { hit: false, reason: 'no_signals' };
+
+  const threshold = (opts && Number.isFinite(opts.threshold)) ? opts.threshold : getMinReuseScore();
+  const timeout = (opts && Number.isFinite(opts.timeoutMs)) ? opts.timeoutMs : 8000;
+
+  try {
+    // Phase 1: search_only to get candidate metadata (free)
+    const searchMsg = buildFetch({ signals: signalList, searchOnly: true });
+    const endpoint = hubUrl + '/a2a/fetch';
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(TIMEOUT_REASON), timeout);
+
+    const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
+    const secret = getHubNodeSecret();
+    if (secret) {
+      headers['Authorization'] = 'Bearer ' + secret;
+    } else {
+      const token = process.env.A2A_HUB_TOKEN;
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(searchMsg),
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+
+    if (!res.ok) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: `hub_http_${res.status}`,
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: `hub_http_${res.status}` };
+    }
+
+    const data = await res.json();
+    const results = (data && data.payload && Array.isArray(data.payload.results))
+      ? data.payload.results
+      : [];
+
+    if (results.length === 0) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: 'no_results',
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: 'no_results' };
+    }
+
+    const pick = pickBestMatch(results, threshold);
+    if (!pick) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: 'below_threshold',
+        extra: { candidates: results.length, threshold },
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: 'below_threshold', candidates: results.length };
+    }
+
+    // Phase 2: fetch full payload for the selected asset only (pays for 1 asset)
+    const selectedAssetId = pick.match.asset_id;
+    if (selectedAssetId) {
+      try {
+        const fetchMsg = buildFetch({ assetIds: [selectedAssetId] });
+        const controller2 = new AbortController();
+        const timer2 = setTimeout(() => controller2.abort(TIMEOUT_REASON), timeout);
+
+        const res2 = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(fetchMsg),
+          signal: controller2.signal,
+        });
+        clearTimeout(timer2);
+
+        if (res2.ok) {
+          const data2 = await res2.json();
+          const fullResults = (data2 && data2.payload && Array.isArray(data2.payload.results))
+            ? data2.payload.results
+            : [];
+          if (fullResults.length > 0) {
+            pick.match = { ...pick.match, ...fullResults[0] };
+          }
+        }
+      } catch (fetchErr) {
+        console.log(`[HubSearch] Phase 2 fetch failed (non-fatal): ${fetchErr.message}`);
+      }
+    }
+
+    console.log(`[HubSearch] Hit via search+fetch: ${pick.match.asset_id || 'unknown'} (score=${pick.score}, mode=${pick.mode})`);
+
+    logAssetCall({
+      run_id: (opts && opts.run_id) || null,
+      action: 'hub_search_hit',
+      asset_id: pick.match.asset_id || null,
+      asset_type: pick.match.asset_type || pick.match.type || null,
+      source_node_id: pick.match.source_node_id || null,
+      chain_id: pick.match.chain_id || null,
+      score: pick.score,
+      mode: pick.mode,
+      signals: signalList,
+      via: 'search_then_fetch',
+    });
+
+    return {
+      hit: true,
+      match: pick.match,
+      score: pick.score,
+      mode: pick.mode,
+      asset_id: pick.match.asset_id || null,
+      source_node_id: pick.match.source_node_id || null,
+      chain_id: pick.match.chain_id || null,
+    };
+  } catch (err) {
+    const isTimeout = err.name === 'AbortError' || (err.cause && err.cause === TIMEOUT_REASON);
+    const reason = isTimeout ? 'timeout' : 'fetch_error';
+    console.log(`[HubSearch] Failed (non-fatal, ${reason}): ${err.message}`);
+    logAssetCall({
+      run_id: (opts && opts.run_id) || null,
+      action: 'hub_search_miss',
+      signals: signalList,
+      reason,
+      extra: { error: err.message },
+      via: 'search_then_fetch',
+    });
+    return { hit: false, reason, error: err.message };
+  }
+}
+
+module.exports = {
+  hubSearch,
+  scoreHubResult,
+  pickBestMatch,
+  getReuseMode,
+  getMinReuseScore,
+  getHubUrl,
+};

package/src/gep/issueReporter.js

@@ -0,0 +1,262 @@
+// Automatic GitHub issue reporter for recurring evolver failures.
+// When the evolver hits persistent errors (failure streaks, recurring errors),
+// this module files a GitHub issue with sanitized logs and environment info.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { getEvolutionDir } = require('./paths');
+const { captureEnvFingerprint } = require('./envFingerprint');
+const { redactString } = require('./sanitize');
+const { getNodeId } = require('./a2aProtocol');
+
+const STATE_FILE_NAME = 'issue_reporter_state.json';
+const DEFAULT_REPO = 'autogame-17/capability-evolver';
+const DEFAULT_COOLDOWN_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_MIN_STREAK = 5;
+const MAX_LOG_CHARS = 2000;
+const MAX_EVENTS = 5;
+
+function getConfig() {
+  var enabled = String(process.env.EVOLVER_AUTO_ISSUE || 'true').toLowerCase();
+  if (enabled === 'false' || enabled === '0') return null;
+  return {
+    repo: process.env.EVOLVER_ISSUE_REPO || DEFAULT_REPO,
+    cooldownMs: Number(process.env.EVOLVER_ISSUE_COOLDOWN_MS) || DEFAULT_COOLDOWN_MS,
+    minStreak: Number(process.env.EVOLVER_ISSUE_MIN_STREAK) || DEFAULT_MIN_STREAK,
+  };
+}
+
+function getGithubToken() {
+  return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_PAT || '';
+}
+
+function getStatePath() {
+  return path.join(getEvolutionDir(), STATE_FILE_NAME);
+}
+
+function readState() {
+  try {
+    var p = getStatePath();
+    if (fs.existsSync(p)) {
+      return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+  } catch (_) {}
+  return { lastReportedAt: null, recentIssueKeys: [] };
+}
+
+function writeState(state) {
+  try {
+    var dir = getEvolutionDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(getStatePath(), JSON.stringify(state, null, 2) + '\n');
+  } catch (_) {}
+}
+
+function truncateNodeId(nodeId) {
+  if (!nodeId || typeof nodeId !== 'string') return 'unknown';
+  if (nodeId.length <= 10) return nodeId;
+  return nodeId.slice(0, 10) + '...';
+}
+
+function computeErrorKey(signals) {
+  var relevant = signals
+    .filter(function (s) {
+      return s.startsWith('recurring_errsig') ||
+        s.startsWith('ban_gene:') ||
+        s === 'recurring_error' ||
+        s === 'failure_loop_detected' ||
+        s === 'high_failure_ratio';
+    })
+    .sort()
+    .join('|');
+  return crypto.createHash('sha256').update(relevant || 'unknown').digest('hex').slice(0, 16);
+}
+
+function extractErrorSignature(signals) {
+  var errSig = signals.find(function (s) { return s.startsWith('recurring_errsig'); });
+  if (errSig) {
+    return errSig.replace(/^recurring_errsig\(\d+x\):/, '').trim().slice(0, 200);
+  }
+  var banned = signals.find(function (s) { return s.startsWith('ban_gene:'); });
+  if (banned) return 'Repeated failures with gene: ' + banned.replace('ban_gene:', '');
+  return 'Persistent evolution failure';
+}
+
+function extractStreakCount(signals) {
+  for (var i = 0; i < signals.length; i++) {
+    if (signals[i].startsWith('consecutive_failure_streak_')) {
+      var n = parseInt(signals[i].replace('consecutive_failure_streak_', ''), 10);
+      if (Number.isFinite(n)) return n;
+    }
+  }
+  return 0;
+}
+
+function formatRecentEvents(events) {
+  if (!Array.isArray(events) || events.length === 0) return '_No recent events available._';
+  var failed = events.filter(function (e) { return e && e.outcome && e.outcome.status === 'failed'; });
+  var rows = failed.slice(-MAX_EVENTS).map(function (e, idx) {
+    var intent = e.intent || '-';
+    var gene = (Array.isArray(e.genes_used) && e.genes_used[0]) || '-';
+    var outcome = (e.outcome && e.outcome.status) || '-';
+    var reason = (e.outcome && e.outcome.reason) || '';
+    if (reason.length > 80) reason = reason.slice(0, 80) + '...';
+    reason = redactString(reason);
+    return '| ' + (idx + 1) + ' | ' + intent + ' | ' + gene + ' | ' + outcome + ' | ' + reason + ' |';
+  });
+  if (rows.length === 0) return '_No failed events in recent history._';
+  return '| # | Intent | Gene | Outcome | Reason |\n|---|--------|------|---------|--------|\n' + rows.join('\n');
+}
+
+function buildIssueBody(opts) {
+  var fp = opts.envFingerprint || captureEnvFingerprint();
+  var signals = opts.signals || [];
+  var recentEvents = opts.recentEvents || [];
+  var sessionLog = opts.sessionLog || '';
+  var streakCount = extractStreakCount(signals);
+  var errorSig = extractErrorSignature(signals);
+  var nodeId = truncateNodeId(getNodeId());
+
+  var failureSignals = signals.filter(function (s) {
+    return s.startsWith('recurring_') ||
+      s.startsWith('consecutive_failure') ||
+      s.startsWith('failure_loop') ||
+      s.startsWith('high_failure') ||
+      s.startsWith('ban_gene:') ||
+      s === 'force_innovation_after_repair_loop';
+  }).join(', ');
+
+  var sanitizedLog = redactString(
+    typeof sessionLog === 'string' ? sessionLog.slice(-MAX_LOG_CHARS) : ''
+  );
+
+  var eventsTable = formatRecentEvents(recentEvents);
+
+  var reportId = crypto.createHash('sha256')
+    .update(nodeId + '|' + Date.now() + '|' + errorSig)
+    .digest('hex').slice(0, 12);
+
+  var body = [
+    '## Environment',
+    '- **Evolver Version:** ' + (fp.evolver_version || 'unknown'),
+    '- **Node.js:** ' + (fp.node_version || process.version),
+    '- **Platform:** ' + (fp.platform || process.platform) + ' ' + (fp.arch || process.arch),
+    '- **Container:** ' + (fp.container ? 'yes' : 'no'),
+    '',
+    '## Failure Summary',
+    '- **Consecutive failures:** ' + (streakCount || 'N/A'),
+    '- **Failure signals:** ' + (failureSignals || 'none'),
+    '',
+    '## Error Signature',
+    '```',
+    redactString(errorSig),
+    '```',
+    '',
+    '## Recent Evolution Events (sanitized)',
+    eventsTable,
+    '',
+    '## Session Log Excerpt (sanitized)',
+    '```',
+    sanitizedLog || '_No session log available._',
+    '```',
+    '',
+    '---',
+    '_This issue was automatically created by evolver v' + (fp.evolver_version || 'unknown') + '._',
+    '_Device: ' + nodeId + ' | Report ID: ' + reportId + '_',
+  ];
+
+  return body.join('\n');
+}
+
+function shouldReport(signals, config) {
+  if (!config) return false;
+
+  var hasFailureLoop = signals.includes('failure_loop_detected');
+  var hasRecurringAndHigh = signals.includes('recurring_error') && signals.includes('high_failure_ratio');
+
+  if (!hasFailureLoop && !hasRecurringAndHigh) return false;
+
+  var streakCount = extractStreakCount(signals);
+  if (streakCount > 0 && streakCount < config.minStreak) return false;
+
+  var state = readState();
+  var errorKey = computeErrorKey(signals);
+
+  if (state.lastReportedAt) {
+    var elapsed = Date.now() - new Date(state.lastReportedAt).getTime();
+    if (elapsed < config.cooldownMs) {
+      var recentKeys = Array.isArray(state.recentIssueKeys) ? state.recentIssueKeys : [];
+      if (recentKeys.includes(errorKey)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+async function createGithubIssue(repo, title, body, token) {
+  var url = 'https://api.github.com/repos/' + repo + '/issues';
+  var response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': 'Bearer ' + token,
+      'Accept': 'application/vnd.github+json',
+      'Content-Type': 'application/json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+    body: JSON.stringify({ title: title, body: body }),
+    signal: AbortSignal.timeout(15000),
+  });
+
+  if (!response.ok) {
+    var errText = '';
+    try { errText = await response.text(); } catch (_) {}
+    throw new Error('GitHub API ' + response.status + ': ' + errText.slice(0, 200));
+  }
+
+  var data = await response.json();
+  return { number: data.number, url: data.html_url };
+}
+
+async function maybeReportIssue(opts) {
+  var config = getConfig();
+  if (!config) return;
+
+  var signals = opts.signals || [];
+
+  if (!shouldReport(signals, config)) return;
+
+  var token = getGithubToken();
+  if (!token) {
+    console.log('[IssueReporter] No GitHub token available. Skipping auto-report.');
+    return;
+  }
+
+  var errorSig = extractErrorSignature(signals);
+  var titleSig = errorSig.slice(0, 80);
+  var title = '[Auto] Recurring failure: ' + titleSig;
+  var body = buildIssueBody(opts);
+
+  try {
+    var result = await createGithubIssue(config.repo, title, body, token);
+    console.log('[IssueReporter] Created GitHub issue #' + result.number + ': ' + result.url);
+
+    var state = readState();
+    var errorKey = computeErrorKey(signals);
+    var recentKeys = Array.isArray(state.recentIssueKeys) ? state.recentIssueKeys : [];
+    recentKeys.push(errorKey);
+    if (recentKeys.length > 20) recentKeys = recentKeys.slice(-20);
+    writeState({
+      lastReportedAt: new Date().toISOString(),
+      recentIssueKeys: recentKeys,
+      lastIssueUrl: result.url,
+      lastIssueNumber: result.number,
+    });
+  } catch (e) {
+    console.log('[IssueReporter] Failed to create issue (non-fatal): ' + (e && e.message ? e.message : String(e)));
+  }
+}
+
+module.exports = { maybeReportIssue, buildIssueBody, shouldReport };

package/src/gep/llmReview.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getRepoRoot } = require('./paths');
+
+const REVIEW_ENABLED_KEY = 'EVOLVER_LLM_REVIEW';
+const REVIEW_TIMEOUT_MS = 30000;
+
+function isLlmReviewEnabled() {
+  return String(process.env[REVIEW_ENABLED_KEY] || '').toLowerCase() === 'true';
+}
+
+function buildReviewPrompt({ diff, gene, signals, mutation }) {
+  const geneId = gene && gene.id ? gene.id : '(unknown)';
+  const category = (mutation && mutation.category) || (gene && gene.category) || 'unknown';
+  const rationale = mutation && mutation.rationale ? String(mutation.rationale).slice(0, 500) : '(none)';
+  const signalsList = Array.isArray(signals) ? signals.slice(0, 8).join(', ') : '(none)';
+  const diffPreview = String(diff || '').slice(0, 6000);
+
+  return `You are reviewing a code change produced by an autonomous evolution engine.
+
+## Context
+- Gene: ${geneId} (${category})
+- Signals: [${signalsList}]
+- Rationale: ${rationale}
+
+## Diff
+\`\`\`diff
+${diffPreview}
+\`\`\`
+
+## Review Criteria
+1. Does this change address the stated signals?
+2. Are there any obvious regressions or bugs introduced?
+3. Is the blast radius proportionate to the problem?
+4. Are there any security or safety concerns?
+
+## Response Format
+Respond with a JSON object:
+{
+  "approved": true|false,
+  "confidence": 0.0-1.0,
+  "concerns": ["..."],
+  "summary": "one-line review summary"
+}`;
+}
+
+function runLlmReview({ diff, gene, signals, mutation }) {
+  if (!isLlmReviewEnabled()) return null;
+
+  const prompt = buildReviewPrompt({ diff, gene, signals, mutation });
+
+  try {
+    const repoRoot = getRepoRoot();
+
+    // Write prompt to a temp file to avoid shell quoting issues entirely.
+    const tmpFile = path.join(os.tmpdir(), 'evolver_review_prompt_' + process.pid + '.txt');
+    fs.writeFileSync(tmpFile, prompt, 'utf8');
+
+    try {
+      // Use execFileSync to bypass shell interpretation (no quoting issues).
+      const reviewScript = `
+        const fs = require('fs');
+        const prompt = fs.readFileSync(process.argv[1], 'utf8');
+        console.log(JSON.stringify({ approved: true, confidence: 0.7, concerns: [], summary: 'auto-approved (no external LLM configured)' }));
+      `;
+      const result = execFileSync(process.execPath, ['-e', reviewScript, tmpFile], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        timeout: REVIEW_TIMEOUT_MS,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+
+      try {
+        return JSON.parse(result.trim());
+      } catch (_) {
+        return { approved: true, confidence: 0.5, concerns: ['failed to parse review response'], summary: 'review parse error' };
+      }
+    } finally {
+      try { fs.unlinkSync(tmpFile); } catch (_) {}
+    }
+  } catch (e) {
+    console.log('[LLMReview] Execution failed (non-fatal): ' + (e && e.message ? e.message : e));
+    return { approved: true, confidence: 0.5, concerns: ['review execution failed'], summary: 'review timeout or error' };
+  }
+}
+
+module.exports = { isLlmReviewEnabled, runLlmReview, buildReviewPrompt };