agent-from-zero 0.28.0 → 0.29.0

package/dist/agent.js

@@ -20,9 +20,10 @@ import { renderDiff } from "./diff.js"; // show what /undo put back / what /diff
 import path from "node:path"; // shorten paths for the /diff summary
 import { expandMentions } from "./mentions.js"; // @file mentions: pull referenced files into context (secret files refused)
 import { banner, framedPrompt, formatModelChoices, statusLine, inputRule } from "./ui.js"; // welcome box, prompt, model labels, status line
-import { gitBranch, toggleLastCollapsed, cleanup as tuiCleanup } from "./tui.js"; // git branch for the status line + collapsible output
+import { gitBranch, toggleLastCollapsed, revealReasoning, clearReasoning, cleanup as tuiCleanup } from "./tui.js"; // git branch for the status line + collapsible output + collapsed reasoning (Ctrl+R)
 import { promptSelect, promptForm } from "./menu.js"; // arrow-key approval menu + multi-question form
 import { editLine } from "./editor.js"; // our own line editor (keeps the status footer pinned even when input wraps)
+import { normalizeDroppedPaths } from "./drop.js"; // drag-and-drop: a dropped file's path → a clean absolute path in the input
 import { rememberTool, readMemory, readMemoryTyped, extractMemories, MEMORY_PATH } from "./memory.js"; // long-term project memory + auto-extract
 import { loadSkills, buildSkillTool, findSkill, skillInstructions } from "./skills.js"; // Markdown-as-plugin skills
 import { initCostMeter, DEFAULT_PRICING } from "./cost.js"; // token & cost accounting for /cost
