pigpig-agent 1.0.0

package/dist/session/store.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const SESSION_DIR = '.sessions';
+const DEFAULT_SESSION = 'default';
+export class SessionStore {
+    dir = '';
+    sessionId = '';
+    constructor(sessionId = DEFAULT_SESSION) {
+        this.sessionId = sessionId;
+        this.dir = SESSION_DIR;
+        if (!existsSync(this.dir)) {
+            mkdirSync(this.dir, { recursive: true });
+        }
+    }
+    get filePath() {
+        return join(this.dir, `${this.sessionId}.jsonl`); // ./sessions/default.jsonl
+    }
+    // 追加消息到会话文件
+    append(message) {
+        const entry = {
+            type: 'message',
+            timestamp: new Date().toISOString(),
+            message,
+        };
+        appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
+    }
+    // 追加多个消息到会话文件
+    appendAll(messages) {
+        for (const message of messages) {
+            this.append(message);
+        }
+    }
+    // 从会话文件加载消息
+    load() {
+        if (!existsSync(this.filePath))
+            return [];
+        const content = readFileSync(this.filePath, 'utf-8').trim();
+        if (!content)
+            return [];
+        const messages = [];
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === 'message') {
+                    messages.push(entry.message);
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return messages;
+    }
+    // 检查会话文件是否存在
+    exists() {
+        return existsSync(this.filePath);
+    }
+}

package/dist/skills/loader.js

@@ -0,0 +1,100 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'node:url';
+const SKILLS_DIR = '.skills';
+const SKILL_FILE = 'SKILL.md';
+const BUILTIN_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../.skills');
+export class SkillLoader {
+    baseDir = '';
+    skills = new Map();
+    constructor(baseDir = '.') {
+        this.baseDir = baseDir;
+    }
+    load() {
+        this.skills.clear();
+        const dirs = [
+            path.join(this.baseDir, SKILLS_DIR), // 'xxx/xxx/.skills'
+            BUILTIN_SKILLS_DIR,
+        ];
+        for (const skillsDir of dirs) {
+            this.loadFrom(skillsDir);
+        }
+        return this.list(); // 得到所有的Skill
+    }
+    loadFrom(skillsDir) {
+        if (!fs.existsSync(skillsDir))
+            return;
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillFile = path.join(skillsDir, entry.name, SKILL_FILE); // 'xxx/xxx/.skills/<skill-name>/SKILL.md'
+            if (!fs.existsSync(skillFile))
+                continue;
+            const raw = fs.readFileSync(skillFile, 'utf-8');
+            const parsed = this.parseFrontmatter(raw); // 解析Skill的Frontmatter
+            if (!parsed)
+                continue;
+            if (this.skills.has(entry.name))
+                continue;
+            this.skills.set(entry.name, {
+                name: entry.name,
+                description: parsed.description,
+                whenToUse: parsed.whenToUse,
+                content: parsed.content,
+                dirPath: path.join(skillsDir, entry.name), // 'xxx/xxx/.skills/<skill-name>'
+            });
+        }
+    }
+    list() {
+        return Array.from(this.skills.values());
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    buildPromptSection(activeSkills) {
+        if (this.skills.size === 0)
+            return null;
+        const lines = [];
+        for (const name of activeSkills) {
+            const skill = this.skills.get(name);
+            if (!skill)
+                continue;
+            lines.push(`[激活的Skill:${skill.name}]`);
+            lines.push(skill.content);
+            lines.push('');
+        }
+        const available = this.list()
+            .filter(s => !activeSkills.has(s.name)) // 过滤出未激活的Skill
+            .map(s => {
+            const hint = s.whenToUse ? `(适用场景为：${s.whenToUse})` : '';
+            return ` / ${s.name} - ${s.description}${hint}`; // '/ <skill-name> - <skill-description> (适用场景为：<when-to-use>)'
+        });
+        if (available.length > 0) {
+            lines.push(`可用的 Skills (输入 /skill load <name> 激活)：`);
+            lines.push(...available);
+        }
+        return lines.length > 0 ? lines.join('\n') : null;
+    }
+    parseFrontmatter(raw) {
+        const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+        if (!match)
+            return { description: '', content: raw };
+        const meta = {};
+        for (const line of match[1].split(/\r?\n/)) { // ['name: <skill-name>', 'description: <skill-description>']
+            const idx = line.indexOf(':');
+            if (idx > 0) {
+                const key = line.slice(0, idx).trim();
+                let value = line.slice(idx + 1).trim();
+                if (value.startsWith('"') && value.endsWith('"'))
+                    value = value.slice(1, -1);
+                meta[key] = value;
+            }
+        }
+        return {
+            description: meta.description || '',
+            whenToUse: meta.whenToUse || undefined,
+            content: match[2].trim()
+        };
+    }
+}

