@code4bug/jarvis-agent 1.0.2 → 1.0.4

package/dist/screens/slashCommands.d.ts

@@ -0,0 +1,7 @@
+import { Message } from '../types/index.js';
+/**
+ * 斜杠命令执行器
+ *
+ * 纯函数，返回要追加的系统消息。不涉及 React 状态。
+ */
+export declare function executeSlashCommand(cmdName: string): Message | null;

package/dist/screens/slashCommands.js

@@ -0,0 +1,134 @@
+import { executeInit } from '../commands/init.js';
+import { APP_VERSION } from '../config/constants.js';
+import { allTools } from '../tools/index.js';
+import { listSkills } from '../skills/index.js';
+import { getExternalSkillsDir } from '../skills/loader.js';
+import { listPermanentAuthorizations, DANGER_RULES, } from '../core/safeguard.js';
+/**
+ * 斜杠命令执行器
+ *
+ * 纯函数，返回要追加的系统消息。不涉及 React 状态。
+ */
+export function executeSlashCommand(cmdName) {
+    switch (cmdName) {
+        case 'init': {
+            const result = executeInit();
+            return {
+                id: `init-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: result.displayText,
+                timestamp: Date.now(),
+            };
+        }
+        case 'help': {
+            const helpText = [
+                '可用命令:',
+                '  /init        初始化项目信息，生成 JARVIS.md',
+                '  /new         开启新会话，重新初始化上下文',
+                '  /resume      恢复历史会话（支持二级菜单选择）',
+                '  /resume <ID> 直接恢复指定会话',
+                '  /help        显示此帮助信息',
+                '  /session_clear 清理所有非当前会话的历史记录',
+                '  /skills      查看当前所有 tools 和 skills',
+                '  /permissions 查看所有持久化授权列表',
+                '  /create_skill <描述> 根据需求创建新 skill',
+                '  /agent <名称> 切换智能体（需重启生效）',
+                '  /read <路径>  读取文件内容',
+                '  /write <路径> 写入文件',
+                '  /bash <命令>  执行 Bash 命令',
+                '  /ls <路径>    列出目录',
+                '  /search <词>  搜索文件内容',
+                '  /version     显示当前版本号',
+                '',
+                '快捷键:',
+                '  Ctrl+L       清屏重置',
+                '  Ctrl+O       切换详情显示',
+                '  ESC          中断推理 / 双击清空输入',
+                '  Ctrl+C ×2    退出',
+            ].join('\n');
+            return {
+                id: `help-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: helpText,
+                timestamp: Date.now(),
+            };
+        }
+        case 'permissions': {
+            const perms = listPermanentAuthorizations();
+            const lines = ['持久化授权列表 (~/.jarvis/.permissions.json)', ''];
+            if (perms.rules.length > 0) {
+                lines.push('按规则授权:');
+                for (const r of perms.rules) {
+                    const rule = DANGER_RULES.find((d) => d.name === r);
+                    lines.push(`  [v] ${r}${rule ? ` — ${rule.reason}` : ''}`);
+                }
+                lines.push('');
+            }
+            if (perms.commands.length > 0) {
+                lines.push('按命令授权:');
+                for (const c of perms.commands) {
+                    lines.push(`  [v] [${c.ruleName}] ${c.command} (${c.grantedAt})`);
+                }
+                lines.push('');
+            }
+            if (perms.rules.length === 0 && perms.commands.length === 0) {
+                lines.push('(空) 暂无持久化授权记录');
+            }
+            return {
+                id: `perms-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: lines.join('\n'),
+                timestamp: Date.now(),
+            };
+        }
+        case 'skills': {
+            const skills = listSkills();
+            const parts = [];
+            parts.push('### Built-in Tools\n');
+            allTools.forEach((t, i) => {
+                parts.push(`${i + 1}. \`${t.name}\` - ${t.description.slice(0, 60)}`);
+            });
+            parts.push('');
+            parts.push(`### External Skills\n`);
+            parts.push(`> ${getExternalSkillsDir()}\n`);
+            if (skills.length === 0) {
+                parts.push('_(empty)_');
+            }
+            else {
+                skills.forEach((s, i) => {
+                    const hint = s.meta.argumentHint ? ` \`${s.meta.argumentHint}\`` : '';
+                    const flags = [];
+                    if (s.meta.disableModelInvocation)
+                        flags.push('manual-only');
+                    if (s.meta.userInvocable === false)
+                        flags.push('hidden');
+                    const flagStr = flags.length > 0 ? ` _(${flags.join(', ')})_` : '';
+                    parts.push(`${i + 1}. \`${s.meta.name}\`${hint} - ${s.meta.description}${flagStr}`);
+                });
+            }
+            parts.push('');
+            parts.push(`**Total:** ${allTools.length} tools + ${skills.length} skills = ${allTools.length + skills.length}`);
+            return {
+                id: `skills-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: parts.join('\n'),
+                timestamp: Date.now(),
+            };
+        }
+        case 'version': {
+            return {
+                id: `version-${Date.now()}`,
+                type: 'system',
+                status: 'success',
+                content: `当前版本: ${APP_VERSION}`,
+                timestamp: Date.now(),
+            };
+        }
+        default:
+            return null;
+    }
+}

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

@@ -14,6 +14,8 @@ export interface LLMConfig {
     maxTokens: number;
     baseUrl?: string;
     temperature?: number;
+    /** 额外请求体参数，直接合并到 API 请求 body */
+    extraBody?: Record<string, unknown>;
 }
 /** 从配置文件构建 LLMConfig，找不到则回退环境变量 */
 export declare function getDefaultConfig(): LLMConfig;

package/dist/services/api/llm.js

@@ -34,6 +34,7 @@ export function fromModelConfig(mc) {
         maxTokens: mc.max_tokens ?? 4096,
         baseUrl: mc.api_url,
         temperature: mc.temperature,
+        extraBody: mc.extra_body,
     };
 }
 /** 将内部 TranscriptMessage[] 转为 OpenAI messages 格式 */
@@ -118,7 +119,15 @@ function parseSSELine(line) {
         return null;
     try {
         const parsed = JSON.parse(data);
-        return parsed.choices?.[0]?.delta ?? null;
+        const choice = parsed.choices?.[0];
+        if (!choice)
+            return null;
+        const delta = choice.delta;
+        if (!delta)
+            return null;
+        // 兼容 Qwen/vLLM：thinking 内容可能在 delta.reasoning_content 或 delta.content（role=thinking 时）
+        // 部分 vLLM 部署会将 thinking 内容放在 content 字段，通过 choice.finish_reason 或特殊标记区分
+        return delta;
     }
     catch {
         return null;
@@ -166,6 +175,10 @@ export class LLMServiceImpl {
             body.tools = openaiTools;
             body.tool_choice = 'auto';
         }
+        // 合并额外请求体参数（如 enable_thinking、chat_template_kwargs 等）
+        if (this.config.extraBody) {
+            Object.assign(body, this.config.extraBody);
+        }
         const url = this.config.baseUrl || 'https://api.openai.com/v1/chat/completions';
         // 创建 AbortController 用于取消 HTTP 请求
         const controller = new AbortController();
@@ -213,6 +226,15 @@ export class LLMServiceImpl {
         let buffer = '';
         // 用于累积 tool_calls（可能跨多个 chunk）
         const pendingToolCalls = new Map();
+        // 轮询 abortSignal，一旦外部中断立即 abort HTTP 请求，打断 reader.read() 阻塞
+        const abortPollTimer = abortSignal
+            ? setInterval(() => {
+                if (abortSignal.aborted) {
+                    controller.abort();
+                    clearInterval(abortPollTimer);
+                }
+            }, 50)
+            : null;
         try {
             while (true) {
                 // 检查是否需要中断
@@ -240,8 +262,8 @@ export class LLMServiceImpl {
                     if (delta.reasoning_content && callbacks.onThinking) {
                         callbacks.onThinking(delta.reasoning_content);
                     }
-                    // 文本内容
-                    if (delta.content) {
+                    // 文本内容（注意：用 != null 判断，避免空字符串 "" 被跳过）
+                    if (delta.content != null && delta.content !== '') {
                         callbacks.onText(delta.content);
                     }
                     // 工具调用（增量拼接）
@@ -285,16 +307,46 @@ export class LLMServiceImpl {
                     }
                 }
             }
-            // 流结束后，触发工具调用回调（只取第一个，与 agentic loop 单步设计一致）
+            // 流结束后，触发工具调用回调
             if (pendingToolCalls.size > 0) {
-                const first = pendingToolCalls.get(0);
-                if (first && first.name) {
-                    let input = {};
-                    try {
-                        input = JSON.parse(first.args);
+                // 按 index 排序，收集所有有效的 tool_call
+                const sortedCalls = Array.from(pendingToolCalls.entries())
+                    .sort(([a], [b]) => a - b)
+                    .map(([, tc]) => tc)
+                    .filter((tc) => tc.name);
+                if (sortedCalls.length > 0) {
+                    if (sortedCalls.length === 1) {
+                        // 单工具：走原有路径
+                        const tc = sortedCalls[0];
+                        let input = {};
+                        try {
+                            input = JSON.parse(tc.args);
+                        }
+                        catch { /* 参数解析失败则传空 */ }
+                        callbacks.onToolUse(tc.id, tc.name, input);
+                    }
+                    else if (callbacks.onMultiToolUse) {
+                        // 多工具：触发并行回调
+                        const calls = sortedCalls.map((tc) => {
+                            let input = {};
+                            try {
+                                input = JSON.parse(tc.args);
+                            }
+                            catch { /* ignore */ }
+                            return { id: tc.id, name: tc.name, input };
+                        });
+                        callbacks.onMultiToolUse(calls);
+                    }
+                    else {
+                        // 降级：逐个触发 onToolUse（只触发第一个，保持原有行为）
+                        const tc = sortedCalls[0];
+                        let input = {};
+                        try {
+                            input = JSON.parse(tc.args);
+                        }
+                        catch { /* ignore */ }
+                        callbacks.onToolUse(tc.id, tc.name, input);
                     }
-                    catch { /* 参数解析失败则传空 */ }
-                    callbacks.onToolUse(first.id, first.name, input);
                     return; // tool_use 时不触发 onComplete
                 }
             }
@@ -308,6 +360,8 @@ export class LLMServiceImpl {
             callbacks.onError(new Error(`流式读取失败: ${err.message}`));
         }
         finally {
+            if (abortPollTimer)
+                clearInterval(abortPollTimer);
             reader.releaseLock();
         }
     }

package/dist/skills/index.js

@@ -110,7 +110,7 @@ async function executeSkillScript(scriptPath, skill, args) {
     // 写入临时 Python 文件，避免 shell -c 的转义问题
     const tmpFile = path.join(skill.dirPath, `_tmp_run_${Date.now()}.py`);
     const pyCode = [
-        'import sys, json',
+        'import sys,os,json',
         `sys.path.insert(0, ${JSON.stringify(path.dirname(scriptPath))})`,
         `from skill import ${funcName}`,
         `result = ${funcName}(${kwargs.join(', ')})`,

package/dist/tools/index.d.ts

@@ -4,8 +4,9 @@ import { writeFile } from './writeFile.js';
 import { runCommand } from './runCommand.js';
 import { listDirectory } from './listDirectory.js';
 import { searchFiles } from './searchFiles.js';
+import { semanticSearch } from './semanticSearch.js';
 import { createSkill } from './createSkill.js';
-export { readFile, writeFile, runCommand, listDirectory, searchFiles, createSkill };
+export { readFile, writeFile, runCommand, listDirectory, searchFiles, semanticSearch, createSkill };
 /** 所有内置工具 */
 export declare const allTools: Tool[];
 /** 按名称查找内置工具 */

package/dist/tools/index.js

@@ -3,10 +3,11 @@ import { writeFile } from './writeFile.js';
 import { runCommand } from './runCommand.js';
 import { listDirectory } from './listDirectory.js';
 import { searchFiles } from './searchFiles.js';
+import { semanticSearch } from './semanticSearch.js';
 import { createSkill } from './createSkill.js';
-export { readFile, writeFile, runCommand, listDirectory, searchFiles, createSkill };
+export { readFile, writeFile, runCommand, listDirectory, searchFiles, semanticSearch, createSkill };
 /** 所有内置工具 */
-export const allTools = [readFile, writeFile, runCommand, listDirectory, searchFiles, createSkill];
+export const allTools = [readFile, writeFile, runCommand, listDirectory, searchFiles, semanticSearch, createSkill];
 /** 按名称查找内置工具 */
 export function findTool(name) {
     return allTools.find((t) => t.name === name);

package/dist/tools/runCommand.js

@@ -1,11 +1,20 @@
 import { exec } from 'child_process';
 import { sanitizeOutput } from '../core/safeguard.js';
 /**
- * 异步执行命令，不阻塞事件循环，保证 TUI 渲染正常
+ * 异步执行命令，支持通过 abortSignal 中断子进程
  */
-function execAsync(command, options) {
+function execAsync(command, options, abortSignal) {
     return new Promise((resolve, reject) => {
-        exec(command, options, (error, stdout, stderr) => {
+        const child = exec(command, options, (error, stdout, stderr) => {
+            // 清理轮询
+            if (pollTimer !== null)
+                clearInterval(pollTimer);
+            // 被中断时直接返回已有输出，不视为错误
+            if (abortSignal?.aborted) {
+                const partial = sanitizeOutput(String(stdout ?? '').trim());
+                resolve(partial ? `(命令被中断)\n${partial}` : '(命令被中断)');
+                return;
+            }
             if (error) {
                 const parts = [];
                 if (stderr)
@@ -21,6 +30,29 @@ function execAsync(command, options) {
             }
             resolve(sanitizeOutput(String(stdout).trim()) || '(命令执行完成，无输出)');
         });
+        // 轮询 abortSignal，检测到中断时 kill 子进程
+        let pollTimer = null;
+        if (abortSignal) {
+            pollTimer = setInterval(() => {
+                if (abortSignal.aborted && child.pid) {
+                    if (pollTimer !== null)
+                        clearInterval(pollTimer);
+                    pollTimer = null;
+                    // 先尝试 SIGTERM，给进程优雅退出的机会
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch { /* ignore */ }
+                    // 500ms 后强制 SIGKILL
+                    setTimeout(() => {
+                        try {
+                            child.kill('SIGKILL');
+                        }
+                        catch { /* ignore */ }
+                    }, 500);
+                }
+            }, 100);
+        }
     });
 }
 export const runCommand = {
@@ -29,15 +61,14 @@ export const runCommand = {
     parameters: {
         command: { type: 'string', description: '要执行的 Bash 命令', required: true },
     },
-    execute: async (args) => {
+    execute: async (args, abortSignal) => {
         const command = args.command;
-        // 安全围栏拦截已在 query 层（executeTool）统一处理，此处仅负责执行 + 脱敏
         return execAsync(command, {
             encoding: 'utf-8',
             timeout: 30000,
             maxBuffer: 1024 * 1024,
             env: sanitizeEnv(process.env),
-        });
+        }, abortSignal);
     },
 };
 /**

package/dist/tools/semanticSearch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 语义搜索工具
+ *
+ * 当配置了大模型时，先通过 LLM 对中文关键词进行语义扩展（同义词、近义词、相关表达），
+ * 再用扩展后的词集合在文件中进行匹配搜索，实现"相似搜索"能力。
+ * 未配置大模型时降级为普通关键词搜索。
+ */
+import { Tool } from '../types/index.js';
+export declare const semanticSearch: Tool;

package/dist/tools/semanticSearch.js

@@ -0,0 +1,159 @@
+/**
+ * 语义搜索工具
+ *
+ * 当配置了大模型时，先通过 LLM 对中文关键词进行语义扩展（同义词、近义词、相关表达），
+ * 再用扩展后的词集合在文件中进行匹配搜索，实现"相似搜索"能力。
+ * 未配置大模型时降级为普通关键词搜索。
+ */
+import fs from 'fs';
+import path from 'path';
+import { loadConfig, getActiveModel } from '../config/loader.js';
+/** 通过 LLM 扩展关键词，返回扩展后的词列表（含原始关键词） */
+async function expandKeywords(keyword) {
+    const config = loadConfig();
+    const activeModel = getActiveModel(config);
+    if (!activeModel) {
+        return [keyword];
+    }
+    const prompt = `你是一个关键词扩展助手。请对以下搜索关键词进行语义扩展，生成同义词、近义词、相关表达和常见别名。
+
+关键词: "${keyword}"
+
+要求:
+1. 返回 JSON 数组格式，例如: ["词1", "词2", "词3"]
+2. 包含原始关键词
+3. 包含中文同义词、近义词
+4. 如果关键词是中文，也包含对应的英文表达
+5. 如果关键词是英文，也包含对应的中文表达
+6. 包含常见缩写或别名
+7. 最多返回 15 个词
+8. 只返回 JSON 数组，不要其他内容`;
+    try {
+        const url = activeModel.api_url;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${activeModel.api_key}`,
+            },
+            body: JSON.stringify({
+                model: activeModel.model,
+                messages: [
+                    { role: 'system', content: '你是一个关键词扩展助手，只返回 JSON 数组，不要任何其他内容。' },
+                    { role: 'user', content: prompt },
+                ],
+                max_tokens: 500,
+                temperature: 0.3,
+                stream: false,
+            }),
+        });
+        if (!response.ok) {
+            return [keyword];
+        }
+        const data = (await response.json());
+        const content = data.choices?.[0]?.message?.content?.trim() ?? '';
+        // 从返回内容中提取 JSON 数组
+        const jsonMatch = content.match(/\[[\s\S]*?\]/);
+        if (!jsonMatch) {
+            return [keyword];
+        }
+        const expanded = JSON.parse(jsonMatch[0]);
+        // 确保原始关键词在列表中
+        if (!expanded.includes(keyword)) {
+            expanded.unshift(keyword);
+        }
+        return expanded.filter((w) => typeof w === 'string' && w.trim().length > 0);
+    }
+    catch {
+        // LLM 调用失败，降级为原始关键词
+        return [keyword];
+    }
+}
+/** 在文件内容中检查是否匹配任意一个关键词（不区分大小写） */
+function matchesAny(line, keywords) {
+    const lower = line.toLowerCase();
+    for (const kw of keywords) {
+        if (lower.includes(kw.toLowerCase())) {
+            return kw;
+        }
+    }
+    return null;
+}
+/** 递归遍历目录搜索 */
+function walkAndSearch(dir, keywords, results, maxResults) {
+    if (results.length >= maxResults)
+        return;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                return;
+            const full = path.join(dir, entry.name);
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist')
+                continue;
+            if (entry.isDirectory()) {
+                walkAndSearch(full, keywords, results, maxResults);
+            }
+            else {
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (results.length >= maxResults)
+                            return;
+                        const matched = matchesAny(lines[i], keywords);
+                        if (matched) {
+                            results.push({
+                                file: full,
+                                line: i + 1,
+                                content: lines[i].trim(),
+                                matchedKeyword: matched,
+                            });
+                        }
+                    }
+                }
+                catch { /* 跳过二进制文件 */ }
+            }
+        }
+    }
+    catch { /* 跳过无权限目录 */ }
+}
+export const semanticSearch = {
+    name: 'semantic_search',
+    description: '语义搜索：通过大模型扩展中文关键词的同义词和相关表达，在指定目录中进行相似搜索。未配置大模型时降级为普通搜索。',
+    parameters: {
+        path: { type: 'string', description: '搜索目录', required: true },
+        pattern: { type: 'string', description: '搜索关键词', required: true },
+        expand: { type: 'string', description: '是否启用语义扩展（true/false），默认 true', required: false },
+    },
+    execute: async (args) => {
+        const dirPath = args.path || '.';
+        const pattern = args.pattern;
+        const enableExpand = args.expand !== 'false';
+        // 第一步：关键词扩展
+        let keywords;
+        let expandInfo = '';
+        if (enableExpand) {
+            keywords = await expandKeywords(pattern);
+            if (keywords.length > 1) {
+                expandInfo = `语义扩展: "${pattern}" → [${keywords.map((k) => `"${k}"`).join(', ')}]\n\n`;
+            }
+            else {
+                expandInfo = `未配置大模型或扩展失败，使用原始关键词: "${pattern}"\n\n`;
+            }
+        }
+        else {
+            keywords = [pattern];
+            expandInfo = `普通搜索模式，关键词: "${pattern}"\n\n`;
+        }
+        // 第二步：搜索文件
+        const results = [];
+        walkAndSearch(dirPath, keywords, results, 50);
+        if (results.length === 0) {
+            return expandInfo + `未找到匹配的内容`;
+        }
+        // 格式化输出，标注匹配的关键词
+        const formatted = results.map((r) => `${r.file}:${r.line}: [匹配:"${r.matchedKeyword}"] ${r.content}`).join('\n');
+        return expandInfo + `找到 ${results.length} 条结果:\n${formatted}`;
+    },
+};