@evomap/evolver 1.67.4 → 1.68.0-beta.1

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();

package/src/config.js

@@ -84,6 +84,23 @@ const SELF_PR_TIMEOUT_MS = envInt('EVOLVER_SELF_PR_TIMEOUT_MS', 30000);
 
 const LEAK_CHECK_MODE = envStr('EVOLVER_LEAK_CHECK', 'warn');
 
+// --- Validator mode (opt-in) ---
+// Opt-in node role: when enabled, the evolver periodically fetches assigned
+// validation tasks from the Hub, runs the commands in an isolated sandbox,
+// and submits ValidationReports. Default is OFF for backward compatibility.
+
+const VALIDATOR_ENABLED = (function () {
+  const v = String(process.env.EVOLVER_VALIDATOR_ENABLED || '').toLowerCase().trim();
+  return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+})();
+const VALIDATOR_STAKE_AMOUNT = envInt('EVOLVER_VALIDATOR_STAKE_AMOUNT', 100);
+const VALIDATOR_MAX_TASKS_PER_CYCLE = envInt('EVOLVER_VALIDATOR_MAX_TASKS_PER_CYCLE', 2);
+const VALIDATOR_FETCH_TIMEOUT_MS = envInt('EVOLVER_VALIDATOR_FETCH_TIMEOUT_MS', 8000);
+const VALIDATOR_REPORT_TIMEOUT_MS = envInt('EVOLVER_VALIDATOR_REPORT_TIMEOUT_MS', 10000);
+const VALIDATOR_STAKE_TIMEOUT_MS = envInt('EVOLVER_VALIDATOR_STAKE_TIMEOUT_MS', 10000);
+const VALIDATOR_CMD_TIMEOUT_MS = envInt('EVOLVER_VALIDATOR_CMD_TIMEOUT_MS', 60000);
+const VALIDATOR_BATCH_TIMEOUT_MS = envInt('EVOLVER_VALIDATOR_BATCH_TIMEOUT_MS', 180000);
+
 module.exports = {
   // Network
   HELLO_TIMEOUT_MS,
@@ -136,6 +153,15 @@ module.exports = {
   SELF_PR_TIMEOUT_MS,
   // Security
   LEAK_CHECK_MODE,
+  // Validator (opt-in role)
+  VALIDATOR_ENABLED,
+  VALIDATOR_STAKE_AMOUNT,
+  VALIDATOR_MAX_TASKS_PER_CYCLE,
+  VALIDATOR_FETCH_TIMEOUT_MS,
+  VALIDATOR_REPORT_TIMEOUT_MS,
+  VALIDATOR_STAKE_TIMEOUT_MS,
+  VALIDATOR_CMD_TIMEOUT_MS,
+  VALIDATOR_BATCH_TIMEOUT_MS,
   // Helpers
   envInt,
   envFloat,