botinabox 2.5.2 → 2.5.3

package/dist/core/chat/session-manager.js

@@ -1,23 +0,0 @@
-/**
- * ChatSessionManager — wraps orchestrator SessionManager with SessionKey-based lookup.
- * Story 4.3
- */
-import { SessionManager } from "../orchestrator/session-manager.js";
-export class ChatSessionManager {
-    inner;
-    constructor(db) {
-        this.inner = new SessionManager(db);
-    }
-    async save(key, params) {
-        return this.inner.save(key.agentId, key.channel, key.scope, params);
-    }
-    async load(key) {
-        return this.inner.load(key.agentId, key.channel, key.scope);
-    }
-    async clear(key) {
-        return this.inner.clear(key.agentId, key.channel, key.scope);
-    }
-    async shouldClear(session, opts) {
-        return this.inner.shouldClear(session, opts);
-    }
-}

package/dist/core/chat/text-chunker.d.ts

@@ -1,9 +0,0 @@
-/**
- * Text chunker — splits long text into chunks at natural boundaries.
- * Story 4.4
- */
-/**
- * Split text into chunks of at most maxLen characters.
- * Splits at paragraph boundaries first, then sentence, then word, then hard-cuts.
- */
-export declare function chunkText(text: string, maxLen: number): string[];

package/dist/core/chat/text-chunker.js

@@ -1,48 +0,0 @@
-/**
- * Text chunker — splits long text into chunks at natural boundaries.
- * Story 4.4
- */
-/**
- * Split text into chunks of at most maxLen characters.
- * Splits at paragraph boundaries first, then sentence, then word, then hard-cuts.
- */
-export function chunkText(text, maxLen) {
-    if (maxLen <= 0)
-        throw new Error("maxLen must be > 0");
-    if (text.length <= maxLen)
-        return [text];
-    const chunks = [];
-    function splitInto(segment) {
-        if (segment.length <= maxLen) {
-            if (segment.length > 0)
-                chunks.push(segment);
-            return;
-        }
-        // Try paragraph split (\n\n)
-        const paraIdx = segment.lastIndexOf("\n\n", maxLen);
-        if (paraIdx > 0) {
-            chunks.push(segment.slice(0, paraIdx));
-            splitInto(segment.slice(paraIdx + 2).trimStart());
-            return;
-        }
-        // Try sentence split (". ")
-        const sentIdx = segment.lastIndexOf(". ", maxLen);
-        if (sentIdx > 0) {
-            chunks.push(segment.slice(0, sentIdx + 1));
-            splitInto(segment.slice(sentIdx + 2).trimStart());
-            return;
-        }
-        // Try word split (" ")
-        const wordIdx = segment.lastIndexOf(" ", maxLen);
-        if (wordIdx > 0) {
-            chunks.push(segment.slice(0, wordIdx));
-            splitInto(segment.slice(wordIdx + 1));
-            return;
-        }
-        // Hard cut
-        chunks.push(segment.slice(0, maxLen));
-        splitInto(segment.slice(maxLen));
-    }
-    splitInto(text);
-    return chunks;
-}

package/dist/core/chat/triage-router.d.ts

@@ -1,75 +0,0 @@
-/**
- * TriageRouter — content-based routing with deterministic-first resolution.
- * Story 6.3
- *
- * Replaces the simple channel→agent binding with intelligent routing:
- * 1. Keyword/regex rules evaluated first (deterministic, ~4ms)
- * 2. LLM classification only for ambiguous messages (async, ~2-4s)
- * 3. Ownership chain logged for every routing decision
- *
- * Key constraint: specialists return to triage, never to another specialist.
- */
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-import type { InboundMessage } from './types.js';
-export interface RoutingRule {
-    /** Target agent slug */
-    agentSlug: string;
-    /** Keywords that trigger this rule (case-insensitive) */
-    keywords?: string[];
-    /** Regex patterns that trigger this rule */
-    patterns?: string[];
-    /** Priority — lower number wins ties. Default: 50 */
-    priority?: number;
-}
-export interface RoutingDecision {
-    timestamp: string;
-    source: string;
-    target: string;
-    reason: string;
-    method: 'deterministic' | 'llm';
-    messageId?: string;
-    channel?: string;
-}
-export interface TriageRouterConfig {
-    /** Static routing rules evaluated deterministically */
-    rules: RoutingRule[];
-    /** Fallback agent if no rule matches and LLM is unavailable */
-    fallbackAgent?: string;
-    /** Whether to use LLM for ambiguous messages. Default: true */
-    llmFallback?: boolean;
-    /** Log decisions to the database. Default: true */
-    persist?: boolean;
-}
-export declare class TriageRouter {
-    private db;
-    private hooks;
-    private readonly rules;
-    private readonly fallbackAgent?;
-    private readonly llmFallback;
-    private readonly persist;
-    private readonly compiledRules;
-    constructor(db: DataStore, hooks: HookBus, config: TriageRouterConfig);
-    /**
-     * Route an inbound message to the best agent.
-     * Returns the agent slug and the routing decision.
-     */
-    route(msg: InboundMessage): Promise<{
-        agentSlug: string | undefined;
-        decision: RoutingDecision;
-    }>;
-    /**
-     * Query the ownership chain for a given message or channel.
-     */
-    getDecisionHistory(filter?: {
-        channel?: string;
-        limit?: number;
-    }): Promise<RoutingDecision[]>;
-    /**
-     * LLM classification — emits a hook for external LLM integration.
-     * Returns agent slug + reason, or undefined if LLM is unavailable.
-     */
-    private classifyWithLLM;
-    private buildDecision;
-    private logDecision;
-}

