@code4bug/jarvis-agent 1.0.2

package/dist/components/MultilineInput.js

@@ -0,0 +1,437 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { Box, Text, useInput, useStdin } from 'ink';
+/** 粘贴占位符的正则，匹配 [Pasted text #N +X lines] */
+const PASTE_PLACEHOLDER_RE = /\[Pasted text #(\d+) \+(\d+) lines\]/g;
+/** 粘贴检测的时间窗口（ms），在此窗口内连续到达的数据视为一次粘贴 */
+const PASTE_DETECT_WINDOW_MS = 8;
+/**
+ * 多行文本输入组件，支持光标移动和粘贴折叠。
+ *
+ * - Enter: 提交（占位符会被展开为真实内容）
+ * - Alt/Option+Enter: 换行
+ * - ←→: 左右移动光标
+ * - ↑↓: 上下行移动光标（单行时触发 onUpArrow/onDownArrow）
+ * - Backspace: 删除光标前一个字符（占位符整体删除）
+ * - 粘贴多行内容: 折叠为 [Pasted text #N +X lines] 占位符
+ */
+export default function MultilineInput({ value, onChange, onSubmit, onUpArrow, onDownArrow, placeholder = '', isActive = true, showCursor = true, slashMenuActive = false, onSlashMenuUp, onSlashMenuDown, onSlashMenuSelect, onSlashMenuClose, onTabFillPlaceholder, }) {
+    const { stdin } = useStdin();
+    const [cursor, setCursor] = useState(value.length);
+    // 粘贴内容存储
+    const pasteCountRef = useRef(0);
+    const pastedChunksRef = useRef(new Map());
+    // bracketed paste 缓冲
+    const pasteBufferRef = useRef(null);
+    // 时间窗口粘贴检测：收集短时间内连续到达的数据块
+    const batchBufferRef = useRef('');
+    const batchTimerRef = useRef(null);
+    // 启用 bracketed paste mode
+    useEffect(() => {
+        if (!stdin || !isActive)
+            return;
+        process.stdout.write('\x1B[?2004h');
+        return () => {
+            process.stdout.write('\x1B[?2004l');
+        };
+    }, [stdin, isActive]);
+    // 标记内部触发的 value 变更，避免 useEffect 覆盖光标位置
+    const internalChangeRef = useRef(false);
+    // 外部 value 变化时，将光标移到末尾（仅外部变更时）
+    useEffect(() => {
+        if (internalChangeRef.current) {
+            internalChangeRef.current = false;
+            return;
+        }
+        setCursor(value.length);
+    }, [value]);
+    const valueRef = useRef(value);
+    valueRef.current = value;
+    const cursorRef = useRef(cursor);
+    cursorRef.current = cursor;
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    /** 内部触发 onChange，标记为内部变更避免光标跳转 */
+    const emitChange = (val) => {
+        internalChangeRef.current = true;
+        onChangeRef.current(val);
+    };
+    const onSubmitRef = useRef(onSubmit);
+    onSubmitRef.current = onSubmit;
+    const onUpArrowRef = useRef(onUpArrow);
+    onUpArrowRef.current = onUpArrow;
+    const onDownArrowRef = useRef(onDownArrow);
+    onDownArrowRef.current = onDownArrow;
+    // 斜杠菜单相关 ref
+    const slashMenuActiveRef = useRef(slashMenuActive);
+    slashMenuActiveRef.current = slashMenuActive;
+    const onSlashMenuUpRef = useRef(onSlashMenuUp);
+    onSlashMenuUpRef.current = onSlashMenuUp;
+    const onSlashMenuDownRef = useRef(onSlashMenuDown);
+    onSlashMenuDownRef.current = onSlashMenuDown;
+    const onSlashMenuSelectRef = useRef(onSlashMenuSelect);
+    onSlashMenuSelectRef.current = onSlashMenuSelect;
+    const onSlashMenuCloseRef = useRef(onSlashMenuClose);
+    onSlashMenuCloseRef.current = onSlashMenuClose;
+    const onTabFillPlaceholderRef = useRef(onTabFillPlaceholder);
+    onTabFillPlaceholderRef.current = onTabFillPlaceholder;
+    // 辅助：根据光标偏移计算所在行号和行内列号
+    const getCursorRowCol = (text, pos) => {
+        const before = text.slice(0, pos);
+        const row = (before.match(/\n/g) || []).length;
+        const lastNewline = before.lastIndexOf('\n');
+        const col = lastNewline === -1 ? pos : pos - lastNewline - 1;
+        return { row, col };
+    };
+    // 辅助：根据行号和列号计算偏移
+    const rowColToOffset = (text, row, col) => {
+        const lines = text.split('\n');
+        let offset = 0;
+        for (let i = 0; i < row && i < lines.length; i++) {
+            offset += lines[i].length + 1;
+        }
+        const targetLine = lines[Math.min(row, lines.length - 1)] ?? '';
+        return offset + Math.min(col, targetLine.length);
+    };
+    /** 将粘贴的多行内容折叠为占位符，插入到当前光标位置 */
+    const insertPaste = (pastedText) => {
+        const v = valueRef.current;
+        const c = cursorRef.current;
+        const cleaned = pastedText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const lineCount = cleaned.split('\n').length;
+        // 单行粘贴直接插入，不折叠
+        if (lineCount <= 1) {
+            const newVal = v.slice(0, c) + cleaned + v.slice(c);
+            emitChange(newVal);
+            setCursor(c + cleaned.length);
+            return;
+        }
+        // 多行 → 生成占位符
+        const id = ++pasteCountRef.current;
+        pastedChunksRef.current.set(id, { id, content: cleaned, lineCount });
+        const tag = `[Pasted text #${id} +${lineCount} lines]`;
+        const newVal = v.slice(0, c) + tag + v.slice(c);
+        emitChange(newVal);
+        setCursor(c + tag.length);
+    };
+    /** 展开 value 中所有占位符为真实内容 */
+    const expandPlaceholders = (text) => {
+        return text.replace(PASTE_PLACEHOLDER_RE, (match, idStr) => {
+            const id = parseInt(idStr, 10);
+            const chunk = pastedChunksRef.current.get(id);
+            return chunk ? chunk.content : match;
+        });
+    };
+    /** 检测光标前是否紧邻一个占位符 */
+    const findPlaceholderBeforeCursor = (text, pos) => {
+        if (pos === 0 || text[pos - 1] !== ']')
+            return null;
+        const before = text.slice(0, pos);
+        const idx = before.lastIndexOf('[Pasted text #');
+        if (idx === -1)
+            return null;
+        const sub = before.slice(idx);
+        const m = sub.match(/^\[Pasted text #\d+ \+\d+ lines\]$/);
+        if (m)
+            return { start: idx, end: pos };
+        return null;
+    };
+    /** 处理单个普通输入字符/按键（非粘贴） */
+    const handleNormalInput = (raw) => {
+        const v = valueRef.current;
+        const c = cursorRef.current;
+        // Alt+Enter → 插入换行
+        if (raw === '\x1B\r' || raw === '\x1B\n') {
+            const newVal = v.slice(0, c) + '\n' + v.slice(c);
+            emitChange(newVal);
+            setCursor(c + 1);
+            return;
+        }
+        // Enter → 提交（展开占位符）
+        if (raw === '\r' || raw === '\n') {
+            // 斜杠菜单激活时，回车 = 选中当前项
+            if (slashMenuActiveRef.current) {
+                onSlashMenuSelectRef.current?.();
+                return;
+            }
+            const expanded = expandPlaceholders(v);
+            onSubmitRef.current(expanded);
+            return;
+        }
+        // Backspace
+        if (raw === '\x7F' || raw === '\x08') {
+            if (c > 0) {
+                const ph = findPlaceholderBeforeCursor(v, c);
+                if (ph) {
+                    const match = v.slice(ph.start, ph.end).match(/\[Pasted text #(\d+)/);
+                    if (match)
+                        pastedChunksRef.current.delete(parseInt(match[1], 10));
+                    const newVal = v.slice(0, ph.start) + v.slice(ph.end);
+                    emitChange(newVal);
+                    setCursor(ph.start);
+                }
+                else {
+                    const newVal = v.slice(0, c - 1) + v.slice(c);
+                    emitChange(newVal);
+                    setCursor(c - 1);
+                }
+            }
+            return;
+        }
+        // ← 左移光标
+        if (raw === '\x1B[D') {
+            setCursor(prev => Math.max(0, prev - 1));
+            return;
+        }
+        // → 右移光标
+        if (raw === '\x1B[C') {
+            setCursor(prev => Math.min(v.length, prev + 1));
+            return;
+        }
+        // ↑ 上移光标
+        if (raw === '\x1B[A') {
+            // 斜杠菜单激活时，上箭头 = 选中上一项
+            if (slashMenuActiveRef.current) {
+                onSlashMenuUpRef.current?.();
+                return;
+            }
+            const lines = v.split('\n');
+            if (lines.length <= 1) {
+                onUpArrowRef.current?.();
+                return;
+            }
+            const { row, col } = getCursorRowCol(v, c);
+            if (row === 0) {
+                onUpArrowRef.current?.();
+                return;
+            }
+            setCursor(rowColToOffset(v, row - 1, col));
+            return;
+        }
+        // ↓ 下移光标
+        if (raw === '\x1B[B') {
+            // 斜杠菜单激活时，下箭头 = 选中下一项
+            if (slashMenuActiveRef.current) {
+                onSlashMenuDownRef.current?.();
+                return;
+            }
+            const lines = v.split('\n');
+            if (lines.length <= 1) {
+                onDownArrowRef.current?.();
+                return;
+            }
+            const { row, col } = getCursorRowCol(v, c);
+            if (row >= lines.length - 1) {
+                onDownArrowRef.current?.();
+                return;
+            }
+            setCursor(rowColToOffset(v, row + 1, col));
+            return;
+        }
+        // Ctrl+C → 不在此处处理，交给上层 useInput 的双击退出逻辑
+        if (raw === '\x03')
+            return;
+        // 忽略控制字符和转义序列
+        if (raw === '\t') {
+            // 斜杠菜单激活时，Tab = 选中当前项
+            if (slashMenuActiveRef.current) {
+                onSlashMenuSelectRef.current?.();
+            }
+            else if (valueRef.current.length === 0) {
+                // 输入为空时，Tab = 填入 placeholder
+                onTabFillPlaceholderRef.current?.();
+            }
+            return;
+        }
+        if (raw === '\x1B') {
+            // 斜杠菜单激活时，ESC = 关闭菜单
+            if (slashMenuActiveRef.current) {
+                onSlashMenuCloseRef.current?.();
+            }
+            return;
+        }
+        if (raw.length === 1 && raw.charCodeAt(0) < 32)
+            return;
+        if (raw.startsWith('\x1B[') || raw.startsWith('\x1B]') || raw.startsWith('\x1BO'))
+            return;
+        // 可打印字符 → 在光标位置插入
+        const newVal = v.slice(0, c) + raw + v.slice(c);
+        emitChange(newVal);
+        setCursor(c + raw.length);
+    };
+    /**
+     * 处理批量缓冲区中积累的数据。
+     * 如果缓冲区包含换行（多行），视为粘贴；否则逐字符处理。
+     */
+    const flushBatchBuffer = () => {
+        const buf = batchBufferRef.current;
+        batchBufferRef.current = '';
+        batchTimerRef.current = null;
+        if (!buf)
+            return;
+        const cleaned = buf.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        // 多行 → 粘贴
+        if (cleaned.includes('\n') && cleaned.length > 1) {
+            insertPaste(cleaned);
+        }
+        else {
+            // 单字符或单行短文本，按普通输入处理
+            handleNormalInput(buf);
+        }
+    };
+    // Alt+Enter 组合键检测：ESC 可能单独到达，需要等待后续字符
+    const escTimerRef = useRef(null);
+    const ESC_WAIT_MS = 50; // 等待后续字符的时间窗口
+    useEffect(() => {
+        if (!stdin || !isActive)
+            return;
+        const onData = (data) => {
+            const raw = data.toString('utf-8');
+            // === Bracketed paste 模式处理（优先级最高） ===
+            if (raw.includes('\x1B[200~')) {
+                const startIdx = raw.indexOf('\x1B[200~') + 6;
+                const endIdx = raw.indexOf('\x1B[201~');
+                if (endIdx !== -1) {
+                    insertPaste(raw.slice(startIdx, endIdx));
+                }
+                else {
+                    pasteBufferRef.current = raw.slice(startIdx);
+                }
+                return;
+            }
+            if (pasteBufferRef.current !== null) {
+                const endIdx = raw.indexOf('\x1B[201~');
+                if (endIdx !== -1) {
+                    pasteBufferRef.current += raw.slice(0, endIdx);
+                    insertPaste(pasteBufferRef.current);
+                    pasteBufferRef.current = null;
+                }
+                else {
+                    pasteBufferRef.current += raw;
+                }
+                return;
+            }
+            // === 处理 ESC 等待状态：上一次收到了单独的 ESC，现在看后续字符 ===
+            if (escTimerRef.current !== null) {
+                clearTimeout(escTimerRef.current);
+                escTimerRef.current = null;
+                if (raw === '\r' || raw === '\n') {
+                    // ESC + Enter = Alt+Enter → 插入换行
+                    handleNormalInput('\x1B\r');
+                    return;
+                }
+                // ESC + 其他字符：先处理 ESC 本身，再处理当前字符
+                handleNormalInput('\x1B');
+                // 继续往下处理当前 raw
+            }
+            // === 非 bracketed paste：用时间窗口检测 ===
+            // 控制字符和转义序列不参与批量缓冲，直接处理
+            const isSingleControl = raw === '\r' || raw === '\n' ||
+                raw === '\x7F' || raw === '\x08' ||
+                raw === '\t' || raw === '\x1B' ||
+                raw === '\x1B\r' || raw === '\x1B\n' ||
+                raw.startsWith('\x1B[') || raw.startsWith('\x1B]') || raw.startsWith('\x1BO');
+            // Ctrl+C → 不拦截，让上层 useInput 处理双击退出
+            if (raw === '\x03')
+                return;
+            // Ctrl+O → 不拦截，让上层 useInput 处理详情展开/折叠
+            if (raw === '\x0F')
+                return;
+            // Ctrl+L → 拦截，不穿透到终端（避免清屏）
+            if (raw === '\x0C')
+                return;
+            // 单独的 ESC：进入等待状态，看后续是否跟着 Enter（Alt+Enter 组合）
+            if (raw === '\x1B') {
+                escTimerRef.current = setTimeout(() => {
+                    escTimerRef.current = null;
+                    handleNormalInput('\x1B');
+                }, ESC_WAIT_MS);
+                return;
+            }
+            if (isSingleControl && batchBufferRef.current === '') {
+                // 没有正在积累的缓冲，直接处理控制字符
+                handleNormalInput(raw);
+                return;
+            }
+            if (isSingleControl && batchBufferRef.current !== '') {
+                // 有缓冲在积累中，控制字符也追加进去（可能是粘贴内容中的 \r）
+                batchBufferRef.current += raw;
+                return;
+            }
+            // 可打印字符：追加到批量缓冲，重置定时器
+            batchBufferRef.current += raw;
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+            }
+            batchTimerRef.current = setTimeout(flushBatchBuffer, PASTE_DETECT_WINDOW_MS);
+        };
+        stdin.prependListener('data', onData);
+        return () => {
+            stdin.off('data', onData);
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+                batchTimerRef.current = null;
+            }
+            if (escTimerRef.current !== null) {
+                clearTimeout(escTimerRef.current);
+                escTimerRef.current = null;
+            }
+        };
+    }, [stdin, isActive]);
+    // 组件卸载时清理
+    useEffect(() => {
+        return () => {
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+            }
+            if (escTimerRef.current !== null) {
+                clearTimeout(escTimerRef.current);
+            }
+        };
+    }, []);
+    useInput(() => { }, { isActive });
+    // --- 渲染 ---
+    const isEmpty = value.length === 0;
+    if (isEmpty) {
+        // value 清空时重置粘贴状态
+        if (pasteCountRef.current > 0) {
+            pasteCountRef.current = 0;
+            pastedChunksRef.current.clear();
+        }
+        if (showCursor && placeholder.length > 0) {
+            return (_jsxs(Box, { children: [_jsx(Text, { inverse: true, color: "white", children: placeholder[0] }), _jsx(Text, { color: "gray", children: placeholder.slice(1) }), _jsx(Text, { color: "gray", dimColor: true, children: "  [Tab]" })] }));
+        }
+        return (_jsxs(Box, { children: [showCursor && _jsx(Text, { inverse: true, children: " " }), _jsx(Text, { color: "gray", children: placeholder })] }));
+    }
+    const lines = value.split('\n');
+    const { row: cursorRow, col: cursorCol } = getCursorRowCol(value, cursor);
+    /** 渲染一段文本，将其中的占位符高亮 */
+    const renderWithPlaceholders = (text, keyPrefix) => {
+        const parts = [];
+        let lastIndex = 0;
+        const re = new RegExp(PASTE_PLACEHOLDER_RE.source, 'g');
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            if (m.index > lastIndex) {
+                parts.push(_jsx(Text, { children: text.slice(lastIndex, m.index) }, `${keyPrefix}-t-${lastIndex}`));
+            }
+            parts.push(_jsx(Text, { color: "cyan", dimColor: true, children: m[0] }, `${keyPrefix}-p-${m.index}`));
+            lastIndex = m.index + m[0].length;
+        }
+        if (lastIndex < text.length) {
+            parts.push(_jsx(Text, { children: text.slice(lastIndex) }, `${keyPrefix}-t-${lastIndex}`));
+        }
+        return parts;
+    };
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, i) => {
+            if (!showCursor || i !== cursorRow) {
+                const parts = renderWithPlaceholders(line, `l${i}`);
+                return _jsx(Box, { children: parts.length > 0 ? parts : _jsx(Text, { children: " " }) }, i);
+            }
+            // 光标所在行
+            const before = line.slice(0, cursorCol);
+            const cursorChar = line[cursorCol] ?? ' ';
+            const after = line.slice(cursorCol + 1);
+            return (_jsxs(Box, { children: [renderWithPlaceholders(before, 'b'), _jsx(Text, { inverse: true, children: cursorChar }), renderWithPlaceholders(after, 'a')] }, i));
+        }) }));
+}

