@evomap/evolver 1.67.4 → 1.67.6

package/src/adapters/scripts/evolver-session-end.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+// evolver-session-end.js
+// Records evolution outcome at session end.
+// Collects git diff stats, extracts signals, records via Hub API or local memory.
+// Input: stdin JSON. Output: stdout JSON with followup_message.
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function findEvolverRoot() {
+  const candidates = [
+    process.env.EVOLVER_ROOT,
+    path.resolve(__dirname, '..', '..', '..'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(path.join(c, 'package.json'))) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(c, 'package.json'), 'utf8'));
+        if (pkg.name === '@evomap/evolver' || pkg.name === 'evolver') return c;
+      } catch { /* skip */ }
+    }
+  }
+  const homeSkills = path.join(require('os').homedir(), 'skills', 'evolver');
+  if (fs.existsSync(path.join(homeSkills, 'package.json'))) return homeSkills;
+  return null;
+}
+
+function findMemoryGraph(evolverRoot) {
+  if (process.env.MEMORY_GRAPH_PATH && fs.existsSync(process.env.MEMORY_GRAPH_PATH)) {
+    return process.env.MEMORY_GRAPH_PATH;
+  }
+  const candidates = [
+    evolverRoot && path.join(evolverRoot, 'memory', 'evolution', 'memory_graph.jsonl'),
+    evolverRoot && path.join(evolverRoot, 'MEMORY', 'evolution', 'memory_graph.jsonl'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  if (evolverRoot) {
+    const defaultPath = path.join(evolverRoot, 'memory', 'evolution', 'memory_graph.jsonl');
+    fs.mkdirSync(path.dirname(defaultPath), { recursive: true });
+    return defaultPath;
+  }
+  return null;
+}
+
+function getGitDiffStats() {
+  try {
+    const cwd = process.cwd();
+    const stat = execSync('git diff --stat HEAD~1 2>/dev/null || git diff --stat 2>/dev/null || echo ""', {
+      cwd,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    const diffContent = execSync('git diff HEAD~1 --no-color 2>/dev/null || git diff --no-color 2>/dev/null || echo ""', {
+      cwd,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    const filesChanged = (stat.match(/\d+ files? changed/) || ['0'])[0];
+    const insertions = (stat.match(/(\d+) insertions?/) || [null, '0'])[1];
+    const deletions = (stat.match(/(\d+) deletions?/) || [null, '0'])[1];
+    return {
+      stat,
+      summary: `${filesChanged}, +${insertions}/-${deletions}`,
+      diffSnippet: diffContent.slice(0, 2000),
+      hasChanges: stat.length > 0,
+    };
+  } catch {
+    return { stat: '', summary: 'unknown', diffSnippet: '', hasChanges: false };
+  }
+}
+
+function detectSignals(text) {
+  if (!text) return [];
+  const lower = text.toLowerCase();
+  const signals = [];
+  if (/error:|exception:|failed/i.test(lower)) signals.push('log_error');
+  if (/timeout|slow|latency|bottleneck/i.test(lower)) signals.push('perf_bottleneck');
+  if (/add|implement|feature|new function|new module/i.test(lower)) signals.push('user_feature_request');
+  if (/improve|enhance|refactor|optimize/i.test(lower)) signals.push('user_improvement_suggestion');
+  if (/not supported|unsupported|not implemented/i.test(lower)) signals.push('capability_gap');
+  if (/deploy|ci|pipeline|build failed/i.test(lower)) signals.push('deployment_issue');
+  if (/test fail|assertion|expect\(/i.test(lower)) signals.push('test_failure');
+  return [...new Set(signals)];
+}
+
+function recordToHub(outcome) {
+  const hubUrl = process.env.EVOMAP_HUB_URL || process.env.A2A_HUB_URL;
+  const apiKey = process.env.EVOMAP_API_KEY || process.env.A2A_NODE_SECRET;
+  const nodeId = process.env.EVOMAP_NODE_ID || process.env.A2A_NODE_ID;
+  if (!hubUrl || !apiKey) return false;
+
+  try {
+    const payload = JSON.stringify({
+      gene_id: outcome.geneId || 'ad_hoc',
+      signals: outcome.signals,
+      status: outcome.status,
+      score: outcome.score,
+      summary: outcome.summary,
+      sender_id: nodeId || undefined,
+    });
+    const curlCmd = `curl -s -m 8 -X POST`
+      + ` -H "Content-Type: application/json"`
+      + ` -H "Authorization: Bearer ${apiKey}"`
+      + ` -d '${payload.replace(/'/g, "'\\''")}'`
+      + ` "${hubUrl.replace(/\/+$/, '')}/a2a/evolution/record"`;
+    execSync(curlCmd, { timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function recordToLocal(graphPath, outcome) {
+  try {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      gene_id: outcome.geneId || 'ad_hoc',
+      signals: outcome.signals,
+      outcome: {
+        status: outcome.status,
+        score: outcome.score,
+        note: outcome.summary,
+      },
+      source: 'hook:session-end',
+    };
+    fs.appendFileSync(graphPath, JSON.stringify(entry) + '\n', 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  let inputData = '';
+  let handled = false;
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { inputData += chunk; });
+  process.stdin.on('end', () => {
+    if (handled) return;
+    handled = true;
+    try {
+      const diffInfo = getGitDiffStats();
+
+      if (!diffInfo.hasChanges) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+      }
+
+      const signals = detectSignals(diffInfo.diffSnippet);
+      if (signals.length === 0) signals.push('stable_success_plateau');
+
+      const hasErrors = signals.includes('log_error') || signals.includes('test_failure');
+      const status = hasErrors ? 'failed' : 'success';
+      const score = hasErrors ? 0.3 : 0.8;
+
+      const outcome = {
+        geneId: 'ad_hoc',
+        signals,
+        status,
+        score,
+        summary: `Session end: ${diffInfo.summary}. Signals: [${signals.join(', ')}]`,
+      };
+
+      const evolverRoot = findEvolverRoot();
+      const graphPath = findMemoryGraph(evolverRoot);
+
+      const hubOk = recordToHub(outcome);
+      const localOk = graphPath ? recordToLocal(graphPath, outcome) : false;
+
+      const target = hubOk ? 'Hub' : localOk ? 'local memory' : 'nowhere (no Hub or local path)';
+      const msg = `[Evolution] Session outcome recorded to ${target}: ${outcome.summary}`;
+
+      process.stdout.write(JSON.stringify({
+        followup_message: msg,
+        stopMessage: msg,
+        additionalContext: msg,
+      }));
+    } catch (e) {
+      process.stdout.write(JSON.stringify({}));
+    }
+  });
+
+  setTimeout(() => {
+    if (handled) return;
+    handled = true;
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }, 7000);
+}
+
+main();

package/src/adapters/scripts/evolver-session-start.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// evolver-session-start.js
+// Reads recent evolution memory and injects it as context for the agent session.
+// Input: stdin JSON (session context). Output: stdout JSON with agent_message.
+
+const fs = require('fs');
+const path = require('path');
+
+function findEvolverRoot() {
+  const candidates = [
+    process.env.EVOLVER_ROOT,
+    path.resolve(__dirname, '..', '..', '..'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(path.join(c, 'package.json'))) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(c, 'package.json'), 'utf8'));
+        if (pkg.name === '@evomap/evolver' || pkg.name === 'evolver') return c;
+      } catch { /* skip */ }
+    }
+  }
+  const homeSkills = path.join(require('os').homedir(), 'skills', 'evolver');
+  if (fs.existsSync(path.join(homeSkills, 'package.json'))) return homeSkills;
+  return null;
+}
+
+function findMemoryGraph(evolverRoot) {
+  if (process.env.MEMORY_GRAPH_PATH && fs.existsSync(process.env.MEMORY_GRAPH_PATH)) {
+    return process.env.MEMORY_GRAPH_PATH;
+  }
+  const candidates = [
+    evolverRoot && path.join(evolverRoot, 'memory', 'evolution', 'memory_graph.jsonl'),
+    evolverRoot && path.join(evolverRoot, 'MEMORY', 'evolution', 'memory_graph.jsonl'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function readLastN(filePath, n) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    return lines.slice(-n).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function formatOutcome(entry) {
+  const status = entry.outcome ? entry.outcome.status : 'unknown';
+  const score = entry.outcome && entry.outcome.score != null ? entry.outcome.score : '?';
+  const note = entry.outcome && entry.outcome.note ? entry.outcome.note : '';
+  const signals = Array.isArray(entry.signals) ? entry.signals.slice(0, 3).join(', ') : '';
+  const ts = entry.timestamp ? entry.timestamp.slice(0, 10) : '';
+  const icon = status === 'success' ? '+' : status === 'failed' ? '-' : '?';
+  return `[${icon}] ${ts} score=${score} signals=[${signals}] ${note}`.slice(0, 200);
+}
+
+function main() {
+  const evolverRoot = findEvolverRoot();
+  const graphPath = findMemoryGraph(evolverRoot);
+
+  if (!graphPath) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const entries = readLastN(graphPath, 5);
+  if (entries.length === 0) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const successCount = entries.filter(e => e.outcome && e.outcome.status === 'success').length;
+  const failCount = entries.filter(e => e.outcome && e.outcome.status === 'failed').length;
+
+  const lines = entries.map(formatOutcome);
+  const summary = [
+    `[Evolution Memory] Recent ${entries.length} outcomes (${successCount} success, ${failCount} failed):`,
+    ...lines,
+    '',
+    'Use successful approaches. Avoid repeating failed patterns.',
+  ].join('\n');
+
+  process.stdout.write(JSON.stringify({
+    agent_message: summary,
+    additionalContext: summary,
+  }));
+}
+
+main();

package/src/adapters/scripts/evolver-signal-detect.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// evolver-signal-detect.js
+// Lightweight signal detection on file edit events.
+// Input: stdin JSON (edit event). Output: stdout JSON with additional_context.
+
+const SIGNAL_KEYWORDS = {
+  perf_bottleneck: ['timeout', 'slow', 'latency', 'bottleneck', 'oom', 'out of memory', 'performance'],
+  capability_gap: ['not supported', 'unsupported', 'not implemented', 'missing feature', 'not available'],
+  log_error: ['error:', 'exception:', 'typeerror', 'referenceerror', 'syntaxerror', 'failed'],
+  user_feature_request: ['add feature', 'implement', 'new function', 'new module', 'please add'],
+  recurring_error: ['same error', 'still failing', 'not fixed', 'keeps failing', 'repeatedly'],
+  deployment_issue: ['deploy failed', 'build failed', 'ci failed', 'pipeline', 'rollback'],
+  test_failure: ['test failed', 'test failure', 'assertion', 'expect(', 'assert.'],
+};
+
+function detectSignals(text) {
+  if (!text || typeof text !== 'string') return [];
+  const lower = text.toLowerCase();
+  const found = [];
+  for (const [signal, keywords] of Object.entries(SIGNAL_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw)) {
+        found.push(signal);
+        break;
+      }
+    }
+  }
+  return [...new Set(found)];
+}
+
+function main() {
+  let inputData = '';
+  let handled = false;
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { inputData += chunk; });
+  process.stdin.on('end', () => {
+    if (handled) return;
+    handled = true;
+    try {
+      const input = inputData.trim() ? JSON.parse(inputData) : {};
+      const content = input.content || input.file_content || input.diff || '';
+      const filePath = input.path || input.file_path || '';
+
+      const signals = detectSignals(content);
+
+      if (signals.length === 0) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+      }
+
+      const ctx = `[Evolution Signal] Detected: [${signals.join(', ')}] in ${filePath || 'edited file'}. Consider recording this outcome.`;
+      process.stdout.write(JSON.stringify({
+        additional_context: ctx,
+        additionalContext: ctx,
+      }));
+    } catch {
+      process.stdout.write(JSON.stringify({}));
+    }
+  });
+
+  setTimeout(() => {
+    if (handled) return;
+    handled = true;
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }, 1500);
+}
+
+main();