@autopilot-agent/cli 0.0.0-stage → 0.1.0

package/dist/tui/hooks/use-file-mention-index.js

@@ -0,0 +1,59 @@
+/**
+ * TUI @文件提及的索引预热：挂载后调用一次 Core `listWorkspaceFiles`，模块级缓存供整个会话复用。
+ * 空查询候选由「工作区一层目录（尾随 /）+ 全部文件」合并稳定排序构成；失败静默降级为空候选。
+ */
+import { useEffect, useState } from "react";
+import { listWorkspaceFiles } from "@autopilot-agent/core";
+let cachedMentionEntries;
+let cachedMentionLoad;
+/** 清空模块级 @ 索引缓存；仅供测试在用例间隔离。 */
+export function resetFileMentionIndexCache() {
+    cachedMentionEntries = undefined;
+    cachedMentionLoad = undefined;
+}
+/** 从文件列表推导空查询候选：一层目录（尾随 /）+ 全部文件，localeCompare 稳定排序。 */
+function buildMentionEntries(files) {
+    const directories = new Set();
+    for (const file of files) {
+        const slashIndex = file.indexOf("/");
+        if (slashIndex > 0)
+            directories.add(`${file.slice(0, slashIndex)}/`);
+    }
+    return [...directories, ...files].sort(function compareEntries(left, right) {
+        return left.localeCompare(right);
+    });
+}
+/** 挂载后预热 @ 文件索引；workspaceRoot 缺失或 Core 枚举失败时静默降级为空候选，不影响普通输入。 */
+export function useFileMentionIndex(workspaceRoot) {
+    const [entries, setEntries] = useState(function readCachedEntries() {
+        return cachedMentionEntries ?? [];
+    });
+    const [ready, setReady] = useState(function readCachedReady() {
+        return cachedMentionEntries !== undefined;
+    });
+    useEffect(function preloadMentionIndex() {
+        if (!workspaceRoot || cachedMentionEntries !== undefined)
+            return;
+        if (!cachedMentionLoad) {
+            cachedMentionLoad = listWorkspaceFiles({ workspaceRoot })
+                .then(function collect(result) {
+                return buildMentionEntries(result.files);
+            })
+                .catch(function degradeOnFailure() {
+                return [];
+            });
+        }
+        let cancelled = false;
+        void cachedMentionLoad.then(function applyLoaded(loaded) {
+            if (cancelled)
+                return;
+            cachedMentionEntries = loaded;
+            setEntries(loaded);
+            setReady(true);
+        });
+        return function cancelPreload() {
+            cancelled = true;
+        };
+    }, [workspaceRoot]);
+    return { entries, ready };
+}

package/dist/tui/hooks/use-pickers.d.ts

