@code4bug/jarvis-agent 1.0.2 → 1.0.4

package/dist/hooks/useSlashMenu.d.ts

@@ -0,0 +1,36 @@
+import { Message } from '../types/index.js';
+import { QueryEngine } from '../core/QueryEngine.js';
+import { SlashCommand } from '../commands/index.js';
+interface UseSlashMenuOptions {
+    engineRef: React.RefObject<QueryEngine | null>;
+    sessionRef: React.MutableRefObject<import('../types/index.js').Session>;
+    tokenCountRef: React.MutableRefObject<number>;
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    setDisplayTokens: (n: number) => void;
+    setLoopState: React.Dispatch<React.SetStateAction<import('../types/index.js').LoopState | null>>;
+    setIsProcessing: React.Dispatch<React.SetStateAction<boolean>>;
+    setShowWelcome: React.Dispatch<React.SetStateAction<boolean>>;
+    setInput: React.Dispatch<React.SetStateAction<string>>;
+    /** resume 时重置所有流式状态（含 thinkingIdRef） */
+    stopAll: () => void;
+}
+/**
+ * 斜杠命令菜单状态管理 hook
+ *
+ * 管理菜单可见性、选中项、二级菜单（agent / resume）等。
+ */
+export declare function useSlashMenu(opts: UseSlashMenuOptions): {
+    slashMenuVisible: boolean;
+    slashMenuItems: SlashCommand[];
+    slashMenuIndex: number;
+    agentMenuMode: boolean;
+    resumeMenuMode: boolean;
+    handleSlashMenuUp: () => void;
+    handleSlashMenuDown: () => void;
+    handleSlashMenuSelect: () => void;
+    handleSlashMenuClose: () => void;
+    updateSlashMenu: (val: string) => void;
+    setSlashMenuVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    resumeSession: (sessionId: string) => void;
+};
+export {};

package/dist/hooks/useSlashMenu.js