package/dist/core/chat/triage-router.js

@@ -1,142 +0,0 @@
-/**
- * TriageRouter — content-based routing with deterministic-first resolution.
- * Story 6.3
- *
- * Replaces the simple channel→agent binding with intelligent routing:
- * 1. Keyword/regex rules evaluated first (deterministic, ~4ms)
- * 2. LLM classification only for ambiguous messages (async, ~2-4s)
- * 3. Ownership chain logged for every routing decision
- *
- * Key constraint: specialists return to triage, never to another specialist.
- */
-export class TriageRouter {
-    db;
-    hooks;
-    rules;
-    fallbackAgent;
-    llmFallback;
-    persist;
-    compiledRules;
-    constructor(db, hooks, config) {
-        this.db = db;
-        this.hooks = hooks;
-        this.rules = config.rules;
-        this.fallbackAgent = config.fallbackAgent;
-        this.llmFallback = config.llmFallback ?? true;
-        this.persist = config.persist ?? true;
-        // Pre-compile patterns for fast matching
-        this.compiledRules = this.rules
-            .sort((a, b) => (a.priority ?? 50) - (b.priority ?? 50))
-            .map((rule) => ({
-            rule,
-            regexes: (rule.patterns ?? []).map((p) => new RegExp(p, 'i')),
-            keywordSet: new Set((rule.keywords ?? []).map((k) => k.toLowerCase())),
-        }));
-    }
-    /**
-     * Route an inbound message to the best agent.
-     * Returns the agent slug and the routing decision.
-     */
-    async route(msg) {
-        const body = msg.body.toLowerCase();
-        const words = new Set(body.split(/\s+/));
-        // Phase 1: Deterministic — keyword + regex matching
-        for (const { rule, regexes, keywordSet } of this.compiledRules) {
-            // Keyword match
-            for (const keyword of keywordSet) {
-                if (words.has(keyword) || body.includes(keyword)) {
-                    const decision = this.buildDecision(rule.agentSlug, `keyword: '${keyword}'`, 'deterministic', msg);
-                    await this.logDecision(decision);
-                    return { agentSlug: rule.agentSlug, decision };
-                }
-            }
-            // Regex match
-            for (const regex of regexes) {
-                if (regex.test(msg.body)) {
-                    const decision = this.buildDecision(rule.agentSlug, `pattern: ${regex.source}`, 'deterministic', msg);
-                    await this.logDecision(decision);
-                    return { agentSlug: rule.agentSlug, decision };
-                }
-            }
-        }
-        // Phase 2: LLM classification (if enabled)
-        if (this.llmFallback) {
-            const agentSlugs = this.rules.map((r) => r.agentSlug);
-            const classified = await this.classifyWithLLM(msg, agentSlugs);
-            if (classified) {
-                const decision = this.buildDecision(classified.agentSlug, `llm: ${classified.reason}`, 'llm', msg);
-                await this.logDecision(decision);
-                return { agentSlug: classified.agentSlug, decision };
-            }
-        }
-        // Phase 3: Fallback
-        const decision = this.buildDecision(this.fallbackAgent, 'fallback: no rule matched', 'deterministic', msg);
-        await this.logDecision(decision);
-        return { agentSlug: this.fallbackAgent, decision };
-    }
-    /**
-     * Query the ownership chain for a given message or channel.
-     */
-    async getDecisionHistory(filter) {
-        const rows = await this.db.query('activity_log', {
-            where: { event_type: 'triage_decision' },
-        });
-        let decisions = rows.map((r) => {
-            try {
-                return JSON.parse(r['payload']);
-            }
-            catch {
-                return null;
-            }
-        }).filter((d) => d !== null);
-        if (filter?.channel) {
-            decisions = decisions.filter((d) => d.channel === filter.channel);
-        }
-        // Sort by timestamp descending
-        decisions.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-        if (filter?.limit) {
-            decisions = decisions.slice(0, filter.limit);
-        }
-        return decisions;
-    }
-    /**
-     * LLM classification — emits a hook for external LLM integration.
-     * Returns agent slug + reason, or undefined if LLM is unavailable.
-     */
-    async classifyWithLLM(msg, agentSlugs) {
-        // Emit classification request — listeners provide the result
-        const result = {};
-        await this.hooks.emit('triage.classify', {
-            message: msg,
-            candidates: agentSlugs,
-            respond: (slug, reason) => {
-                result.agentSlug = slug;
-                result.reason = reason;
-            },
-        });
-        if (result.agentSlug && result.reason) {
-            return { agentSlug: result.agentSlug, reason: result.reason };
-        }
-        return undefined;
-    }
-    buildDecision(target, reason, method, msg) {
-        return {
-            timestamp: new Date().toISOString(),
-            source: 'triage',
-            target: target ?? 'none',
-            reason,
-            method,
-            messageId: msg.id,
-            channel: msg.channel,
-        };
-    }
-    async logDecision(decision) {
-        if (!this.persist)
-            return;
-        await this.db.insert('activity_log', {
-            event_type: 'triage_decision',
-            payload: JSON.stringify(decision),
-        });
-        await this.hooks.emit('triage.routed', { decision });
-    }
-}

