@bolloon/bolloon-agent 0.2.12 → 0.2.13

package/dist/constraint-runtime/src/tools.js

@@ -1,80 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { executeToolFromSnapshot } from './dynamic-tool-loader.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const SNAPSHOT_PATH = path.join(__dirname, 'reference_data', 'tools_snapshot.json');
-function loadToolSnapshot() {
-    try {
-        if (!fs.existsSync(SNAPSHOT_PATH)) {
-            console.warn(`[tools] Snapshot not found: ${SNAPSHOT_PATH}, using empty list`);
-            return [];
-        }
-        const raw = JSON.parse(fs.readFileSync(SNAPSHOT_PATH, 'utf-8'));
-        return raw.map((e) => ({
-            name: e.name,
-            responsibility: e.responsibility,
-            sourceHint: e.source_hint,
-            status: 'mirrored',
-        }));
-    }
-    catch (error) {
-        console.warn(`[tools] Failed to load snapshot: ${error}, using empty list`);
-        return [];
-    }
-}
-export const PORTED_TOOLS = loadToolSnapshot();
-export function getTool(name) {
-    const needle = name.toLowerCase();
-    return PORTED_TOOLS.find(m => m.name.toLowerCase() === needle);
-}
-export function getTools(simpleMode = false) {
-    let tools = [...PORTED_TOOLS];
-    if (simpleMode) {
-        tools = tools.filter(m => ['BashTool', 'FileReadTool', 'FileEditTool'].includes(m.name));
-    }
-    return tools;
-}
-export function findTools(query, limit = 20) {
-    const needle = query.toLowerCase();
-    return PORTED_TOOLS.filter(m => m.name.toLowerCase().includes(needle) || m.sourceHint.toLowerCase().includes(needle)).slice(0, limit);
-}
-export async function executeTool(name, payload = '') {
-    const module = getTool(name);
-    if (!module) {
-        return { name, sourceHint: '', payload, handled: false, message: `Unknown mirrored tool: ${name}` };
-    }
-    let params = {};
-    try {
-        params = payload ? JSON.parse(payload) : {};
-    }
-    catch {
-        return {
-            name: module.name,
-            sourceHint: module.sourceHint,
-            payload,
-            handled: false,
-            message: `Invalid JSON payload for tool '${module.name}'`,
-        };
-    }
-    const result = await executeToolFromSnapshot(module.sourceHint, params);
-    if (result.success) {
-        return {
-            name: module.name,
-            sourceHint: module.sourceHint,
-            payload: JSON.stringify(result.data),
-            handled: true,
-            message: `Tool '${module.name}' executed successfully`,
-        };
-    }
-    else {
-        return {
-            name: module.name,
-            sourceHint: module.sourceHint,
-            payload,
-            handled: false,
-            message: `Tool '${module.name}' failed: ${result.error}`,
-        };
-    }
-}

package/dist/constraint-runtime/src/transcript.js

@@ -1,19 +0,0 @@
-export class TranscriptStore {
-    entries = [];
-    flushed = false;
-    append(entry) {
-        this.entries.push(entry);
-        this.flushed = false;
-    }
-    compact(keepLast = 10) {
-        if (this.entries.length > keepLast) {
-            this.entries = this.entries.slice(-keepLast);
-        }
-    }
-    replay() {
-        return [...this.entries];
-    }
-    flush() {
-        this.flushed = true;
-    }
-}

package/dist/constraint-runtime/src/types/index.js

@@ -1,12 +0,0 @@
-import { loadArchiveMetadata } from '../_archive_helper.js';
-const SNAPSHOT = loadArchiveMetadata('types');
-export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
-export const MODULE_COUNT = SNAPSHOT['module_count'];
-export const SAMPLE_FILES = SNAPSHOT['sample_files'];
-export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
-export default {
-    ARCHIVE_NAME,
-    MODULE_COUNT,
-    PORTING_NOTE,
-    SAMPLE_FILES,
-};

package/dist/constraint-runtime/src/upstream_proxy/index.js

@@ -1,12 +0,0 @@
-import { loadArchiveMetadata } from '../_archive_helper.js';
-const SNAPSHOT = loadArchiveMetadata('upstream_proxy');
-export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
-export const MODULE_COUNT = SNAPSHOT['module_count'];
-export const SAMPLE_FILES = SNAPSHOT['sample_files'];
-export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
-export default {
-    ARCHIVE_NAME,
-    MODULE_COUNT,
-    PORTING_NOTE,
-    SAMPLE_FILES,
-};

package/dist/constraint-runtime/src/utils/index.js

@@ -1,12 +0,0 @@
-import { loadArchiveMetadata } from '../_archive_helper.js';
-const SNAPSHOT = loadArchiveMetadata('utils');
-export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
-export const MODULE_COUNT = SNAPSHOT['module_count'];
-export const SAMPLE_FILES = SNAPSHOT['sample_files'];
-export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
-export default {
-    ARCHIVE_NAME,
-    MODULE_COUNT,
-    PORTING_NOTE,
-    SAMPLE_FILES,
-};

package/dist/constraint-runtime/src/vim/index.js

@@ -1,12 +0,0 @@
-import { loadArchiveMetadata } from '../_archive_helper.js';
-const SNAPSHOT = loadArchiveMetadata('vim');
-export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
-export const MODULE_COUNT = SNAPSHOT['module_count'];
-export const SAMPLE_FILES = SNAPSHOT['sample_files'];
-export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
-export default {
-    ARCHIVE_NAME,
-    MODULE_COUNT,
-    PORTING_NOTE,
-    SAMPLE_FILES,
-};

