ningzhi-agent-cli 0.0.1

package/dist/agent/agent.js

@@ -0,0 +1,432 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAgent = initAgent;
+exports.runAgentStream = runAgentStream;
+exports.runSubAgent = runSubAgent;
+exports.compressContext = compressContext;
+const langgraph_checkpoint_sqlite_1 = require("@langchain/langgraph-checkpoint-sqlite");
+const messages_1 = require("@langchain/core/messages");
+const langgraph_1 = require("@langchain/langgraph");
+const langgraph_2 = require("@langchain/langgraph");
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("node:fs"));
+const db_1 = require("./db");
+const tools_1 = require("./tools");
+const context_1 = require("./context");
+const colors_1 = require("./colors");
+const prompt_1 = require("./prompt");
+const read_1 = require("./permission/read");
+const write_1 = require("./permission/write");
+const exec_1 = require("./permission/exec");
+const network_1 = require("./permission/network");
+const hooks_1 = require("./hooks");
+dotenv.config();
+const model_1 = require("./model");
+// ── 模型 ──────────────────────────────────────────────────
+const model = (0, model_1.createModel)({ streaming: true });
+// ── State Schema ──────────────────────────────────────────
+const StateAnnotation = langgraph_1.Annotation.Root({
+    // 完整对话消息列表（含 HumanMessage / AIMessage / ToolMessage 等）
+    messages: (0, langgraph_1.Annotation)({
+        // reducer：合并状态更新时使用 langgraph 内置的消息合并器（按 id 去重、追加新消息、支持删除/替换）
+        reducer: langgraph_2.messagesStateReducer,
+        default: () => [],
+    }),
+    contextSummary: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next, // 保持最新摘要
+        default: () => null,
+    }),
+    compressionCount: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next, // 保持最新压缩次数
+        default: () => 0,
+    }),
+    lastCompressedIndex: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next, // 保持最新压缩索引
+        default: () => 0,
+    }),
+});
+// ── Graph Nodes ───────────────────────────────────────────
+function shouldContinue(state) {
+    const lastMessage = state.messages[state.messages.length - 1];
+    if (messages_1.AIMessage.isInstance(lastMessage) && lastMessage.tool_calls?.length) {
+        return "tools";
+    }
+    return langgraph_1.END;
+}
+/**
+ * 简化工具调用消息，只保留最近 3 个
+ * @param messages - 原始消息数组
+ * @returns 简化后的消息数组
+ */
+function simplifyToolMessages(messages) {
+    const toolIndices = [];
+    // 找到所有工具调用消息的索引
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].type === "tool") {
+            toolIndices.push(i);
+        }
+    }
+    // 只保留最近 3 个工具调用消息
+    const recentToolIndices = new Set(toolIndices.slice(-3));
+    // 遍历所有消息，简化工具调用消息
+    return messages.map((msg, i) => {
+        if (msg.type !== "tool")
+            return msg;
+        if (recentToolIndices.has(i))
+            return msg;
+        const toolMsg = msg;
+        if (toolMsg.name === "read_file")
+            return msg;
+        // 简化工具调用消息，只保留工具名
+        return new messages_1.ToolMessage({
+            content: `[Previous: used ${toolMsg.name}]`,
+            tool_call_id: toolMsg.tool_call_id,
+            name: toolMsg.name,
+        });
+    });
+}
+// ── 记忆 ──────────────────────────────────────────────────
+// recursive 作用： 1. 目录已存在时静默跳过(最重要)不报错。   2. 支持多级路径自动补全父目录：
+// fs.mkdirSync("a/b/c", { recursive: true }); // 一口气把 a、a/b、a/b/c 全建出来
+fs.mkdirSync(".dbData", { recursive: true });
+const checkpointer = langgraph_checkpoint_sqlite_1.SqliteSaver.fromConnString(db_1.DB_PATH);
+// ── Agent Graph 工厂 ──────────────────────────────────────
+function createAgentGraph(toolList) {
+    const modelWithTheseTools = model.bindTools(toolList);
+    async function modelRequest(state, config) {
+        let modelMessages = state.messages ?? [];
+        // 如果有历史摘要，添加到系统提示词
+        if (state.contextSummary && state.lastCompressedIndex > 0) {
+            const summaryMsg = new messages_1.SystemMessage(`历史对话摘要：\n\n${state.contextSummary}`);
+            // 从压缩索引开始添加新消息
+            modelMessages = [
+                summaryMsg,
+                ...modelMessages.slice(state.lastCompressedIndex),
+            ];
+        }
+        // 简化工具调用消息，只保留工具名
+        modelMessages = simplifyToolMessages(modelMessages);
+        // 上下文压缩的最后一道防线
+        // 只保留最近 500 条消息， 极端场景，一般达不到，是为了防止上下文爆炸，不过一般不加这个逻辑也可以正常工作
+        modelMessages = modelMessages.slice(-500);
+        // 构建模型输入，包含系统提示词和简化后的消息
+        const messages = [new messages_1.SystemMessage(prompt_1.systemPrompt), ...modelMessages];
+        // 调用模型
+        const response = await modelWithTheseTools.invoke(messages, config);
+        // 返回模型响应， response 是一个 AIMessage 对象
+        return { messages: [response] };
+    }
+    async function toolNode(state, config) {
+        const messages = state.messages;
+        // 找到所有工具调用消息的 id
+        const toolMessageIds = new Set(messages
+            .filter((msg) => msg.type === "tool")
+            .map((msg) => msg.tool_call_id));
+        // 找到最后一个 AI 消息
+        let aiMessage;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages_1.AIMessage.isInstance(messages[i])) {
+                aiMessage = messages[i];
+                break;
+            }
+        }
+        // 如果没有 AI 消息，或者不是 AI 消息，抛出错误
+        if (!aiMessage || !messages_1.AIMessage.isInstance(aiMessage)) {
+            throw new Error("ToolNode only accepts AIMessages as input.");
+        }
+        // 过滤出 未处理的工具调用, 就是 id 为 null 或不在 toolMessageIds 中的
+        // 如果 ai message 某个工具调用的 id 找不到对应的 ToolMessage，说明它还没被执行过，
+        // 正常是走 !toolMessageIds.has(call.id) 这个逻辑
+        const toolCalls = aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)) ?? [];
+        if (toolCalls.length === 0) {
+            return { messages: [] };
+        }
+        // 过滤出允许执行的工具调用
+        const allowCalls = [];
+        const blockMessages = [];
+        const confirmCalls = [];
+        // 遍历所有工具调用，根据权限等级判断是否允许执行
+        for (const call of toolCalls) {
+            const tool = toolList.find((t) => t.name === call.name);
+            const level = tool?.permission_level;
+            let decision;
+            if (level === "read") {
+                decision = (0, read_1.checkReadPermission)(call);
+            }
+            else if (level === "write") {
+                decision = (0, write_1.checkWritePermission)(call);
+            }
+            else if (level === "exec") {
+                decision = (0, exec_1.checkExecPermission)(call);
+            }
+            else if (level === "network") {
+                decision = (0, network_1.checkNetworkPermission)(call);
+            }
+            else if (level === "mcp") {
+                decision = { action: "confirm" };
+            }
+            else {
+                decision = { action: "allow" };
+            }
+            if (decision.action === "allow") {
+                allowCalls.push(call);
+            }
+            else if (decision.action === "block") {
+                blockMessages.push(new messages_1.ToolMessage({
+                    content: decision.reason,
+                    tool_call_id: call.id ?? "",
+                    name: call.name,
+                }));
+            }
+            else {
+                confirmCalls.push(call);
+            }
+        }
+        // 执行允许执行的工具调用
+        async function executeCalls(calls) {
+            return Promise.all(calls.map(async (call) => {
+                const tool = toolList.find((t) => t.name === call.name);
+                console.log((0, colors_1.formatToolLog)(call.name, JSON.stringify(call.args)));
+                try {
+                    const threadId = config?.configurable?.thread_id || "";
+                    // PreToolUse hook
+                    const preResult = await (0, hooks_1.runPreToolUseHooks)({
+                        toolName: call.name,
+                        toolArgs: call.args,
+                        toolCallId: call.id ?? "",
+                        threadId,
+                    });
+                    if (preResult.action === "block") {
+                        return new messages_1.ToolMessage({
+                            content: preResult.reason,
+                            tool_call_id: call.id ?? "",
+                            name: call.name,
+                        });
+                    }
+                    if (!tool)
+                        throw new Error(`Tool "${call.name}" not found.`);
+                    const output = await tool.invoke({ ...call, type: "tool_call" }, config);
+                    let content = typeof output === "string" ? output : JSON.stringify(output);
+                    // PostToolUse hook
+                    const postResult = await (0, hooks_1.runPostToolUseHooks)({
+                        toolName: call.name,
+                        toolArgs: call.args,
+                        toolOutput: content,
+                        toolCallId: call.id ?? "",
+                        threadId,
+                    });
+                    if (postResult.action === "block") {
+                        content = postResult.reason;
+                    }
+                    else if (postResult.action === "inject") {
+                        content = `[Hook injection]\n${postResult.message}\n\n${content}`;
+                    }
+                    if (preResult.action === "inject") {
+                        content = `[Hook injection]\n${preResult.message}\n\n${content}`;
+                    }
+                    const finalContent = await (0, tools_1.maybePersistedOutput)(content, call.id ?? "");
+                    return new messages_1.ToolMessage({
+                        content: finalContent,
+                        tool_call_id: call.id ?? "",
+                        name: call.name,
+                    });
+                }
+                catch (e) {
+                    return new messages_1.ToolMessage({
+                        content: `Error: ${e.message}\n Please fix your mistakes.`,
+                        tool_call_id: call.id ?? "",
+                        name: call.name,
+                    });
+                }
+            }));
+        }
+        const allowOutputs = await executeCalls(allowCalls);
+        if (confirmCalls.length === 0) {
+            return { messages: [...allowOutputs, ...blockMessages] };
+        }
+        const result = (0, langgraph_1.interrupt)({ toolCalls: confirmCalls });
+        if (result !== "approved") {
+            const deniedMessages = confirmCalls.map((call) => new messages_1.ToolMessage({
+                content: "Tool execution was denied by the user.",
+                tool_call_id: call.id ?? "",
+                name: call.name,
+            }));
+            return {
+                messages: [...allowOutputs, ...blockMessages, ...deniedMessages],
+            };
+        }
+        const confirmOutputs = await executeCalls(confirmCalls);
+        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs] };
+    }
+    // 定义工作流
+    const workflow = new langgraph_1.StateGraph(StateAnnotation)
+        .addNode("model_request", modelRequest)
+        .addNode("tools", toolNode)
+        .addEdge(langgraph_1.START, "model_request")
+        .addConditionalEdges("model_request", shouldContinue, {
+        tools: "tools",
+        [langgraph_1.END]: langgraph_1.END,
+    })
+        .addEdge("tools", "model_request");
+    // 编译工作流
+    return workflow.compile({
+        checkpointer,
+    });
+}
+// ── Agent 创建 ────────────────────────────────────────────
+let agent = null;
+let subAgent = null;
+async function initAgent() {
+    await (0, tools_1.initTools)();
+    agent = createAgentGraph(tools_1.tools);
+    subAgent = createAgentGraph(tools_1.tools.filter((t) => t.name !== "agent_tool"));
+}
+function getAgent() {
+    if (!agent)
+        throw new Error("Agent not initialized. Call initAgent() first.");
+    return agent;
+}
+function getSubAgent() {
+    if (!subAgent)
+        throw new Error("Agent not initialized. Call initAgent() first.");
+    return subAgent;
+}
+// ── 核心运行逻辑 ──────────────────────────────────────────
+async function _runAgent(compiledAgent, userMessage, onToken, onToolConfirmation, threadId, signal) {
+    const config = { configurable: { thread_id: threadId } };
+    let fullResponse = "";
+    let usageMetadata;
+    let input = { messages: [new messages_1.HumanMessage(userMessage)] };
+    while (true) {
+        const stream = await compiledAgent.stream(input, {
+            ...config,
+            streamMode: "messages",
+            signal,
+        });
+        // for await...of 遍历的是 异步可迭代对象（AsyncIterable）
+        // 每次 next() 返回的是 Promise，需要 await 才能拿到下一项。 LangGraph 的 agent.stream(...) 返回一个 AsyncGenerator。它的特点是：
+        // 不是一次性把结果给你，而是 LLM 每生成一个 token（或一小批 token），就 yield 一次。 必须等网络/模型把这块数据推送过来才能继续，这正是 await 存在的意义。
+        for await (const chunk of stream) {
+            if (signal?.aborted) {
+                throw new Error("abort");
+            }
+            const message = chunk[0];
+            const metadata = chunk[1];
+            // streamMode: "messages" 下，工具调用等非模型节点产生的消息也会出现在流里，
+            // 通过 metadata.langgraph_node 过滤，只保留模型节点（model_request）输出的 token
+            if (metadata?.langgraph_node !== "model_request")
+                continue;
+            // 从 message 中提取 token 使用信息
+            const msgUsage = message.usage_metadata;
+            if (msgUsage) {
+                usageMetadata = msgUsage;
+            }
+            // AIMessageChunk 的 content 在 message.content 属性上，不在 kwargs.content
+            const content = message.content ?? message.kwargs?.content ?? "";
+            const toolCallChunks = message.tool_call_chunks ?? [];
+            // 过滤掉工具调用消息，只保留模型节点（model_request）输出的 token
+            if (!content || toolCallChunks.length > 0)
+                continue;
+            // 回调 token 给调用方
+            onToken(content);
+            fullResponse += content;
+        }
+        // 流消费完后，取出当前会话状态，检查是否卡在 interrupt 上
+        // （toolNode 里的 interrupt({ toolCalls }) 会让图执行暂停，等待外部 resume）
+        const state = await compiledAgent.getState(config);
+        // 找到处于中断状态的任务（其 interrupts 数组非空）
+        const interruptedTask = state.tasks?.find((t) => t.interrupts?.length > 0);
+        // 没有中断任务，说明本轮已正常走到 END，退出 while 循环
+        if (!interruptedTask)
+            break;
+        // =====》 有需要用户确认的工具调用，就会有中断任务  《===== 工具节点中断，来到 model_request 节点
+        // 把待确认的工具调用清单回调给调用方，由用户决定是否执行
+        const confirmed = await onToolConfirmation(interruptedTask.interrupts[0].value.toolCalls);
+        // 用 Command({ resume }) 把用户的决定送回给正在等待的 interrupt()   =====》  发送给 toolNode
+        // 从 toolNode 里 interrupt() 调用的那一行继续往下执行
+        // 对应 toolNode 中 `const result = interrupt({ toolCalls })` 的返回值
+        input = new langgraph_1.Command({ resume: confirmed ? "approved" : "denied" });
+    }
+    // 返回完整回复及 token 使用信息
+    return { response: fullResponse, usageMetadata };
+}
+/**
+ * 以流式方式运行 agent，将 token 逐个回调给调用方
+ * @param {string} userMessage - 当前用户输入（历史已由 checkpointer 自动续接）
+ * @param {Function} onToken   - 每个 token 到来时的回调 (token: string) => void
+ * @param {Function} onToolConfirmation - tool 调用前的确认回调，返回 true 则执行，false 则拒绝
+ * @param {string} threadId    - 会话 ID，相同 ID 自动续上历史记录
+ * @returns {Promise<{ response: string; usageMetadata?: UsageMetadata }>}  完整的 AI 回复文本及 token 使用信息
+ */
+async function runAgentStream(userMessage, onToken, onToolConfirmation, threadId = "default-session", signal) {
+    return _runAgent(getAgent(), userMessage, onToken, onToolConfirmation, threadId, signal);
+}
+/**
+ * 启动一个 subagent 执行独立任务，完成后返回结果
+ * @param {string} prompt - 给 subagent 的任务提示
+ * @returns {Promise<string>} subagent 的最终回复
+ */
+async function runSubAgent(prompt) {
+    const threadId = `subagent-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const result = await _runAgent(getSubAgent(), prompt.trim(), () => { }, // 不需要流式输出
+    async () => true, // subagent 自动确认 tools
+    threadId, undefined);
+    return result.response;
+}
+// 压缩上下文
+async function compressContext(threadId) {
+    const config = { configurable: { thread_id: threadId } };
+    const currentState = await getAgent().getState(config);
+    const messages = currentState.values.messages || [];
+    const existingSummary = currentState.values.contextSummary || null;
+    const lastIndex = currentState.values.lastCompressedIndex || 0;
+    const count = currentState.values.compressionCount || 0;
+    const recentKeep = 6;
+    const safeIndex = (0, context_1.findSafeCompressionIndex)(messages, recentKeep);
+    if (safeIndex <= lastIndex) {
+        return { didCompress: false, count };
+    }
+    // 从 lastCompressedIndex 开始，压缩到 safeIndex
+    // safeIndex 是最近保留的索引，压缩到 safeIndex 之前的消息
+    const toCompress = messages.slice(lastIndex, safeIndex);
+    const newSummary = await (0, context_1.compressMessages)(toCompress, existingSummary);
+    await getAgent().updateState(config, {
+        contextSummary: newSummary,
+        lastCompressedIndex: safeIndex,
+        compressionCount: count + 1,
+    });
+    return { didCompress: true, count: count + 1 };
+}

package/dist/agent/cli.d.ts

@@ -0,0 +1 @@
+export declare function interactiveChat(): Promise<void>;

package/dist/agent/cli.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactiveChat = interactiveChat;
+const readline = __importStar(require("readline")); // readline 用于处理命令行输入输出，提供交互式界面
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const agent_1 = require("./agent");
+const context_1 = require("./context");
+const colors_1 = require("./colors");
+const hooks_1 = require("./hooks");
+const commands_1 = require("./commands");
+const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+// 打印启动 Banner：ASCII 艺术标题 + 信息盒 + 使用说明
+async function printBanner() {
+    // 动态导入 figlet（ASCII 字体）和 boxen（边框盒子），避免首屏加载开销
+    const figlet = (await Promise.resolve().then(() => __importStar(require("figlet")))).default; // figlet 用于生成 ASCII 字体
+    const { default: boxen } = await Promise.resolve().then(() => __importStar(require("boxen"))); // boxen 用于创建带边框的文本框
+    // 用 Slant 字体渲染包名，并以 banner 色输出
+    console.log(colors_1.color.banner(figlet.textSync(pkg.name, { font: "Slant" })));
+    // 信息盒内容：每行「字段名: 值」，字段名用灰色弱化
+    const info = [
+        `${colors_1.color.gray("Description")}: ${pkg.description}`,
+        `${colors_1.color.gray("Version")}:     ${pkg.version}`,
+        `${colors_1.color.gray("Author")}:      ${pkg.author}`,
+        `${colors_1.color.gray("Docs")}:        ${pkg.docs}`,
+    ].join("\n");
+    // boxen 把 info 包成圆角边框盒子，padding=1 留内边距，灰色边框
+    console.log(boxen(info, {
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "gray",
+    }));
+    // 使用说明：按键与退出命令
+    console.log("Usage:");
+    console.log("  ESC       - Cancel AI request");
+    console.log("  exit      - Exit the chat");
+    for (const [name, cmd] of commands_1.commands) {
+        // padEnd 如果不足8个字符，用空格填充到8个字符
+        console.log(`  /${name.padEnd(8)} - ${cmd.description}`);
+    }
+    console.log();
+}
+function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface(); // 创建 readline 接口，用于处理用户输入
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+async function chat(userInput) {
+    const rl = createInterface();
+    process.stdout.write("\n" + colors_1.color.aiPrefix());
+    const controller = new AbortController();
+    // 监听 ESC 键，中断 AI 请求
+    const escListener = (_str, key) => {
+        if (key.name === "escape" || key.name === "esc") {
+            process.stdout.write("\n\n" + colors_1.color.cancelled("[Cancelled]") + "\n");
+            controller.abort();
+            rl.close();
+        }
+    };
+    // 让 process.stdin 开始发出 "keypress" 事件（默认不发）
+    // 这样才能在 AI 请求过程中 实时捕获 ESC 键而不必等待用户按回车
+    readline.emitKeypressEvents(process.stdin);
+    // 监听 process.stdin 的 "keypress" 事件，捕获 ESC 键
+    process.stdin.on("keypress", escListener);
+    let usageMetadata;
+    try {
+        const result = await (0, agent_1.runAgentStream)(userInput, (token) => {
+            process.stdout.write(token);
+        }, async (toolCalls) => {
+            for (const call of toolCalls) {
+                console.log((0, colors_1.formatToolLog)(call.name, JSON.stringify(call.args)));
+            }
+            const answer = await new Promise((resolve) => {
+                rl.question("确认执行以上工具? (y/n): ", resolve);
+            });
+            return (answer.trim().toLowerCase() === "y" ||
+                answer.trim().toLowerCase() === "yes");
+        }, commands_1.threadId, controller.signal);
+        usageMetadata = result.usageMetadata;
+    }
+    catch (err) {
+        if (err.message !== "abort") {
+            throw err;
+        }
+    }
+    finally {
+        process.stdin.removeListener("keypress", escListener);
+        // 关闭接口，"交出对 stdin 的控制权"，移除 readline 挂在 stdin 上的内部监听
+        rl.close();
+    }
+    // 在一轮对话 结束后打印 token 使用情况
+    if (usageMetadata) {
+        const limit = (0, context_1.getModelContextLimit)();
+        const percentage = (usageMetadata.total_tokens / limit) * 100;
+        const percentageStr = percentage.toFixed(1);
+        const tokenText = `\n\nTokens: ${usageMetadata.total_tokens.toLocaleString()} / ${limit.toLocaleString()} (${percentageStr}%)`;
+        if (percentage >= 80) {
+            process.stdout.write("\n" +
+                colors_1.color.error(tokenText) +
+                "\n" +
+                colors_1.color.error("警告：Context window 接近大模型接口上限，即将压缩 Context，可能会丢失信息") +
+                "\n" +
+                colors_1.color.error("建议输入 /new 命令开启新会话"));
+            try {
+                const result = await (0, agent_1.compressContext)(commands_1.threadId);
+                if (result.didCompress) {
+                    process.stdout.write("\n" +
+                        colors_1.color.error(`Context 已压缩（第 ${result.count} 次），已保留最近 6 条消息`) +
+                        "\n");
+                    if (result.count >= 3) {
+                        process.stdout.write(colors_1.color.error("强烈建议输入 /new 命令开启新会话，以避免信息丢失") +
+                            "\n");
+                    }
+                }
+            }
+            catch {
+                // 压缩失败不影响主流程
+            }
+        }
+        else {
+            process.stdout.write("\n" + colors_1.color.tokenInfo(tokenText));
+        }
+    }
+    process.stdout.write("\n\n");
+    // 在本轮对话的 readline 接口关闭后，把`process.stdin` 恢复回“流动模式”，
+    // 确保下一轮`prompt()` 能正常读到用户输入
+    // `rl.close()` 移除了所有消费者之后，stdin 可能退回暂停模式。
+    // 如果不恢复，下一轮主循环里`prompt()` 新建的接口有可能出现“提示符显示了但打字没反应”的情况
+    rl.resume();
+}
+async function interactiveChat() {
+    await printBanner();
+    await (0, hooks_1.runSessionStartHooks)(commands_1.threadId);
+    while (true) {
+        const userInput = await prompt(colors_1.color.userPrefix());
+        if (!userInput.trim())
+            continue;
+        if (userInput.toLowerCase() === "exit") {
+            console.log(colors_1.color.goodbye("再见！"));
+            break;
+        }
+        // 以 "/" 开头的输入按内置命令处理（如 /skills），否则交给 AI
+        if (userInput.startsWith("/")) {
+            // 按空白（空格/Tab）拆分，如 "/new abc" -> ["/new", "abc"]
+            const parts = userInput.trim().split(/\s+/);
+            // 去掉首字符 "/" 得到命令名，例如："​/new" -> "new"
+            const cmdName = parts[0].slice(1);
+            // 其余部分作为命令参数传给处理器
+            const args = parts.slice(1);
+            const cmd = commands_1.commands.get(cmdName);
+            if (cmd) {
+                await cmd.execute(args);
+            }
+            else {
+                console.log(colors_1.color.error(`Unknown command: ${cmdName}`));
+            }
+            continue; // 命令已处理完，回到循环等待下一次输入
+        }
+        try {
+            await chat(userInput);
+        }
+        catch (err) {
+            console.error(colors_1.color.error(`请求出错: ${err.message}`));
+        }
+    }
+}

package/dist/agent/colors.d.ts

@@ -0,0 +1,19 @@
+export declare function initColors(): Promise<void>;
+export declare const color: {
+    banner: (text: string) => string;
+    userPrefix: () => string;
+    aiPrefix: () => string;
+    goodbye: (text: string) => string;
+    cancelled: (text: string) => string;
+    error: (text: string) => string;
+    toolTag: () => string;
+    toolName: (name: string) => string;
+    toolAction: () => string;
+    toolArg: (arg: string) => string;
+    gray: (text: string) => string;
+    tokenInfo: (text: string) => string;
+    warn: (text: string) => string;
+    info: (text: string) => string;
+    good: (text: string) => string;
+};
+export declare function formatToolLog(name: string, detail?: string): string;