@armadra/agent 0.4.0 → 0.5.0

package/dist/modes/interactive/rewind-flow.js

@@ -0,0 +1,151 @@
+/**
+ * 回滚交互流程（rewind-plan §3.5、§3.6、§4）：列表 → 确认面板 → 执行 → 结果通知。[RW-C]
+ *
+ * - `open()`（`/rewind`、空闲时双击 Esc）：运行中只提示；没有回滚点提示一行。
+ * - 执行：对话类（恢复代码和对话 / 恢复对话 / 从这里摘要）之后重画消息区并把原消息回填输入框
+ *   （文本进编辑器，图片随下一条消息发送）；结果写一条通知，错误码换成中文说明。
+ * - `afterInterrupt()`（中断即撤回）：Esc 中断后等运行结束；输入框仍为空且会话判定可撤回
+ *   （`ui.restoreOnCancel`、本回合没有任何助手文本 / 工具调用）→ 撤回并回填原消息。
+ */
+import { AgentSessionImpl } from "../../agent/session.js";
+import { PreviewCache, openRewindList } from "./rewind-list.js";
+import { RewindPanel } from "./rewind-panel.js";
+import { rewindErrorText, rewindResultLines } from "./rewind-text.js";
+export const REFILLED = "原消息已放回输入框";
+/** 打开确认面板（底部覆盖层）；返回选择或 undefined（取消）。 */
+export function openRewindPanel(host, model) {
+    return new Promise((resolve) => {
+        let handle;
+        const panel = new RewindPanel(model, {
+            theme: host.theme,
+            ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
+            ...(host.rows !== undefined ? { rows: host.rows } : {}),
+        }, (choice) => {
+            handle?.hide();
+            resolve(choice);
+        });
+        handle = host.showOverlay(panel, { anchor: "bottom" });
+    });
+}
+function draftNote(draft) {
+    const images = draft.images?.length ?? 0;
+    return images > 0 ? `${REFILLED}（${images} 张图片随下一条消息发送）` : REFILLED;
+}
+/** 执行面板里的选择，结果与错误都写成通知。 */
+export async function executeRewind(host, point, choice) {
+    const session = host.session();
+    try {
+        switch (choice.action) {
+            case "both":
+            case "conversation":
+            case "code": {
+                host.hint("回滚中…");
+                const result = await session.rewind({
+                    entryId: point.entryId,
+                    mode: choice.action,
+                    ...(choice.onConflict !== undefined ? { onConflict: choice.onConflict } : {}),
+                });
+                const draft = result.conversation?.draft;
+                if (draft !== undefined) {
+                    host.reload();
+                    host.setDraft(draft);
+                }
+                const shown = { ...result };
+                if (choice.action === "conversation")
+                    delete shown.gitHint;
+                const lines = rewindResultLines(shown, {
+                    overwrite: choice.onConflict === "overwrite",
+                    ...(draft !== undefined
+                        ? { conversation: `对话已回到这条消息之前，${draftNote(draft)}` }
+                        : {}),
+                });
+                const code = result.code;
+                const nothing = code !== undefined &&
+                    code.restored.length + code.deleted.length === 0 &&
+                    (choice.onConflict !== "overwrite" || code.conflicts.length === 0);
+                host.notice(nothing && choice.action === "code" ? "warn" : "info", lines.join("\n"));
+                break;
+            }
+            case "summarize-from": {
+                host.hint("正在为离开的部分写摘要…");
+                const result = await session.summarizeFrom(point.entryId, choice.instructions);
+                host.reload();
+                host.setDraft(result.draft);
+                host.notice("info", `已从这里分叉，离开的部分写成了摘要；${draftNote(result.draft)}`);
+                break;
+            }
+            case "summarize-up-to": {
+                host.hint("正在摘要…");
+                const result = await session.summarizeUpTo(point.entryId, choice.instructions);
+                const after = result.tokensAfter !== undefined ? ` → ${result.tokensAfter}` : "";
+                host.notice("info", `已摘要到这里：${result.tokensBefore}${after} token`);
+                break;
+            }
+        }
+    }
+    catch (error) {
+        host.notice("error", rewindErrorText(error));
+    }
+    finally {
+        host.hint("");
+    }
+}
+export function createRewindFlow(host) {
+    let opening = false;
+    return {
+        async open() {
+            const session = host.session();
+            if (session.state.isStreaming) {
+                host.notice("warn", "正在运行，不能回滚（先按 Esc 中断）");
+                return;
+            }
+            if (opening)
+                return;
+            opening = true;
+            try {
+                const points = session.rewindPoints();
+                if (points.length === 0) {
+                    host.notice("info", "还没有可回滚的消息");
+                    return;
+                }
+                const cache = new PreviewCache((entryId) => session.rewind({ entryId, mode: "code", dryRun: true }));
+                const point = await openRewindList(host, points, cache);
+                if (point === undefined)
+                    return;
+                const model = { point, now: host.now() };
+                if (point.hasCheckpoint) {
+                    const state = await cache.ensure(point.entryId);
+                    if (state.state === "done")
+                        model.preview = state.result;
+                    else if (state.state === "error")
+                        model.previewError = state.message;
+                }
+                const choice = await openRewindPanel(host, model);
+                if (choice !== undefined)
+                    await executeRewind(host, point, choice);
+            }
+            finally {
+                opening = false;
+            }
+        },
+        async afterInterrupt(editorWasEmpty) {
+            const session = host.session();
+            await session.waitForIdle();
+            if (!editorWasEmpty || !host.editorEmpty())
+                return;
+            if (!(session instanceof AgentSessionImpl) || !session.canUndoAbortedTurn())
+                return;
+            try {
+                const draft = await session.undoAbortedTurn();
+                if (draft === undefined)
+                    return;
+                host.reload();
+                host.setDraft(draft);
+                host.notice("info", `已撤回被中断的消息，${draftNote(draft)}`);
+            }
+            catch (error) {
+                host.notice("error", rewindErrorText(error));
+            }
+        },
+    };
+}