package/dist/components/SlashCommandMenu.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { SlashCommand } from '../commands/index.js';
+interface SlashCommandMenuProps {
+    commands: SlashCommand[];
+    selectedIndex: number;
+    /** 菜单最大可见行数 */
+    maxVisible?: number;
+}
+/**
+ * 斜杠命令下拉菜单组件
+ *
+ * 显示在输入框上方，支持滚动窗口。
+ */
+declare function SlashCommandMenu({ commands, selectedIndex, maxVisible, }: SlashCommandMenuProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof SlashCommandMenu>;
+export default _default;

package/dist/components/SlashCommandMenu.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+/** 类别标签颜色 */
+const categoryColor = {
+    agent: 'magenta',
+    tool: 'cyan',
+    builtin: 'gray',
+};
+const categoryLabel = {
+    agent: '智能体',
+    tool: '工具',
+    builtin: '内置',
+};
+/**
+ * 斜杠命令下拉菜单组件
+ *
+ * 显示在输入框上方，支持滚动窗口。
+ */
+function SlashCommandMenu({ commands, selectedIndex, maxVisible = 6, }) {
+    if (commands.length === 0) {
+        return (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "gray", italic: true, children: "\u65E0\u5339\u914D\u547D\u4EE4" }) }));
+    }
+    // 计算滚动窗口
+    const total = commands.length;
+    const visible = Math.min(total, maxVisible);
+    let start = 0;
+    if (selectedIndex >= visible) {
+        start = selectedIndex - visible + 1;
+    }
+    if (start + visible > total) {
+        start = Math.max(0, total - visible);
+    }
+    const visibleItems = commands.slice(start, start + visible);
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [start > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  \u2191 \u8FD8\u6709 ", start, " \u9879"] })), visibleItems.map((cmd, i) => {
+                const realIndex = start + i;
+                const isSelected = realIndex === selectedIndex;
+                const catColor = categoryColor[cmd.category] ?? 'gray';
+                const catText = categoryLabel[cmd.category] ?? cmd.category;
+                return (_jsxs(Box, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : 'white', children: [' ', "/", cmd.name, ' '] }), _jsxs(Text, { color: isSelected ? 'cyan' : 'gray', children: ["- ", cmd.description, ' '] }), _jsxs(Text, { color: catColor, dimColor: true, children: ["[", catText, "]"] })] }, cmd.name));
+            }), start + visible < total && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  \u2193 \u8FD8\u6709 ", total - start - visible, " \u9879"] }))] }));
+}
+export default React.memo(SlashCommandMenu);

