@armadra/agent 0.0.0-stage → 0.2.1

package/dist/modes/interactive/approval-dialog.js

@@ -0,0 +1,202 @@
+/**
+ * 审批对话框（设计 §12.6）：模式层的 UI `ApprovalBroker`，底部覆盖层。[B7]
+ *
+ * - 标题行：`[task]`（`request.context.depth > 0`，子 Agent 发起）+ 工具名 + 原因标签；
+ * - 输入：bash 显示命令全文，write 显示路径与行数，edit 显示路径与每处修改的 −/+ 摘要，其它显示
+ *   一行摘要；`v` 展开 / 收起完整输入（JSON）；
+ * - 执行前预览（W3-B9a-2，`request.preview`）：输入摘要之后列出会碰到的路径与规模，danger 红、
+ *   warn 黄、info 暗色；`other` 类预览与输入摘要重复，不显示；
+ * - 原因：mode（当前权限模式需要确认）/ dangerous / hook + Hook 给的文本；
+ * - 按键：`y` 允许、`n` / Esc / Ctrl+C 拒绝、`a` 本会话允许同类；
+ * - 超时与中断：broker 链在超时（缺省 10 分钟）或运行被中断时 abort `signal`，对话框关闭并返回
+ *   undefined（链按 deny 处理），消息区留一行说明。
+ *
+ * broker 链本身串行化审批，所以同一时刻最多一个对话框。
+ */
+import { previewDisplayLines } from "../../permissions/preview.js";
+import { Box, Container, Text, defaultKeybindings, matchesKey, truncateToWidth, } from "../../tui.js";
+import { toolSummary } from "./tool-view.js";
+const COMMAND_LINES = 8;
+const EDIT_LINES = 3;
+const FULL_INPUT_LINES = 40;
+function lines(text, max) {
+    const all = text.replace(/\r\n?/g, "\n").replace(/\t/g, "    ").split("\n");
+    while (all.length > 1 && all[all.length - 1].trim() === "")
+        all.pop();
+    return { shown: all.slice(0, max), hidden: Math.max(0, all.length - max) };
+}
+function record(input) {
+    return typeof input === "object" && input !== null ? input : {};
+}
+/** 对话框正文（不含按键行）。 */
+export function describeRequest(request, theme, options = {}) {
+    const out = [];
+    const task = (request.context?.depth ?? 0) > 0 ? theme.fg("warning", "[task] ") : "";
+    const tag = request.reason === "dangerous"
+        ? theme.fg("error", "危险命令")
+        : request.reason === "hook"
+            ? theme.fg("warning", "Hook 要求确认")
+            : theme.fg("dim", "需要确认");
+    out.push(`${task}${theme.bold(theme.fg("tool", request.toolName))}  ${tag}`);
+    const input = record(request.input);
+    const more = (n) => theme.fg("dim", `… 另 ${n} 行（v 查看）`);
+    if (options.expanded === true) {
+        const json = JSON.stringify(request.input, null, 2) ?? String(request.input);
+        const { shown, hidden } = lines(json, FULL_INPUT_LINES);
+        out.push(...shown.map((l) => theme.fg("code", l)));
+        if (hidden > 0)
+            out.push(theme.fg("dim", `… 另 ${hidden} 行`));
+    }
+    else if (request.toolName === "bash" && typeof input["command"] === "string") {
+        const { shown, hidden } = lines(input["command"], COMMAND_LINES);
+        out.push(...shown.map((l, i) => theme.fg("code", (i === 0 ? "$ " : "  ") + l)));
+        if (hidden > 0)
+            out.push(more(hidden));
+    }
+    else if (request.toolName === "write" && typeof input["content"] === "string") {
+        const count = lines(input["content"], Number.MAX_SAFE_INTEGER).shown.length;
+        out.push(`${toolSummary("write", input, options.cwd)}  ${theme.fg("dim", `写入 ${count} 行`)}`);
+    }
+    else if (request.toolName === "edit" && Array.isArray(input["edits"])) {
+        const edits = input["edits"];
+        out.push(`${toolSummary("edit", input, options.cwd)}  ${theme.fg("dim", `${edits.length} 处修改`)}`);
+        for (const edit of edits.slice(0, 2)) {
+            for (const [sign, text, color] of [
+                ["-", edit.oldText, "error"],
+                ["+", edit.newText, "success"],
+            ]) {
+                if (typeof text !== "string")
+                    continue;
+                const { shown, hidden } = lines(text, EDIT_LINES);
+                out.push(...shown.map((l) => theme.fg(color, `${sign} ${l}`)));
+                if (hidden > 0)
+                    out.push(more(hidden));
+            }
+        }
+        if (edits.length > 2)
+            out.push(theme.fg("dim", `… 另 ${edits.length - 2} 处`));
+    }
+    else {
+        const summary = toolSummary(request.toolName, input, options.cwd);
+        if (summary !== "")
+            out.push(summary);
+    }
+    const severity = request.preview?.severity;
+    const color = severity === "danger" ? "error" : severity === "warn" ? "warning" : "dim";
+    out.push(...previewDisplayLines(request.preview).map((l) => theme.fg(color, l)));
+    if (request.reason === "hook") {
+        out.push(theme.fg("warning", `Hook：${request.hookReason ?? "（无说明）"}`));
+    }
+    else if (request.reason === "dangerous") {
+        out.push(theme.fg("error", "这条命令可能有破坏性，请确认"));
+    }
+    else if (options.permissionMode !== undefined) {
+        out.push(theme.fg("dim", `权限模式 ${options.permissionMode} 下需要确认`));
+    }
+    return out;
+}
+export const APPROVAL_KEYS_HINT = "[y] 允许  [n] 拒绝  [a] 本会话允许同类  [v] 完整输入";
+class ApprovalDialog {
+    request;
+    host;
+    decide;
+    focused = false;
+    expanded = false;
+    body = new Container();
+    constructor(request, host, decide) {
+        this.request = request;
+        this.host = host;
+        this.decide = decide;
+        this.rebuild();
+    }
+    rebuild() {
+        const { theme } = this.host;
+        this.body.clear();
+        const options = {
+            permissionMode: this.host.permissionMode(),
+            expanded: this.expanded,
+        };
+        if (this.host.cwd !== undefined)
+            options.cwd = this.host.cwd;
+        this.body.addChild(new Text(describeRequest(this.request, theme, options).join("\n")));
+        this.body.addChild(new Text(theme.fg("accent", APPROVAL_KEYS_HINT)));
+    }
+    handleInput(data) {
+        const keys = this.host.keybindings ?? defaultKeybindings;
+        const key = data.length === 1 ? data.toLowerCase() : "";
+        if (key === "y")
+            this.decide("allow");
+        else if (key === "a")
+            this.decide("allow_session");
+        else if (key === "n" ||
+            matchesKey(data, "escape") ||
+            keys.matches(data, "app.clear") ||
+            keys.matches(data, "tui.select.cancel")) {
+            this.decide("deny");
+        }
+        else if (key === "v") {
+            this.expanded = !this.expanded;
+            this.rebuild();
+        }
+    }
+    render(width) {
+        return this.body.render(width).map((l) => truncateToWidth(l, width));
+    }
+    invalidate() {
+        this.body.invalidate();
+    }
+}
+/** UI broker：每个请求开一个底部覆盖层，等用户按键或 signal abort。 */
+export class ApprovalDialogBroker {
+    host;
+    open = 0;
+    constructor(host) {
+        this.host = host;
+    }
+    get isOpen() {
+        return this.open > 0;
+    }
+    ask(request, signal) {
+        if (signal.aborted)
+            return Promise.resolve(undefined);
+        return new Promise((resolve) => {
+            let handle;
+            let settled = false;
+            const settle = (decision) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener("abort", onAbort);
+                handle?.hide();
+                this.open--;
+                this.host.onClose?.();
+                this.host.report?.(request, decision ?? "cancelled");
+                resolve(decision);
+            };
+            const onAbort = () => settle(undefined);
+            const dialog = new ApprovalDialog(request, this.host, settle);
+            this.open++;
+            this.host.onOpen?.();
+            handle = this.host.showOverlay(new Box(dialog, {
+                title: (request.context?.depth ?? 0) > 0 ? "子任务审批" : "审批",
+                theme: this.host.theme,
+            }));
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}
+/** 结果的一行说明（消息区）。 */
+export function approvalOutcomeText(request, outcome) {
+    const task = (request.context?.depth ?? 0) > 0 ? "[task] " : "";
+    const what = `${task}${request.toolName}`;
+    switch (outcome) {
+        case "allow":
+            return `已允许 ${what}`;
+        case "allow_session":
+            return `已允许 ${what}（本会话同类不再询问）`;
+        case "deny":
+            return `已拒绝 ${what}`;
+        case "cancelled":
+            return `审批已取消（超时或中断）：${what}`;
+    }
+}

package/dist/modes/interactive/commands.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 交互模式的斜杠命令：把 commands-core 的 `CommandResult` 变成界面动作。[B7]
+ *
+ * - `handled` → 消息区显示文本；`prompt` → 发提示；`exit` → 退出；
+ * - `pick` → 打开对应选择器：模型（setModel）、会话（resume）、树（/fork 无参数：从选中的用户消息
+ *   之前分叉，消息文本回填编辑器）、权限模式、思考级别；
+ * - 交互模式自有命令：`/tree`（同一文件内换叶子到选中消息之前，文本回填编辑器，可改后重发形成新分支）、
+ *   `/permissions`（当前模式、判定顺序与已加载规则）；`/help` 追加这两条与按键说明。
+ * - 不是命令（含模板与 `/skill:`）返回 false，调用方把整行当提示发出。
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { SwitchRequest } from "../../cli/compose-session.js";
+import type { Runtime } from "../../cli/runtime.js";
+import type { SelectItem } from "../../tui.js";
+import { type CommandInfo } from "../commands-core.js";
+import { type NoticeLevel } from "./message-view.js";
+import { type PickerSpec } from "./pickers.js";
+export declare const INTERACTIVE_COMMANDS: readonly CommandInfo[];
+/** 补全与 /help 用的完整命令表。 */
+export declare const ALL_COMMANDS: readonly CommandInfo[];
+export declare const KEY_HINTS: string;
+export interface CommandUi {
+    readonly runtime: Runtime;
+    session(): AgentSession;
+    /** 切换会话（调用方负责重新订阅、重画消息区、announceStart）。 */
+    switchSession(request: SwitchRequest): Promise<AgentSession>;
+    pick(spec: PickerSpec): Promise<SelectItem | undefined>;
+    notice(level: NoticeLevel, text: string): void;
+    setEditorText(text: string): void;
+    /** 发一条提示（不等运行结束）。 */
+    prompt(text: string): void;
+    /** /tree 换叶子后重画消息区。 */
+    reload(): void;
+    exit(code: number): void;
+    now(): number;
+}
+/** 当前分支上的条目 id（树选择器标 ●）。 */
+export declare function activeBranchIds(session: AgentSession): Set<string>;
+export declare function permissionsText(runtime: Runtime, session: AgentSession): string;
+/** 返回 false：不是命令，调用方当作提示发出。 */
+export declare function runInteractiveCommand(line: string, ui: CommandUi): Promise<boolean>;

package/dist/modes/interactive/commands.js

@@ -0,0 +1,202 @@
+/**
+ * 交互模式的斜杠命令：把 commands-core 的 `CommandResult` 变成界面动作。[B7]
+ *
+ * - `handled` → 消息区显示文本；`prompt` → 发提示；`exit` → 退出；
+ * - `pick` → 打开对应选择器：模型（setModel）、会话（resume）、树（/fork 无参数：从选中的用户消息
+ *   之前分叉，消息文本回填编辑器）、权限模式、思考级别；
+ * - 交互模式自有命令：`/tree`（同一文件内换叶子到选中消息之前，文本回填编辑器，可改后重发形成新分支）、
+ *   `/permissions`（当前模式、判定顺序与已加载规则）；`/help` 追加这两条与按键说明。
+ * - 不是命令（含模板与 `/skill:`）返回 false，调用方把整行当提示发出。
+ */
+import { AgentSessionImpl } from "../../agent/session.js";
+import { listSessions } from "../../cli/compose-store.js";
+import { BUILTIN_COMMANDS, parseSlash, runSlashCommand, } from "../commands-core.js";
+import { contentText } from "./message-view.js";
+import { modelItems, permissionItems, sessionItems, thinkingItems, treeItems, } from "./pickers.js";
+export const INTERACTIVE_COMMANDS = [
+    { name: "tree", description: "浏览会话树，回到某条消息之前重写" },
+    { name: "permissions", description: "权限模式、判定顺序与规则" },
+];
+/** 补全与 /help 用的完整命令表。 */
+export const ALL_COMMANDS = [...BUILTIN_COMMANDS, ...INTERACTIVE_COMMANDS];
+export const KEY_HINTS = [
+    "Enter 发送（运行中 = steer）  Alt+Enter 排到本轮之后  Shift+Enter / Ctrl+J 换行",
+    "Esc 中断（排队消息回填编辑器）  Alt+↑ 取回最后一条排队消息",
+    "Shift+Tab 切换权限模式  Ctrl+L 模型  Ctrl+T 思考级别  Ctrl+O 展开工具输出",
+    "Ctrl+C 清空输入（再按退出）  Ctrl+D 空输入时退出  Tab 补全  @ 引用文件",
+].join("\n");
+function userEntryText(entry) {
+    if (entry?.type !== "message" || entry.message.role !== "user")
+        return undefined;
+    return contentText(entry.message.content);
+}
+/** 当前分支上的条目 id（树选择器标 ●）。 */
+export function activeBranchIds(session) {
+    if (session instanceof AgentSessionImpl)
+        return new Set(session.manager.branch().map((e) => e.id));
+    return new Set(session.entries.map((e) => e.id));
+}
+export function permissionsText(runtime, session) {
+    const rules = runtime.permission.rules;
+    const lines = [
+        `权限模式：${session.state.permissionMode}`,
+        "判定顺序：deny 规则 → Hook deny → 危险命令确认 → 权限模式 → allow 规则 / Hook allow / 本会话记忆 → 询问",
+        rules.length === 0 ? "规则：（无）" : `规则（${rules.length}）：`,
+        ...rules.map((r) => `  ${r.effect === "deny" ? "deny " : "allow"}  ${r.raw}  [${r.source}]`),
+    ];
+    return lines.join("\n");
+}
+async function pickTree(ui, title) {
+    const session = ui.session();
+    const items = treeItems(session.entries, activeBranchIds(session), ui.now());
+    if (items.length === 0) {
+        ui.notice("info", "还没有用户消息");
+        return undefined;
+    }
+    const active = [...items].reverse().find((i) => i.label.includes("● "));
+    const picked = await ui.pick({
+        title,
+        items,
+        filterable: true,
+        ...(active !== undefined ? { selected: active.value } : {}),
+    });
+    return picked === undefined ? undefined : session.entries.find((e) => e.id === picked.value);
+}
+/** /tree：换叶子到选中用户消息之前，文本回填编辑器。 */
+async function treeCommand(ui) {
+    const session = ui.session();
+    if (!(session instanceof AgentSessionImpl)) {
+        ui.notice("warn", "当前会话不支持 /tree");
+        return;
+    }
+    if (session.state.isStreaming) {
+        ui.notice("warn", "运行中不能切换分支（先 Esc 中断）");
+        return;
+    }
+    const entry = await pickTree(ui, "会话树");
+    if (entry === undefined)
+        return;
+    await session.navigate(entry.parentId);
+    ui.reload();
+    ui.setEditorText(userEntryText(entry) ?? "");
+}
+async function handlePick(what, ui) {
+    const session = ui.session();
+    switch (what) {
+        case "model": {
+            const current = session.state.model;
+            const picked = await ui.pick({
+                title: "选择模型",
+                items: await modelItems(ui.runtime.providers),
+                filterable: true,
+                ...(current !== undefined ? { selected: `${current.provider}/${current.id}` } : {}),
+            });
+            if (picked === undefined)
+                return;
+            await session.setModel(picked.value);
+            ui.notice("info", `模型：${picked.value}`);
+            return;
+        }
+        case "session": {
+            const items = listSessions({
+                sessionDir: ui.runtime.paths.sessionDir,
+                cwd: session.state.cwd,
+            });
+            const others = items.filter((i) => i.id !== session.state.sessionId);
+            if (others.length === 0) {
+                ui.notice("info", "本目录没有其它会话");
+                return;
+            }
+            const picked = await ui.pick({
+                title: "恢复会话",
+                items: sessionItems(others, ui.now()),
+                filterable: true,
+            });
+            if (picked === undefined)
+                return;
+            const next = await ui.switchSession({ kind: "resume", id: picked.value });
+            ui.notice("info", `已恢复会话 ${next.state.sessionId.slice(0, 8)}`);
+            return;
+        }
+        case "tree": {
+            const entry = await pickTree(ui, "从哪条消息之前分叉");
+            if (entry === undefined)
+                return;
+            const next = await ui.switchSession(entry.parentId === null ? { kind: "new" } : { kind: "fork", entryId: entry.parentId });
+            ui.notice("info", `已分叉到新会话 ${next.state.sessionId.slice(0, 8)}`);
+            ui.setEditorText(userEntryText(entry) ?? "");
+            return;
+        }
+        case "permission": {
+            const picked = await ui.pick({
+                title: "权限模式",
+                items: permissionItems(),
+                selected: session.state.permissionMode,
+            });
+            if (picked !== undefined)
+                session.setPermissionMode(picked.value);
+            return;
+        }
+        case "thinking": {
+            const model = session.state.model;
+            const found = model === undefined
+                ? undefined
+                : ui.runtime.providers.findModel(`${model.provider}/${model.id}`);
+            const reasoning = found?.ok === true ? found.model.reasoning : true;
+            const picked = await ui.pick({
+                title: "思考级别",
+                items: thinkingItems(reasoning),
+                selected: session.state.thinkingLevel,
+            });
+            if (picked !== undefined)
+                session.setThinkingLevel(picked.value);
+            return;
+        }
+    }
+}
+/** 返回 false：不是命令，调用方当作提示发出。 */
+export async function runInteractiveCommand(line, ui) {
+    const parsed = parseSlash(line);
+    if (parsed === undefined)
+        return false;
+    try {
+        if (parsed.name === "tree") {
+            await treeCommand(ui);
+            return true;
+        }
+        if (parsed.name === "permissions") {
+            ui.notice("info", permissionsText(ui.runtime, ui.session()));
+            return true;
+        }
+        const result = await runSlashCommand(line, {
+            runtime: ui.runtime,
+            session: () => ui.session(),
+            switchSession: (request) => ui.switchSession(request),
+        });
+        if (result === undefined)
+            return false;
+        switch (result.kind) {
+            case "exit":
+                ui.exit(0);
+                break;
+            case "prompt":
+                ui.prompt(result.text);
+                break;
+            case "pick":
+                await handlePick(result.what, ui);
+                break;
+            case "handled":
+                if (parsed.name === "help") {
+                    const extra = INTERACTIVE_COMMANDS.map((c) => `/${c.name}  ${c.description}`);
+                    ui.notice("info", [result.message ?? "", ...extra, "", KEY_HINTS].join("\n"));
+                }
+                else if (result.message !== undefined)
+                    ui.notice("info", result.message);
+                break;
+        }
+    }
+    catch (error) {
+        ui.notice("error", error instanceof Error ? error.message : String(error));
+    }
+    return true;
+}

package/dist/modes/interactive/completion.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 编辑器补全（设计 §12.4）。[B7]
+ *
+ * - 首行行首 `/`：内置命令（commands-core 的表 + 交互模式自有命令）、提示模板 `/<名字>`、
+ *   Skill `/skill:<名字>`；名字前缀匹配排前，其次子串匹配。
+ * - `@` 文件（行首或空白之后）：遍历会话 cwd（尊重 .gitignore，复用 tools/ignore.ts 的 walk），
+ *   最多 50 项；查询含 glob 字符时按 glob（tools/glob.ts）匹配相对路径，否则按「文件名前缀 → 路径前缀 →
+ *   文件名子串 → 路径子串」排序。目录以 `/` 结尾，可继续补全。文件表按 cwd 缓存 15 秒、最多 20 000 项。
+ */
+import type { AutocompleteContext, AutocompleteItem, AutocompleteProvider, AutocompleteResult } from "../../tui.js";
+export declare const MAX_FILE_ITEMS = 50;
+export declare const MAX_FILE_INDEX = 20000;
+export declare const FILE_INDEX_TTL_MS = 15000;
+export interface CompletionCommand {
+    name: string;
+    args?: string;
+    description: string;
+}
+export interface CompletionSource {
+    commands(): readonly CompletionCommand[];
+    prompts(): readonly {
+        name: string;
+    }[];
+    skills(): readonly {
+        name: string;
+        description: string;
+    }[];
+    cwd(): string;
+    now?(): number;
+}
+interface FileIndex {
+    cwd: string;
+    at: number;
+    entries: {
+        rel: string;
+        isDir: boolean;
+    }[];
+}
+/** 文件匹配排序：0 文件名前缀 / 1 路径前缀 / 2 文件名子串 / 3 路径子串。 */
+export declare function fileScore(rel: string, query: string): number | undefined;
+export declare class InteractiveCompletion implements AutocompleteProvider {
+    private readonly source;
+    private index;
+    private loading;
+    constructor(source: CompletionSource);
+    getSuggestions(context: AutocompleteContext): AutocompleteResult | null | Promise<AutocompleteResult | null>;
+    private slash;
+    private now;
+    /** 文件表（缓存）；并发请求共用一次遍历。 */
+    fileIndex(): Promise<FileIndex>;
+    files(query: string): Promise<AutocompleteItem[]>;
+}
+export {};

package/dist/modes/interactive/completion.js

@@ -0,0 +1,157 @@
+/**
+ * 编辑器补全（设计 §12.4）。[B7]
+ *
+ * - 首行行首 `/`：内置命令（commands-core 的表 + 交互模式自有命令）、提示模板 `/<名字>`、
+ *   Skill `/skill:<名字>`；名字前缀匹配排前，其次子串匹配。
+ * - `@` 文件（行首或空白之后）：遍历会话 cwd（尊重 .gitignore，复用 tools/ignore.ts 的 walk），
+ *   最多 50 项；查询含 glob 字符时按 glob（tools/glob.ts）匹配相对路径，否则按「文件名前缀 → 路径前缀 →
+ *   文件名子串 → 路径子串」排序。目录以 `/` 结尾，可继续补全。文件表按 cwd 缓存 15 秒、最多 20 000 项。
+ */
+import { GlobMatcher } from "../../tools/glob.js";
+import { walk } from "../../tools/ignore.js";
+export const MAX_FILE_ITEMS = 50;
+export const MAX_FILE_INDEX = 20_000;
+export const FILE_INDEX_TTL_MS = 15_000;
+const GLOB_CHARS = /[*?[{]/;
+function rank(name, query) {
+    const lower = name.toLowerCase();
+    const q = query.toLowerCase();
+    if (lower.startsWith(q))
+        return 0;
+    if (lower.includes(q))
+        return 1;
+    return undefined;
+}
+function basename(rel) {
+    const trimmed = rel.endsWith("/") ? rel.slice(0, -1) : rel;
+    const at = trimmed.lastIndexOf("/");
+    return at === -1 ? trimmed : trimmed.slice(at + 1);
+}
+/** 文件匹配排序：0 文件名前缀 / 1 路径前缀 / 2 文件名子串 / 3 路径子串。 */
+export function fileScore(rel, query) {
+    if (query === "")
+        return 0;
+    const q = query.toLowerCase();
+    const base = basename(rel).toLowerCase();
+    const path = rel.toLowerCase();
+    if (base.startsWith(q))
+        return 0;
+    if (path.startsWith(q))
+        return 1;
+    if (base.includes(q))
+        return 2;
+    if (path.includes(q))
+        return 3;
+    return undefined;
+}
+export class InteractiveCompletion {
+    source;
+    index;
+    loading;
+    constructor(source) {
+        this.source = source;
+    }
+    getSuggestions(context) {
+        const before = context.textBeforeCursor;
+        const firstLine = context.text.startsWith(context.line);
+        const slash = /^\/(\S*)$/.exec(before);
+        if (slash !== null && firstLine)
+            return this.slash(slash[1] ?? "");
+        const at = /(?:^|\s)@(\S*)$/.exec(before);
+        if (at !== null) {
+            const query = at[1] ?? "";
+            return this.files(query).then((items) => items.length === 0 ? null : { items, from: before.length - query.length - 1 });
+        }
+        return null;
+    }
+    slash(query) {
+        const ranked = [];
+        const push = (value, description, key) => {
+            const score = rank(key, query);
+            if (score === undefined)
+                return;
+            ranked.push({
+                item: { value: `/${value}`, label: `/${value}`, description },
+                score,
+                order: ranked.length,
+            });
+        };
+        for (const command of this.source.commands()) {
+            push(command.name, command.args !== undefined
+                ? `${command.args}  ${command.description}`
+                : command.description, command.name);
+        }
+        for (const prompt of this.source.prompts())
+            push(prompt.name, "提示模板", prompt.name);
+        for (const skill of this.source.skills()) {
+            push(`skill:${skill.name}`, skill.description, `skill:${skill.name}`);
+        }
+        if (ranked.length === 0)
+            return null;
+        ranked.sort((a, b) => a.score - b.score || a.order - b.order);
+        return { items: ranked.slice(0, MAX_FILE_ITEMS).map((r) => r.item), from: 0 };
+    }
+    now() {
+        return this.source.now?.() ?? Date.now();
+    }
+    /** 文件表（缓存）；并发请求共用一次遍历。 */
+    async fileIndex() {
+        const cwd = this.source.cwd();
+        const cached = this.index;
+        if (cached !== undefined && cached.cwd === cwd && this.now() - cached.at < FILE_INDEX_TTL_MS) {
+            return cached;
+        }
+        this.loading ??= (async () => {
+            const entries = [];
+            const controller = new AbortController();
+            try {
+                for await (const entry of walk(cwd, { signal: controller.signal })) {
+                    entries.push({ rel: entry.isDir ? `${entry.rel}/` : entry.rel, isDir: entry.isDir });
+                    if (entries.length >= MAX_FILE_INDEX) {
+                        controller.abort();
+                        break;
+                    }
+                }
+            }
+            catch {
+                // 遍历出错（权限等）：用已收集到的部分
+            }
+            const index = { cwd, at: this.now(), entries };
+            this.index = index;
+            return index;
+        })().finally(() => {
+            this.loading = undefined;
+        });
+        return this.loading;
+    }
+    async files(query) {
+        const { entries } = await this.fileIndex();
+        let matched;
+        if (GLOB_CHARS.test(query)) {
+            let matcher;
+            try {
+                matcher = new GlobMatcher(query);
+            }
+            catch {
+                return [];
+            }
+            matched = entries
+                .filter((e) => !e.isDir && matcher.matches(e.rel))
+                .map((e) => ({ rel: e.rel, score: 0 }));
+        }
+        else {
+            matched = [];
+            for (const entry of entries) {
+                const score = fileScore(entry.rel, query);
+                if (score !== undefined)
+                    matched.push({ rel: entry.rel, score });
+            }
+        }
+        const depth = (rel) => rel.split("/").filter(Boolean).length;
+        matched.sort((a, b) => a.score - b.score ||
+            depth(a.rel) - depth(b.rel) ||
+            a.rel.length - b.rel.length ||
+            a.rel.localeCompare(b.rel));
+        return matched.slice(0, MAX_FILE_ITEMS).map((m) => ({ value: `@${m.rel}`, label: m.rel }));
+    }
+}