package/dist/modes/interactive/rewind-list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 回滚列表（rewind-plan §4）：居中覆盖层 + `SelectList`。[RW-C]
+ *
+ * - 活动路径上的回滚点，最旧在上、最近在下，缺省选中最后一条；标签是消息首行，说明是相对时间。
+ * - 右侧徽标：没有检查点的行一律「仅对话」；有检查点的只给高亮行算——对它做一次代码 dry-run，
+ *   结果按 entryId 缓存，算好后异步刷新：`N 文件 +x −y` / `无代码改动`，计算中 `…`，失败 `—`。
+ */
+import type { RewindPoint, RewindResult } from "../../checkpoints/types.js";
+import { type SelectItem } from "../../tui.js";
+import { type PickerHost } from "./pickers.js";
+export type PreviewState = {
+    state: "pending";
+} | {
+    state: "done";
+    result: RewindResult;
+} | {
+    state: "error";
+    message: string;
+};
+/** 代码 dry-run 的缓存：每个回滚点最多算一次。 */
+export declare class PreviewCache {
+    private readonly load;
+    private readonly states;
+    private readonly running;
+    constructor(load: (entryId: string) => Promise<RewindResult>);
+    get(entryId: string): PreviewState | undefined;
+    ensure(entryId: string): Promise<PreviewState>;
+}
+/** 列表项：value = 用户消息条目 id。 */
+export declare function rewindListItems(points: readonly RewindPoint[], cache: PreviewCache, highlighted: string | undefined, now: number, ascii?: boolean): SelectItem[];
+export interface RewindListHost extends PickerHost {
+    render(): void;
+    now(): number;
+}
+/** 打开回滚列表；Enter 返回选中的回滚点，Esc 返回 undefined。 */
+export declare function openRewindList(host: RewindListHost, points: readonly RewindPoint[], cache: PreviewCache): Promise<RewindPoint | undefined>;

package/dist/modes/interactive/rewind-list.js

