@armadra/agent 0.0.0-stage → 0.3.0

package/dist/modes/interactive/line/line-editor.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 行式界面的单行编辑器（raw 模式可用时）。[B6]
+ *
+ * 键位：可见字符插入；←/→、Home/End（Ctrl+A / Ctrl+E）移动；↑/↓ 历史；退格、Delete、
+ * Ctrl+U（删到行首）、Ctrl+K（删到行尾）、Ctrl+W（删前一个词）；Enter 提交；Ctrl+C 中断；
+ * 空行 Ctrl+D 结束。括号粘贴：单行原样插入，多行折叠成 `[粘贴 #n +k 行]` 标记，提交时展开。
+ * `ask()`：审批等单键问答，下一个可见字符（或 Enter = 缺省答案）作答。
+ */
+export type EditorAction = {
+    kind: "submit";
+    text: string;
+} | {
+    kind: "interrupt";
+} | {
+    kind: "eof";
+};
+export interface LineEditorOptions {
+    prompt: string;
+    write(text: string): void;
+    history?: string[];
+}
+export declare class LineEditor {
+    private readonly options;
+    buffer: string;
+    cursor: number;
+    private readonly paste;
+    private readonly pastes;
+    private readonly history;
+    private historyAt;
+    private visible;
+    private question;
+    constructor(options: LineEditorOptions);
+    /** 提示符 + 内容，光标放到正确的列。 */
+    render(): void;
+    /** 清掉编辑行（输出前调用）。 */
+    hide(): void;
+    get isVisible(): boolean;
+    /** 单键问答：返回小写的回答字符；Enter → fallback；Ctrl+C → fallback。 */
+    ask(question: string, fallback: string): Promise<string>;
+    feed(data: string): EditorAction[];
+    /** 输入暂停后交出留着的 ESC 前缀。 */
+    flush(): EditorAction[];
+    private answer;
+    private keys;
+    private special;
+    private insert;
+    private insertPaste;
+    /** 展开粘贴标记、记历史、清空。 */
+    private submit;
+}

package/dist/modes/interactive/line/line-editor.js

