0agent 1.0.38 → 1.0.40

package/bin/chat.js

@@ -23,33 +23,64 @@ class Spinner {
     this._msg = msg;
     this._frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
     this._i = 0; this._timer = null; this._active = false;
+    this._sessionMode = false; // true during agent sessions — no \r animation
   }
+
+  // Animated spinner — safe only at startup when user cannot type yet.
+  // Uses \r which conflicts with readline when user is typing.
   start(msg) {
     if (this._active) return;
     if (msg) this._msg = msg;
     this._active = true;
+    this._sessionMode = false;
     this._timer = setInterval(() => {
       process.stdout.write(`\r  \x1b[36m${this._frames[this._i++ % this._frames.length]}\x1b[0m \x1b[2m${this._msg}\x1b[0m  `);
     }, 80);
   }
+
+  // Session mode — prints a one-time static status line, NO \r animation.
+  // readline owns the cursor; call rl.prompt(true) after this to show › .
+  startSession(msg) {
+    if (this._active) return;
+    if (msg) this._msg = msg;
+    this._active = true;
+    this._sessionMode = true;
+    process.stdout.write(`  \x1b[2m⠋ ${this._msg}...\x1b[0m\n`);
+  }
+
   update(msg) { this._msg = msg; }
+
   stop(clearIt = true) {
     if (!this._active) return;
-    clearInterval(this._timer); this._timer = null; this._active = false;
-    if (clearIt) process.stdout.write('\r\x1b[2K');
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+    const wasSession = this._sessionMode;
+    this._active = false;
+    this._sessionMode = false;
+    // Only clear the \r-based animation line; session mode output flows naturally
+    if (clearIt && !wasSession) {
+      process.stdout.write('\r\x1b[2K');
+    }
   }
+
   get active() { return this._active; }
 
-  /**
-   * Pause spinner, run fn() (which may print lines), then resume.
-   * Prevents spinner from overwriting printed content.
-   */
+  // Pause to print something cleanly, then resume.
   pauseFor(fn) {
-    const wasActive = this._active;
-    const savedMsg  = this._msg;
-    if (wasActive) this.stop(true);
+    const wasActive  = this._active;
+    const wasSession = this._sessionMode;
+    const savedMsg   = this._msg;
+    this.stop(!wasSession); // clear animated spinner; session mode: just deactivate
     fn();
-    if (wasActive) this.start(savedMsg);
+    if (wasActive) {
+      if (wasSession) {
+        // Re-mark active without printing again — readline is showing the prompt
+        this._active = true;
+        this._sessionMode = true;
+        this._msg = savedMsg;
+      } else {
+        this.start(savedMsg);
+      }
+    }
   }
 }
 
