@bolloon/bolloon-agent 0.1.38 → 0.1.40

package/dist/pi-ecosystem-colony/index.js

@@ -1,365 +0,0 @@
-/**
- * Pi Ant Colony Integration for Bolloon
- *
- * Multi-agent collaboration system with white-box signal protocol.
- * Based on oh-pi's ant colony system: COLONY_SIGNAL protocol for agent coordination.
- *
- * Signal Protocol:
- * COLONY_SIGNAL:LAUNCHED → SCOUTING → WORKING → REVIEWING → COMPLETE
- *
- * Key features:
- * - Fully visible signal protocol (no black boxes)
- * - Per-ant turn limits, cost tracking, concurrent scheduling
- * - White-box design: no "what is it doing in the background" anxiety
- */
-import { EventEmitter } from 'events';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-// Colony state
-const ants = new Map();
-const tasks = new Map();
-const signalHistory = [];
-const STATE_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'colony');
-// Event emitter
-class ColonyEventEmitter extends EventEmitter {
-}
-const colonyEvents = new ColonyEventEmitter();
-/**
- * Generate a unique ant ID
- */
-function generateAntId() {
-    return `ant-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-}
-/**
- * Register a new ant in the colony
- */
-export function registerAnt(name, role, maxTurns = 10, tokenBudget = 50000) {
-    const id = generateAntId();
-    const ant = {
-        id,
-        name,
-        role,
-        signal: 'LAUNCHED',
-        turnCount: 0,
-        maxTurns,
-        tokenBudget,
-        tokensUsed: 0,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    };
-    ants.set(id, ant);
-    emitSignal(id, 'LAUNCHED');
-    console.log(`[Colony] Registered ant: ${name} (${role})`);
-    return ant;
-}
-/**
- * Emit a signal transition
- */
-function emitSignal(antId, newSignal, details) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    const event = {
-        antId,
-        antName: ant.name,
-        fromSignal: ant.signal,
-        toSignal: newSignal,
-        timestamp: new Date().toISOString(),
-        details,
-    };
-    signalHistory.push(event);
-    if (signalHistory.length > 100) {
-        signalHistory.shift();
-    }
-    ant.signal = newSignal;
-    ant.updatedAt = new Date().toISOString();
-    ants.set(antId, ant);
-    colonyEvents.emit('signal', event);
-    console.log(`[Colony] ${ant.name}: ${event.fromSignal} → ${event.toSignal}${details ? ` (${details})` : ''}`);
-}
-/**
- * Transition ant to SCOUTING
- */
-export function antScouting(antId, task) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    ant.task = task;
-    ants.set(antId, ant);
-    emitSignal(antId, 'SCOUTING', `Task: ${task.substring(0, 50)}...`);
-}
-/**
- * Transition ant to WORKING
- */
-export function antWorking(antId) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    emitSignal(antId, 'WORKING');
-}
-/**
- * Transition ant to REVIEWING
- */
-export function antReviewing(antId) {
-    emitSignal(antId, 'REVIEWING');
-}
-/**
- * Complete ant work
- */
-export function antComplete(antId, result) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    ant.result = result;
-    ants.set(antId, ant);
-    emitSignal(antId, 'COMPLETE', `Result: ${result.substring(0, 50)}...`);
-}
-/**
- * Fail ant work
- */
-export function antFail(antId, error) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    ant.result = error;
-    ants.set(antId, ant);
-    emitSignal(antId, 'FAILED', error);
-}
-/**
- * Abort ant work
- */
-export function antAbort(antId, reason) {
-    emitSignal(antId, 'ABORTED', reason);
-}
-/**
- * Increment turn count
- */
-export function antTick(antId, tokensUsed = 0) {
-    const ant = ants.get(antId);
-    if (!ant)
-        return;
-    ant.turnCount++;
-    ant.tokensUsed += tokensUsed;
-    ant.updatedAt = new Date().toISOString();
-    ants.set(antId, ant);
-    // Check if exceeded limits
-    if (ant.turnCount >= ant.maxTurns) {
-        antAbort(antId, 'Max turns exceeded');
-    }
-    else if (ant.tokensUsed >= ant.tokenBudget) {
-        antAbort(antId, 'Token budget exceeded');
-    }
-}
-/**
- * Create a colony task
- */
-export function createTask(description) {
-    const id = `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-    const task = {
-        id,
-        description,
-        status: 'pending',
-        assignedAnts: [],
-        results: new Map(),
-        createdAt: new Date().toISOString(),
-    };
-    tasks.set(id, task);
-    console.log(`[Colony] Created task: ${id} - ${description.substring(0, 50)}...`);
-    return task;
-}
-/**
- * Dispatch task to ants
- */
-export function dispatchTask(taskId, antIds) {
-    const task = tasks.get(taskId);
-    if (!task)
-        return;
-    task.status = 'dispatched';
-    task.assignedAnts = antIds;
-    tasks.set(taskId, task);
-    for (const antId of antIds) {
-        const ant = ants.get(antId);
-        if (ant) {
-            antScouting(antId, task.description);
-        }
-    }
-    console.log(`[Colony] Dispatched task ${taskId} to ${antIds.length} ants`);
-}
-/**
- * Record ant result for a task
- */
-export function recordResult(taskId, antId, result) {
-    const task = tasks.get(taskId);
-    if (!task)
-        return;
-    task.results.set(antId, result);
-    // Check if all ants completed
-    if (task.results.size === task.assignedAnts.length) {
-        task.status = 'completed';
-        task.completedAt = new Date().toISOString();
-        for (const id of task.assignedAnts) {
-            antReviewing(id);
-        }
-    }
-    tasks.set(taskId, task);
-}
-/**
- * Get ant by ID
- */
-export function getAnt(antId) {
-    return ants.get(antId);
-}
-/**
- * List all ants
- */
-export function listAnts() {
-    return Array.from(ants.values());
-}
-/**
- * List ants by role
- */
-export function listAntsByRole(role) {
-    return Array.from(ants.values()).filter((a) => a.role === role);
-}
-/**
- * Get ants by signal state
- */
-export function listAntsBySignal(signal) {
-    return Array.from(ants.values()).filter((a) => a.signal === signal);
-}
-/**
- * Get active ants (not complete/failed/aborted)
- */
-export function getActiveAnts() {
-    return Array.from(ants.values()).filter((a) => !['COMPLETE', 'FAILED', 'ABORTED'].includes(a.signal));
-}
-/**
- * Get task by ID
- */
-export function getTask(taskId) {
-    return tasks.get(taskId);
-}
-/**
- * List all tasks
- */
-export function listTasks() {
-    return Array.from(tasks.values());
-}
-/**
- * Get signal history
- */
-export function getSignalHistory() {
-    return [...signalHistory];
-}
-/**
- * Get colony status
- */
-export function getColonyStatus() {
-    const antList = Array.from(ants.values());
-    const taskList = Array.from(tasks.values());
-    const signalDistribution = {
-        LAUNCHED: 0,
-        SCOUTING: 0,
-        WORKING: 0,
-        REVIEWING: 0,
-        COMPLETE: 0,
-        FAILED: 0,
-        ABORTED: 0,
-    };
-    for (const ant of antList) {
-        signalDistribution[ant.signal]++;
-    }
-    return {
-        antCount: antList.length,
-        activeAnts: antList.filter((a) => !['COMPLETE', 'FAILED', 'ABORTED'].includes(a.signal)).length,
-        taskCount: taskList.length,
-        activeTasks: taskList.filter((t) => t.status === 'in_progress' || t.status === 'dispatched').length,
-        signalDistribution,
-    };
-}
-/**
- * Subscribe to colony events
- */
-export function onColonyEvent(event, callback) {
-    colonyEvents.on(event, callback);
-}
-/**
- * Unsubscribe from colony events
- */
-export function offColonyEvent(event, callback) {
-    colonyEvents.off(event, callback);
-}
-/**
- * Get formatted colony dump for debugging
- */
-export function getColonyDump() {
-    const status = getColonyStatus();
-    const active = getActiveAnts();
-    let dump = '# Colony Status\n\n';
-    dump += `Ants: ${status.antCount} total, ${status.activeAnts} active\n`;
-    dump += `Tasks: ${status.taskCount} total, ${status.activeTasks} active\n\n`;
-    dump += '## Signal Distribution\n';
-    for (const [signal, count] of Object.entries(status.signalDistribution)) {
-        if (count > 0) {
-            dump += `- ${signal}: ${count}\n`;
-        }
-    }
-    dump += '\n## Active Ants\n';
-    for (const ant of active) {
-        dump += `- ${ant.name} (${ant.role}): ${ant.signal} [${ant.turnCount}/${ant.maxTurns} turns, ${ant.tokensUsed}/${ant.tokenBudget} tokens]\n`;
-        if (ant.task) {
-            dump += `  Task: ${ant.task.substring(0, 60)}...\n`;
-        }
-    }
-    dump += '\n## Recent Signals\n';
-    const recent = signalHistory.slice(-10);
-    for (const event of recent.reverse()) {
-        dump += `- ${event.timestamp}: ${event.antName}: ${event.fromSignal} → ${event.toSignal}\n`;
-    }
-    return dump;
-}
-/**
- * Persist colony state
- */
-export async function persistColony() {
-    try {
-        await fs.mkdir(STATE_DIR, { recursive: true });
-        const state = {
-            ants: Array.from(ants.values()),
-            tasks: Array.from(tasks.entries()).map(([id, t]) => ({
-                ...t,
-                results: Array.from(t.results.entries()),
-            })),
-            signalHistory: signalHistory.slice(-50),
-            persistedAt: new Date().toISOString(),
-        };
-        await fs.writeFile(path.join(STATE_DIR, 'colony.json'), JSON.stringify(state, null, 2));
-        console.log('[Colony] Persisted state');
-    }
-    catch (e) {
-        console.warn('[Colony] Failed to persist:', e);
-    }
-}
-/**
- * Load colony state
- */
-export async function loadColony() {
-    try {
-        const data = await fs.readFile(path.join(STATE_DIR, 'colony.json'), 'utf-8');
-        const state = JSON.parse(data);
-        ants.clear();
-        for (const a of state.ants) {
-            ants.set(a.id, a);
-        }
-        tasks.clear();
-        for (const t of state.tasks) {
-            tasks.set(t.id, { ...t, results: new Map(t.results) });
-        }
-        signalHistory.length = 0;
-        signalHistory.push(...state.signalHistory);
-        console.log(`[Colony] Loaded ${ants.size} ants, ${tasks.size} tasks`);
-    }
-    catch {
-        // No persisted state
-    }
-}

