pigpig-agent 1.0.0

package/dist/context/defense.js

@@ -0,0 +1,201 @@
+import { toolResultOutputToText, textToolResultOutput } from './tool-result-output.js';
+export class TokenTracker {
+    lastPreciseCount = 0; // 上一次API返回的token用量
+    pendingChars = 0; // 新增消息的字符数
+    updateFromAPI(promptTokens) {
+        this.lastPreciseCount = promptTokens;
+        this.pendingChars = 0; // 重置 
+    }
+    addMessage(message) {
+        this.pendingChars += countMessageChars(message);
+    }
+    addMessages(messages) {
+        for (const message of messages) {
+            this.addMessage(message);
+        }
+    }
+    replaceMessages(before, after) {
+        this.pendingChars += countMessagesChars(after) - countMessagesChars(before);
+    }
+    get estimateTokens() {
+        return Math.max(0, this.lastPreciseCount + Math.ceil(this.pendingChars / 4));
+    }
+    get status() {
+        const tokens = this.estimateTokens;
+        const percent = Math.round((tokens / CONTEXT_WINDOW) * 100);
+        return {
+            tokens,
+            percent,
+            needsAction: percent >= 75,
+        };
+    }
+}
+const CONTEXT_WINDOW = 200_000;
+function countMessageChars(message) {
+    let chars = 0;
+    if (typeof message.content === 'string') {
+        return message.content.length;
+    }
+    if (!Array.isArray(message.content))
+        return chars;
+    for (const part of message.content) {
+        if ('text' in part && typeof part.text === 'string') {
+            chars += part.text.length;
+        }
+        else if ('output' in part) {
+            chars += toolResultOutputToText(part.output).length;
+        }
+        else if ('input' in part) {
+            chars += JSON.stringify(part.input)?.length || 0;
+        }
+    }
+    return chars;
+}
+function countMessagesChars(messages) {
+    let chars = 0;
+    for (const message of messages) {
+        chars += countMessageChars(message);
+    }
+    return chars;
+}
+export function estimateMessageTokens(messages) {
+    const chars = countMessagesChars(messages); // 所有消息的字符数
+    return Math.ceil((chars / 4) * 1.2); // 1.2x 中文安全系数
+}
+// 2 ----------------------------------
+export function truncateToolResult(messages, config = {
+    maxSingleResult: CONTEXT_WINDOW * 0.5 * 2, // 50%窗口，2倍安全系数
+    contextBudgetChars: CONTEXT_WINDOW * 0.75 * 4, // 75%窗口，4倍安全系数
+}) {
+    let truncated = 0;
+    let compacted = 0;
+    // 1. 单条截断 -- 超过窗口50%的工具结果做 head/tail 分割
+    let result = messages.map(msg => {
+        if (msg.role !== 'tool' || !Array.isArray(msg.content))
+            return msg;
+        const newContent = msg.content.map((part) => {
+            if (!part.output)
+                return part;
+            const outputText = toolResultOutputToText(part.output);
+            if (outputText.length <= config.maxSingleResult)
+                return part;
+            truncated++;
+            const maxChars = config.maxSingleResult;
+            const headSize = Math.floor(maxChars * 0.6);
+            const tailSize = Math.floor(maxChars * 0.4);
+            const head = outputText.slice(0, headSize);
+            const tail = outputText.slice(-tailSize);
+            return {
+                ...part,
+                output: textToolResultOutput(`${head}\n\n[truncated: ${outputText.length} → ${maxChars} chars]\n\n${tail}`),
+            };
+        });
+        return { ...msg, content: newContent };
+    });
+    // 2. 总上下文超过窗口75%， 从最老的 tool result 开始清理  (将 output 替换为 占位符)
+    let totalChars = result.reduce((sum, msg) => {
+        if (typeof msg.content === 'string')
+            return sum + msg.content.length;
+        if (Array.isArray(msg.content)) {
+            return sum + msg.content.reduce((s, p) => s + (p.output ? toolResultOutputToText(p.output).length : p.text?.length || 0), 0);
+        }
+        return sum;
+    }, 0);
+    if (totalChars > config.contextBudgetChars) {
+        for (let i = 0; i < result.length && totalChars > config.contextBudgetChars; i++) {
+            const msg = result[i];
+            if (msg.role !== 'tool' || !Array.isArray(msg.content))
+                continue;
+            const toolName = (msg.content[0])?.toolName || 'unknown';
+            const oldSize = msg.content.reduce((s, p) => s + (p.output ? toolResultOutputToText(p.output).length : 0), 0);
+            result[i] = {
+                ...msg,
+                content: msg.content.map((p) => ({
+                    ...p,
+                    output: textToolResultOutput(`[compacted: ${toolName} output removed to free context]`),
+                })),
+            };
+            totalChars -= oldSize;
+            compacted++;
+        }
+    }
+    return { messages: result, truncated, compacted };
+}
+const DEFAULT_TTL = {
+    softTTLMs: 5 * 60 * 1000,
+    hardTTLMs: 10 * 60 * 1000,
+    keepHeadTail: 1500,
+};
+// 5分钟之前的工具结果做软修剪，10分钟之前的工具结果做硬修剪
+export function ttlPrune(messages, timestamp, config = DEFAULT_TTL) {
+    const now = Date.now();
+    let softPruned = 0;
+    let hardPruned = 0;
+    const result = messages.map((msg, idx) => {
+        // 只修剪角色为 tool 的消息
+        if (msg.role !== 'tool' || !Array.isArray(msg.content))
+            return msg;
+        const ts = timestamp.get(idx); // 这条消息的 timestamp 
+        if (!ts)
+            return msg;
+        const age = now - ts;
+        // 出错的工具调用也不修剪
+        const outputText = msg.content
+            .map((p) => p.output ? toolResultOutputToText(p.output) : '')
+            .join('');
+        const isError = /error|失败|不存在|denied|refused|timeout/i.test(outputText);
+        if (isError)
+            return msg;
+        // 10分钟之前....
+        if (age >= config.hardTTLMs) {
+            hardPruned++;
+            const toolName = msg.content[0]?.toolName || 'unknown';
+            return {
+                ...msg,
+                content: msg.content.map((p) => ({
+                    ...p,
+                    output: textToolResultOutput(`[ tool result expired: ${toolName} ]`),
+                })),
+            };
+        }
+        // 5分钟之前....
+        if (age >= config.softTTLMs) {
+            const newContent = msg.content.map((part) => {
+                if (!part.output)
+                    return part;
+                const outputText = toolResultOutputToText(part.output);
+                if (outputText.length <= config.keepHeadTail * 2)
+                    return part;
+                softPruned++;
+                const head = outputText.slice(0, config.keepHeadTail);
+                const tail = outputText.slice(-config.keepHeadTail);
+                const removed = outputText.length - config.keepHeadTail * 2;
+                return {
+                    ...part,
+                    output: textToolResultOutput(`${head}\n\n[soft pruned: ${removed} chars removed, content older than ${Math.round(config.softTTLMs / 60000)} min]\n\n${tail}`),
+                };
+            });
+            return { ...msg, content: newContent };
+        }
+        return msg;
+    });
+    return { messages: result, softPruned, hardPruned };
+}
+export function applyDefense(messages, timestamps) {
+    // Layer 2: truncate oversized tool results
+    const trunc = truncateToolResult(messages);
+    let result = trunc.messages;
+    // Layer 3: TTL prune old tool results
+    const prune = ttlPrune(result, timestamps);
+    result = prune.messages;
+    // Layer 1: estimate final token count
+    const tokenEstimate = estimateMessageTokens(result);
+    return {
+        messages: result,
+        tokenEstimate,
+        truncated: trunc.truncated,
+        compacted: trunc.compacted,
+        softPruned: prune.softPruned,
+        hardPruned: prune.hardPruned,
+    };
+}