@@ -0,0 +1,216 @@
+import { useState, useCallback } from 'react';
+import { QueryEngine } from '../core/QueryEngine.js';
+import { filterCommands, filterAgentCommands } from '../commands/index.js';
+import { setActiveAgent } from '../config/agentState.js';
+import { executeSlashCommand } from '../screens/slashCommands.js';
+/**
+ * 斜杠命令菜单状态管理 hook
+ *
+ * 管理菜单可见性、选中项、二级菜单（agent / resume）等。
+ */
+export function useSlashMenu(opts) {
+    const { engineRef, sessionRef, tokenCountRef, setMessages, setDisplayTokens, setLoopState, setIsProcessing, setShowWelcome, setInput, stopAll, } = opts;
+    const [slashMenuVisible, setSlashMenuVisible] = useState(false);
+    const [slashMenuItems, setSlashMenuItems] = useState([]);
+    const [slashMenuIndex, setSlashMenuIndex] = useState(0);
+    const [agentMenuMode, setAgentMenuMode] = useState(false);
+    const [resumeMenuMode, setResumeMenuMode] = useState(false);
+    // 上移
+    const handleSlashMenuUp = useCallback(() => {
+        setSlashMenuIndex((prev) => (prev > 0 ? prev - 1 : slashMenuItems.length - 1));
+    }, [slashMenuItems.length]);
+    // 下移
+    const handleSlashMenuDown = useCallback(() => {
+        setSlashMenuIndex((prev) => (prev < slashMenuItems.length - 1 ? prev + 1 : 0));
+    }, [slashMenuItems.length]);
+    // 关闭
+    const handleSlashMenuClose = useCallback(() => {
+        if (agentMenuMode || resumeMenuMode) {
+            setAgentMenuMode(false);
+            setResumeMenuMode(false);
+            setInput('/');
+            const matched = filterCommands('');
+            setSlashMenuItems(matched);
+            setSlashMenuIndex(0);
+            setSlashMenuVisible(matched.length > 0);
+        }
+        else {
+            setSlashMenuVisible(false);
+        }
+    }, [agentMenuMode, resumeMenuMode, setInput]);
+    // 恢复会话的通用逻辑
+    const resumeSession = useCallback((sessionId) => {
+        if (!engineRef.current)
+            return;
+        const result = engineRef.current.loadSession(sessionId);
+        if (result) {
+            // 先重置所有流式状态（含 thinkingIdRef），避免旧 id 残留导致新会话 thinking 永不结束
+            stopAll();
+            setMessages(result.messages);
+            sessionRef.current = result.session;
+            tokenCountRef.current = result.session.totalTokens;
+            setDisplayTokens(result.session.totalTokens);
+            setLoopState(null);
+            setIsProcessing(false);
+            setShowWelcome(false);
+            const resumeMsg = {
+                id: `resume-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: `已恢复会话 ${sessionId.slice(0, 8)}...（${result.messages.length} 条消息）`,
+                timestamp: Date.now(),
+            };
+            setMessages((prev) => [...prev, resumeMsg]);
+        }
+        else {
+            const errMsg = {
+                id: `resume-err-${Date.now()}`,
+                type: 'error',
+                status: 'error',
+                content: `会话 ${sessionId} 不存在或已损坏`,
+                timestamp: Date.now(),
+            };
+            setMessages((prev) => [...prev, errMsg]);
+        }
+    }, [engineRef, sessionRef, tokenCountRef, setMessages, setDisplayTokens, stopAll, setLoopState, setIsProcessing, setShowWelcome]);
+    // 选中
+    const handleSlashMenuSelect = useCallback(() => {
+        if (slashMenuItems.length === 0)
+            return;
+        const cmd = slashMenuItems[slashMenuIndex];
+        if (!cmd)
+            return;
+        // 二级 agent 菜单
+        if (agentMenuMode) {
+            setActiveAgent(cmd.name);
+            setInput('');
+            setSlashMenuVisible(false);
+            setAgentMenuMode(false);
+            const switchMsg = {
+                id: `switch-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: `已切换智能体为 ${cmd.name}，请重启以生效（Ctrl+C 两次退出后重新启动）`,
+                timestamp: Date.now(),
+            };
+            setMessages((prev) => [...prev, switchMsg]);
+            return;
+        }
+        // 二级 resume 菜单
+        if (resumeMenuMode) {
+            setInput('');
+            setSlashMenuVisible(false);
+            setResumeMenuMode(false);
+            resumeSession(cmd.name);
+            return;
+        }
+        // 一级菜单选中 /agent -> 进入二级菜单
+        if (cmd.name === 'agent') {
+            setInput('/agent ');
+            const matched = filterAgentCommands('');
+            setSlashMenuItems(matched);
+            setSlashMenuIndex(0);
+            setAgentMenuMode(true);
+            setResumeMenuMode(false);
+            return;
+        }
+        // 一级菜单选中 /resume -> 进入二级菜单
+        if (cmd.name === 'resume') {
+            setInput('/resume ');
+            const sessions = QueryEngine.listSessions().slice(0, 20);
+            const items = sessions.map((s) => {
+                const date = new Date(s.updatedAt);
+                const dateStr = `${date.getMonth() + 1}/${date.getDate()} ${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+                return {
+                    name: s.id,
+                    description: `[${dateStr}] ${s.summary}`,
+                    category: 'builtin',
+                };
+            });
+            setSlashMenuItems(items);
+            setSlashMenuIndex(0);
+            setSlashMenuVisible(items.length > 0);
+            setResumeMenuMode(true);
+            setAgentMenuMode(false);
+            return;
+        }
+        // 内置命令：直接执行
+        if (cmd.category === 'builtin') {
+            setInput('');
+            setSlashMenuVisible(false);
+            const msg = executeSlashCommand(cmd.name);
+            if (msg)
+                setMessages((prev) => [...prev, msg]);
+            return;
+        }
+        // 工具命令：填入输入框
+        setInput(`/${cmd.name} `);
+        setSlashMenuVisible(false);
+    }, [slashMenuItems, slashMenuIndex, agentMenuMode, resumeMenuMode, setInput, setMessages, resumeSession]);
+    // 输入变化时更新菜单
+    const updateSlashMenu = useCallback((val) => {
+        if (val.startsWith('/') && !val.includes('\n')) {
+            const query = val.slice(1);
+            // /agent 二级菜单
+            if (/^agent\s/i.test(query)) {
+                const subQuery = query.replace(/^agent\s*/i, '');
+                const matched = filterAgentCommands(subQuery);
+                setSlashMenuItems(matched);
+                setSlashMenuIndex(0);
+                setSlashMenuVisible(matched.length > 0);
+                setAgentMenuMode(true);
+                setResumeMenuMode(false);
+                return;
+            }
+            // /resume 二级菜单
+            if (/^resume\s/i.test(query)) {
+                const subQuery = query.replace(/^resume\s*/i, '').toLowerCase();
+                const sessions = QueryEngine.listSessions().slice(0, 20);
+                const items = sessions.map((s) => {
+                    const date = new Date(s.updatedAt);
+                    const dateStr = `${date.getMonth() + 1}/${date.getDate()} ${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+                    return {
+                        name: s.id,
+                        description: `[${dateStr}] ${s.summary}`,
+                        category: 'builtin',
+                    };
+                });
+                const matched = subQuery
+                    ? items.filter((i) => i.name.includes(subQuery) || i.description.toLowerCase().includes(subQuery))
+                    : items;
+                setSlashMenuItems(matched);
+                setSlashMenuIndex(0);
+                setSlashMenuVisible(matched.length > 0);
+                setResumeMenuMode(true);
+                setAgentMenuMode(false);
+                return;
+            }
+            // 一级菜单
+            const matched = filterCommands(query);
+            setSlashMenuItems(matched);
+            setSlashMenuIndex(0);
+            setSlashMenuVisible(matched.length > 0);
+            setAgentMenuMode(false);
+            setResumeMenuMode(false);
+        }
+        else {
+            setSlashMenuVisible(false);
+            setAgentMenuMode(false);
+            setResumeMenuMode(false);
+        }
+    }, []);
+    return {
+        slashMenuVisible,
+        slashMenuItems,
+        slashMenuIndex,
+        agentMenuMode,
+        resumeMenuMode,
+        handleSlashMenuUp,
+        handleSlashMenuDown,
+        handleSlashMenuSelect,
+        handleSlashMenuClose,
+        updateSlashMenu,
+        setSlashMenuVisible,
+        resumeSession,
+    };
+}