@@ -192,13 +223,20 @@ function handleWsEvent(event) {
     case 'session.step': {
       spinner.stop();
       if (streaming) { process.stdout.write('\n'); streaming = false; }
+      // Clear current readline line, print step, then restore › prompt
+      process.stdout.write('\r\x1b[2K');
       console.log(`  ${fmt(C.dim, '›')} ${event.step}`);
-      spinner.start(event.step.slice(0, 50));  // resume with current step label
+      spinner.startSession(event.step.slice(0, 50));
+      rl.prompt(true); // restore › so user can keep typing
       break;
     }
     case 'session.token': {
       spinner.stop();
-      if (!streaming) { process.stdout.write('\n  '); streaming = true; }
+      if (!streaming) {
+        // Clear › prompt line before streaming response
+        process.stdout.write('\r\x1b[2K\n  ');
+        streaming = true;
+      }
       process.stdout.write(event.token);
       lineBuffer += event.token;
       break;
@@ -383,9 +421,10 @@ async function runTask(input) {
     });
     const s = await res.json();
     sessionId = s.session_id ?? s.id;
-    // Show affordance so user knows they can queue messages while agent works
-    process.stdout.write(`\n  \x1b[2m(type and press Enter to queue next message)\x1b[0m\n`);
-    spinner.start('Thinking');
+    // Start session-mode status (no \r animation) then restore › so user can type
+    process.stdout.write('\n');
+    spinner.startSession('Thinking');
+    rl.prompt(true); // keep › visible — user can queue next message while agent works
 
     // Polling fallback — runs concurrently with WS events.
     // Catches completion when WS is disconnected (e.g. daemon just restarted).
@@ -416,8 +455,10 @@ async function runTask(input) {
         const steps = session.steps ?? [];
         for (let j = lastPolledStep; j < steps.length; j++) {
           spinner.stop();
+          process.stdout.write('\r\x1b[2K');
           console.log(`  \x1b[2m›\x1b[0m ${steps[j].description}`);
-          spinner.start(steps[j].description.slice(0, 50));
+          spinner.startSession(steps[j].description.slice(0, 50));
+          rl.prompt(true);
         }
         lastPolledStep = steps.length;
 
@@ -968,14 +1009,16 @@ rl.on('line', async (input) => {
   if (pendingResolve) {
     messageQueue.push(line);
     const qLen = messageQueue.length;
-    spinner.pauseFor(() => {
-      process.stdout.write(
-        `  ${fmt(C.magenta, '↳')} ${fmt(C.bold, `[queued #${qLen}]`)} ${fmt(C.dim, line.slice(0, 70))}\n`
-      );
-      if (qLen > 1) {
-        process.stdout.write(`  ${fmt(C.dim, `${qLen} tasks waiting`)}\n`);
-      }
-    });
+    // No spinner.pauseFor() needed — session mode has no \r animation
+    // Just print the queued confirmation and restore the › prompt
+    process.stdout.write('\r\x1b[2K');
+    process.stdout.write(
+      `  ${fmt(C.magenta, '↳')} ${fmt(C.bold, `[queued #${qLen}]`)} ${fmt(C.dim, line.slice(0, 70))}\n`
+    );
+    if (qLen > 1) {
+      process.stdout.write(`  ${fmt(C.dim, `${qLen} tasks waiting`)}\n`);
+    }
+    rl.prompt(true); // keep › visible
     return;
   }
 

package/dist/daemon.mjs

@@ -2406,14 +2406,14 @@ var init_FileCapability = __esm({
     "use strict";
     FileCapability = class {
       name = "file_op";
-      description = "Read, write, or list files. Scoped to working directory.";
+      description = "Read, write, list files, or create directories. Scoped to working directory.";
       toolDefinition = {
         name: "file_op",
-        description: "Read, write, or list files in the working directory.",
+        description: "Read, write, list files, or create directories in the working directory.",
         input_schema: {
           type: "object",
           properties: {
-            op: { type: "string", description: '"read", "write", or "list"' },
+            op: { type: "string", description: '"read", "write", "list", or "mkdir"' },
             path: { type: "string", description: "File or directory path (relative to cwd)" },
             content: { type: "string", description: "Content for write operation" }
           },
@@ -2448,7 +2448,11 @@ var init_FileCapability = __esm({
             const entries = readdirSync(safe, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => `${e.isDirectory() ? "d" : "f"}  ${e.name}`).join("\n");
             return { success: true, output: entries || "(empty)", duration_ms: Date.now() - start };
           }
-          return { success: false, output: `Unknown op: ${op}`, duration_ms: Date.now() - start };
+          if (op === "mkdir") {
+            mkdirSync(safe, { recursive: true });
+            return { success: true, output: `Directory created: ${rel}`, duration_ms: Date.now() - start };
+          }
+          return { success: false, output: `Unknown op: ${op}. Use "read", "write", "list", or "mkdir"`, duration_ms: Date.now() - start };
         } catch (err) {
           return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, duration_ms: Date.now() - start };
         }
@@ -2457,6 +2461,74 @@ var init_FileCapability = __esm({
   }
 });
 
+// packages/daemon/src/capabilities/MemoryCapability.ts
+var MemoryCapability;
+var init_MemoryCapability = __esm({
+  "packages/daemon/src/capabilities/MemoryCapability.ts"() {
+    "use strict";
+    init_src();
+    MemoryCapability = class {
+      constructor(graph) {
+        this.graph = graph;
+      }
+      name = "memory_write";
+      description = "Persist a discovered fact to long-term memory so it survives across sessions.";
+      toolDefinition = {
+        name: "memory_write",
+        description: 'Write an important fact to long-term memory. Call this whenever you discover something worth remembering: URLs (ngrok, live servers), file paths, port numbers, API endpoints, configuration values, decisions made, or task outcomes. Examples: memory_write({label:"ngrok_url", content:"https://abc.ngrok.io", type:"url"}) or memory_write({label:"project_port", content:"3000", type:"config"})',
+        input_schema: {
+          type: "object",
+          properties: {
+            label: { type: "string", description: 'Short name for this fact (e.g. "ngrok_url", "project_port")' },
+            content: { type: "string", description: "The value to remember" },
+            type: { type: "string", description: 'Category: "url", "path", "config", "note", "outcome"' }
+          },
+          required: ["label", "content"]
+        }
+      };
+      async execute(input, _cwd) {
+        const label = String(input.label ?? "").trim();
+        const content = String(input.content ?? "").trim();
+        const type = String(input.type ?? "note").trim();
+        const start = Date.now();
+        if (!label || !content) {
+          return { success: false, output: "label and content are required", duration_ms: 0 };
+        }
+        try {
+          const nodeId = `memory:${label.toLowerCase().replace(/[^a-z0-9_]/g, "_")}`;
+          const existing = this.graph.getNode(nodeId);
+          if (existing) {
+            this.graph.updateNode(nodeId, {
+              label,
+              metadata: { ...existing.metadata, content, type, updated_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          } else {
+            const node = createNode({
+              id: nodeId,
+              graph_id: "root",
+              label,
+              type: "context" /* CONTEXT */,
+              metadata: { content, type, saved_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+            this.graph.addNode(node);
+          }
+          return {
+            success: true,
+            output: `Remembered: "${label}" = ${content.slice(0, 120)}${content.length > 120 ? "\u2026" : ""}`,
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          return {
+            success: false,
+            output: `Memory write failed: ${err instanceof Error ? err.message : String(err)}`,
+            duration_ms: Date.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
 var CodespaceBrowserCapability_exports = {};
 __export(CodespaceBrowserCapability_exports, {
@@ -2541,6 +2613,7 @@ var init_CapabilityRegistry = __esm({
     init_ScraperCapability();
     init_ShellCapability();
     init_FileCapability();
+    init_MemoryCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
       /**
@@ -2553,7 +2626,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) {
+      constructor(codespaceManager, graph) {
         this.register(new WebSearchCapability());
         if (codespaceManager) {
           try {
@@ -2568,6 +2641,9 @@ var init_CapabilityRegistry = __esm({
         this.register(new ScraperCapability());
         this.register(new ShellCapability());
         this.register(new FileCapability());
+        if (graph) {
+          this.register(new MemoryCapability(graph));
+        }
       }
       register(cap) {
         this.capabilities.set(cap.name, cap);
@@ -2633,7 +2709,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();
+        this.registry = new CapabilityRegistry(void 0, config.graph);
       }
       cwd;
       maxIterations;
@@ -2658,23 +2734,39 @@ var init_AgentExecutor = __esm({
         for (let i = 0; i < this.maxIterations; i++) {
           this.onStep(i === 0 ? "Thinking\u2026" : "Continuing\u2026");
           let response;
-          try {
-            response = await this.llm.completeWithTools(
-              messages,
-              this.registry.getToolDefinitions(),
-              systemPrompt,
-              // Only stream tokens on the final (non-tool) turn
-              (token) => {
-                this.onToken(token);
-                finalOutput += token;
+          let llmFailed = false;
+          {
+            let llmRetry = 0;
+            while (true) {
+              try {
+                response = await this.llm.completeWithTools(
+                  messages,
+                  this.registry.getToolDefinitions(),
+                  systemPrompt,
+                  // Only stream tokens on the final (non-tool) turn
+                  (token) => {
+                    this.onToken(token);
+                    finalOutput += token;
+                  }
+                );
+                break;
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const isTimeout = /timeout|AbortError|aborted/i.test(msg);
+                if (isTimeout && llmRetry < 2) {
+                  llmRetry++;
+                  this.onStep(`LLM timeout \u2014 retrying (${llmRetry}/2)\u2026`);
+                  await new Promise((r) => setTimeout(r, 2e3 * llmRetry));
+                  continue;
+                }
+                this.onStep(`LLM error: ${msg}`);
+                finalOutput = `Error: ${msg}`;
+                llmFailed = true;
+                break;
               }
-            );
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.onStep(`LLM error: ${msg}`);
-            finalOutput = `Error: ${msg}`;
-            break;
+            }
           }
+          if (llmFailed) break;
           totalTokens += response.tokens_used;
           modelName = response.model;
           if (response.stop_reason === "end_turn" || !response.tool_calls?.length) {
@@ -2889,6 +2981,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       }
       buildSystemPrompt(extra, task) {
         const isSelfMod = !!(task && SELF_MOD_PATTERN.test(task));
+        const hasMemory = !!this.config.graph;
         const lines = [
           `You are 0agent, an AI software engineer. You can execute shell commands and manage files.`,
           `Working directory: ${this.cwd}`,
@@ -2899,12 +2992,24 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           `  cmd > /tmp/0agent-server.log 2>&1 &`,
           `  Example: python3 -m http.server 3000 > /tmp/0agent-server.log 2>&1 &`,
           `  NEVER run background commands without redirecting output.`,
-          `- For npm/node projects: check package.json first with read_file or list_dir`,
-          `- After write_file, verify with read_file if needed`,
+          `- To create a folder: use file_op with op="mkdir" and path="folder/name"`,
+          `- To create a file (and its parent folders): use file_op with op="write" \u2014 parent dirs are created automatically`,
+          `- For npm/node projects: check package.json first with file_op op="list"`,
+          `- After writing files, verify with file_op op="read" if needed`,
           `- After shell_exec, check output for errors and retry if needed`,
           `- For research tasks: use web_search first, then scrape_url for full page content`,
           `- Use relative paths from the working directory`,
-          `- Be concise in your final response: state what was done and where to find it`
+          `- 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"})`,
+            `  \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`
+          ] : []
         ];
         if (isSelfMod && this.agentRoot) {
           lines.push(
@@ -4597,7 +4702,7 @@ var SessionManager = class {
       if (activeLLM?.isConfigured) {
         const executor = new AgentExecutor(
           activeLLM,
-          { cwd: this.cwd, agent_root: this.agentRoot },
+          { cwd: this.cwd, agent_root: this.agentRoot, graph: this.graph },
           // step callback → emit session.step events
           (step) => this.addStep(sessionId, step),
           // token callback → emit session.token events

package/package.json

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