@code4bug/jarvis-agent 1.0.2

package/dist/services/api/llm.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 真实 LLM 服务 - 支持 OpenAI 兼容 API（流式）
+ *
+ * 配置来源（优先级从低到高）：
+ *   1. 环境变量 API_KEY / LLM_MODEL / API_BASE_URL
+ *   2. ~/.jarvis/config.json
+ *   3. ./.jarvis/config.json
+ */
+import { LLMService, StreamCallbacks, TranscriptMessage, Tool, AbortSignal as AppAbortSignal } from '../../types/index.js';
+import { ModelConfig } from '../../config/loader.js';
+export interface LLMConfig {
+    apiKey: string;
+    model: string;
+    maxTokens: number;
+    baseUrl?: string;
+    temperature?: number;
+}
+/** 从配置文件构建 LLMConfig，找不到则回退环境变量 */
+export declare function getDefaultConfig(): LLMConfig;
+/** 将 ModelConfig 转为 LLMConfig */
+export declare function fromModelConfig(mc: ModelConfig): LLMConfig;
+export declare class LLMServiceImpl implements LLMService {
+    private config;
+    private systemPrompt;
+    constructor(config?: LLMConfig);
+    streamMessage(transcript: TranscriptMessage[], tools: Tool[], callbacks: StreamCallbacks, abortSignal?: AppAbortSignal): Promise<void>;
+}

package/dist/services/api/llm.js

