@evomap/evolver 1.89.12 → 1.89.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.89.12",
+  "version": "1.89.13",
   "description": "A GEP-powered self-evolution engine for AI agents. Features automated log analysis and Genome Evolution Protocol (GEP) for auditable, reusable evolution assets.",
   "main": "index.js",
   "bin": {
@@ -28,12 +28,10 @@
     "run": "node index.js run",
     "solidify": "node index.js solidify",
     "review": "node index.js review",
-    "distill": "node index.js distill",
-    "webui": "node index.js webui",
-    "test": "node -e \"const fs=require('fs'),cp=require('child_process');const all=fs.readdirSync('test').filter(f=>f.endsWith('.test.js'));const iso=new Set(['solidifyIntegration.test.js']);const others=all.filter(f=>!iso.has(f)).map(f=>'test/'+f);const isoFiles=all.filter(f=>iso.has(f)).map(f=>'test/'+f);if(others.length)cp.execSync('node --test '+others.join(' '),{stdio:'inherit'});if(isoFiles.length)cp.execSync('node --test '+isoFiles.join(' '),{stdio:'inherit'})\"",
     "a2a:export": "node scripts/a2a_export.js",
     "a2a:ingest": "node scripts/a2a_ingest.js",
-    "a2a:promote": "node scripts/a2a_promote.js"
+    "a2a:promote": "node scripts/a2a_promote.js",
+    "test": "node -e \"const fs=require('fs'),cp=require('child_process');const all=fs.readdirSync('test').filter(f=>f.endsWith('.test.js'));const iso=new Set(['solidifyIntegration.test.js']);const others=all.filter(f=>!iso.has(f)).map(f=>'test/'+f);const isoFiles=all.filter(f=>iso.has(f)).map(f=>'test/'+f);if(others.length)cp.execSync('node --test '+others.join(' '),{stdio:'inherit'});if(isoFiles.length)cp.execSync('node --test '+isoFiles.join(' '),{stdio:'inherit'})\""
   },
   "engines": {
     "node": ">=22.12"
@@ -50,5 +48,19 @@
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "^1.1.6"
-  }
+  },
+  "files": [
+    "assets/",
+    "index.js",
+    "src/",
+    "scripts/",
+    "skills/",
+    "conformance/",
+    "README.md",
+    "README.zh-CN.md",
+    "README.ja-JP.md",
+    "SKILL.md",
+    "CONTRIBUTING.md",
+    "LICENSE"
+  ]
 }

package/scripts/a2a_export.js

@@ -0,0 +1,63 @@
+const { loadGenes, loadCapsules, readAllEvents } = require('../src/gep/assetStore');
+const { exportEligibleCapsules, exportEligibleGenes, isAllowedA2AAsset } = require('../src/gep/a2a');
+const { buildPublish, buildHello, getTransport } = require('../src/gep/a2aProtocol');
+const { computeAssetId, SCHEMA_VERSION } = require('../src/gep/contentHash');
+
+function main() {
+  var args = process.argv.slice(2);
+  var asJson = args.includes('--json');
+  var asProtocol = args.includes('--protocol');
+  var withHello = args.includes('--hello');
+  var persist = args.includes('--persist');
+  var includeEvents = args.includes('--include-events');
+
+  var capsules = loadCapsules();
+  var genes = loadGenes();
+  var events = readAllEvents();
+
+  // Build eligible list: Capsules (filtered) + Genes (filtered) + Events (opt-in)
+  var eligibleCapsules = exportEligibleCapsules({ capsules: capsules, events: events });
+  var eligibleGenes = exportEligibleGenes({ genes: genes });
+  var eligible = eligibleCapsules.concat(eligibleGenes);
+
+  if (includeEvents) {
+    var eligibleEvents = (Array.isArray(events) ? events : []).filter(function (e) {
+      return isAllowedA2AAsset(e) && e.type === 'EvolutionEvent';
+    });
+    for (var ei = 0; ei < eligibleEvents.length; ei++) {
+      var ev = eligibleEvents[ei];
+      if (!ev.schema_version) ev.schema_version = SCHEMA_VERSION;
+      if (!ev.asset_id) { try { ev.asset_id = computeAssetId(ev); } catch (e) {} }
+    }
+    eligible = eligible.concat(eligibleEvents);
+  }
+
+  if (withHello || asProtocol) {
+    var hello = buildHello({ geneCount: genes.length, capsuleCount: capsules.length });
+    process.stdout.write(JSON.stringify(hello) + '\n');
+    if (persist) { try { getTransport().send(hello); } catch (e) {} }
+  }
+
+  if (asProtocol) {
+    for (var i = 0; i < eligible.length; i++) {
+      var msg = buildPublish({ asset: eligible[i] });
+      process.stdout.write(JSON.stringify(msg) + '\n');
+      if (persist) { try { getTransport().send(msg); } catch (e) {} }
+    }
+    return;
+  }
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify(eligible, null, 2) + '\n');
+    return;
+  }
+
+  for (var j = 0; j < eligible.length; j++) {
+    process.stdout.write(JSON.stringify(eligible[j]) + '\n');
+  }
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/a2a_ingest.js

