botinabox 2.5.2 → 2.5.3

package/dist/core/orchestrator/claude-stream-parser.d.ts

@@ -1,31 +0,0 @@
-/**
- * Parse Claude CLI NDJSON (stream-json) output into structured results.
- * Used by the CLI execution adapter to extract session info, costs,
- * token usage, and text output from Claude CLI subprocess output.
- */
-export interface ParsedStream {
-    sessionId: string | null;
-    model: string | null;
-    costUsd: number | null;
-    usage: UsageSummary | null;
-    summary: string;
-    isError: boolean;
-    errorMessage: string | null;
-    stopReason: string | null;
-}
-export interface UsageSummary {
-    inputTokens: number;
-    cachedInputTokens: number;
-    outputTokens: number;
-}
-/**
- * Parse Claude CLI NDJSON output into a structured result.
- * Handles init, assistant, and result event types.
- */
-export declare function parseClaudeStream(stdout: string): ParsedStream;
-/** Check if the run stopped due to max turns. */
-export declare function isMaxTurns(parsed: ParsedStream): boolean;
-/** Check if Claude CLI requires login. */
-export declare function isLoginRequired(stdout: string): boolean;
-/** Rewrite local image paths to prevent CLI auto-embedding as vision content. */
-export declare function deactivateLocalImagePaths(prompt: string): string;

package/dist/core/orchestrator/claude-stream-parser.js

@@ -1,99 +0,0 @@
-/**
- * Parse Claude CLI NDJSON (stream-json) output into structured results.
- * Used by the CLI execution adapter to extract session info, costs,
- * token usage, and text output from Claude CLI subprocess output.
- */
-/**
- * Parse Claude CLI NDJSON output into a structured result.
- * Handles init, assistant, and result event types.
- */
-export function parseClaudeStream(stdout) {
-    let sessionId = null;
-    let model = null;
-    let costUsd = null;
-    let usage = null;
-    let isError = false;
-    let errorMessage = null;
-    let stopReason = null;
-    const textBlocks = [];
-    for (const line of stdout.split("\n")) {
-        if (!line.trim())
-            continue;
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const type = event.type;
-        if (type === "system" && event.subtype === "init") {
-            sessionId = event.session_id ?? null;
-            model = event.model ?? null;
-        }
-        if (type === "assistant") {
-            const msg = event.message;
-            const content = msg?.content ?? event.content;
-            if (Array.isArray(content)) {
-                for (const block of content) {
-                    if (block.type === "text" && block.text) {
-                        textBlocks.push(block.text);
-                    }
-                }
-            }
-        }
-        if (type === "result") {
-            isError = !!event.is_error;
-            stopReason = event.stop_reason ?? null;
-            costUsd =
-                typeof event.total_cost_usd === "number" ? event.total_cost_usd : null;
-            const u = event.usage;
-            if (u) {
-                usage = {
-                    inputTokens: u.input_tokens ?? 0,
-                    cachedInputTokens: u.cache_read_input_tokens ?? 0,
-                    outputTokens: u.output_tokens ?? 0,
-                };
-            }
-            if (isError) {
-                errorMessage =
-                    event.error ??
-                        event.result ??
-                        "Unknown error";
-            }
-            const resultContent = event.result;
-            if (typeof resultContent === "string" && resultContent) {
-                textBlocks.push(resultContent);
-            }
-        }
-    }
-    return {
-        sessionId,
-        model,
-        costUsd,
-        usage,
-        summary: textBlocks.join("\n"),
-        isError,
-        errorMessage,
-        stopReason,
-    };
-}
-/** Check if the run stopped due to max turns. */
-export function isMaxTurns(parsed) {
-    return (parsed.stopReason === "max_turns" || parsed.stopReason === "tool_use");
-}
-/** Check if Claude CLI requires login. */
-export function isLoginRequired(stdout) {
-    const patterns = [
-        "not logged in",
-        "login required",
-        "authentication required",
-        "please log in",
-    ];
-    const lower = stdout.toLowerCase();
-    return patterns.some((p) => lower.includes(p));
-}
-/** Rewrite local image paths to prevent CLI auto-embedding as vision content. */
-export function deactivateLocalImagePaths(prompt) {
-    return prompt.replace(/(?<=\s|^)(\/[\w./-]+\.(?:png|jpg|jpeg|gif|webp|svg))(?=\s|$)/gi, "[image-path:$1]");
-}