package/dist/context/prompt-builder.js

@@ -0,0 +1,56 @@
+export class PromptBuilder {
+    pipes = []; // 存放所有需要的系统提示词
+    pipe(name, fn) {
+        this.pipes.push({ name, fn });
+        return this;
+    }
+    build(ctx) {
+        const sections = [];
+        for (const { fn } of this.pipes) {
+            const result = fn(ctx);
+            if (result !== null) {
+                sections.push(result);
+            }
+        }
+        return sections.join('\n\n');
+    }
+    debug(ctx) {
+        console.log(`\n=== Prompt Pipe Debug ===\n`);
+        for (const { name, fn } of this.pipes) {
+            const result = fn(ctx);
+            const status = result !== null ? `[ON] ${result.length} chars` : `[OFF]`;
+            console.log(`${name}: ${status}`);
+        }
+        console.log(`\n=== Prompt Debug End ===\n`);
+    }
+}
+// 预定义 pipe
+export function coreRules() {
+    return (ctx) => `你是 PIGPIG Agent，一个有工具调用能力的 AI 助手。
+    你的行为准则：
+    - 先读文件再修改，不要凭记忆编辑
+    - 不要加没被要求的功能
+    - 工具调用失败时，换一个思路而不是重复同样的操作
+    - 回答要简洁直接`;
+}
+export function toolGuide() {
+    return (ctx) => {
+        if (ctx.toolCount === 0)
+            return null;
+        return `你有 ${ctx.toolCount} 个工具可用。需要操作本地文件时使用内置工具，需要访问外部服务时使用 MCP 工具。`;
+    };
+}
+export function deferredTools() {
+    return (ctx) => {
+        if (!ctx.deferredToolSummary)
+            return null;
+        return `如果你需要的工具不在当前列表中，使用 tool_search 工具搜索。${ctx.deferredToolSummary}`;
+    };
+}
+export function sessionContext() {
+    return (ctx) => {
+        if (ctx.sessionMessageCount === 0)
+            return null;
+        return `[会话信息] 当前会话 ${ctx.sessionId}，已有 ${ctx.sessionMessageCount} 条历史消息。`;
+    };
+}

