minimal-agent 0.1.9 → 0.3.0

package/src/ui/Root.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ============================================================
+ *  src/ui/Root.tsx —— TUI 顶层 phase 切换器
+ * ------------------------------------------------------------
+ *  作为 Ink 渲染树的根节点，根据"有没有 Provider 配置"决定渲染：
+ *    - 没有 → <ConfigWizard>：用户填完 + 测试通过后切到 App
+ *    - 有 → <App>：常规对话界面
+ *
+ *  为什么需要这一层而不是直接在 main.tsx 二选一渲染？
+ *    向导成功后必须直接进 App，不能让用户手动重跑命令。在 React 树里用 state
+ *    切换是最自然的方式，无需 ink unmount/remount 的额外开销。
+ *
+ *  initialHistory 的构造（buildFullSystemPrompt + 历史持久化加载）在向导后才跑，
+ *  因为：
+ *    - 系统提示词本身不依赖 provider，但流程上推迟到"确定要进 App"那一刻
+ *      最干净。
+ *    - 第一次启动时常常没历史可加载，buildInitialHistory 行为是只返 system
+ *      prompt，开销可忽略。
+ * ============================================================
+ */
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { getWorkingDir } from '../bootstrap/workingDir.js';
+import { ConfigWizard } from '../cli/configWizard.js';
+import { loadContext } from '../context/persistContext.js';
+import { buildFullSystemPrompt } from '../prompts/system.js';
+import { ALL_TOOLS } from '../tools/index.js';
+import { App } from './App.js';
+export function Root({ initialProvider }) {
+    const [phase, setPhase] = useState(initialProvider
+        ? { kind: 'loading-history', provider: initialProvider }
+        : { kind: 'wizard' });
+    useEffect(() => {
+        if (phase.kind !== 'loading-history')
+            return;
+        let cancelled = false;
+        void (async () => {
+            const history = await buildInitialHistory();
+            if (cancelled)
+                return;
+            setPhase({ kind: 'app', provider: phase.provider, initialHistory: history });
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [phase]);
+    if (phase.kind === 'wizard') {
+        return (_jsx(ConfigWizard, { onSuccess: (provider) => {
+                setPhase({ kind: 'loading-history', provider });
+            } }));
+    }
+    if (phase.kind === 'loading-history') {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "gray", children: "\u6B63\u5728\u52A0\u8F7D\u5386\u53F2\u4E0A\u4E0B\u6587..." }) }));
+    }
+    return _jsx(App, { provider: phase.provider, initialHistory: phase.initialHistory });
+}
+/**
+ * 复用 main.tsx 的逻辑：fresh system prompt + 上次未关闭的对话。
+ * 这里独立一份是为了让 Root 内部能在向导成功后即时构造，不必返工 main.tsx。
+ */
+async function buildInitialHistory() {
+    const content = await buildFullSystemPrompt(getWorkingDir(), ALL_TOOLS);
+    const fresh = { role: 'system', content };
+    const persisted = await loadContext();
+    if (!persisted || persisted.length === 0)
+        return [fresh];
+    const rest = persisted[0]?.role === 'system' ? persisted.slice(1) : persisted;
+    return [fresh, ...rest];
+}