package/dist/tools/cron-tools.js

@@ -0,0 +1,94 @@
+export function createCronTool(cronService) {
+    return {
+        name: 'cron_manage',
+        description: '管理定时任务。支持创建、删除、查看、立即执行定时任务。',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['list', 'add', 'remove', 'run', 'enable', 'disable', 'logs'],
+                    description: '操作类型',
+                },
+                id: { type: 'string', description: '任务 ID（add/remove/run/enable/disable 时必填）' },
+                name: { type: 'string', description: '任务名称（add 时必填）' },
+                schedule: {
+                    type: 'string',
+                    description: '调度表达式：cron("*/5 * * * *")、间隔("every 30s")、一次性(ISO 时间戳)',
+                },
+                prompt: { type: 'string', description: '任务执行时发送给 Agent 的 prompt（add 时必填）' },
+            },
+            required: ['action'],
+        },
+        isConcurrencySafe: false,
+        isReadOnly: false,
+        execute: async (input) => {
+            switch (input.action) {
+                case 'list': {
+                    const jobs = cronService.list();
+                    if (jobs.length === 0)
+                        return '当前没有定时任务';
+                    return jobs.map(j => {
+                        const last = j.lastRun
+                            ? ` | 上次: ${j.lastRun.status} @ ${j.lastRun.finishedAt}`
+                            : '';
+                        return `[${j.status}] ${j.config.id} — ${j.config.name}\n  调度: ${j.config.schedule}${last}`;
+                    }).join('\n\n');
+                }
+                case 'add': {
+                    if (!input.id || !input.name || !input.schedule || !input.prompt) {
+                        return '添加任务需要: id, name, schedule, prompt';
+                    }
+                    const scheduleType = input.schedule.startsWith('every') ? 'interval'
+                        : /^\d{4}-/.test(input.schedule) ? 'once'
+                            : 'cron';
+                    const config = {
+                        id: input.id,
+                        name: input.name,
+                        schedule: input.schedule,
+                        scheduleType,
+                        enabled: true,
+                        payload: { type: 'agent', prompt: input.prompt },
+                        source: 'runtime',
+                    };
+                    try {
+                        cronService.add(config);
+                        return `✓ 任务 "${input.name}" 已创建，调度: ${input.schedule}`;
+                    }
+                    catch (err) {
+                        return `✗ 创建失败: ${err.message}`;
+                    }
+                }
+                case 'remove': {
+                    if (!input.id)
+                        return '需要指定任务 id';
+                    const removed = cronService.remove(input.id);
+                    return removed ? `✓ 任务 ${input.id} 已删除` : `✗ 任务 ${input.id} 不存在`;
+                }
+                case 'run': {
+                    if (!input.id)
+                        return '需要指定任务 id';
+                    return cronService.runNow(input.id);
+                }
+                case 'enable': {
+                    if (!input.id)
+                        return '需要指定任务 id';
+                    return cronService.enable(input.id) ? `✓ 已启用` : `✗ 任务不存在`;
+                }
+                case 'disable': {
+                    if (!input.id)
+                        return '需要指定任务 id';
+                    return cronService.disable(input.id) ? `✓ 已禁用` : `✗ 任务不存在`;
+                }
+                case 'logs': {
+                    const logs = cronService.getRecentLogs(input.id, 5);
+                    if (logs.length === 0)
+                        return '暂无执行记录';
+                    return logs.map(l => `[${l.status}] ${l.jobId} @ ${l.startedAt}\n  ${l.output?.slice(0, 100) || l.error || ''}`).join('\n\n');
+                }
+                default:
+                    return `未知操作: ${input.action}`;
+            }
+        },
+    };
+}

package/dist/tools/file-tools.js