package/dist/components/StatusBar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface StatusBarProps {
+    width: number;
+    totalTokens: number;
+}
+declare function StatusBar({ width, totalTokens }: StatusBarProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof StatusBar>;
+export default _default;

package/dist/components/StatusBar.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { MODEL_NAME, PROJECT_NAME, ENABLE_THINKING_MODE_TOGGLE, CONTEXT_TOKEN_LIMIT } from '../config/constants.js';
+/** 生成 token 用量进度条 */
+function tokenProgressBar(used, limit, barWidth) {
+    const ratio = Math.min(used / limit, 1);
+    const filled = Math.round(ratio * barWidth);
+    const empty = barWidth - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    const color = ratio >= 0.9 ? 'red' : ratio >= 0.7 ? 'yellow' : 'green';
+    return { bar, color };
+}
+function StatusBar({ width, totalTokens }) {
+    const left = ` ${MODEL_NAME} │ ${PROJECT_NAME}`;
+    // 右侧：token 进度条 + 思考模式切换（可选）
+    const tokenLabel = `${totalTokens}/${CONTEXT_TOKEN_LIMIT}`;
+    const barWidth = 10;
+    const { bar, color } = tokenProgressBar(totalTokens, CONTEXT_TOKEN_LIMIT, barWidth);
+    const effortPart = ENABLE_THINKING_MODE_TOGGLE ? ' │ ● medium · /effort' : '';
+    // 右侧完整文本长度（用于计算间距）
+    const rightLen = tokenLabel.length + 1 + barWidth + effortPart.length + 1;
+    const gap = Math.max(width - left.length - rightLen, 1);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: left }), _jsx(Text, { children: ' '.repeat(gap) }), _jsxs(Text, { color: "gray", children: [tokenLabel, " "] }), _jsx(Text, { color: color, children: bar }), ENABLE_THINKING_MODE_TOGGLE && _jsx(Text, { color: "gray", children: effortPart }), _jsx(Text, { children: " " })] }));
+}
+export default React.memo(StatusBar);

