@bolloon/bolloon-agent 0.1.34 → 0.1.36

package/dist/context-compaction/pipeline.js

@@ -0,0 +1,123 @@
+/**
+ * Context Compaction Pipeline — 5 层编排
+ *
+ * 严格对齐 Claude Code 论文: 每次 LLM call 前顺序执行 5 个 shaper, 由便宜到重, 任一层 fit 就短路.
+ *
+ *   1. Budget Reduction   (总是, 截断 > 阈值的单条消息)
+ *   2. Snip               (feature flag BOLLOON_SNIP_ENABLED)
+ *   3. Microcompact       (总是, 折叠老 tool_result)
+ *   4. Context Collapse   (feature flag BOLLOON_CONTEXT_COLLAPSE, 读时虚拟投影)
+ *   5. Auto-Compact       (LLM 摘要, 兜底)
+ *
+ * 短路: 任一层后 budget fit (< 0.8) → 返回该层结果, 不跑后续.
+ *
+ * 关键不变量:
+ *   - 任何异常 → 整 pipeline 返回原 history (与现状一致)
+ *   - 第 1-3 层不破坏 messageHistory 内存引用 (内容可改)
+ *   - 第 4 层读时投影, memory 不变
+ *   - 第 5 层破坏性, 折叠 N 对成 1 条
+ *
+ * 失败静默: 整 pipeline 用 try/catch 包, 任何 stage 失败不影响整体
+ */
+import { budgetGate } from './budget-gate.js';
+import { budgetReduce } from './budget-reduce.js';
+import { snip, isSnipEnabled } from './snip.js';
+import { microcompact } from './microcompact.js';
+import { contextCollapse, isContextCollapseEnabled } from './context-collapse.js';
+import { autoCompact } from './auto-compact.js';
+const DEFAULT_MAX_TOKENS = 8000;
+export async function compactPipeline(history, opts = {}) {
+    const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const ctx = {
+        inputHistory: history,
+        history,
+        estimatedTokens: 0,
+        opts,
+        stages: [],
+    };
+    try {
+        // Stage 1: Budget Reduction
+        let result = budgetReduce(history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('budgetReduce', result, history));
+        let gate = budgetGate(ctx.history, maxTokens);
+        ctx.estimatedTokens = gate.estimatedTokens;
+        if (gate.fit)
+            return finalize(ctx, result.applied); // 短路但可能 budgetReduce 实际改了内容
+        // Stage 2: Snip (feature flag)
+        if (isSnipEnabled()) {
+            const before = ctx.history;
+            result = snip(ctx.history, opts);
+            ctx.history = result.history;
+            ctx.stages.push(stageRecord('snip', result, before));
+            gate = budgetGate(ctx.history, maxTokens);
+            ctx.estimatedTokens = gate.estimatedTokens;
+            if (gate.fit)
+                return finalize(ctx, true);
+        }
+        else {
+            ctx.stages.push({ stage: 'snip', applied: false, before: ctx.history.length, after: ctx.history.length, detail: 'feature flag off' });
+        }
+        // Stage 3: Microcompact
+        const before3 = ctx.history;
+        result = microcompact(ctx.history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('microcompact', result, before3));
+        gate = budgetGate(ctx.history, maxTokens);
+        ctx.estimatedTokens = gate.estimatedTokens;
+        if (gate.fit)
+            return finalize(ctx, result.applied || true);
+        // Stage 4: Context Collapse (feature flag)
+        if (isContextCollapseEnabled()) {
+            const before4 = ctx.history;
+            result = contextCollapse(ctx.history, opts);
+            ctx.history = result.history;
+            ctx.stages.push(stageRecord('contextCollapse', result, before4));
+            gate = budgetGate(ctx.history, maxTokens);
+            ctx.estimatedTokens = gate.estimatedTokens;
+            if (gate.fit)
+                return finalize(ctx, true);
+        }
+        else {
+            ctx.stages.push({ stage: 'contextCollapse', applied: false, before: ctx.history.length, after: ctx.history.length, detail: 'feature flag off' });
+        }
+        // Stage 5: Auto-Compact (兜底)
+        const before5 = ctx.history;
+        result = await autoCompact(ctx.history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('autoCompact', result, before5));
+        return finalize(ctx, true);
+    }
+    catch (err) {
+        console.warn('[compactor] pipeline failed (silent, returning original):', err);
+        return {
+            history,
+            estimatedTokens: 0,
+            stages: ctx.stages,
+            compacted: false,
+        };
+    }
+}
+function stageRecord(name, result, before) {
+    return {
+        stage: name,
+        applied: result.applied,
+        before: before.length,
+        after: result.history.length,
+        detail: result.detail,
+    };
+}
+function finalize(ctx, compacted) {
+    return {
+        history: ctx.history,
+        estimatedTokens: ctx.estimatedTokens,
+        stages: ctx.stages,
+        compacted,
+    };
+}
+// ============================================================
+// 测试钩子
+// ============================================================
+export function _resetPipelineForTest() {
+    // pipeline 是 stateless, 但保留 API 一致性
+}