package/dist/hooks/useStreamThrottle.d.ts

@@ -0,0 +1,20 @@
+import { Message } from '../types/index.js';
+/**
+ * 流式文本 + thinking 文本节流 hook
+ *
+ * 用 ref 积累 chunk，定时刷新到 state，减少 re-render 频率。
+ */
+export declare function useStreamThrottle(setMessages: React.Dispatch<React.SetStateAction<Message[]>>): {
+    streamText: string;
+    streamBufferRef: import("react").MutableRefObject<string>;
+    startStreamTimer: () => void;
+    stopStreamTimer: () => void;
+    startThinkingTimer: () => void;
+    stopThinkingTimer: () => void;
+    appendStreamChunk: (text: string) => void;
+    clearStream: () => void;
+    handleThinkingUpdate: (id: string, content: string) => void;
+    finishThinking: () => void;
+    thinkingIdRef: import("react").MutableRefObject<string | null>;
+    stopAll: () => void;
+};

package/dist/hooks/useStreamThrottle.js

@@ -0,0 +1,120 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+const STREAM_FLUSH_INTERVAL = 80; // ms
+const THINKING_FLUSH_INTERVAL = 100; // ms
+/**
+ * 流式文本 + thinking 文本节流 hook
+ *
+ * 用 ref 积累 chunk，定时刷新到 state，减少 re-render 频率。
+ */
+export function useStreamThrottle(setMessages) {
+    const [streamText, setStreamText] = useState('');
+    // 流式文本节流
+    const streamBufferRef = useRef('');
+    const streamTimerRef = useRef(null);
+    // thinking 文本节流
+    const thinkingBufferRef = useRef('');
+    const thinkingIdRef = useRef(null);
+    const thinkingTimerRef = useRef(null);
+    // 启动流式文本节流定时器
+    const startStreamTimer = useCallback(() => {
+        if (streamTimerRef.current)
+            return;
+        streamTimerRef.current = setInterval(() => {
+            if (streamBufferRef.current) {
+                const buf = streamBufferRef.current;
+                streamBufferRef.current = '';
+                setStreamText((prev) => prev + buf);
+            }
+        }, STREAM_FLUSH_INTERVAL);
+    }, []);
+    const stopStreamTimer = useCallback(() => {
+        if (streamTimerRef.current) {
+            clearInterval(streamTimerRef.current);
+            streamTimerRef.current = null;
+        }
+        if (streamBufferRef.current) {
+            const buf = streamBufferRef.current;
+            streamBufferRef.current = '';
+            setStreamText((prev) => prev + buf);
+        }
+    }, []);
+    // 启动 thinking 文本节流定时器
+    const startThinkingTimer = useCallback(() => {
+        if (thinkingTimerRef.current)
+            return;
+        thinkingTimerRef.current = setInterval(() => {
+            const id = thinkingIdRef.current;
+            const buf = thinkingBufferRef.current;
+            if (id && buf) {
+                setMessages((prev) => prev.map((msg) => (msg.id === id ? { ...msg, content: buf } : msg)));
+            }
+        }, THINKING_FLUSH_INTERVAL);
+    }, [setMessages]);
+    const stopThinkingTimer = useCallback(() => {
+        if (thinkingTimerRef.current) {
+            clearInterval(thinkingTimerRef.current);
+            thinkingTimerRef.current = null;
+        }
+        const id = thinkingIdRef.current;
+        const buf = thinkingBufferRef.current;
+        if (id && buf) {
+            setMessages((prev) => prev.map((msg) => (msg.id === id ? { ...msg, content: buf } : msg)));
+        }
+    }, [setMessages]);
+    /** 追加流式文本到 buffer（不直接 setState） */
+    const appendStreamChunk = useCallback((text) => {
+        streamBufferRef.current += text;
+    }, []);
+    /** 清空流式文本（每轮迭代结束时调用） */
+    const clearStream = useCallback(() => {
+        streamBufferRef.current = '';
+        setStreamText('');
+    }, []);
+    /** 处理 thinking 消息的 content 更新 */
+    const handleThinkingUpdate = useCallback((id, content) => {
+        if (thinkingIdRef.current === null) {
+            thinkingIdRef.current = id;
+            thinkingBufferRef.current = content;
+            startThinkingTimer();
+        }
+        else {
+            thinkingBufferRef.current = content;
+        }
+    }, [startThinkingTimer]);
+    /** thinking 完成时调用 */
+    const finishThinking = useCallback(() => {
+        stopThinkingTimer();
+        thinkingIdRef.current = null;
+        thinkingBufferRef.current = '';
+    }, [stopThinkingTimer]);
+    /** 全部停止（loop 结束时调用） */
+    const stopAll = useCallback(() => {
+        stopStreamTimer();
+        stopThinkingTimer();
+        thinkingIdRef.current = null;
+        thinkingBufferRef.current = '';
+        streamBufferRef.current = '';
+        setStreamText('');
+    }, [stopStreamTimer, stopThinkingTimer]);
+    // 组件卸载时清理
+    useEffect(() => () => {
+        if (streamTimerRef.current)
+            clearInterval(streamTimerRef.current);
+        if (thinkingTimerRef.current)
+            clearInterval(thinkingTimerRef.current);
+    }, []);
+    return {
+        streamText,
+        streamBufferRef,
+        startStreamTimer,
+        stopStreamTimer,
+        startThinkingTimer,
+        stopThinkingTimer,
+        appendStreamChunk,
+        clearStream,
+        handleThinkingUpdate,
+        finishThinking,
+        thinkingIdRef,
+        stopAll,
+    };
+}