package/dist/constraint-runtime/src/voice/index.js

@@ -1,12 +0,0 @@
-import { loadArchiveMetadata } from '../_archive_helper.js';
-const SNAPSHOT = loadArchiveMetadata('voice');
-export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
-export const MODULE_COUNT = SNAPSHOT['module_count'];
-export const SAMPLE_FILES = SNAPSHOT['sample_files'];
-export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
-export default {
-    ARCHIVE_NAME,
-    MODULE_COUNT,
-    PORTING_NOTE,
-    SAMPLE_FILES,
-};

package/dist/constraint-runtime/tests/agent.test.js

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AgentCoordinator } from '../src/agent/coordinator.js';
-describe('AgentCoordinator', () => {
-    it('dispatches parallel tasks', async () => {
-        const coordinator = new AgentCoordinator(2);
-        const results = await coordinator.dispatch('one two three four', 2);
-        expect(results.length).toBe(2);
-        expect(results.every(r => r.success)).toBe(true);
-    });
-    it('aggregates results in order', async () => {
-        const coordinator = new AgentCoordinator(2);
-        const results = await coordinator.dispatch('a b c d', 3);
-        const ids = results.map(r => r.taskId);
-        expect(ids).toEqual(ids.sort());
-    });
-});

package/dist/constraint-runtime/tests/constraint.test.js

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ToolPermissionContext } from '../src/constraint/permission.js';
-import { BudgetTracker } from '../src/constraint/budget.js';
-describe('ToolPermissionContext', () => {
-    it('blocks denied tools by exact name', () => {
-        const ctx = ToolPermissionContext.fromIterables(['BashTool', 'FileEditTool'], []);
-        expect(ctx.blocks('BashTool')).toBe(true);
-        expect(ctx.blocks('FileEditTool')).toBe(true);
-        expect(ctx.blocks('FileReadTool')).toBe(false);
-    });
-    it('blocks tools by prefix', () => {
-        const ctx = ToolPermissionContext.fromIterables([], ['mcp_']);
-        expect(ctx.blocks('mcp_server')).toBe(true);
-        expect(ctx.blocks('mcp_client')).toBe(true);
-        expect(ctx.blocks('bash_tool')).toBe(false);
-    });
-    it('creates permission denial', () => {
-        const ctx = ToolPermissionContext.fromIterables(['BashTool'], []);
-        const denial = ctx.createDenial('BashTool', 'destructive shell execution');
-        expect(denial.toolName).toBe('BashTool');
-        expect(denial.reason).toBe('destructive shell execution');
-    });
-});
-describe('BudgetTracker', () => {
-    it('tracks token usage', () => {
-        const tracker = new BudgetTracker(1000, 8, 12);
-        const usage = tracker.addTurn(100, 50);
-        expect(usage.inputTokens).toBe(100);
-        expect(usage.outputTokens).toBe(50);
-    });
-    it('detects budget exceeded', () => {
-        const tracker = new BudgetTracker(100, 8, 12);
-        expect(tracker.isBudgetExceeded({ inputTokens: 60, outputTokens: 50 })).toBe(true);
-        expect(tracker.isBudgetExceeded({ inputTokens: 30, outputTokens: 30 })).toBe(false);
-    });
-    it('detects turn limit', () => {
-        const tracker = new BudgetTracker(1000, 5, 12);
-        expect(tracker.isTurnLimitExceeded(4)).toBe(false);
-        expect(tracker.isTurnLimitExceeded(5)).toBe(true);
-    });
-});

package/dist/constraint-runtime/tests/skill.test.js

@@ -1,19 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SkillRegistry } from '../src/skills/skill-registry.js';
-describe('SkillRegistry', () => {
-    it('registers and retrieves skills', async () => {
-        const registry = new SkillRegistry();
-        registry.register({
-            name: 'testSkill',
-            description: 'A test skill',
-            execute: async (params) => `executed with ${params.input}`
-        });
-        expect(registry.has('testSkill')).toBe(true);
-        const result = await registry.execute('testSkill', { input: 'hello' });
-        expect(result).toBe('executed with hello');
-    });
-    it('throws on unknown skill', async () => {
-        const registry = new SkillRegistry();
-        await expect(registry.execute('unknown', {})).rejects.toThrow('Skill not found');
-    });
-});

package/dist/constraint-runtime/tests/thinking.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { DeepThinkingEngine } from '../src/thinking/engine.js';
-describe('DeepThinkingEngine', () => {
-    it('performs thinking steps', async () => {
-        const engine = new DeepThinkingEngine(2);
-        const result = await engine.think('test prompt');
-        expect(result.originalPrompt).toBe('test prompt');
-        expect(result.steps.length).toBe(2);
-        expect(result.depth).toBe(2);
-    });
-    it('respects max depth', async () => {
-        const engine = new DeepThinkingEngine(5);
-        const result = await engine.think('deep thought');
-        expect(result.steps.length).toBe(5);
-    });
-    it('allows depth adjustment', async () => {
-        const engine = new DeepThinkingEngine(1);
-        engine.setDepth(3);
-        const result = await engine.think('adjustable');
-        expect(result.steps.length).toBe(3);
-    });
-});

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
-    }
-}