package/dist/core/chat/types.d.ts

@@ -1,5 +0,0 @@
-/**
- * Chat types — re-exports from @botinabox/shared channel types.
- * Story 4.1
- */
-export type { ChatType, FormattingMode, ChannelCapabilities, ChannelMeta, InboundMessage, Attachment, OutboundPayload, SendResult, HealthStatus, ChannelConfig, ChannelAdapter, } from "../../shared/index.js";

package/dist/core/chat/types.js

@@ -1,5 +0,0 @@
-/**
- * Chat types — re-exports from @botinabox/shared channel types.
- * Story 4.1
- */
-export {};

package/dist/core/config/defaults.d.ts

@@ -1,2 +0,0 @@
-import type { BotConfig } from "../../shared/index.js";
-export declare const DEFAULT_CONFIG: BotConfig;

package/dist/core/config/defaults.js

@@ -1,38 +0,0 @@
-export const DEFAULT_CONFIG = {
-    data: {
-        path: "./data/bot.db",
-        walMode: true,
-    },
-    channels: {},
-    agents: [],
-    providers: {},
-    models: {
-        aliases: {
-            fast: "claude-haiku-4-5",
-            smart: "claude-opus-4-6",
-            balanced: "claude-sonnet-4-6",
-        },
-        default: "smart",
-        routing: {
-            conversation: "fast",
-            task_execution: "smart",
-            classification: "fast",
-        },
-        fallbackChain: [],
-    },
-    entities: {},
-    security: {
-        fieldLengthLimits: { default: 65535 },
-    },
-    render: {
-        outputDir: "./context",
-        watchIntervalMs: 30_000,
-    },
-    updates: {
-        policy: "auto-compatible",
-        checkIntervalMs: 86_400_000,
-    },
-    budget: {
-        warnPercent: 80,
-    },
-};

package/dist/core/config/index.d.ts

@@ -1,6 +0,0 @@
-export { loadConfig, getConfig, initConfig, _resetConfig } from "./loader.js";
-export type { ConfigLoadError, ConfigLoadResult } from "./loader.js";
-export { interpolateEnv } from "./interpolate.js";
-export { validateConfig } from "./schema.js";
-export type { SchemaError } from "./schema.js";
-export { DEFAULT_CONFIG } from "./defaults.js";

package/dist/core/config/index.js

@@ -1,4 +0,0 @@
-export { loadConfig, getConfig, initConfig, _resetConfig } from "./loader.js";
-export { interpolateEnv } from "./interpolate.js";
-export { validateConfig } from "./schema.js";
-export { DEFAULT_CONFIG } from "./defaults.js";