package/dist/core/orchestrator/config-revisions.d.ts

@@ -1,6 +0,0 @@
-import type { DataStore } from '../data/data-store.js';
-/**
- * Creates a config revision record with before/after snapshots.
- * Note: uses config_revisions table with config_yaml storing JSON of {agentId, before, after}.
- */
-export declare function createConfigRevision(db: DataStore, agentId: string, before: Record<string, unknown>, after: Record<string, unknown>): Promise<void>;

package/dist/core/orchestrator/config-revisions.js

@@ -1,17 +0,0 @@
-/**
- * Creates a config revision record with before/after snapshots.
- * Note: uses config_revisions table with config_yaml storing JSON of {agentId, before, after}.
- */
-export async function createConfigRevision(db, agentId, before, after) {
-    // Get the current max version for this agent and increment
-    const existing = await db.query('config_revisions', {
-        where: { notes: agentId },
-    });
-    const version = existing.length + 1;
-    await db.insert('config_revisions', {
-        version,
-        config_yaml: JSON.stringify({ agentId, before, after }),
-        applied_by: agentId,
-        notes: agentId,
-    });
-}

package/dist/core/orchestrator/dependency-resolver.d.ts

@@ -1,20 +0,0 @@
-/**
- * Dependency resolution utilities for workflow steps and task deps.
- */
-export interface StepRef {
-    id: string;
-    dependsOn?: string[];
-}
-/**
- * DFS cycle detection — returns true if cycle exists.
- */
-export declare function detectCycle(steps: StepRef[]): boolean;
-/**
- * Returns step IDs in topological (execution) order.
- * Throws if a cycle is detected.
- */
-export declare function topologicalSort(steps: StepRef[]): string[];
-/**
- * Returns true if all dependencies are satisfied (present in completedTaskIds).
- */
-export declare function areDependenciesMet(taskDepsJson: string | undefined, completedTaskIds: Set<string>): boolean;

package/dist/core/orchestrator/dependency-resolver.js

@@ -1,78 +0,0 @@
-/**
- * Dependency resolution utilities for workflow steps and task deps.
- */
-/**
- * DFS cycle detection — returns true if cycle exists.
- */
-export function detectCycle(steps) {
-    const deps = new Map();
-    for (const s of steps) {
-        deps.set(s.id, s.dependsOn ?? []);
-    }
-    const WHITE = 0, GRAY = 1, BLACK = 2;
-    const color = new Map();
-    for (const s of steps)
-        color.set(s.id, WHITE);
-    function dfs(node) {
-        color.set(node, GRAY);
-        for (const dep of deps.get(node) ?? []) {
-            const c = color.get(dep);
-            if (c === GRAY)
-                return true; // back edge = cycle
-            if (c === WHITE && dfs(dep))
-                return true;
-        }
-        color.set(node, BLACK);
-        return false;
-    }
-    for (const s of steps) {
-        if (color.get(s.id) === WHITE && dfs(s.id))
-            return true;
-    }
-    return false;
-}
-/**
- * Returns step IDs in topological (execution) order.
- * Throws if a cycle is detected.
- */
-export function topologicalSort(steps) {
-    if (detectCycle(steps)) {
-        throw new Error('Cycle detected in step dependencies');
-    }
-    const deps = new Map();
-    for (const s of steps) {
-        deps.set(s.id, s.dependsOn ?? []);
-    }
-    const visited = new Set();
-    const result = [];
-    function visit(id) {
-        if (visited.has(id))
-            return;
-        visited.add(id);
-        for (const dep of deps.get(id) ?? []) {
-            visit(dep);
-        }
-        result.push(id);
-    }
-    for (const s of steps) {
-        visit(s.id);
-    }
-    return result;
-}
-/**
- * Returns true if all dependencies are satisfied (present in completedTaskIds).
- */
-export function areDependenciesMet(taskDepsJson, completedTaskIds) {
-    if (!taskDepsJson)
-        return true;
-    let deps;
-    try {
-        deps = JSON.parse(taskDepsJson);
-    }
-    catch {
-        return true;
-    }
-    if (!Array.isArray(deps) || deps.length === 0)
-        return true;
-    return deps.every((id) => completedTaskIds.has(id));
-}

