0agent 1.0.47 → 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; }
@@ -1002,51 +1047,55 @@ async function openPalette(initialFilter = '') {
 
   let filter  = initialFilter.toLowerCase();
   let idx     = 0;
-  let drawn   = 0; // number of lines we've printed so far
+  let scroll  = 0;  // top of the visible window
+  let drawn   = 0;
+  const PAGE  = 10; // visible rows at once
 
   const getItems = () => SLASH_COMMANDS.filter(c =>
     !filter || c.cmd.slice(1).startsWith(filter)
   );
 
   const paint = () => {
-    // Erase previous draw: move up `drawn` lines, clear everything below
     if (drawn > 0) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
 
-    const items  = getItems();
-    const show   = items.slice(0, 14);
-    if (idx >= items.length) idx = Math.max(0, items.length - 1);
+    const items = getItems();
+    if (items.length === 0) { idx = 0; scroll = 0; }
+    else {
+      idx = Math.max(0, Math.min(idx, items.length - 1));
+      // Keep selected item inside the visible window
+      if (idx < scroll)           scroll = idx;
+      if (idx >= scroll + PAGE)   scroll = idx - PAGE + 1;
+    }
 
+    const show  = items.slice(scroll, scroll + PAGE);
     const lines = [];
 
-    // Top border
     lines.push(`  \x1b[2m${'─'.repeat(58)}\x1b[0m`);
 
-    if (show.length === 0) {
+    if (items.length === 0) {
       lines.push(`  \x1b[2m  no commands match "/${filter}"\x1b[0m`);
     } else {
       for (let i = 0; i < show.length; i++) {
         const m   = show[i];
-        const sel = i === idx;
+        const sel = (scroll + i) === idx;
         if (sel) {
-          lines.push(
-            `  \x1b[36;1m›\x1b[0m \x1b[36;1m${m.cmd.padEnd(22)}\x1b[0m \x1b[0m${m.desc}\x1b[0m`
-          );
+          lines.push(`  \x1b[36;1m›\x1b[0m \x1b[36;1m${m.cmd.padEnd(22)}\x1b[0m ${m.desc}`);
         } else {
-          lines.push(
-            `    \x1b[36m${m.cmd.padEnd(22)}\x1b[0m \x1b[2m${m.desc}\x1b[0m`
-          );
+          lines.push(`    \x1b[36m${m.cmd.padEnd(22)}\x1b[0m \x1b[2m${m.desc}\x1b[0m`);
         }
       }
     }
 
-    if (items.length > 14) lines.push(`  \x1b[2m  …${items.length - 14} more\x1b[0m`);
+    // Scroll indicator
+    if (items.length > PAGE) {
+      const pct = Math.round(((scroll + PAGE / 2) / items.length) * 100);
+      lines.push(`  \x1b[2m  ${idx + 1} / ${items.length}  (${pct}%)\x1b[0m`);
+    }
 
-    // Bottom: search input line
     lines.push(`  \x1b[2m${'─'.repeat(58)}\x1b[0m`);
-    lines.push(`  ${fmt(C.cyan, '/')}${filter}\x1b[K  \x1b[2m↑↓ navigate · Enter select · Esc cancel\x1b[0m`);
+    lines.push(`  ${fmt(C.cyan, '/')}${filter}\x1b[K  \x1b[2m↑↓ scroll · Enter select · Esc cancel\x1b[0m`);
 
-    const out = lines.join('\n') + '\n';
-    process.stdout.write(out);
+    process.stdout.write(lines.join('\n') + '\n');
     drawn = lines.length;
   };
 
@@ -1069,11 +1118,11 @@ async function openPalette(initialFilter = '') {
         paint();
       } else if (s === '\x7f' || s === '\x08') { // Backspace
         filter = filter.slice(0, -1);
-        idx = 0;
+        idx = 0; scroll = 0;
         paint();
       } else if (/^[a-z0-9\-_]$/i.test(s)) {   // Printable letter/digit/hyphen
         filter += s.toLowerCase();
-        idx = 0;
+        idx = 0; scroll = 0;
         paint();
       }
     };
@@ -1410,17 +1459,19 @@ function isNewerVersion(a, b) {
 
 // ─── Message queue + serial executor ─────────────────────────────────────────
 
-const COMMAND_PREFIXES = ['/model','/key','/status','/skills','/graph','/clear','/help','/schedule','/update'];
+// Only these exact prefixes are built-in commands handled by handleCommand().
+// Everything else starting with '/' is a skill → routed to runTask().
+const COMMAND_PREFIXES = ['/model','/key','/status','/skills','/graph','/clear',
+  '/help','/schedule','/update','/telegram'];
 
 async function executeInput(line) {
-  const isCmd = line.startsWith('/') || COMMAND_PREFIXES.some(c => line.startsWith(c));
+  const isCmd = COMMAND_PREFIXES.some(c => line === c || line.startsWith(c + ' '));
   if (isCmd) {
     await handleCommand(line);
   } else {
     lastFailedTask = null;
     await runTask(line);
   }
-  // After this input completes, drain the queue
   await drainQueue();
 }
 

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.47",
+  "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",