pigpig-agent 1.0.0

package/dist/cron/service.js

@@ -0,0 +1,211 @@
+import { parseSchedule, getNextCronTime } from './parser.js';
+import { CronStore } from './store.js';
+const QUOTES = [
+    '"知之为知之，不知为不知，是知也。" —— 孔子',
+    '"学而不思则罔，思而不学则殆。" —— 孔子',
+    '"千里之行，始于足下。" —— 老子',
+    '"天行健，君子以自强不息。" —— 《周易》',
+    '"不积跬步，无以至千里。" —— 荀子',
+    '"Stay hungry, stay foolish." —— Steve Jobs',
+    '"The best way to predict the future is to invent it." —— Alan Kay',
+    '"Talk is cheap. Show me the code." —— Linus Torvalds',
+    '"Simplicity is the ultimate sophistication." —— Leonardo da Vinci',
+    '"First, solve the problem. Then, write the code." —— John Johnson',
+];
+export class CronService {
+    jobs = new Map();
+    store;
+    executor;
+    running = false;
+    constructor(baseDir = '.') {
+        this.store = new CronStore(baseDir); // 初始化存储
+        this.store.init();
+    }
+    setExecutor(executor) {
+        this.executor = executor; // 设置执行器
+    }
+    load() {
+        const configs = this.store.loadJobs(); // 读到所有任务配置
+        for (const config of configs) {
+            if (config.enabled) {
+                this.jobs.set(config.id, {
+                    config, timerId: null, consecutiveFailures: 0, running: false,
+                });
+            }
+        }
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        for (const state of this.jobs.values()) {
+            if (state.config.enabled)
+                this.scheduleJob(state);
+        }
+    }
+    stop() {
+        this.running = false;
+        for (const state of this.jobs.values()) {
+            if (state.timerId) {
+                clearTimeout(state.timerId);
+                state.timerId = null;
+            }
+        }
+    }
+    add(config) {
+        if (this.jobs.has(config.id))
+            throw new Error(`任务 ${config.id} 已存在`);
+        const state = { config, timerId: null, consecutiveFailures: 0, running: false };
+        this.jobs.set(config.id, state);
+        this.persist();
+        if (this.running && config.enabled)
+            this.scheduleJob(state);
+    }
+    remove(id) {
+        const state = this.jobs.get(id);
+        if (!state)
+            return false;
+        if (state.timerId)
+            clearTimeout(state.timerId);
+        this.jobs.delete(id);
+        this.persist();
+        return true;
+    }
+    enable(id) {
+        const state = this.jobs.get(id);
+        if (!state)
+            return false;
+        state.config.enabled = true;
+        state.consecutiveFailures = 0;
+        this.persist();
+        if (this.running)
+            this.scheduleJob(state);
+        return true;
+    }
+    disable(id) {
+        const state = this.jobs.get(id);
+        if (!state)
+            return false;
+        state.config.enabled = false;
+        if (state.timerId) {
+            clearTimeout(state.timerId);
+            state.timerId = null;
+        }
+        this.persist();
+        return true;
+    }
+    list() {
+        return Array.from(this.jobs.values()).map(state => ({
+            config: state.config,
+            status: state.running ? 'running'
+                : !state.config.enabled ? 'disabled'
+                    : state.timerId ? 'scheduled' : 'idle',
+            lastRun: state.lastRun,
+        }));
+    }
+    async runNow(id) {
+        const state = this.jobs.get(id);
+        if (!state)
+            return `任务 ${id} 不存在`;
+        return this.executeJob(state);
+    }
+    getRecentLogs(jobId, limit) {
+        return this.store.getRecentLogs(jobId, limit);
+    }
+    scheduleJob(state) {
+        if (state.timerId) {
+            clearTimeout(state.timerId);
+            state.timerId = null;
+        }
+        try {
+            const parsed = parseSchedule(state.config.schedule);
+            let delayMs;
+            switch (parsed.type) {
+                case 'interval':
+                    delayMs = parsed.intervalMs;
+                    break;
+                case 'once': {
+                    const diff = parsed.onceAt.getTime() - Date.now();
+                    if (diff <= 0) {
+                        this.executeJob(state);
+                        return;
+                    }
+                    delayMs = diff;
+                    break;
+                }
+                case 'cron':
+                    delayMs = getNextCronTime(parsed.cronInstance);
+                    break;
+            }
+            state.timerId = setTimeout(async () => {
+                await this.executeJob(state);
+                if (parsed.type !== 'once' && state.config.enabled && this.running) {
+                    this.scheduleJob(state);
+                }
+                else if (parsed.type === 'once') {
+                    this.remove(state.config.id);
+                }
+            }, delayMs);
+        }
+        catch (err) {
+            console.log(`  [cron] ✗ 调度失败 ${state.config.id}: ${err.message}`);
+        }
+    }
+    async executeJob(state) {
+        if (state.running)
+            return '任务正在执行中';
+        state.running = true;
+        const startedAt = new Date().toISOString();
+        let output = '';
+        let status = 'success';
+        let error;
+        try {
+            const timeout = state.config.timeout || 60000;
+            output = await this.runPayload(state.config.payload, timeout);
+            state.consecutiveFailures = 0;
+        }
+        catch (err) {
+            status = err.message?.includes('timeout') ? 'timeout' : 'error';
+            error = err.message;
+            output = `执行失败: ${err.message}`;
+            state.consecutiveFailures++;
+            const maxRetries = state.config.maxRetries ?? 3;
+            if (state.consecutiveFailures >= maxRetries) {
+                state.config.enabled = false;
+                console.log(`  [cron] ✗ ${state.config.id} 连续失败 ${maxRetries} 次，已自动禁用`);
+                this.persist();
+            }
+        }
+        finally {
+            state.running = false;
+        }
+        const log = { jobId: state.config.id, startedAt, finishedAt: new Date().toISOString(), status, output: output.slice(0, 1000), error };
+        state.lastRun = log;
+        this.store.appendLog(log);
+        if (this.executor?.notify) {
+            const icon = status === 'success' ? '✓' : '✗';
+            this.executor.notify(`[cron] ${icon} ${state.config.name}: ${output.slice(0, 200)}`);
+        }
+        return output;
+    }
+    async runPayload(payload, timeout) {
+        if (!this.executor)
+            return '[cron] 未设置执行器，无法运行任务';
+        if (payload.type === 'agent') {
+            return this.executor.runAgentPrompt(payload.prompt, timeout);
+        }
+        if (payload.type === 'handler') {
+            if (payload.handler === 'random-quote') {
+                return QUOTES[Math.floor(Math.random() * QUOTES.length)];
+            }
+            return `[handler] ${payload.handler} — handler 类型需要通过插件注册`;
+        }
+        return '未知 payload 类型';
+    }
+    persist() {
+        const configs = Array.from(this.jobs.values())
+            .filter(s => s.config.source === 'runtime').map(s => s.config);
+        const existing = this.store.loadJobs().filter(j => j.source === 'config');
+        this.store.saveJobs([...existing, ...configs]);
+    }
+}