@@ -0,0 +1,123 @@
+/**
+ * 回滚列表（rewind-plan §4）：居中覆盖层 + `SelectList`。[RW-C]
+ *
+ * - 活动路径上的回滚点，最旧在上、最近在下，缺省选中最后一条；标签是消息首行，说明是相对时间。
+ * - 右侧徽标：没有检查点的行一律「仅对话」；有检查点的只给高亮行算——对它做一次代码 dry-run，
+ *   结果按 entryId 缓存，算好后异步刷新：`N 文件 +x −y` / `无代码改动`，计算中 `…`，失败 `—`。
+ */
+import { Box, SelectList } from "../../tui.js";
+import { PICKER_FOOTER } from "./pickers.js";
+import { badgeText, hasCodeChanges, oneLine, rewindErrorText } from "./rewind-text.js";
+import { relativeTime } from "./startup-ui.js";
+/** 代码 dry-run 的缓存：每个回滚点最多算一次。 */
+export class PreviewCache {
+    load;
+    states = new Map();
+    running = new Map();
+    constructor(load) {
+        this.load = load;
+    }
+    get(entryId) {
+        return this.states.get(entryId);
+    }
+    ensure(entryId) {
+        const known = this.states.get(entryId);
+        if (known !== undefined && known.state !== "pending")
+            return Promise.resolve(known);
+        const running = this.running.get(entryId);
+        if (running !== undefined)
+            return running;
+        this.states.set(entryId, { state: "pending" });
+        const promise = this.load(entryId).then((result) => ({ state: "done", result }), (error) => ({ state: "error", message: rewindErrorText(error) }));
+        const settled = promise.then((state) => {
+            this.states.set(entryId, state);
+            this.running.delete(entryId);
+            return state;
+        });
+        this.running.set(entryId, settled);
+        return settled;
+    }
+}
+/** 列表项：value = 用户消息条目 id。 */
+export function rewindListItems(points, cache, highlighted, now, ascii = false) {
+    return points.map((point) => {
+        const text = oneLine(point.text, 60, ascii ? "..." : "…");
+        const item = {
+            value: point.entryId,
+            label: text === "" ? "（空）" : text,
+            description: relativeTime(new Date(point.timestamp).toISOString(), now),
+        };
+        if (!point.hasCheckpoint) {
+            item.badge = "仅对话";
+            item.badgeColor = "dim";
+        }
+        else if (point.entryId === highlighted) {
+            const state = cache.get(point.entryId);
+            if (state === undefined || state.state === "pending") {
+                item.badge = ascii ? "..." : "…";
+                item.badgeColor = "dim";
+            }
+            else if (state.state === "error") {
+                item.badge = ascii ? "-" : "—";
+                item.badgeColor = "dim";
+            }
+            else {
+                const code = state.result.code;
+                item.badge = code === undefined ? "无代码改动" : badgeText(code, ascii);
+                item.badgeColor = hasCodeChanges(code) ? "accent" : "dim";
+            }
+        }
+        return item;
+    });
+}
+/** 打开回滚列表；Enter 返回选中的回滚点，Esc 返回 undefined。 */
+export function openRewindList(host, points, cache) {
+    return new Promise((resolve) => {
+        const ascii = host.theme.glyphs.ascii;
+        let highlighted = points.at(-1)?.entryId;
+        let refreshing = false;
+        let closed = false;
+        const items = () => rewindListItems(points, cache, highlighted, host.now(), ascii);
+        const refresh = () => {
+            if (refreshing || closed)
+                return;
+            refreshing = true;
+            list.setItems(items());
+            refreshing = false;
+            host.render();
+        };
+        const close = (point) => {
+            closed = true;
+            handle.hide();
+            resolve(point);
+        };
+        const highlight = (entryId) => {
+            highlighted = entryId;
+            const point = points.find((p) => p.entryId === entryId);
+            if (point?.hasCheckpoint === true)
+                void cache.ensure(point.entryId).then(refresh);
+            refresh();
+        };
+        const list = new SelectList(items(), {
+            theme: host.theme,
+            maxVisible: 10,
+            filterable: points.length > 8,
+            ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
+            footer: PICKER_FOOTER.replace("↑↓", host.theme.glyphs.arrowUp + host.theme.glyphs.arrowDown),
+            onSelect: (item) => close(points.find((p) => p.entryId === item.value)),
+            onCancel: () => close(undefined),
+            onSelectionChange: (item) => {
+                if (!refreshing && item?.value !== highlighted)
+                    highlight(item?.value);
+            },
+        });
+        if (highlighted !== undefined)
+            list.selectValue(highlighted);
+        const width = Math.max(20, Math.min(host.columns() - 2, 72));
+        const handle = host.showOverlay(new Box(list, { title: "回滚到哪条消息之前", theme: host.theme }), {
+            anchor: "center",
+            width,
+        });
+        highlight(highlighted);
+    });
+}