package/src/ui/StatusLine.js

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { homedir } from 'node:os';
+import { sep } from 'node:path';
+import { getWorkingDir } from '../bootstrap/workingDir.js';
+import { useTokenUsage } from './hooks/useTokenUsage.js';
+export function StatusLine({ provider, history, pluginProgress, }) {
+    const usage = useTokenUsage(history, provider);
+    const ratio = usage.tokens / usage.threshold;
+    const color = ratio >= 1 ? 'red' : ratio >= 0.7 ? 'yellow' : 'green';
+    const cwdDisplay = shortenPath(getWorkingDir());
+    return (_jsxs(Box, { children: [pluginProgress && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "magenta", children: ["\uD83D\uDD04 ", pluginProgress.pluginId, " "] }), _jsxs(Text, { color: "magenta", children: [pluginProgress.current, "/", pluginProgress.max] }), _jsx(Text, { color: "gray", children: ' · ' })] })), _jsx(Text, { color: "cyan", children: "cwd " }), _jsx(Text, { color: "gray", children: cwdDisplay }), _jsx(Text, { color: "gray", children: ' · ' }), _jsxs(Text, { color: "gray", children: [provider.name, "/", provider.model] }), _jsx(Text, { color: "gray", children: ' · ' }), _jsxs(Text, { color: color, children: ["tokens ", fmt(usage.tokens), " / ", fmt(usage.contextWindow)] }), _jsx(Text, { color: "gray", children: ' · ' }), _jsx(Text, { color: color, children: usage.toThreshold > 0 ? `距压缩 ${fmt(usage.toThreshold)}` : `已超阈值（下轮压缩）` })] }));
+}
+/** 把整数格式化为 1.2K / 12.3K / 1.5M */
+function fmt(n) {
+    if (n < 1000)
+        return `${n}`;
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+/**
+ * 把绝对路径精简成适合状态栏显示的形式：
+ *   - home 下 → 以 ~ 开头
+ *   - 超过 40 字符 → 保留首段 + … + 末两段
+ */
+export function shortenPath(abs) {
+    const home = homedir();
+    let p = abs;
+    if (home && (p === home || p.startsWith(home + sep))) {
+        p = '~' + p.slice(home.length);
+    }
+    if (p.length <= 40)
+        return p;
+    const parts = p.split(/[\\/]/).filter(Boolean);
+    if (parts.length <= 3)
+        return p;
+    const head = p.startsWith('~') ? '~' : parts[0];
+    const tail = parts.slice(-2).join(sep);
+    return `${head}${sep}…${sep}${tail}`;
+}

package/src/ui/ToolStatus.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function ToolStatus({ status, compacting }) {
+    if (compacting) {
+        return (_jsx(Box, { children: _jsx(Text, { color: "magenta", bold: true, children: "\uD83D\uDDDC  \u6B63\u5728\u538B\u7F29\u5BF9\u8BDD\u5386\u53F2..." }) }));
+    }
+    if (status) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: ['⏳ ', _jsx(Text, { bold: true, children: status.toolName }), `(${status.argsPreview})`] }) }));
+    }
+    return null;
+}

package/src/ui/hooks/useChat.js