package/dist/core/orchestrator/governance-gate.d.ts

@@ -1,110 +0,0 @@
-/**
- * GovernanceGate — independent validation gates for agent output.
- * Story 6.7
- *
- * Key principle: gates report to the HUMAN, not to each other
- * or to a project manager agent. Structural independence prevents capture.
- *
- * Gate dimensions:
- *   QA       — data correctness (schema, row counts, format)
- *   Quality  — code quality (lint, coverage, patterns)
- *   Drift    — architectural drift (unintended dependencies, scope creep)
- */
-import type { HookBus } from '../hooks/hook-bus.js';
-export type GateVerdict = 'pass' | 'fail' | 'warn';
-export interface GateResult {
-    gateId: string;
-    verdict: GateVerdict;
-    findings: GateFinding[];
-    checkedAt: string;
-    durationMs: number;
-}
-export interface GateFinding {
-    severity: 'info' | 'warning' | 'error' | 'critical';
-    message: string;
-    location?: string;
-    suggestion?: string;
-}
-export interface GateInput {
-    agentId: string;
-    taskId: string;
-    output: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Base class for governance gates. Each gate checks a different dimension.
- * Gates are structurally independent — they report to the human operator,
- * not to each other or to any agent.
- */
-export declare abstract class GovernanceGate {
-    abstract readonly id: string;
-    abstract readonly name: string;
-    abstract readonly dimension: string;
-    /**
-     * Run the gate check on agent output.
-     * Must return a verdict and any findings.
-     */
-    abstract check(input: GateInput): Promise<GateResult>;
-}
-/**
- * QA Gate — validates data correctness.
- * Checks: schema conformance, row counts, format validation.
- */
-export declare class QAGate extends GovernanceGate {
-    private validators;
-    readonly id = "qa";
-    readonly name = "Quality Assurance";
-    readonly dimension = "data_correctness";
-    constructor(validators?: Array<{
-        name: string;
-        validate: (output: string, metadata?: Record<string, unknown>) => GateFinding[];
-    }>);
-    check(input: GateInput): Promise<GateResult>;
-}
-/**
- * Quality Gate — validates code quality.
- * Checks: lint results, test coverage, review patterns.
- */
-export declare class QualityGate extends GovernanceGate {
-    private checks;
-    readonly id = "quality";
-    readonly name = "Code Quality";
-    readonly dimension = "code_quality";
-    constructor(checks?: Array<{
-        name: string;
-        check: (output: string, metadata?: Record<string, unknown>) => Promise<GateFinding[]>;
-    }>);
-    check(input: GateInput): Promise<GateResult>;
-}
-/**
- * Drift Gate — detects architectural drift.
- * Checks: unintended dependencies, scope creep, pattern violations.
- */
-export declare class DriftGate extends GovernanceGate {
-    private rules;
-    readonly id = "drift";
-    readonly name = "Architectural Drift";
-    readonly dimension = "architecture";
-    constructor(rules?: Array<{
-        name: string;
-        detect: (output: string, metadata?: Record<string, unknown>) => GateFinding[];
-    }>);
-    check(input: GateInput): Promise<GateResult>;
-}
-/**
- * GateRunner — orchestrates multiple independent gates on agent output.
- * Each gate runs independently. Results are reported to the human, not to agents.
- */
-export declare class GateRunner {
-    private gates;
-    private hooks;
-    constructor(gates: GovernanceGate[], hooks: HookBus);
-    /**
-     * Run all gates on the given input.
-     * Gates run independently — one failure doesn't block others.
-     */
-    runAll(input: GateInput): Promise<{
-        passed: boolean;
-        results: GateResult[];
-    }>;
-}

package/dist/core/orchestrator/governance-gate.js

@@ -1,170 +0,0 @@
-/**
- * GovernanceGate — independent validation gates for agent output.
- * Story 6.7
- *
- * Key principle: gates report to the HUMAN, not to each other
- * or to a project manager agent. Structural independence prevents capture.
- *
- * Gate dimensions:
- *   QA       — data correctness (schema, row counts, format)
- *   Quality  — code quality (lint, coverage, patterns)
- *   Drift    — architectural drift (unintended dependencies, scope creep)
- */
-/**
- * Base class for governance gates. Each gate checks a different dimension.
- * Gates are structurally independent — they report to the human operator,
- * not to each other or to any agent.
- */
-export class GovernanceGate {
-}
-/**
- * QA Gate — validates data correctness.
- * Checks: schema conformance, row counts, format validation.
- */
-export class QAGate extends GovernanceGate {
-    validators;
-    id = 'qa';
-    name = 'Quality Assurance';
-    dimension = 'data_correctness';
-    constructor(validators = []) {
-        super();
-        this.validators = validators;
-    }
-    async check(input) {
-        const start = Date.now();
-        const findings = [];
-        for (const validator of this.validators) {
-            const results = validator.validate(input.output, input.metadata);
-            findings.push(...results);
-        }
-        const hasErrors = findings.some((f) => f.severity === 'error' || f.severity === 'critical');
-        const hasWarnings = findings.some((f) => f.severity === 'warning');
-        return {
-            gateId: this.id,
-            verdict: hasErrors ? 'fail' : hasWarnings ? 'warn' : 'pass',
-            findings,
-            checkedAt: new Date().toISOString(),
-            durationMs: Date.now() - start,
-        };
-    }
-}
-/**
- * Quality Gate — validates code quality.
- * Checks: lint results, test coverage, review patterns.
- */
-export class QualityGate extends GovernanceGate {
-    checks;
-    id = 'quality';
-    name = 'Code Quality';
-    dimension = 'code_quality';
-    constructor(checks = []) {
-        super();
-        this.checks = checks;
-    }
-    async check(input) {
-        const start = Date.now();
-        const findings = [];
-        for (const chk of this.checks) {
-            const results = await chk.check(input.output, input.metadata);
-            findings.push(...results);
-        }
-        const hasErrors = findings.some((f) => f.severity === 'error' || f.severity === 'critical');
-        const hasWarnings = findings.some((f) => f.severity === 'warning');
-        return {
-            gateId: this.id,
-            verdict: hasErrors ? 'fail' : hasWarnings ? 'warn' : 'pass',
-            findings,
-            checkedAt: new Date().toISOString(),
-            durationMs: Date.now() - start,
-        };
-    }
-}
-/**
- * Drift Gate — detects architectural drift.
- * Checks: unintended dependencies, scope creep, pattern violations.
- */
-export class DriftGate extends GovernanceGate {
-    rules;
-    id = 'drift';
-    name = 'Architectural Drift';
-    dimension = 'architecture';
-    constructor(rules = []) {
-        super();
-        this.rules = rules;
-    }
-    async check(input) {
-        const start = Date.now();
-        const findings = [];
-        for (const rule of this.rules) {
-            const results = rule.detect(input.output, input.metadata);
-            findings.push(...results);
-        }
-        const hasErrors = findings.some((f) => f.severity === 'error' || f.severity === 'critical');
-        const hasWarnings = findings.some((f) => f.severity === 'warning');
-        return {
-            gateId: this.id,
-            verdict: hasErrors ? 'fail' : hasWarnings ? 'warn' : 'pass',
-            findings,
-            checkedAt: new Date().toISOString(),
-            durationMs: Date.now() - start,
-        };
-    }
-}
-/**
- * GateRunner — orchestrates multiple independent gates on agent output.
- * Each gate runs independently. Results are reported to the human, not to agents.
- */
-export class GateRunner {
-    gates;
-    hooks;
-    constructor(gates, hooks) {
-        this.gates = gates;
-        this.hooks = hooks;
-    }
-    /**
-     * Run all gates on the given input.
-     * Gates run independently — one failure doesn't block others.
-     */
-    async runAll(input) {
-        const results = [];
-        for (const gate of this.gates) {
-            try {
-                const result = await gate.check(input);
-                results.push(result);
-                await this.hooks.emit('governance.gate_completed', {
-                    gateId: gate.id,
-                    gateName: gate.name,
-                    verdict: result.verdict,
-                    findingCount: result.findings.length,
-                    agentId: input.agentId,
-                    taskId: input.taskId,
-                });
-            }
-            catch (err) {
-                // Gate error — report but don't block others
-                results.push({
-                    gateId: gate.id,
-                    verdict: 'fail',
-                    findings: [{
-                            severity: 'error',
-                            message: `Gate error: ${err instanceof Error ? err.message : String(err)}`,
-                        }],
-                    checkedAt: new Date().toISOString(),
-                    durationMs: 0,
-                });
-            }
-        }
-        const passed = results.every((r) => r.verdict !== 'fail');
-        await this.hooks.emit('governance.review_completed', {
-            passed,
-            agentId: input.agentId,
-            taskId: input.taskId,
-            results: results.map((r) => ({
-                gateId: r.gateId,
-                verdict: r.verdict,
-                findingCount: r.findings.length,
-            })),
-        });
-        return { passed, results };
-    }
-}

package/dist/core/orchestrator/learning-pipeline.d.ts

@@ -1,109 +0,0 @@
-/**
- * LearningPipeline — turns execution experience into durable knowledge.
- * Story 6.5
- *
- * Promotion ladder:
- *   Execution → Feedback (structured capture)
- *     → 3+ similar → Playbook (generalized rule)
- *       → 3+ projects → Skill (executable behavior)
- *         → Agent-Skill Matrix → Per-Agent Context
- *
- * Two-axis evaluation:
- *   - Accuracy: was the output correct?
- *   - Efficiency: how fast / how many tokens?
- */
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-export interface FeedbackEntry {
-    agentId: string;
-    taskId?: string;
-    issue: string;
-    rootCause?: string;
-    severity: 'low' | 'medium' | 'high' | 'critical';
-    repeatable: boolean;
-    accuracyScore?: number;
-    efficiencyScore?: number;
-    tags?: string[];
-}
-export interface PlaybookEntry {
-    pattern: string;
-    rule: string;
-    feedbackIds: string[];
-    projectScoped: boolean;
-    agentIds?: string[];
-}
-export interface SkillEntry {
-    name: string;
-    slug: string;
-    description?: string;
-    behavior: string;
-    sourcePlaybookIds: string[];
-    category?: string;
-}
-export interface LearningPipelineConfig {
-    /** Feedback count threshold for playbook promotion. Default: 3 */
-    playbookThreshold?: number;
-    /** Project count threshold for skill promotion. Default: 3 */
-    skillThreshold?: number;
-    /** Auto-promote when thresholds are met. Default: false */
-    autoPromote?: boolean;
-}
-export declare class LearningPipeline {
-    private db;
-    private hooks;
-    private readonly playbookThreshold;
-    private readonly skillThreshold;
-    private readonly autoPromote;
-    constructor(db: DataStore, hooks: HookBus, config?: LearningPipelineConfig);
-    /**
-     * Capture a structured feedback record from an execution.
-     */
-    captureFeedback(entry: FeedbackEntry): Promise<string>;
-    /**
-     * Get all feedback records, optionally filtered.
-     */
-    listFeedback(filter?: {
-        agentId?: string;
-        severity?: string;
-        repeatable?: boolean;
-    }): Promise<Array<Record<string, unknown>>>;
-    /**
-     * Check if feedback records with similar issues should be promoted to a playbook.
-     * Groups by issue text similarity (exact match for now).
-     */
-    checkPlaybookPromotion(issue: string): Promise<string | undefined>;
-    /**
-     * Manually create a playbook from a set of feedback records.
-     */
-    promoteToPlaybook(entry: PlaybookEntry): Promise<string>;
-    /**
-     * List playbooks, optionally filtered.
-     */
-    listPlaybooks(filter?: {
-        projectScoped?: boolean;
-    }): Promise<Array<Record<string, unknown>>>;
-    /**
-     * Check if a playbook should be promoted to a skill.
-     * A playbook becomes a skill when it works across multiple projects
-     * (indicated by being referenced by agents in different contexts).
-     */
-    checkSkillPromotion(playbookId: string): Promise<string | undefined>;
-    /**
-     * Manually promote a playbook to a reusable skill.
-     */
-    promoteToSkill(entry: SkillEntry): Promise<string>;
-    /**
-     * Assign a skill to an agent.
-     */
-    assignSkill(agentId: string, skillId: string): Promise<void>;
-    /**
-     * Get learning metrics for an agent.
-     */
-    getMetrics(agentId: string): Promise<{
-        feedbackCount: number;
-        avgAccuracy: number | null;
-        avgEfficiency: number | null;
-        playbookCount: number;
-        skillCount: number;
-    }>;
-}