@bolloon/bolloon-agent 0.3.0 → 0.3.3

package/dist/agents/parse-tool-call.js

@@ -72,6 +72,42 @@ export function parseToolCall(content, ctx) {
         return null;
     // === 0. 剥离 思考块 — 必须先做, 否则旧 regex `<(\w+)>...</\1>` 会先匹配 想想标签 ===
     const strippedContent = content.replace(/<think[\s\S]*?<\/think/g, '');
+    // [diag-2026-07-12] 临时诊断日志:WebUI 出现 7 个 “必填/参数 undefined” 错误,
+    //   怀疑 parseToolCall 没拿到正确的 name/args. 这里只打日志不改任何逻辑.
+    //   日志形态: [parseToolCall diag] ok=true/false name=... argKeys=... rawHead=...
+    //   用 console.warn 一行 JSON, 方便 grep + 排时间线.
+    try {
+        const result = (function _diagProbe() {
+            // 用与正文完全相同的解析路径,但提前跑一次,记录是否命中
+            // 走完下面所有分支再覆盖回原值即可
+            return null;
+        })();
+        void result;
+        const probe = (function _doParse() {
+            // 内联一份最便宜的 "能不能解出 name" 探测 — 不重复跑全部分支
+            const m1 = strippedContent.match(/<invoke\s+name=["']([\w]+)["']/);
+            if (m1) {
+                return { name: m1[1], args: { __probe_invoketag: '1' } };
+            }
+            const m2 = strippedContent.match(/<function_calls>[\s\S]*?<invoke\s+name=["']([\w]+)["']/);
+            if (m2) {
+                return { name: m2[1], args: { __probe_function_calls: '1' } };
+            }
+            const m3 = strippedContent.match(/\{[\s\S]*?"name"\s*:\s*["']([\w]+)["']/);
+            if (m3) {
+                return { name: m3[1], args: { __probe_json_name: '1' } };
+            }
+            return null;
+        })();
+        console.warn('[parseToolCall diag] rawLen=' + content.length +
+            ' strippedLen=' + strippedContent.length +
+            ' probeName=' + (probe?.name ?? 'null') +
+            ' rawHead=' + JSON.stringify(content.slice(0, 500)));
+    }
+    catch (diagErr) {
+        // 诊断日志绝不能影响主路径 — 吞掉任何 diag 自身抛错
+        console.warn('[parseToolCall diag] diag-self-failed:', String(diagErr));
+    }
     // === 1. JSON function-call (OpenAI / Anthropic / Minimax-style) ===
     const jsonPatterns = [
         // markdown json code block + OpenAI  块, 同时匹配 arguments/input 字段

package/dist/agents/pi-sdk-tools.js

@@ -37,10 +37,13 @@ export function registerBuiltinTools(ctx) {
     ctx.tools.set('read_document', {
         name: 'read_document',
         description: '读取文档内容，支持 .txt, .md, .pdf, .docx 格式',
-        parameters: { path: 'string' },
+        parameters: { path: '文件路径 (必填)' },
         execute: async (args) => {
             try {
-                const content = await documentReader.read(args.path);
+                const path = String(args.path || '').trim();
+                if (!path)
+                    return { success: false, error: 'path 必填' };
+                const content = await documentReader.read(path);
                 return {
                     success: true,
                     output: `📄 ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n\n${content.text.substring(0, 1000)}${content.text.length > 1000 ? '...' : ''}`
@@ -54,16 +57,19 @@ export function registerBuiltinTools(ctx) {
     ctx.tools.set('summarize_document', {
         name: 'summarize_document',
         description: '总结文档内容，分析并生成摘要',
-        parameters: { path: 'string', context: 'string' },
+        parameters: { path: '文件路径 (必填)', context: '可选, 总结上下文提示' },
         execute: async (args) => {
             try {
+                const path = String(args.path || '').trim();
+                if (!path)
+                    return { success: false, error: 'path 必填' };
                 if (!ctx.minimaxAvailable) {
                     return { success: false, error: 'LLM未初始化，请设置 MINIMAX_API_KEY' };
                 }
                 // summarizeDocument 走 PiAgentSession.summarizeDocument, 这里通过 tools 反向调用不好处理
                 // 简化: 让 LLM 自己直接走 shell_exec / use_skill 路径
                 const llm = getMinimax();
-                const content = await documentReader.read(args.path);
+                const content = await documentReader.read(path);
                 const r = await llm.summarize(content.text, args.context);
                 return {
                     success: true,
@@ -78,15 +84,21 @@ export function registerBuiltinTools(ctx) {
     ctx.tools.set('improve_document', {
         name: 'improve_document',
         description: '根据要求改进文档内容',
-        parameters: { path: 'string', requirements: 'string' },
+        parameters: { path: '文件路径 (必填)', requirements: '改进要求 (必填)' },
         execute: async (args) => {
             try {
+                const path = String(args.path || '').trim();
+                if (!path)
+                    return { success: false, error: 'path 必填' };
+                const requirements = String(args.requirements || '').trim();
+                if (!requirements)
+                    return { success: false, error: 'requirements 必填' };
                 if (!ctx.minimaxAvailable) {
                     return { success: false, error: 'LLM未初始化，请设置 MINIMAX_API_KEY' };
                 }
                 const llm = getMinimax();
-                const content = await documentReader.read(args.path);
-                const improved = await llm.summarize(content.text + '\n\n改进要求: ' + args.requirements, undefined);
+                const content = await documentReader.read(path);
+                const improved = await llm.summarize(content.text + '\n\n改进要求: ' + requirements, undefined);
                 return {
                     success: true,
                     output: `✅ 改进完成\n质量评分: ${(improved.qualityScore * 10).toFixed(1)}/10\n${improved.summary ? '\n改进内容:\n' + improved.summary.substring(0, 500) + '...' : ''}`

package/dist/cli/loading-tui.js

@@ -7,34 +7,101 @@ const GREEN = '\x1b[32m';
 const RED = '\x1b[31m';
 const GRAY = '\x1b[90m';
 const RESET = '\x1b[0m';
+const STEP_SYMBOL = {
+    pending: `${GRAY}○${RESET}`,
+    active: `${YELLOW}⠹${RESET}`,
+    ok: `${GREEN}✓${RESET}`,
+    warn: `${YELLOW}⚠${RESET}`,
+    error: `${RED}✗${RESET}`,
+};
 export class LoadingTUI {
     write;
     timer = null;
-    running = false;
+    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    frameIdx = 0;
+    steps = [];
+    currentLabel = 'Bolloon loading...';
+    lastRenderedStepCount = 0;
+    finished = false;
+    ok = true;
     constructor() {
         this.write = process.stdout.write.bind(process.stdout);
     }
+    setSteps(steps) {
+        this.steps = steps.map(label => ({ label, status: 'pending' }));
+        this.drawAll();
+    }
+    startStep(index, label) {
+        if (index < 0 || index >= this.steps.length)
+            return;
+        this.steps[index].status = 'active';
+        if (label !== undefined)
+            this.steps[index].label = label;
+        this.drawAll();
+    }
+    completeStep(index, status = 'ok', label) {
+        if (index < 0 || index >= this.steps.length)
+            return;
+        this.steps[index].status = status;
+        if (label !== undefined)
+            this.steps[index].label = label;
+        this.drawAll();
+    }
+    setMessage(msg) {
+        this.currentLabel = msg;
+    }
     start(msg = 'Bolloon loading...') {
-        this.running = true;
+        if (this.timer)
+            return;
+        this.currentLabel = msg;
         this.write(HIDE);
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        let i = 0;
         this.timer = setInterval(() => {
-            if (!this.running)
+            if (this.finished)
                 return;
-            this.write(`\r${CLEAR}\r  ${YELLOW}${frames[i++ % frames.length]}${RESET} ${msg}`);
+            this.write(`\r${CLEAR}\r  ${YELLOW}${this.frames[this.frameIdx++ % this.frames.length]}${RESET} ${this.currentLabel}`);
         }, 100);
     }
+    drawAll() {
+        if (!this.timer || this.finished)
+            return;
+        const out = [];
+        for (const step of this.steps) {
+            const prefix = step.status === 'active' ? YELLOW : '';
+            out.push(`  ${STEP_SYMBOL[step.status]} ${prefix}${step.label}${RESET}\n`);
+        }
+        this.lastRenderedStepCount = this.steps.length;
+        this.write(out.join(''));
+        this.write(`\x1b[${this.steps.length}A`);
+        this.write(`\r${CLEAR}\r  ${YELLOW}${this.frames[this.frameIdx % this.frames.length]}${RESET} ${this.currentLabel}`);
+    }
     stop(ok = true) {
-        this.running = false;
-        if (this.timer)
+        this.finished = true;
+        this.ok = ok;
+        if (this.timer) {
             clearInterval(this.timer);
-        this.timer = null;
+            this.timer = null;
+        }
+        if (this.lastRenderedStepCount > 0) {
+            this.write(`\x1b[${this.lastRenderedStepCount}B`);
+        }
         this.write(`\r${CLEAR}\r`);
-        if (ok)
+        if (this.steps.length > 0) {
+            for (const step of this.steps) {
+                this.write(`  ${STEP_SYMBOL[step.status]} ${step.label}\n`);
+            }
+        }
+        if (this.ok) {
             this.write(`  ${GREEN}✓${RESET} ${CYAN}Bolloon${RESET} ${GRAY}ready${RESET}\n`);
-        else
+        }
+        else {
             this.write(`  ${RED}✗${RESET} ${CYAN}Bolloon${RESET} ${GRAY}startup failed${RESET}\n`);
+        }
         this.write(SHOW);
     }
+    isFinished() {
+        return this.finished;
+    }
+    wasOk() {
+        return this.ok;
+    }
 }

package/dist/documents/reader.js

@@ -4,6 +4,9 @@ import pdfParse from 'pdf-parse';
 import mammoth from 'mammoth';
 export class DocumentReader {
     async read(filePath) {
+        if (!filePath || typeof filePath !== 'string' || !filePath.trim()) {
+            throw new Error('read(filePath): filePath 必填且必须是非空字符串');
+        }
         const stats = await fs.stat(filePath);
         const ext = path.extname(filePath).toLowerCase();
         const filename = path.basename(filePath);

package/dist/index.js

@@ -1819,7 +1819,16 @@ async function main() {
         const isCLIInteractive = mode === 'cli' && !isNonInteractive;
         loading = isCLIInteractive ? new LoadingTUI() : null;
         if (loading) {
-            loading.start();
+            loading.setSteps([
+                'LLM provider 检测',
+                'DIAP 身份生成',
+                'DID 发布到 IPFS',
+                'P2P 网络启动',
+                'iroh transport 启动',
+                'Bolloon 上下文 bootstrap',
+                'Web 服务启动',
+            ]);
+            loading.start('启动中...');
             console.log = () => { };
             console.info = () => { };
             process.stdout.write = () => true;
@@ -1873,22 +1882,31 @@ async function main() {
                                             hasQwen ? 'Qwen' : null;
         if (llmProvider) {
             s.step(0, 4, `LLM: ${llmProvider}`, 'ok');
+            loading?.completeStep(0, 'ok', `LLM: ${llmProvider}`);
             initMinimax({ provider: llmProvider.toLowerCase() });
         }
         else {
             s.step(0, 4, 'LLM: 未配置', 'warn');
+            loading?.completeStep(0, 'warn', 'LLM: 未配置');
             if (isNonInteractive) {
                 s.warn('未设置任何 LLM API Key，功能受限');
             }
         }
+        loading?.startStep(1, '生成 DIAP 身份...');
         const { keypair, did, name } = await bootstrapIdentity();
         agentIdentity = { did, name, publicKey: Buffer.from(keypair.publicKey).toString('hex') };
+        loading?.completeStep(1, 'ok', `身份 ${name}`);
+        loading?.startStep(2, '发布 DID 到 IPFS...');
         publishDID(name, keypair).then(({ cid, ipnsName }) => {
             if (cid)
                 agentIdentity.cid = cid;
             if (ipnsName)
                 agentIdentity.ipnsName = ipnsName;
-        }).catch(() => { });
+            loading?.completeStep(2, cid ? 'ok' : 'warn', cid ? 'DID 已发布' : 'DID 本地模式');
+        }).catch(() => {
+            loading?.completeStep(2, 'warn', 'DID 本地模式');
+        });
+        loading?.startStep(3, '启动 P2P 网络...');
         const verifier = createVerificationManager();
         let comm = null;
         try {
@@ -1900,7 +1918,9 @@ async function main() {
                         agentIdentity.peerId = connections[0].publicKey;
                         agentIdentity.p2pChannel = 'bolloon-agent-harness';
                     }
+                    loading?.completeStep(3, 'ok', 'P2P 已连接');
                 }).catch(err => {
+                    loading?.completeStep(3, 'warn', 'P2P Web 模式启动失败');
                     s.warn(`P2P Web 模式启动失败: ${err.message}`);
                 });
             }
@@ -1911,23 +1931,30 @@ async function main() {
                     agentIdentity.peerId = connections[0].publicKey;
                     agentIdentity.p2pChannel = 'bolloon-agent-harness';
                 }
+                loading?.completeStep(3, 'ok', 'P2P 已连接');
             }
         }
         catch (err) {
             s.warn(`P2P 初始化失败: ${err.message}`);
             s.warn('将使用无 P2P 模式运行');
+            loading?.completeStep(3, 'error', 'P2P 初始化失败');
         }
+        loading?.startStep(4, '启动 iroh transport...');
         await bootstrapIroh(keypair, name);
+        loading?.completeStep(4, 'ok', 'iroh 已就绪');
         // Bolloon Bootstrap: 启动扫描 + Context 收集 + 挂定时任务
         // 失败静默 (主流程不被阻塞)
+        loading?.startStep(5, '正在 bootstrap bolloon 上下文...');
         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} 个非致命错误)`);
+            loading?.completeStep(5, 'ok', `Bootstrap 完成 (${bs.durationMs}ms)`);
         }
         catch (err) {
             s.warn(`Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+            loading?.completeStep(5, 'warn', 'Bootstrap 失败 (已跳过)');
         }
         s.divider();
         if (mode === 'web') {
@@ -1939,10 +1966,12 @@ async function main() {
                 console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
             }
             const { createWebServer, openBrowser } = await import('./web/server.js');
+            loading?.startStep(6, `启动 Web 服务端口 ${port}...`);
             s.info(`启动 Web 服务端口 ${port}...`);
             // 2026-06-24: CLI 默认 loopback bind (安全), LAN 访问需 BOLLOON_HOST=0.0.0.0
             const bindHost = process.env.BOLLOON_HOST;
             const { port: actualPort } = await createWebServer(port, { selfImprove, ...(bindHost ? { host: bindHost } : {}) });
+            loading?.completeStep(6, 'ok', `Web 服务 :${actualPort}`);
             const displayHost = bindHost ?? '127.0.0.1';
             s.success(`浏览器已打开 → http://${displayHost}:${actualPort}`);
             openBrowser(`http://${displayHost}:${actualPort}`);

package/dist/judgeness/auto-add.js

@@ -0,0 +1,145 @@
+/**
+ * judgeness · auto-add.ts — Channel-based Auto-add (反攻期 O3)
+ *
+ * 用户原话: "传播智能体的时候, 智能体可根据内容频道选择其他用户的 Id 自动添加"
+ *
+ * 流程:
+ *   1. POST /api/hearth/channel-autoadd { channelTopic, sourceChannelOwnerPk? }
+ *   2. 闸 2 (allowlist gate) 校验 sourceChannelOwnerPk
+ *   3. 扫描 ~/.bolloon/judgeness/descriptions/, 找出 scope.topics 含 channelTopic 且 openState='open' 的 description
+ *   4. 对每个 description 的 owner pk 调用 p2p-direct.joinTopic
+ *   5. 全部进 ~/.bolloon/human-values/counterfactual-audit.jsonl
+ *   6. 频次限制 (defense=无; 反攻期 = 每分钟 5 次; 单 peer pk 24h 内最多 10 次)
+ *
+ * 反攻期接 src/network/p2p-direct.ts 的 joinTopic; 防御期 stub.
+ * 反攻期接 src/judgeness/protocol.ts 的 sendAutoaddInvite.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+const DEFENSE_FREQ_LIMIT_PER_HOUR = 5; // 防御期更严
+const ROLLING_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+export async function performAutoAdd(req, opts = {}) {
+    if (!req.channelTopic)
+        throw new Error('channelTopic required');
+    const now = opts.nowMs ?? Date.now();
+    // ---- 频次限制 (读 audit log last hour 统计) ----
+    const auditLog = await readAutoaddAudit();
+    const recent = auditLog.filter((l) => now - l.ts < ROLLING_WINDOW_MS);
+    if (recent.length >= DEFENSE_FREQ_LIMIT_PER_HOUR) {
+        return {
+            channelTopic: req.channelTopic,
+            matched: 0,
+            joined: 0,
+            skipped: 0,
+            auditLines: [],
+            frequencyLimited: true,
+        };
+    }
+    // ---- 扫描 descriptions 找 matches ----
+    const { listDescriptions } = await import('./store.js');
+    const descs = await listDescriptions();
+    const matched = descs.filter((d) => {
+        const open = d.openState === 'open';
+        const topicMatch = (d.scope.topics ?? []).includes(req.channelTopic);
+        return open && topicMatch;
+    });
+    // ---- join (defense=stub) ----
+    const result = {
+        channelTopic: req.channelTopic,
+        matched: matched.length,
+        joined: 0,
+        skipped: 0,
+        auditLines: [],
+        frequencyLimited: false,
+    };
+    // 每次请求都写一条 audit line (不论 matched), 这样 frequency limit 才能工作
+    result.auditLines.push(JSON.stringify({
+        ts: now,
+        kind: 'autoadd_request',
+        channelTopic: req.channelTopic,
+        by: undefined,
+        matched: matched.length,
+    }));
+    for (const d of matched) {
+        const ownerPk = d.byAgentId ?? '__no-pk__';
+        if (!opts.joinTopic) {
+            // defense: 仅 audit, 不调用 joinTopic
+            result.skipped += 1;
+            const line = JSON.stringify({
+                ts: now,
+                kind: 'autoadd_skipped',
+                channelTopic: req.channelTopic,
+                descriptionId: d.descriptionId,
+                ownerPk,
+                reason: 'defense stub',
+            });
+            result.auditLines.push(line);
+            continue;
+        }
+        const r = await opts.joinTopic(req.channelTopic, ownerPk);
+        if (r.ok) {
+            result.joined += 1;
+            result.auditLines.push(JSON.stringify({
+                ts: now,
+                kind: 'autoadd_joined',
+                channelTopic: req.channelTopic,
+                descriptionId: d.descriptionId,
+                ownerPk,
+            }));
+        }
+        else {
+            result.skipped += 1;
+            result.auditLines.push(JSON.stringify({
+                ts: now,
+                kind: 'autoadd_join_failed',
+                channelTopic: req.channelTopic,
+                descriptionId: d.descriptionId,
+                ownerPk,
+            }));
+        }
+    }
+    // ---- 写 audit log ----
+    await appendCounterfactualAudit(result.auditLines);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// audit 读写 helpers
+// ---------------------------------------------------------------------------
+async function readAutoaddAudit() {
+    const auditPath = await auditPathResolved();
+    try {
+        const raw = await fs.readFile(auditPath, 'utf-8');
+        return raw.split('\n').filter(Boolean).map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        }).filter((x) => !!x);
+    }
+    catch {
+        return [];
+    }
+}
+async function appendCounterfactualAudit(lines) {
+    if (lines.length === 0)
+        return;
+    const auditPath = await auditPathResolved();
+    const dir = path.dirname(auditPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.appendFile(auditPath, lines.join('\n') + '\n', 'utf-8');
+}
+let _auditPathCache = null;
+async function auditPathResolved() {
+    if (_auditPathCache)
+        return _auditPathCache;
+    const home = process.env.BOLLOON_HOME || path.join(os.homedir(), '.bolloon');
+    _auditPathCache = path.join(home, 'human-values', 'counterfactual-audit.jsonl');
+    return _auditPathCache;
+}
+// 工具: 复位 cache (测试用)
+export function _resetAuditPathCacheForTest() {
+    _auditPathCache = null;
+}