@@ -0,0 +1,234 @@
+/**
+ * ============================================================
+ *  src/ui/hooks/useChat.ts —— 把 loop.runQuery 桥接到 React 状态
+ * ------------------------------------------------------------
+ *  这个 hook 是 UI 层的核心：
+ *    - 维护 history 数组（用 ref 持久引用，version 计数器触发重渲染）
+ *    - 维护"当前正在打字"的 streamingText
+ *    - 维护"当前工具状态" toolStatus
+ *    - 暴露 submit() 给 InputBox 调用、abort() 给 Ctrl+C 处理
+ *
+ *  为什么 history 用 ref 而不是 state？
+ *    runQuery 内部会 mutate history 数组（push 新消息、压缩时清空重建），
+ *    React state 的"不可变更新"规则不适合。用 ref 持有可变引用，
+ *    用 version 计数器驱动 setState 触发 re-render 是更顺手的写法。
+ * ============================================================
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { getWorkingDir } from '../../bootstrap/workingDir.js';
+import { forceCompact } from '../../context/compact.js';
+import { clearContext } from '../../context/persistContext.js';
+import { resetReactiveCompactState } from '../../context/reactiveCompact.js';
+import { buildFullSystemPrompt } from '../../prompts/system.js';
+import { ALL_TOOLS } from '../../tools/index.js';
+import { clearFileState } from '../../tools/shared/fileState.js';
+import { runWithPlugins } from '../../plugins/pluginRunner.js';
+export function useChat(args) {
+    // 历史用 ref（可变），用 version 触发 re-render
+    const historyRef = useRef(args.initialHistory.slice());
+    const [version, setVersion] = useState(0);
+    const bump = useCallback(() => setVersion((v) => v + 1), []);
+    const [streamingText, setStreamingText] = useState('');
+    const [toolStatus, setToolStatus] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [interrupted, setInterrupted] = useState(false);
+    const [compacting, setCompacting] = useState(false);
+    const [pluginProgress, setPluginProgress] = useState(null);
+    const abortRef = useRef(null);
+    // 卸载时取消任何进行中的请求
+    useEffect(() => {
+        return () => {
+            abortRef.current?.abort();
+        };
+    }, []);
+    const submit = useCallback(async (input) => {
+        if (isLoading)
+            return;
+        const trimmed = input.trim();
+        if (trimmed.length === 0)
+            return;
+        setIsLoading(true);
+        setError(null);
+        setInterrupted(false);
+        setStreamingText('');
+        setPluginProgress(null);
+        const ac = new AbortController();
+        abortRef.current = ac;
+        try {
+            for await (const ev of runWithPlugins(trimmed, {
+                provider: args.provider,
+                history: historyRef.current,
+                signal: ac.signal,
+            })) {
+                handleEvent(ev, {
+                    setStreamingText,
+                    setToolStatus,
+                    setCompacting,
+                    setError,
+                    setInterrupted,
+                    setPluginProgress,
+                    bump,
+                });
+            }
+        }
+        catch (e) {
+            setError(`未捕获异常：${e.message}`);
+        }
+        finally {
+            setIsLoading(false);
+            setStreamingText('');
+            setToolStatus(null);
+            setCompacting(false);
+            setPluginProgress(null);
+            abortRef.current = null;
+            args.onPersist?.(historyRef.current);
+        }
+    }, [args.provider, args.onPersist, bump, isLoading]);
+    const abort = useCallback(() => {
+        abortRef.current?.abort();
+    }, []);
+    /**
+     * /new —— 清空历史，重新生成 system prompt（带最新 skills + 项目指令）。
+     * 不复用启动时的初始 history 快照，避免把磁盘里的损坏数据带回来。
+     * isLoading 时拒绝执行，避免和正在跑的 runQuery 抢状态。
+     */
+    const clearHistory = useCallback(async () => {
+        if (isLoading)
+            return;
+        // 生成全新的 system prompt（实时扫 skills + 拼项目指令），
+        // 与启动时 main.tsx buildInitialHistory 行为完全一致
+        const newSystemPrompt = await buildFullSystemPrompt(getWorkingDir(), ALL_TOOLS);
+        historyRef.current.length = 0;
+        historyRef.current.push({ role: 'system', content: newSystemPrompt });
+        // 允许新 session 再次触发反应式压缩自救
+        resetReactiveCompactState();
+        setStreamingText('');
+        setToolStatus(null);
+        setError(null);
+        setInterrupted(false);
+        setCompacting(false);
+        bump();
+        // 清空磁盘上的持久化文件（防止下次启动又加载损坏数据）
+        await clearContext();
+        // 清空 pre-read guard 状态表（防止跨 session 的 Read 记录污染新会话）
+        clearFileState();
+        // 注意：这里不调用 onPersist，因为我们刚刚清空了，没必要再保存一次"空历史"
+    }, [bump, isLoading]);
+    /**
+     * /compact —— 手动跑一次压缩（不看阈值）。
+     * isLoading 时拒绝执行；压缩自身的 setIsLoading(true) 会让 InputBox 显示 ⏳。
+     *
+     * ✅ 关键改进：压缩失败时不保存 history（可能包含损坏数据）
+     */
+    const compactNow = useCallback(async () => {
+        if (isLoading)
+            return;
+        setIsLoading(true);
+        setCompacting(true);
+        setError(null);
+        let success = false;
+        try {
+            const r = await forceCompact(historyRef.current, args.provider);
+            historyRef.current.length = 0;
+            historyRef.current.push(...r.messages);
+            bump();
+            success = true; // ✅ 标记成功
+        }
+        catch (e) {
+            setError(`手动压缩失败：${e.message}`);
+            // ❌ 不修改 historyRef.current，保持原样（不保存可能损坏的数据）
+        }
+        finally {
+            setCompacting(false);
+            setIsLoading(false);
+            // ✅ 只在成功时才持久化，避免保存损坏的历史到磁盘
+            if (success) {
+                args.onPersist?.(historyRef.current);
+                args.onCompactDone?.();
+            }
+        }
+    }, [args.provider, args.onPersist, args.onCompactDone, bump, isLoading]);
+    // history 用 useMemo 托管：version 变化时重新计算，返回当前 historyRef.current
+    // 这样任何导致 version++ 的操作（submit/clearHistory/compactNow/工具回调 bump）都会
+    // 让所有消费 history 的组件（MessageList/StatusLine/ToolStatus）自动收到新引用、触发 re-render。
+    const history = useMemo(() => historyRef.current, [version]);
+    return {
+        history,
+        streamingText,
+        toolStatus,
+        isLoading,
+        error,
+        interrupted,
+        compacting,
+        pluginProgress,
+        submit,
+        abort,
+        clearHistory,
+        compactNow,
+    };
+}
+/**
+ * 把一个事件派发到对应的 setState。
+ *
+ * 接受 LoopEvent（框架已识别）或 PluginEvent（插件私有，type 可为任意字符串）。
+ * switch 只匹配 LoopEvent 字面量 type；未识别走 default no-op，等同静默忽略。
+ */
+function handleEvent(ev, setters) {
+    // 收口到 LoopEvent：未识别的 PluginEvent type 走 default no-op
+    const e = ev;
+    switch (e.type) {
+        case 'text':
+            setters.setStreamingText((prev) => prev + e.delta);
+            break;
+        case 'assistant_message':
+            // history 已被 runQuery 直接 push，这里只刷一下视图 + 清流式 buffer
+            setters.setStreamingText(() => '');
+            setters.bump();
+            break;
+        case 'tool_start':
+            setters.setToolStatus({
+                toolName: e.toolName,
+                argsPreview: e.argsPreview,
+                status: 'running',
+            });
+            setters.bump();
+            break;
+        case 'tool_end':
+            setters.setToolStatus(null);
+            setters.bump();
+            break;
+        case 'compact_start':
+            // reactive 自救场景：LLM 失败前可能已经 yield 过部分 text delta，
+            // 压缩前清掉残留 streamingText，避免重发后新文本追加在旧 buffer 后面。
+            // autoCompact 场景下 streamingText 本来就是空，这里 no-op。
+            setters.setStreamingText(() => '');
+            setters.setCompacting(true);
+            setters.bump();
+            break;
+        case 'compact_done':
+            setters.setCompacting(false);
+            setters.bump();
+            break;
+        case 'turn_done':
+            setters.bump();
+            break;
+        case 'interrupted':
+            setters.setInterrupted(true);
+            setters.bump();
+            break;
+        case 'error':
+            setters.setError(e.error);
+            setters.bump();
+            break;
+        case 'plugin_progress':
+            setters.setPluginProgress({
+                pluginId: e.pluginId,
+                current: e.current,
+                max: e.max ?? 0,
+                message: e.message,
+            });
+            setters.bump();
+            break;
+    }
+}

