0agent 1.0.44 → 1.0.46

package/bin/chat.js

@@ -7,7 +7,7 @@
  * /model to switch. /key to add provider keys. Never forgets previous keys.
  */
 
-import { createInterface, emitKeypressEvents, moveCursor, clearLine as rlClearLine } from 'node:readline';
+import { createInterface, emitKeypressEvents } from 'node:readline';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
@@ -836,61 +836,114 @@ async function handleCommand(input) {
   }
 }
 
-// ─── Live slash-command menu ──────────────────────────────────────────────────
-// Drawn below the prompt as the user types. Uses moveCursor to avoid cursor
-// save/restore conflicts with readline.
-let _menuLines = 0; // how many lines the current menu occupies below the cursor
+// ─── Command palette ──────────────────────────────────────────────────────────
+// Fully takes over stdin when open. No cursor tricks — pauses readline,
+// reads raw bytes directly, draws with \x1b[NA\x1b[0J (up + clear-to-end).
+// Returns the selected command string, or null if cancelled.
 
-function _drawMenu(filter) {
-  if (pendingResolve) { _clearMenu(); return; } // don't show while session running
+let _paletteOpen = false;
 
-  const items = filter === null ? [] :
-    SLASH_COMMANDS.filter(c =>
-      !filter || c.cmd.slice(1).toLowerCase().startsWith(filter.toLowerCase())
-    ).slice(0, 10);
+async function openPalette(initialFilter = '') {
+  if (_paletteOpen || pendingResolve) return null;
+  _paletteOpen = true;
 
-  // If nothing changed (same count), skip redraw to avoid flicker
-  if (items.length === 0) { _clearMenu(); return; }
+  // Pause readline so it stops consuming stdin events
+  rl.pause();
+  // Resume the raw stream so our data handler receives bytes
+  process.stdin.resume();
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-  const needed = items.length + 1; // +1 for blank line
+  let filter  = initialFilter.toLowerCase();
+  let idx     = 0;
+  let drawn   = 0; // number of lines we've printed so far
 
-  // Move down past existing menu lines (or 0), then clear downward
-  const existingLines = _menuLines;
-  if (existingLines > 0) {
-    moveCursor(process.stdout, 0, existingLines);
-    for (let i = 0; i < existingLines; i++) {
-      rlClearLine(process.stdout, 0);
-      if (i < existingLines - 1) moveCursor(process.stdout, 0, -1);
-    }
-    moveCursor(process.stdout, 0, -(existingLines - 1));
-  }
+  const getItems = () => SLASH_COMMANDS.filter(c =>
+    !filter || c.cmd.slice(1).startsWith(filter)
+  );
 
-  // Print blank separator + menu items, tracking column 0
-  process.stdout.write('\n');
-  for (const m of items) {
-    process.stdout.write(
-      `  ${fmt(C.cyan, m.cmd.padEnd(20))} ${fmt(C.dim, m.desc)}\x1b[K\n`
-    );
-  }
+  const paint = () => {
+    // Erase previous draw: move up `drawn` lines, clear everything below
+    if (drawn > 0) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
 
-  // Move back up to the prompt line and restore cursor after the typed text
-  moveCursor(process.stdout, 0, -(needed));
-  // Jump to end of current line (readline already put cursor there)
-  moveCursor(process.stdout, 999, 0);
+    const items  = getItems();
+    const show   = items.slice(0, 14);
+    if (idx >= items.length) idx = Math.max(0, items.length - 1);
 
-  _menuLines = needed;
-}
+    const lines = [];
 
-function _clearMenu() {
-  if (_menuLines === 0) return;
-  const n = _menuLines;
-  _menuLines = 0;
-  moveCursor(process.stdout, 0, n);
-  for (let i = 0; i < n; i++) {
-    rlClearLine(process.stdout, 0);
-    moveCursor(process.stdout, 0, -1);
-  }
-  moveCursor(process.stdout, 0, 1); // back to prompt line
+    // Top border
+    lines.push(`  \x1b[2m${'─'.repeat(58)}\x1b[0m`);
+
+    if (show.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;
+        if (sel) {
+          lines.push(
+            `  \x1b[36;1m›\x1b[0m \x1b[36;1m${m.cmd.padEnd(22)}\x1b[0m \x1b[0m${m.desc}\x1b[0m`
+          );
+        } else {
+          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`);
+
+    // 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`);
+
+    const out = lines.join('\n') + '\n';
+    process.stdout.write(out);
+    drawn = lines.length;
+  };
+
+  paint();
+
+  return new Promise((resolve) => {
+    const onData = (chunk) => {
+      const s = chunk.toString();
+
+      if (s === '\r' || s === '\n') {           // Enter — select
+        const sel = getItems()[idx]?.cmd ?? null;
+        finish(sel);
+      } else if (s === '\x1b' || s === '\x03') { // Esc / Ctrl-C — cancel
+        finish(null);
+      } else if (s === '\x1b[A') {              // Up arrow
+        idx = Math.max(0, idx - 1);
+        paint();
+      } else if (s === '\x1b[B') {              // Down arrow
+        idx = Math.min(getItems().length - 1, idx + 1);
+        paint();
+      } else if (s === '\x7f' || s === '\x08') { // Backspace
+        filter = filter.slice(0, -1);
+        idx = 0;
+        paint();
+      } else if (/^[a-z0-9\-_]$/i.test(s)) {   // Printable letter/digit/hyphen
+        filter += s.toLowerCase();
+        idx = 0;
+        paint();
+      }
+    };
+
+    const finish = (selected) => {
+      process.stdin.removeListener('data', onData);
+      // Erase the palette
+      if (drawn > 0) process.stdout.write(`\x1b[${drawn}A\x1b[0J`);
+      drawn = 0;
+      _paletteOpen = false;
+      // Hand control back to readline
+      rl.resume();
+      resolve(selected);
+    };
+
+    process.stdin.on('data', onData);
+  });
 }
 
 // ─── Main REPL ────────────────────────────────────────────────────────────────
@@ -902,50 +955,31 @@ const rl = createInterface({
   completer: (line, callback) => {
     if (!line.startsWith('/')) return callback(null, [[], line]);
 
-    const filter = line.slice(1).toLowerCase();
-    const matches = SLASH_COMMANDS.filter(c =>
-      !filter || c.cmd.slice(1).startsWith(filter)
-    );
-
-    if (matches.length === 0) return callback(null, [[], line]);
+    const filter  = line.slice(1).toLowerCase();
+    const matches = SLASH_COMMANDS.filter(c => !filter || c.cmd.slice(1).startsWith(filter));
 
-    // Single match — let readline silently auto-complete
-    if (matches.length === 1) {
-      _clearMenu();
-      return callback(null, [[matches[0].cmd + ' '], line]);
-    }
+    // Single exact match — let readline silently auto-complete
+    if (matches.length === 1) return callback(null, [[matches[0].cmd + ' '], line]);
 
-    // Multiple matches — print formatted menu, suppress readline's plain list
-    _clearMenu();
-    process.stdout.write('\n\n');
-    for (const m of matches.slice(0, 12)) {
-      process.stdout.write(`  ${fmt(C.cyan, m.cmd.padEnd(22))} ${fmt(C.dim, m.desc)}\n`);
-    }
-    if (matches.length > 12) {
-      process.stdout.write(`  ${fmt(C.dim, `…and ${matches.length - 12} more`)}\n`);
-    }
-    process.stdout.write('\n');
-    setImmediate(() => rl.prompt(true));
+    // Multiple (or bare /) — open interactive palette
+    // Schedule after this tick so readline finishes its Tab handling first
+    setImmediate(async () => {
+      // Clear the typed fragment from the prompt line before opening palette
+      process.stdout.write('\r\x1b[2K');
+      const selected = await openPalette(filter);
+      if (selected) {
+        await executeInput(selected);
+      } else {
+        rl.prompt();
+      }
+    });
     return callback(null, [[], line]);
   },
 });
 
-// Live menu on keypress — draws below the prompt as user types
+// Trigger palette when user types exactly '/' and presses Tab or Enter isn't needed —
+// the completer above handles Tab. For bare '/' + Enter, handled in rl.on('line') below.
 emitKeypressEvents(process.stdin, rl);
-process.stdin.on('keypress', (_char, key) => {
-  if (key?.name === 'return' || key?.name === 'enter') {
-    _clearMenu(); // clear before readline processes the line
-    return;
-  }
-  setImmediate(() => {
-    const line = rl.line ?? '';
-    if (line.startsWith('/') && !pendingResolve) {
-      _drawMenu(line.slice(1));
-    } else {
-      _clearMenu();
-    }
-  });
-});
 
 printHeader();
 printInsights();
@@ -1253,19 +1287,21 @@ async function drainQueue() {
 }
 
 rl.on('line', async (input) => {
-  _clearMenu(); // always clear menu when a line is submitted
   const line = input.trim();
   if (!line) { rl.prompt(); return; }
 
-  // Bare `/` → show full command palette
-  if (line === '/') {
-    console.log('');
-    for (const m of SLASH_COMMANDS) {
-      console.log(`  ${fmt(C.cyan, m.cmd.padEnd(22))} ${fmt(C.dim, m.desc)}`);
+  // Bare `/` or partial `/cmd` with no session running → open interactive palette
+  if (line.startsWith('/') && !pendingResolve) {
+    const filter = line === '/' ? '' : line.slice(1);
+    const exact  = SLASH_COMMANDS.find(c => c.cmd === line);
+    if (!exact) {
+      // Clear the echoed input line before opening palette
+      process.stdout.write('\x1b[1A\r\x1b[2K');
+      const selected = await openPalette(filter);
+      if (selected) await executeInput(selected);
+      else rl.prompt();
+      return;
     }
-    console.log('');
-    rl.prompt();
-    return;
   }
 
   // If a session is already running, queue the message.

package/dist/daemon.mjs

@@ -2493,8 +2493,9 @@ var init_MemoryCapability = __esm({
     "use strict";
     init_src();
     MemoryCapability = class {
-      constructor(graph) {
+      constructor(graph, onWrite) {
         this.graph = graph;
+        this.onWrite = onWrite;
       }
       name = "memory_write";
       description = "Persist a discovered fact to long-term memory so it survives across sessions.";
@@ -2537,11 +2538,13 @@ var init_MemoryCapability = __esm({
             });
             this.graph.addNode(node);
           }
-          return {
+          const result = {
             success: true,
             output: `Remembered: "${label}" = ${content.slice(0, 120)}${content.length > 120 ? "\u2026" : ""}`,
             duration_ms: Date.now() - start
           };
+          this.onWrite?.();
+          return result;
         } catch (err) {
           return {
             success: false,
@@ -2651,7 +2654,7 @@ var init_CapabilityRegistry = __esm({
        * task_type: browser_task). The main agent does NOT have direct access
        * to browser_open without going through a subagent spawn.
        */
-      constructor(codespaceManager, graph) {
+      constructor(codespaceManager, graph, onMemoryWrite) {
         this.register(new WebSearchCapability());
         if (codespaceManager) {
           try {
@@ -2667,7 +2670,7 @@ var init_CapabilityRegistry = __esm({
         this.register(new ShellCapability());
         this.register(new FileCapability());
         if (graph) {
-          this.register(new MemoryCapability(graph));
+          this.register(new MemoryCapability(graph, onMemoryWrite));
         }
       }
       register(cap) {
@@ -2734,7 +2737,7 @@ var init_AgentExecutor = __esm({
         this.maxIterations = config.max_iterations ?? 20;
         this.maxCommandMs = config.max_command_ms ?? 3e4;
         this.agentRoot = config.agent_root;
-        this.registry = new CapabilityRegistry(void 0, config.graph);
+        this.registry = new CapabilityRegistry(void 0, config.graph, config.onMemoryWrite);
       }
       cwd;
       maxIterations;
@@ -4735,7 +4738,7 @@ var SessionManager = class {
       if (activeLLM?.isConfigured) {
         const executor = new AgentExecutor(
           activeLLM,
-          { cwd: this.cwd, agent_root: this.agentRoot, graph: this.graph },
+          { cwd: this.cwd, agent_root: this.agentRoot, graph: this.graph, onMemoryWrite: this.onMemoryWritten },
           // step callback → emit session.step events
           (step) => this.addStep(sessionId, step),
           // token callback → emit session.token events
@@ -4901,33 +4904,48 @@ Current task:`;
    */
   async _extractAndPersistFacts(task, output, llm) {
     if (!this.graph || !llm.isConfigured) return;
+    const combined = `${task} ${output}`;
+    if (combined.trim().length < 20) return;
     const prompt = `Extract factual entities from this conversation that should be remembered long-term.
-Return ONLY a JSON array, no other text, max 12 items.
+Return ONLY a valid JSON array (no markdown, no explanation), max 12 items.
+If nothing worth remembering, return [].
 
 Types: identity (name/role), project (apps/products), tech (stack/tools), preference, url, path, config, outcome
 
-Format: [{"label":"snake_case_key","content":"value to remember","type":"type"}]
+Format: [{"label":"snake_case_key","content":"value","type":"type"}]
 
 Examples:
-- User says "my name is Sahil" \u2192 {"label":"user_name","content":"Sahil","type":"identity"}
-- User says "we have a telegram bot" \u2192 {"label":"project_telegram_bot","content":"user has a Telegram bot project","type":"project"}
-- User says "I use React and Next.js" \u2192 {"label":"tech_stack","content":"React, Next.js","type":"tech"}
+- "my name is Sahil" \u2192 {"label":"user_name","content":"Sahil","type":"identity"}
+- "we have a telegram bot" \u2192 {"label":"project_telegram_bot","content":"user has a Telegram bot","type":"project"}
+- "I use React and Next.js" \u2192 {"label":"tech_stack","content":"React, Next.js","type":"tech"}
+- ngrok URL found \u2192 {"label":"ngrok_url","content":"https://abc.ngrok.io","type":"url"}
 
 Conversation:
 User: ${task.slice(0, 600)}
-Agent: ${output.slice(0, 400)}`;
+Agent: ${output.slice(0, 500)}`;
     try {
       const resp = await llm.complete(
         [{ role: "user", content: prompt }],
-        "You are a concise memory extraction system. Extract only factual, durable information. Skip generic statements."
+        "You are a memory extraction system. Be concise. Extract only factual, durable information. Return valid JSON only."
       );
-      const jsonMatch = resp.content.match(/\[[\s\S]*?\]/);
-      if (!jsonMatch) return;
-      const entities = JSON.parse(jsonMatch[0]);
+      let entities = [];
+      const raw = resp.content.trim();
+      try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) entities = parsed;
+      } catch {
+        const match = raw.match(/\[\s*\{[\s\S]*?\}\s*\]/);
+        if (match) {
+          try {
+            entities = JSON.parse(match[0]);
+          } catch {
+          }
+        }
+      }
       if (!Array.isArray(entities) || entities.length === 0) return;
       let wrote = 0;
       for (const e of entities.slice(0, 12)) {
-        if (!e.label?.trim() || !e.content?.trim()) continue;
+        if (!e?.label?.trim() || !e?.content?.trim()) continue;
         const nodeId = `memory:${e.label.toLowerCase().replace(/[^a-z0-9_]/g, "_")}`;
         try {
           const existing = this.graph.getNode(nodeId);
@@ -4946,14 +4964,16 @@ Agent: ${output.slice(0, 400)}`;
             }));
           }
           wrote++;
-        } catch {
+        } catch (err) {
+          console.warn(`[0agent] Memory write failed for "${e.label}":`, err instanceof Error ? err.message : err);
         }
       }
       if (wrote > 0) {
-        console.log(`[0agent] Memory: extracted ${wrote} facts from session`);
+        console.log(`[0agent] Memory: persisted ${wrote} facts \u2192 graph`);
         this.onMemoryWritten?.();
       }
-    } catch {
+    } catch (err) {
+      console.warn("[0agent] Memory extraction failed:", err instanceof Error ? err.message : String(err));
     }
   }
   /**
@@ -7303,20 +7323,24 @@ var ZeroAgentDaemon = class {
       adapter: this.adapter,
       agentRoot,
       // agent source path — self-improvement tasks read the right files
-      // Mark GitHub memory dirty immediately when facts are extracted — pushes within 2min
+      // Push to GitHub immediately when facts are extracted from a session
       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(() => {
+          });
+        }
       }
     });
     const teamSync = identity && teams.length > 0 ? new TeamSync(teamManager, this.adapter, identity.entity_node_id) : null;
     if (this.githubMemorySync) {
       const memSync = this.githubMemorySync;
       this.memorySyncTimer = setInterval(async () => {
-        if (memSync.hasPendingChanges()) {
-          const result = await memSync.push().catch(() => null);
-          if (result?.pushed) {
-            console.log(`[0agent] Memory auto-synced: ${result.nodes_synced} nodes`);
-          }
+        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`);
         }
       }, 2 * 60 * 1e3);
       if (typeof this.memorySyncTimer === "object") this.memorySyncTimer.unref?.();

package/package.json

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