package/dist/core/config/interpolate.d.ts

@@ -1,5 +0,0 @@
-/**
- * Interpolate ${ENV_VAR} references in YAML string values.
- * Recursively walks objects and arrays.
- */
-export declare function interpolateEnv(value: unknown, env?: Record<string, string | undefined>): unknown;

package/dist/core/config/interpolate.js

@@ -1,27 +0,0 @@
-/**
- * Interpolate ${ENV_VAR} references in YAML string values.
- * Recursively walks objects and arrays.
- */
-export function interpolateEnv(value, env = process.env) {
-    if (typeof value === "string") {
-        return value.replace(/\$\{([^}]+)\}/g, (_, name) => {
-            const envVal = env[name];
-            if (envVal === undefined) {
-                // Leave the placeholder if env var is not set (don't silently swallow)
-                return `\${${name}}`;
-            }
-            return envVal;
-        });
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => interpolateEnv(item, env));
-    }
-    if (value !== null && typeof value === "object") {
-        const result = {};
-        for (const [k, v] of Object.entries(value)) {
-            result[k] = interpolateEnv(v, env);
-        }
-        return result;
-    }
-    return value;
-}

package/dist/core/config/loader.d.ts

@@ -1,24 +0,0 @@
-import type { BotConfig } from "../../shared/index.js";
-export interface ConfigLoadError {
-    field: string;
-    message: string;
-}
-export interface ConfigLoadResult {
-    config: BotConfig;
-    errors: ConfigLoadError[];
-}
-/**
- * Load and merge config from file, with env var interpolation and runtime overrides.
- * Merge order: defaults < config file < runtime overrides
- */
-export declare function loadConfig(opts?: {
-    configPath?: string;
-    overrides?: Partial<BotConfig>;
-    env?: Record<string, string | undefined>;
-}): ConfigLoadResult;
-/** Get the loaded config singleton. Call loadConfig() first. */
-export declare function getConfig(): BotConfig;
-/** Initialize the config singleton. Returns errors if any. */
-export declare function initConfig(opts?: Parameters<typeof loadConfig>[0]): ConfigLoadError[];
-/** Reset the singleton (for testing) */
-export declare function _resetConfig(): void;

package/dist/core/config/loader.js

@@ -1,59 +0,0 @@
-import { readFileSync, existsSync } from "node:fs";
-import { parse as parseYaml } from "yaml";
-import { DEFAULT_CONFIG } from "./defaults.js";
-import { interpolateEnv } from "./interpolate.js";
-function deepMerge(base, override) {
-    if (override === undefined || override === null)
-        return base;
-    if (base === undefined || base === null)
-        return override;
-    if (typeof base !== "object" || typeof override !== "object")
-        return override;
-    if (Array.isArray(override))
-        return override;
-    const result = { ...base };
-    for (const [k, v] of Object.entries(override)) {
-        if (v !== undefined) {
-            result[k] = deepMerge(result[k], v);
-        }
-    }
-    return result;
-}
-/**
- * Load and merge config from file, with env var interpolation and runtime overrides.
- * Merge order: defaults < config file < runtime overrides
- */
-export function loadConfig(opts) {
-    const configPath = opts?.configPath ?? "botinabox.config.yml";
-    const errors = [];
-    let fileConfig = {};
-    if (existsSync(configPath)) {
-        try {
-            const raw = readFileSync(configPath, "utf-8");
-            const parsed = parseYaml(raw);
-            fileConfig = interpolateEnv(parsed, opts?.env ?? process.env);
-        }
-        catch (err) {
-            errors.push({ field: "configPath", message: `Failed to parse ${configPath}: ${String(err)}` });
-        }
-    }
-    const merged = deepMerge(deepMerge(DEFAULT_CONFIG, fileConfig), opts?.overrides ?? {});
-    return { config: Object.freeze(merged), errors };
-}
-let _config = null;
-/** Get the loaded config singleton. Call loadConfig() first. */
-export function getConfig() {
-    if (!_config)
-        throw new Error("Config not loaded — call loadConfig() first");
-    return _config;
-}
-/** Initialize the config singleton. Returns errors if any. */
-export function initConfig(opts) {
-    const { config, errors } = loadConfig(opts);
-    _config = config;
-    return errors;
-}
-/** Reset the singleton (for testing) */
-export function _resetConfig() {
-    _config = null;
-}

package/dist/core/config/schema.d.ts

@@ -1,5 +0,0 @@
-export interface SchemaError {
-    path: string;
-    message: string;
-}
-export declare function validateConfig(config: unknown): SchemaError[];