package/dist/context-compaction/snip.js

@@ -0,0 +1,45 @@
+/**
+ * Snip — 第 2 层: 裁掉老 history
+ *
+ * 论文: feature flag 关闭 (默认), 用户开启后才生效
+ * 开启环境变量: BOLLOON_SNIP_ENABLED=1
+ *
+ * 行为: 只保留最近 N 对 user/assistant (默认 20 对)
+ * 工具结果消息按其所属 round 一起保留
+ *
+ * 失败静默: 异常 → 返回原 history
+ */
+const DEFAULT_KEEP_PAIRS = 20;
+export function isSnipEnabled() {
+    return process.env.BOLLOON_SNIP_ENABLED === '1';
+}
+export function snip(history, opts = {}) {
+    try {
+        if (opts.skip || !isSnipEnabled()) {
+            return { history, applied: false, detail: isSnipEnabled() ? 'skipped' : 'feature flag off' };
+        }
+        const keepPairs = opts.snipKeepPairs ?? DEFAULT_KEEP_PAIRS;
+        // 从后往前数 N 对 user/assistant 边界
+        let pairsFound = 0;
+        let cutFrom = -1;
+        for (let i = history.length - 1; i >= 0; i--) {
+            const m = history[i];
+            if (m.role === 'user') {
+                pairsFound++;
+                if (pairsFound >= keepPairs) {
+                    cutFrom = i;
+                    break;
+                }
+            }
+        }
+        if (cutFrom <= 0) {
+            return { history, applied: false, detail: 'history too short' };
+        }
+        const out = history.slice(cutFrom);
+        return { history: out, applied: true, detail: `kept last ${keepPairs} pairs, dropped ${cutFrom} older messages` };
+    }
+    catch (err) {
+        console.warn('[compactor] snip failed (silent, returning original):', err);
+        return { history, applied: false, detail: 'error' };
+    }
+}

package/dist/context-compaction/token-estimator.js