package/dist/runtime/context/minimax-prompt.js

@@ -1,178 +0,0 @@
-import { initMinimaxProvider } from '../../llm/minimax-provider.js';
-export class MinimaxLLM {
-    provider;
-    model;
-    constructor(config, provider) {
-        this.provider = provider;
-        this.model = config.model || 'MiniMax-M2.7';
-    }
-    buildSystemPrompt(context) {
-        const envDetails = this.getEnvironmentDetails();
-        return `你是一个友好的AI助手，正在与用户对话。
-
-## 用户工作目录
-${context || process.cwd()}
-
-## 环境信息
-${envDetails}`;
-    }
-    getEnvironmentDetails() {
-        const workflows = [
-            'read - 读取文档',
-            'summarize - 总结文档',
-            'improve - 改进文档',
-            'collaborate - 多智能体协作',
-            'query - 查询状态',
-            'report - 生成报告'
-        ];
-        const capabilities = [
-            '文档处理 (Markdown, Text, PDF, DOCX)',
-            '多智能体协作 (P2P 网络)',
-            '工作流引擎 (约束层检查)',
-            '质量评估与自动发送'
-        ];
-        return `
-## 可用工作流
-${workflows.map(w => `- ${w}`).join('\n')}
-
-## 系统能力
-${capabilities.map(c => `- ${c}`).join('\n')}
-
-## 当前时间
-${new Date().toISOString()}`;
-    }
-    async chat(message, context) {
-        const systemPrompt = this.buildSystemPrompt(context);
-        try {
-            const data = await this.provider.chat({
-                model: this.model,
-                messages: [
-                    { role: 'system', content: systemPrompt },
-                    { role: 'user', content: message, sender_name: 'user', sender_type: 'USER' }
-                ],
-                temperature: 0.8
-            });
-            if (data.base_resp?.status_msg) {
-                console.error('Minimax API error:', data.base_resp.status_msg);
-                return { reply: `AI服务暂时不可用: ${data.base_resp.status_msg}` };
-            }
-            const reply = data.choices?.[0]?.message?.content || '抱歉，我没有收到回复。';
-            return { reply };
-        }
-        catch (error) {
-            console.error('Minimax chat error:', error);
-            return { reply: '抱歉，AI服务暂时不可用。' };
-        }
-    }
-    async summarize(text, context) {
-        const prompt = this.buildSummarizePrompt(text, context);
-        try {
-            const data = await this.provider.chat({
-                model: this.model,
-                messages: [
-                    { role: 'system', content: 'You are a professional document summarizer.' },
-                    { role: 'user', content: prompt, sender_name: 'user', sender_type: 'USER' }
-                ],
-                temperature: 0.7
-            });
-            if (data.base_resp?.status_msg) {
-                console.error('Minimax API error:', data.base_resp.status_msg);
-                return { summary: `API错误: ${data.base_resp.status_msg}`, qualityScore: 0 };
-            }
-            const content = data.choices?.[0]?.message?.content || '';
-            const qualityScore = this.estimateQuality(text, content);
-            return { summary: content, qualityScore };
-        }
-        catch (error) {
-            console.error('Minimax API error:', error);
-            return {
-                summary: text.substring(0, 500) + '...',
-                qualityScore: 0.5
-            };
-        }
-    }
-    buildSummarizePrompt(text, context) {
-        const maxLength = 8000;
-        const truncatedText = text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
-        let prompt = `请为以下文档生成简洁准确的摘要：
-
-${truncatedText}
-
-请按以下格式输出：
-## 摘要
-[在此处撰写摘要]
-
-## 质量自评
-[评分 1-10，说明理由]`;
-        if (context) {
-            prompt = `背景信息：${context}
-
-${prompt}`;
-        }
-        return prompt;
-    }
-    estimateQuality(original, summary) {
-        const coverageRatio = summary.length / Math.max(original.length, 1);
-        const hasKeyPoints = /\d+\s*[.。]/.test(summary);
-        const decentLength = summary.length > 100 && summary.length < original.length * 0.5;
-        let score = 0.5;
-        if (coverageRatio > 0.1 && coverageRatio < 0.5)
-            score += 0.2;
-        if (hasKeyPoints)
-            score += 0.15;
-        if (decentLength)
-            score += 0.15;
-        return Math.min(1, score);
-    }
-    async improveContent(content, requirements, context) {
-        const prompt = this.buildImprovePrompt(content, requirements, context);
-        try {
-            const data = await this.provider.chatPro({
-                model: this.model,
-                messages: [
-                    { role: 'system', content: 'You are a professional document editor and improver.' },
-                    { role: 'user', content: prompt }
-                ],
-                temperature: 0.8
-            });
-            return data.choices?.[0]?.message?.content || content;
-        }
-        catch (error) {
-            console.error('Minimax improve error:', error);
-            return content;
-        }
-    }
-    buildImprovePrompt(content, requirements, context) {
-        const maxLength = 8000;
-        const truncatedContent = content.length > maxLength ? content.substring(0, maxLength) + '...' : content;
-        let prompt = `请根据以下要求改进文档：
-
-要求：${requirements}
-
-原始文档：
-${truncatedContent}
-
-请直接输出改进后的文档，不要添加额外说明。`;
-        if (context) {
-            prompt = `背景信息：${context}
-
-${prompt}`;
-        }
-        return prompt;
-    }
-    async shouldAutoSend(qualityScore, threshold = 0.7) {
-        return qualityScore >= threshold;
-    }
-}
-let minimaxInstance = null;
-export function initMinimax(config) {
-    const provider = initMinimaxProvider(config.apiKey);
-    minimaxInstance = new MinimaxLLM(config, provider);
-    return minimaxInstance;
-}
-export function getMinimax() {
-    if (!minimaxInstance) {
-        throw new Error('Minimax not initialized. Call initMinimax first.');
-    }
-    return minimaxInstance;
-}

package/dist/runtime/context/sys-prompt.js

@@ -1 +0,0 @@
-export { PiAIModel as MinimaxLLM, initPiAI, getModel, isModelAvailable, getMinimax, initMinimax } from '../../llm/pi-ai.js';

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

@@ -1,101 +0,0 @@
-/**
- * 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);
-        }
-    }
-}