package/dist/context/prompt-pipes.js

@@ -0,0 +1,14 @@
+// .memory 记忆系统中的上下文
+export function memoryContext(memoryStore) {
+    return () => memoryStore.buildPromptSection(); // 跟记忆系统相关的那一截提示词
+}
+// .rag RAG系统中的上下文
+export function ragContext(vectorStore) {
+    return () => {
+        const size = vectorStore.size();
+        if (size === 0)
+            return null;
+        const sources = vectorStore.sources();
+        return `[知识库] 已导入 ${size} 条文档片段（来源：${sources.join(', ')}）。使用 rag_search 工具搜索知识库。`;
+    };
+}

package/dist/context/tool-result-output.js

@@ -0,0 +1,25 @@
+export function textToolResultOutput(value) {
+    return {
+        type: 'text',
+        value: value,
+    };
+}
+export function toolResultOutputToText(output) {
+    switch (output.type) {
+        case 'text':
+        case 'error-text':
+            return output.value;
+        case 'json':
+        case 'error-json':
+            return JSON.stringify(output.value);
+        case 'content':
+            return output.value
+                .map(part => {
+                if (part.type === 'text')
+                    return part.text;
+                const mediaType = 'mediaType' in part ? part.mediaType : undefined;
+                return `[media:${mediaType ?? part.type}]`;
+            })
+                .join('\n');
+    }
+}

package/dist/context/view.js

