@evomap/evolver 1.29.0

package/src/gep/analyzer.js

@@ -0,0 +1,35 @@
+const fs = require('fs');
+const path = require('path');
+
+// Innovation: Self-Correction Analyzer
+// Analyze past failures to suggest better future mutations
+// Pattern: Meta-learning
+
+function analyzeFailures() {
+  const memoryPath = path.join(process.cwd(), 'MEMORY.md');
+  if (!fs.existsSync(memoryPath)) return { status: 'skipped', reason: 'no_memory' };
+  
+  const content = fs.readFileSync(memoryPath, 'utf8');
+  const failureRegex = /\|\s*\*\*F\d+\*\*\s*\|\s*Fix\s*\|\s*(.*?)\s*\|\s*\*\*(.*?)\*\*\s*\((.*?)\)\s*\|/g;
+  
+  const failures = [];
+  let match;
+  while ((match = failureRegex.exec(content)) !== null) {
+    failures.push({
+      summary: match[1].trim(),
+      detail: match[2].trim()
+    });
+  }
+  
+  return {
+    status: 'success',
+    count: failures.length,
+    failures: failures.slice(0, 3) // Return top 3 for prompt context
+  };
+}
+
+if (require.main === module) {
+  console.log(JSON.stringify(analyzeFailures(), null, 2));
+}
+
+module.exports = { analyzeFailures };

package/src/gep/assetCallLog.js

@@ -0,0 +1,130 @@
+// Append-only asset call log for tracking Hub asset interactions per evolution run.
+// Log file: {evolution_dir}/asset_call_log.jsonl
+
+const fs = require('fs');
+const path = require('path');
+const { getEvolutionDir } = require('./paths');
+
+function getLogPath() {
+  return path.join(getEvolutionDir(), 'asset_call_log.jsonl');
+}
+
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Append a single asset call record to the log.
+ *
+ * @param {object} entry
+ * @param {string} entry.run_id
+ * @param {string} entry.action - hub_search_hit | hub_search_miss | asset_reuse | asset_reference | asset_publish | asset_publish_skip
+ * @param {string} [entry.asset_id]
+ * @param {string} [entry.asset_type]
+ * @param {string} [entry.source_node_id]
+ * @param {string} [entry.chain_id]
+ * @param {number} [entry.score]
+ * @param {string} [entry.mode] - direct | reference
+ * @param {string[]} [entry.signals]
+ * @param {string} [entry.reason]
+ * @param {object} [entry.extra]
+ */
+function logAssetCall(entry) {
+  if (!entry || typeof entry !== 'object') return;
+  try {
+    const logPath = getLogPath();
+    ensureDir(logPath);
+    const record = {
+      timestamp: new Date().toISOString(),
+      ...entry,
+    };
+    fs.appendFileSync(logPath, JSON.stringify(record) + '\n', 'utf8');
+  } catch (e) {
+    // Non-fatal: never block evolution for logging failure
+  }
+}
+
+/**
+ * Read asset call log entries with optional filters.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.run_id] - filter by run_id
+ * @param {string} [opts.action] - filter by action type
+ * @param {number} [opts.last] - only return last N entries
+ * @param {string} [opts.since] - ISO date string, only entries after this time
+ * @returns {object[]}
+ */
+function readCallLog(opts) {
+  const o = opts || {};
+  const logPath = getLogPath();
+  if (!fs.existsSync(logPath)) return [];
+
+  const raw = fs.readFileSync(logPath, 'utf8');
+  const lines = raw.split('\n').filter(Boolean);
+
+  let entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch (e) { /* skip corrupt lines */ }
+  }
+
+  if (o.since) {
+    const sinceTs = new Date(o.since).getTime();
+    if (Number.isFinite(sinceTs)) {
+      entries = entries.filter(e => new Date(e.timestamp).getTime() >= sinceTs);
+    }
+  }
+
+  if (o.run_id) {
+    entries = entries.filter(e => e.run_id === o.run_id);
+  }
+
+  if (o.action) {
+    entries = entries.filter(e => e.action === o.action);
+  }
+
+  if (o.last && Number.isFinite(o.last) && o.last > 0) {
+    entries = entries.slice(-o.last);
+  }
+
+  return entries;
+}
+
+/**
+ * Summarize asset call log (for CLI display).
+ *
+ * @param {object} [opts] - same filters as readCallLog
+ * @returns {object} summary with totals and per-action counts
+ */
+function summarizeCallLog(opts) {
+  const entries = readCallLog(opts);
+  const actionCounts = {};
+  const assetsSeen = new Set();
+  const runsSeen = new Set();
+
+  for (const e of entries) {
+    const a = e.action || 'unknown';
+    actionCounts[a] = (actionCounts[a] || 0) + 1;
+    if (e.asset_id) assetsSeen.add(e.asset_id);
+    if (e.run_id) runsSeen.add(e.run_id);
+  }
+
+  return {
+    total_entries: entries.length,
+    unique_assets: assetsSeen.size,
+    unique_runs: runsSeen.size,
+    by_action: actionCounts,
+    entries,
+  };
+}
+
+module.exports = {
+  logAssetCall,
+  readCallLog,
+  summarizeCallLog,
+  getLogPath,
+};