package/dist/cron/store.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+const JOBS_FILE = '.cron/jobs.json';
+const LOGS_FILE = '.cron/logs.jsonl';
+export class CronStore {
+    baseDir;
+    constructor(baseDir = '.') {
+        this.baseDir = baseDir;
+    }
+    get jobsPath() { return `${this.baseDir}/${JOBS_FILE}`; }
+    get logsPath() { return `${this.baseDir}/${LOGS_FILE}`; }
+    init() {
+        const dir = `${this.baseDir}/.cron`;
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    loadJobs() {
+        if (!fs.existsSync(this.jobsPath))
+            return [];
+        try {
+            const data = JSON.parse(fs.readFileSync(this.jobsPath, 'utf-8'));
+            return data.jobs || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    saveJobs(jobs) {
+        this.init();
+        fs.writeFileSync(this.jobsPath, JSON.stringify({ jobs }, null, 2));
+    }
+    appendLog(log) {
+        this.init();
+        fs.appendFileSync(this.logsPath, JSON.stringify(log) + '\n');
+    }
+    getRecentLogs(jobId, limit = 10) {
+        if (!fs.existsSync(this.logsPath))
+            return [];
+        const lines = fs.readFileSync(this.logsPath, 'utf-8')
+            .split('\n')
+            .filter(Boolean);
+        let logs = lines.map(l => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+        if (jobId)
+            logs = logs.filter(l => l.jobId === jobId);
+        return logs.slice(-limit);
+    }
+}

package/dist/cron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const command = process.argv[2];
+if (command === 'init') {
+    import('./config/init.js').then((m) => m.runInit());
+}
+else {
+    import('./main.js').then((m) => m.startAgent().catch(console.error));
+}
+export {};

package/dist/main.js

@@ -0,0 +1,270 @@
+import 'dotenv/config';
+import { loadConfig } from './config/loader.js';
+import fs from 'node:fs';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createMockModel } from './mock-model.js';
+import { createInterface } from 'node:readline';
+import { ToolRegistry } from './tools/registry.js';
+import { allTools } from './tools/index.js';
+import { createToolSearchTool } from './tools/tool-search.js';
+import { createMemoryTool } from './tools/memory-tools.js';
+import { createRagTools } from './tools/rag-tools.js';
+import { agentLoop } from './agent/loop.js';
+import { SessionStore } from './session/store.js';
+import { PromptBuilder, coreRules, toolGuide, deferredTools, sessionContext, } from './context/prompt-builder.js';
+import { estimateMessageTokens } from './context/defense.js';
+import { UsageTracker } from './usage/tracker.js';
+import { MemoryStore } from './memory/store.js';
+import { memoryContext, ragContext } from './context/prompt-pipes.js';
+import { chunkDocument } from './rag/chunker.js';
+import { createDashScopeEmbedder, embed } from './rag/embedder.js';
+import { SqliteVectorStore as VectorStore } from './rag/sqlite-store.js';
+import { createDispatcher } from './commands/index.js';
+import { debugCommands } from './commands/debug.js';
+import { contextCommands } from './commands/context.js';
+import { memoryCommands } from './commands/memory.js';
+import { ragCommands } from './commands/rag.js';
+import { dreamCommands } from './commands/dream.js';
+import { SkillLoader } from './skills/loader.js';
+import { createSkillCommands } from './commands/skill.js';
+import { PluginManager } from './plugins/manager.js';
+import { supabasePlugin } from './plugins/supabase-plugin.js';
+import { createPluginCommands } from './commands/plugin.js';
+import { HookPipeline } from './security/hook.js';
+import { createSecurityCommands } from './commands/security.js';
+import { CronService } from './cron/service.js';
+import { createCronTool } from './tools/cron-tools.js';
+import { createCronCommands } from './commands/cron.js';
+import { SubAgentRegistry } from './agents/registry.js';
+import { createSpawnTool } from './tools/spawn-tools.js';
+import { createAgentCommands } from './commands/agent.js';
+import { MCPClient } from './tools/mcp-client.js';
+// ── 加载配置 ────────────────────────────────
+const config = loadConfig();
+function createModel(cfg) {
+    if (!cfg.apiKey)
+        return createMockModel();
+    const provider = createOpenAI({ baseURL: cfg.baseURL, apiKey: cfg.apiKey });
+    return provider.chat(cfg.name);
+}
+const model = createModel(config.model);
+// ── Registry ────────────────────────────────────────
+const registry = new ToolRegistry();
+registry.register(...allTools);
+registry.register(createToolSearchTool(registry));
+// ── Memory ────────────────────────────────────────
+const memoryStore = new MemoryStore(config.memory.dataDir);
+memoryStore.init();
+registry.register(createMemoryTool(memoryStore));
+// ── RAG ────────────────────────────────────────
+const vectorStore = new VectorStore();
+const embedFn = config.model.apiKey
+    ? createDashScopeEmbedder(config.model.apiKey)
+    : embed;
+registry.register(...createRagTools(vectorStore, embedFn));
+async function connectMCP() {
+    const token = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+    if (!token) {
+        console.log('  ⚠ 未设置 GITHUB_PERSONAL_ACCESS_TOKEN，跳过 GitHub MCP');
+        return;
+    }
+    try {
+        const mcpClient = new MCPClient('pnpm', ['dlx', '@modelcontextprotocol/server-github'], { GITHUB_PERSONAL_ACCESS_TOKEN: token });
+        const tools = await registry.registerMCPServer('github', mcpClient);
+        console.log(`  已注册 ${tools.length} 个 MCP 工具`);
+    }
+    catch (err) {
+        console.log(`  ⚠ GitHub MCP 加载失败: ${err.message}`);
+    }
+}
+// ── Skills ────────────────────────────────────────
+const skillLoader = new SkillLoader('.');
+const loadedSkills = skillLoader.load();
+const activeSkills = new Set();
+// ── Plugins ────────────────────────────────────────
+const pluginManager = new PluginManager(registry);
+const availablePlugins = new Map([
+    ['supabase', supabasePlugin],
+]);
+// ── Security: Hook Pipeline ────────────────────────────────────────
+const hookPipeline = new HookPipeline();
+hookPipeline.registerPre('audit-log', (toolName, input) => {
+    if (toolName === 'write_file' || toolName === 'edit_file') {
+        const path = input?.path || 'unknown';
+        console.log(`  [audit] 文件写入操作: ${toolName} → ${path}`);
+    }
+    return { action: 'allow' };
+});
+hookPipeline.registerPost('bash-timestamp', (toolName, _input, output) => {
+    if (toolName === 'bash') {
+        const timestamp = new Date().toISOString();
+        return {
+            action: 'modify',
+            modifiedOutput: `[${timestamp}]\n${output}`,
+        };
+    }
+    return { action: 'allow' };
+});
+registry.setHookPipeline(hookPipeline);
+// ── Cron Service ────────────────────────────────────────
+const cronService = new CronService(config.cron.dataDir);
+registry.register(createCronTool(cronService));
+// ── Sub-Agent ────────────────────────────────────────
+const agentRegistry = new SubAgentRegistry({
+    maxSpawnDepth: config.agents.maxSpawnDepth,
+    maxConcurrent: config.agents.maxConcurrent,
+});
+function getSpawnCtx() {
+    return {
+        model,
+        registry,
+        agentRegistry,
+        buildSystem: () => builder.build(makePromptCtx()),
+        currentDepth: 0,
+    };
+}
+registry.register(createSpawnTool(agentRegistry, getSpawnCtx));
+// ── Prompt Builder ────────────────────────────────────────
+const builder = new PromptBuilder()
+    .pipe('coreRules', coreRules())
+    .pipe('toolGuide', toolGuide())
+    .pipe('deferredTools', deferredTools())
+    .pipe('memoryContext', memoryContext(memoryStore))
+    .pipe('ragContext', ragContext(vectorStore))
+    .pipe('skillContext', () => skillLoader.buildPromptSection(activeSkills))
+    .pipe('sessionContext', sessionContext());
+// ── Commands ────────────────────────────────────────
+const dispatch = createDispatcher([
+    ...debugCommands,
+    ...contextCommands,
+    ...memoryCommands,
+    ...ragCommands,
+    ...dreamCommands,
+    ...createSkillCommands(skillLoader, activeSkills),
+    ...createPluginCommands(pluginManager, availablePlugins),
+    ...createSecurityCommands(registry, hookPipeline),
+    ...createCronCommands(cronService),
+    ...createAgentCommands(agentRegistry),
+]);
+function makePromptCtx() {
+    return {
+        toolCount: registry.getActiveTools().length,
+        deferredToolSummary: registry.getDeferredToolSummary(),
+        sessionMessageCount: 0,
+        sessionId: config.session.id,
+    };
+}
+export async function startAgent() {
+    await connectMCP();
+    // 加载插件
+    console.log('  加载插件...');
+    for (const [name, def] of availablePlugins) {
+        try {
+            const tools = await pluginManager.load(def);
+            console.log(`  ✓ ${name} — ${tools.length} 个工具`);
+        }
+        catch {
+            console.log(`  ✗ ${name} — 加载失败`);
+        }
+    }
+    // 启动 Cron
+    cronService.load();
+    cronService.setExecutor({
+        runAgentPrompt: async (prompt, timeout) => {
+            const cronMessages = [{ role: 'user', content: prompt }];
+            const system = builder.build(makePromptCtx());
+            await agentLoop(model, registry, cronMessages, system);
+            const lastMsg = cronMessages[cronMessages.length - 1];
+            if (!lastMsg)
+                return '(无输出)';
+            if (typeof lastMsg.content === 'string')
+                return lastMsg.content;
+            if (Array.isArray(lastMsg.content)) {
+                return lastMsg.content
+                    .filter((p) => p.type === 'text')
+                    .map((p) => p.text)
+                    .join('') || '(无输出)';
+            }
+            return String(lastMsg.content);
+        },
+        notify: (message) => {
+            console.log(`\n${message}`);
+        },
+    });
+    cronService.start();
+    const cronJobs = cronService.list();
+    const store = new SessionStore('default');
+    let messages = [];
+    const timestamps = new Map();
+    const tracker = new UsageTracker('.usage/today.jsonl');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    function ask() {
+        rl.question('\nYou: ', async (input) => {
+            const trimmed = input.trim();
+            if (!trimmed || trimmed === 'exit') {
+                console.log('Bye!');
+                cronService.stop();
+                await pluginManager.unloadAll();
+                rl.close();
+                return;
+            }
+            const ctx = {
+                messages, timestamps, registry, builder, tracker,
+                sessionStore: store, model, makePromptCtx, ask,
+                memoryStore, vectorStore,
+            };
+            const handled = dispatch(trimmed, ctx);
+            if (handled === 'async')
+                return;
+            if (handled) {
+                ask();
+                return;
+            }
+            const userMsg = { role: 'user', content: trimmed };
+            messages.push(userMsg);
+            timestamps.set(messages.length - 1, Date.now());
+            store.append(userMsg);
+            const currentSystem = builder.build(makePromptCtx());
+            const beforeLen = messages.length;
+            await agentLoop(model, registry, messages, currentSystem, tracker);
+            const newMessages = messages.slice(beforeLen);
+            const now = Date.now();
+            for (let i = beforeLen; i < messages.length; i++)
+                timestamps.set(i, now);
+            store.appendAll(newMessages);
+            console.log(`  [Token] ~${estimateMessageTokens(messages)} tokens`);
+            ask();
+        });
+    }
+    const role = registry.getRole();
+    const toolCount = registry.getActiveTools().length;
+    const hooks = hookPipeline.list();
+    console.log('Super Agent v1.0 (type "exit" to quit)');
+    console.log('快捷命令：');
+    console.log('  /agents           — 查看子 Agent 记录');
+    console.log('  /cron             — 查看定时任务');
+    console.log('  /role [角色]      — 查看/切换角色');
+    console.log('');
+    console.log(`  当前角色: ${role}，可用工具: ${toolCount} 个`);
+    console.log(`  Sub-Agent: 最大深度 ${agentRegistry.getConfig().maxSpawnDepth}，最大并发 ${agentRegistry.getConfig().maxConcurrent}`);
+    console.log('');
+    console.log('  试试：');
+    console.log('    帮我对比 Hono、Fastify 和 Express 的性能和生态');
+    console.log('    /agents       — 查看子 Agent 执行记录');
+    console.log('');
+    if (fs.existsSync('docs')) {
+        const files = fs.readdirSync('docs').filter(f => f.endsWith('.md'));
+        if (files.length > 0) {
+            console.log(`  发现 ${files.length} 个文档，自动导入知识库...`);
+            for (const f of files) {
+                const path = `docs/${f}`;
+                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] })));
+            }
+            console.log(`  知识库就绪，共 ${vectorStore.size()} 个片段\n`);
+        }
+    }
+    ask();
+}