@@ -0,0 +1,314 @@
+/**
+ * 真实 LLM 服务 - 支持 OpenAI 兼容 API（流式）
+ *
+ * 配置来源（优先级从低到高）：
+ *   1. 环境变量 API_KEY / LLM_MODEL / API_BASE_URL
+ *   2. ~/.jarvis/config.json
+ *   3. ./.jarvis/config.json
+ */
+import { loadConfig, getActiveModel } from '../../config/loader.js';
+import { getAgent } from '../../agents/index.js';
+import { DEFAULT_AGENT } from '../../config/constants.js';
+import { getActiveAgent } from '../../config/agentState.js';
+import { getSystemInfoPrompt } from '../../config/systemInfo.js';
+/** 从配置文件构建 LLMConfig，找不到则回退环境变量 */
+export function getDefaultConfig() {
+    const jarvisCfg = loadConfig();
+    const active = getActiveModel(jarvisCfg);
+    if (active) {
+        return fromModelConfig(active);
+    }
+    // 回退：环境变量
+    return {
+        apiKey: process.env.API_KEY || '',
+        model: process.env.LLM_MODEL || 'claude-sonnet-4-20250514',
+        maxTokens: 4096,
+        baseUrl: process.env.API_BASE_URL,
+    };
+}
+/** 将 ModelConfig 转为 LLMConfig */
+export function fromModelConfig(mc) {
+    return {
+        apiKey: mc.api_key,
+        model: mc.model,
+        maxTokens: mc.max_tokens ?? 4096,
+        baseUrl: mc.api_url,
+        temperature: mc.temperature,
+    };
+}
+/** 将内部 TranscriptMessage[] 转为 OpenAI messages 格式 */
+function toOpenAIMessages(transcript, systemPrompt) {
+    const messages = [];
+    // 系统提示 — 来自当前激活的智能体定义
+    messages.push({
+        role: 'system',
+        content: systemPrompt,
+    });
+    for (const msg of transcript) {
+        if (msg.role === 'user') {
+            messages.push({ role: 'user', content: msg.content });
+        }
+        else if (msg.role === 'assistant') {
+            // 兼容 content 为 string（旧会话恢复）或 ContentBlock[] 两种情况
+            if (typeof msg.content === 'string') {
+                messages.push({ role: 'assistant', content: msg.content || '(empty)' });
+            }
+            else {
+                const blocks = msg.content;
+                let text = '';
+                const toolCalls = [];
+                for (const block of blocks) {
+                    if (block.type === 'text') {
+                        text += block.text;
+                    }
+                    else if (block.type === 'tool_use') {
+                        toolCalls.push({
+                            id: block.id,
+                            type: 'function',
+                            function: {
+                                name: block.name,
+                                arguments: JSON.stringify(block.input),
+                            },
+                        });
+                    }
+                }
+                const assistantMsg = { role: 'assistant' };
+                // 确保 content 不为空，避免 API MissingParameter 错误
+                assistantMsg.content = text || null;
+                if (toolCalls.length > 0)
+                    assistantMsg.tool_calls = toolCalls;
+                messages.push(assistantMsg);
+            }
+        }
+        else if (msg.role === 'tool_result') {
+            messages.push({
+                role: 'tool',
+                tool_call_id: msg.toolUseId || '',
+                content: msg.content,
+            });
+        }
+    }
+    return messages;
+}
+/** 将内部 Tool[] 转为 OpenAI tools 格式 */
+function toOpenAITools(tools) {
+    if (tools.length === 0)
+        return [];
+    return tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: {
+                type: 'object',
+                properties: Object.fromEntries(Object.entries(t.parameters).map(([k, v]) => [k, { type: v.type, description: v.description }])),
+                required: Object.entries(t.parameters)
+                    .filter(([, v]) => v.required !== false)
+                    .map(([k]) => k),
+            },
+        },
+    }));
+}
+/** 解析单行 SSE data，返回 delta 或 null（[DONE] / 空行） */
+function parseSSELine(line) {
+    if (!line.startsWith('data: '))
+        return null;
+    const data = line.slice(6).trim();
+    if (data === '[DONE]')
+        return null;
+    try {
+        const parsed = JSON.parse(data);
+        return parsed.choices?.[0]?.delta ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ===== LLMServiceImpl =====
+export class LLMServiceImpl {
+    config;
+    systemPrompt;
+    constructor(config) {
+        this.config = config ?? getDefaultConfig();
+        if (!this.config.apiKey) {
+            throw new Error('API_KEY 未配置。请在 .jarvis/config.json 或环境变量中设置。');
+        }
+        // 从当前激活的智能体加载 system prompt（运行时动态读取）
+        const currentAgent = getActiveAgent(DEFAULT_AGENT);
+        const agent = getAgent(currentAgent);
+        const agentPrompt = agent?.systemPrompt
+            ?? '你是一个强大的终端智能助手。回答时使用中文，简洁明了。当需要操作文件系统或执行命令时，请调用对应的工具。';
+        // 追加通用角色边界约束（兜底）+ 安全围栏说明
+        const roleBoundary = '\n\n---\n[系统约束] 你必须严格遵守智能体定义中的角色边界。' +
+            '只回答与你角色职责相关的问题。' +
+            '对于超出角色范围的请求，礼貌拒绝并引导用户回到你的专业领域。' +
+            '不要为了讨好用户而突破角色边界。' +
+            '\n\n[安全围栏] 系统已内置安全围栏（Safeguard），会自动拦截危险命令并弹出交互式确认菜单。' +
+            '当你需要执行任何命令时，直接调用 Bash 工具即可，不要自行判断命令是否危险，不要用文字询问用户"是否确认执行"。' +
+            '安全围栏会自动处理拦截和用户确认流程。';
+        // 追加系统环境信息，帮助 LLM 感知用户运行环境
+        const systemInfo = getSystemInfoPrompt();
+        this.systemPrompt = agentPrompt + roleBoundary + systemInfo;
+    }
+    async streamMessage(transcript, tools, callbacks, abortSignal) {
+        const messages = toOpenAIMessages(transcript, this.systemPrompt);
+        const openaiTools = toOpenAITools(tools);
+        const body = {
+            model: this.config.model,
+            messages,
+            max_tokens: this.config.maxTokens,
+            stream: true,
+        };
+        if (this.config.temperature !== undefined) {
+            body.temperature = this.config.temperature;
+        }
+        if (openaiTools.length > 0) {
+            body.tools = openaiTools;
+            body.tool_choice = 'auto';
+        }
+        const url = this.config.baseUrl || 'https://api.openai.com/v1/chat/completions';
+        // 创建 AbortController 用于取消 HTTP 请求
+        const controller = new AbortController();
+        // 如果外部已经 abort，直接返回
+        if (abortSignal?.aborted) {
+            callbacks.onComplete();
+            return;
+        }
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                callbacks.onComplete();
+                return;
+            }
+            callbacks.onError(new Error(`网络请求失败: ${err.message}`));
+            return;
+        }
+        if (!response.ok) {
+            let errBody = '';
+            try {
+                errBody = await response.text();
+            }
+            catch { /* ignore */ }
+            callbacks.onError(new Error(`API 错误 ${response.status}: ${errBody.slice(0, 500)}`));
+            return;
+        }
+        // 流式读取 SSE
+        const reader = response.body?.getReader();
+        if (!reader) {
+            callbacks.onError(new Error('无法获取响应流'));
+            return;
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // 用于累积 tool_calls（可能跨多个 chunk）
+        const pendingToolCalls = new Map();
+        try {
+            while (true) {
+                // 检查是否需要中断
+                if (abortSignal?.aborted) {
+                    controller.abort();
+                    break;
+                }
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                // 读取后再次检查
+                if (abortSignal?.aborted) {
+                    controller.abort();
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                // 最后一行可能不完整，保留
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const delta = parseSSELine(line);
+                    if (!delta)
+                        continue;
+                    // 思考过程（reasoning_content）
+                    if (delta.reasoning_content && callbacks.onThinking) {
+                        callbacks.onThinking(delta.reasoning_content);
+                    }
+                    // 文本内容
+                    if (delta.content) {
+                        callbacks.onText(delta.content);
+                    }
+                    // 工具调用（增量拼接）
+                    if (delta.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index;
+                            if (!pendingToolCalls.has(idx)) {
+                                pendingToolCalls.set(idx, { id: '', name: '', args: '' });
+                            }
+                            const entry = pendingToolCalls.get(idx);
+                            if (tc.id)
+                                entry.id = tc.id;
+                            if (tc.function?.name)
+                                entry.name += tc.function.name;
+                            if (tc.function?.arguments)
+                                entry.args += tc.function.arguments;
+                        }
+                    }
+                }
+            }
+            // 处理 buffer 中剩余的数据
+            if (buffer.trim()) {
+                const delta = parseSSELine(buffer);
+                if (delta?.reasoning_content && callbacks.onThinking)
+                    callbacks.onThinking(delta.reasoning_content);
+                if (delta?.content)
+                    callbacks.onText(delta.content);
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index;
+                        if (!pendingToolCalls.has(idx)) {
+                            pendingToolCalls.set(idx, { id: '', name: '', args: '' });
+                        }
+                        const entry = pendingToolCalls.get(idx);
+                        if (tc.id)
+                            entry.id = tc.id;
+                        if (tc.function?.name)
+                            entry.name += tc.function.name;
+                        if (tc.function?.arguments)
+                            entry.args += tc.function.arguments;
+                    }
+                }
+            }
+            // 流结束后，触发工具调用回调（只取第一个，与 agentic loop 单步设计一致）
+            if (pendingToolCalls.size > 0) {
+                const first = pendingToolCalls.get(0);
+                if (first && first.name) {
+                    let input = {};
+                    try {
+                        input = JSON.parse(first.args);
+                    }
+                    catch { /* 参数解析失败则传空 */ }
+                    callbacks.onToolUse(first.id, first.name, input);
+                    return; // tool_use 时不触发 onComplete
+                }
+            }
+            callbacks.onComplete();
+        }
+        catch (err) {
+            if (err.name === 'AbortError' || abortSignal?.aborted) {
+                callbacks.onComplete();
+                return;
+            }
+            callbacks.onError(new Error(`流式读取失败: ${err.message}`));
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/services/api/mock.d.ts

@@ -0,0 +1,9 @@
+import { LLMService, StreamCallbacks, TranscriptMessage, Tool, AbortSignal as AppAbortSignal } from '../../types/index.js';
+/**
+ * Mock LLM 服务 - 模拟智能体行为，支持工具调用
+ */
+export declare class MockService implements LLMService {
+    streamMessage(transcript: TranscriptMessage[], _tools: Tool[], callbacks: StreamCallbacks, abortSignal?: AppAbortSignal): Promise<void>;
+    /** 模拟流式逐字输出 */
+    private streamText;
+}

package/dist/services/api/mock.js

@@ -0,0 +1,102 @@
+/**
+ * Mock LLM 服务 - 模拟智能体行为，支持工具调用
+ */
+export class MockService {
+    async streamMessage(transcript, _tools, callbacks, abortSignal) {
+        const lastMsg = transcript[transcript.length - 1];
+        const userText = typeof lastMsg?.content === 'string'
+            ? lastMsg.content
+            : '';
+        // 检查是否是工具结果的后续回复
+        const hasToolResult = transcript.some((m) => m.role === 'tool_result');
+        if (hasToolResult && !userText) {
+            // 对工具结果做总结
+            const toolResultMsg = [...transcript].reverse().find((m) => m.role === 'tool_result');
+            const resultText = typeof toolResultMsg?.content === 'string' ? toolResultMsg.content : '';
+            const summary = `以上是工具执行的结果。\n\n${resultText.slice(0, 200)}${resultText.length > 200 ? '...' : ''}`;
+            if (await this.streamText(summary, callbacks, abortSignal))
+                return;
+            callbacks.onComplete();
+            return;
+        }
+        const input = userText.toLowerCase().trim();
+        // 路由：根据用户输入决定是否调用工具
+        if (input.includes('ls') || input.includes('列出') || input.includes('目录')) {
+            if (await this.streamText('好的，让我查看一下当前目录的内容。\n', callbacks, abortSignal))
+                return;
+            callbacks.onToolUse('tool_1', 'list_directory', { path: '.' });
+            return;
+        }
+        if (input.includes('读取') || input.includes('read') || input.includes('查看文件')) {
+            const fileMatch = userText.match(/(?:读取|read|查看文件)\s+(\S+)/i);
+            const filePath = fileMatch?.[1] || 'package.json';
+            if (await this.streamText(`好的，我来读取文件 ${filePath}。\n`, callbacks, abortSignal))
+                return;
+            callbacks.onToolUse('tool_2', 'read_file', { path: filePath });
+            return;
+        }
+        if (input.includes('搜索') || input.includes('search') || input.includes('查找')) {
+            const keyword = userText.replace(/^.*(搜索|search|查找)\s*/i, '').trim() || 'TODO';
+            if (await this.streamText(`好的，我来搜索包含 "${keyword}" 的文件。\n`, callbacks, abortSignal))
+                return;
+            callbacks.onToolUse('tool_3', 'search_files', { path: '.', pattern: keyword });
+            return;
+        }
+        if (input.includes('执行') || input.includes('运行') || input.includes('run')) {
+            const cmd = userText.replace(/^.*(执行|运行|run)\s*/i, '').trim() || 'echo hello';
+            if (await this.streamText(`好的，我来执行命令: \`${cmd}\`\n`, callbacks, abortSignal))
+                return;
+            callbacks.onToolUse('tool_4', 'run_command', { command: cmd });
+            return;
+        }
+        if (input.includes('时间') || input.includes('time') || input.includes('几点')) {
+            if (await this.streamText(`当前时间是: ${new Date().toLocaleString('zh-CN')}`, callbacks, abortSignal))
+                return;
+            callbacks.onComplete();
+            return;
+        }
+        if (input.includes('帮助') || input.includes('help')) {
+            const helpText = [
+                '我是 Jarvis，你的终端智能助手。我可以帮你：',
+                '',
+                '文件操作：「列出目录」「读取 <文件>」「搜索 <关键词>」',
+                '执行命令：「执行 <命令>」「运行 ls -la」',
+                '实用工具：「时间」「帮助」',
+                '',
+                '快捷键：Ctrl+L 清屏 | Ctrl+C 退出 | Esc 终止任务/清空输入',
+            ].join('\n');
+            if (await this.streamText(helpText, callbacks, abortSignal))
+                return;
+            callbacks.onComplete();
+            return;
+        }
+        // 默认回复
+        const reply = `你好！我是 Jarvis 智能助手。你说了「${userText}」。\n\n输入「帮助」查看我能做什么。`;
+        // 模拟思考过程
+        if (callbacks.onThinking) {
+            const thinkText = `分析用户输入: "${userText}"\n考虑最佳回复方式...`;
+            for (const char of thinkText) {
+                if (abortSignal?.aborted)
+                    return;
+                callbacks.onThinking(char);
+                await sleep(10);
+            }
+        }
+        if (await this.streamText(reply, callbacks, abortSignal))
+            return;
+        callbacks.onComplete();
+    }
+    /** 模拟流式逐字输出 */
+    async streamText(text, callbacks, abortSignal) {
+        for (const char of text) {
+            if (abortSignal?.aborted)
+                return true;
+            callbacks.onText(char);
+            await sleep(15 + Math.random() * 20);
+        }
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/skills/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Skill 注册中心
+ *
+ * 负责：
+ *   1. 启动时扫描 ~/.jarvis/skills/ 加载外部 skill
+ *   2. 将 skill 转换为 Tool 格式，与系统内置 tools 合并
+ *   3. 提供统一的工具查找接口
+ *
+ * 如果 skill 目录下存在 skill.py，execute 时直接调用 Python 脚本获取真实结果；
+ * 否则回退为返回 skill 指令文本（由 LLM 解释执行）。
+ */
+import { Tool } from '../types/index.js';
+import { SkillDefinition } from './loader.js';
+/** 加载所有外部 skills（带缓存） */
+export declare function loadExternalSkills(): SkillDefinition[];
+/** 获取合并后的所有工具：内置 tools + 外部 skills */
+export declare function getMergedTools(): Tool[];
+/** 从合并工具列表中按名称查找 */
+export declare function findMergedTool(name: string): Tool | undefined;
+/** 获取已加载的 skill 列表（用于斜杠命令等） */
+export declare function listSkills(): SkillDefinition[];
+/** 清除缓存，强制下次重新扫描 */
+export declare function reloadSkills(): void;