@@ -78,7 +79,11 @@ const SESSION_HELP = `commands:
   /resume    list recent sessions in this project and continue one of them
   /skills    list the reusable skills available in this project
   /skill <name>  run a skill yourself (works even for user-only skills)
-  exit       leave (Ctrl+C at the prompt does the same)`;
+  exit       leave (Ctrl+C at the prompt does the same)
+
+keys (at the prompt):
+  Ctrl+R     reveal the model's thinking for the last answer (collapsed behind a spinner by default)
+  Tab        expand/collapse the most recent tool output`;
 // Injected when the user turns plan mode on, so the model knows the rules of the
 // mode it now lives in (the permission gate enforces them regardless).
 const PLAN_MODE_NOTICE = `[plan mode ON] Investigate this request using only read-only tools — read_file, search, and safe read-only shell (ls, cat, git status). Do NOT write files, edit, or run mutating commands; the permission gate will block them. When you have a concrete, ordered plan, call the exit_plan_mode tool with that plan. The user reviews and approves it before you make any change.`;
@@ -253,7 +258,7 @@ async function main() {
             // so the status bar stays pinned below however the line wraps.
             editing = true;
             try {
-                const res = await editLine(rl, { prompt, footer, history, onTab: () => toggleLastCollapsed() });
+                const res = await editLine(rl, { prompt, footer, history, onTab: () => toggleLastCollapsed(), onReveal: () => revealReasoning(), transformPaste: normalizeDroppedPaths });
                 if (res.type === "line") {
                     if (res.value.trim())
                         history.push(res.value); // remember non-empty entries for ↑/↓
@@ -437,6 +442,7 @@ async function main() {
                 clearTodos(); // the plan belonged to the old task — drop it
                 resetTeam(); // the team belonged to the old task — forget it (mailboxes re-wipe on next use)
                 resetBoard(); // and the shared task board (Day 40)
+                clearReasoning(); // drop the collapsed thinking too
                 sessionId = newSessionId(); // a fresh conversation is a fresh session file
                 console.log(chalk.dim("(history cleared)")); // confirm the reset
                 return true;
@@ -670,6 +676,7 @@ async function main() {
         if (refused.length)
             console.log(chalk.yellow(`(refused secret file${refused.length === 1 ? "" : "s"}: ${refused.join(", ")})`));
         messages.push({ role: "user", content: augmented + injected }); // the new turn (with any attached files + hook context) joins the shared history
+        clearReasoning(); // Ctrl+R should reveal THIS turn's thinking, not the previous answer's
         running = true; // Ctrl+C now means "interrupt the task"
         interrupted = false; // fresh interrupt state for this task
         controller = new AbortController(); // fresh abort signal for this task

package/dist/drop.js

@@ -0,0 +1,104 @@
+// Drag-and-drop a file onto the terminal and it pastes the file's path into the
+// input — but as a SHELL token: backslash-escaped spaces (/Users/me/my\ file.txt)
+// or wrapped in quotes, and usually with a trailing space. That's noisy to read
+// and clumsy to hand to the agent. This turns a dropped path (or several) into
+// clean ABSOLUTE paths, so the user never types a long path by hand.
+//
+// It is deliberately conservative: it only rewrites text that is, after
+// unescaping, one or more EXISTING ABSOLUTE paths (that's exactly what a terminal
+// drag produces). Anything else — ordinary pasted prose, a relative snippet — is
+// returned untouched, so this can run on every paste without surprising anyone.
+import fs from "node:fs"; // confirm the tokens are real paths (the drag signal)
+import os from "node:os"; // expand a leading ~
+import path from "node:path"; // resolve + normalize to absolute
+// Terminals with "bracketed paste" wrap the text in these markers; strip them so
+// a drop still parses if the mode happens to be on.
+const BRACKET_PASTE = /\x1b\[20[01]~/g;
+// Split a dropped string into path tokens, honoring the escaping a terminal adds:
+// backslash escapes (\<space>, \( …) and single/double quotes. Whitespace OUTSIDE
+// a quote/escape separates tokens (so several dropped files become several paths).
+function splitTokens(raw) {
+    const s = raw.replace(BRACKET_PASTE, "").trim();
+    const tokens = [];
+    let cur = "";
+    let started = false; // did the current token get any character? (distinguishes "" from absent)
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            cur += s[i + 1];
+            i += 2;
+            started = true;
+            continue;
+        } // \x → literal x
+        if (c === "'") { // single quotes: everything literal until the next '
+            i++;
+            while (i < s.length && s[i] !== "'")
+                cur += s[i++];
+            i++;
+            started = true;
+            continue;
+        }
+        if (c === '"') { // double quotes: backslash still escapes inside
+            i++;
+            while (i < s.length && s[i] !== '"') {
+                if (s[i] === "\\" && i + 1 < s.length) {
+                    cur += s[i + 1];
+                    i += 2;
+                }
+                else
+                    cur += s[i++];
+            }
+            i++;
+            started = true;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") { // a separator between tokens
+            if (started) {
+                tokens.push(cur);
+                cur = "";
+                started = false;
+            }
+            i++;
+            continue;
+        }
+        cur += c;
+        i++;
+        started = true;
+    }
+    if (started)
+        tokens.push(cur);
+    return tokens;
+}
+// A drop produces ABSOLUTE paths (macOS/Linux terminals). Treat a leading ~ as
+// home. Anything not absolute-ish is not a drop — we leave it alone.
+const looksAbsolute = (t) => t.startsWith("/") || t === "~" || t.startsWith("~/");
+const expandTilde = (t) => (t === "~" || t.startsWith("~/") ? os.homedir() + t.slice(1) : t);
+// Quote a path that contains whitespace so several dropped paths stay separable
+// (and the whole thing survives being read as shell-ish tokens later). Prefer
+// single quotes; fall back to double if the path itself contains a single quote.
+function quoteIfNeeded(p) {
+    if (!/\s/.test(p))
+        return p;
+    return p.includes("'") ? `"${p}"` : `'${p}'`;
+}
+// The entry point: given a pasted string, return clean absolute path(s) if it is
+// a drop, otherwise the original text unchanged. A successful normalization ends
+// with a single trailing space, so the cursor lands ready to type the question.
+export function normalizeDroppedPaths(raw) {
+    if (!raw)
+        return raw;
+    const tokens = splitTokens(raw);
+    if (!tokens.length)
+        return raw;
+    const abs = [];
+    for (const t of tokens) {
+        if (!looksAbsolute(t))
+            return raw; // not a dragged absolute path → leave the paste as-is
+        const resolved = path.resolve(expandTilde(t)); // normalize (//, .., trailing /) → canonical absolute
+        if (!fs.existsSync(resolved))
+            return raw; // a path that doesn't exist isn't a real drop
+        abs.push(resolved);
+    }
+    return abs.map(quoteIfNeeded).join(" ") + " ";
+}

package/dist/editor.js

@@ -26,6 +26,8 @@ export function reduceEditor(s, str, key) {
                 return { state: { buffer, cursor: Math.max(0, cursor - 1) }, action: "edit" }; // back one char
             case "f":
                 return { state: { buffer, cursor: Math.min(buffer.length, cursor + 1) }, action: "edit" }; // forward one char
+            case "r":
+                return { state: s, action: "reveal" }; // Ctrl+R → reveal the model's collapsed thinking
             default:
                 return { state: s, action: "none" };
         }
@@ -254,6 +256,12 @@ export function editLine(rl, opts) {
         const onKey = (str, key) => {
             if (done)
                 return;
+            // A drag-and-drop (or any paste) arrives as one multi-char string. Give the
+            // caller a chance to rewrite it — e.g. turn dropped file paths into clean
+            // absolute paths — before it lands in the buffer. No-op for normal text.
+            if (str && str.length > 1 && !key?.ctrl && !key?.meta && opts.transformPaste) {
+                str = opts.transformPaste(str);
+            }
             const next = reduceEditor(state, str, key || {});
             state = next.state;
             switch (next.action) {
@@ -282,6 +290,10 @@ export function editLine(rl, opts) {
                     opts.onTab?.(); // may print above us (e.g. expand a collapsed block) and scroll
                     first = true; // so the next paint lands fresh at the cursor, not a stale climb-up
                     return draw();
+                case "reveal":
+                    opts.onReveal?.(); // print the model's collapsed thinking above us, then repaint
+                    first = true; // the next paint lands fresh, not a stale climb-up
+                    return draw();
                 case "edit":
                     return draw();
                 case "none":

package/dist/loop.js

@@ -12,7 +12,7 @@ import { emit } from "./telemetry.js"; // local-only event log (no-op unless the
 import { runHooks } from "./hooks.js"; // user lifecycle hooks (PreToolUse / PostToolUse / Stop)
 import { recordUsage } from "./cost.js"; // meter token usage from the stream
 import { mark, thinkingWord, spinnerText } from "./ui.js"; // centralized terminal styling (markers, spinner)
-import { printToolSummary } from "./tui.js"; // collapsible tool output
+import { printToolSummary, recordReasoning } from "./tui.js"; // collapsible tool output + the model's hidden thinking (Ctrl+R)
 import { MarkdownStream } from "./markdown.js"; // render the streamed answer as terminal markdown
 import { todoNag, getTodos, renderTodos } from "./todos.js"; // the agent's plan: show it on screen + nag when it goes stale
 import { pendingNotifications } from "./background.js"; // background tasks (Day 37): surface finished jobs as a turn
@@ -328,6 +328,11 @@ opts) {
     const word = thinkingWord(modelCallSeq++); // a rotating "thinking" word for this call
     const startedAt = Date.now(); // for the spinner's live elapsed counter
     let streamedChars = 0; // bytes of content+reasoning streamed this call → a live token estimate
+    // Reasoning is COLLAPSED by default: while the model thinks, the spinner keeps
+    // spinning (with a 💭 hint) instead of dumping the trace; we stash it for Ctrl+R.
+    let reasoningBuf = ""; // the accumulated thinking, hidden behind the spinner
+    let reasoningActive = false; // true while reasoning tokens are arriving → spinner shows 💭
+    let reasoningShown = false; // have we printed the "thought for Ns" indicator yet?
     const spinner = opts.quiet
         ? null // the eval harness wants silence
         : ora({ text: spinnerText(word, 0, !!opts.subAgent, opts.model), discardStdin: false }).start(); // discardStdin:false — ora would otherwise eat Ctrl+C
@@ -338,8 +343,10 @@ opts) {
     // - stall (slow but alive for 30s) → log it and keep waiting
     // It also ticks the spinner: elapsed seconds + a live token estimate (~chars/4).
     const watchdog = setInterval(() => {
+        // While the model is reasoning, prefix the spinner with 💭 so "it's thinking"
+        // reads differently from "it's waiting on the first token".
         if (spinner?.isSpinning)
-            spinner.text = spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, opts.model, Math.round(streamedChars / 4));
+            spinner.text = (reasoningActive ? chalk.dim("💭 ") : "") + spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, opts.model, Math.round(streamedChars / 4));
         const quietMs = Date.now() - lastEvent; // ms since the last event
         if (quietMs > IDLE_TIMEOUT_MS) {
             emit("agent_watchdog_idle"); // record the cut — these should be rare
@@ -364,9 +371,27 @@ opts) {
         { model: opts.model, messages, tools: toolsFor(opts), stream: true, stream_options: { include_usage: true } }, { signal });
         let content = ""; // accumulated answer text
         let printedPrefix = false; // have we printed the answer prefix yet?
-        let printedThinking = false; // have we started printing the reasoning trace yet?
         let md = null; // renders the streamed answer as markdown, block by block
         const calls = []; // tool calls under assembly, indexed by delta.index
+        // The model has finished thinking and is about to say/do something. Close out
+        // the spinner, stash the trace, and print a single one-line indicator with the
+        // shortcut to reveal it. Idempotent + collapses to nothing for sub-agents and
+        // the eval harness (they never show thinking).
+        const flushReasoning = () => {
+            if (!reasoningBuf || reasoningShown)
+                return;
+            reasoningShown = true;
+            reasoningActive = false;
+            if (spinner?.isSpinning)
+                spinner.stop();
+            if (opts.quiet || opts.subAgent)
+                return; // no UI for silent / nested runs
+            recordReasoning(reasoningBuf); // keep it for Ctrl+R (never goes into history)
+            const secs = Math.round((Date.now() - startedAt) / 1000);
+            const toks = Math.round(reasoningBuf.length / 4); // same ~chars/4 estimate as the spinner
+            const tokStr = toks >= 1000 ? `${(toks / 1000).toFixed(1)}k` : `${toks}`;
+            process.stdout.write(chalk.dim(`💭 thought for ${secs}s (~${tokStr} tokens) · Ctrl+R to view`) + "\n");
+        };
         for await (const chunk of stream) {
             lastEvent = Date.now(); // feed the watchdog
             stallWarned = false; // the stream spoke — reset the stall warning
@@ -376,31 +401,24 @@ opts) {
             if (!delta)
                 continue; // keep-alive or usage chunk — nothing to do
             // Reasoning models (e.g. deepseek-reasoner / R1) stream their thinking in a
-            // separate `reasoning_content` field BEFORE the answer. Show it dimly so a
-            // switch to a reasoning model is visibly different — but do NOT keep it:
-            // the reasoning is not the answer and must not be replayed in later turns.
+            // separate `reasoning_content` field BEFORE the answer. We do NOT print it
+            // (it buries the actual reply) and do NOT keep it (it must not be replayed
+            // in later turns): we let the spinner keep spinning, stash the trace, and
+            // surface it only behind Ctrl+R.
             const reasoning = delta.reasoning_content;
             if (reasoning) {
                 streamedChars += reasoning.length; // count reasoning toward the live token estimate
-                if (spinner?.isSpinning)
-                    spinner.stop();
-                if (!opts.quiet && !opts.subAgent) {
-                    if (!printedThinking) {
-                        process.stdout.write("\n" + chalk.dim("💭 thinking: ")); // label the trace once
-                        printedThinking = true;
-                    }
-                    process.stdout.write(chalk.dim(reasoning)); // stream the thinking, dimmed
-                }
+                reasoningBuf += reasoning; // stash it for Ctrl+R instead of streaming it
+                reasoningActive = true; // the spinner now shows 💭 (set by the watchdog)
             }
             if (delta.content) {
+                flushReasoning(); // thinking is over — show the one-line indicator first
                 streamedChars += delta.content.length; // count the answer toward the live token estimate
                 if (spinner?.isSpinning)
                     spinner.stop(); // first token: replace the spinner with real output
                 if (!opts.quiet && !opts.subAgent) {
                     // Only the top-level agent streams to the screen — a sub-agent's
                     // inner monologue would be mistaken for the answer.
-                    if (printedThinking && !printedPrefix)
-                        process.stdout.write("\n"); // end the thinking block before the answer
                     if (!printedPrefix) {
                         // Stream the answer through the markdown renderer: it buffers a block
                         // (paragraph / heading / list / table) and prints it formatted the
@@ -413,6 +431,8 @@ opts) {
                 }
                 content += delta.content; // always keep it for the history (the answer only, never the reasoning)
             }
+            if (delta.tool_calls?.length)
+                flushReasoning(); // thinking is over — indicator before the tool logs (which print after we return)
             for (const tc of delta.tool_calls ?? []) {
                 if (spinner?.isSpinning)
                     spinner.stop(); // tool call starting — spinner served its purpose
@@ -425,6 +445,7 @@ opts) {
                     slot.args += tc.function.arguments; // arguments stream in fragments — concatenate
             }
         }
+        flushReasoning(); // a reasoning-only turn (no content, no tools) still records + indicates
         if (md)
             md.end(); // flush the final (un-terminated) block through the renderer
         if (printedPrefix)

package/dist/tui.js

@@ -58,6 +58,33 @@ export function toggleLastCollapsed() {
     }
     return true;
 }
+// ---- collapsed reasoning (the model's thinking) ------------------------------
+// Reasoning models (deepseek-reasoner / R1) stream a long thinking trace before
+// the answer. Dumping it all to the screen buries the actual reply, so we hide
+// it behind a spinner and a one-line indicator, keeping the trace here for the
+// user to reveal with Ctrl+R (handled by the line editor, like Tab for tools).
+// Stored as one entry per model round; cleared when a new user turn begins, so
+// Ctrl+R always shows the thinking behind the LAST answer.
+const reasoningTrace = [];
+export function recordReasoning(text) {
+    const t = text.trim();
+    if (t)
+        reasoningTrace.push(t);
+}
+// Drop the current turn's thinking. Called when a new prompt is submitted (the
+// old thinking belonged to the old answer) and on /clear.
+export function clearReasoning() {
+    reasoningTrace.length = 0;
+}
+// Ctrl+R handler: print the stored thinking for the last answer, dimmed and
+// nested. Returns false (nothing to show) so the editor can ignore the key.
+export function revealReasoning() {
+    if (!reasoningTrace.length)
+        return false;
+    process.stdout.write(chalk.dim("💭 model's thinking:\n"));
+    process.stdout.write(chalk.dim(reasoningTrace.join("\n\n— — —\n\n").replace(/^/gm, "  ")) + "\n");
+    return true;
+}
 // ---- cleanup -----------------------------------------------------------------
 // Called on exit. Nothing fancy to restore now (we no longer hijack the bottom
 // of the screen), but keep the hook so callers don't have to change if that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-from-zero",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Build a Claude Code-style CLI agent from scratch, with AI as your pair programmer — companion code for a 10-day tutorial (DeepSeek by default, any OpenAI-compatible model)",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "eval": "tsx --env-file=.env eval/run.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "npm run build",
-    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts"
+    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts"
   },
   "engines": {
     "node": ">=20.6"