@@ -0,0 +1,115 @@
+import { resolve, join } from 'node:path';
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+export const readFileTool = {
+    name: 'read_file',
+    description: '读取指定路径的文件内容',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: '文件路径'
+            }
+        },
+        required: ['path'],
+        additionalProperties: false,
+    },
+    isConcurrencySafe: true,
+    isReadOnly: true,
+    maxResultChars: 500,
+    execute: async ({ path }) => {
+        return readFileSync(resolve(path), 'utf-8');
+    }
+};
+export const writeFileTool = {
+    name: 'write_file',
+    description: '写入内容到指定路径的文件',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: '文件路径'
+            },
+            content: {
+                type: 'string',
+                description: '要写入的内容'
+            }
+        },
+        required: ['path', 'content'],
+        additionalProperties: false,
+    },
+    isConcurrencySafe: false, // 写入操作不能并发
+    isReadOnly: false,
+    execute: async ({ path, content }) => {
+        writeFileSync(resolve(path), content, 'utf-8');
+        return `已写入 ${content.length} 个字符到 ${path}`;
+    }
+};
+export const listDirectoryTool = {
+    name: 'list_directory',
+    description: '列出指定目录下的文件和子目录',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: '目录路径，默认为当前目录' },
+        },
+        required: [],
+        additionalProperties: false,
+    },
+    isConcurrencySafe: true,
+    isReadOnly: true,
+    execute: async ({ path = '.' }) => {
+        const resolved = resolve(path);
+        const entries = readdirSync(resolved);
+        return entries.map(name => {
+            try {
+                const stat = statSync(join(resolved, name));
+                return `${stat.isDirectory() ? '[DIR]' : '[FILE]'} ${name}`;
+            }
+            catch {
+                return `[?] ${name}`;
+            }
+        }).join('\n');
+    },
+};
+// 编辑文件
+export const editFileTool = {
+    name: 'edit_file',
+    description: '精确的替换文件中的指定内容，用 old_string 定位要替换的内容，用 new_string 替换它。不是全量覆写，只是改你指定的部分',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: '文件路径'
+            },
+            old_string: {
+                type: 'string',
+                description: '要被替换的原始文本(必须精确匹配)'
+            },
+            new_string: {
+                type: 'string',
+                description: '替换后的新文本'
+            }
+        },
+        required: ['path', 'old_string', 'new_string'],
+        additionalProperties: false,
+    },
+    isConcurrencySafe: false, // 编辑操作不能并发
+    isReadOnly: false,
+    execute: async ({ path, old_string, new_string }) => {
+        const resolved = resolve(path);
+        if (!existsSync(resolved))
+            return `文件不存在: ${path}`;
+        const content = readFileSync(resolved, 'utf-8');
+        const count = content.split(old_string).length - 1;
+        if (count === 0)
+            return `未找到匹配的内容。请检查 old_string 是否与文件中的文本完全一致(包括空格和换行符)`;
+        if (count > 1)
+            return `找到 ${count} 个匹配项。请提供更多上下文信息，让 old_string 唯一`;
+        const updated = content.replace(old_string, new_string);
+        writeFileSync(resolved, updated, 'utf-8');
+        return `已替换 ${path} 中的内容 (${old_string} 为 ${new_string} 字符)`;
+    }
+};

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+import { readFileTool, writeFileTool, listDirectoryTool, editFileTool } from './file-tools.js';
+import { globTool, grepTool } from './search-tools.js';
+import { bashTool } from './shell-tools.js';
+import { pickSearchTool, webFetchTool } from './web-search.js';
+export const allTools = [
+    readFileTool,
+    writeFileTool,
+    listDirectoryTool,
+    editFileTool,
+    globTool,
+    grepTool,
+    bashTool,
+    pickSearchTool(),
+    webFetchTool,
+];
+// 核心工具
+export { readFileTool, writeFileTool, listDirectoryTool, editFileTool, globTool, grepTool, bashTool, };

package/dist/tools/mcp-client.js

