@code4bug/jarvis-agent 1.0.2

package/dist/skills/index.js

@@ -0,0 +1,232 @@
+/**
+ * Skill 注册中心
+ *
+ * 负责：
+ *   1. 启动时扫描 ~/.jarvis/skills/ 加载外部 skill
+ *   2. 将 skill 转换为 Tool 格式，与系统内置 tools 合并
+ *   3. 提供统一的工具查找接口
+ *
+ * 如果 skill 目录下存在 skill.py，execute 时直接调用 Python 脚本获取真实结果；
+ * 否则回退为返回 skill 指令文本（由 LLM 解释执行）。
+ */
+import { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { scanExternalSkills, getExternalSkillsDir } from './loader.js';
+import { allTools as builtinTools } from '../tools/index.js';
+// ===== 缓存 =====
+let _skillCache = null;
+let _mergedTools = null;
+// ===== Skill → Tool 转换 =====
+/**
+ * 从 skill.py 的 TOOL_METADATA 中提取参数定义
+ */
+function buildParamsFromScript(scriptPath, skill) {
+    try {
+        const content = fs.readFileSync(scriptPath, 'utf-8');
+        const metaStart = content.indexOf('TOOL_METADATA');
+        if (metaStart === -1)
+            throw new Error('no metadata');
+        const metaSection = content.slice(metaStart);
+        const paramsStart = metaSection.indexOf('"parameters"');
+        if (paramsStart === -1)
+            throw new Error('no parameters');
+        // 跳过 "parameters": { 本身，从其内部开始匹配参数
+        const afterParamsKey = metaSection.slice(paramsStart + '"parameters"'.length);
+        const braceIdx = afterParamsKey.indexOf('{');
+        if (braceIdx === -1)
+            throw new Error('no parameters brace');
+        const paramsBody = afterParamsKey.slice(braceIdx + 1);
+        // 如果是嵌套的 JSON Schema 格式（含 "properties"），跳到 properties 内部
+        let paramsSection = paramsBody;
+        const propsIdx = paramsBody.indexOf('"properties"');
+        if (propsIdx !== -1) {
+            const afterProps = paramsBody.slice(propsIdx + '"properties"'.length);
+            const propsBrace = afterProps.indexOf('{');
+            if (propsBrace !== -1) {
+                paramsSection = afterProps.slice(propsBrace + 1);
+            }
+        }
+        const paramRegex = /"(\w+)"\s*:\s*\{[^}]*"type"/g;
+        const paramNames = [];
+        let match;
+        while ((match = paramRegex.exec(paramsSection)) !== null) {
+            paramNames.push(match[1]);
+        }
+        if (paramNames.length === 0)
+            throw new Error('no params found');
+        const params = {};
+        for (const name of paramNames) {
+            const descMatch = paramsSection.match(new RegExp(`"${name}"[^}]*"description"\\s*:\\s*"([^"]*)"`));
+            const reqMatch = paramsSection.match(new RegExp(`"${name}"[^}]*"required"\\s*:\\s*(true|false)`));
+            params[name] = {
+                type: 'string',
+                description: descMatch ? descMatch[1] : name,
+                required: reqMatch ? reqMatch[1] === 'true' : false,
+            };
+        }
+        return params;
+    }
+    catch {
+        return {
+            arguments: {
+                type: 'string',
+                description: skill.meta.argumentHint
+                    ? `参数: ${skill.meta.argumentHint}`
+                    : '传递给 skill 的 JSON 参数（可选）',
+                required: false,
+            },
+        };
+    }
+}
+/**
+ * 执行 Python skill 脚本，返回真实结果
+ *
+ * 通过写入临时 .py 文件再执行，避免 shell 转义问题。
+ */
+async function executeSkillScript(scriptPath, skill, args) {
+    const funcName = skill.meta.name.replace(/-/g, '_');
+    const kwargs = [];
+    for (const [key, value] of Object.entries(args)) {
+        if (key === 'arguments') {
+            // 兼容旧的 arguments 字符串模式
+            try {
+                const parsed = JSON.parse(value);
+                for (const [k, v] of Object.entries(parsed)) {
+                    kwargs.push(`${k}=${JSON.stringify(v)}`);
+                }
+            }
+            catch {
+                if (value)
+                    kwargs.push(`query=${JSON.stringify(value)}`);
+            }
+        }
+        else {
+            // 跳过不属于函数签名的参数名（如 LLM 传了 "parameters"），映射为 query
+            const paramKey = key === 'parameters' ? 'query' : key;
+            kwargs.push(`${paramKey}=${JSON.stringify(value)}`);
+        }
+    }
+    // 写入临时 Python 文件，避免 shell -c 的转义问题
+    const tmpFile = path.join(skill.dirPath, `_tmp_run_${Date.now()}.py`);
+    const pyCode = [
+        'import sys, json',
+        `sys.path.insert(0, ${JSON.stringify(path.dirname(scriptPath))})`,
+        `from skill import ${funcName}`,
+        `result = ${funcName}(${kwargs.join(', ')})`,
+        'print(json.dumps(result, ensure_ascii=False, indent=2))',
+    ].join('\n');
+    try {
+        fs.writeFileSync(tmpFile, pyCode, 'utf-8');
+        const output = await new Promise((resolve, reject) => {
+            exec(`python3 ${JSON.stringify(tmpFile)}`, {
+                encoding: 'utf-8',
+                timeout: 30000,
+                maxBuffer: 1024 * 1024,
+                env: { ...process.env },
+                cwd: skill.dirPath,
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    const parts = [];
+                    if (stderr)
+                        parts.push(String(stderr).trim());
+                    if (stdout)
+                        parts.push(String(stdout).trim());
+                    if (parts.length === 0)
+                        parts.push(error.message);
+                    reject(new Error(parts.join('\n')));
+                    return;
+                }
+                resolve(String(stdout).trim());
+            });
+        });
+        return output || '(skill 执行完成，无输出)';
+    }
+    catch (e) {
+        return `[Skill ${skill.meta.name} 执行失败]\n${e.message}`;
+    }
+    finally {
+        // 清理临时文件
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * 回退模式：返回 skill 指令文本（无 Python 脚本时）
+ */
+async function executeSkillPrompt(skill, args) {
+    let instruction = skill.instruction;
+    const rawArgs = args.arguments || '';
+    const argParts = rawArgs.split(/\s+/).filter(Boolean);
+    instruction = instruction.replace(/\$ARGUMENTS/g, rawArgs);
+    for (let i = 0; i < argParts.length; i++) {
+        instruction = instruction.replace(new RegExp(`\\$ARGUMENTS\\[${i}\\]`, 'g'), argParts[i]);
+        instruction = instruction.replace(new RegExp(`\\${i}\\b`, 'g'), argParts[i]);
+    }
+    if (rawArgs && !skill.instruction.includes('$ARGUMENTS') && !skill.instruction.match(/\$\d/)) {
+        instruction += `\n\n参数: ${rawArgs}`;
+    }
+    return `[Skill: ${skill.meta.name}]\n\n${instruction}`;
+}
+/**
+ * 将 SkillDefinition 转换为 Tool
+ */
+function skillToTool(skill) {
+    const toolName = `skill_${skill.meta.name}`;
+    const scriptPath = path.join(skill.dirPath, 'skill.py');
+    const hasScript = fs.existsSync(scriptPath);
+    const parameters = hasScript
+        ? buildParamsFromScript(scriptPath, skill)
+        : {
+            arguments: {
+                type: 'string',
+                description: skill.meta.argumentHint
+                    ? `参数: ${skill.meta.argumentHint}`
+                    : '传递给 skill 的参数（可选）',
+                required: false,
+            },
+        };
+    return {
+        name: toolName,
+        description: `[Skill] ${skill.meta.description || skill.meta.name}`,
+        parameters,
+        execute: hasScript
+            ? async (args) => executeSkillScript(scriptPath, skill, args)
+            : async (args) => executeSkillPrompt(skill, args),
+    };
+}
+// ===== 公开接口 =====
+/** 加载所有外部 skills（带缓存） */
+export function loadExternalSkills() {
+    if (_skillCache)
+        return _skillCache;
+    _skillCache = scanExternalSkills();
+    console.log(`[skills] 已加载 ${_skillCache.length} 个外部 skill (${getExternalSkillsDir()})`);
+    return _skillCache;
+}
+/** 获取合并后的所有工具：内置 tools + 外部 skills */
+export function getMergedTools() {
+    if (_mergedTools)
+        return _mergedTools;
+    const skills = loadExternalSkills();
+    const skillTools = skills
+        .filter((s) => s.meta.userInvocable !== false)
+        .map(skillToTool);
+    _mergedTools = [...builtinTools, ...skillTools];
+    return _mergedTools;
+}
+/** 从合并工具列表中按名称查找 */
+export function findMergedTool(name) {
+    return getMergedTools().find((t) => t.name === name);
+}
+/** 获取已加载的 skill 列表（用于斜杠命令等） */
+export function listSkills() {
+    return loadExternalSkills();
+}
+/** 清除缓存，强制下次重新扫描 */
+export function reloadSkills() {
+    _skillCache = null;
+    _mergedTools = null;
+}

package/dist/skills/loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 外部 Skill 加载器
+ *
+ * 扫描 ~/.jarvis/skills/ 目录，解析每个子目录中的 SKILL.md，
+ * 提取 frontmatter 元数据和正文指令。
+ *
+ * Skill 目录结构：
+ *   ~/.jarvis/skills/<skill-name>/SKILL.md
+ *   ~/.jarvis/skills/<skill-name>/reference.md  (可选)
+ *   ~/.jarvis/skills/<skill-name>/scripts/       (可选)
+ */
+export interface SkillMeta {
+    /** skill 名称，省略时用目录名；只允许小写字母、数字、连字符 */
+    name: string;
+    /** 描述：说明 skill 做什么、什么时候用 */
+    description: string;
+    /** 参数提示，例如 [issue-number] */
+    argumentHint?: string;
+    /** 禁止模型自动触发，仅用户手动 /name 调用 */
+    disableModelInvocation?: boolean;
+    /** 从 / 菜单隐藏，用户不能直接调 */
+    userInvocable?: boolean;
+    /** 允许使用的工具列表 */
+    allowedTools?: string;
+    /** 推理强度 */
+    effort?: 'low' | 'medium' | 'high' | 'max';
+    /** 其他自定义字段 */
+    [key: string]: unknown;
+}
+export interface SkillDefinition {
+    /** frontmatter 元数据 */
+    meta: SkillMeta;
+    /** markdown 正文，作为 skill 指令 */
+    instruction: string;
+    /** skill 目录路径 */
+    dirPath: string;
+    /** SKILL.md 文件路径 */
+    filePath: string;
+}
+/** 外部 skills 根目录：~/.jarvis/skills/ */
+export declare function getExternalSkillsDir(): string;
+/** 扫描 ~/.jarvis/skills/ 下所有子目录，加载 SKILL.md */
+export declare function scanExternalSkills(): SkillDefinition[];
+/** 按名称获取单个 skill */
+export declare function getSkill(name: string, skills: SkillDefinition[]): SkillDefinition | undefined;

package/dist/skills/loader.js

@@ -0,0 +1,108 @@
+/**
+ * 外部 Skill 加载器
+ *
+ * 扫描 ~/.jarvis/skills/ 目录，解析每个子目录中的 SKILL.md，
+ * 提取 frontmatter 元数据和正文指令。
+ *
+ * Skill 目录结构：
+ *   ~/.jarvis/skills/<skill-name>/SKILL.md
+ *   ~/.jarvis/skills/<skill-name>/reference.md  (可选)
+ *   ~/.jarvis/skills/<skill-name>/scripts/       (可选)
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+// ===== 常量 =====
+const JARVIS_DIR = '.jarvis';
+const SKILLS_DIR = 'skills';
+const SKILL_FILENAME = 'SKILL.md';
+/** 外部 skills 根目录：~/.jarvis/skills/ */
+export function getExternalSkillsDir() {
+    return path.join(os.homedir(), JARVIS_DIR, SKILLS_DIR);
+}
+// ===== frontmatter 解析 =====
+function parseFrontMatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+        return { meta: {}, body: raw };
+    }
+    const meta = {};
+    for (const line of match[1].split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const val = line.slice(idx + 1).trim();
+        meta[key] = val;
+    }
+    return { meta, body: match[2].trim() };
+}
+// ===== 加载单个 Skill =====
+function loadSkillDir(dirPath, dirName) {
+    const filePath = path.join(dirPath, SKILL_FILENAME);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { meta, body } = parseFrontMatter(raw);
+        // name 默认用目录名
+        const name = meta.name || dirName;
+        // 校验 name 格式：只允许小写字母、数字、连字符
+        if (!/^[a-z0-9-]+$/.test(name)) {
+            console.warn(`[skills] 跳过非法 name "${name}"（仅允许小写字母、数字、连字符）: ${filePath}`);
+            return null;
+        }
+        if (name.length > 64) {
+            console.warn(`[skills] 跳过过长 name "${name}"（最长 64 字符）: ${filePath}`);
+            return null;
+        }
+        const skillMeta = {
+            name,
+            description: meta.description || '',
+            argumentHint: meta['argument-hint'] || undefined,
+            disableModelInvocation: meta['disable-model-invocation'] === 'true',
+            userInvocable: meta['user-invocable'] !== 'false', // 默认 true
+            allowedTools: meta['allowed-tools'] || undefined,
+            effort: (['low', 'medium', 'high', 'max'].includes(meta.effort) ? meta.effort : undefined),
+        };
+        return {
+            meta: skillMeta,
+            instruction: body,
+            dirPath,
+            filePath,
+        };
+    }
+    catch (err) {
+        console.error(`[skills] 加载失败: ${filePath}`, err instanceof Error ? err.message : err);
+        return null;
+    }
+}
+// ===== 扫描所有外部 Skills =====
+/** 扫描 ~/.jarvis/skills/ 下所有子目录，加载 SKILL.md */
+export function scanExternalSkills() {
+    const skillsDir = getExternalSkillsDir();
+    if (!fs.existsSync(skillsDir)) {
+        return [];
+    }
+    const results = [];
+    try {
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skill = loadSkillDir(path.join(skillsDir, entry.name), entry.name);
+            if (skill) {
+                results.push(skill);
+            }
+        }
+    }
+    catch (err) {
+        console.error('[skills] 扫描外部 skills 目录失败:', err instanceof Error ? err.message : err);
+    }
+    return results;
+}
+/** 按名称获取单个 skill */
+export function getSkill(name, skills) {
+    return skills.find((s) => s.meta.name === name);
+}

