@bolloon/bolloon-agent 0.1.38 → 0.1.39

package/dist/constraints/commands.js

@@ -1,100 +0,0 @@
-export const PORTED_COMMANDS = [
-    {
-        name: 'read',
-        responsibility: 'Read and display file contents',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'summarize',
-        responsibility: 'Summarize conversation or context',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'improve',
-        responsibility: 'Improve code or text quality',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'broadcast',
-        responsibility: 'Broadcast message to multiple targets',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'send',
-        responsibility: 'Send message to a specific target',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'peers',
-        responsibility: 'List connected peers',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'identity',
-        responsibility: 'Display current identity information',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'logs',
-        responsibility: 'Retrieve and display logs',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'tools',
-        responsibility: 'List available tools',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-    {
-        name: 'search',
-        responsibility: 'Search across files or content',
-        sourceHint: 'bolloon built-in',
-        status: 'mirrored',
-    },
-];
-export function getCommand(name) {
-    const needle = name.toLowerCase();
-    for (const entry of PORTED_COMMANDS) {
-        if (entry.name.toLowerCase() === needle) {
-            return entry;
-        }
-    }
-    return null;
-}
-export function getCommands() {
-    return [...PORTED_COMMANDS];
-}
-export function findCommands(query, limit = 20) {
-    const needle = query.toLowerCase();
-    const matches = PORTED_COMMANDS.filter((entry) => entry.name.toLowerCase().includes(needle) ||
-        entry.sourceHint.toLowerCase().includes(needle));
-    return matches.slice(0, limit);
-}
-export function executeCommand(name, prompt = '') {
-    const entry = getCommand(name);
-    if (entry === null) {
-        return {
-            name,
-            sourceHint: '',
-            prompt,
-            handled: false,
-            message: `Unknown mirrored command: ${name}`,
-        };
-    }
-    const action = `Mirrored command '${entry.name}' from ${entry.sourceHint} would handle prompt ${JSON.stringify(prompt)}.`;
-    return {
-        name: entry.name,
-        sourceHint: entry.sourceHint,
-        prompt,
-        handled: true,
-        message: action,
-    };
-}

package/dist/constraints/permissions.js

@@ -1,37 +0,0 @@
-export class ToolPermissionContext {
-    denyNames;
-    denyPrefixes;
-    constructor(denyNames = new Set(), denyPrefixes = []) {
-        this.denyNames = denyNames;
-        this.denyPrefixes = denyPrefixes;
-    }
-    static fromIterables(denyNames, denyPrefixes) {
-        return new ToolPermissionContext(new Set(denyNames
-            ? Array.from(denyNames).map((n) => n.toLowerCase())
-            : []), denyPrefixes
-            ? Array.from(denyPrefixes).map((p) => p.toLowerCase())
-            : []);
-    }
-    blocks(toolName) {
-        const lowered = toolName.toLowerCase();
-        return (this.denyNames.has(lowered) ||
-            this.denyPrefixes.some((prefix) => lowered.startsWith(prefix)));
-    }
-    withDenial(name, reason) {
-        const newDenyNames = new Set(this.denyNames);
-        newDenyNames.add(name.toLowerCase());
-        return {
-            context: new ToolPermissionContext(newDenyNames, this.denyPrefixes),
-            denial: { toolName: name, reason },
-        };
-    }
-}
-export function checkPermission(context, toolName, reason) {
-    if (context.blocks(toolName)) {
-        return {
-            allowed: false,
-            denialReason: { toolName, reason },
-        };
-    }
-    return { allowed: true };
-}

package/dist/constraints/runtime.js

@@ -1,135 +0,0 @@
-import { getCommands } from './commands';
-import { getTools, executeTool } from './tools';
-import { executeCommand } from './commands';
-import { ToolPermissionContext } from './permissions';
-import { buildSystemInitMessage } from './system-init';
-export class ConstraintRuntime {
-    permissionContext;
-    constructor(permissionContext) {
-        this.permissionContext = permissionContext || new ToolPermissionContext();
-    }
-    routePrompt(prompt, limit = 5) {
-        const tokens = new Set(prompt
-            .replace(/\//g, ' ')
-            .replace(/-/g, ' ')
-            .split(/\s+/)
-            .map((t) => t.toLowerCase())
-            .filter((t) => t.length > 0));
-        const commandMatches = this.scoreMatches(tokens, getCommands(), 'command');
-        const toolMatches = this.scoreMatches(tokens, getTools(), 'tool');
-        const selected = [];
-        if (commandMatches.length > 0) {
-            selected.push(commandMatches[0]);
-        }
-        if (toolMatches.length > 0) {
-            selected.push(toolMatches[0]);
-        }
-        const leftovers = [...commandMatches, ...toolMatches]
-            .filter((m) => !selected.some((s) => s.name === m.name))
-            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
-        selected.push(...leftovers.slice(0, Math.max(0, limit - selected.length)));
-        return selected.slice(0, limit);
-    }
-    scoreMatches(tokens, entries, kind) {
-        const matches = [];
-        for (const entry of entries) {
-            const haystacks = [entry.name.toLowerCase(), entry.sourceHint.toLowerCase()];
-            let score = 0;
-            for (const token of tokens) {
-                if (haystacks.some((h) => h.includes(token))) {
-                    score += 1;
-                }
-            }
-            if (score > 0) {
-                matches.push({
-                    kind,
-                    name: entry.name,
-                    sourceHint: entry.sourceHint,
-                    score,
-                });
-            }
-        }
-        return matches.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
-    }
-    bootstrapSession(prompt, limit = 5, trusted = true) {
-        const sessionId = crypto.randomUUID();
-        const matches = this.routePrompt(prompt, limit);
-        const commandExecs = [];
-        const toolExecs = [];
-        const denials = [];
-        for (const match of matches) {
-            if (match.kind === 'command') {
-                const result = executeCommand(match.name, prompt);
-                if (result.handled) {
-                    commandExecs.push(result.message);
-                }
-            }
-            else if (match.kind === 'tool') {
-                if (this.permissionContext.blocks(match.name)) {
-                    denials.push({
-                        toolName: match.name,
-                        reason: 'permission denied by context',
-                    });
-                }
-                else {
-                    const result = executeTool(match.name, '');
-                    if (result.handled) {
-                        toolExecs.push(result.message);
-                    }
-                }
-            }
-        }
-        return {
-            sessionId,
-            prompt,
-            trusted,
-            systemInitMessage: buildSystemInitMessage(trusted),
-            routedMatches: matches,
-            commandExecutionMessages: commandExecs,
-            toolExecutionMessages: toolExecs,
-            permissionDenials: denials,
-        };
-    }
-    runTurnLoop(prompt, limit = 5, maxTurns = 3) {
-        const results = [];
-        let currentPrompt = prompt;
-        for (let turn = 0; turn < maxTurns; turn++) {
-            const turnPrompt = turn === 0 ? currentPrompt : `${currentPrompt} [turn ${turn + 1}]`;
-            const matches = this.routePrompt(turnPrompt, limit);
-            const commandNames = matches
-                .filter((m) => m.kind === 'command')
-                .map((m) => m.name);
-            const toolNames = matches
-                .filter((m) => m.kind === 'tool')
-                .map((m) => m.name);
-            const outputLines = [
-                `Turn ${turn + 1}`,
-                `Prompt: ${turnPrompt}`,
-                `Matched commands: ${commandNames.join(', ') || 'none'}`,
-                `Matched tools: ${toolNames.join(', ') || 'none'}`,
-            ];
-            const output = outputLines.join('\n');
-            const inputTokens = turnPrompt.split(/\s+/).length;
-            const outputTokens = output.split(/\s+/).length;
-            results.push({
-                output,
-                matchedCommands: commandNames,
-                matchedTools: toolNames,
-                permissionDenials: [],
-                stopReason: 'completed',
-                usage: { inputTokens, outputTokens },
-            });
-            if (turn < maxTurns - 1) {
-                currentPrompt = turnPrompt;
-            }
-        }
-        return results;
-    }
-    setPermissionContext(context) {
-        this.permissionContext = context;
-    }
-    getPermissionContext() {
-        return this.permissionContext;
-    }
-}
-export const defaultRuntime = new ConstraintRuntime();

package/dist/constraints/session.js

@@ -1,48 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-const DEFAULT_SESSION_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
-export async function saveSession(session, directory) {
-    const targetDir = directory || DEFAULT_SESSION_DIR;
-    await fs.mkdir(targetDir, { recursive: true });
-    const filePath = path.join(targetDir, `${session.sessionId}.json`);
-    await fs.writeFile(filePath, JSON.stringify(session, null, 2));
-    return filePath;
-}
-export async function loadSession(sessionId, directory) {
-    const targetDir = directory || DEFAULT_SESSION_DIR;
-    const data = await fs.readFile(path.join(targetDir, `${sessionId}.json`), 'utf-8');
-    return JSON.parse(data);
-}
-export async function listSessions(directory) {
-    const targetDir = directory || DEFAULT_SESSION_DIR;
-    try {
-        const files = await fs.readdir(targetDir);
-        const sessions = [];
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                try {
-                    const data = await fs.readFile(path.join(targetDir, file), 'utf-8');
-                    sessions.push(JSON.parse(data));
-                }
-                catch {
-                    // Skip invalid session files
-                }
-            }
-        }
-        return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-    }
-    catch {
-        return [];
-    }
-}
-export async function deleteSession(sessionId, directory) {
-    const targetDir = directory || DEFAULT_SESSION_DIR;
-    const filePath = path.join(targetDir, `${sessionId}.json`);
-    try {
-        await fs.unlink(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/constraints/system-init.js

@@ -1,51 +0,0 @@
-import { getCommands } from './commands';
-import { getTools } from './tools';
-const STARTUP_STEPS = [
-    { name: 'start top-level prefetch side effects', description: 'Initiate background prefetch operations' },
-    { name: 'build workspace context', description: 'Construct workspace context for agent operations' },
-    { name: 'load mirrored command snapshot', description: 'Load command definitions from snapshot' },
-    { name: 'load mirrored tool snapshot', description: 'Load tool definitions from snapshot' },
-    { name: 'prepare parity audit hooks', description: 'Set up parity audit instrumentation' },
-    { name: 'apply trust-gated deferred init', description: 'Execute deferred initialization based on trust level' },
-];
-function buildWorkspaceSetup(trusted, context) {
-    return {
-        trusted,
-        builtInCommandCount: getBuiltInCommandNames().size,
-        loadedCommandCount: getCommands().length,
-        loadedToolCount: getTools().length,
-        startupSteps: STARTUP_STEPS,
-        permissionContext: context?.permissionContext,
-        currentTime: new Date().toISOString(),
-    };
-}
-function getBuiltInCommandNames() {
-    const commands = getCommands();
-    return new Set(commands.map((c) => c.name));
-}
-export function buildSystemInitMessage(trusted, context) {
-    const setup = buildWorkspaceSetup(trusted, context);
-    const commands = getCommands();
-    const tools = getTools();
-    const lines = [
-        '# System Init',
-        '',
-        `Trusted: ${setup.trusted}`,
-        `Built-in command names: ${setup.builtInCommandCount}`,
-        `Loaded command entries: ${commands.length}`,
-        `Loaded tool entries: ${tools.length}`,
-        '',
-        '## Available Commands',
-        ...commands.map((cmd) => `- ${cmd.name}: ${cmd.responsibility}`),
-        '',
-        '## Available Tools',
-        ...tools.map((tool) => `- ${tool.name}: ${tool.responsibility}`),
-        '',
-        '## Startup Steps',
-        ...setup.startupSteps.map((step) => `- ${step.name}`),
-        '',
-        `Current Time: ${setup.currentTime}`,
-    ];
-    return lines.join('\n');
-}
-export { STARTUP_STEPS };

package/dist/constraints/tools.js

@@ -1,104 +0,0 @@
-const PORTED_TOOLS_DATA = [
-    {
-        name: 'read_document',
-        responsibility: 'Read content from a document or file',
-        sourceHint: 'bolloon/documents/reader.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'summarize_document',
-        responsibility: 'Generate a summary of a document',
-        sourceHint: 'bolloon/documents/summarizer.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'improve_document',
-        responsibility: 'Improve the quality of a document',
-        sourceHint: 'bolloon/documents/improver.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'list_peers',
-        responsibility: 'List all connected peers in the network',
-        sourceHint: 'bolloon/network/p2p.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'send_message',
-        responsibility: 'Send a direct message to a peer',
-        sourceHint: 'bolloon/network/messaging.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'broadcast_message',
-        responsibility: 'Broadcast a message to all connected peers',
-        sourceHint: 'bolloon/network/messaging.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'get_identity',
-        responsibility: 'Get the identity information of the current node',
-        sourceHint: 'bolloon/agents/protocol.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'get_operation_logs',
-        responsibility: 'Retrieve operation logs for the current session',
-        sourceHint: 'bolloon/agents/protocol.ts',
-        status: 'mirrored',
-    },
-    {
-        name: 'search_files',
-        responsibility: 'Search for files matching a query pattern',
-        sourceHint: 'bolloon/documents/search.ts',
-        status: 'mirrored',
-    },
-];
-export const PORTED_TOOLS = PORTED_TOOLS_DATA;
-export function getTool(name) {
-    const needle = name.toLowerCase();
-    for (const tool of PORTED_TOOLS) {
-        if (tool.name.toLowerCase() === needle) {
-            return tool;
-        }
-    }
-    return null;
-}
-export function getTools() {
-    return [...PORTED_TOOLS];
-}
-export function findTools(query, limit = 20) {
-    const needle = query.toLowerCase();
-    const matches = PORTED_TOOLS.filter((tool) => tool.name.toLowerCase().includes(needle) ||
-        tool.sourceHint.toLowerCase().includes(needle));
-    return matches.slice(0, limit);
-}
-export function executeTool(name, payload = '') {
-    const tool = getTool(name);
-    if (tool === null) {
-        return {
-            name,
-            sourceHint: '',
-            payload,
-            handled: false,
-            message: `Unknown mirrored tool: ${name}`,
-        };
-    }
-    const message = `Mirrored tool '${tool.name}' from ${tool.sourceHint} would handle payload ${JSON.stringify(payload)}.`;
-    return {
-        name: tool.name,
-        sourceHint: tool.sourceHint,
-        payload,
-        handled: true,
-        message,
-    };
-}
-export function filterToolsByPermissionContext(tools, permissionContext) {
-    if (permissionContext === null) {
-        return [...tools];
-    }
-    return tools.filter((tool) => !permissionContext.blocks(tool.name));
-}
-export function toolNames() {
-    return PORTED_TOOLS.map((tool) => tool.name);
-}

package/dist/llm/minimax-provider.js

@@ -1,46 +0,0 @@
-export class MinimaxProvider {
-    apiKey;
-    baseUrl = 'https://api.minimax.chat/v1';
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async chat(options) {
-        const response = await fetch(`${this.baseUrl}/text/chatcompletion_v2`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`
-            },
-            body: JSON.stringify(options)
-        });
-        if (!response.ok) {
-            throw new Error(`Minimax API error: ${response.status}`);
-        }
-        return response.json();
-    }
-    async chatPro(options) {
-        const response = await fetch(`${this.baseUrl}/text/chatcompletion_pro`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`
-            },
-            body: JSON.stringify(options)
-        });
-        if (!response.ok) {
-            throw new Error(`Minimax API error: ${response.status}`);
-        }
-        return response.json();
-    }
-}
-let providerInstance = null;
-export function initMinimaxProvider(apiKey) {
-    providerInstance = new MinimaxProvider(apiKey);
-    return providerInstance;
-}
-export function getMinimaxProvider() {
-    if (!providerInstance) {
-        throw new Error('Minimax provider not initialized. Call initMinimaxProvider first.');
-    }
-    return providerInstance;
-}

package/dist/llm/minimax.js

@@ -1,45 +0,0 @@
-import { initPiAI, getModel, isModelAvailable } from './pi-ai.js';
-export class MinimaxLLM {
-    model;
-    constructor(config) {
-        this.model = initPiAI({
-            provider: config.provider,
-            apiKey: config.apiKey,
-            baseUrl: config.baseUrl,
-            model: config.model
-        });
-    }
-    async chat(message, context) {
-        return this.model.chat(message, context);
-    }
-    async summarize(text, context) {
-        return this.model.summarize(text, context);
-    }
-    async improveContent(content, requirements, context) {
-        return this.model.improveContent(content, requirements, context);
-    }
-    estimateQuality(original, summary) {
-        return this.model.estimateQuality(original, summary);
-    }
-    async shouldAutoSend(qualityScore, threshold = 0.7) {
-        return this.model.shouldAutoSend(qualityScore, threshold);
-    }
-}
-export { initPiAI, getModel, isModelAvailable } from './pi-ai.js';
-let minimaxInstance = null;
-export function initMinimax(config) {
-    minimaxInstance = new MinimaxLLM(config);
-    return minimaxInstance;
-}
-export function getMinimax() {
-    if (!minimaxInstance) {
-        if (isModelAvailable()) {
-            const piModel = getModel();
-            minimaxInstance = new MinimaxLLM({});
-            minimaxInstance.model = piModel;
-            return minimaxInstance;
-        }
-        throw new Error('Minimax not initialized. Call initMinimax first.');
-    }
-    return minimaxInstance;
-}