package/src/ui/hooks/usePasteHandler.js

@@ -0,0 +1,137 @@
+/**
+ * ============================================================
+ *  src/ui/hooks/usePasteHandler.ts —— 粘贴检测 Hook（v0.3 最终版）
+ * ------------------------------------------------------------
+ *  功能：
+ *    1. 检测粘贴输入（通过内容长度阈值）
+ *    2. 收集多 Chunk 粘贴内容（处理 stdin 分块到达）
+ *    3. ✨ 粘贴期间拦截所有 Enter（防止多行内容被误发送）
+ *    4. 跨平台兼容：Win / Mac / Linux
+ *
+ *  v0.3 核心设计原则（符合用户直觉）：
+ *    - Enter（单独按）：始终返回 'continue' → 调用方处理为**发送消息**
+ *    - Alt+Enter（Mac: Option+Enter）：返回 'enter-newline' → 调用方处理为**插入换行**
+ *    - Ctrl+Enter：返回 'continue' → 调用方处理为**强制发送**
+ *    - 粘贴期间 + 任何 Enter：返回 'enter-in-paste' → **忽略**（防止误触发发送）
+ *
+ *  工作原理：
+ *    当用户粘贴多行内容时，stdin 可能分多个 chunk 到达。
+ *    如果不处理，粘贴内容中的 \n 会被解析为 Enter 键，
+ *    导致只有最后一个换行之前的内容被保留，或者直接触发了发送。
+ * ============================================================
+ */
+import { useCallback, useRef, useState } from 'react';
+// 粘贴检测阈值：超过此长度视为粘贴输入
+const PASTE_THRESHOLD = 20;
+// 多 Chunk 等待超时：100ms 内收到的内容视为同一批粘贴
+const PASTE_TIMEOUT_MS = 100;
+/**
+ * 粘贴检测 Hook（v0.3 最终版）
+ *
+ * @example
+ * ```tsx
+ * const { handleInput } = usePasteHandler({
+ *   onPasteComplete: (text) => {
+ *     buf.insert(text);
+ *     forceRefresh();
+ *   },
+ *   multiline: true,
+ * });
+ *
+ * useInput((input, key) => {
+ *   const result = handleInput(input, key);
+ *   if (result === 'paste') return;           // 粘贴已处理
+ *   if (result === 'enter-in-paste') return;  // 粘贴中的 Enter 忽略
+ *   if (result === 'enter-newline') {         // Alt+Enter → 换行
+ *     buf.insert('\n');
+ *     forceRefresh();
+ *     return;
+ *   }
+ *   // result === 'continue': 正常处理
+ *   // 包括：Enter 发送、Ctrl+Enter 发送、普通字符输入等
+ * });
+ * ```
+ */
+export function usePasteHandler({ onPasteComplete, multiline = false, }) {
+    const [isPasting, setIsPasting] = useState(false);
+    const pasteStateRef = useRef({
+        chunks: [],
+        timeoutId: null,
+    });
+    /**
+     * 刷新 UI 的引用（避免闭包问题）
+     */
+    const onPasteCompleteRef = useRef(onPasteComplete);
+    onPasteCompleteRef.current = onPasteComplete;
+    /**
+     * 刷新 isPasting 状态的引用
+     */
+    const setIsPastingRef = useRef(setIsPasting);
+    setIsPastingRef.current = setIsPasting;
+    /**
+     * 将收集的 chunks 合并并触发回调
+     */
+    const flushPaste = useCallback(() => {
+        const { chunks } = pasteStateRef.current;
+        if (chunks.length === 0)
+            return;
+        // 合并所有 chunks
+        const rawText = chunks.join('');
+        // 清理文本：
+        // 1. \r\n → \n（Windows 行尾）
+        // 2. 连续的 \n 压缩为最多两个（保持段落分隔）
+        const cleanedText = rawText
+            .replace(/\r\n/g, '\n')
+            .replace(/\r/g, '\n')
+            .replace(/\n{3,}/g, '\n\n');
+        // 清除状态
+        pasteStateRef.current = { chunks: [], timeoutId: null };
+        setIsPastingRef.current(false);
+        // 触发回调
+        onPasteCompleteRef.current(cleanedText);
+    }, []);
+    /**
+     * 处理输入（v0.3：Enter 始终发送，Alt+Enter 换行，粘贴期间拦截）
+     */
+    const handleInput = useCallback((input, key) => {
+        // ---- 1. 粘贴期间的任何 Enter 键：全部拦截 ----
+        // 这是最关键的防御！防止多行粘贴内容中的 \n 触发发送
+        if (isPasting && key.return) {
+            return 'enter-in-paste';
+        }
+        // ---- 2. Alt+Enter（Mac: Option+Enter）：插入换行符（用于编辑时手动换行）----
+        // multiline=false 时不识别 Alt+Enter，让它走到下面的普通 Enter 分支（提交）
+        if (multiline && key.return && key.meta && !key.ctrl) {
+            return 'enter-newline';
+        }
+        // ---- 3. Enter（包括 Ctrl+Enter）：始终返回 continue → 让调用方处理为发送 ----
+        // 不管是单行还是多行内容，Enter 的默认行为都是发送
+        // 只有 Alt+Enter 才是换行
+        if (key.return) {
+            return 'continue'; // 调用方会执行 onSubmit()
+        }
+        // ---- 4. 检测是否为粘贴输入 ----
+        const isLongInput = input.length > PASTE_THRESHOLD;
+        if (isLongInput || isPasting) {
+            // 进入或继续粘贴状态
+            setIsPasting(true);
+            // 清除之前的超时
+            if (pasteStateRef.current.timeoutId) {
+                clearTimeout(pasteStateRef.current.timeoutId);
+            }
+            // 收集这个 chunk
+            pasteStateRef.current.chunks.push(input);
+            // 设置新的超时，超时后 flush
+            pasteStateRef.current.timeoutId = setTimeout(() => {
+                flushPaste();
+            }, PASTE_TIMEOUT_MS);
+            return 'paste';
+        }
+        // ---- 5. 普通输入，继续处理 ----
+        return 'continue';
+    }, [isPasting, multiline, flushPaste]);
+    return {
+        handleInput,
+        isPasting,
+    };
+}

