@bolloon/bolloon-agent 0.3.52 → 0.4.0

package/dist/social/ant-colony/AdaptiveHeartbeat.js

@@ -0,0 +1,101 @@
+/**
+ * AdaptiveHeartbeat - 动态心跳策略
+ *
+ * 基于活跃度、信息素密度等因子动态调整心跳间隔
+ */
+import { DEFAULT_ADAPTIVE_CONFIG, } from './types.js';
+export class AdaptiveHeartbeat {
+    config;
+    lastActivityTime = Date.now();
+    activityHistory = [];
+    recentDiscoveries = 0;
+    pheromoneDensity = 0;
+    discoveryBoost = 0;
+    activityTimer = null;
+    constructor(config) {
+        this.config = { ...DEFAULT_ADAPTIVE_CONFIG, ...config };
+        this.startActivityTracking();
+    }
+    /**
+     * 获取下一次心跳的决策
+     */
+    decide() {
+        const now = Date.now();
+        const timeSinceLastActivity = now - this.lastActivityTime;
+        const activityRate = this.calculateActivityRate();
+        const pheromoneFactor = this.pheromoneDensity;
+        const discoveryFactor = this.calculateDiscoveryFactor();
+        const combinedFactor = activityRate * 0.2 +
+            pheromoneFactor * this.config.pheromoneBoostFactor +
+            discoveryFactor * this.config.discoveryBoostFactor;
+        const interval = Math.max(this.config.minInterval, Math.min(this.config.maxInterval, this.config.baseInterval * (1 - combinedFactor * 0.7)));
+        let priority = 'normal';
+        if (discoveryFactor > 0.5 || this.discoveryBoost > 0.6) {
+            priority = 'high';
+        }
+        else if (this.discoveryBoost > 0.8) {
+            priority = 'urgent';
+        }
+        else if (activityRate < this.config.lowActivityThreshold) {
+            priority = 'low';
+        }
+        return {
+            interval: Math.round(interval),
+            shouldExplore: discoveryFactor > 0.3 || pheromoneFactor > 0.5,
+            shouldBroadcast: priority !== 'low' || timeSinceLastActivity > this.config.baseInterval,
+            priorityLevel: priority,
+        };
+    }
+    /**
+     * 记录活跃事件
+     */
+    recordActivity(type) {
+        const now = Date.now();
+        this.lastActivityTime = now;
+        this.activityHistory.push(now);
+        if (type === 'discovery') {
+            this.recentDiscoveries++;
+            this.discoveryBoost = Math.min(1, this.discoveryBoost + 0.2);
+        }
+        this.discoveryBoost = Math.max(0, this.discoveryBoost - 0.05);
+    }
+    /**
+     * 设置信息素密度
+     */
+    setPheromoneDensity(density) {
+        this.pheromoneDensity = Math.max(0, Math.min(1, density));
+    }
+    /**
+     * 获取当前配置
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * 更新配置
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+    calculateActivityRate() {
+        const now = Date.now();
+        const recentActivity = this.activityHistory.filter((t) => now - t < 60000).length;
+        return recentActivity / 60;
+    }
+    calculateDiscoveryFactor() {
+        return Math.min(1, this.recentDiscoveries / 5);
+    }
+    startActivityTracking() {
+        this.activityTimer = setInterval(() => {
+            const cutoff = Date.now() - 5 * 60 * 1000;
+            this.activityHistory = this.activityHistory.filter((t) => t > cutoff);
+            this.recentDiscoveries = Math.max(0, this.recentDiscoveries - 1);
+            this.discoveryBoost = Math.max(0, this.discoveryBoost - 0.1);
+        }, 60000);
+    }
+    shutdown() {
+        if (this.activityTimer) {
+            clearInterval(this.activityTimer);
+        }
+    }
+}

package/dist/social/ant-colony/PheromoneEngine.js

@@ -0,0 +1,227 @@
+/**
+ * PheromoneEngine - 信息素管理引擎
+ *
+ * 模拟蚂蚁的信息素系统，用于引导智能体发现和路由决策
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { PheromoneType, DEFAULT_PHEROMONE_CONFIG, } from './types.js';
+export { PheromoneType };
+const PHEROMONE_DB_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'ant-colony', 'pheromones.json');
+export class PheromoneEngine {
+    trails = new Map();
+    fields = new Map();
+    evaporationTimer = null;
+    saveTimer = null;
+    dirty = false;
+    async initialize() {
+        await fs.mkdir(path.dirname(PHEROMONE_DB_PATH), { recursive: true });
+        await this.load();
+        this.startEvaporation();
+        this.startAutoSave();
+    }
+    startEvaporation() {
+        this.evaporationTimer = setInterval(() => {
+            this.evaporate();
+        }, DEFAULT_PHEROMONE_CONFIG.evaporationInterval);
+    }
+    startAutoSave() {
+        this.saveTimer = setInterval(() => {
+            if (this.dirty) {
+                this.save().catch(console.error);
+                this.dirty = false;
+            }
+        }, 30000);
+    }
+    /**
+     * 放置信息素
+     */
+    async deposit(type, sourceDid, targetDid, strength = 0.5, options) {
+        const key = this.getTrailKey(type, sourceDid, targetDid);
+        const existing = this.trails.get(key);
+        const newStrength = existing
+            ? Math.min(1, existing.strength + strength * 0.3)
+            : Math.min(1, strength);
+        const trail = {
+            id: key,
+            type,
+            sourceDid,
+            targetDid,
+            strength: newStrength,
+            decayRate: DEFAULT_PHEROMONE_CONFIG.decayRate,
+            createdAt: existing?.createdAt || Date.now(),
+            lastUpdate: Date.now(),
+            capability: options?.capability,
+            qualityScore: options?.qualityScore,
+        };
+        this.trails.set(key, trail);
+        this.dirty = true;
+        if (options?.capability) {
+            this.updateField(type, targetDid, options.capability);
+        }
+    }
+    /**
+     * 读取某方向的信息素强度
+     */
+    getStrength(type, targetDid) {
+        let totalStrength = 0;
+        let count = 0;
+        for (const trail of this.trails.values()) {
+            if (trail.type === type && trail.targetDid === targetDid) {
+                totalStrength += trail.strength;
+                count++;
+            }
+        }
+        return count > 0 ? totalStrength / count : 0;
+    }
+    /**
+     * 查询特定能力的最佳节点
+     */
+    queryByCapability(capability, limit = 5) {
+        const field = this.fields.get(capability);
+        if (!field)
+            return [];
+        const candidates = [];
+        for (const trail of this.trails.values()) {
+            if (trail.type === PheromoneType.CAPABILITY &&
+                trail.capability?.includes(capability)) {
+                const score = trail.strength * (trail.qualityScore || 0.5);
+                candidates.push({ did: trail.targetDid, strength: score });
+            }
+        }
+        candidates.sort((a, b) => b.strength - a.strength);
+        return candidates.slice(0, limit).map((c) => c.did);
+    }
+    /**
+     * 获取到达某节点的最佳下一跳
+     */
+    getNextHop(targetDid, excludeDids = []) {
+        let bestHop = null;
+        let bestStrength = 0;
+        for (const trail of this.trails.values()) {
+            if (trail.targetDid === targetDid && trail.strength > bestStrength) {
+                if (!excludeDids.includes(trail.sourceDid)) {
+                    bestHop = trail.sourceDid;
+                    bestStrength = trail.strength;
+                }
+            }
+        }
+        return bestHop;
+    }
+    /**
+     * 获取所有已知节点及其信息素强度
+     */
+    getAllNodeStrengths() {
+        const result = new Map();
+        for (const trail of this.trails.values()) {
+            const current = result.get(trail.targetDid) || 0;
+            result.set(trail.targetDid, Math.max(current, trail.strength));
+        }
+        return result;
+    }
+    /**
+     * 获取信息素统计
+     */
+    getStats() {
+        let totalStrength = 0;
+        for (const trail of this.trails.values()) {
+            totalStrength += trail.strength;
+        }
+        return {
+            totalTrails: this.trails.size,
+            avgStrength: this.trails.size > 0 ? totalStrength / this.trails.size : 0,
+            capabilityCount: this.fields.size,
+        };
+    }
+    getTrailKey(type, source, target) {
+        return `${type}:${source}:${target}`;
+    }
+    updateField(type, targetDid, capability) {
+        if (!capability)
+            return;
+        for (const cap of capability) {
+            let field = this.fields.get(cap);
+            if (!field) {
+                field = {
+                    capability: cap,
+                    avgStrength: 0,
+                    nodeCount: 0,
+                    lastUpdate: Date.now(),
+                };
+                this.fields.set(cap, field);
+            }
+            const trails = Array.from(this.trails.values()).filter((t) => t.type === type && t.capability?.includes(cap));
+            field.avgStrength =
+                trails.reduce((sum, t) => sum + t.strength, 0) / (trails.length || 1);
+            field.nodeCount = new Set(trails.map((t) => t.targetDid)).size;
+            field.lastUpdate = Date.now();
+        }
+    }
+    evaporate() {
+        const now = Date.now();
+        const toDelete = [];
+        for (const [key, trail] of this.trails.entries()) {
+            const ageHours = (now - trail.lastUpdate) / (1000 * 60 * 60);
+            const decayFactor = Math.pow(1 - trail.decayRate, ageHours);
+            trail.strength = trail.strength * decayFactor;
+            if (trail.strength < DEFAULT_PHEROMONE_CONFIG.minStrength ||
+                now - trail.createdAt > DEFAULT_PHEROMONE_CONFIG.maxTrailAge) {
+                toDelete.push(key);
+            }
+            else {
+                trail.lastUpdate = now;
+            }
+        }
+        for (const key of toDelete) {
+            this.trails.delete(key);
+        }
+        if (toDelete.length > 0) {
+            this.dirty = true;
+            this.save().catch(console.error);
+        }
+    }
+    async save() {
+        try {
+            const data = {
+                trails: Array.from(this.trails.values()),
+                fields: Array.from(this.fields.entries()),
+            };
+            await fs.writeFile(PHEROMONE_DB_PATH, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            console.warn('[PheromoneEngine] Save failed:', e);
+        }
+    }
+    async load() {
+        try {
+            const data = await fs.readFile(PHEROMONE_DB_PATH, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.trails.clear();
+            for (const t of parsed.trails || []) {
+                this.trails.set(t.id, t);
+            }
+            this.fields.clear();
+            for (const [cap, field] of parsed.fields || []) {
+                this.fields.set(cap, field);
+            }
+            console.log(`[PheromoneEngine] Loaded ${this.trails.size} trails, ${this.fields.size} fields`);
+        }
+        catch {
+            console.log('[PheromoneEngine] No existing pheromone data, starting fresh');
+        }
+    }
+    shutdown() {
+        if (this.evaporationTimer) {
+            clearInterval(this.evaporationTimer);
+        }
+        if (this.saveTimer) {
+            clearInterval(this.saveTimer);
+        }
+        if (this.dirty) {
+            this.save()
+                .then(() => console.log('[PheromoneEngine] Saved on shutdown'))
+                .catch(console.error);
+        }
+    }
+}
+export const pheromoneEngine = new PheromoneEngine();

package/dist/social/ant-colony/index.js

@@ -0,0 +1,6 @@
+/**
+ * Ant Colony Module - 蚁群心跳系统核心模块
+ */
+export { PheromoneType, DEFAULT_PHEROMONE_CONFIG, DEFAULT_ADAPTIVE_CONFIG, } from './types.js';
+export { PheromoneEngine, pheromoneEngine } from './PheromoneEngine.js';
+export { AdaptiveHeartbeat } from './AdaptiveHeartbeat.js';

package/dist/social/ant-colony/types.js

@@ -0,0 +1,24 @@
+/**
+ * Ant Colony Types - 信息素系统类型定义
+ */
+export var PheromoneType;
+(function (PheromoneType) {
+    PheromoneType["DISCOVERY"] = "discovery";
+    PheromoneType["CAPABILITY"] = "capability";
+})(PheromoneType || (PheromoneType = {}));
+export const DEFAULT_PHEROMONE_CONFIG = {
+    decayRate: 0.05,
+    evaporationInterval: 5 * 60 * 1000,
+    maxTrailAge: 24 * 60 * 60 * 1000,
+    minStrength: 0.05,
+    maxStrength: 1.0,
+};
+export const DEFAULT_ADAPTIVE_CONFIG = {
+    minInterval: 10 * 1000,
+    maxInterval: 120 * 1000,
+    baseInterval: 30 * 1000,
+    lowActivityThreshold: 0.5,
+    highActivityThreshold: 5,
+    pheromoneBoostFactor: 0.3,
+    discoveryBoostFactor: 0.4,
+};

package/dist/storage/trajectory.js

@@ -0,0 +1,101 @@
+/**
+ * trajectory.ts — agent 运行轨迹录制 (2026-08-08)
+ *
+ * 把 bolloon agent 一次运行的完整过程 (用户输入 / 工具步骤 / 思考 / 最终回复)
+ * 沉淀进 DID 目录 (Postgres 式, 以用户 DID 分区) + 镜像到 OrbitDB CID 存储,
+ * 供多设备同步 (DidCatalog WAL 回放) 与去中心化 CID 拉取 (cid_load) 双通道消费。
+ *
+ * 设计:
+ *   - capture: 收集运行事件 (step_start/done/error/thinking/done) 到一个 Trajectory
+ *   - flush:  把轨迹写入 DidCatalog context_os 表 (key = runId, DID 分区),
+ *             并 (可选) 通过 getCIDDatabase() 保存为 type='state' 记录 + share 上链
+ *   - 非致命: OrbitDB 首次拉起较重, 全部 fire-and-forget + 吞错, 不影响 agent 主流程
+ *
+ * 用法 (server / CLI 的 run-end finally 里):
+ *   const t = createTrajectory({ runId, did, agentId });
+ *   t.capture(event);             // 事件流中逐条喂
+ *   await t.flush({ mirrorOrbit: true });
+ */
+import { registryOpen } from './did-catalog.js';
+/** 是否工具步骤事件 */
+function isToolStep(ev) {
+    return ev.type === 'step_done' || ev.type === 'step_error' || (ev.type === 'step_start');
+}
+/**
+ * 创建轨迹录制器。
+ * @param meta.did 用户 DID — 作为目录分区主键 (跨设备绑定)。
+ */
+export function createTrajectory(meta) {
+    const events = [];
+    return {
+        meta: { ...meta, startedAt: meta.startedAt ?? Date.now() },
+        get size() { return events.length; },
+        capture(ev) {
+            if (ev)
+                events.push(ev);
+        },
+        summary() {
+            const m = {};
+            for (const e of events)
+                m[e.type] = (m[e.type] || 0) + 1;
+            return m;
+        },
+        async flush(opts = {}) {
+            const okTools = events.filter((e) => e.type === 'step_done' && e.success !== false && e.tool && e.tool !== 'system');
+            const toolNames = Array.from(new Set(okTools.map((e) => e.tool))).slice(0, 12).join(', ');
+            const failed = events.filter((e) => e.type === 'step_error' || (e.type === 'step_done' && e.success === false));
+            const endedAt = Date.now();
+            const start = meta.startedAt ?? endedAt;
+            const payload = {
+                runId: meta.runId,
+                agentId: meta.agentId,
+                source: meta.source,
+                channelId: meta.channelId,
+                startedAt: start,
+                endedAt,
+                durationMs: endedAt - start,
+                toolCount: okTools.length,
+                failedCount: failed.length,
+                toolNames,
+                summary: events.reduce((acc, e) => {
+                    acc[e.type] = (acc[e.type] || 0) + 1;
+                    return acc;
+                }, {}),
+                events: events.slice(-200).map((e) => ({
+                    type: e.type,
+                    tool: e.tool,
+                    success: e.success,
+                    durationMs: e.durationMs,
+                    output: e.output ? String(e.output).slice(0, 400) : undefined,
+                    error: e.error ? String(e.error).slice(0, 400) : undefined,
+                })),
+            };
+            // 1) 写入 DID 目录 (Postgres 式, 以用户 DID 分区)
+            const cat = await registryOpen(meta.did, opts.home ? { home: opts.home } : {});
+            const key = `run-${meta.runId}`;
+            await cat.upsert('context_os', key, payload);
+            await cat.persist();
+            // 2) 镜像到 OrbitDB (fire-and-forget, 非致命)
+            let orbitCid;
+            if (opts.mirrorOrbit) {
+                try {
+                    const { getCIDDatabase } = await import('../orbitdb/cid-database.js');
+                    const db = getCIDDatabase();
+                    const rec = await db.save({
+                        agentId: meta.agentId || 'bolloon',
+                        type: 'state',
+                        content: payload,
+                        metadata: { runId: meta.runId, did: meta.did, kind: 'trajectory' },
+                    });
+                    orbitCid = rec.id;
+                    try {
+                        await db.share(rec.id);
+                    }
+                    catch { /* 上链失败不致命 */ }
+                }
+                catch { /* OrbitDB 不可用则跳过镜像 */ }
+            }
+            return { catalogKey: key, orbitCid };
+        },
+    };
+}

package/dist/test/ai-judgment-test.js

@@ -0,0 +1,80 @@
+/**
+ * AI + 判断力注入 测试
+ * 验证 AI 调用和价值观注入功能
+ */
+import { createAgentSession } from '../agents/pi-sdk.js';
+import { generateValueInjection } from '../pi-ecosystem-judgment/value-injection.js';
+import { storeHumanJudgment, initializeValueStore, getValueStats } from '../pi-ecosystem-judgment/human-value-store.js';
+async function main() {
+    console.log('╔═══════════════════════════════════════════════════╗');
+    console.log('║     AI + 判断力注入测试                       ║');
+    console.log('╚═══════════════════════════════════════════════════╝');
+    // 1. 初始化
+    console.log('\n[1] 初始化...');
+    await initializeValueStore();
+    console.log('  ✅ 判断力存储就绪');
+    // 2. 存储一些测试判断
+    console.log('\n[2] 存储测试判断...');
+    await storeHumanJudgment({
+        decision: '代码安全性比性能更重要',
+        decision_type: 'approve',
+        reasons: ['防止被攻击', '用户数据保护'],
+        values_derived: [
+            { category: 'safety', value: 'security-first', weight: 0.9 }
+        ],
+        context: {
+            domain: 'code',
+            complexity: 'moderate',
+            stakes: 'high',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: {
+            source: 'explicit',
+            confidence: 0.85,
+            revisable: true
+        }
+    });
+    console.log('  ✅ 判断已存储');
+    // 3. 查看统计
+    console.log('\n[3] 判断力统计...');
+    const stats = await getValueStats();
+    console.log(`  总判断数: ${stats.total_judgments}`);
+    console.log(`  顶级价值观: ${stats.top_values.slice(0, 3).map(v => v.value).join(', ')}`);
+    // 4. 生成价值观注入
+    console.log('\n[4] 生成价值观注入...');
+    const injection = await generateValueInjection('代码安全问题', {
+        mode: 'standard',
+        maxTokens: 400,
+        includeExamples: true,
+        includeRules: true
+    });
+    console.log(`  注入内容长度: ${injection.length} 字符`);
+    if (injection) {
+        console.log('  ✅ 价值观注入已生成');
+    }
+    // 5. 调用 AI
+    console.log('\n[5] 调用 AI...');
+    const session = await createAgentSession({ cwd: process.cwd() });
+    const prompt = injection
+        ? `${injection}
+
+---
+【当前问题】
+用户问：如何确保 API 接口的安全性？
+
+请基于上面的价值观回复用户。`
+        : '用户问：如何确保 API 接口的安全性？请给出建议。';
+    console.log('\n[6] 发送请求到 AI...');
+    const response = await session.prompt(prompt);
+    console.log('\n═══════════════════════════════════════════════════════');
+    console.log('  AI 回复:');
+    console.log('═══════════════════════════════════════════════════════');
+    console.log(response);
+    console.log('═══════════════════════════════════════════════════════\n');
+    console.log('✅ 测试完成！');
+}
+main().catch(e => {
+    console.error('❌ 测试失败:', e);
+    process.exit(1);
+});