agent-from-zero 0.34.2 → 0.35.0

package/dist/mcp.js

@@ -543,6 +543,7 @@ function registerTools(name, specs, client) {
     for (const spec of specs) {
         const toolName = `mcp__${name}__${spec.name}`; // namespaced, collision-proof
         const tool = {
+            annotations: spec.annotations,
             definition: {
                 type: "function",
                 function: {

package/dist/menu.js

@@ -1,6 +1,41 @@
 import readline from "node:readline"; // raw-mode keypress events + the interface to pause
+import chalk from "chalk";
+import { reduceEditor, truncateToWidth } from "./editor.js";
 import { renderMenu, MENU_HINT } from "./ui.js"; // the pure drawing + the footer hint
 import { initFormState, reduceForm, renderForm, collectAnswers } from "./form.js"; // the multi-question form
+// Navigation owns arrows; printable text belongs to this editor. Sending a
+// follow-up cancels the pending choice, never implicitly approves it.
+function promptDraft(submit, redraw, cancel) {
+    let state = { buffer: "", cursor: 0 };
+    let sending = false;
+    let error = "";
+    return {
+        render: () => submit ? `\n${truncateToWidth(`Follow-up ❯ ${state.buffer.slice(0, state.cursor)}${chalk.inverse(state.buffer[state.cursor] ?? " ")}${state.buffer.slice(state.cursor + 1)}`, Math.max(10, (process.stdout.columns || 80) - 1))}\n${truncateToWidth(error || "Type a follow-up · Enter sends text; empty input selects", Math.max(10, (process.stdout.columns || 80) - 1))}` : "",
+        handle(str, key) {
+            if (sending)
+                return true;
+            if (!submit || ["up", "down", "tab", "escape"].includes(key.name ?? "") || (key.ctrl && key.name === "c"))
+                return false;
+            const next = reduceEditor(state, str, key);
+            if (next.action === "submit" && state.buffer.trim()) {
+                sending = true;
+                void Promise.resolve().then(() => submit(state.buffer.trim())).then((accepted) => { if (accepted)
+                    cancel();
+                else
+                    redraw(); })
+                    .catch(() => { error = "Could not submit follow-up; draft retained."; redraw(); }).finally(() => { sending = false; });
+                return true;
+            }
+            if (next.action === "edit") {
+                state = next.state;
+                error = "";
+                redraw();
+                return true;
+            }
+            return next.action !== "submit";
+        },
+    };
+}
 // An arrow-key selection menu. The whole point: an approval is one keystroke
 // (↑/↓ then Enter), not "type y, then N, then realize you meant the other".
 // Selecting costs the user less than typing.
@@ -14,7 +49,8 @@ import { initFormState, reduceForm, renderForm, collectAnswers } from "./form.js
 // callers treat -1 as "no" (fail closed for an approval).
 export function promptSelect(rl, // the session's line reader, paused while we own the keys
 options, // the choices, top to bottom
-input = process.stdin) {
+input = process.stdin, // injectable for tests
+onFollowUp) {
     return new Promise((resolve) => {
         if (!input.isTTY)
             return resolve(-1); // no interactive selection without a terminal — caller falls back
@@ -24,11 +60,11 @@ input = process.stdin) {
         // Redraw the menu in place: move the cursor back up over the previous
         // render (options + the one footer line), clear downward, reprint. The
         // question above the menu stays put.
-        const lineCount = options.length + 1; // options, plus the hint footer
+        const lineCount = options.length + 1 + (onFollowUp ? 2 : 0);
         const draw = (first) => {
             if (!first)
                 process.stdout.write(`\x1b[${lineCount}A`); // up to the menu's top
-            process.stdout.write(`\x1b[J${renderMenu(options, selected)}\n${MENU_HINT}\n`); // clear down, repaint + hint
+            process.stdout.write(`\x1b[J${renderMenu(options, selected)}\n${MENU_HINT}${draft.render()}\n`);
         };
         const finish = (result) => {
             if (done)
@@ -44,9 +80,12 @@ input = process.stdin) {
             rl.resume(); // the line reader takes over again
             resolve(result);
         };
-        const onKey = (_str, key) => {
+        const draft = promptDraft(onFollowUp, () => draw(false), () => finish(-1));
+        const onKey = (str, key) => {
             if (!key || done)
                 return;
+            if (draft.handle(str, key))
+                return;
             switch (key.name) {
                 case "up":
                 case "k":
@@ -88,18 +127,18 @@ input = process.stdin) {
 // the user answers each and submits, and we hand back organized answers. Same
 // raw-mode borrow/return dance as promptSelect; the state machine is in form.ts.
 // Returns the answers, or null if cancelled / not a TTY.
-export function promptForm(rl, questions, input = process.stdin) {
+export function promptForm(rl, questions, input = process.stdin, onFollowUp) {
     return new Promise((resolve) => {
         if (!input.isTTY || !questions.length)
             return resolve(null); // no form without a terminal or questions
         let state = initFormState(questions);
         let done = false;
         const wasRaw = input.isRaw === true; // restore this on exit, not false (see promptSelect)
-        const lineCount = renderForm(questions, state).split("\n").length; // constant for these questions
+        const lineCount = renderForm(questions, state).split("\n").length + (onFollowUp ? 2 : 0);
         const draw = (first) => {
             if (!first)
                 process.stdout.write(`\x1b[${lineCount}A`); // up over the whole form
-            process.stdout.write(`\x1b[J${renderForm(questions, state)}\n`); // clear down, repaint
+            process.stdout.write(`\x1b[J${renderForm(questions, state)}${draft.render()}\n`);
         };
         const finish = (result) => {
             if (done)
@@ -115,9 +154,12 @@ export function promptForm(rl, questions, input = process.stdin) {
             rl.resume();
             resolve(result);
         };
-        const onKey = (_str, key) => {
+        const draft = promptDraft(onFollowUp, () => draw(false), () => finish(null));
+        const onKey = (str, key) => {
             if (!key || done)
                 return;
+            if (draft.handle(str, key))
+                return;
             if (key.name === "up" || key.name === "k") {
                 state = reduceForm(questions, state, "up").state;
                 draw(false);

package/dist/output.js

@@ -24,7 +24,7 @@ class StdoutSpinner {
 // `output`. Each method is the exact line the loop used to run inline.
 export const STDOUT_OUTPUT = {
     spinner: (text) => new StdoutSpinner(text),
-    reasoning: (line) => process.stdout.write(line + "\n"),
+    reasoning: () => { },
     answer: () => {
         // Lazily build the MarkdownStream on the first token (so a tool-only or
         // empty turn prints nothing), then end with a single trailing newline —

package/dist/pasted-text.js

@@ -0,0 +1,32 @@
+// Terminal-independent storage for folded text. Labels are presentation only:
+// expand exactly once before hooks, permission context or model submission.
+// Keep entries for the session so recalling an earlier draft never loses text.
+export class PastedTextStore {
+    entries = new Map();
+    sequence = 0;
+    fold(text) {
+        const lines = text.split(/\r\n|\r|\n/).length;
+        if (lines < 4 && text.length < 1000)
+            return text;
+        const size = lines > 1 ? `${lines - 1} lines` : `${Array.from(text).length} chars`;
+        const label = `[Pasted text #${++this.sequence} +${size}]`;
+        this.entries.set(label, { label, text });
+        return label;
+    }
+    expand(input) {
+        return input.replace(/\[Pasted text #\d+ \+\d+ (?:lines|chars)\]/g, (label) => this.entries.get(label)?.text ?? label);
+    }
+    // A capsule is one editing unit: arrows jump over it and Backspace removes
+    // it whole, including when a mouse/other editor leaves the caret inside it.
+    at(input, cursor, direction) {
+        for (const match of input.matchAll(/\[Pasted text #\d+ \+\d+ (?:lines|chars)\]/g)) {
+            if (!this.entries.has(match[0]))
+                continue;
+            const start = match.index;
+            const end = start + match[0].length;
+            if (direction === "left" ? start < cursor && cursor <= end : start <= cursor && cursor < end)
+                return { start, end };
+        }
+        return undefined;
+    }
+}