hebbian 0.3.3 → 0.3.4

package/dist/bin/hebbian.js

@@ -1237,6 +1237,29 @@ function logEpisode(brainRoot, type, path, detail) {
     "utf8"
   );
 }
+function readEpisodes(brainRoot) {
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) return [];
+  const episodes = [];
+  let entries;
+  try {
+    entries = readdirSync7(logDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
+    try {
+      const content = readFileSync4(join12(logDir, entry), "utf8");
+      if (content.trim()) {
+        episodes.push(JSON.parse(content));
+      }
+    } catch {
+    }
+  }
+  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
+  return episodes;
+}
 function getNextSlot(logDir) {
   let maxSlot = 0;
   try {
@@ -2171,6 +2194,263 @@ var init_digest = __esm({
   }
 });
 
+// src/evolve.ts
+var evolve_exports = {};
+__export(evolve_exports, {
+  buildBrainSummary: () => buildBrainSummary,
+  buildPrompt: () => buildPrompt,
+  callGemini: () => callGemini,
+  executeActions: () => executeActions,
+  parseActions: () => parseActions,
+  runEvolve: () => runEvolve,
+  validateActions: () => validateActions
+});
+async function runEvolve(brainRoot, dryRun) {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    console.error("\u274C GEMINI_API_KEY not set. Get one at https://aistudio.google.com/apikey");
+    return { actions: [], executed: 0, skipped: 0, dryRun };
+  }
+  const episodes = readEpisodes(brainRoot);
+  const brain = scanBrain(brainRoot);
+  const summary = buildBrainSummary(brain);
+  const prompt = buildPrompt(summary, episodes);
+  let rawActions;
+  try {
+    rawActions = await callGemini(prompt, apiKey);
+  } catch (err) {
+    const msg = err.message;
+    console.log(`\u23ED\uFE0F evolve skipped: ${msg}`);
+    logEpisode(brainRoot, "evolve-error", "", msg);
+    return { actions: [], executed: 0, skipped: 0, dryRun };
+  }
+  const actions = validateActions(rawActions, brain);
+  const skipped = rawActions.length - actions.length;
+  if (actions.length === 0) {
+    console.log("\u{1F9E0} evolve: no valid actions proposed");
+    return { actions: [], executed: 0, skipped, dryRun };
+  }
+  if (dryRun) {
+    console.log(`\u{1F9E0} evolve (dry-run): ${actions.length} action(s) proposed`);
+    for (const action of actions) {
+      console.log(`  ${actionIcon(action.type)} ${action.type} ${action.path} \u2014 ${action.reason}`);
+    }
+    return { actions, executed: 0, skipped, dryRun: true };
+  }
+  const executed = executeActions(brainRoot, actions);
+  logEpisode(brainRoot, "evolve", "", `${executed} action(s) executed, ${skipped} skipped`);
+  console.log(`\u{1F9E0} evolve: ${executed} action(s) executed, ${skipped} skipped`);
+  return { actions, executed, skipped, dryRun: false };
+}
+function buildBrainSummary(brain) {
+  const lines = ["# Brain State\n"];
+  for (const region of brain.regions) {
+    const neurons = region.neurons;
+    if (neurons.length === 0 && !region.hasBomb) continue;
+    lines.push(`## ${region.name} (P${REGION_PRIORITY[region.name]})`);
+    if (region.hasBomb) lines.push("\u26A0\uFE0F BOMB active \u2014 region blocked");
+    for (const neuron of neurons) {
+      const flags = [];
+      if (neuron.isDormant) flags.push("dormant");
+      if (neuron.hasBomb) flags.push("bomb");
+      if (neuron.hasMemory) flags.push("memory");
+      if (neuron.dopamine > 0) flags.push(`dopamine:${neuron.dopamine}`);
+      const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+      lines.push(`- ${neuron.path} (counter:${neuron.counter}, intensity:${neuron.intensity})${flagStr}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildPrompt(summary, episodes) {
+  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${e.path} \u2014 ${e.detail}`).join("\n") : "(no recent episodes)";
+  return `You are the evolve engine for a hebbian brain \u2014 a filesystem-based memory system for AI agents.
+
+## Axioms
+- Folder = Neuron, File = Firing Trace, Counter = Activation strength
+- 7 regions in subsumption cascade: brainstem(P0) > limbic(P1) > hippocampus(P2) > sensors(P3) > cortex(P4) > ego(P5) > prefrontal(P6)
+- Lower priority ALWAYS overrides higher priority
+- PROTECTED regions (brainstem, limbic, sensors): NEVER propose mutations for these
+
+## Current Brain
+${summary}
+
+## Recent Episodes (last ${episodes.length})
+${episodeLines}
+
+## Available Actions
+- grow: Create a new neuron at the given path (region/name). Use for recurring patterns that deserve permanent memory.
+- fire: Increment an existing neuron's counter. Use for strengthening well-confirmed rules.
+- signal: Add dopamine (reward), bomb (block), or memory signal. Use sparingly.
+- prune: Decrement a neuron's counter. Use for rules that aren't working or cause issues.
+- decay: Mark inactive neurons as dormant. Use for stale rules with no recent activity.
+
+## Constraints
+- Max ${MAX_ACTIONS} actions per cycle
+- PREFER fire over grow \u2014 strengthen existing neurons before creating new ones
+- NEVER target brainstem, limbic, or sensors regions
+- Each action needs a "reason" explaining why
+
+## Task
+Analyze the brain state and recent episodes. Propose actions to improve the brain.
+Focus on: strengthening repeatedly-used rules, pruning ineffective ones, growing new neurons from repeated patterns.
+
+Respond with a JSON array of actions:
+[{"type":"fire","path":"cortex/NO_console_log","reason":"fired 3 times in recent sessions"}]`;
+}
+async function callGemini(prompt, apiKey) {
+  const model = process.env.EVOLVE_MODEL || DEFAULT_MODEL;
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+  const body = {
+    contents: [{ parts: [{ text: prompt }] }],
+    generationConfig: {
+      responseMimeType: "application/json",
+      temperature: 0.2
+    }
+  };
+  let lastError = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    if (attempt > 0) {
+      await new Promise((r) => setTimeout(r, RETRY_DELAY));
+    }
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(API_TIMEOUT)
+      });
+      if (!res.ok) {
+        lastError = new Error(`Gemini API ${res.status}: ${res.statusText}`);
+        continue;
+      }
+      const data = await res.json();
+      if (data.error) {
+        lastError = new Error(`Gemini error: ${data.error.message || "unknown"}`);
+        continue;
+      }
+      const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+      if (!text) {
+        lastError = new Error("Gemini returned empty response");
+        continue;
+      }
+      return parseActions(text);
+    } catch (err) {
+      lastError = err;
+      continue;
+    }
+  }
+  throw lastError || new Error("Gemini call failed");
+}
+function parseActions(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`Failed to parse LLM response as JSON: ${text.slice(0, 100)}`);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("LLM response is not an array");
+  }
+  const validTypes = /* @__PURE__ */ new Set(["grow", "fire", "signal", "prune", "decay"]);
+  const actions = [];
+  for (const item of parsed) {
+    if (!item || typeof item !== "object") continue;
+    const { type, path, reason, signal } = item;
+    if (typeof type !== "string" || !validTypes.has(type)) continue;
+    if (typeof path !== "string" || path.length === 0) continue;
+    if (typeof reason !== "string") continue;
+    const action = { type, path, reason };
+    if (type === "signal" && typeof signal === "string") {
+      action.signal = signal;
+    }
+    actions.push(action);
+  }
+  return actions;
+}
+function validateActions(actions, _brain) {
+  return actions.filter((action) => {
+    const region = action.path.split("/")[0];
+    if (!region || PROTECTED_REGIONS.includes(region)) {
+      console.log(`   \u{1F6E1}\uFE0F blocked: ${action.type} ${action.path} (protected region)`);
+      return false;
+    }
+    if (!REGIONS.includes(region)) {
+      console.log(`   \u26A0\uFE0F skipped: ${action.type} ${action.path} (invalid region)`);
+      return false;
+    }
+    if (action.type === "signal" && action.signal && !["dopamine", "bomb", "memory"].includes(action.signal)) {
+      console.log(`   \u26A0\uFE0F skipped: signal ${action.path} (invalid signal type: ${action.signal})`);
+      return false;
+    }
+    return true;
+  }).slice(0, MAX_ACTIONS);
+}
+function executeActions(brainRoot, actions) {
+  let executed = 0;
+  for (const action of actions) {
+    try {
+      switch (action.type) {
+        case "fire":
+          fireNeuron(brainRoot, action.path);
+          break;
+        case "grow":
+          growNeuron(brainRoot, action.path);
+          break;
+        case "signal":
+          signalNeuron(brainRoot, action.path, action.signal || "dopamine");
+          break;
+        case "prune":
+          rollbackNeuron(brainRoot, action.path);
+          break;
+        case "decay":
+          runDecay(brainRoot, 0);
+          break;
+      }
+      console.log(`   ${actionIcon(action.type)} ${action.type} ${action.path}`);
+      executed++;
+    } catch (err) {
+      console.log(`   \u26A0\uFE0F failed: ${action.type} ${action.path} \u2014 ${err.message}`);
+    }
+  }
+  return executed;
+}
+function actionIcon(type) {
+  switch (type) {
+    case "fire":
+      return "\u{1F525}";
+    case "grow":
+      return "\u{1F331}";
+    case "signal":
+      return "\u26A1";
+    case "prune":
+      return "\u2702\uFE0F";
+    case "decay":
+      return "\u{1F4A4}";
+    default:
+      return "\u2753";
+  }
+}
+var MAX_ACTIONS, PROTECTED_REGIONS, DEFAULT_MODEL, API_TIMEOUT, RETRY_DELAY;
+var init_evolve = __esm({
+  "src/evolve.ts"() {
+    "use strict";
+    init_episode();
+    init_scanner();
+    init_constants();
+    init_fire();
+    init_grow();
+    init_signal();
+    init_rollback();
+    init_decay();
+    MAX_ACTIONS = 10;
+    PROTECTED_REGIONS = ["brainstem", "limbic", "sensors"];
+    DEFAULT_MODEL = "gemini-2.0-flash-lite";
+    API_TIMEOUT = 3e4;
+    RETRY_DELAY = 5e3;
+  }
+});
+
 // src/cli.ts
 init_constants();
 import { parseArgs } from "util";
