@bolloon/bolloon-agent 0.3.44 → 0.3.45

package/bin/bolloon.js

@@ -1,157 +0,0 @@
-#!/usr/bin/env node
-const path = require("path");
-const { spawn } = require("child_process");
-const fs = require("fs");
-
-const RESET = "\x1b[0m";
-const BOLD = "\x1b[1m";
-const CYAN = "\x1b[36m";
-const GREEN = "\x1b[32m";
-const MAGENTA = "\x1b[35m";
-
-function log(msg, color) {
-  console.log((color || RESET) + msg + RESET);
-}
-
-function printBanner() {
-  console.log("\n" + CYAN + BOLD + [
-    "   ╔═══════════════════════════════════════════╗",
-    "   ║      🤖 Bolloon Agent                     ║",
-    "   ║      P2P AI Document Processor            ║",
-    "   ╚═══════════════════════════════════════════╝"
-  ].join("\n") + RESET + "\n");
-}
-
-function getMainEntry() {
-  const distDir = path.dirname(require.main.filename);
-  const distIndex = path.join(distDir, "index.js");
-  if (fs.existsSync(distIndex)) {
-    return distIndex;
-  }
-  return path.join(process.cwd(), "src", "index.ts");
-}
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    return { mode: "gui", args: [] };
-  }
-  const first = args[0];
-  switch (first) {
-    case "-v":
-    case "--version":
-      return { mode: "version", args: [] };
-    case "-h":
-    case "--help":
-      return { mode: "help", args: [] };
-    case "-g":
-    case "--gui":
-      return { mode: "gui", args: args.slice(1) };
-    case "-w":
-    case "--web":
-      return { mode: "web", args: args.slice(1) };
-    case "-c":
-    case "--cli":
-      return { mode: "cli", args: args.slice(1) };
-    default:
-      return { mode: "passthrough", args };
-  }
-}
-
-async function startElectron(additionalArgs) {
-  try {
-    const electron = require("electron");
-    const distDir = path.dirname(require.main.filename);
-    let mainPath = path.join(distDir, "electron.js");
-    if (!fs.existsSync(mainPath)) {
-      mainPath = path.join(process.cwd(), "src", "electron.ts");
-    }
-    log("启动 Electron...", CYAN);
-    const child = spawn(electron, [mainPath, ...additionalArgs], {
-      stdio: "inherit",
-      env: { ...process.env, NODE_ENV: "development" }
-    });
-    child.on("error", (err) => {
-      log("Electron 启动失败: " + err.message, MAGENTA);
-      process.exit(1);
-    });
-    child.on("exit", (code) => process.exit(code || 0));
-  } catch (err) {
-    log("Electron 不可用，切换到 Web 模式...", CYAN);
-    await startWebServer(additionalArgs);
-  }
-}
-
-async function startWebServer(additionalArgs) {
-  const mainPath = getMainEntry();
-  const webArgs = ["--web", ...additionalArgs];
-  log("启动 Web 服务...", CYAN);
-  const child = spawn(process.execPath, [mainPath, ...webArgs], { stdio: "inherit" });
-  child.on("error", (err) => {
-    log("Web 服务启动失败: " + err.message, MAGENTA);
-    process.exit(1);
-  });
-  child.on("exit", (code) => process.exit(code || 0));
-}
-
-async function startCLI(additionalArgs) {
-  const mainPath = getMainEntry();
-  log("启动命令行界面...", CYAN);
-  const child = spawn(process.execPath, [mainPath, ...additionalArgs], { stdio: "inherit" });
-  child.on("error", (err) => {
-    log("CLI 启动失败: " + err.message, MAGENTA);
-    process.exit(1);
-  });
-  child.on("exit", (code) => process.exit(code || 0));
-}
-
-async function main() {
-  const { mode, args } = parseArgs();
-  switch (mode) {
-    case "version":
-      console.log("Bolloon Agent v0.1.1");
-      break;
-    case "help":
-      printBanner();
-      console.log(BOLD + "用法:" + RESET + "  bolloon [选项] [命令] [参数]");
-      console.log(BOLD + "选项:" + RESET + "  --gui, -g           启动图形界面");
-      console.log("         --web, -w           启动 Web UI");
-      console.log("         --cli, -c           启动命令行界面");
-      console.log("         --version, -v       显示版本");
-      console.log("         --help, -h          显示帮助");
-      console.log(BOLD + "示例:" + RESET + "  bolloon              # 启动图形界面");
-      console.log("         bolloon --web        # 启动 Web UI");
-      console.log("         bolloon --read file  # 读取文档");
-      break;
-    case "gui":
-      printBanner();
-      await startElectron(args);
-      break;
-    case "web":
-      printBanner();
-      await startWebServer(args);
-      break;
-    case "cli":
-      await startCLI(args);
-      break;
-    case "passthrough":
-      const mainPath = getMainEntry();
-      const child = spawn(process.execPath, [mainPath, ...args], { stdio: "inherit" });
-      child.on("error", (err) => {
-        log("执行失败: " + err.message, MAGENTA);
-        process.exit(1);
-      });
-      child.on("exit", (code) => process.exit(code || 0));
-      break;
-    default:
-      log("未知模式: " + mode, MAGENTA);
-      printBanner();
-      console.log("输入 --help 查看帮助");
-      process.exit(1);
-  }
-}
-
-main().catch((err) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});

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/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);
-        }
-    }
-}