@@ -0,0 +1,232 @@
+/**
+ * 行式界面的单行编辑器（raw 模式可用时）。[B6]
+ *
+ * 键位：可见字符插入；←/→、Home/End（Ctrl+A / Ctrl+E）移动；↑/↓ 历史；退格、Delete、
+ * Ctrl+U（删到行首）、Ctrl+K（删到行尾）、Ctrl+W（删前一个词）；Enter 提交；Ctrl+C 中断；
+ * 空行 Ctrl+D 结束。括号粘贴：单行原样插入，多行折叠成 `[粘贴 #n +k 行]` 标记，提交时展开。
+ * `ask()`：审批等单键问答，下一个可见字符（或 Enter = 缺省答案）作答。
+ */
+import { visibleWidth } from "../../../tui/ansi.js";
+import { PasteState } from "./paste-state.js";
+const KEYS = {
+    "\x1b[A": "up",
+    "\x1b[B": "down",
+    "\x1b[C": "right",
+    "\x1b[D": "left",
+    "\x1b[H": "home",
+    "\x1bOH": "home",
+    "\x1b[1~": "home",
+    "\x1b[F": "end",
+    "\x1bOF": "end",
+    "\x1b[4~": "end",
+    "\x1b[3~": "delete",
+};
+export class LineEditor {
+    options;
+    buffer = "";
+    cursor = 0;
+    paste = new PasteState();
+    pastes = new Map();
+    history;
+    historyAt;
+    visible = false;
+    question;
+    constructor(options) {
+        this.options = options;
+        this.history = options.history ?? [];
+        this.historyAt = this.history.length;
+    }
+    /** 提示符 + 内容，光标放到正确的列。 */
+    render() {
+        this.visible = true;
+        const line = this.options.prompt + this.buffer;
+        const back = visibleWidth(this.buffer.slice(this.cursor));
+        this.options.write(`\r\x1b[2K${line}${back > 0 ? `\x1b[${back}D` : ""}`);
+    }
+    /** 清掉编辑行（输出前调用）。 */
+    hide() {
+        if (!this.visible)
+            return;
+        this.visible = false;
+        this.options.write("\r\x1b[2K");
+    }
+    get isVisible() {
+        return this.visible;
+    }
+    /** 单键问答：返回小写的回答字符；Enter → fallback；Ctrl+C → fallback。 */
+    ask(question, fallback) {
+        this.hide();
+        this.options.write(question);
+        return new Promise((resolve) => {
+            this.question = { resolve, fallback };
+        });
+    }
+    feed(data) {
+        const actions = [];
+        for (const piece of this.paste.feed(data)) {
+            if (piece.kind === "paste")
+                this.insertPaste(piece.text);
+            else
+                this.keys(piece.text, actions);
+        }
+        return actions;
+    }
+    /** 输入暂停后交出留着的 ESC 前缀。 */
+    flush() {
+        const actions = [];
+        for (const piece of this.paste.flush())
+            if (piece.kind === "text")
+                this.keys(piece.text, actions);
+        return actions;
+    }
+    answer(ch) {
+        const q = this.question;
+        if (q === undefined)
+            return;
+        this.question = undefined;
+        const answer = ch === "\r" || ch === "\n" || ch === "\x03" ? q.fallback : ch.toLowerCase();
+        this.options.write(`${answer}\n`);
+        q.resolve(answer);
+    }
+    keys(text, actions) {
+        let i = 0;
+        while (i < text.length) {
+            if (this.question !== undefined) {
+                const ch = text[i];
+                i++;
+                if (ch === "\x1b")
+                    continue;
+                this.answer(ch);
+                continue;
+            }
+            if (text[i] === "\x1b") {
+                const seq = /^\x1b(?:\[[0-9;]*[~A-Za-z]|O[A-Za-z])?/.exec(text.slice(i))?.[0] ?? "\x1b";
+                i += seq.length;
+                this.special(KEYS[seq]);
+                continue;
+            }
+            const cp = text.codePointAt(i);
+            const ch = String.fromCodePoint(cp);
+            i += ch.length;
+            switch (ch) {
+                case "\r":
+                case "\n":
+                    actions.push({ kind: "submit", text: this.submit() });
+                    break;
+                case "\x03":
+                    actions.push({ kind: "interrupt" });
+                    break;
+                case "\x04":
+                    if (this.buffer === "")
+                        actions.push({ kind: "eof" });
+                    else
+                        this.special("delete");
+                    break;
+                case "\x7f":
+                case "\b":
+                    if (this.cursor > 0) {
+                        const before = Array.from(this.buffer.slice(0, this.cursor));
+                        before.pop();
+                        const head = before.join("");
+                        this.buffer = head + this.buffer.slice(this.cursor);
+                        this.cursor = head.length;
+                    }
+                    break;
+                case "\x01":
+                    this.special("home");
+                    break;
+                case "\x05":
+                    this.special("end");
+                    break;
+                case "\x15":
+                    this.buffer = this.buffer.slice(this.cursor);
+                    this.cursor = 0;
+                    break;
+                case "\x0b":
+                    this.buffer = this.buffer.slice(0, this.cursor);
+                    break;
+                case "\x17": {
+                    const head = this.buffer.slice(0, this.cursor).replace(/\S+\s*$/, "");
+                    this.buffer = head + this.buffer.slice(this.cursor);
+                    this.cursor = head.length;
+                    break;
+                }
+                default:
+                    if (cp >= 0x20)
+                        this.insert(ch);
+            }
+        }
+        if (this.visible)
+            this.render();
+    }
+    special(key) {
+        switch (key) {
+            case "left":
+                if (this.cursor > 0)
+                    this.cursor -= Array.from(this.buffer.slice(0, this.cursor)).pop()?.length ?? 1;
+                break;
+            case "right":
+                if (this.cursor < this.buffer.length)
+                    this.cursor += Array.from(this.buffer.slice(this.cursor))[0]?.length ?? 1;
+                break;
+            case "home":
+                this.cursor = 0;
+                break;
+            case "end":
+                this.cursor = this.buffer.length;
+                break;
+            case "delete":
+                if (this.cursor < this.buffer.length) {
+                    const tail = Array.from(this.buffer.slice(this.cursor)).slice(1).join("");
+                    this.buffer = this.buffer.slice(0, this.cursor) + tail;
+                }
+                break;
+            case "up":
+            case "down": {
+                const next = this.historyAt + (key === "up" ? -1 : 1);
+                if (next < 0 || next > this.history.length)
+                    break;
+                this.historyAt = next;
+                this.buffer = this.history[next] ?? "";
+                this.cursor = this.buffer.length;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    insert(text) {
+        this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
+        this.cursor += text.length;
+    }
+    insertPaste(text) {
+        const lines = text.split("\n").length;
+        if (lines <= 1) {
+            this.insert(text);
+        }
+        else {
+            const marker = `[粘贴 #${this.pastes.size + 1} +${lines} 行]`;
+            this.pastes.set(marker, text);
+            this.insert(marker);
+        }
+        if (this.visible)
+            this.render();
+    }
+    /** 展开粘贴标记、记历史、清空。 */
+    submit() {
+        // 提交时把整行（含粘贴标记）留在屏幕上，再换行。
+        if (this.visible)
+            this.options.write(`\r\x1b[2K${this.options.prompt}${this.buffer}\n`);
+        let text = this.buffer;
+        for (const [marker, content] of this.pastes)
+            text = text.split(marker).join(content);
+        if (this.buffer.trim() !== "" && this.history.at(-1) !== this.buffer)
+            this.history.push(this.buffer);
+        this.historyAt = this.history.length;
+        this.buffer = "";
+        this.cursor = 0;
+        this.pastes.clear();
+        this.visible = false;
+        return text;
+    }
+}

package/dist/modes/interactive/line/line-mode.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 行式界面（`--no-tui`、非 TTY、`TERM=dumb`；B7 的终端界面合入前也承担交互模式）。[B6]
+ *
+ * - stdin 是 TTY 且可开 raw：自带单行编辑器（line-editor.ts：历史、括号粘贴折叠），运行中回车
+ *   = steer；Ctrl+C 运行中中断、空闲时连按两次退出（130）；空行 Ctrl+D 退出；审批 y / a / N 单键问答。
+ *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
+ * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
+ * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选。
+ */
+import type { ModeContext } from "../../../cli/deps.js";
+import type { Runtime } from "../../../cli/runtime.js";
+export interface LineModeOptions {
+    stdin?: NodeJS.ReadableStream & {
+        setRawMode?(raw: boolean): unknown;
+        isTTY?: boolean;
+    };
+    /** 强制 raw / 管道（测试）；缺省按 io.stdinIsTTY 与 setRawMode 判断。 */
+    raw?: boolean;
+}
+export declare function runLineMode(runtime: Runtime, context: ModeContext, options?: LineModeOptions): Promise<number>;

package/dist/modes/interactive/line/line-mode.js

@@ -0,0 +1,218 @@
+/**
+ * 行式界面（`--no-tui`、非 TTY、`TERM=dumb`；B7 的终端界面合入前也承担交互模式）。[B6]
+ *
+ * - stdin 是 TTY 且可开 raw：自带单行编辑器（line-editor.ts：历史、括号粘贴折叠），运行中回车
+ *   = steer；Ctrl+C 运行中中断、空闲时连按两次退出（130）；空行 Ctrl+D 退出；审批 y / a / N 单键问答。
+ *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
+ * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
+ * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选。
+ */
+import { promptImages, sessionModel } from "../../image-input.js";
+import { currentSession, switchSession } from "../../../cli/compose-session.js";
+import { ExitCode } from "../../../cli/exit-codes.js";
+import { previewDisplayLines } from "../../../permissions/preview.js";
+import { AMA_VERSION } from "../../../version.js";
+import { runSlashCommand } from "../../commands-core.js";
+import { createLineReader } from "../../rpc/jsonl.js";
+import { errorText, onTerminationSignals } from "../../shared.js";
+import { LineEditor } from "./line-editor.js";
+import { cacheNoticesEnabled } from "../../session-report.js";
+import { EventPrinter, approvalQuestion, logsInfo, pickHint } from "./line-render.js";
+const DOUBLE_INTERRUPT_MS = 1500;
+export async function runLineMode(runtime, context, options = {}) {
+    const { io } = context;
+    const stdin = options.stdin ?? process.stdin;
+    const raw = options.raw ?? (io.stdinIsTTY && typeof stdin.setRawMode === "function");
+    let editor;
+    const out = (text) => {
+        editor?.hide();
+        io.stdout(text);
+    };
+    const err = (text) => {
+        editor?.hide();
+        io.stderr(text);
+    };
+    let session = currentSession(runtime);
+    const printer = new EventPrinter(out, err, {
+        missNotices: () => cacheNoticesEnabled(session),
+        info: logsInfo(io.env),
+    });
+    let unsubscribe = session.subscribe((event) => printer.handle(event));
+    const commands = {
+        runtime,
+        session: () => session,
+        async switchSession(request) {
+            const next = await switchSession(runtime, request);
+            unsubscribe();
+            session = next;
+            unsubscribe = next.subscribe((event) => printer.handle(event));
+            return next;
+        },
+    };
+    /** 一行输入：命令或提示；返回 "exit" 表示结束。 */
+    const handle = async (line) => {
+        if (line.trim() === "")
+            return undefined;
+        try {
+            const result = await runSlashCommand(line, commands);
+            if (result === undefined)
+                await prompt(session, line);
+            else if (result.kind === "exit")
+                return "exit";
+            else if (result.kind === "prompt")
+                await prompt(session, result.text);
+            else if (result.kind === "pick")
+                out(`${await pickHint(result.what, runtime, session)}\n`);
+            else if (result.message !== undefined)
+                out(`${result.message}\n`);
+        }
+        catch (error) {
+            printer.endLine();
+            err(`ama: ${errorText(error)}\n`);
+        }
+        return undefined;
+    };
+    const prompt = async (target, text) => {
+        const images = await promptImages(text, [], target.state.cwd, sessionModel(runtime.providers, target));
+        await target.prompt(text, images.length > 0 ? { images } : {});
+        printer.endLine();
+    };
+    if (!raw)
+        return runPiped(stdin, context, handle, () => session, () => unsubscribe());
+    // ---- raw 终端 ----
+    const tty = stdin;
+    editor = new LineEditor({ prompt: "› ", write: (t) => io.stdout(t) });
+    const ed = editor;
+    if (runtime.config.ui?.quietStartup !== "silent") {
+        const model = session.state.model;
+        io.stdout(`ama ${AMA_VERSION} · ${model?.provider}/${model?.id} · /help 查看命令，Ctrl+D 退出\n`);
+    }
+    runtime.approvals.setUiBroker({
+        ask: (request, signal) => new Promise((resolve) => {
+            if (signal.aborted)
+                return resolve(undefined);
+            signal.addEventListener("abort", () => resolve(undefined), { once: true });
+            const preview = previewDisplayLines(request.preview).map((l) => `  ${l}\n`);
+            void ed.ask(`\n${preview.join("")}${approvalQuestion(request)}`, "n").then((answer) => {
+                resolve(answer === "y" ? "allow" : answer === "a" ? "allow_session" : "deny");
+                if (!busy)
+                    ed.render();
+            });
+        }),
+    });
+    runtime.notifier.set((message, level) => err(`ama: [${level}] ${message}\n`));
+    let busy = false;
+    let lastInterrupt = 0;
+    return new Promise((resolve) => {
+        let finished = false;
+        const finish = (code) => {
+            if (finished)
+                return;
+            finished = true;
+            tty.off("data", onData);
+            ed.hide();
+            io.stdout("\x1b[?2004l");
+            tty.setRawMode?.(false);
+            tty.pause?.();
+            runtime.approvals.setUiBroker(undefined);
+            runtime.notifier.set(undefined);
+            void session
+                .abort()
+                .catch(() => undefined)
+                .finally(() => {
+                unsubscribe();
+                resolve(code);
+            });
+        };
+        const run = (text) => {
+            busy = true;
+            void handle(text).then((outcome) => {
+                busy = false;
+                if (outcome === "exit")
+                    finish(ExitCode.Ok);
+                else
+                    ed.render();
+            });
+        };
+        let flushTimer;
+        const apply = (actions) => {
+            for (const action of actions) {
+                if (action.kind === "eof")
+                    return finish(ExitCode.Ok);
+                if (action.kind === "interrupt") {
+                    if (busy) {
+                        void session.abort();
+                        err("^C 已中断\n");
+                    }
+                    else if (Date.now() - lastInterrupt < DOUBLE_INTERRUPT_MS) {
+                        return finish(ExitCode.Sigint);
+                    }
+                    else {
+                        lastInterrupt = Date.now();
+                        io.stdout("\n（再按一次 Ctrl+C 退出）\n");
+                        ed.render();
+                    }
+                    continue;
+                }
+                if (busy) {
+                    if (action.text.trim() !== "") {
+                        void session.steer(action.text).catch(() => undefined);
+                        out(`↳ steer：${action.text}\n`);
+                    }
+                    continue;
+                }
+                run(action.text);
+            }
+        };
+        const onData = (chunk) => {
+            apply(ed.feed(typeof chunk === "string" ? chunk : chunk.toString("utf8")));
+            if (flushTimer !== undefined)
+                clearTimeout(flushTimer);
+            flushTimer = setTimeout(() => apply(ed.flush()), 50);
+        };
+        tty.setRawMode?.(true);
+        io.stdout("\x1b[?2004h");
+        tty.on("data", onData);
+        tty.resume?.();
+        if (context.prompt !== undefined) {
+            io.stdout(`› ${context.prompt}\n`);
+            run(context.prompt);
+        }
+        else
+            ed.render();
+    });
+}
+/** 管道：逐行依次执行；stdin 结束后等最后一条跑完退出 0。 */
+function runPiped(stdin, context, handle, session, unsubscribe) {
+    return new Promise((resolve) => {
+        let chain = Promise.resolve(undefined);
+        let finished = false;
+        const finish = (code) => {
+            if (finished)
+                return;
+            finished = true;
+            reader.close();
+            offSignals();
+            stdin.pause?.();
+            unsubscribe();
+            resolve(code);
+        };
+        const enqueue = (line) => {
+            chain = chain.then((state) => (state === "exit" ? state : handle(line)));
+            void chain.then((state) => {
+                if (state === "exit")
+                    finish(ExitCode.Ok);
+            });
+        };
+        const reader = createLineReader(stdin, enqueue, () => {
+            void chain.then(() => finish(ExitCode.Ok));
+        });
+        const offSignals = onTerminationSignals((code) => {
+            void session()
+                .abort()
+                .finally(() => finish(code));
+        });
+        if (context.prompt !== undefined)
+            enqueue(context.prompt);
+    });
+}

package/dist/modes/interactive/line/line-render.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 行式界面的输出：会话事件 → 纯文本（助手文本流式写 stdout，工具 / 重试 / 压缩一行提示）。[B6]
+ * 选择器在行式界面里退化为列出候选、提示带参数重发。
+ */
+import type { AgentSession, SessionEvent } from "../../../agent/types.js";
+import type { Runtime } from "../../../cli/runtime.js";
+import type { ApprovalRequest } from "../../../permissions/types.js";
+import type { CommandResult } from "../../commands-core.js";
+/** 工具参数的一行摘要（第一个常见字段，折叠换行、截到 80 字符）。 */
+export declare function argsSummary(args: unknown): string;
+export declare function approvalQuestion(request: ApprovalRequest): string;
+/** [W3-C2] 缓存提示的开关（line 模式由 runLineMode 传入）。 */
+export interface EventPrinterOptions {
+    /** `cache.missNotices`（每次现取，切换会话后跟随新会话）；缺省 true。 */
+    missNotices?(): boolean;
+    /** `AMA_LOG` 为 info / debug：保温成功也写一行。 */
+    info?: boolean;
+}
+/** `AMA_LOG=info|debug`。 */
+export declare function logsInfo(env: Readonly<Record<string, string | undefined>>): boolean;
+export declare class EventPrinter {
+    private readonly out;
+    private readonly err;
+    private readonly options;
+    private midLine;
+    constructor(out: (text: string) => void, err: (text: string) => void, options?: EventPrinterOptions);
+    private line;
+    /** 收尾：保证光标在行首。 */
+    endLine(): void;
+    handle(event: SessionEvent): void;
+}
+/** `pick` 在行式界面：列出候选，提示带参数重发。 */
+export declare function pickHint(what: Extract<CommandResult, {
+    kind: "pick";
+}>["what"], runtime: Runtime, session: AgentSession): Promise<string>;