@bolloon/bolloon-agent 0.1.0

package/dist/bollharness-integration/pi-ecosystem-judgment/index.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Pi Judgment Integration for Bolloon
+ *
+ * Core module for capturing, distilling, and applying human judgment.
+ *
+ * Architecture:
+ * Human Input → Distillation Trigger → LLM Extraction → Judgment YAML
+ *                              ↓
+ *                      ValueFunction
+ *                              ↓
+ *                    Runtime Decision
+ *
+ * Storage: Hybrid mode
+ * - High-frequency rules: Embedded in context-fragments/*.md YAML frontmatter
+ * - Long-term preferences: .bolloon/judgments/*.yaml
+ */
+export type JudgmentType = 'rule' | 'preference' | 'trajectory' | 'reward';
+export type JudgmentSource = 'human' | 'agent' | 'collaboration';
+export type DistillationTrigger = 'explicit' | 'implicit' | 'trajectory';
+export interface Judgment {
+    id: string;
+    type: JudgmentType;
+    content: string;
+    source: JudgmentSource;
+    confidence: number;
+    context?: string;
+    createdAt: string;
+    updatedAt: string;
+    evidence?: JudgmentEvidence;
+    metadata?: Record<string, unknown>;
+}
+export interface JudgmentEvidence {
+    trajectory?: TrajectoryPoint[];
+    preference_pair?: PreferencePair[];
+    correction?: Correction;
+}
+export interface TrajectoryPoint {
+    timestamp: string;
+    action: string;
+    outcome: string;
+    approved: boolean;
+}
+export interface PreferencePair {
+    query: string;
+    chosen: string;
+    rejected: string;
+    context?: string;
+}
+export interface Correction {
+    original: string;
+    corrected: string;
+    reason?: string;
+    timestamp: string;
+}
+export interface JudgmentFile {
+    judgments: Judgment[];
+    filePath: string;
+    lastModified: string;
+}
+export interface DistillationRequest {
+    rawInput: string;
+    trigger: DistillationTrigger;
+    context: string;
+    conversationHistory?: string[];
+    agentPrediction?: string;
+}
+export interface ValueFunction {
+    judgments: Judgment[];
+    contextWeights: Record<string, number>;
+    lastUpdated: string;
+}
+/**
+ * Load all judgments from YAML files
+ */
+export declare function loadJudgments(): Promise<Map<string, Judgment[]>>;
+/**
+ * Create a new judgment
+ */
+export declare function createJudgment(params: {
+    type: JudgmentType;
+    content: string;
+    source: JudgmentSource;
+    confidence: number;
+    context?: string;
+    evidence?: JudgmentEvidence;
+}): Promise<Judgment>;
+/**
+ * Update judgment confidence based on feedback
+ */
+export declare function updateJudgmentConfidence(id: string, delta: number, feedbackType: 'approve' | 'reject' | 'correct'): Promise<Judgment | null>;
+/**
+ * Get all judgments
+ */
+export declare function getAllJudgments(): Promise<Judgment[]>;
+/**
+ * Get judgments by type
+ */
+export declare function getJudgmentsByType(type: JudgmentType): Promise<Judgment[]>;
+/**
+ * Get judgments relevant to a context
+ */
+export declare function getJudgmentsForContext(context: string): Promise<Judgment[]>;
+/**
+ * Calculate confidence score for a decision
+ */
+export declare function calculateConfidence(judgments: Judgment[]): number;
+/**
+ * Build ValueFunction from judgments
+ */
+export declare function buildValueFunction(context?: string): Promise<ValueFunction>;
+/**
+ * Get cached ValueFunction
+ */
+export declare function getValueFunction(context?: string): Promise<ValueFunction>;
+/**
+ * Extract judgments from context fragment YAML frontmatter
+ */
+export declare function extractFromFragment(fragmentPath: string): Promise<Judgment[]>;
+/**
+ * Load judgments from all context fragments
+ */
+export declare function loadFragmentJudgments(): Promise<Judgment[]>;
+/**
+ * Get combined judgments (file + fragments)
+ */
+export declare function getCombinedJudgments(): Promise<Judgment[]>;
+/**
+ * Get judgment statistics
+ */
+export declare function getJudgmentStats(): Promise<{
+    total: number;
+    byType: Record<JudgmentType, number>;
+    bySource: Record<JudgmentSource, number>;
+    averageConfidence: number;
+}>;
+/**
+ * Clear judgment cache
+ */
+export declare function clearCache(): void;

