0agent 1.0.43 → 1.0.44

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 } from 'node:readline';
+import { createInterface, emitKeypressEvents, moveCursor, clearLine as rlClearLine } from 'node:readline';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
@@ -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: '/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'                         },
   { cmd: '/status',        desc: 'Daemon health, graph stats, active sessions'     },
@@ -754,6 +755,33 @@ async function handleCommand(input) {
       break;
     }
 
+    // /telegram — configure Telegram bot token
+    case '/telegram': {
+      if (!cfg) { console.log(fmt(C.red, '  No config found. Run: 0agent init')); break; }
+      const existingToken = cfg?.telegram?.token;
+      if (existingToken) {
+        console.log(`\n  Telegram bot: ${fmt(C.green, '✓ configured')}`);
+        console.log(`  Token: ${existingToken.slice(0, 10)}••••`);
+        console.log(`  ${fmt(C.dim, 'To update: /telegram <new-token>\n')}`);
+      }
+      const token = parts[1];
+      if (!token) {
+        if (!existingToken) {
+          console.log('\n  Connect your Telegram bot to 0agent:\n');
+          console.log(`  1. Create a bot: ${fmt(C.cyan, 'https://t.me/BotFather')} → /newbot`);
+          console.log(`  2. Copy the token and run: ${fmt(C.cyan, '/telegram <token>')}`);
+          console.log(`  3. Restart daemon: ${fmt(C.dim, '0agent stop && 0agent start')}\n`);
+        }
+        break;
+      }
+      if (!cfg.telegram) cfg.telegram = {};
+      cfg.telegram.token = token;
+      saveConfig(cfg);
+      console.log(`  ${fmt(C.green, '✓')} Telegram token saved`);
+      console.log(`  ${fmt(C.dim, 'Restart daemon for changes to take effect: 0agent stop && 0agent start\n')}`);
+      break;
+    }
+
     case '/skills': {
       try {
         const skills = await fetch(`${BASE_URL}/api/skills`).then(r => r.json());
@@ -831,7 +859,7 @@ function _drawMenu(filter) {
   if (existingLines > 0) {
     moveCursor(process.stdout, 0, existingLines);
     for (let i = 0; i < existingLines; i++) {
-      clearLine(process.stdout, 0);
+      rlClearLine(process.stdout, 0);
       if (i < existingLines - 1) moveCursor(process.stdout, 0, -1);
     }
     moveCursor(process.stdout, 0, -(existingLines - 1));
@@ -859,7 +887,7 @@ function _clearMenu() {
   _menuLines = 0;
   moveCursor(process.stdout, 0, n);
   for (let i = 0; i < n; i++) {
-    clearLine(process.stdout, 0);
+    rlClearLine(process.stdout, 0);
     moveCursor(process.stdout, 0, -1);
   }
   moveCursor(process.stdout, 0, 1); // back to prompt line

package/dist/daemon.mjs

@@ -3027,13 +3027,19 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           `- Be concise in your final response: state what was done and where to find it`,
           ...hasMemory ? [
             ``,
-            `Memory (IMPORTANT):`,
-            `- ALWAYS call memory_write after discovering important facts:`,
-            `  \xB7 Live URLs (ngrok, deployed apps, APIs): memory_write({label:"ngrok_url", content:"https://...", type:"url"})`,
+            `Memory (CRITICAL \u2014 write EVERYTHING you learn):`,
+            `- Call memory_write for ANY fact you discover \u2014 conversational OR from tools:`,
+            `  \xB7 User's name/identity: memory_write({label:"user_name", content:"Sahil", type:"identity"})`,
+            `  \xB7 Projects they mention: memory_write({label:"project_telegram_bot", content:"user has a Telegram bot", type:"project"})`,
+            `  \xB7 Tech stack / tools: memory_write({label:"tech_stack", content:"Node.js, Telegram", type:"tech"})`,
+            `  \xB7 Preferences and decisions they express`,
+            `  \xB7 Live URLs (ngrok, deployed apps): memory_write({label:"ngrok_url", content:"https://...", type:"url"})`,
             `  \xB7 Server ports: memory_write({label:"dev_server_port", content:"3000", type:"config"})`,
             `  \xB7 File paths of created projects: memory_write({label:"project_path", content:"/path/to/project", type:"path"})`,
-            `  \xB7 Task outcomes: memory_write({label:"last_task_result", content:"...", type:"outcome"})`,
-            `- Call memory_write immediately when you find the value, not just at the end`
+            `  \xB7 Task outcomes: memory_write({label:"last_outcome", content:"...", type:"outcome"})`,
+            `- Write to memory FIRST when the user tells you something about themselves or their work`,
+            `- If the user says "my name is X" \u2192 memory_write immediately, before anything else`,
+            `- If they say "we have a Y" or "our Y" \u2192 memory_write it as a project fact`
           ] : []
         ];
         if (isSelfMod && this.agentRoot) {
@@ -4516,6 +4522,7 @@ var SessionManager = class {
   weightUpdater;
   anthropicFetcher = new AnthropicSkillFetcher();
   agentRoot;
+  onMemoryWritten;
   constructor(deps = {}) {
     this.inferenceEngine = deps.inferenceEngine;
     this.eventBus = deps.eventBus;
@@ -4525,6 +4532,7 @@ var SessionManager = class {
     this.identity = deps.identity;
     this.projectContext = deps.projectContext;
     this.agentRoot = deps.agentRoot;
+    this.onMemoryWritten = deps.onMemoryWritten;
     if (deps.adapter) {
       this.conversationStore = new ConversationStore(deps.adapter);
       this.conversationStore.init();
@@ -4816,6 +4824,8 @@ 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(() => {
+        });
         this.completeSession(sessionId, {
           output: agentResult.output,
           files_written: agentResult.files_written,
@@ -4884,6 +4894,68 @@ Current task:`;
     }
     return this.llm;
   }
+  /**
+   * After every session, run a lightweight LLM pass to extract factual entities
+   * (name, projects, tech, preferences, URLs) and persist them to the graph.
+   * This catches everything the agent didn't explicitly memory_write during execution.
+   */
+  async _extractAndPersistFacts(task, output, llm) {
+    if (!this.graph || !llm.isConfigured) 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.
+
+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"}]
+
+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"}
+
+Conversation:
+User: ${task.slice(0, 600)}
+Agent: ${output.slice(0, 400)}`;
+    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."
+      );
+      const jsonMatch = resp.content.match(/\[[\s\S]*?\]/);
+      if (!jsonMatch) return;
+      const entities = JSON.parse(jsonMatch[0]);
+      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;
+        const nodeId = `memory:${e.label.toLowerCase().replace(/[^a-z0-9_]/g, "_")}`;
+        try {
+          const existing = this.graph.getNode(nodeId);
+          if (existing) {
+            this.graph.updateNode(nodeId, {
+              label: e.label,
+              metadata: { ...existing.metadata, content: e.content, type: e.type ?? "note", updated_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          } else {
+            this.graph.addNode(createNode({
+              id: nodeId,
+              graph_id: "root",
+              label: e.label,
+              type: "context" /* CONTEXT */,
+              metadata: { content: e.content, type: e.type ?? "note", saved_at: (/* @__PURE__ */ new Date()).toISOString() }
+            }));
+          }
+          wrote++;
+        } catch {
+        }
+      }
+      if (wrote > 0) {
+        console.log(`[0agent] Memory: extracted ${wrote} facts from session`);
+        this.onMemoryWritten?.();
+      }
+    } catch {
+    }
+  }
   /**
    * Convert a task result into a weight signal for the knowledge graph.
    *
@@ -6930,6 +7002,192 @@ var CodespaceManager = class {
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_RuntimeSelfHeal();
+
+// packages/daemon/src/TelegramBridge.ts
+var TelegramBridge = class {
+  constructor(config, sessions, eventBus) {
+    this.config = config;
+    this.sessions = sessions;
+    this.eventBus = eventBus;
+    this.token = config.token;
+    this.allowedUsers = new Set(config.allowed_users ?? []);
+  }
+  token;
+  allowedUsers;
+  offset = 0;
+  pollTimer = null;
+  running = false;
+  // session_id per chat for streaming
+  pendingSessions = /* @__PURE__ */ new Map();
+  start() {
+    if (this.running) return;
+    this.running = true;
+    console.log("[0agent] Telegram: bot polling started");
+    this._poll();
+    this.eventBus.onEvent((event) => {
+      const chatId = this._getChatIdForSession(String(event.session_id ?? ""));
+      if (!chatId) return;
+      if (event.type === "session.completed") {
+        const result = event.result;
+        const output = String(result?.output ?? "").trim();
+        if (output && output !== "(no output)") {
+          this._send(chatId, output).catch(() => {
+          });
+        }
+        this.pendingSessions.delete(chatId);
+      } else if (event.type === "session.failed") {
+        const err = String(event.error ?? "Task failed");
+        this._send(chatId, `\u26A0\uFE0F ${err}`).catch(() => {
+        });
+        this.pendingSessions.delete(chatId);
+      }
+    });
+  }
+  stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  _getChatIdForSession(sessionId) {
+    for (const [chatId, sid] of this.pendingSessions) {
+      if (sid === sessionId) return chatId;
+    }
+    return null;
+  }
+  async _poll() {
+    if (!this.running) return;
+    try {
+      const updates = await this._getUpdates();
+      for (const u of updates) {
+        await this._handleUpdate(u);
+      }
+    } catch {
+    }
+    if (this.running) {
+      this.pollTimer = setTimeout(() => this._poll(), 1e3);
+    }
+  }
+  async _getUpdates() {
+    const res = await fetch(
+      `https://api.telegram.org/bot${this.token}/getUpdates?offset=${this.offset}&timeout=10&limit=20`,
+      { signal: AbortSignal.timeout(15e3) }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (!data.ok || !data.result.length) return [];
+    this.offset = data.result[data.result.length - 1].update_id + 1;
+    return data.result;
+  }
+  async _handleUpdate(u) {
+    const msg = u.message;
+    if (!msg?.text || !msg.from) return;
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+    const text = msg.text.trim();
+    const userName = msg.from.first_name ?? msg.from.username ?? "User";
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(userId)) {
+      await this._send(chatId, "\u26D4 You are not authorised to use this agent.");
+      return;
+    }
+    if (text === "/start" || text === "/help") {
+      await this._send(
+        chatId,
+        `\u{1F44B} Hi ${userName}! I'm 0agent \u2014 your AI that runs on your machine.
+
+Send me any task and I'll get it done:
+\u2022 "make a website for my coffee shop"
+\u2022 "research my competitor's pricing"
+\u2022 "fix the bug in auth.ts"
+
+I remember everything across sessions.`
+      );
+      return;
+    }
+    if (text === "/status") {
+      try {
+        const r = await fetch("http://localhost:4200/api/health", { signal: AbortSignal.timeout(2e3) });
+        const h = await r.json();
+        await this._send(
+          chatId,
+          `\u2705 Daemon running
+Graph: ${h.graph_nodes} nodes \xB7 ${h.graph_edges} edges
+Sessions: ${h.active_sessions} active`
+        );
+      } catch {
+        await this._send(chatId, "\u26A0\uFE0F Daemon not reachable");
+      }
+      return;
+    }
+    await this._sendAction(chatId, "typing");
+    await this._send(chatId, `\u23F3 Working on it\u2026`);
+    try {
+      const res = await fetch("http://localhost:4200/api/sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          task: text,
+          context: { system_context: `User's name: ${userName}. Message from Telegram.` }
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      const session = await res.json();
+      const sessionId = session.session_id ?? session.id;
+      if (sessionId) {
+        this.pendingSessions.set(chatId, sessionId);
+      } else {
+        await this._send(chatId, "\u26A0\uFE0F Could not start session");
+      }
+    } catch (e) {
+      await this._send(chatId, `\u26A0\uFE0F Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  async _send(chatId, text) {
+    const chunks = this._splitMessage(text);
+    for (const chunk of chunks) {
+      await fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId, text: chunk, parse_mode: "Markdown" }),
+        signal: AbortSignal.timeout(1e4)
+      }).catch(() => {
+        return fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: chatId, text: chunk }),
+          signal: AbortSignal.timeout(1e4)
+        }).catch(() => {
+        });
+      });
+    }
+  }
+  async _sendAction(chatId, action) {
+    await fetch(`https://api.telegram.org/bot${this.token}/sendChatAction`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, action }),
+      signal: AbortSignal.timeout(5e3)
+    }).catch(() => {
+    });
+  }
+  _splitMessage(text) {
+    if (text.length <= 4e3) return [text];
+    const chunks = [];
+    let i = 0;
+    while (i < text.length) {
+      chunks.push(text.slice(i, i + 4e3));
+      i += 4e3;
+    }
+    return chunks;
+  }
+  static isConfigured(config) {
+    const c = config;
+    return !!(c?.token && typeof c.token === "string" && c.token.length > 10);
+  }
+};
+
+// packages/daemon/src/ZeroAgentDaemon.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { dirname as dirname6 } from "node:path";
 var ZeroAgentDaemon = class {
@@ -6949,6 +7207,7 @@ var ZeroAgentDaemon = class {
   codespaceManager = null;
   schedulerManager = null;
   runtimeHealer = null;
+  telegramBridge = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
@@ -7042,8 +7301,12 @@ var ZeroAgentDaemon = class {
       identity: identity ?? void 0,
       projectContext: projectContext ?? void 0,
       adapter: this.adapter,
-      agentRoot
+      agentRoot,
       // agent source path — self-improvement tasks read the right files
+      // Mark GitHub memory dirty immediately when facts are extracted — pushes within 2min
+      onMemoryWritten: () => {
+        this.githubMemorySync?.markDirty();
+      }
     });
     const teamSync = identity && teams.length > 0 ? new TeamSync(teamManager, this.adapter, identity.entity_node_id) : null;
     if (this.githubMemorySync) {
@@ -7055,7 +7318,7 @@ var ZeroAgentDaemon = class {
             console.log(`[0agent] Memory auto-synced: ${result.nodes_synced} nodes`);
           }
         }
-      }, 30 * 60 * 1e3);
+      }, 2 * 60 * 1e3);
       if (typeof this.memorySyncTimer === "object") this.memorySyncTimer.unref?.();
     }
     let proactiveSurface = null;
@@ -7085,6 +7348,11 @@ var ZeroAgentDaemon = class {
     }
     this.schedulerManager = new SchedulerManager(this.adapter, this.sessionManager, this.eventBus);
     this.schedulerManager.start();
+    const tgCfg = this.config["telegram"];
+    if (TelegramBridge.isConfigured(tgCfg) && this.sessionManager && this.eventBus) {
+      this.telegramBridge = new TelegramBridge(tgCfg, this.sessionManager, this.eventBus);
+      this.telegramBridge.start();
+    }
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
       traceStore: this.traceStore,
@@ -7156,6 +7424,8 @@ var ZeroAgentDaemon = class {
       this.memorySyncTimer = null;
     }
     this.githubMemorySync = null;
+    this.telegramBridge?.stop();
+    this.telegramBridge = null;
     this.schedulerManager?.stop();
     this.schedulerManager = null;
     this.codespaceManager?.closeTunnel();

package/package.json

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