@@ -0,0 +1,47 @@
+/** 四 picker（skill/permission/model/effort）及审批/slash 菜单焦点的状态与处理函数。 */
+import type { Key } from "ink";
+import type { CliAction, CliEffortOption, CliModelOption, CliPermissionOption, CliSkillSummary } from "../../types.js";
+import { parseTuiControlAction } from "../input/keys.js";
+/** usePickers 的输入依赖；dispatchAction 与 rawInputSequenceRef 由 app.tsx 注入。 */
+export interface UsePickersInput {
+    dispatchAction: (action: CliAction, prompt?: string, preserveSkillPickerQuery?: boolean) => Promise<void>;
+    rawInputSequenceRef: {
+        current: string;
+    };
+}
+/** 管理四个 picker 与审批/slash 菜单焦点；对外暴露 state、setter 与统一分发入口。 */
+export declare function usePickers(input: UsePickersInput): {
+    skillPickerSkills: CliSkillSummary[] | undefined;
+    skillPickerQuery: string;
+    skillPickerIndex: number;
+    permissionPickerOptions: CliPermissionOption[] | undefined;
+    permissionPickerIndex: number;
+    modelPickerOptions: CliModelOption[] | undefined;
+    modelPickerIndex: number;
+    effortPickerOptions: CliEffortOption[] | undefined;
+    effortPickerIndex: number;
+    approvalPickerIndex: number;
+    slashCommandIndex: number;
+    fileMentionIndex: number;
+    fileMentionDismissedInput: string | undefined;
+    setSkillPickerSkills: import("react").Dispatch<import("react").SetStateAction<CliSkillSummary[] | undefined>>;
+    setPermissionPickerOptions: import("react").Dispatch<import("react").SetStateAction<CliPermissionOption[] | undefined>>;
+    setModelPickerOptions: import("react").Dispatch<import("react").SetStateAction<CliModelOption[] | undefined>>;
+    setEffortPickerOptions: import("react").Dispatch<import("react").SetStateAction<CliEffortOption[] | undefined>>;
+    updateSkillPickerQuery: (query: string) => void;
+    updatePermissionPickerIndex: (index: number) => void;
+    updateModelPickerIndex: (index: number) => void;
+    updateEffortPickerIndex: (index: number) => void;
+    updateApprovalPickerIndex: (index: number) => void;
+    updateSlashCommandIndex: (index: number) => void;
+    updateFileMentionIndex: (index: number) => void;
+    setFileMentionDismissedInput: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+    isPickerActive: boolean;
+    dispatchPickerInput: (value: string, key: Key, controlAction: ReturnType<typeof parseTuiControlAction>) => void;
+    approvalPickerIndexRef: import("react").RefObject<number>;
+    slashCommandIndexRef: import("react").RefObject<number>;
+    fileMentionIndexRef: import("react").RefObject<number>;
+    permissionPickerOptionsRef: import("react").RefObject<CliPermissionOption[] | undefined>;
+    modelPickerOptionsRef: import("react").RefObject<CliModelOption[] | undefined>;
+    effortPickerOptionsRef: import("react").RefObject<CliEffortOption[] | undefined>;
+};

package/dist/tui/hooks/use-pickers.js