package/src/ui/hooks/useTextBuffer.js

@@ -0,0 +1,55 @@
+/**
+ * ============================================================
+ *  src/ui/hooks/useTextBuffer.ts —— 输入框文本缓冲（React 包装）
+ * ------------------------------------------------------------
+ *  把 textBuffer.ts 里的纯函数包成 React Hook：useState 持有 BufferState，
+ *  暴露一组 callback 给 InputBox 调用。callback 用 setState(prev => ...)
+ *  形式，避免 useInput handler 闭包看到旧 state 的问题。
+ * ============================================================
+ */
+import { useCallback, useMemo, useState } from 'react';
+import { bufClear, bufDeleteAt, bufDeleteBefore, bufDeleteWordBefore, bufInsert, bufKillToLineEnd, bufKillToLineStart, bufMoveBufferEnd, bufMoveBufferStart, bufMoveDown, bufMoveLeft, bufMoveLineEnd, bufMoveLineStart, bufMoveRight, bufMoveUp, bufMoveWordLeft, bufMoveWordRight, bufSetText, EMPTY_BUFFER, layoutBuffer, } from '../textBuffer.js';
+export function useTextBuffer() {
+    const [state, setState] = useState(EMPTY_BUFFER);
+    const insert = useCallback((s) => setState((p) => bufInsert(p, s)), []);
+    const setText = useCallback((s) => setState(bufSetText(s)), []);
+    const clear = useCallback(() => setState(bufClear()), []);
+    const deleteBefore = useCallback(() => setState(bufDeleteBefore), []);
+    const deleteAt = useCallback(() => setState(bufDeleteAt), []);
+    const deleteWordBefore = useCallback(() => setState(bufDeleteWordBefore), []);
+    const killToLineStart = useCallback(() => setState(bufKillToLineStart), []);
+    const killToLineEnd = useCallback(() => setState(bufKillToLineEnd), []);
+    const moveLeft = useCallback(() => setState(bufMoveLeft), []);
+    const moveRight = useCallback(() => setState(bufMoveRight), []);
+    const moveWordLeft = useCallback(() => setState(bufMoveWordLeft), []);
+    const moveWordRight = useCallback(() => setState(bufMoveWordRight), []);
+    const moveLineStart = useCallback(() => setState(bufMoveLineStart), []);
+    const moveLineEnd = useCallback(() => setState(bufMoveLineEnd), []);
+    const moveBufferStart = useCallback(() => setState(bufMoveBufferStart), []);
+    const moveBufferEnd = useCallback(() => setState(bufMoveBufferEnd), []);
+    const moveUp = useCallback(() => setState(bufMoveUp), []);
+    const moveDown = useCallback(() => setState(bufMoveDown), []);
+    const layout = useMemo(() => layoutBuffer(state), [state]);
+    return {
+        state,
+        layout,
+        insert,
+        setText,
+        clear,
+        deleteBefore,
+        deleteAt,
+        deleteWordBefore,
+        killToLineStart,
+        killToLineEnd,
+        moveLeft,
+        moveRight,
+        moveWordLeft,
+        moveWordRight,
+        moveLineStart,
+        moveLineEnd,
+        moveBufferStart,
+        moveBufferEnd,
+        moveUp,
+        moveDown,
+    };
+}