package/dist/components/StreamingText.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare function StreamingText({ text }: {
+    text: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare const _default: React.MemoExoticComponent<typeof StreamingText>;
+export default _default;

package/dist/components/StreamingText.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import MarkdownText from './MarkdownText.js';
+function StreamingText({ text }) {
+    if (!text)
+        return null;
+    return (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\u25CF" }), _jsx(Box, { marginLeft: 1, children: _jsx(MarkdownText, { text: text }) })] }) }));
+}
+export default React.memo(StreamingText);

package/dist/components/WelcomeHeader.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare function WelcomeHeader({ width }: {
+    width: number;
+}): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof WelcomeHeader>;
+export default _default;

package/dist/components/WelcomeHeader.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { APP_NAME, APP_VERSION, MODEL_NAME } from '../config/constants.js';
+function truncatePath(p, max) {
+    if (p.length <= max)
+        return p;
+    return '…' + p.slice(p.length - max + 1);
+}
+/** ASCII art logo */
+const LOGO_LINES = [
+    '     ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗',
+    '     ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝',
+    '     ██║███████║██████╔╝██║   ██║██║███████╗',
+    '██   ██║██╔══██║██╔══██╗╚██╗ ██╔╝██║╚════██║',
+    '╚█████╔╝██║  ██║██║  ██║ ╚████╔╝ ██║███████║',
+    ' ╚════╝ ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝',
+];
+const LOGO_COLORS = ['cyan', 'cyan', 'blueBright', 'blueBright', 'magenta', 'magenta'];
+function WelcomeHeader({ width }) {
+    const maxPath = Math.max(width - 10, 20);
+    const showLogo = width >= 52;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, width: width, children: [showLogo && (_jsx(Box, { flexDirection: "column", children: LOGO_LINES.map((line, i) => (_jsx(Text, { color: LOGO_COLORS[i], children: line }, i))) })), _jsxs(Box, { marginTop: 0, children: [_jsx(Text, { color: "gray" }), _jsx(Text, { color: "white", bold: true, children: "Your AI-Powered Dev Companion" }), _jsx(Text, { color: "gray" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: '─'.repeat(Math.min(width - 4, 48)) }) }), _jsxs(Box, { marginTop: 0, children: [_jsx(Text, { color: "gray", children: "model " }), _jsx(Text, { color: "cyan", children: MODEL_NAME }), _jsxs(Text, { color: "gray", children: ["  ", APP_NAME, " "] }), _jsx(Text, { color: "magenta", children: APP_VERSION })] }), _jsx(Box, { children: _jsx(Text, { color: "gray", children: truncatePath(process.cwd(), maxPath) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: '─'.repeat(Math.min(width - 4, 48)) }) }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "/" }), _jsx(Text, { color: "cyan", children: "init" }), _jsx(Text, { color: "gray", children: " \u521D\u59CB\u5316  " }), _jsx(Text, { color: "gray", children: "/" }), _jsx(Text, { color: "cyan", children: "help" }), _jsx(Text, { color: "gray", children: " \u5E2E\u52A9  " }), _jsx(Text, { color: "gray", children: "/" }), _jsx(Text, { color: "cyan", children: "new" }), _jsx(Text, { color: "gray", children: " \u65B0\u4F1A\u8BDD  " }), _jsx(Text, { color: "gray", children: "/" }), _jsx(Text, { color: "cyan", children: "agent" }), _jsx(Text, { color: "gray", children: " \u5207\u6362" })] }), _jsx(Text, { children: ' ' })] }));
+}
+export default React.memo(WelcomeHeader);