@@ -0,0 +1,288 @@
+/** 四 picker（skill/permission/model/effort）及审批/slash 菜单焦点的状态与处理函数。 */
+import { useRef, useState } from "react";
+import { splitTuiInputGraphemes } from "../input/graphemes.js";
+import { resolveTuiDeleteDirection } from "../input/keys.js";
+import { filterTuiSkills } from "../pickers/skill.js";
+/** 管理四个 picker 与审批/slash 菜单焦点；对外暴露 state、setter 与统一分发入口。 */
+export function usePickers(input) {
+    const { dispatchAction, rawInputSequenceRef } = input;
+    const [skillPickerSkills, setSkillPickerSkills] = useState(undefined);
+    const [skillPickerQuery, setSkillPickerQuery] = useState("");
+    const [skillPickerIndex, setSkillPickerIndex] = useState(0);
+    const [permissionPickerOptions, setPermissionPickerOptions] = useState(undefined);
+    const [permissionPickerIndex, setPermissionPickerIndex] = useState(0);
+    const [modelPickerOptions, setModelPickerOptions] = useState(undefined);
+    const [modelPickerIndex, setModelPickerIndex] = useState(0);
+    const [effortPickerOptions, setEffortPickerOptions] = useState(undefined);
+    const [effortPickerIndex, setEffortPickerIndex] = useState(0);
+    const [approvalPickerIndex, setApprovalPickerIndex] = useState(0);
+    const [slashCommandIndex, setSlashCommandIndex] = useState(0);
+    const [fileMentionIndex, setFileMentionIndex] = useState(0);
+    /** Esc 关闭 @ 菜单时记录的完整输入；输入变化后菜单可复活（CC dismissedForInput 模式）。 */
+    const [fileMentionDismissedInput, setFileMentionDismissedInput] = useState(undefined);
+    const skillPickerQueryRef = useRef("");
+    const skillPickerIndexRef = useRef(0);
+    const permissionPickerIndexRef = useRef(0);
+    const permissionPickerOptionsRef = useRef(undefined);
+    const modelPickerIndexRef = useRef(0);
+    const modelPickerOptionsRef = useRef(undefined);
+    const effortPickerIndexRef = useRef(0);
+    const effortPickerOptionsRef = useRef(undefined);
+    const approvalPickerIndexRef = useRef(0);
+    const slashCommandIndexRef = useRef(0);
+    const fileMentionIndexRef = useRef(0);
+    /** 更新 picker 搜索词并回到筛选结果首项。 */
+    function updateSkillPickerQuery(query) {
+        skillPickerQueryRef.current = query;
+        setSkillPickerQuery(query);
+        updateSkillPickerIndex(0);
+    }
+    /** 同步保存 picker 当前行，保证连续方向键和回车不会读取旧 React 状态。 */
+    function updateSkillPickerIndex(index) {
+        skillPickerIndexRef.current = index;
+        setSkillPickerIndex(index);
+    }
+    /** 关闭 picker 并恢复普通单行 prompt。 */
+    function closeSkillPicker() {
+        setSkillPickerSkills(undefined);
+        updateSkillPickerQuery("");
+    }
+    /** 关闭权限 picker 并恢复普通 prompt。 */
+    function closePermissionPicker() {
+        permissionPickerOptionsRef.current = undefined;
+        setPermissionPickerOptions(undefined);
+        updatePermissionPickerIndex(0);
+    }
+    /** 关闭模型 picker 并恢复普通单行 prompt。 */
+    function closeModelPicker() {
+        modelPickerOptionsRef.current = undefined;
+        setModelPickerOptions(undefined);
+        updateModelPickerIndex(0);
+    }
+    /** 同步保存模型 picker 当前焦点，避免连续方向键读取旧 React 状态。 */
+    function updateModelPickerIndex(index) {
+        modelPickerIndexRef.current = index;
+        setModelPickerIndex(index);
+    }
+    /** 关闭 effort picker 并恢复普通单行 prompt。 */
+    function closeEffortPicker() {
+        effortPickerOptionsRef.current = undefined;
+        setEffortPickerOptions(undefined);
+        updateEffortPickerIndex(0);
+    }
+    /** 同步保存 effort picker 当前焦点，避免连续方向键读取旧 React 状态。 */
+    function updateEffortPickerIndex(index) {
+        effortPickerIndexRef.current = index;
+        setEffortPickerIndex(index);
+    }
+    /** 同步保存权限 picker 当前焦点，避免连续方向键读取旧 React 状态。 */
+    function updatePermissionPickerIndex(index) {
+        permissionPickerIndexRef.current = index;
+        setPermissionPickerIndex(index);
+    }
+    /** 同步保存审批菜单当前焦点，保证连续方向键和回车读取同一选择。 */
+    function updateApprovalPickerIndex(index) {
+        approvalPickerIndexRef.current = index;
+        setApprovalPickerIndex(index);
+    }
+    /** 同步保存 slash 菜单当前焦点，避免连续方向键读取旧 React 状态。 */
+    function updateSlashCommandIndex(index) {
+        slashCommandIndexRef.current = index;
+        setSlashCommandIndex(index);
+    }
+    /** 同步保存 @ 菜单当前焦点，避免连续方向键读取旧 React 状态。 */
+    function updateFileMentionIndex(index) {
+        fileMentionIndexRef.current = index;
+        setFileMentionIndex(index);
+    }
+    /** 在 Skill picker 内处理搜索、方向键、空格开关、确认和取消。 */
+    function handleSkillPickerInput(value, key, controlAction) {
+        if (controlAction === "cancel") {
+            closeSkillPicker();
+            return;
+        }
+        const skills = skillPickerSkills ?? [];
+        const filteredSkills = filterTuiSkills(skills, skillPickerQueryRef.current);
+        if (key.upArrow) {
+            updateSkillPickerIndex(Math.max(0, skillPickerIndexRef.current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            updateSkillPickerIndex(Math.min(Math.max(0, filteredSkills.length - 1), skillPickerIndexRef.current + 1));
+            return;
+        }
+        if (key.return) {
+            closeSkillPicker();
+            return;
+        }
+        if (value === " ") {
+            const selectedSkill = filteredSkills[skillPickerIndexRef.current];
+            if (selectedSkill)
+                void dispatchAction({ type: "toggle_skill", skill: selectedSkill.qualifiedName }, undefined, true);
+            return;
+        }
+        const deleteDirection = resolveTuiDeleteDirection(value, key, rawInputSequenceRef.current);
+        if (deleteDirection) {
+            updateSkillPickerQuery(splitTuiInputGraphemes(skillPickerQueryRef.current).slice(0, -1).join(""));
+            return;
+        }
+        if (value === "/" && !skillPickerQueryRef.current)
+            return;
+        if (value && !key.ctrl && !key.meta)
+            updateSkillPickerQuery(skillPickerQueryRef.current + value);
+    }
+    /** 在权限 picker 内移动焦点，回车提交 Session 默认权限，Esc 只关闭界面。 */
+    function handlePermissionPickerInput(value, key, controlAction) {
+        if (controlAction === "cancel") {
+            closePermissionPicker();
+            return;
+        }
+        const options = permissionPickerOptionsRef.current ?? permissionPickerOptions ?? [];
+        if (key.upArrow) {
+            updatePermissionPickerIndex(Math.max(0, permissionPickerIndexRef.current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            updatePermissionPickerIndex(Math.min(Math.max(0, options.length - 1), permissionPickerIndexRef.current + 1));
+            return;
+        }
+        if (value === " ") {
+            const focused = options[permissionPickerIndexRef.current];
+            if (!focused || focused.selected)
+                return;
+            const nextOptions = options.map(function selectPermission(option) {
+                return { ...option, selected: option.mode === focused.mode };
+            });
+            permissionPickerOptionsRef.current = nextOptions;
+            setPermissionPickerOptions(nextOptions);
+            return;
+        }
+        if (key.return) {
+            const selected = options.find(function findEnabledPermission(option) { return option.selected; });
+            closePermissionPicker();
+            if (selected)
+                void dispatchAction({ type: "set_permission_mode", mode: selected.mode });
+        }
+    }
+    /** 在模型 picker 内移动焦点，空格选择模型，回车只更新下一 Turn 的 Session 默认模型。 */
+    function handleModelPickerInput(value, key, controlAction) {
+        if (controlAction === "cancel") {
+            closeModelPicker();
+            return;
+        }
+        const options = modelPickerOptionsRef.current ?? modelPickerOptions ?? [];
+        if (key.upArrow) {
+            updateModelPickerIndex(Math.max(0, modelPickerIndexRef.current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            updateModelPickerIndex(Math.min(Math.max(0, options.length - 1), modelPickerIndexRef.current + 1));
+            return;
+        }
+        if (value === " ") {
+            const focused = options[modelPickerIndexRef.current];
+            if (!focused || focused.selected)
+                return;
+            const nextOptions = options.map(function selectModel(option) {
+                return { ...option, selected: option.provider === focused.provider && option.modelId === focused.modelId };
+            });
+            modelPickerOptionsRef.current = nextOptions;
+            setModelPickerOptions(nextOptions);
+            return;
+        }
+        if (key.return) {
+            const selected = options.find(function findEnabledModel(option) { return option.selected; });
+            closeModelPicker();
+            if (selected)
+                void dispatchAction({ type: "set_model", provider: selected.provider, modelId: selected.modelId });
+        }
+    }
+    /** 在 effort picker 内移动焦点，空格选择推理强度，回车只更新下一 Turn 的 Session 默认推理强度。 */
+    function handleEffortPickerInput(value, key, controlAction) {
+        if (controlAction === "cancel") {
+            closeEffortPicker();
+            return;
+        }
+        const options = effortPickerOptionsRef.current ?? effortPickerOptions ?? [];
+        if (key.upArrow) {
+            updateEffortPickerIndex(Math.max(0, effortPickerIndexRef.current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            updateEffortPickerIndex(Math.min(Math.max(0, options.length - 1), effortPickerIndexRef.current + 1));
+            return;
+        }
+        if (value === " ") {
+            const focused = options[effortPickerIndexRef.current];
+            if (!focused || focused.selected)
+                return;
+            const nextOptions = options.map(function selectEffort(option) {
+                return { ...option, selected: option.effort === focused.effort };
+            });
+            effortPickerOptionsRef.current = nextOptions;
+            setEffortPickerOptions(nextOptions);
+            return;
+        }
+        if (key.return) {
+            const selected = options.find(function findEnabledEffort(option) { return option.selected; });
+            closeEffortPicker();
+            if (selected)
+                void dispatchAction({ type: "set_effort", effort: selected.effort });
+        }
+    }
+    const isPickerActive = permissionPickerOptions !== undefined || modelPickerOptions !== undefined || effortPickerOptions !== undefined || skillPickerSkills !== undefined;
+    /** 按激活的 picker 分发按键；无激活 picker 时由 handleInput 继续处理普通输入。 */
+    function dispatchPickerInput(value, key, controlAction) {
+        if (permissionPickerOptions) {
+            handlePermissionPickerInput(value, key, controlAction);
+            return;
+        }
+        if (modelPickerOptions) {
+            handleModelPickerInput(value, key, controlAction);
+            return;
+        }
+        if (effortPickerOptions) {
+            handleEffortPickerInput(value, key, controlAction);
+            return;
+        }
+        if (skillPickerSkills) {
+            handleSkillPickerInput(value, key, controlAction);
+            return;
+        }
+    }
+    return {
+        skillPickerSkills,
+        skillPickerQuery,
+        skillPickerIndex,
+        permissionPickerOptions,
+        permissionPickerIndex,
+        modelPickerOptions,
+        modelPickerIndex,
+        effortPickerOptions,
+        effortPickerIndex,
+        approvalPickerIndex,
+        slashCommandIndex,
+        fileMentionIndex,
+        fileMentionDismissedInput,
+        setSkillPickerSkills,
+        setPermissionPickerOptions,
+        setModelPickerOptions,
+        setEffortPickerOptions,
+        updateSkillPickerQuery,
+        updatePermissionPickerIndex,
+        updateModelPickerIndex,
+        updateEffortPickerIndex,
+        updateApprovalPickerIndex,
+        updateSlashCommandIndex,
+        updateFileMentionIndex,
+        setFileMentionDismissedInput,
+        isPickerActive,
+        dispatchPickerInput,
+        approvalPickerIndexRef,
+        slashCommandIndexRef,
+        fileMentionIndexRef,
+        permissionPickerOptionsRef,
+        modelPickerOptionsRef,
+        effortPickerOptionsRef,
+    };
+}

package/dist/tui/hooks/use-prompt-input.d.ts

@@ -0,0 +1,54 @@
+/** prompt 输入状态与 handleInput：字符串/光标/历史维护与按键分发。 */
+import type { Key } from "ink";
+import type { CliAction, CliSlashCommand } from "../../types.js";
+import { parseTuiControlAction } from "../input/keys.js";
+import type { CliTuiStore } from "../types.js";
+/** usePromptInput 的运行依赖；派生值（slash 建议、视口按键）由 app.tsx 通过 ref 注入。 */
+export interface UsePromptInputInput {
+    store: CliTuiStore;
+    columns: number;
+    busy: {
+        current: boolean;
+    };
+    keepOpenAfterCancel: {
+        current: boolean;
+    };
+    lastSubmittedPromptRef: {
+        current: string | undefined;
+    };
+    rawInputSequenceRef: {
+        current: string;
+    };
+    dispatchAction: (action: CliAction, prompt?: string, preserveSkillPickerQuery?: boolean) => Promise<void>;
+    onEof: () => void;
+    onRequestInterrupt: () => void;
+    onRequestCancel: () => void;
+    isPickerActive: boolean;
+    dispatchPickerInput: (value: string, key: Key, controlAction: ReturnType<typeof parseTuiControlAction>) => void;
+    approvalPickerIndexRef: {
+        current: number;
+    };
+    updateApprovalPickerIndex: (index: number) => void;
+    slashCommandIndexRef: {
+        current: number;
+    };
+    updateSlashCommandIndex: (index: number) => void;
+    fileMentionIndexRef: {
+        current: number;
+    };
+    updateFileMentionIndex: (index: number) => void;
+    setFileMentionDismissedInput: (input: string | undefined) => void;
+    derivedRef: {
+        current: {
+            slashCommandSuggestions: CliSlashCommand[];
+            fileMentionSuggestions: string[];
+            handleTuiViewportKey: (key: Key) => boolean;
+        };
+    };
+}
+/** 管理 prompt 输入状态、历史与按键分发，并暴露 handleInput 供 Ink 的 useInput 使用。 */
+export declare function usePromptInput(input: UsePromptInputInput): {
+    input: string;
+    cursorIndex: number;
+    handleInput: (value: string, key: Key) => void;
+};