package/dist/modes/interactive/rewind-panel.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 回滚确认面板（rewind-plan §4）：底部覆盖层，左竖条样式与 `/session` 面板一致（`Card`）。[RW-C]
+ *
+ * - 标题「回滚到这条消息之前」+ 相对时间；消息原文最多 3 行（超出计数）。
+ * - 选项编号列表：恢复代码和对话 / 恢复对话 / 恢复代码（两个代码项只在 dry-run 有改动时出现）/
+ *   从这里摘要 / 摘要到这里 / 取消。每项下一行是预览（「将恢复 N 个文件 +x −y」「代码不变 · 对话将分叉」…）；
+ *   宽 < 56 时只给选中项画预览、去空行。
+ * - 两个摘要项可以在行内输入说明：选中后直接打字，Enter 提交；数字键直接执行（不带说明）；
+ *   有说明时 Esc 先清空说明，再按才关闭。
+ * - 冲突：选了代码类且 dry-run 有冲突 → 进入第二步「跳过冲突文件 / 覆盖冲突文件 / 返回」，
+ *   覆盖对应 `onConflict: "overwrite"`。
+ * - 明细：冲突与无法恢复的文件（各最多 5 个）、git HEAD 变化提示与两条命令（只显示，不执行）。
+ */
+import type { RewindMode, RewindPoint, RewindResult } from "../../checkpoints/types.js";
+import { type Component, type Focusable, type Keybindings, type Theme } from "../../tui.js";
+export type RewindAction = RewindMode | "summarize-from" | "summarize-up-to";
+export interface RewindChoice {
+    action: RewindAction;
+    /** 摘要两项的说明。 */
+    instructions?: string;
+    /** 代码类且有冲突时的选择。 */
+    onConflict?: "skip" | "overwrite";
+}
+export interface RewindPanelModel {
+    point: RewindPoint;
+    /** 代码 dry-run（`mode: "code"`）；没有检查点或预览失败时 undefined。 */
+    preview?: RewindResult;
+    /** 预览失败的说明。 */
+    previewError?: string;
+    now: number;
+}
+export interface RewindOption {
+    action: RewindAction | "cancel";
+    label: string;
+    preview?: string;
+    /** 可在行内输入说明。 */
+    input?: boolean;
+}
+/** 面板的选项（按显示顺序）。 */
+export declare function rewindOptions(model: RewindPanelModel, ascii?: boolean): RewindOption[];
+export interface RewindPanelHost {
+    theme: Theme;
+    keybindings?: Keybindings;
+    /** 终端行数：整面板放不下时改用紧凑排版。 */
+    rows?(): number;
+}
+export declare class RewindPanel implements Component, Focusable {
+    private readonly model;
+    private readonly host;
+    private readonly done;
+    focused: boolean;
+    private selected;
+    private readonly inputs;
+    private stage;
+    /** 终端放不下时：原文 1 行、文件清单并成一行、git 提示去掉说明。 */
+    private tight;
+    readonly options: readonly RewindOption[];
+    constructor(model: RewindPanelModel, host: RewindPanelHost, done: (choice: RewindChoice | undefined) => void);
+    /** 当前选中项（测试用）。 */
+    get selectedOption(): RewindOption;
+    /** 选中项的说明（测试用）。 */
+    inputOf(action: RewindAction): string;
+    private get conflicts();
+    private choose;
+    handleInput(data: string): void;
+    private move;
+    private conflictInput;
+    render(width: number): string[];
+    invalidate(): void;
+    private body;
+    private messageLines;
+    private optionLabel;
+    private optionLine;
+    /** 文件清单：每个一行（最多 5 个）；紧凑时接在 `head` 后面并成一行。 */
+    private fileLines;
+    private detailLines;
+}