package/dist/config/agentState.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 智能体选择状态管理
+ *
+ * 持久化当前激活的智能体到 ~/.jarvis/agent.json
+ * 启动时自动读取，运行时可动态切换。
+ */
+/**
+ * 获取当前激活的智能体名称
+ *
+ * 优先级：运行时设置 > 持久化文件 > fallback
+ */
+export declare function getActiveAgent(fallback: string): string;
+/**
+ * 切换当前激活的智能体（运行时 + 持久化）
+ */
+export declare function setActiveAgent(name: string): void;

package/dist/config/agentState.js

@@ -0,0 +1,65 @@
+/**
+ * 智能体选择状态管理
+ *
+ * 持久化当前激活的智能体到 ~/.jarvis/agent.json
+ * 启动时自动读取，运行时可动态切换。
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const JARVIS_HOME = path.join(os.homedir(), '.jarvis');
+const AGENT_STATE_FILE = path.join(JARVIS_HOME, 'agent.json');
+/** 运行时当前激活的智能体名称 */
+let _currentAgent = null;
+/** 确保 ~/.jarvis 目录存在 */
+function ensureDir() {
+    if (!fs.existsSync(JARVIS_HOME)) {
+        fs.mkdirSync(JARVIS_HOME, { recursive: true });
+    }
+}
+/** 从 ~/.jarvis/agent.json 读取持久化的智能体选择 */
+function loadPersistedAgent() {
+    try {
+        if (!fs.existsSync(AGENT_STATE_FILE))
+            return null;
+        const raw = fs.readFileSync(AGENT_STATE_FILE, 'utf-8');
+        const state = JSON.parse(raw);
+        return state.activeAgent || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 持久化智能体选择到 ~/.jarvis/agent.json */
+function persistAgent(name) {
+    try {
+        ensureDir();
+        const state = { activeAgent: name };
+        fs.writeFileSync(AGENT_STATE_FILE, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.error('[agentState] 持久化失败:', err instanceof Error ? err.message : err);
+    }
+}
+/**
+ * 获取当前激活的智能体名称
+ *
+ * 优先级：运行时设置 > 持久化文件 > fallback
+ */
+export function getActiveAgent(fallback) {
+    if (_currentAgent)
+        return _currentAgent;
+    const persisted = loadPersistedAgent();
+    if (persisted) {
+        _currentAgent = persisted;
+        return persisted;
+    }
+    return fallback;
+}
+/**
+ * 切换当前激活的智能体（运行时 + 持久化）
+ */
+export function setActiveAgent(name) {
+    _currentAgent = name;
+    persistAgent(name);
+}