package/dist/core/config/schema.js

@@ -1,119 +0,0 @@
-import Ajv from "ajv";
-const ajv = new Ajv({ allErrors: true, coerceTypes: false });
-const BOT_CONFIG_SCHEMA = {
-    type: "object",
-    additionalProperties: true,
-    properties: {
-        data: {
-            type: "object",
-            required: ["path", "walMode"],
-            properties: {
-                path: { type: "string", minLength: 1 },
-                walMode: { type: "boolean" },
-                backupDir: { type: "string" },
-            },
-        },
-        models: {
-            type: "object",
-            required: ["aliases", "default", "routing", "fallbackChain"],
-            properties: {
-                aliases: { type: "object", additionalProperties: { type: "string" } },
-                default: { type: "string", minLength: 1 },
-                routing: { type: "object", additionalProperties: { type: "string" } },
-                fallbackChain: { type: "array", items: { type: "string" } },
-                costLimit: {
-                    type: "object",
-                    properties: {
-                        perRunCents: { type: "number", minimum: 0 },
-                    },
-                },
-            },
-        },
-        security: {
-            type: "object",
-            properties: {
-                fieldLengthLimits: { type: "object", additionalProperties: { type: "number" } },
-                allowedFilePrefixes: { type: "array", items: { type: "string" } },
-            },
-        },
-        render: {
-            type: "object",
-            required: ["outputDir", "watchIntervalMs"],
-            properties: {
-                outputDir: { type: "string", minLength: 1 },
-                watchIntervalMs: { type: "number", minimum: 1000 },
-            },
-        },
-        updates: {
-            type: "object",
-            required: ["policy", "checkIntervalMs"],
-            properties: {
-                policy: { type: "string", enum: ["auto-all", "auto-compatible", "auto-patch", "notify", "manual"] },
-                checkIntervalMs: { type: "number", minimum: 60_000 },
-            },
-        },
-        budget: {
-            type: "object",
-            required: ["warnPercent"],
-            properties: {
-                warnPercent: { type: "number", minimum: 1, maximum: 100 },
-                globalMonthlyCents: { type: "number", minimum: 0 },
-            },
-        },
-        agents: {
-            type: "array",
-            items: {
-                type: "object",
-                required: ["slug", "name", "adapter"],
-                properties: {
-                    slug: { type: "string", minLength: 1, pattern: "^[a-z0-9-]+$" },
-                    name: { type: "string", minLength: 1 },
-                    adapter: { type: "string", minLength: 1 },
-                    model: { type: "string" },
-                    workdir: { type: "string" },
-                    maxConcurrentRuns: { type: "number", minimum: 1 },
-                    budgetMonthlyCents: { type: "number", minimum: 0 },
-                    canCreateAgents: { type: "boolean" },
-                    skipPermissions: { type: "boolean" },
-                },
-            },
-        },
-        channels: {
-            type: "object",
-            additionalProperties: {
-                type: "object",
-                required: ["enabled"],
-                properties: {
-                    enabled: { type: "boolean" },
-                },
-            },
-        },
-        providers: {
-            type: "object",
-            additionalProperties: {
-                type: "object",
-                required: ["enabled"],
-                properties: {
-                    enabled: { type: "boolean" },
-                },
-            },
-        },
-    },
-};
-let _validate = null;
-function getValidator() {
-    if (!_validate) {
-        _validate = ajv.compile(BOT_CONFIG_SCHEMA);
-    }
-    return _validate;
-}
-export function validateConfig(config) {
-    const validate = getValidator();
-    const valid = validate(config);
-    if (valid)
-        return [];
-    return (validate.errors ?? []).map(err => ({
-        path: err.instancePath || "/",
-        message: err.message ?? "invalid",
-    }));
-}

package/dist/core/data/core-entity-contexts.d.ts

@@ -1,14 +0,0 @@
-import type { DataStore } from "./data-store.js";
-/**
- * Define default entity context rendering for botinabox core tables.
- * Call after defineCoreTables() and before or after init().
- *
- * Renders:
- * - agents/ — per-agent context (AGENT.md, PROJECTS.md if agent_project exists)
- * - users/  — per-user context (USER.md) — protected
- * - skills/ — per-skill context (SKILL.md)
- *
- * Apps can override by calling db.defineEntityContext() with the same table name
- * BEFORE calling defineCoreEntityContexts().
- */
-export declare function defineCoreEntityContexts(db: DataStore): void;