package/src/gep/assetStore.js

@@ -0,0 +1,297 @@
+const fs = require('fs');
+const path = require('path');
+const { getGepAssetsDir } = require('./paths');
+const { computeAssetId, SCHEMA_VERSION } = require('./contentHash');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJsonIfExists(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonAtomic(filePath, obj) {
+  const dir = path.dirname(filePath);
+  ensureDir(dir);
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, filePath);
+}
+
+// Build a validation command using repo-root-relative paths.
+// runValidations() executes with cwd=repoRoot, so require('./src/...')
+// resolves correctly without embedding machine-specific absolute paths.
+function buildValidationCmd(relModules) {
+  const paths = relModules.map(m => `./${m}`);
+  return `node scripts/validate-modules.js ${paths.join(' ')}`;
+}
+
+function getDefaultGenes() {
+  return {
+    version: 1,
+    genes: [
+      {
+        type: 'Gene', id: 'gene_gep_repair_from_errors', category: 'repair',
+        signals_match: ['error', 'exception', 'failed', 'unstable'],
+        preconditions: ['signals contains error-related indicators'],
+        strategy: [
+          'Extract structured signals from logs and user instructions',
+          'Select an existing Gene by signals match (no improvisation)',
+          'Estimate blast radius (files, lines) before editing',
+          'Apply smallest reversible patch',
+          'Validate using declared validation steps; rollback on failure',
+          'Solidify knowledge: append EvolutionEvent, update Gene/Capsule store',
+        ],
+        constraints: { max_files: 12, forbidden_paths: ['.git', 'node_modules'] },
+        validation: [
+          buildValidationCmd(['src/evolve', 'src/gep/solidify']),
+          buildValidationCmd(['src/gep/selector', 'src/gep/memoryGraph']),
+        ],
+      },
+      {
+        type: 'Gene', id: 'gene_gep_optimize_prompt_and_assets', category: 'optimize',
+        signals_match: ['protocol', 'gep', 'prompt', 'audit', 'reusable'],
+        preconditions: ['need stricter, auditable evolution protocol outputs'],
+        strategy: [
+          'Extract signals and determine selection rationale via Selector JSON',
+          'Prefer reusing existing Gene/Capsule; only create if no match exists',
+          'Refactor prompt assembly to embed assets (genes, capsules, parent event)',
+          'Reduce noise and ambiguity; enforce strict output schema',
+          'Validate by running node index.js run and ensuring no runtime errors',
+          'Solidify: record EvolutionEvent, update Gene definitions, create Capsule on success',
+        ],
+        constraints: { max_files: 20, forbidden_paths: ['.git', 'node_modules'] },
+        validation: [buildValidationCmd(['src/evolve', 'src/gep/prompt'])],
+      },
+    ],
+  };
+}
+
+function getDefaultCapsules() { return { version: 1, capsules: [] }; }
+function genesPath() { return path.join(getGepAssetsDir(), 'genes.json'); }
+function capsulesPath() { return path.join(getGepAssetsDir(), 'capsules.json'); }
+function capsulesJsonlPath() { return path.join(getGepAssetsDir(), 'capsules.jsonl'); }
+function eventsPath() { return path.join(getGepAssetsDir(), 'events.jsonl'); }
+function candidatesPath() { return path.join(getGepAssetsDir(), 'candidates.jsonl'); }
+function externalCandidatesPath() { return path.join(getGepAssetsDir(), 'external_candidates.jsonl'); }
+function failedCapsulesPath() { return path.join(getGepAssetsDir(), 'failed_capsules.json'); }
+
+function loadGenes() {
+  const jsonGenes = readJsonIfExists(genesPath(), getDefaultGenes()).genes || [];
+  const jsonlGenes = [];
+  try {
+    const p = path.join(getGepAssetsDir(), 'genes.jsonl');
+    if (fs.existsSync(p)) {
+      const raw = fs.readFileSync(p, 'utf8');
+      raw.split('\n').forEach(line => {
+        if (line.trim()) {
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed && parsed.type === 'Gene') jsonlGenes.push(parsed);
+          } catch(e) {}
+        }
+      });
+    }
+  } catch(e) {}
+
+  // Combine and deduplicate by ID (JSONL takes precedence if newer, but here we just merge)
+  const combined = [...jsonGenes, ...jsonlGenes];
+  const unique = new Map();
+  combined.forEach(g => {
+    if (g && g.id) unique.set(String(g.id), g);
+  });
+  return Array.from(unique.values());
+}
+
+function loadCapsules() {
+  const legacy = readJsonIfExists(capsulesPath(), getDefaultCapsules()).capsules || [];
+  const jsonlCapsules = [];
+  try {
+    const p = capsulesJsonlPath();
+    if (fs.existsSync(p)) {
+      const raw = fs.readFileSync(p, 'utf8');
+      raw.split('\n').forEach(line => {
+        if (line.trim()) {
+            try { jsonlCapsules.push(JSON.parse(line)); } catch(e) {}
+        }
+      });
+    }
+  } catch(e) {}
+  
+  // Combine and deduplicate by ID
+  const combined = [...legacy, ...jsonlCapsules];
+  const unique = new Map();
+  combined.forEach(c => {
+      if (c && c.id) unique.set(String(c.id), c);
+  });
+  return Array.from(unique.values());
+}
+
+function getLastEventId() {
+  try {
+    const p = eventsPath();
+    if (!fs.existsSync(p)) return null;
+    const raw = fs.readFileSync(p, 'utf8');
+    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+    if (lines.length === 0) return null;
+    const last = JSON.parse(lines[lines.length - 1]);
+    return last && typeof last.id === 'string' ? last.id : null;
+  } catch { return null; }
+}
+
+function readAllEvents() {
+  try {
+    const p = eventsPath();
+    if (!fs.existsSync(p)) return [];
+    const raw = fs.readFileSync(p, 'utf8');
+    return raw.split('\n').map(l => l.trim()).filter(Boolean).map(l => {
+      try { return JSON.parse(l); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function appendEventJsonl(eventObj) {
+  const dir = getGepAssetsDir(); ensureDir(dir);
+  fs.appendFileSync(eventsPath(), JSON.stringify(eventObj) + '\n', 'utf8');
+}
+
+function appendCandidateJsonl(candidateObj) {
+  const dir = getGepAssetsDir(); ensureDir(dir);
+  fs.appendFileSync(candidatesPath(), JSON.stringify(candidateObj) + '\n', 'utf8');
+}
+
+function appendExternalCandidateJsonl(obj) {
+  const dir = getGepAssetsDir(); ensureDir(dir);
+  fs.appendFileSync(externalCandidatesPath(), JSON.stringify(obj) + '\n', 'utf8');
+}
+
+function readRecentCandidates(limit = 20) {
+  try {
+    const p = candidatesPath();
+    if (!fs.existsSync(p)) return [];
+    const raw = fs.readFileSync(p, 'utf8');
+    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+    return lines.slice(Math.max(0, lines.length - limit)).map(l => {
+      try { return JSON.parse(l); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function readRecentExternalCandidates(limit = 50) {
+  try {
+    const p = externalCandidatesPath();
+    if (!fs.existsSync(p)) return [];
+    const raw = fs.readFileSync(p, 'utf8');
+    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+    return lines.slice(Math.max(0, lines.length - limit)).map(l => {
+      try { return JSON.parse(l); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+// Safety net: ensure schema_version and asset_id are present before writing.
+function ensureSchemaFields(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (!obj.schema_version) obj.schema_version = SCHEMA_VERSION;
+  if (!obj.asset_id) { try { obj.asset_id = computeAssetId(obj); } catch (e) {} }
+  return obj;
+}
+
+function upsertGene(geneObj) {
+  ensureSchemaFields(geneObj);
+  const current = readJsonIfExists(genesPath(), getDefaultGenes());
+  const genes = Array.isArray(current.genes) ? current.genes : [];
+  const idx = genes.findIndex(g => g && g.id === geneObj.id);
+  if (idx >= 0) genes[idx] = geneObj; else genes.push(geneObj);
+  writeJsonAtomic(genesPath(), { version: current.version || 1, genes });
+}
+
+function appendCapsule(capsuleObj) {
+  ensureSchemaFields(capsuleObj);
+  const current = readJsonIfExists(capsulesPath(), getDefaultCapsules());
+  const capsules = Array.isArray(current.capsules) ? current.capsules : [];
+  capsules.push(capsuleObj);
+  writeJsonAtomic(capsulesPath(), { version: current.version || 1, capsules });
+}
+
+function upsertCapsule(capsuleObj) {
+  if (!capsuleObj || capsuleObj.type !== 'Capsule' || !capsuleObj.id) return;
+  ensureSchemaFields(capsuleObj);
+  const current = readJsonIfExists(capsulesPath(), getDefaultCapsules());
+  const capsules = Array.isArray(current.capsules) ? current.capsules : [];
+  const idx = capsules.findIndex(c => c && c.type === 'Capsule' && String(c.id) === String(capsuleObj.id));
+  if (idx >= 0) capsules[idx] = capsuleObj; else capsules.push(capsuleObj);
+  writeJsonAtomic(capsulesPath(), { version: current.version || 1, capsules });
+}
+
+var FAILED_CAPSULES_MAX = 200;
+var FAILED_CAPSULES_TRIM_TO = 100;
+
+function getDefaultFailedCapsules() { return { version: 1, failed_capsules: [] }; }
+
+function appendFailedCapsule(capsuleObj) {
+  if (!capsuleObj || typeof capsuleObj !== 'object') return;
+  ensureSchemaFields(capsuleObj);
+  var current = readJsonIfExists(failedCapsulesPath(), getDefaultFailedCapsules());
+  var list = Array.isArray(current.failed_capsules) ? current.failed_capsules : [];
+  list.push(capsuleObj);
+  if (list.length > FAILED_CAPSULES_MAX) {
+    list = list.slice(list.length - FAILED_CAPSULES_TRIM_TO);
+  }
+  writeJsonAtomic(failedCapsulesPath(), { version: current.version || 1, failed_capsules: list });
+}
+
+function readRecentFailedCapsules(limit) {
+  var n = Number.isFinite(Number(limit)) && Number(limit) > 0 ? Number(limit) : 50;
+  try {
+    var current = readJsonIfExists(failedCapsulesPath(), getDefaultFailedCapsules());
+    var list = Array.isArray(current.failed_capsules) ? current.failed_capsules : [];
+    return list.slice(Math.max(0, list.length - n));
+  } catch (e) {
+    return [];
+  }
+}
+
+// Ensure all expected asset files exist on startup.
+// Creates empty files for optional append-only stores so that
+// external grep/read commands never fail with "No such file or directory".
+function ensureAssetFiles() {
+  const dir = getGepAssetsDir();
+  ensureDir(dir);
+  const files = [
+    { path: genesPath(), defaultContent: JSON.stringify(getDefaultGenes(), null, 2) + '\n' },
+    { path: capsulesPath(), defaultContent: JSON.stringify(getDefaultCapsules(), null, 2) + '\n' },
+    { path: path.join(dir, 'genes.jsonl'), defaultContent: '' },
+    { path: eventsPath(), defaultContent: '' },
+    { path: candidatesPath(), defaultContent: '' },
+    { path: failedCapsulesPath(), defaultContent: JSON.stringify(getDefaultFailedCapsules(), null, 2) + '\n' },
+  ];
+  for (const f of files) {
+    if (!fs.existsSync(f.path)) {
+      try {
+        fs.writeFileSync(f.path, f.defaultContent, 'utf8');
+      } catch (e) {
+        // Non-fatal: log but continue
+        console.error(`[AssetStore] Failed to create ${f.path}: ${e.message}`);
+      }
+    }
+  }
+}
+
+module.exports = {
+  loadGenes, loadCapsules, readAllEvents, getLastEventId,
+  appendEventJsonl, appendCandidateJsonl, appendExternalCandidateJsonl,
+  readRecentCandidates, readRecentExternalCandidates,
+  upsertGene, appendCapsule, upsertCapsule,
+  appendFailedCapsule, readRecentFailedCapsules,
+  genesPath, capsulesPath, eventsPath, candidatesPath, externalCandidatesPath, failedCapsulesPath,
+  ensureAssetFiles, buildValidationCmd,
+};

package/src/gep/assets.js

@@ -0,0 +1,36 @@
+const { computeAssetId, SCHEMA_VERSION } = require('./contentHash');
+
+/**
+ * Format asset preview for prompt inclusion.
+ * Handles stringified JSON, arrays, and error cases gracefully.
+ */
+function formatAssetPreview(preview) {
+  if (!preview) return '(none)';
+  if (typeof preview === 'string') {
+      try {
+          const parsed = JSON.parse(preview);
+          if (Array.isArray(parsed) && parsed.length > 0) {
+              return JSON.stringify(parsed, null, 2);
+          }
+          return preview; // Keep as string if not array or empty
+      } catch (e) {
+          return preview; // Keep as string if parse fails
+      }
+  }
+  return JSON.stringify(preview, null, 2);
+}
+
+/**
+ * Validate and normalize an asset object.
+ * Ensures schema version and ID are present.
+ */
+function normalizeAsset(asset) {
+  if (!asset || typeof asset !== 'object') return asset;
+  if (!asset.schema_version) asset.schema_version = SCHEMA_VERSION;
+  if (!asset.asset_id) {
+    try { asset.asset_id = computeAssetId(asset); } catch (e) {}
+  }
+  return asset;
+}
+
+module.exports = { formatAssetPreview, normalizeAsset };

package/src/gep/bridge.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dir) {
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  } catch (e) {}
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function clip(text, maxChars) {
+  const s = String(text || '');
+  const n = Number(maxChars);
+  if (!Number.isFinite(n) || n <= 0) return s;
+  if (s.length <= n) return s;
+  return s.slice(0, Math.max(0, n - 40)) + '\n...[TRUNCATED]...\n';
+}
+
+function writePromptArtifact({ memoryDir, cycleId, runId, prompt, meta }) {
+  const dir = String(memoryDir || '').trim();
+  if (!dir) throw new Error('bridge: missing memoryDir');
+  ensureDir(dir);
+  const safeCycle = String(cycleId || 'cycle').replace(/[^a-zA-Z0-9_\-#]/g, '_');
+  const safeRun = String(runId || Date.now()).replace(/[^a-zA-Z0-9_\-]/g, '_');
+  const base = `gep_prompt_${safeCycle}_${safeRun}`;
+  const promptPath = path.join(dir, base + '.txt');
+  const metaPath = path.join(dir, base + '.json');
+
+  fs.writeFileSync(promptPath, String(prompt || ''), 'utf8');
+  fs.writeFileSync(
+    metaPath,
+    JSON.stringify(
+      {
+        type: 'GepPromptArtifact',
+        at: nowIso(),
+        cycle_id: cycleId || null,
+        run_id: runId || null,
+        prompt_path: promptPath,
+        meta: meta && typeof meta === 'object' ? meta : null,
+      },
+      null,
+      2
+    ) + '\n',
+    'utf8'
+  );
+
+  return { promptPath, metaPath };
+}
+
+function renderSessionsSpawnCall({ task, agentId, label, cleanup }) {
+  const t = String(task || '').trim();
+  if (!t) throw new Error('bridge: missing task');
+  const a = String(agentId || 'main');
+  const l = String(label || 'gep_bridge');
+  const c = cleanup ? String(cleanup) : 'delete';
+
+  // Output valid JSON so wrappers can parse with JSON.parse (not regex).
+  // The wrapper uses lastIndexOf('sessions_spawn(') + JSON.parse to extract the task.
+  const payload = JSON.stringify({ task: t, agentId: a, cleanup: c, label: l });
+  return `sessions_spawn(${payload})`;
+}
+
+module.exports = {
+  clip,
+  writePromptArtifact,
+  renderSessionsSpawnCall,
+};
+