package/dist/tools/createSkill.d.ts

@@ -0,0 +1,8 @@
+/**
+ * create_skill 工具
+ *
+ * 根据用户需求，调用 LLM 基于 SKILL_INSTRUCTIONS.md 规范自动生成 skill，
+ * 并写入 ~/.jarvis/skills/ 目录。
+ */
+import { Tool } from '../types/index.js';
+export declare const createSkill: Tool;

package/dist/tools/createSkill.js

@@ -0,0 +1,255 @@
+/**
+ * create_skill 工具
+ *
+ * 根据用户需求，调用 LLM 基于 SKILL_INSTRUCTIONS.md 规范自动生成 skill，
+ * 并写入 ~/.jarvis/skills/ 目录。
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getExternalSkillsDir } from '../skills/loader.js';
+import { reloadSkills } from '../skills/index.js';
+import { LLMServiceImpl, getDefaultConfig } from '../services/api/llm.js';
+// SKILL_INSTRUCTIONS.md 查找路径：项目根目录 > 用户主目录
+function loadSkillInstructions() {
+    const candidates = [
+        path.join(process.cwd(), 'SKILL_INSTRUCTIONS.md'),
+        path.join(os.homedir(), '.jarvis', 'SKILL_INSTRUCTIONS.md'),
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            return fs.readFileSync(p, 'utf-8');
+        }
+    }
+    return '';
+}
+/**
+ * 加载已有 skill 作为 LLM 参考示例
+ * 从 ~/.jarvis/skills/ 和项目 skills/ 目录中读取
+ */
+function loadExampleSkills() {
+    const examples = [];
+    // 扫描项目内 skills/ 目录和 ~/.jarvis/skills/ 目录
+    const dirs = [
+        path.join(process.cwd(), 'skills'),
+        getExternalSkillsDir(),
+    ];
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillMdPath = path.join(dir, entry.name, 'SKILL.md');
+                const skillPyPath = path.join(dir, entry.name, 'skill.py');
+                if (!fs.existsSync(skillMdPath))
+                    continue;
+                const mdContent = fs.readFileSync(skillMdPath, 'utf-8').slice(0, 800);
+                let example = `--- 示例 skill: ${entry.name} ---\n[SKILL.md]\n${mdContent}`;
+                if (fs.existsSync(skillPyPath)) {
+                    const pyContent = fs.readFileSync(skillPyPath, 'utf-8').slice(0, 1200);
+                    example += `\n[skill.py]\n${pyContent}`;
+                }
+                examples.push(example);
+                if (examples.length >= 2)
+                    break; // 最多取 2 个示例
+            }
+        }
+        catch { /* ignore */ }
+        if (examples.length >= 2)
+            break;
+    }
+    if (examples.length === 0)
+        return '';
+    return '=== 已有 skill 参考示例（请参考其格式和风格） ===\n' + examples.join('\n\n');
+}
+/**
+ * 确保 SKILL.md 的 frontmatter 中包含 description 字段
+ * 如果缺失则自动补入
+ */
+function ensureFrontmatterDescription(skillMd, description) {
+    const fmMatch = skillMd.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fmMatch) {
+        // 没有 frontmatter，整个补上
+        const fm = `---\ndescription: ${description}\n---\n\n`;
+        return fm + skillMd;
+    }
+    const fmBody = fmMatch[1];
+    // 检查是否已有 description 行（允许值为空的情况也算缺失）
+    const descLine = fmBody.split('\n').find((l) => /^description\s*:/.test(l));
+    if (descLine) {
+        const val = descLine.replace(/^description\s*:\s*/, '').trim();
+        if (val && val !== '""' && val !== "''") {
+            // 已有有效 description，不修改
+            return skillMd;
+        }
+        // description 值为空，替换
+        return skillMd.replace(descLine, `description: ${description}`);
+    }
+    // frontmatter 中没有 description 行，在 name 行后插入
+    const nameLine = fmBody.split('\n').find((l) => /^name\s*:/.test(l));
+    if (nameLine) {
+        return skillMd.replace(nameLine, `${nameLine}\ndescription: ${description}`);
+    }
+    // 兜底：在 frontmatter 末尾插入
+    return skillMd.replace(/\n---/, `\ndescription: ${description}\n---`);
+}
+/**
+ * 调用 LLM 生成 skill 内容
+ *
+ * 返回 JSON: { name, description, argument_hint?, skill_md, skill_py? }
+ */
+async function callLLMForSkill(requirement) {
+    const instructions = loadSkillInstructions();
+    // 加载已有 skill 作为参考示例
+    const exampleSkills = loadExampleSkills();
+    const systemPrompt = [
+        '你是一个 Skill 生成专家。请严格按照以下规范为用户生成 Skill。',
+        '',
+        '=== Skill 编写规范 ===',
+        instructions || '(规范文件未找到，请按通用 SKILL.md 格式生成)',
+        '',
+        '=== 语言要求 ===',
+        '- 所有 description、注释、文档说明必须使用中文',
+        '- name 字段使用英文小写+连字符',
+        '- 代码中的变量名、函数名使用英文',
+        '',
+        '=== 输出要求 ===',
+        '你必须返回一个合法的 JSON 对象，不要包含任何其他文字、解释或 markdown 代码块标记。',
+        'JSON 结构如下:',
+        '{',
+        '  "name": "skill 名称，仅小写字母、数字、连字符",',
+        '  "description": "中文简短描述，说明功能和触发场景",',
+        '  "argument_hint": "参数提示，可选",',
+        '  "skill_md": "完整的 SKILL.md 文件内容（包含 frontmatter 和正文）",',
+        '  "skill_py": "如果 skill 需要可执行逻辑则必须提供完整 Python 代码"',
+        '}',
+        '',
+        '=== 关键规则 ===',
+        '1. skill_md 的 frontmatter 必须包含 name 和 description，description 必须是中文，不能为空',
+        '2. skill_md 的 frontmatter 中如果 skill 接受参数，必须包含 argument-hint 字段（如 [message] [target]）',
+        '3. 如果用户需求涉及任何可执行逻辑（API 调用、网络请求、数据处理、文件操作等），必须生成 skill_py',
+        '4. skill_py 中的 TOOL_METADATA["parameters"] 必须是扁平字典结构，每个参数直接作为 key，格式如下:',
+        '   "parameters": {',
+        '       "query": {',
+        '           "type": "string",',
+        '           "description": "中文参数说明",',
+        '           "required": True',
+        '       },',
+        '       "max_results": {',
+        '           "type": "integer",',
+        '           "description": "最大返回结果数",',
+        '           "required": False',
+        '       }',
+        '   }',
+        '   注意: required 使用 Python 的 True/False，不要用 JavaScript 的 true/false',
+        '   注意: 不要嵌套 "properties" 或 "type": "object"，直接把参数名作为 key',
+        '5. skill_py 中的函数名必须与 name 一致（连字符替换为下划线）',
+        '6. skill_py 中的 TOOL_METADATA["description"] 也必须是中文',
+        '7. JSON 输出中的字符串值如果包含换行，使用 \\n 转义',
+        '8. 有副作用的操作（发消息、部署、写入外部系统）必须设置 disable-model-invocation: true',
+        '9. JSON 输出中 argument_hint 字段必须与 skill_md frontmatter 中的 argument-hint 一致',
+        '',
+        exampleSkills,
+    ].join('\n');
+    // 收集 LLM 流式输出
+    let result = '';
+    const service = new LLMServiceImpl({
+        ...getDefaultConfig(),
+    });
+    await new Promise((resolve, reject) => {
+        const callbacks = {
+            onText: (text) => { result += text; },
+            onToolUse: () => { },
+            onComplete: () => resolve(),
+            onError: (err) => reject(err),
+        };
+        const messagesWithContext = [
+            { role: 'user', content: `${systemPrompt}\n\n---\n\n用户需求: ${requirement}` },
+        ];
+        service.streamMessage(messagesWithContext, [], callbacks).catch(reject);
+    });
+    // 解析 JSON 结果
+    // LLM 可能返回 ```json ... ``` 包裹的内容，需要提取
+    let jsonStr = result.trim();
+    const jsonBlockMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (jsonBlockMatch) {
+        jsonStr = jsonBlockMatch[1].trim();
+    }
+    try {
+        const parsed = JSON.parse(jsonStr);
+        if (!parsed.name || !parsed.skill_md) {
+            throw new Error('LLM 返回的 JSON 缺少必要字段 (name, skill_md)');
+        }
+        if (!parsed.description) {
+            throw new Error('LLM 返回的 JSON 缺少 description 字段');
+        }
+        // 确保 skill_md 的 frontmatter 中包含 description
+        parsed.skill_md = ensureFrontmatterDescription(parsed.skill_md, parsed.description);
+        return parsed;
+    }
+    catch (e) {
+        if (e.message.startsWith('LLM 返回'))
+            throw e;
+        throw new Error(`解析 LLM 生成结果失败: ${e.message}\n\n原始输出:\n${result.slice(0, 500)}`);
+    }
+}
+export const createSkill = {
+    name: 'create_skill',
+    description: '根据用户需求，调用大模型基于 SKILL_INSTRUCTIONS.md 规范自动生成 Skill 并写入 ~/.jarvis/skills/',
+    parameters: {
+        requirement: {
+            type: 'string',
+            description: '用户对 skill 的需求描述，例如"一个可以查询天气的工具"',
+            required: true,
+        },
+    },
+    execute: async (args) => {
+        const requirement = (args.requirement || '').trim();
+        if (!requirement) {
+            throw new Error('缺少必填参数: requirement（skill 需求描述）');
+        }
+        // 1. 调用 LLM 生成 skill 内容
+        const generated = await callLLMForSkill(requirement);
+        // 2. 校验 name
+        const name = generated.name;
+        if (!/^[a-z0-9-]+$/.test(name)) {
+            throw new Error(`LLM 生成的 skill 名称 "${name}" 不合法，仅允许小写字母、数字、连字符`);
+        }
+        if (name.length > 64) {
+            throw new Error('LLM 生成的 skill 名称过长，最多 64 个字符');
+        }
+        const skillsDir = getExternalSkillsDir();
+        const skillDir = path.join(skillsDir, name);
+        // 3. 检查是否已存在
+        if (fs.existsSync(skillDir)) {
+            throw new Error(`Skill "${name}" 已存在: ${skillDir}`);
+        }
+        // 4. 创建目录并写入文件
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), generated.skill_md, 'utf-8');
+        if (generated.skill_py) {
+            fs.writeFileSync(path.join(skillDir, 'skill.py'), generated.skill_py, 'utf-8');
+        }
+        // 5. 刷新缓存
+        reloadSkills();
+        // 6. 返回结果
+        const parts = [
+            `Skill "${name}" 创建成功`,
+            `  描述: ${generated.description}`,
+            `  目录: ${skillDir}`,
+            `  SKILL.md: 已生成`,
+        ];
+        if (generated.skill_py) {
+            parts.push('  skill.py: 已生成');
+        }
+        if (generated.argument_hint) {
+            parts.push(`  参数提示: ${generated.argument_hint}`);
+        }
+        parts.push('', '已刷新 skill 缓存，新 skill 立即可用。');
+        parts.push('可通过 /skills 查看，或直接使用 /' + name + ' 调用。');
+        return parts.join('\n');
+    },
+};

package/dist/tools/index.d.ts

@@ -0,0 +1,16 @@
+import { Tool } from '../types/index.js';
+import { readFile } from './readFile.js';
+import { writeFile } from './writeFile.js';
+import { runCommand } from './runCommand.js';
+import { listDirectory } from './listDirectory.js';
+import { searchFiles } from './searchFiles.js';
+import { createSkill } from './createSkill.js';
+export { readFile, writeFile, runCommand, listDirectory, searchFiles, createSkill };
+/** 所有内置工具 */
+export declare const allTools: Tool[];
+/** 按名称查找内置工具 */
+export declare function findTool(name: string): Tool | undefined;
+/** 获取所有工具（内置 + 外部 skills），供 QueryEngine 使用 */
+export declare function getAllTools(): Tool[];
+/** 按名称查找工具（内置 + 外部 skills） */
+export declare function findToolMerged(name: string): Tool | undefined;