@bolloon/bolloon-agent 0.1.1 → 0.1.3

package/dist/pi-ecosystem/index.js

@@ -0,0 +1,233 @@
+/**
+ * Pi Ecosystem Integration for Bolloon
+ *
+ * Main entry point for Pi ecosystem packages integration.
+ *
+ * Installed packages:
+ * - oh-pi: Configuration management (API keys, model selection, extensions)
+ * - pi-mcp-adapter: MCP protocol bridge for tools
+ * - pi-goals: Persistent goal tracking and workflow orchestration
+ * - pi-subagents: Lightweight subagents based on tmux
+ * - pi-ecosystem-colony: Ant colony multi-agent collaboration
+ *
+ * Design philosophy:
+ * - Minimal primitives (read/write/edit/bash)
+ * - No Plan Mode - direct execution
+ * - No permission popups - use safe-guard extensions
+ * - No built-in todos - use pi-goals
+ * - White-box design - everything visible
+ *
+ * Token efficiency:
+ * - Claude Code: 5k-8k token/request overhead
+ * - Pi ecosystem: ~800 token/request
+ * - Result: 80-90% token cost savings
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Re-export all modules with correct paths
+export { initializeMcpAdapter, discoverMcpServers, registerServer, registerTool, listTools, hasTool, getTool, executeTool, getToolCallLog, clearToolCallLog, startServer, stopServer, discoverTools, createTavilyTool, createAmapTool, getAdapterStatus, on as onMcpEvent, off as offMcpEvent, } from '../pi-ecosystem-mcp/index.js';
+export { createGoal, createGoalQueue, getCurrentGoal, startCurrentGoal, completeCurrentGoal, failCurrentGoal, cutoffCurrentGoal, pauseCurrentGoal, checkBudget, getGoalStats, getQueueSummary, loadGoals, clearGoals, compactQueue, loadTemplates, createFromTemplate, nudgeCurrentGoal, } from '../pi-ecosystem-goals/index.js';
+export { createSubagent, startSubagent, delegateTask, getSubagent, listSubagents, listRunningSubagents, terminateSubagent, getStats as getSubagentStats, parallelDelegate, splitTask, } from '../pi-ecosystem-subagents/index.js';
+export { registerAnt, antScouting, antWorking, antReviewing, antComplete, antFail, antAbort, antTick, createTask, dispatchTask, recordResult, getAnt, listAnts, listAntsByRole, listAntsBySignal, getActiveAnts, getTask, listTasks, getSignalHistory, getColonyStatus, getColonyDump, persistColony, loadColony, onColonyEvent, offColonyEvent, } from '../pi-ecosystem-colony/index.js';
+// Judgment exports
+export { createJudgment, updateJudgmentConfidence, getAllJudgments, getJudgmentsByType, getJudgmentsForContext, getCombinedJudgments, calculateConfidence, buildValueFunction, getValueFunction, getJudgmentStats, loadFragmentJudgments, clearCache, } from '../pi-ecosystem-judgment/index.js';
+// Distillation exports
+export { initializeDistillation, detectTrigger, detectCorrection, isJudgmentSignal, addToTrajectory, detectTrajectoryPattern, distillInput, processFeedback, getTrajectoryStats, clearTrajectory, } from '../pi-ecosystem-judgment/distillation.js';
+// Decision exports
+export { setConfidenceThreshold, getConfidenceThreshold, setDefaultDecisionLevel, getDefaultDecisionLevel, evaluateDecision, submitDecisionResponse, isDecisionResponse, parseDecisionResponse, queryInternalAgents, processHumanFeedback, getPendingDecisions, getDecisionRequest, getDecisionStats, onDecisionEvent, offDecisionEvent, } from '../pi-ecosystem-judgment/decision.js';
+const PI_ECOSYSTEM_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'pi-ecosystem');
+const CONFIG_FILE = path.join(PI_ECOSYSTEM_DIR, 'config.json');
+/**
+ * Default Pi ecosystem configuration (mirrors oh-pi)
+ */
+const DEFAULT_CONFIG = {
+    model: process.env.MINIMAX_MODEL || 'MiniMax-M2.7',
+    extensions: [
+        'safe-guard',
+        'git-guard',
+        'auto-session',
+        'custom-footer',
+        'context7',
+        'web-search',
+        'git-workflow',
+    ],
+    templates: [
+        '/review',
+        '/fix',
+        '/commit',
+        '/test',
+        '/plan',
+        '/debug',
+        '/refactor',
+        '/docs',
+        '/search',
+        '/colony',
+    ],
+};
+/**
+ * Initialize the Pi ecosystem (mirrors oh-pi setup)
+ */
+export async function initializePiEcosystem(config) {
+    await fs.mkdir(PI_ECOSYSTEM_DIR, { recursive: true });
+    let currentConfig = DEFAULT_CONFIG;
+    try {
+        const existing = await fs.readFile(CONFIG_FILE, 'utf-8');
+        currentConfig = { ...DEFAULT_CONFIG, ...JSON.parse(existing) };
+    }
+    catch {
+        // No existing config
+    }
+    if (config) {
+        currentConfig = { ...currentConfig, ...config };
+    }
+    currentConfig.initializedAt = new Date().toISOString();
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(currentConfig, null, 2));
+    console.log('[PiEcosystem] Initialized with config:', JSON.stringify(currentConfig, null, 2));
+    return currentConfig;
+}
+/**
+ * Load Pi ecosystem configuration
+ */
+export async function loadPiConfig() {
+    try {
+        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if Pi ecosystem is initialized
+ */
+export async function isPiEcosystemInitialized() {
+    try {
+        await fs.access(CONFIG_FILE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get combined Pi ecosystem status
+ */
+export async function getPiEcosystemStatus() {
+    const { getAdapterStatus } = await import('../pi-ecosystem-mcp/index.js');
+    const { getGoalStats } = await import('../pi-ecosystem-goals/index.js');
+    const { getStats } = await import('../pi-ecosystem-subagents/index.js');
+    const { getColonyStatus } = await import('../pi-ecosystem-colony/index.js');
+    const config = await loadPiConfig();
+    const mcpStatus = getAdapterStatus();
+    const goalStats = getGoalStats();
+    const subagentStats = getStats();
+    const colonyStatus = getColonyStatus();
+    return {
+        initialized: !!config?.initializedAt,
+        mcp: mcpStatus,
+        goals: goalStats,
+        subagents: subagentStats,
+        colony: colonyStatus,
+    };
+}
+/**
+ * Unified Pi ecosystem CLI-like interface
+ */
+export class PiEcosystem {
+    initialized = false;
+    async initialize(config) {
+        if (this.initialized)
+            return;
+        const [mcp, goals, subagents, colony] = await Promise.all([
+            import('../pi-ecosystem-mcp/index.js'),
+            import('../pi-ecosystem-goals/index.js'),
+            import('../pi-ecosystem-subagents/index.js'),
+            import('../pi-ecosystem-colony/index.js'),
+        ]);
+        await mcp.initializeMcpAdapter();
+        await goals.loadGoals();
+        await subagents.loadSubagents();
+        await colony.loadColony();
+        await initializePiEcosystem(config);
+        this.initialized = true;
+        console.log('[PiEcosystem] Initialization complete');
+    }
+    async getStatus() {
+        return getPiEcosystemStatus();
+    }
+    async addMcpTool(config) {
+        const mcp = await import('../pi-ecosystem-mcp/index.js');
+        mcp.registerServer(config);
+    }
+    async listMcpTools() {
+        const mcp = await import('../pi-ecosystem-mcp/index.js');
+        return mcp.listTools().map(t => t.name);
+    }
+    async createGoal(objective, budget) {
+        const goals = await import('../pi-ecosystem-goals/index.js');
+        const goal = await goals.createGoal(objective, budget);
+        return goal.id;
+    }
+    async createGoalQueue(objectives) {
+        const goals = await import('../pi-ecosystem-goals/index.js');
+        const goalList = await goals.createGoalQueue(objectives);
+        return goalList.map(g => g.id);
+    }
+    async getCurrentGoal() {
+        const goals = await import('../pi-ecosystem-goals/index.js');
+        const goal = goals.getCurrentGoal();
+        return goal?.id || null;
+    }
+    async advanceGoal(result) {
+        const goals = await import('../pi-ecosystem-goals/index.js');
+        if (result) {
+            await goals.completeCurrentGoal(result);
+        }
+        else {
+            await goals.completeCurrentGoal();
+        }
+    }
+    async delegateTask(task, command) {
+        const subagents = await import('../pi-ecosystem-subagents/index.js');
+        const result = await subagents.delegateTask(task, command);
+        return result.subagentId;
+    }
+    async listSubagents() {
+        const subagents = await import('../pi-ecosystem-subagents/index.js');
+        return subagents.listSubagents().map(s => s.id);
+    }
+    async registerAnt(name, role) {
+        const colony = await import('../pi-ecosystem-colony/index.js');
+        const ant = colony.registerAnt(name, role);
+        return ant.id;
+    }
+    async createColonyTask(description) {
+        const colony = await import('../pi-ecosystem-colony/index.js');
+        const task = colony.createTask(description);
+        return task.id;
+    }
+    async dispatchToColony(taskId, antIds) {
+        const colony = await import('../pi-ecosystem-colony/index.js');
+        colony.dispatchTask(taskId, antIds);
+    }
+    async persist() {
+        const colony = await import('../pi-ecosystem-colony/index.js');
+        await colony.persistColony();
+    }
+    async shutdown() {
+        await this.persist();
+        console.log('[PiEcosystem] Shutdown complete');
+    }
+}
+let piEcosystemInstance = null;
+export function getPiEcosystem() {
+    if (!piEcosystemInstance) {
+        piEcosystemInstance = new PiEcosystem();
+    }
+    return piEcosystemInstance;
+}
+export async function ohMyPi(config) {
+    const ecosystem = getPiEcosystem();
+    await ecosystem.initialize(config);
+    return ecosystem;
+}

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Pi Ant Colony Integration for Bolloon
  *
@@ -13,75 +12,16 @@
  * - Per-ant turn limits, cost tracking, concurrent scheduling
  * - White-box design: no "what is it doing in the background" anxiety
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerAnt = registerAnt;
-exports.antScouting = antScouting;
-exports.antWorking = antWorking;
-exports.antReviewing = antReviewing;
-exports.antComplete = antComplete;
-exports.antFail = antFail;
-exports.antAbort = antAbort;
-exports.antTick = antTick;
-exports.createTask = createTask;
-exports.dispatchTask = dispatchTask;
-exports.recordResult = recordResult;
-exports.getAnt = getAnt;
-exports.listAnts = listAnts;
-exports.listAntsByRole = listAntsByRole;
-exports.listAntsBySignal = listAntsBySignal;
-exports.getActiveAnts = getActiveAnts;
-exports.getTask = getTask;
-exports.listTasks = listTasks;
-exports.getSignalHistory = getSignalHistory;
-exports.getColonyStatus = getColonyStatus;
-exports.onColonyEvent = onColonyEvent;
-exports.offColonyEvent = offColonyEvent;
-exports.getColonyDump = getColonyDump;
-exports.persistColony = persistColony;
-exports.loadColony = loadColony;
-const events_1 = require("events");
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
+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 events_1.EventEmitter {
+class ColonyEventEmitter extends EventEmitter {
 }
 const colonyEvents = new ColonyEventEmitter();
 /**
@@ -93,7 +33,7 @@ function generateAntId() {
 /**
  * Register a new ant in the colony
  */
-function registerAnt(name, role, maxTurns = 10, tokenBudget = 50000) {
+export function registerAnt(name, role, maxTurns = 10, tokenBudget = 50000) {
     const id = generateAntId();
     const ant = {
         id,
@@ -140,7 +80,7 @@ function emitSignal(antId, newSignal, details) {
 /**
  * Transition ant to SCOUTING
  */
-function antScouting(antId, task) {
+export function antScouting(antId, task) {
     const ant = ants.get(antId);
     if (!ant)
         return;
@@ -151,7 +91,7 @@ function antScouting(antId, task) {
 /**
  * Transition ant to WORKING
  */
-function antWorking(antId) {
+export function antWorking(antId) {
     const ant = ants.get(antId);
     if (!ant)
         return;
@@ -160,13 +100,13 @@ function antWorking(antId) {
 /**
  * Transition ant to REVIEWING
  */
-function antReviewing(antId) {
+export function antReviewing(antId) {
     emitSignal(antId, 'REVIEWING');
 }
 /**
  * Complete ant work
  */
-function antComplete(antId, result) {
+export function antComplete(antId, result) {
     const ant = ants.get(antId);
     if (!ant)
         return;
@@ -177,7 +117,7 @@ function antComplete(antId, result) {
 /**
  * Fail ant work
  */
-function antFail(antId, error) {
+export function antFail(antId, error) {
     const ant = ants.get(antId);
     if (!ant)
         return;
@@ -188,13 +128,13 @@ function antFail(antId, error) {
 /**
  * Abort ant work
  */
-function antAbort(antId, reason) {
+export function antAbort(antId, reason) {
     emitSignal(antId, 'ABORTED', reason);
 }
 /**
  * Increment turn count
  */
-function antTick(antId, tokensUsed = 0) {
+export function antTick(antId, tokensUsed = 0) {
     const ant = ants.get(antId);
     if (!ant)
         return;
@@ -213,7 +153,7 @@ function antTick(antId, tokensUsed = 0) {
 /**
  * Create a colony task
  */
-function createTask(description) {
+export function createTask(description) {
     const id = `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
     const task = {
         id,
@@ -230,7 +170,7 @@ function createTask(description) {
 /**
  * Dispatch task to ants
  */
-function dispatchTask(taskId, antIds) {
+export function dispatchTask(taskId, antIds) {
     const task = tasks.get(taskId);
     if (!task)
         return;
@@ -248,7 +188,7 @@ function dispatchTask(taskId, antIds) {
 /**
  * Record ant result for a task
  */
-function recordResult(taskId, antId, result) {
+export function recordResult(taskId, antId, result) {
     const task = tasks.get(taskId);
     if (!task)
         return;
@@ -266,55 +206,55 @@ function recordResult(taskId, antId, result) {
 /**
  * Get ant by ID
  */
-function getAnt(antId) {
+export function getAnt(antId) {
     return ants.get(antId);
 }
 /**
  * List all ants
  */
-function listAnts() {
+export function listAnts() {
     return Array.from(ants.values());
 }
 /**
  * List ants by role
  */
-function listAntsByRole(role) {
+export function listAntsByRole(role) {
     return Array.from(ants.values()).filter((a) => a.role === role);
 }
 /**
  * Get ants by signal state
  */
-function listAntsBySignal(signal) {
+export function listAntsBySignal(signal) {
     return Array.from(ants.values()).filter((a) => a.signal === signal);
 }
 /**
  * Get active ants (not complete/failed/aborted)
  */
-function getActiveAnts() {
+export function getActiveAnts() {
     return Array.from(ants.values()).filter((a) => !['COMPLETE', 'FAILED', 'ABORTED'].includes(a.signal));
 }
 /**
  * Get task by ID
  */
-function getTask(taskId) {
+export function getTask(taskId) {
     return tasks.get(taskId);
 }
 /**
  * List all tasks
  */
-function listTasks() {
+export function listTasks() {
     return Array.from(tasks.values());
 }
 /**
  * Get signal history
  */
-function getSignalHistory() {
+export function getSignalHistory() {
     return [...signalHistory];
 }
 /**
  * Get colony status
  */
-function getColonyStatus() {
+export function getColonyStatus() {
     const antList = Array.from(ants.values());
     const taskList = Array.from(tasks.values());
     const signalDistribution = {
@@ -340,19 +280,19 @@ function getColonyStatus() {
 /**
  * Subscribe to colony events
  */
-function onColonyEvent(event, callback) {
+export function onColonyEvent(event, callback) {
     colonyEvents.on(event, callback);
 }
 /**
  * Unsubscribe from colony events
  */
-function offColonyEvent(event, callback) {
+export function offColonyEvent(event, callback) {
     colonyEvents.off(event, callback);
 }
 /**
  * Get formatted colony dump for debugging
  */
-function getColonyDump() {
+export function getColonyDump() {
     const status = getColonyStatus();
     const active = getActiveAnts();
     let dump = '# Colony Status\n\n';
@@ -381,7 +321,7 @@ function getColonyDump() {
 /**
  * Persist colony state
  */
-async function persistColony() {
+export async function persistColony() {
     try {
         await fs.mkdir(STATE_DIR, { recursive: true });
         const state = {
@@ -403,7 +343,7 @@ async function persistColony() {
 /**
  * Load colony state
  */
-async function loadColony() {
+export async function loadColony() {
     try {
         const data = await fs.readFile(path.join(STATE_DIR, 'colony.json'), 'utf-8');
         const state = JSON.parse(data);
@@ -423,4 +363,3 @@ async function loadColony() {
         // No persisted state
     }
 }
-//# sourceMappingURL=index.js.map