@@ -0,0 +1,35 @@
+/**
+ * Token Estimator — 4 字符 ≈ 1 token 的粗估
+ *
+ * 为什么不引 tiktoken 依赖:
+ * - bolloon 默认 npm 用户, 引依赖增加 install 体积
+ * - Claude Code 论文也指出: 精确 token 计数不是关键, 渐进压缩才是
+ * - 4 字符/token 在中文/英文混合场景下误差约 ±20%, 对预算判定足够
+ *
+ * 失败静默: 任何异常 → 返回估算值 (不抛错)
+ */
+const CHARS_PER_TOKEN = 4;
+export function estimateTokens(messages) {
+    let total = 0;
+    for (const m of messages) {
+        total += Math.ceil((m.content?.length || 0) / CHARS_PER_TOKEN);
+        if (m.toolResult) {
+            try {
+                const s = typeof m.toolResult === 'string' ? m.toolResult : JSON.stringify(m.toolResult);
+                total += Math.ceil(s.length / CHARS_PER_TOKEN);
+            }
+            catch { /* circular ref, ignore */ }
+        }
+        if (m.toolCall) {
+            try {
+                const s = typeof m.toolCall === 'string' ? m.toolCall : JSON.stringify(m.toolCall);
+                total += Math.ceil(s.length / CHARS_PER_TOKEN);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return total;
+}
+export function estimateStringTokens(s) {
+    return Math.ceil(s.length / CHARS_PER_TOKEN);
+}

package/dist/context-compaction/types.js

@@ -0,0 +1,19 @@
+/**
+ * Context Compaction — 类型定义
+ *
+ * 严格对齐 Claude Code 论文 5 层压缩流水线:
+ *   1. Budget Reduction   (单条消息大小限制)
+ *   2. Snip               (裁掉老历史, feature flag 关闭)
+ *   3. Microcompact       (cache-aware 细粒度压缩, 老 tool_result 折叠)
+ *   4. Context Collapse   (读时虚拟投影, 非破坏)
+ *   5. Auto-Compact       (LLM 摘要, 兜底)
+ *
+ * 关键不变量:
+ *   - 第 1-3 层不破坏 messageHistory 内存结构, 只改 buildContext 输出
+ *   - 第 4 层读时投影, 绝不改 messageHistory
+ *   - 第 5 层破坏 messageHistory, 把 N 对折叠成 1 条 summary
+ *
+ * 类型设计: Message 在本模块内独立定义, 靠 structural typing 与 pi-sdk.ts 的 Message 兼容.
+ * 不 import pi-sdk 避免循环依赖.
+ */
+export {};

package/dist/heartbeat/HealthMonitor.js

@@ -231,9 +231,10 @@ export class HealthMonitor {
     async pingLLM(minimax) {
         const start = Date.now();
         try {
-            // 简单的 chat 测试
+            // 2026-06-15: signal 位置正确传 undefined (chat signature 是 (message, context?, signal?))
+            //   之前传 { maxTokens: 1 } 被当 signal, Node 22+ undici 强类型 AbortSignal 校验 throw
             if (minimax.chat) {
-                await minimax.chat('ping', 'test', { maxTokens: 1 });
+                await minimax.chat('ping', 'test', undefined);
             }
             else if (minimax.ping) {
                 await minimax.ping();

package/dist/index.js

@@ -978,6 +978,34 @@ async function runNonInteractive(args, comm) {
         console.log(`✅ 结果已保存到: ${output}`);
         return;
     }
+    if (tool === 'prompt' && prompt) {
+        // 2026-06-15: --prompt "text" 走直接调 a.prompt(prompt) 路径, 避开 runToolCommand
+        //   (case 'prompt' 内的 [text] = args 从 toolArgs 取值是空数组, 永远报"缺少 prompt 文本"是 CLI bug)
+        const startTime = Date.now();
+        const a = await getAgent();
+        try {
+            const response = await a.prompt(prompt);
+            const elapsed = Date.now() - startTime;
+            if (json) {
+                console.log(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
+            }
+            else {
+                console.log(response);
+                console.log(`\n耗时: ${elapsed}ms`);
+            }
+        }
+        catch (e) {
+            const error = e?.message || String(e);
+            if (json) {
+                console.log(JSON.stringify({ success: false, error }, null, 2));
+            }
+            else {
+                console.log(`\n错误: ${error}`);
+            }
+            process.exit(1);
+        }
+        return;
+    }
     if (tool) {
         await runToolCommand(tool, toolArgs, !!json, comm);
     }
@@ -1367,7 +1395,9 @@ async function main() {
     s.banner();
     s.section('系统初始化');
     const hasOpenAI = !!process.env.OPENAI_API_KEY;
-    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
+    // 2026-06-15: 修复 — 之前 anthropic 401 是因为 shell env 残留的旧 ANTHROPIC_API_KEY 抢了 provider 选择
+    //   用 BOLLOON_LLM_PROVIDER env 显式覆盖, 否则还是按 env hasXxx 顺序自动选
+    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY && !process.env.BOLLOON_LLM_PROVIDER;
     const hasMinimax = !!process.env.MINIMAX_API_KEY;
     const hasDeepSeek = !!process.env.DEEPSEEK_API_KEY;
     const hasKimi = !!(process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY);
@@ -1433,12 +1463,29 @@ async function main() {
         s.warn('将使用无 P2P 模式运行');
     }
     await bootstrapIroh(keypair, name);
+    // Bolloon Bootstrap: 启动扫描 + Context 收集 + 挂定时任务
+    // 失败静默 (主流程不被阻塞)
+    try {
+        const { bootstrapBolloon } = await import('./pi-ecosystem-judgment/human-value-pipeline.js');
+        s.info('正在 bootstrap bolloon 上下文...');
+        const bs = await bootstrapBolloon({ cwd: process.cwd() });
+        s.info(`Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
+    }
+    catch (err) {
+        s.warn(`Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+    }
     s.divider();
     if (mode === 'web') {
         const port = parseInt(process.env.PORT || '54188');
+        // 2026-06-16: BOLLOON_DEV_MODE=1 或 selfImprove=true 启动项 → 开发者模式, 启用自迭代 (健康监控+自改总线)
+        // 默认用户模式: 不自迭代, 自改卡片不自动出现, 仍可 POST /api/self-improve/trigger 手动触发
+        const selfImprove = process.env.BOLLOON_DEV_MODE === '1' || process.env.BOLLOON_DEV_MODE === 'true';
+        if (selfImprove) {
+            console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
+        }
         const { createWebServer, openBrowser } = await import('./web/server.js');
         s.info(`启动 Web 服务端口 ${port}...`);
-        const { port: actualPort } = await createWebServer(port);
+        const { port: actualPort } = await createWebServer(port, { selfImprove });
         s.success(`浏览器已打开 → http://localhost:${actualPort}`);
         openBrowser(`http://localhost:${actualPort}`);
     }

package/dist/llm/llm-judgment-client.js

@@ -6,19 +6,31 @@
  */
 import { llmConfigStore } from './config-store.js';
 import { PiAIModel } from './pi-ai.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LAYERS_DIR = path.join(__dirname, 'system-prompt', 'layers');
+/**
+ * 从 layer 读 .md 文件作为系统 prompt
+ * 失败时降级到兜底字符串 (不挂)
+ */
+async function loadRoleLayer(layerId, fallback) {
+    const [group, ...rest] = layerId.split('.');
+    const path2md = path.join(LAYERS_DIR, group, `${rest.join('.')}.md`);
+    try {
+        return await fs.readFile(path2md, 'utf-8');
+    }
+    catch {
+        return fallback;
+    }
+}
 // 预定义的判断 Prompt 配置
 export const JUDGMENT_PROMPTS = {
     // 默认判断 Prompt
     default: {
-        systemPrompt: `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
-
-核心原则：
-1. 第一性原理：追问问题的本质，而非表面现象
-2. 多角度思考：考虑不同视角和影响因素
-3. 上下文感知：理解对话历史和隐含意图
-4. 动态评估：根据实际情况判断复杂性
-
-你的判断会影响后续的智能体协作方式，请认真分析。`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.expert', '你是一个专业的 AI 任务分析专家. '),
         userPromptTemplate: `【当前输入】
 {user_input}
 
@@ -73,16 +85,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 架构相关问题
     architecture: {
-        systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
-- 从需求中提取本质问题
-- 设计可扩展的系统架构
-- 权衡技术方案
-- 识别架构风险
-
-你相信：
-- 本质和实现必须分离
-- 好的架构从简单规则中生长
-- 复杂性应该被控制而非消除`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.architect', '你是一个经验丰富的系统架构师. '),
         userPromptTemplate: `【架构设计问题】
 {user_input}
 
@@ -108,11 +112,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 代码相关问题
     code: {
-        systemPrompt: `你是一个高效的代码实现专家。你擅长：
-- 快速理解和实现需求
-- 编写清晰、可维护的代码
-- 遵循最佳实践
-- 处理边界情况`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.implementer', '你是一个高效的代码实现专家. '),
         userPromptTemplate: `【代码问题】
 {user_input}
 
@@ -134,11 +135,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 安全相关问题
     security: {
-        systemPrompt: `你是一个严格的安全专家。你擅长：
-- 识别安全风险
-- 评估威胁模型
-- 设计安全方案
-- 遵循安全最佳实践`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.security', '你是一个严格的安全专家. '),
         userPromptTemplate: `【安全问题】
 {user_input}
 
@@ -221,8 +219,12 @@ export class LLMJudgmentClient {
         }
         try {
             // 调用 LLM
+            // 优先用 systemPromptResolver (从 layer 读), fallback 静态 systemPrompt
+            const systemPrompt = this.promptConfig.systemPromptResolver
+                ? await this.promptConfig.systemPromptResolver()
+                : this.promptConfig.systemPrompt;
             const messages = [
-                { role: 'system', content: this.promptConfig.systemPrompt },
+                { role: 'system', content: systemPrompt },
                 { role: 'user', content: userPrompt }
             ];
             const response = await this.model.chat(userPrompt);