0agent 1.0.48 → 1.0.49

package/bin/chat.js

@@ -31,6 +31,7 @@ const SLASH_COMMANDS = [
   { cmd: '/security-audit',desc: 'Security audit — find vulnerabilities'           },
   { cmd: '/design-review', desc: 'Design review — architecture and patterns'       },
   // Built-ins
+  { cmd: '/memory',        desc: 'Show graph nodes and force-push to GitHub'        },
   { cmd: '/telegram',      desc: 'Connect Telegram bot — forward messages to 0agent'},
   { cmd: '/model',         desc: 'Show or switch the LLM model'                   },
   { cmd: '/key',           desc: 'Update a stored API key'                         },
@@ -902,6 +903,50 @@ async function handleCommand(input) {
       break;
     }
 
+    // /memory — inspect graph nodes + force GitHub sync
+    case '/memory': {
+      try {
+        const sub = parts[1]?.toLowerCase();
+
+        if (sub === 'sync' || sub === 'push') {
+          process.stdout.write(`  ${fmt(C.dim, 'Pushing to GitHub...')}\n`);
+          const res = await fetch(`${BASE_URL}/api/memory/push`, { method: 'POST' }).catch(() => null);
+          const data = res?.ok ? await res.json().catch(() => null) : null;
+          if (data?.pushed) {
+            console.log(`  ${fmt(C.green, '✓')} Pushed ${data.nodes_synced} nodes, ${data.edges_synced} edges to GitHub\n`);
+          } else {
+            console.log(`  ${fmt(C.yellow, '⚠')} ${data?.error ?? 'Sync not configured or failed'}\n`);
+          }
+          break;
+        }
+
+        // Show memory nodes from graph
+        const res = await fetch(`${BASE_URL}/api/graph/nodes?limit=200`).then(r => r.json()).catch(() => []);
+        const nodes = Array.isArray(res) ? res : [];
+        const memNodes = nodes.filter(n => n.id?.startsWith('memory:') || n.type === 'context');
+        const total    = nodes.length;
+
+        console.log(`\n  ${fmt(C.bold, 'Knowledge graph')} — ${total} nodes total, ${memNodes.length} memory nodes\n`);
+
+        if (memNodes.length === 0) {
+          console.log(`  ${fmt(C.dim, 'No memory nodes yet. Run a task — the agent will write facts here.')}\n`);
+        } else {
+          for (const n of memNodes.slice(0, 20)) {
+            const content = n.metadata?.content ?? n.label;
+            const type    = n.metadata?.type ?? n.type;
+            console.log(`  ${fmt(C.cyan, n.label.padEnd(28))} ${fmt(C.dim, String(content).slice(0, 50))}`);
+            console.log(`  ${fmt(C.dim, `  ${n.id}  [${type}]`)}`);
+          }
+          if (memNodes.length > 20) console.log(fmt(C.dim, `\n  …and ${memNodes.length - 20} more`));
+        }
+        console.log();
+        console.log(`  ${fmt(C.dim, 'Force sync: /memory sync  ·  Dashboard: http://localhost:4200')}\n`);
+      } catch {
+        console.log(`  ${fmt(C.red, '✗')} Daemon not running\n`);
+      }
+      break;
+    }
+
     // /telegram — configure Telegram bot token
     case '/telegram': {
       if (!cfg) { console.log(fmt(C.red, '  No config found. Run: 0agent init')); break; }

package/dist/daemon.mjs

@@ -4765,12 +4765,18 @@ Current task:`;
           anthropicContext,
           enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : void 0
         ].filter(Boolean).join("\n\n") || void 0;
+        const fullConfig = {
+          cwd: this.cwd,
+          agent_root: this.agentRoot,
+          graph: this.graph,
+          onMemoryWrite: this.onMemoryWritten
+        };
         let agentResult;
         try {
           const { SelfHealLoop: SelfHealLoop2 } = await Promise.resolve().then(() => (init_SelfHealLoop(), SelfHealLoop_exports));
           const healLoop = new SelfHealLoop2(
             activeLLM,
-            { cwd: this.cwd, agent_root: this.agentRoot },
+            fullConfig,
             (step) => this.addStep(sessionId, step),
             (token) => this.emit({ type: "session.token", session_id: sessionId, token })
           );
@@ -4827,7 +4833,37 @@ Current task:`;
           this.addStep(sessionId, `Commands run: ${agentResult.commands_run.length}`);
         }
         this.addStep(sessionId, `Done (${agentResult.tokens_used} tokens, ${agentResult.iterations} LLM turns)`);
-        this._extractAndPersistFacts(enrichedReq.task, agentResult.output, activeLLM).catch(() => {
+        if (this.graph) {
+          try {
+            const nodeId = `memory:session_${sessionId.slice(0, 8)}`;
+            const label = enrichedReq.task.slice(0, 80);
+            const existing = this.graph.getNode(nodeId);
+            const meta = {
+              task: enrichedReq.task.slice(0, 300),
+              output: agentResult.output.slice(0, 300),
+              type: "session_summary",
+              tokens: agentResult.tokens_used,
+              saved_at: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (existing) {
+              this.graph.updateNode(nodeId, { label, metadata: meta });
+            } else {
+              this.graph.addNode(createNode({
+                id: nodeId,
+                graph_id: "root",
+                label,
+                type: "context" /* CONTEXT */,
+                metadata: meta
+              }));
+            }
+            console.log(`[0agent] Graph: wrote session summary node (${nodeId})`);
+            this.onMemoryWritten?.();
+          } catch (err) {
+            console.warn("[0agent] Graph: baseline write failed:", err instanceof Error ? err.message : err);
+          }
+        }
+        this._extractAndPersistFacts(enrichedReq.task, agentResult.output, activeLLM).catch((err) => {
+          console.warn("[0agent] Memory extraction outer error:", err instanceof Error ? err.message : err);
         });
         this.completeSession(sessionId, {
           output: agentResult.output,
@@ -7323,13 +7359,18 @@ var ZeroAgentDaemon = class {
       adapter: this.adapter,
       agentRoot,
       // agent source path — self-improvement tasks read the right files
-      // Push to GitHub immediately when facts are extracted from a session
+      // Push to GitHub immediately when facts are written to the graph
       onMemoryWritten: () => {
         this.githubMemorySync?.markDirty();
         if (this.githubMemorySync) {
           this.githubMemorySync.push("sync: new facts learned").then((r) => {
-            if (r.pushed) console.log(`[0agent] Memory pushed: ${r.nodes_synced} nodes \u2192 github`);
-          }).catch(() => {
+            if (r.pushed) {
+              console.log(`[0agent] Memory pushed: ${r.nodes_synced} nodes, ${r.edges_synced} edges \u2192 github`);
+            } else if (r.error) {
+              console.warn(`[0agent] Memory push failed: ${r.error}`);
+            }
+          }).catch((err) => {
+            console.warn("[0agent] Memory push exception:", err instanceof Error ? err.message : err);
           });
         }
       }
@@ -7338,9 +7379,14 @@ var ZeroAgentDaemon = class {
     if (this.githubMemorySync) {
       const memSync = this.githubMemorySync;
       this.memorySyncTimer = setInterval(async () => {
-        const result = await memSync.push().catch(() => null);
-        if (result?.pushed && result.nodes_synced > 0) {
-          console.log(`[0agent] Memory synced: ${result.nodes_synced} nodes \u2192 github`);
+        const result = await memSync.push().catch((err) => {
+          console.warn("[0agent] Memory timer push failed:", err instanceof Error ? err.message : err);
+          return null;
+        });
+        if (result?.pushed) {
+          console.log(`[0agent] Memory sync: ${result.nodes_synced} nodes \u2192 github`);
+        } else if (result?.error) {
+          console.warn(`[0agent] Memory sync error: ${result.error}`);
         }
       }, 2 * 60 * 1e3);
       if (typeof this.memorySyncTimer === "object") this.memorySyncTimer.unref?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",