@@ -2199,6 +2479,7 @@ COMMANDS:
   inbox                           Process corrections inbox
   claude install|uninstall|status Manage Claude Code hooks
   digest [--transcript <path>]    Extract corrections from conversation
+  evolve [--dry-run]              LLM-powered brain evolution (Gemini)
   diag                            Print brain diagnostics
   stats                           Print brain statistics
 
@@ -2213,6 +2494,7 @@ EXAMPLES:
   hebbian fire cortex/frontend/NO_console_log --brain ./my-brain
   hebbian emit claude --brain ./my-brain
   hebbian emit all
+  GEMINI_API_KEY=... hebbian evolve --dry-run
 `.trim();
 function readStdin() {
   return new Promise((resolve4) => {
@@ -2238,6 +2520,7 @@ async function main(argv) {
       days: { type: "string", short: "d" },
       port: { type: "string", short: "p" },
       transcript: { type: "string", short: "t" },
+      "dry-run": { type: "boolean" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" }
     },
@@ -2401,6 +2684,12 @@ async function main(argv) {
       }
       break;
     }
+    case "evolve": {
+      const dryRun = values["dry-run"] === true;
+      const { runEvolve: runEvolve2 } = await Promise.resolve().then(() => (init_evolve(), evolve_exports));
+      await runEvolve2(brainRoot, dryRun);
+      break;
+    }
     case "diag":
     case "stats": {
       const { scanBrain: scanBrain2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));