@bolloon/bolloon-agent 0.1.0

package/dist/bollharness-integration/bollharness-integration/integration.js

@@ -0,0 +1,420 @@
+/**
+ * Bollharness Integration for Bolloon
+ *
+ * Main integration class that combines:
+ * - Gate State Machine (8-gate workflow governance)
+ * - Guard Checker (code quality checks)
+ * - Context Router (automatic context injection)
+ * - Skill Adapter (bollharness skills in Bolloon)
+ */
+import { GateStateMachine } from './gate-state-machine.js';
+import { GuardChecker, runGuards } from './guard-checker.js';
+import { ContextRouter } from './context-router.js';
+import { createSkillAdapter } from './skill-adapter.js';
+/**
+ * Main integration class
+ */
+export class BollharnessIntegration {
+    config;
+    gateMachine;
+    guardChecker;
+    contextRouter;
+    skillAdapter;
+    sessionArchives = [];
+    currentSessionId = '';
+    constructor(config = {}) {
+        this.config = {
+            enabled: config.enabled ?? true,
+            guardsEnabled: config.guardsEnabled ?? true,
+            contextEnabled: config.contextEnabled ?? true,
+            skillsEnabled: config.skillsEnabled ?? true,
+            gatesEnabled: config.gatesEnabled ?? true,
+        };
+        this.gateMachine = new GateStateMachine();
+        this.guardChecker = new GuardChecker();
+        this.contextRouter = new ContextRouter();
+        this.skillAdapter = createSkillAdapter();
+    }
+    /**
+     * Process a file edit with all enabled checks
+     */
+    async processFileEdit(filePath) {
+        const errors = [];
+        let guards;
+        let context;
+        // Run guards if enabled
+        if (this.config.guardsEnabled) {
+            try {
+                guards = await runGuards(filePath);
+                if (!guards.passed) {
+                    errors.push(...guards.findings.map(f => f.message));
+                }
+            }
+            catch (error) {
+                errors.push(`Guard check failed: ${error}`);
+            }
+        }
+        // Get context fragments if enabled
+        if (this.config.contextEnabled) {
+            try {
+                context = this.contextRouter.match(filePath);
+            }
+            catch (error) {
+                errors.push(`Context routing failed: ${error}`);
+            }
+        }
+        return {
+            success: errors.length === 0,
+            guards,
+            context,
+            errors,
+        };
+    }
+    /**
+     * Check file before edit (pre-check)
+     */
+    async preEditCheck(filePath) {
+        const errors = [];
+        let guards;
+        if (this.config.guardsEnabled) {
+            try {
+                guards = await runGuards(filePath);
+                if (!guards.passed && guards.blockingCount > 0) {
+                    errors.push(...guards.findings
+                        .filter(f => f.blocking)
+                        .map(f => `BLOCKING: ${f.message}`));
+                }
+            }
+            catch (error) {
+                errors.push(`Pre-check failed: ${error}`);
+            }
+        }
+        return {
+            success: errors.length === 0,
+            guards,
+            errors,
+        };
+    }
+    /**
+     * Get context for a file
+     */
+    getContext(filePath) {
+        if (!this.config.contextEnabled) {
+            return '';
+        }
+        return this.contextRouter.getContext(filePath);
+    }
+    /**
+     * Get fragments for a file
+     */
+    getFragments(filePath) {
+        return this.contextRouter.match(filePath);
+    }
+    // ==================== Gate Methods ====================
+    /**
+     * Get current gate state
+     */
+    getCurrentGate() {
+        return this.gateMachine.getCurrentGate();
+    }
+    /**
+     * Get gate pack for output
+     */
+    getGatePack() {
+        return this.gateMachine.getGatePack();
+    }
+    /**
+     * Submit artifact to current gate
+     */
+    submitGateArtifact(name, artifact) {
+        this.gateMachine.submitArtifact(name, artifact);
+    }
+    /**
+     * Attempt gate transition
+     */
+    async transitionGate(reviewResult) {
+        const transition = await this.gateMachine.transition(reviewResult);
+        return {
+            success: transition.blockers.length === 0,
+            transition,
+        };
+    }
+    /**
+     * Classify change type
+     */
+    classifyChange(description) {
+        const isPolicy = description.includes('policy') || description.includes('boundary');
+        const isContract = description.includes('API') || description.includes('contract');
+        const isImplementation = !isPolicy && !isContract;
+        return {
+            classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+            minimum_gates: isPolicy ? '0→8' : isContract ? '0→8' : '0→7',
+            fast_track: isImplementation,
+        };
+    }
+    // ==================== Skill Methods ====================
+    /**
+     * Execute a bollharness skill
+     */
+    async executeSkill(skillName, params) {
+        try {
+            const result = await this.skillAdapter.executeSkill(skillName, params);
+            return { success: true, result };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    /**
+     * List available skills
+     */
+    listSkills() {
+        return this.skillAdapter.listSkills().map(s => ({
+            name: s.name,
+            description: s.description,
+        }));
+    }
+    /**
+     * Get skill registry
+     */
+    getSkillAdapter() {
+        return this.skillAdapter;
+    }
+    /**
+     * List harness-native skills (metadata from SKILL.md files)
+     */
+    listHarnessSkills() {
+        return this.skillAdapter.listHarnessSkills().map(s => ({
+            name: s.name,
+            description: s.description,
+            tier: s.tier,
+        }));
+    }
+    // ==================== Configuration Methods ====================
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Enable/disable specific checks
+     */
+    enableCheck(checkName) {
+        this.guardChecker.enableCheck(checkName);
+    }
+    disableCheck(checkName) {
+        this.guardChecker.disableCheck(checkName);
+    }
+    // ==================== Metrics ====================
+    /**
+     * Get integration metrics
+     */
+    getMetrics() {
+        return {
+            config: this.config,
+            currentGate: this.gateMachine.getCurrentGate(),
+            enabledChecks: 'multiple',
+            availableSkills: this.skillAdapter.listSkills().length,
+            sessionArchives: this.sessionArchives.length,
+        };
+    }
+    // ==================== Session Archive Methods ====================
+    /**
+     * Archive current session operations with compression
+     */
+    archiveSession(logs, options) {
+        const id = `session_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const gate = this.gateMachine.getCurrentGate();
+        const compressed = this.compressLogs(logs);
+        const summary = options?.summary || this.generateSessionSummary(logs);
+        const keyDecisions = options?.keyDecisions || this.extractKeyDecisions(logs);
+        const archive = {
+            id,
+            timestamp: Date.now(),
+            gate,
+            summary,
+            actionCount: logs.length,
+            compressed,
+            keyDecisions,
+        };
+        this.sessionArchives.push(archive);
+        this.currentSessionId = id;
+        return archive;
+    }
+    /**
+     * Compress logs by removing redundancy
+     */
+    compressLogs(logs) {
+        if (logs.length === 0)
+            return '';
+        const lines = [];
+        const seenActions = new Set();
+        const recentTime = logs.length > 10 ? logs[logs.length - 10].timestamp : logs[0].timestamp;
+        lines.push(`## Session Archive (${logs.length} actions)`);
+        lines.push(`Gate: ${this.gateMachine.getCurrentGate()}`);
+        lines.push('');
+        for (const log of logs.slice(-50)) {
+            const time = new Date(log.timestamp).toISOString();
+            const action = log.action.padEnd(30);
+            if (seenActions.has(log.action) && log.status === 'ok') {
+                lines.push(`  ${time} [RPT] ${action}`);
+            }
+            else {
+                lines.push(`  ${time} [${log.status.padEnd(4)}] ${action}`);
+                seenActions.add(log.action);
+            }
+            if (log.timestamp < recentTime) {
+                lines.push(`    ^ ${log.details ? JSON.stringify(log.details).substring(0, 100) : ''}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate a brief summary of the session
+     */
+    generateSessionSummary(logs) {
+        const actions = logs.map(l => l.action);
+        const unique = [...new Set(actions)];
+        const okCount = logs.filter(l => l.status === 'ok').length;
+        return `${this.gateMachine.getCurrentGate()}G: ${unique.slice(0, 3).join(', ')}${unique.length > 3 ? '...' : ''} (${okCount}/${logs.length} OK)`;
+    }
+    /**
+     * Extract key decisions from logs
+     */
+    extractKeyDecisions(logs) {
+        const decisions = [];
+        for (const log of logs) {
+            if (log.action.includes('decision') || log.action.includes('approve') || log.action.includes('commit')) {
+                decisions.push(log.action);
+            }
+        }
+        return decisions.slice(0, 10);
+    }
+    /**
+     * Get session context for skills
+     */
+    getSessionContext(sessionId) {
+        if (sessionId) {
+            const archive = this.sessionArchives.find(a => a.id === sessionId);
+            if (archive) {
+                return `## Session ${archive.id}\nGate: ${archive.gate}\n${archive.compressed}`;
+            }
+        }
+        if (this.sessionArchives.length === 0) {
+            return 'No session archives available.';
+        }
+        const recent = this.sessionArchives.slice(-3);
+        const lines = ['## Recent Sessions'];
+        for (const archive of recent) {
+            lines.push(`\n### ${archive.id}`);
+            lines.push(`Gate: ${archive.gate} | Actions: ${archive.actionCount}`);
+            lines.push(`Summary: ${archive.summary}`);
+            if (archive.keyDecisions.length > 0) {
+                lines.push(`Decisions: ${archive.keyDecisions.join(', ')}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get all session archives
+     */
+    getSessionArchives() {
+        return [...this.sessionArchives];
+    }
+    /**
+     * Start a new session
+     */
+    startNewSession() {
+        this.currentSessionId = `session_${Date.now()}`;
+        return this.currentSessionId;
+    }
+    /**
+     * Link current harness session to Pi SDK session
+     */
+    linkSession(sessionId) {
+        this.currentSessionId = sessionId;
+    }
+}
+/**
+ * Create a default integration instance
+ */
+export function createBollharnessIntegration(config) {
+    return new BollharnessIntegration(config);
+}
+/**
+ * Integration hooks for Bolloon's execution pipeline
+ */
+export class BollharnessHooks {
+    integration;
+    constructor(integration) {
+        this.integration = integration || new BollharnessIntegration();
+    }
+    /**
+     * Pre-tool-use hook
+     */
+    async preToolUse(context) {
+        // Check for dangerous operations
+        if (context.tool === 'Bash') {
+            const cmd = context.input?.command;
+            if (cmd?.includes('rm -rf') || cmd?.includes('sudo')) {
+                return {
+                    allowed: false,
+                    blockReason: 'Dangerous command detected',
+                };
+            }
+        }
+        // Check guards if file is being edited
+        if (context.filePath && ['Edit', 'Write'].includes(context.tool)) {
+            const result = await this.integration.preEditCheck(context.filePath);
+            if (!result.success) {
+                return {
+                    allowed: false,
+                    findings: result.guards?.findings.map(f => ({
+                        severity: f.severity,
+                        message: f.message,
+                    })),
+                    blockReason: 'Guard checks failed',
+                };
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Post-tool-use hook
+     */
+    async postToolUse(context) {
+        if (!context.filePath) {
+            return { allowed: true };
+        }
+        const result = await this.integration.processFileEdit(context.filePath);
+        return {
+            allowed: result.success,
+            context: result.context,
+            findings: result.guards?.findings.map(f => ({
+                severity: f.severity,
+                message: f.message,
+            })),
+        };
+    }
+    /**
+     * Session start hook
+     */
+    async sessionStart() {
+        // Reset state if needed
+        console.log('[Bollharness] Session started with governance enabled');
+    }
+    /**
+     * Session end hook
+     */
+    async sessionEnd() {
+        const metrics = this.integration.getMetrics();
+        console.log('[Bollharness] Session ended', JSON.stringify(metrics, null, 2));
+    }
+}

package/dist/bollharness-integration/bollharness-integration/skill-adapter.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Skill Adapter - Bridge between Bollharness skills and Bolloon's SkillRegistry
+ *
+ * Loads skills from src/bollharness/.claude/skills/ and adapts them for Bolloon.
+ *
+ * Skill structure (from bollharness):
+ * - arch: Project architect (architecture decisions, boundary freezing)
+ * - lead: Development workflow commander (fail-closed state machine)
+ * - task-arch: Task decomposition
+ * - harness-eng: Engineering execution
+ * - harness-dev: Development execution
+ * - harness-eng-test: Engineering testing
+ * - harness-ops: Operations and truth maintenance
+ * - harness-bridge: Bridge agent coordination
+ * - crystal-learn: Failure pattern extraction
+ * - bug-triage: Bug classification
+ * - bug-pipeline: Bug fix pipeline
+ * - guardian-fixer: Issue-to-fix workflow
+ * - plan-lock: Plan freezing
+ * - skill-discovery: Skill discovery and recommendation
+ * - toolkit: Toolkit management
+ */
+import { SkillRegistry, Skill } from '@bolloon/constraint-runtime';
+export declare const BOLLHARNESS_SKILLS_DIR: any;
+export interface HarnessSkillMetadata {
+    name: string;
+    description: string;
+    status: 'active' | 'deprecated' | 'experimental';
+    tier: 'entry' | 'intermediate' | 'advanced' | 'meta' | 'execution';
+    owner?: string;
+    last_audited?: string;
+    triggers?: string[];
+    outputs?: string[];
+    truth_policy?: string[];
+}
+export interface SkillTriggers {
+    keywords: string[];
+    patterns: RegExp[];
+    contexts: string[];
+}
+export interface AdaptedSkill {
+    name: string;
+    description: string;
+    triggers: SkillTriggers;
+    execute: (params: Record<string, unknown>) => Promise<string>;
+    getGatePack?: () => Record<string, unknown>;
+}
+export interface SkillMetadata {
+    name: string;
+    tier: 'entry' | 'intermediate' | 'advanced';
+    status: 'active' | 'deprecated' | 'experimental';
+    owner?: string;
+    last_audited?: string;
+}
+/**
+ * Base skill class for bollharness-compatible skills
+ */
+export declare abstract class BaseSkill implements Skill {
+    abstract name: string;
+    abstract description: string;
+    abstract execute(params: Record<string, unknown>): Promise<string>;
+    protected log(message: string, level?: 'info' | 'warn' | 'error'): void;
+    protected formatOutput(output: Record<string, unknown>): string;
+}
+/**
+ * Architecture Skill - Project architect for architecture decisions
+ */
+export declare class ArchSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(params: Record<string, unknown>): Promise<string>;
+    private extractEssence;
+    private identifyTensions;
+    private compareAlternatives;
+    private identifyBoundaries;
+    private makeRecommendation;
+}
+/**
+ * Lead Skill - Development workflow commander (fail-closed state machine)
+ */
+export declare class LeadSkill extends BaseSkill {
+    name: string;
+    description: string;
+    private currentGate;
+    execute(params: Record<string, unknown>): Promise<string>;
+    getGatePack(): string;
+    private handleTransition;
+    private classifyChange;
+}
+/**
+ * Task Architecture Skill - Task decomposition
+ */
+export declare class TaskArchSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(params: Record<string, unknown>): Promise<string>;
+    private extractWorkPackages;
+    private identifySeams;
+    private identifyIntegration;
+    private assignSeamOwners;
+}
+/**
+ * Harness Engineering Skill - Engineering execution
+ */
+export declare class HarnessEngSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(params: Record<string, unknown>): Promise<string>;
+    private checkPrerequisites;
+    private planImplementation;
+    private createExecutionLog;
+}
+/**
+ * Harness Engineering Test Skill - Test strategy and execution
+ * Ported from src/bollharness/.claude/skills/harness-eng-test/SKILL.md
+ */
+export declare class HarnessEngTestSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(params: Record<string, unknown>): Promise<string>;
+    private createTestStrategy;
+    private createTestCases;
+    private executeTests;
+}
+/**
+ * Crystal Learn Skill - Failure pattern extraction
+ */
+export declare class CrystalLearnSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(params: Record<string, unknown>): Promise<string>;
+    private identifyFailures;
+    private extractPatterns;
+    private generateInvariants;
+}
+/**
+ * Skill Adapter - Registers all bollharness skills with Bolloon's SkillRegistry
+ */
+export declare class SkillAdapter {
+    private registry;
+    private harnessSkills;
+    constructor();
+    private registerSkills;
+    getRegistry(): SkillRegistry;
+    getSkill(name: string): Skill | undefined;
+    listSkills(): Skill[];
+    listHarnessSkills(): HarnessSkillMetadata[];
+    executeSkill(name: string, params: Record<string, unknown>): Promise<string>;
+    private log;
+}
+export declare const createSkillAdapter: () => SkillAdapter;