@@ -0,0 +1,100 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+export class MCPClient {
+    command;
+    args;
+    env;
+    process = null;
+    requestId = 0;
+    pending = new Map();
+    serverName = '';
+    rl = null;
+    constructor(command, args, env) {
+        this.command = command;
+        this.args = args;
+        this.env = env;
+        this.serverName = args[args.length - 1]?.replace(/^@.*\//, '') || 'mcp-server';
+    }
+    async connect() {
+        // Windows 上命令是 .cmd/.exe 文件，spawn 无法直接启动（报 ENOENT/EINVAL），
+        // 需要显式用 cmd.exe /c 包装；Linux/macOS 直接 spawn 即可。
+        const isWindows = process.platform === 'win32';
+        const command = isWindows ? 'cmd.exe' : this.command;
+        const args = isWindows ? ['/c', this.command, ...this.args] : this.args;
+        this.process = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'], // 三个pipe：指的是标准输入、标准输出、标准错误输出都通过管道传递
+            env: { ...process.env, ...this.env }, // 主进程环境变量传给子进程，用于访问环境变量
+        });
+        this.process.on('error', (error) => {
+            console.error(` [MCP] 进程启动失败：${error.message}`);
+            // 启动失败时立刻拒绝所有待处理请求，避免它们一直等到超时
+            for (const p of this.pending.values()) {
+                p.reject(new Error(`MCP 进程启动失败: ${error.message}`));
+            }
+            this.pending.clear();
+        });
+        this.process.stderr?.on('data', () => { });
+        this.rl = createInterface({
+            input: this.process.stdout,
+        });
+        this.rl.on('line', (line) => {
+            try {
+                const msg = JSON.parse(line);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const p = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) {
+                        p?.reject(new Error(` [MCP] 错误：${msg.error.code}: ${msg.error.message}`));
+                    }
+                    else {
+                        p?.resolve(msg.result);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(` [MCP] 解析错误：${error.message}`);
+            }
+        });
+        await this.send('initialize', {
+            protocolVersion: '2025-11-25',
+            capabilities: {},
+            clientInfo: { name: 'super-agent', version: '0.5.0' },
+        });
+        this.process.stdin.write(JSON.stringify({
+            jsonrpc: '2.0',
+            method: 'notifications/initialized',
+        }) + '\n');
+    }
+    send(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request timeout: ${method}`));
+            }, 15000);
+            this.pending.set(id, {
+                resolve: (v) => { clearTimeout(timeout); resolve(v); },
+                reject: (e) => { clearTimeout(timeout); reject(e); },
+            });
+            const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params });
+            this.process.stdin.write(msg + '\n');
+        });
+    }
+    async listTools() {
+        const result = await this.send('tools/list', {});
+        return result.tools || [];
+    }
+    async callTool(name, args) {
+        const result = await this.send('tools/call', { name, arguments: args });
+        const texts = (result.content || [])
+            .filter(c => c.type === 'text' && c.text)
+            .map(c => c.text);
+        return texts.join('\n') || '(无返回内容)';
+    }
+    async close() {
+        if (this.rl)
+            this.rl.close();
+        if (this.process)
+            this.process.kill();
+    }
+}

package/dist/tools/memory-tools.js

@@ -0,0 +1,81 @@
+export function createMemoryTool(memoryStore) {
+    return {
+        name: 'memory',
+        description: '管理跨会话记忆。action: save | list | search | read | delete | lint。read/delete 需要 filename（如 project_xxx.md）；save 同名自动覆盖；lint 结果自带内容预览，不需要逐条 read',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['save', 'list', 'search', 'read', 'delete', 'lint'] },
+                name: { type: 'string', description: '记忆名称（save 时必填）' },
+                description: { type: 'string', description: '一句话描述（save 时必填）' },
+                type: { type: 'string', enum: ['user', 'feedback', 'project', 'reference'], description: '记忆类型（save 时必填）' },
+                content: { type: 'string', description: '记忆内容（save 时必填）' },
+                query: { type: 'string', description: '搜索关键词（search 时必填）' },
+                filename: { type: 'string', description: '文件名（read/delete 时必填）' },
+            },
+            required: ['action'],
+            additionalProperties: false,
+        },
+        isConcurrencySafe: false,
+        isReadOnly: false,
+        execute: async (args) => {
+            switch (args.action) {
+                case 'save': {
+                    if (!args.name || !args.type || !args.content) {
+                        return '保存失败：需要 name、type、content 参数';
+                    }
+                    const filename = memoryStore.save({
+                        name: args.name,
+                        description: args.description || args.name,
+                        type: args.type,
+                        content: args.content,
+                    });
+                    return `已保存到记忆: ${filename}`;
+                }
+                case 'list': {
+                    const entries = memoryStore.list();
+                    if (entries.length === 0)
+                        return '当前没有存储任何记忆。';
+                    return `记忆列表（共 ${entries.length} 条记忆）：\n` +
+                        entries.map(e => `  [${e.type}] ${e.name} — ${e.description}`).join('\n');
+                }
+                case 'search': {
+                    const results = memoryStore.search(args.query || '');
+                    if (results.length === 0)
+                        return `没有找到与 "${args.query}" 相关的记忆。`;
+                    return `搜索结果（${results.length} 条匹配）：\n` +
+                        results.map(e => `  [${e.type}] ${e.name} — ${e.description}`).join('\n');
+                }
+                case 'read': {
+                    if (!args.filename)
+                        return '读取失败：需要 filename 参数';
+                    return memoryStore.loadFile(args.filename) ?? `文件不存在: ${args.filename}`;
+                }
+                case 'delete': {
+                    if (!args.filename)
+                        return '删除失败：需要 filename 参数';
+                    return memoryStore.delete(args.filename) ? `已删除: ${args.filename}` : `文件不存在: ${args.filename}`;
+                }
+                case 'lint': {
+                    const reports = memoryStore.lint();
+                    if (reports.length === 0)
+                        return '记忆库健康，没有发现问题。';
+                    const lines = [`记忆库 lint 报告（${reports.length} 条有问题）：`, ''];
+                    for (const r of reports) {
+                        const fname = r.entry.filePath.split('/').pop();
+                        const preview = r.entry.content.slice(0, 100).replace(/\n/g, ' ');
+                        lines.push(`📁 ${fname}  [${r.entry.type}] ${r.entry.name}`);
+                        lines.push(`   内容预览: ${preview}${r.entry.content.length > 100 ? '...' : ''}`);
+                        for (const issue of r.issues)
+                            lines.push(`   • ${issue.kind}: ${issue.message}`);
+                        lines.push('');
+                    }
+                    lines.push('提示: 基于以上报告直接操作即可（delete 删除、save 覆盖更新），不需要逐条 read。');
+                    return lines.join('\n');
+                }
+                default:
+                    return `未知操作: ${args.action}`;
+            }
+        },
+    };
+}

package/dist/tools/rag-tools.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import { chunkDocument } from '../rag/chunker.js';
+import { embed } from '../rag/embedder.js';
+export function createRagTools(vectorStore, embedFn) {
+    const ragIngestTool = {
+        name: 'rag_ingest',
+        description: '将文档导入知识库。path 为文件路径，内容会被分块、向量化后存储。',
+        parameters: {
+            type: 'object',
+            properties: { path: { type: 'string', description: '文档路径' } },
+            required: ['path'],
+            additionalProperties: false,
+        },
+        isConcurrencySafe: false,
+        isReadOnly: false,
+        execute: async ({ path }) => {
+            try {
+                const text = fs.readFileSync(path, 'utf-8');
+                const chunks = chunkDocument(path, text);
+                const embeddings = await embed(embedFn, chunks.map(c => c.text));
+                vectorStore.addBatch(chunks.map((c, i) => ({ chunk: c, embedding: embeddings[i] })));
+                return `已导入 ${chunks.length} 个文档片段（来源: ${path}）。知识库共 ${vectorStore.size()} 个片段。`;
+            }
+            catch (e) {
+                return `导入失败: ${e.message}`;
+            }
+        },
+    };
+    const ragSearchTool = {
+        name: 'rag_search',
+        description: '从知识库中搜索相关信息。返回最相关的文档片段。',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: '搜索查询' },
+                top_k: { type: 'number', description: '返回结果数量（默认 5）' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+        isConcurrencySafe: true,
+        isReadOnly: true,
+        execute: async ({ query, top_k }) => {
+            if (vectorStore.size() === 0)
+                return '知识库为空，请先使用 rag_ingest 导入文档。';
+            // const results = await hybridSearch(vectorStore, embedFn, query, top_k || 5);
+            const results = await vectorStore.hybridSearch(embedFn, query, top_k || 5);
+            if (results.length === 0)
+                return `没有找到与 "${query}" 相关的内容。`;
+            return results.map((r, i) => `[${i + 1}] 来源: ${r.chunk.source} | 综合分: ${r.score.toFixed(3)} (向量: ${r.vectorScore.toFixed(2)}, 关键词: ${r.keywordScore.toFixed(2)})\n${r.chunk.text.slice(0, 500)}`).join('\n\n---\n\n');
+        },
+    };
+    return [ragIngestTool, ragSearchTool];
+}