package/dist/bollharness-integration/pi-ecosystem-judgment/index.js

@@ -0,0 +1,445 @@
+/**
+ * Pi Judgment Integration for Bolloon
+ *
+ * Core module for capturing, distilling, and applying human judgment.
+ *
+ * Architecture:
+ * Human Input → Distillation Trigger → LLM Extraction → Judgment YAML
+ *                              ↓
+ *                      ValueFunction
+ *                              ↓
+ *                    Runtime Decision
+ *
+ * Storage: Hybrid mode
+ * - High-frequency rules: Embedded in context-fragments/*.md YAML frontmatter
+ * - Long-term preferences: .bolloon/judgments/*.yaml
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const JUDGMENTS_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'judgments');
+const JUDGMENT_FILES = {
+    rules: path.join(JUDGMENTS_DIR, 'rules.yaml'),
+    preferences: path.join(JUDGMENTS_DIR, 'preferences.yaml'),
+    trajectories: path.join(JUDGMENTS_DIR, 'trajectories.yaml'),
+    rewards: path.join(JUDGMENTS_DIR, 'rewards.yaml'),
+};
+let judgmentCache = new Map();
+let valueFunctionCache = null;
+let cacheDirty = true;
+function generateJudgmentId() {
+    return `jdg-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * Load all judgments from YAML files
+ */
+export async function loadJudgments() {
+    const judgments = new Map();
+    await fs.mkdir(JUDGMENTS_DIR, { recursive: true });
+    for (const [type, filePath] of Object.entries(JUDGMENT_FILES)) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const data = parseYaml(content);
+            if (data && Array.isArray(data)) {
+                judgments.set(type, data);
+            }
+            else if (data && 'judgments' in data && Array.isArray(data.judgments)) {
+                judgments.set(type, data.judgments);
+            }
+        }
+        catch {
+            judgments.set(type, []);
+        }
+    }
+    judgmentCache = judgments;
+    cacheDirty = false;
+    return judgments;
+}
+/**
+ * Save judgments to YAML file
+ */
+async function saveJudgments(type, judgments) {
+    await fs.mkdir(JUDGMENTS_DIR, { recursive: true });
+    const filePath = JUDGMENT_FILES[type];
+    if (!filePath)
+        return;
+    const yaml = serializeYaml({ judgments });
+    await fs.writeFile(filePath, yaml, 'utf-8');
+    cacheDirty = true;
+}
+/**
+ * Create a new judgment
+ */
+export async function createJudgment(params) {
+    const judgment = {
+        id: generateJudgmentId(),
+        type: params.type,
+        content: params.content,
+        source: params.source,
+        confidence: params.confidence,
+        context: params.context,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        evidence: params.evidence,
+    };
+    const judgments = await loadJudgments();
+    const typeJudgments = judgments.get(params.type) || [];
+    typeJudgments.push(judgment);
+    judgments.set(params.type, typeJudgments);
+    await saveJudgments(params.type, typeJudgments);
+    console.log(`[Judgment] Created ${judgment.id} (${params.type}): ${params.content.substring(0, 50)}...`);
+    return judgment;
+}
+/**
+ * Update judgment confidence based on feedback
+ */
+export async function updateJudgmentConfidence(id, delta, feedbackType) {
+    const judgments = await loadJudgments();
+    for (const [type, typeJudgments] of judgments.entries()) {
+        const judgment = typeJudgments.find((j) => j.id === id);
+        if (judgment) {
+            let confidenceChange = delta;
+            if (feedbackType === 'approve') {
+                confidenceChange = Math.min(delta, 1 - judgment.confidence);
+            }
+            else if (feedbackType === 'reject') {
+                confidenceChange = -delta;
+            }
+            else if (feedbackType === 'correct') {
+                confidenceChange = delta * 2;
+            }
+            judgment.confidence = Math.max(0, Math.min(1, judgment.confidence + confidenceChange));
+            judgment.updatedAt = new Date().toISOString();
+            await saveJudgments(type, typeJudgments);
+            return judgment;
+        }
+    }
+    return null;
+}
+/**
+ * Get all judgments
+ */
+export async function getAllJudgments() {
+    const judgments = await loadJudgments();
+    const all = [];
+    for (const typeJudgments of judgments.values()) {
+        all.push(...typeJudgments);
+    }
+    return all;
+}
+/**
+ * Get judgments by type
+ */
+export async function getJudgmentsByType(type) {
+    const judgments = await loadJudgments();
+    return judgments.get(type) || [];
+}
+/**
+ * Get judgments relevant to a context
+ */
+export async function getJudgmentsForContext(context) {
+    const all = await getAllJudgments();
+    return all.filter((j) => {
+        if (!j.context)
+            return false;
+        return j.context.toLowerCase().includes(context.toLowerCase());
+    });
+}
+/**
+ * Calculate confidence score for a decision
+ */
+export function calculateConfidence(judgments) {
+    if (judgments.length === 0)
+        return 0.5;
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const j of judgments) {
+        const weight = j.confidence * (j.source === 'human' ? 1.5 : 1.0);
+        weightedSum += weight;
+        totalWeight += weight;
+    }
+    return totalWeight > 0 ? weightedSum / totalWeight : 0.5;
+}
+/**
+ * Build ValueFunction from judgments
+ */
+export async function buildValueFunction(context) {
+    const judgments = context
+        ? await getJudgmentsForContext(context)
+        : await getAllJudgments();
+    const contextWeights = {};
+    const contextCounts = {};
+    for (const j of judgments) {
+        const ctx = j.context || 'general';
+        contextCounts[ctx] = (contextCounts[ctx] || 0) + 1;
+    }
+    for (const [ctx, count] of Object.entries(contextCounts)) {
+        contextWeights[ctx] = count / judgments.length;
+    }
+    return {
+        judgments,
+        contextWeights,
+        lastUpdated: new Date().toISOString(),
+    };
+}
+/**
+ * Get cached ValueFunction
+ */
+export async function getValueFunction(context) {
+    if (!valueFunctionCache || cacheDirty) {
+        valueFunctionCache = await buildValueFunction(context);
+    }
+    return valueFunctionCache;
+}
+/**
+ * Extract judgments from context fragment YAML frontmatter
+ */
+export async function extractFromFragment(fragmentPath) {
+    try {
+        const content = await fs.readFile(fragmentPath, 'utf-8');
+        const frontmatter = extractFrontmatter(content);
+        if (!frontmatter.judgment)
+            return [];
+        const j = frontmatter.judgment;
+        return [{
+                id: generateJudgmentId(),
+                type: j.type || 'rule',
+                content: extractMarkdownContent(content),
+                source: j.source || 'human',
+                confidence: typeof j.confidence === 'number' ? j.confidence : 0.9,
+                context: j.category || path.basename(fragmentPath, '.md'),
+                createdAt: j.last_reviewed || new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { source: 'fragment', fragment: fragmentPath },
+            }];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load judgments from all context fragments
+ */
+export async function loadFragmentJudgments() {
+    const FRAGMENTS_DIR = path.join(process.cwd(), 'src', 'bollharness', 'scripts', 'context-fragments');
+    const fragmentJudgments = [];
+    try {
+        const files = await fs.readdir(FRAGMENTS_DIR);
+        for (const file of files) {
+            if (file.endsWith('.md')) {
+                const judgments = await extractFromFragment(path.join(FRAGMENTS_DIR, file));
+                fragmentJudgments.push(...judgments);
+            }
+        }
+    }
+    catch {
+        // Fragment directory doesn't exist
+    }
+    return fragmentJudgments;
+}
+/**
+ * Get combined judgments (file + fragments)
+ */
+export async function getCombinedJudgments() {
+    const [fileJudgments, fragmentJudgments] = await Promise.all([
+        getAllJudgments(),
+        loadFragmentJudgments(),
+    ]);
+    const seen = new Set();
+    const combined = [];
+    for (const j of fragmentJudgments) {
+        combined.push(j);
+        seen.add(j.context || j.id);
+    }
+    for (const j of fileJudgments) {
+        if (!seen.has(j.context || j.id)) {
+            combined.push(j);
+        }
+    }
+    return combined;
+}
+/**
+ * Simple YAML parser (handles basic judgment format)
+ */
+function parseYaml(content) {
+    try {
+        if (!content.trim())
+            return [];
+        const data = {};
+        const lines = content.split('\n');
+        let inArray = false;
+        let arrayKey = '';
+        const arrayItems = [];
+        for (const line of lines) {
+            if (line.trim().startsWith('judgments:')) {
+                inArray = true;
+                continue;
+            }
+            if (inArray && line.trim().startsWith('-')) {
+                const item = {};
+                let currentKey = '';
+                let currentValue = '';
+                const itemContent = line.trim().substring(1);
+                const kvMatch = itemContent.match(/^(\w+):\s*(.*)/);
+                if (kvMatch) {
+                    currentKey = kvMatch[1];
+                    currentValue = kvMatch[2];
+                    item[currentKey] = parseValue(currentValue);
+                }
+                arrayItems.push(item);
+                continue;
+            }
+            if (inArray) {
+                const kvMatch = line.match(/^(\w+):\s*(.*)/);
+                if (kvMatch) {
+                    const key = kvMatch[1];
+                    const value = parseValue(kvMatch[2]);
+                    data[key] = value;
+                }
+            }
+        }
+        if (arrayItems.length > 0) {
+            data['judgments'] = arrayItems;
+        }
+        return data;
+    }
+    catch {
+        return [];
+    }
+}
+function parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null' || trimmed === 'undefined')
+        return null;
+    if (!isNaN(Number(trimmed)) && trimmed !== '')
+        return Number(trimmed);
+    return trimmed;
+}
+/**
+ * Simple YAML serializer
+ */
+function serializeYaml(data) {
+    const lines = ['# Auto-generated by Pi Judgment System', '# Do not edit manually', ''];
+    if (typeof data === 'object' && data !== null) {
+        lines.push('judgments:');
+        const d = data;
+        const arr = d.judgments;
+        if (Array.isArray(arr)) {
+            for (const item of arr) {
+                lines.push('  - ' + serializeObject(item, 4));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function serializeObject(obj, indent) {
+    if (typeof obj !== 'object' || obj === null) {
+        return String(obj);
+    }
+    const spaces = ' '.repeat(indent);
+    const innerSpace = ' '.repeat(indent + 2);
+    const parts = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            parts.push(`${key}:`);
+            parts.push(serializeObject(value, indent + 2));
+        }
+        else if (Array.isArray(value)) {
+            parts.push(`${key}:`);
+            for (const item of value) {
+                parts.push(`${innerSpace}- ${serializeObject(item, indent + 4)}`);
+            }
+        }
+        else {
+            const strValue = typeof value === 'string' ? `"${value}"` : String(value);
+            parts.push(`${key}: ${strValue}`);
+        }
+    }
+    if (parts.length === 1 && !parts[0].includes(':')) {
+        return parts[0];
+    }
+    return parts.join(`\n${spaces}`);
+}
+/**
+ * Extract YAML frontmatter from markdown
+ */
+function extractFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const frontmatter = {};
+    const lines = match[1].split('\n');
+    let currentKey = '';
+    let currentIndent = 0;
+    for (const line of lines) {
+        const indent = line.search(/\S/);
+        const trimmed = line.trim();
+        if (trimmed.startsWith('judgment:')) {
+            currentKey = 'judgment';
+            frontmatter[currentKey] = {};
+        }
+        else if (trimmed.startsWith('-')) {
+            // Array item
+        }
+        else if (trimmed.includes(':')) {
+            const [key, ...valueParts] = trimmed.split(':');
+            const value = valueParts.join(':').trim();
+            if (currentKey === 'judgment' && indent > 0) {
+                frontmatter[currentKey][key] = parseValue(value);
+            }
+            else {
+                frontmatter[key.trim()] = parseValue(value);
+                currentKey = key.trim();
+            }
+        }
+    }
+    return frontmatter;
+}
+/**
+ * Extract markdown content (after frontmatter)
+ */
+function extractMarkdownContent(content) {
+    const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+    return match ? match[1].trim() : content;
+}
+/**
+ * Get judgment statistics
+ */
+export async function getJudgmentStats() {
+    const judgments = await getAllJudgments();
+    const byType = {
+        rule: 0,
+        preference: 0,
+        trajectory: 0,
+        reward: 0,
+    };
+    const bySource = {
+        human: 0,
+        agent: 0,
+        collaboration: 0,
+    };
+    let totalConfidence = 0;
+    for (const j of judgments) {
+        byType[j.type]++;
+        bySource[j.source]++;
+        totalConfidence += j.confidence;
+    }
+    return {
+        total: judgments.length,
+        byType,
+        bySource,
+        averageConfidence: judgments.length > 0 ? totalConfidence / judgments.length : 0,
+    };
+}
+/**
+ * Clear judgment cache
+ */
+export function clearCache() {
+    valueFunctionCache = null;
+    cacheDirty = true;
+}

package/dist/bollharness-integration/pi-ecosystem-mcp/index.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Pi MCP Adapter Integration for Bolloon
+ *
+ * Bridges MCP (Model Context Protocol) servers with Bolloon's tool system.
+ * Based on the pi-mcp-adapter philosophy: on-demand tool loading with minimal token overhead.
+ *
+ * Key differences from Claude Code MCP:
+ * - White-box design: every schema, parameter, and return value is visible
+ * - Minimal primitives: only read, write, edit, bash under the hood
+ * - No schema validation black boxes - interfaces are simple by design
+ */
+export interface McpServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    serverName: string;
+}
+export interface McpRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface McpResponse {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface McpToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * Discover MCP servers from standard config locations
+ */
+export declare function discoverMcpServers(): Promise<McpServerConfig[]>;
+/**
+ * Initialize the MCP adapter
+ */
+export declare function initializeMcpAdapter(): Promise<void>;
+/**
+ * Register an MCP server configuration
+ */
+export declare function registerServer(config: McpServerConfig): void;
+/**
+ * Register an MCP tool
+ */
+export declare function registerTool(tool: McpTool): void;
+/**
+ * List all available MCP tools
+ */
+export declare function listTools(): McpTool[];
+/**
+ * Check if a tool exists
+ */
+export declare function hasTool(name: string): boolean;
+/**
+ * Get a specific tool
+ */
+export declare function getTool(name: string): McpTool | undefined;
+/**
+ * Get tool call log for debugging
+ */
+export declare function getToolCallLog(): Array<{
+    timestamp: string;
+    tool: string;
+    args: unknown;
+    result: unknown;
+}>;
+/**
+ * Clear tool call log
+ */
+export declare function clearToolCallLog(): void;
+/**
+ * Execute an MCP tool via JSON-RPC protocol
+ */
+export declare function executeTool(name: string, args: Record<string, unknown>): Promise<{
+    success: boolean;
+    content?: unknown[];
+    error?: string;
+}>;
+/**
+ * Start an MCP server process
+ */
+export declare function startServer(serverName: string): Promise<boolean>;
+/**
+ * Stop an MCP server
+ */
+export declare function stopServer(serverName: string): void;
+/**
+ * Discover tools from a server using MCP protocol
+ */
+export declare function discoverTools(serverName: string): Promise<McpTool[]>;
+/**
+ * Create a Tavily search tool (common MCP integration)
+ */
+export declare function createTavilyTool(apiKey: string): McpTool;
+/**
+ * Create an Amap maps tool
+ */
+export declare function createAmapTool(apiKey: string): McpTool;
+/**
+ * Get adapter status
+ */
+export declare function getAdapterStatus(): {
+    initialized: boolean;
+    serverCount: number;
+    toolCount: number;
+    servers: string[];
+    runningServers: string[];
+};
+/**
+ * Event subscription
+ */
+export declare function on(event: 'initialized' | 'toolRegistered', callback: (...args: unknown[]) => void): void;
+export declare function off(event: 'initialized' | 'toolRegistered', callback: (...args: unknown[]) => void): void;