@@ -0,0 +1,79 @@
+var fs = require('fs');
+var assetStore = require('../src/gep/assetStore');
+var a2a = require('../src/gep/a2a');
+var memGraph = require('../src/gep/memoryGraphAdapter');
+var contentHash = require('../src/gep/contentHash');
+var a2aProto = require('../src/gep/a2aProtocol');
+
+function readStdin() {
+  try { return fs.readFileSync(0, 'utf8'); } catch (e) { return ''; }
+}
+
+function parseSignalsFromEnv() {
+  var raw = process.env.A2A_SIGNALS || '';
+  if (!raw) return [];
+  try {
+    var maybe = JSON.parse(raw);
+    if (Array.isArray(maybe)) return maybe.map(String).filter(Boolean);
+  } catch (e) {}
+  return String(raw).split(',').map(function (s) { return s.trim(); }).filter(Boolean);
+}
+
+function main() {
+  var args = process.argv.slice(2);
+  var inputPath = '';
+  for (var i = 0; i < args.length; i++) {
+    if (args[i] && !args[i].startsWith('--')) { inputPath = args[i]; break; }
+  }
+  var source = process.env.A2A_SOURCE || 'external';
+  var factor = Number.isFinite(Number(process.env.A2A_EXTERNAL_CONFIDENCE_FACTOR))
+    ? Number(process.env.A2A_EXTERNAL_CONFIDENCE_FACTOR) : 0.6;
+
+  var text = inputPath ? a2a.readTextIfExists(inputPath) : readStdin();
+  var parsed = a2a.parseA2AInput(text);
+  var signals = parseSignalsFromEnv();
+
+  var accepted = 0;
+  var rejected = 0;
+  var emitDecisions = process.env.A2A_EMIT_DECISIONS === 'true';
+
+  for (var j = 0; j < parsed.length; j++) {
+    var obj = parsed[j];
+    if (!a2a.isAllowedA2AAsset(obj)) continue;
+
+    if (obj.asset_id && typeof obj.asset_id === 'string') {
+      if (!contentHash.verifyAssetId(obj)) {
+        rejected += 1;
+        if (emitDecisions) {
+          try {
+            var dm = a2aProto.buildDecision({ assetId: obj.asset_id, localId: obj.id, decision: 'reject', reason: 'asset_id integrity check failed' });
+            a2aProto.getTransport().send(dm);
+          } catch (e) {}
+        }
+        continue;
+      }
+    }
+
+    var staged = a2a.lowerConfidence(obj, { source: source, factor: factor });
+    if (!staged) continue;
+
+    assetStore.appendExternalCandidateJsonl(staged);
+    try { memGraph.recordExternalCandidate({ asset: staged, source: source, signals: signals }); } catch (e) {}
+
+    if (emitDecisions) {
+      try {
+        var dm2 = a2aProto.buildDecision({ assetId: staged.asset_id, localId: staged.id, decision: 'quarantine', reason: 'staged as external candidate' });
+        a2aProto.getTransport().send(dm2);
+      } catch (e) {}
+    }
+
+    accepted += 1;
+  }
+
+  process.stdout.write('accepted=' + accepted + ' rejected=' + rejected + '\n');
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/a2a_promote.js

@@ -0,0 +1,118 @@
+var assetStore = require('../src/gep/assetStore');
+var solidifyMod = require('../src/gep/solidify');
+var contentHash = require('../src/gep/contentHash');
+var a2aProto = require('../src/gep/a2aProtocol');
+
+function parseArgs(argv) {
+  var out = { flags: new Set(), kv: new Map(), positionals: [] };
+  for (var i = 0; i < argv.length; i++) {
+    var a = argv[i];
+    if (!a) continue;
+    if (a.startsWith('--')) {
+      var eq = a.indexOf('=');
+      if (eq > -1) { out.kv.set(a.slice(2, eq), a.slice(eq + 1)); }
+      else {
+        var key = a.slice(2);
+        var next = argv[i + 1];
+        if (next && !String(next).startsWith('--')) { out.kv.set(key, next); i++; }
+        else { out.flags.add(key); }
+      }
+    } else { out.positionals.push(a); }
+  }
+  return out;
+}
+
+function main() {
+  var args = parseArgs(process.argv.slice(2));
+  var id = String(args.kv.get('id') || '').trim();
+  var typeRaw = String(args.kv.get('type') || '').trim().toLowerCase();
+  var validated = args.flags.has('validated') || String(args.kv.get('validated') || '') === 'true';
+  var limit = Number.isFinite(Number(args.kv.get('limit'))) ? Number(args.kv.get('limit')) : 500;
+
+  if (!id || !typeRaw) throw new Error('Usage: node scripts/a2a_promote.js --type capsule|gene|event --id <id> --validated');
+  if (!validated) throw new Error('Refusing to promote without --validated (local verification must be done first).');
+
+  var type = typeRaw === 'capsule' ? 'Capsule' : typeRaw === 'gene' ? 'Gene' : typeRaw === 'event' ? 'EvolutionEvent' : '';
+  if (!type) throw new Error('Invalid --type. Use capsule, gene, or event.');
+
+  var external = assetStore.readRecentExternalCandidates(limit);
+  var candidate = null;
+  for (var i = 0; i < external.length; i++) {
+    if (external[i] && external[i].type === type && String(external[i].id) === id) { candidate = external[i]; break; }
+  }
+  if (!candidate) throw new Error('Candidate not found in external zone: type=' + type + ' id=' + id);
+
+  if (type === 'Gene') {
+    var validation = Array.isArray(candidate.validation) ? candidate.validation : [];
+    for (var j = 0; j < validation.length; j++) {
+      var c = String(validation[j] || '').trim();
+      if (!c) continue;
+      if (!solidifyMod.isValidationCommandAllowed(c)) {
+        throw new Error('Refusing to promote Gene ' + id + ': validation command rejected by safety check: "' + c + '". Only node/npm/npx commands without shell operators are allowed.');
+      }
+    }
+  }
+
+  var promoted = JSON.parse(JSON.stringify(candidate));
+  if (!promoted.a2a || typeof promoted.a2a !== 'object') promoted.a2a = {};
+  promoted.a2a.status = 'promoted';
+  promoted.a2a.promoted_at = new Date().toISOString();
+  if (!promoted.schema_version) promoted.schema_version = contentHash.SCHEMA_VERSION;
+  promoted.asset_id = contentHash.computeAssetId(promoted);
+
+  var emitDecisions = process.env.A2A_EMIT_DECISIONS === 'true';
+
+  if (type === 'EvolutionEvent') {
+    assetStore.appendEventJsonl(promoted);
+    if (emitDecisions) {
+      try {
+        var dmEv = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'event promoted for provenance tracking' });
+        a2aProto.getTransport().send(dmEv);
+      } catch (e) {}
+    }
+    process.stdout.write('promoted_event=' + id + '\n');
+    return;
+  }
+
+  if (type === 'Capsule') {
+    assetStore.appendCapsule(promoted);
+    if (emitDecisions) {
+      try {
+        var dm = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'capsule promoted after validation' });
+        a2aProto.getTransport().send(dm);
+      } catch (e) {}
+    }
+    process.stdout.write('promoted_capsule=' + id + '\n');
+    return;
+  }
+
+  var localGenes = assetStore.loadGenes();
+  var exists = false;
+  for (var k = 0; k < localGenes.length; k++) {
+    if (localGenes[k] && localGenes[k].type === 'Gene' && String(localGenes[k].id) === id) { exists = true; break; }
+  }
+  if (exists) {
+    if (emitDecisions) {
+      try {
+        var dm2 = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'reject', reason: 'local gene with same ID already exists' });
+        a2aProto.getTransport().send(dm2);
+      } catch (e) {}
+    }
+    process.stdout.write('conflict_keep_local_gene=' + id + '\n');
+    return;
+  }
+
+  assetStore.upsertGene(promoted);
+  if (emitDecisions) {
+    try {
+      var dm3 = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'gene promoted after safety audit' });
+      a2aProto.getTransport().send(dm3);
+    } catch (e) {}
+  }
+  process.stdout.write('promoted_gene=' + id + '\n');
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/analyze_by_skill.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const LOG_FILE = path.join(REPO_ROOT, 'evolution_history_full.md');
+const OUT_FILE = path.join(REPO_ROOT, 'evolution_detailed_report.md');
+
+function analyzeEvolution() {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.error("Source file missing.");
+        return;
+    }
+
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    // Split by divider
+    const entries = content.split('---').map(e => e.trim()).filter(e => e.length > 0);
+
+    const skillUpdates = {}; // Map<SkillName, Array<Changes>>
+    const generalUpdates = []; // Array<Changes>
+
+    // Regex to detect skills/paths
+    // e.g. `skills/feishu-card/send.js` or **Target**: `skills/git-sync`
+    const skillRegex = /skills\/([a-zA-Z0-9\-_]+)/;
+    const actionRegex = /Action:\s*([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i; // Capture Action text
+    const statusRegex = /Status:\s*\[?([A-Z\s_]+)\]?/i;
+
+    entries.forEach(entry => {
+        // Extract basic info
+        const statusMatch = entry.match(statusRegex);
+        const status = statusMatch ? statusMatch[1].trim().toUpperCase() : 'UNKNOWN';
+        
+        // Skip routine checks if we want a *detailed evolution* report (focus on changes)
+        // But user asked for "what happened", so routine scans might be boring unless they found something.
+        // Let's filter out "STABILITY" or "RUNNING" unless there is a clear "Mutated" or "Fixed" keyword.
+        const isInteresting = 
+            entry.includes('Fixed') || 
+            entry.includes('Hardened') || 
+            entry.includes('Optimized') || 
+            entry.includes('Patched') || 
+            entry.includes('Created') || 
+            entry.includes('Added') ||
+            status === 'SUCCESS' ||
+            status === 'COMPLETED';
+
+        if (!isInteresting) return;
+
+        // Find associated skill
+        const skillMatch = entry.match(skillRegex);
+        let skillName = 'General / System';
+        if (skillMatch) {
+            skillName = skillMatch[1];
+        } else {
+            // Try heuristics
+            if (entry.toLowerCase().includes('feishu card')) skillName = 'feishu-card';
+            else if (entry.toLowerCase().includes('git sync')) skillName = 'git-sync';
+            else if (entry.toLowerCase().includes('logger')) skillName = 'interaction-logger';
+            else if (entry.toLowerCase().includes('evolve')) skillName = 'capability-evolver';
+        }
+
+        // Extract description
+        let description = "";
+        const actionMatch = entry.match(actionRegex);
+        if (actionMatch) {
+            description = actionMatch[1].trim();
+        } else {
+            // Fallback: take lines that look like bullet points or text after header
+            const lines = entry.split('\n');
+            description = lines.filter(l => l.match(/^[•\-\*]|\w/)).slice(1).join('\n').trim();
+        }
+
+        // Clean up description (remove duplicate "Action:" prefix if captured)
+        description = description.replace(/^Action:\s*/i, '');
+
+        if (!skillUpdates[skillName]) skillUpdates[skillName] = [];
+        
+        // Dedup descriptions slightly (simple check)
+        const isDuplicate = skillUpdates[skillName].some(u => u.desc.includes(description.substring(0, 20)));
+        if (!isDuplicate) {
+            // Extract Date if possible
+            const dateMatch = entry.match(/\((\d{4}\/\d{1,2}\/\d{1,2}.*?)\)/);
+            const date = dateMatch ? dateMatch[1] : 'Unknown';
+            
+            skillUpdates[skillName].push({
+                date,
+                status,
+                desc: description
+            });
+        }
+    });
+
+    // Generate Markdown
+    let md = "# Detailed Evolution Report (By Skill)\n\n> Comprehensive breakdown of system changes.\n\n";
+
+    // Sort skills alphabetically
+    const sortedSkills = Object.keys(skillUpdates).sort();
+
+    sortedSkills.forEach(skill => {
+        md += `## ${skill}\n`;
+        const updates = skillUpdates[skill];
+        
+        updates.forEach(u => {
+            // Icon based on content
+            let icon = '*';
+            const lowerDesc = u.desc.toLowerCase();
+            if (lowerDesc.includes('optimiz')) icon = '[optimize]';
+            if (lowerDesc.includes('secur') || lowerDesc.includes('harden') || lowerDesc.includes('permission')) icon = '[security]';
+            if (lowerDesc.includes('fix') || lowerDesc.includes('patch')) icon = '[repair]';
+            if (lowerDesc.includes('creat') || lowerDesc.includes('add')) icon = '[add]';
+
+            md += `### ${icon} ${u.date}\n`;
+            md += `${u.desc}\n\n`;
+        });
+        md += `---\n`;
+    });
+
+    fs.writeFileSync(OUT_FILE, md);
+    console.log(`Generated report for ${sortedSkills.length} skills.`);
+}
+
+analyzeEvolution();
+