package/src/ui/hooks/useTokenUsage.js

@@ -0,0 +1,30 @@
+/**
+ * ============================================================
+ *  src/ui/hooks/useTokenUsage.ts —— token 用量计算
+ * ------------------------------------------------------------
+ *  纯函数 hook：根据当前 history 算 token 数 + 距离压缩阈值的百分比，
+ *  StatusLine 用它显示底部状态。
+ *
+ *  历史坑：曾经用 useMemo([messages, provider]) 缓存——但 useChat
+ *  里的 historyRef.current 跨渲染始终是同一个数组引用（runQuery
+ *  内部用 push() / length=0 直接 mutate），useMemo 缓存键永不失效，
+ *  导致 StatusLine 显示的 token 数从启动后就冻结。
+ *
+ *  修复：直接每渲染重算。countMessagesTokens 在百 KB 历史上 < 1ms，
+ *  仅状态栏一处调用，零负担。如果未来历史规模变大需要 memo，
+ *  再额外传入版本号 prop 配合依赖即可。
+ * ============================================================
+ */
+import { AUTOCOMPACT_BUFFER_TOKENS } from '../../context/compact.js';
+import { countMessagesTokens } from '../../context/tokenCounter.js';
+export function useTokenUsage(messages, provider) {
+    const tokens = countMessagesTokens(messages);
+    const threshold = Math.max(1000, provider.contextWindow - AUTOCOMPACT_BUFFER_TOKENS);
+    return {
+        tokens,
+        threshold,
+        contextWindow: provider.contextWindow,
+        percentageOfWindow: tokens / provider.contextWindow,
+        toThreshold: threshold - tokens,
+    };
+}