@@ -0,0 +1,185 @@
+const COLORS = {
+    system: 63, // 紫
+    tools: 99, // 紫粉
+    memory: 220, // 黄
+    skills: 36, // 青
+    messages: 111, // 蓝
+    free: 240, // 灰（空格子）
+    buffer: 244, // 灰（autocompact buffer）
+    text: 255, // 白文字
+    dim: 244, // 暗灰
+};
+function fg(code, s) {
+    return `\x1b[38;5;${code}m${s}\x1b[0m`;
+}
+function pct(n, total) {
+    if (total === 0)
+        return '0.0%';
+    return `${((n / total) * 100).toFixed(1)}%`;
+}
+function fmtTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+/**
+ * 画一个 16×16 = 256 格的矩阵，每格代表 window/256 个 tokens。
+ * 已用部分按 slices 顺序填彩色 ●，free 用 ○，autocompact buffer 用 ▢。
+ */
+export function renderContextMatrix(snapshot) {
+    const { windowTokens, slices, autocompactBufferTokens } = snapshot;
+    const TOTAL_CELLS = 256;
+    const tokensPerCell = windowTokens / TOTAL_CELLS;
+    // 把每个 slice 的 token 数转成"格子数"（向上取整避免 0 格丢失）
+    const cells = []; // ANSI color for each cell, or -1 for free, -2 for buffer
+    let used = 0;
+    for (const s of slices) {
+        if (s.tokens <= 0)
+            continue;
+        const n = Math.max(1, Math.round(s.tokens / tokensPerCell));
+        for (let i = 0; i < n && cells.length < TOTAL_CELLS; i++) {
+            cells.push(s.color);
+        }
+        used += n;
+    }
+    const bufferCells = Math.max(0, Math.round(autocompactBufferTokens / tokensPerCell));
+    const freeCells = TOTAL_CELLS - cells.length - bufferCells;
+    for (let i = 0; i < freeCells; i++)
+        cells.push(-1);
+    for (let i = 0; i < bufferCells && cells.length < TOTAL_CELLS; i++)
+        cells.push(-2);
+    const lines = [];
+    for (let row = 0; row < 16; row++) {
+        const rowCells = [];
+        for (let col = 0; col < 16; col++) {
+            const idx = row * 16 + col;
+            const c = cells[idx];
+            if (c === -1)
+                rowCells.push(fg(COLORS.free, '○'));
+            else if (c === -2)
+                rowCells.push(fg(COLORS.buffer, '▢'));
+            else
+                rowCells.push(fg(c, '●'));
+        }
+        lines.push(rowCells.join(' '));
+    }
+    return lines.join('\n');
+}
+export function renderContextLegend(snapshot) {
+    const { slices, autocompactBufferTokens, windowTokens, usedTokens } = snapshot;
+    const lines = [];
+    lines.push(fg(COLORS.text, fg(255, '\x1b[1m') + snapshot.modelName + '\x1b[0m'));
+    lines.push(fg(COLORS.dim, snapshot.modelId));
+    lines.push(`${fmtTokens(usedTokens)}/${fmtTokens(windowTokens)} tokens (${pct(usedTokens, windowTokens)})`);
+    lines.push('');
+    lines.push(fg(COLORS.dim, '\x1b[3mEstimated usage by category\x1b[0m'));
+    for (const s of slices) {
+        if (s.tokens <= 0)
+            continue;
+        const dot = fg(s.color, '●');
+        const label = `${s.icon} ${s.name}`;
+        const value = `${fmtTokens(s.tokens)} tokens (${pct(s.tokens, windowTokens)})`;
+        lines.push(`${dot} ${label}: ${value}`);
+    }
+    const free = windowTokens - usedTokens - autocompactBufferTokens;
+    lines.push(`${fg(COLORS.free, '○')}  Free space: ${fmtTokens(Math.max(0, free))} (${pct(Math.max(0, free), windowTokens)})`);
+    lines.push(`${fg(COLORS.buffer, '▢')}  Autocompact buffer: ${fmtTokens(autocompactBufferTokens)} (${pct(autocompactBufferTokens, windowTokens)})`);
+    return lines.join('\n');
+}
+/**
+ * 并排显示矩阵 + 图例。简单按行拼接，矩阵在左、图例在右。
+ */
+export function renderContextView(snapshot) {
+    const matrix = renderContextMatrix(snapshot).split('\n');
+    const legend = renderContextLegend(snapshot).split('\n');
+    const rows = Math.max(matrix.length, legend.length);
+    const out = [];
+    for (let i = 0; i < rows; i++) {
+        const left = (matrix[i] || '').padEnd(80, ' ');
+        const right = legend[i] || '';
+        out.push(`  ${left}  ${right}`);
+    }
+    return '\n' + out.join('\n') + '\n';
+}
+const CHARS_PER_TOKEN = 3.5;
+function approxTokensFromChars(chars) {
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function approxMessageTokens(messages) {
+    let chars = 0;
+    for (const m of messages) {
+        if (typeof m.content === 'string')
+            chars += m.content.length;
+        else if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === 'text')
+                    chars += (part.text || '').length;
+                else if (part.type === 'tool-call')
+                    chars += JSON.stringify(part.input || {}).length + 80;
+                else if (part.type === 'tool-result') {
+                    const out = part.output;
+                    if (typeof out === 'string')
+                        chars += out.length;
+                    else if (out?.value)
+                        chars += String(out.value).length;
+                    else
+                        chars += JSON.stringify(out || {}).length;
+                    chars += 80;
+                }
+            }
+        }
+    }
+    return approxTokensFromChars(chars);
+}
+export function buildContextSnapshot(input) {
+    const slices = [
+        { name: 'System prompt', tokens: approxTokensFromChars(input.systemPromptChars), color: COLORS.system, icon: '◆' },
+        { name: 'System tools', tokens: approxTokensFromChars(input.toolDescriptionChars), color: COLORS.tools, icon: '◇' },
+        { name: 'Memory', tokens: approxTokensFromChars(input.memoryChars), color: COLORS.memory, icon: '◈' },
+        { name: 'Skills', tokens: approxTokensFromChars(input.skillsChars), color: COLORS.skills, icon: '◉' },
+        { name: 'Messages', tokens: approxMessageTokens(input.messages), color: COLORS.messages, icon: '◎' },
+    ];
+    const usedTokens = slices.reduce((a, s) => a + s.tokens, 0);
+    return {
+        modelName: input.modelName,
+        modelId: input.modelId,
+        windowTokens: input.windowTokens,
+        usedTokens,
+        slices,
+        autocompactBufferTokens: input.autocompactBufferTokens ?? Math.round(input.windowTokens * 0.05),
+    };
+}
+// ── /usage 视图：累计成本 + cache 命中率 ─────────────────────────
+export function renderUsageView(tracker) {
+    const t = tracker.totals();
+    const lines = [];
+    const C = (n, s) => fg(n, s);
+    const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+    const totalCacheable = t.cacheReadTokens + t.cacheWriteTokens + t.inputTokens;
+    lines.push(bold(C(255, '  Usage Summary')));
+    lines.push(C(244, `  ${t.steps} 步累计 · ${new Date().toISOString().slice(0, 19).replace('T', ' ')}`));
+    lines.push('');
+    lines.push(`  ${C(111, '◎')} Input          ${fmtTokens(t.inputTokens).padStart(8)} tokens`);
+    lines.push(`  ${C(220, '◈')} Cache write    ${fmtTokens(t.cacheWriteTokens).padStart(8)} tokens`);
+    lines.push(`  ${C(36, '◉')} Cache read     ${fmtTokens(t.cacheReadTokens).padStart(8)} tokens   (${(t.hitRate * 100).toFixed(1)}% hit)`);
+    lines.push(`  ${C(99, '◇')} Output         ${fmtTokens(t.outputTokens).padStart(8)} tokens`);
+    lines.push('');
+    // Cache 命中率条
+    const barWidth = 30;
+    const filled = Math.round(t.hitRate * barWidth);
+    const bar = C(36, '█'.repeat(filled)) + C(240, '░'.repeat(barWidth - filled));
+    lines.push(`  Cache hit rate  ${bar}  ${(t.hitRate * 100).toFixed(1)}%`);
+    lines.push('');
+    lines.push(`  ${bold('Cost')}            ${C(220, '$' + t.cost.toFixed(4))}`);
+    lines.push(`  ${C(244, 'Without cache')}   ${C(244, '$' + t.baselineCost.toFixed(4))}`);
+    const savedPct = t.baselineCost > 0 ? (t.savedCost / t.baselineCost) * 100 : 0;
+    if (t.savedCost > 0) {
+        lines.push(`  ${bold(C(36, 'Saved'))}           ${C(36, '$' + t.savedCost.toFixed(4))} (${savedPct.toFixed(1)}% off)`);
+    }
+    if (totalCacheable === 0) {
+        lines.push('  ' + C(244, '尚无可缓存的 input，多聊几轮再看 :)'));
+    }
+    return '\n' + lines.join('\n') + '\n';
+}

package/dist/cron/parser.js

@@ -0,0 +1,27 @@
+import { Cron } from 'croner';
+const INTERVAL_RE = /^every\s+(\d+)\s*(s|sec|m|min|h|hour)s?$/i;
+export function parseSchedule(expr) {
+    // 固定间隔
+    const intervalMatch = expr.match(INTERVAL_RE);
+    if (intervalMatch) {
+        const value = parseInt(intervalMatch[1]);
+        const unit = intervalMatch[2].toLowerCase();
+        const multiplier = unit.startsWith('h') ? 3600000
+            : unit.startsWith('m') ? 60000
+                : 1000;
+        return { type: 'interval', intervalMs: value * multiplier };
+    }
+    // ISO 时间戳
+    if (/^\d{4}-\d{2}-\d{2}/.test(expr)) {
+        const date = new Date(expr);
+        if (!isNaN(date.getTime())) {
+            return { type: 'once', onceAt: date };
+        }
+    }
+    // Cron 表达式
+    const cronInstance = new Cron(expr);
+    return { type: 'cron', cronInstance };
+}
+export function getNextCronTime(cron) {
+    return cron.msToNext() ?? 60000;
+}