package/dist/hooks/useTerminalWidth.d.ts

@@ -0,0 +1,2 @@
+/** 响应式终端宽度 */
+export declare function useTerminalWidth(): number;

package/dist/hooks/useTerminalWidth.js

@@ -0,0 +1,13 @@
+import { useState, useEffect } from 'react';
+/** 响应式终端宽度 */
+export function useTerminalWidth() {
+    const [width, setWidth] = useState(() => process.stdout.columns || 80);
+    useEffect(() => {
+        const onResize = () => {
+            setWidth(process.stdout.columns || 80);
+        };
+        process.stdout.on('resize', onResize);
+        return () => { process.stdout.off('resize', onResize); };
+    }, []);
+    return width;
+}

package/dist/hooks/useTokenDisplay.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Token 计数显示 hook
+ *
+ * 用 ref 缓存实时 token 数，定时器驱动 UI 刷新，避免每个 chunk 都触发 re-render。
+ */
+export declare function useTokenDisplay(): {
+    displayTokens: number;
+    tokenCountRef: import("react").MutableRefObject<number>;
+    startTokenTimer: () => void;
+    stopTokenTimer: () => void;
+    updateTokenCount: (count: number) => void;
+    resetTokens: () => void;
+};

package/dist/hooks/useTokenDisplay.js

@@ -0,0 +1,45 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+/**
+ * Token 计数显示 hook
+ *
+ * 用 ref 缓存实时 token 数，定时器驱动 UI 刷新，避免每个 chunk 都触发 re-render。
+ */
+export function useTokenDisplay() {
+    const tokenCountRef = useRef(0);
+    const tokenTimerRef = useRef(null);
+    const [displayTokens, setDisplayTokens] = useState(0);
+    const startTokenTimer = useCallback(() => {
+        if (tokenTimerRef.current)
+            return;
+        tokenTimerRef.current = setInterval(() => {
+            setDisplayTokens(tokenCountRef.current);
+        }, 100);
+    }, []);
+    const stopTokenTimer = useCallback(() => {
+        if (tokenTimerRef.current) {
+            clearInterval(tokenTimerRef.current);
+            tokenTimerRef.current = null;
+        }
+        setDisplayTokens(tokenCountRef.current);
+    }, []);
+    const updateTokenCount = useCallback((count) => {
+        tokenCountRef.current = count;
+    }, []);
+    const resetTokens = useCallback(() => {
+        tokenCountRef.current = 0;
+        setDisplayTokens(0);
+    }, []);
+    // 组件卸载时清理
+    useEffect(() => () => {
+        if (tokenTimerRef.current)
+            clearInterval(tokenTimerRef.current);
+    }, []);
+    return {
+        displayTokens,
+        tokenCountRef,
+        startTokenTimer,
+        stopTokenTimer,
+        updateTokenCount,
+        resetTokens,
+    };
+}