verybot 0.1.3

package/dist/brain/session.js

@@ -0,0 +1,75 @@
+import { compactMessages } from "./compaction.js";
+export class Session {
+    key;
+    messages = [];
+    persistedCount = 0; // how many messages are already on disk
+    _pendingCompaction = null;
+    _needsFullRewrite = false;
+    constructor(key, messages = []) {
+        this.key = key;
+        this.messages = messages;
+        this.persistedCount = messages.length;
+    }
+    append(msg) {
+        this.messages.push(msg);
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    /** Returns only messages not yet written to disk (normal append path). */
+    getNewMessages() {
+        return this.messages.slice(this.persistedCount);
+    }
+    /** After compaction: returns kept + new messages (everything except the summary at index 0). */
+    getCompactionMessages() {
+        return this.messages.slice(1);
+    }
+    /** Mark all current messages as persisted. */
+    markPersisted() {
+        this.persistedCount = this.messages.length;
+        this._pendingCompaction = null;
+        this._needsFullRewrite = false;
+    }
+    /** Pending compaction info for the store to persist as a marker. */
+    get pendingCompaction() {
+        return this._pendingCompaction;
+    }
+    /** True when the file must be fully overwritten (emergency truncate). */
+    get needsFullRewrite() {
+        return this._needsFullRewrite;
+    }
+    /** LLM-based compaction — summarizes old messages when tokens exceed context budget. */
+    async compact(model, contextWindow, systemPrompt) {
+        const result = await compactMessages(model, this.messages, contextWindow, systemPrompt);
+        if (result.compacted) {
+            this.messages = result.messages;
+            if (result.summary) {
+                // LLM summarization succeeded — persist as append-only compaction marker
+                this._pendingCompaction = { summary: result.summary };
+            }
+            else {
+                // Fallback truncation (no summary) — needs full file rewrite
+                this._needsFullRewrite = true;
+            }
+        }
+        return result.compacted;
+    }
+    /** Replace the internal messages array (e.g. after programmatic compaction). Marks full rewrite. */
+    replaceMessages(messages) {
+        this.messages = messages;
+        this._needsFullRewrite = true;
+    }
+    /** Emergency truncation — drop oldest messages, keeping last N. */
+    truncate(keep) {
+        if (this.messages.length > keep) {
+            this.messages = this.messages.slice(-keep);
+            this._needsFullRewrite = true;
+        }
+    }
+    get messageCount() {
+        return this.messages.length;
+    }
+    get updatedAt() {
+        return Date.now();
+    }
+}

package/dist/brain/utils.d.ts

@@ -0,0 +1,4 @@
+/** Check if two sets have the same elements. */
+export declare function setsEqual(a: Set<string>, b: Set<string>): boolean;
+/** Extract a user-facing message from API/runtime errors. */
+export declare function friendlyError(err: unknown): string;

package/dist/brain/utils.js

@@ -0,0 +1,26 @@
+/** Check if two sets have the same elements. */
+export function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+/** Extract a user-facing message from API/runtime errors. */
+export function friendlyError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const lower = msg.toLowerCase();
+    if (lower.includes("credit") || lower.includes("billing") || lower.includes("402") || lower.includes("payment"))
+        return "API credit balance is too low. Please top up your account and try again.";
+    if (lower.includes("rate limit") || lower.includes("429"))
+        return "Rate limited by the API. Please wait a moment and try again.";
+    if (lower.includes("authentication") || lower.includes("api key") || lower.includes("401"))
+        return "API authentication failed. Please check your API key.";
+    if (lower.includes("overloaded") || lower.includes("529"))
+        return "The AI service is currently overloaded. Please try again shortly.";
+    if (lower.includes("context") && lower.includes("overflow"))
+        return "The conversation is too long. Please start a new session.";
+    return `Something went wrong: ${msg.slice(0, 200)}`;
+}

package/dist/brain/worker-coordinator.d.ts

@@ -0,0 +1,25 @@
+import type { MessageQueue } from "./queue.js";
+import type { SessionStateMap } from "./session-state.js";
+/**
+ * Coordinates worker completion and orchestrator re-triggering.
+ * Debounces multiple concurrent worker completions into a single LLM call.
+ */
+export declare class WorkerCoordinator {
+    private sessions;
+    private queue;
+    constructor(sessions: SessionStateMap, queue: MessageQueue);
+    /**
+     * Called when a worker finishes. Debounces multiple completions into a single
+     * orchestrator re-trigger so concurrent workers batch into one LLM call.
+     */
+    onWorkerComplete(sessionKey: string, channelId: string): void;
+    /**
+     * Track delegation depth: synthetic worker triggers increment, real messages reset.
+     * Returns true if the message is a worker result synthetic message.
+     */
+    trackDelegationDepth(sessionKey: string, text: string): void;
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers(): void;
+    /** Enqueue a synthetic message to re-trigger the orchestrator after workers finish. */
+    private triggerOrchestratorForWorkerResults;
+}

package/dist/brain/worker-coordinator.js

@@ -0,0 +1,83 @@
+import { logger } from "../logger.js";
+/** Debounce delay before re-triggering orchestrator after worker completion. */
+const WORKER_TRIGGER_DEBOUNCE_MS = 2_000;
+/** Max times the orchestrator can be auto-triggered by worker results per user message. */
+const MAX_DELEGATION_DEPTH = 5;
+/** Prefix for synthetic messages injected when workers complete. */
+const WORKER_RESULTS_PREFIX = "[worker_results]";
+/**
+ * Coordinates worker completion and orchestrator re-triggering.
+ * Debounces multiple concurrent worker completions into a single LLM call.
+ */
+export class WorkerCoordinator {
+    sessions;
+    queue;
+    constructor(sessions, queue) {
+        this.sessions = sessions;
+        this.queue = queue;
+    }
+    /**
+     * Called when a worker finishes. Debounces multiple completions into a single
+     * orchestrator re-trigger so concurrent workers batch into one LLM call.
+     */
+    onWorkerComplete(sessionKey, channelId) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        // Accumulate completed channel IDs during debounce window
+        if (!state.workerPendingChannels) {
+            state.workerPendingChannels = new Set();
+        }
+        state.workerPendingChannels.add(channelId);
+        // Debounce: reset timer on each completion
+        if (state.workerTriggerTimer)
+            clearTimeout(state.workerTriggerTimer);
+        state.workerTriggerTimer = setTimeout(() => {
+            state.workerTriggerTimer = undefined;
+            this.triggerOrchestratorForWorkerResults(sessionKey);
+        }, WORKER_TRIGGER_DEBOUNCE_MS);
+    }
+    /**
+     * Track delegation depth: synthetic worker triggers increment, real messages reset.
+     * Returns true if the message is a worker result synthetic message.
+     */
+    trackDelegationDepth(sessionKey, text) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        if (text.startsWith(WORKER_RESULTS_PREFIX)) {
+            state.delegationDepth++;
+        }
+        else {
+            state.delegationDepth = 0;
+        }
+    }
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers() {
+        this.sessions.clearAllTimers();
+    }
+    /** Enqueue a synthetic message to re-trigger the orchestrator after workers finish. */
+    triggerOrchestratorForWorkerResults(sessionKey) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        if (state.delegationDepth >= MAX_DELEGATION_DEPTH) {
+            logger.warn(`[${sessionKey}] Delegation depth limit reached (${MAX_DELEGATION_DEPTH}), skipping re-trigger`);
+            return;
+        }
+        const channelIds = state.workerPendingChannels ? [...state.workerPendingChannels] : [];
+        state.workerPendingChannels = undefined;
+        const channelList = channelIds.map((id) => `- ${id}`).join("\n");
+        const synthetic = `${WORKER_RESULTS_PREFIX}\nWorker agents have completed. Call read_channel for each:\n${channelList}`;
+        const deliver = state.replyCallback;
+        this.queue.enqueue(sessionKey, synthetic).then((reply) => {
+            if (reply && deliver) {
+                deliver(reply).catch((err) => {
+                    logger.error(`[${sessionKey}] Failed to deliver worker trigger reply: ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        }, (err) => {
+            logger.error(`[${sessionKey}] Failed to enqueue worker trigger: ${err instanceof Error ? err.message : err}`);
+        });
+    }
+}

package/dist/channels/commands.d.ts

@@ -0,0 +1,35 @@
+/** A segment of a command response that needs channel-specific formatting. */
+export type CommandPart = string | {
+    bold: string;
+} | {
+    code: string;
+};
+export interface CommandResult {
+    parts: CommandPart[];
+}
+export interface CommandRouterOpts {
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    /** List available teams for the /team command. */
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    /** Fallback team when no active team is set for a channel. */
+    defaultTeamId?: string;
+}
+export declare class CommandRouter {
+    private readonly opts;
+    private readonly activeTeams;
+    constructor(opts: CommandRouterOpts);
+    /** Resolve the active team for a channel, falling back to defaultTeamId. */
+    resolveTeamId(channelId: string): string;
+    /**
+     * Parse raw text for slash-style commands (e.g. "/clear", "/team foo").
+     * Returns `null` if the text is not a recognised command.
+     */
+    handle(channelType: string, channelId: string, text: string): Promise<CommandResult | null>;
+    /** Handle /clear (or /reset). */
+    handleClear(channelType: string, channelId: string): Promise<CommandResult>;
+    /** Handle /team [name]. */
+    handleTeam(channelType: string, channelId: string, arg: string): Promise<CommandResult>;
+}

package/dist/channels/commands.js

@@ -0,0 +1,65 @@
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+export class CommandRouter {
+    opts;
+    activeTeams = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Resolve the active team for a channel, falling back to defaultTeamId. */
+    resolveTeamId(channelId) {
+        return this.activeTeams.get(channelId) ?? this.opts.defaultTeamId ?? DEFAULT_TEAM_ID;
+    }
+    /**
+     * Parse raw text for slash-style commands (e.g. "/clear", "/team foo").
+     * Returns `null` if the text is not a recognised command.
+     */
+    async handle(channelType, channelId, text) {
+        const trimmed = text.trim();
+        const lower = trimmed.toLowerCase();
+        if (lower === "/clear" || lower === "/reset") {
+            return this.handleClear(channelType, channelId);
+        }
+        if ((lower === "/team" || lower.startsWith("/team ")) && this.opts.listTeams) {
+            const arg = trimmed.slice("/team".length).trim();
+            return this.handleTeam(channelType, channelId, arg);
+        }
+        return null;
+    }
+    /** Handle /clear (or /reset). */
+    async handleClear(channelType, channelId) {
+        if (this.opts.onClear) {
+            await this.opts.onClear(channelType, channelId, this.resolveTeamId(channelId));
+        }
+        return { parts: ["Session cleared."] };
+    }
+    /** Handle /team [name]. */
+    async handleTeam(channelType, channelId, arg) {
+        const teams = this.opts.listTeams?.() ?? [];
+        // No argument → list teams with the active one highlighted.
+        if (!arg) {
+            const currentTeamId = this.resolveTeamId(channelId);
+            const parts = ["Teams:\n"];
+            for (const t of teams) {
+                if (t.id === currentTeamId) {
+                    parts.push("• ", { bold: t.name }, " (active)\n");
+                }
+                else {
+                    parts.push("• ", t.name, "\n");
+                }
+            }
+            parts.push("\nSwitch with ", { code: "/team <name>" });
+            return { parts };
+        }
+        // Find team by name (case-insensitive).
+        const target = teams.find((t) => t.name.toLowerCase() === arg.toLowerCase());
+        if (!target) {
+            return {
+                parts: ['Unknown team "', arg, '". Use ', { code: "/team" }, " to list available teams."],
+            };
+        }
+        this.activeTeams.set(channelId, target.id);
+        return {
+            parts: ["Switched to team ", { bold: target.name }, "."],
+        };
+    }
+}

package/dist/channels/discord/channel.d.ts

@@ -0,0 +1,18 @@
+import type { Channel, MessageHandler } from "../types.js";
+import type { MarkdownTableMode } from "../../markdown/ir.js";
+/** Callback that resolves the current table mode from config at send time. */
+export type ResolveTableMode = () => MarkdownTableMode;
+export interface CreateDiscordChannelOpts {
+    token: string;
+    onMessage: MessageHandler;
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    /** List available teams for the /team command. */
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    /** Fallback team when no active team is set for a channel. */
+    defaultTeamId?: string;
+    resolveTableMode?: ResolveTableMode;
+}
+export declare function createDiscordChannel(opts: CreateDiscordChannelOpts): Channel;

package/dist/channels/discord/channel.js

@@ -0,0 +1,154 @@
+import { Client, GatewayIntentBits, Partials, Events } from "discord.js";
+import { logger } from "../../logger.js";
+import { markdownToDiscordChunks, escapeDiscord, DISCORD_TEXT_LIMIT } from "./markdown.js";
+import { CommandRouter } from "../commands.js";
+/** Discord typing indicator expires after ~10s; refresh every 8s. */
+const TYPING_INTERVAL_MS = 8000;
+export function createDiscordChannel(opts) {
+    const { token, onMessage, onClear, listTeams, defaultTeamId, resolveTableMode = () => "code", } = opts;
+    const client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.DirectMessages,
+        ],
+        partials: [Partials.Channel],
+    });
+    const typingIntervals = new Map();
+    const commands = new CommandRouter({ onClear, listTeams, defaultTeamId });
+    /** Format a CommandResult using Discord markdown syntax. */
+    function formatDiscordResult(result) {
+        return result.parts
+            .map((p) => {
+            if (typeof p === "string")
+                return escapeDiscord(p);
+            if ("bold" in p)
+                return `**${escapeDiscord(p.bold)}**`;
+            return `\`${p.code}\``;
+        })
+            .join("");
+    }
+    /**
+     * Handle text-based commands (e.g. "/clear", "/team foo").
+     * Returns the formatted response if the message was consumed, or null.
+     */
+    async function handleTextCommand(text, channelId) {
+        try {
+            const result = await commands.handle("discord", channelId, text);
+            if (!result)
+                return null;
+            return formatDiscordResult(result);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`[discord] command error: ${msg}`);
+            return "Failed to process command. Please try again.";
+        }
+    }
+    function startTyping(channelId) {
+        stopTyping(channelId);
+        const discordChannel = client.channels.cache.get(channelId);
+        if (!discordChannel?.isTextBased() || !("sendTyping" in discordChannel))
+            return;
+        // Send immediately, then refresh on interval
+        discordChannel.sendTyping().catch((err) => logger.error(`[discord] typing error: ${err}`));
+        const interval = setInterval(() => {
+            discordChannel.sendTyping().catch((err) => logger.error(`[discord] typing interval error: ${err}`));
+        }, TYPING_INTERVAL_MS);
+        typingIntervals.set(channelId, interval);
+    }
+    function stopTyping(channelId) {
+        const interval = typingIntervals.get(channelId);
+        if (interval) {
+            clearInterval(interval);
+            typingIntervals.delete(channelId);
+        }
+    }
+    /** Send chunked Discord markdown to a channel. */
+    async function sendChunks(channelId, text) {
+        const discordChannel = client.channels.cache.get(channelId);
+        if (!discordChannel?.isTextBased() || !("send" in discordChannel)) {
+            logger.error(`[discord] cannot send to channel ${channelId}: not a text channel`);
+            return;
+        }
+        const tableMode = resolveTableMode();
+        const chunks = markdownToDiscordChunks(text, DISCORD_TEXT_LIMIT, { tableMode });
+        const noMentions = { allowedMentions: { parse: [] } };
+        if (chunks.length === 0 && text) {
+            await discordChannel.send({ content: text, ...noMentions });
+            return;
+        }
+        for (const chunk of chunks) {
+            await discordChannel.send({ content: chunk, ...noMentions });
+        }
+    }
+    /** Strip the bot mention prefix (e.g. `<@123456>`) from message text. */
+    function stripBotMention(text) {
+        const botId = client.user?.id;
+        if (!botId)
+            return text.trim();
+        const mentionRegex = new RegExp(`^\\s*<@!?${botId}>\\s*`);
+        return text.replace(mentionRegex, "").trim();
+    }
+    const channel = {
+        name: "discord",
+        start: async () => {
+            client.on(Events.MessageCreate, async (message) => {
+                try {
+                    const botUser = client.user;
+                    if (!botUser)
+                        return;
+                    // Ignore bot's own messages and other bots
+                    if (message.author.id === botUser.id)
+                        return;
+                    if (message.author.bot)
+                        return;
+                    const isDM = !message.guild;
+                    const isMentioned = message.mentions.has(botUser);
+                    // In guilds, only respond to mentions; in DMs, always respond
+                    if (!isDM && !isMentioned)
+                        return;
+                    const channelId = message.channelId;
+                    const userId = message.author.id;
+                    const rawText = message.content ?? "";
+                    const text = isDM ? rawText.trim() : stripBotMention(rawText);
+                    if (!text)
+                        return;
+                    // Try command handling first
+                    const cmdResponse = await handleTextCommand(text, channelId);
+                    if (cmdResponse) {
+                        await message.reply({ content: cmdResponse, allowedMentions: { parse: [] } });
+                        return;
+                    }
+                    logger.info(`[discord] message from ${userId} in ${channelId} (${isDM ? "DM" : "guild"})`);
+                    startTyping(channelId);
+                    await onMessage({
+                        channelType: "discord",
+                        channelId,
+                        userId,
+                        text,
+                        teamId: commands.resolveTeamId(channelId),
+                    }, channel);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`[discord] error in MessageCreate handler: ${msg}`);
+                }
+            });
+            await client.login(token);
+            logger.info(`[discord] connected as ${client.user?.tag}`);
+        },
+        stop: async () => {
+            for (const chatId of typingIntervals.keys())
+                stopTyping(chatId);
+            await client.destroy();
+            logger.info("[discord] disconnected");
+        },
+        send: async (channelId, text) => {
+            stopTyping(channelId);
+            await sendChunks(channelId, text);
+        },
+    };
+    return channel;
+}

package/dist/channels/discord/markdown.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Markdown → Discord markdown conversion.
+ * Discord supports standard markdown natively, with minor escaping needs.
+ */
+import { type MarkdownTableMode } from "../../markdown/ir.js";
+/** Discord message character limit. */
+export declare const DISCORD_TEXT_LIMIT = 2000;
+/** Escape Discord markdown special characters in plain text. */
+export declare function escapeDiscord(text: string): string;
+export declare function markdownToDiscord(markdown: string, options?: {
+    tableMode?: MarkdownTableMode;
+}): string;
+/**
+ * Convert markdown to chunked Discord markdown strings.
+ * Each chunk is ≤ `limit` characters of plain-text IR.
+ */
+export declare function markdownToDiscordChunks(markdown: string, limit?: number, options?: {
+    tableMode?: MarkdownTableMode;
+}): string[];

package/dist/channels/discord/markdown.js

@@ -0,0 +1,62 @@
+/**
+ * Markdown → Discord markdown conversion.
+ * Discord supports standard markdown natively, with minor escaping needs.
+ */
+import { chunkMarkdownIR, markdownToIR, } from "../../markdown/ir.js";
+import { renderMarkdownWithMarkers } from "../../markdown/render.js";
+const SAFE_LINK_PROTOCOL = /^https?:\/\/|^mailto:|^tel:/i;
+/** Discord message character limit. */
+export const DISCORD_TEXT_LIMIT = 2000;
+/** Escape Discord markdown special characters in plain text. */
+export function escapeDiscord(text) {
+    return text.replace(/([*_~`|>\\])/g, "\\$1");
+}
+function buildDiscordLink(link, _text) {
+    const href = link.href.trim();
+    if (!href || link.start === link.end)
+        return null;
+    if (!SAFE_LINK_PROTOCOL.test(href))
+        return null;
+    return {
+        start: link.start,
+        end: link.end,
+        open: "[",
+        close: `](${href})`,
+    };
+}
+function renderDiscordMarkdown(ir) {
+    return renderMarkdownWithMarkers(ir, {
+        styleMarkers: {
+            bold: { open: "**", close: "**" },
+            italic: { open: "*", close: "*" },
+            strikethrough: { open: "~~", close: "~~" },
+            code: { open: "`", close: "`" },
+            code_block: { open: "```\n", close: "\n```" },
+        },
+        escapeText: escapeDiscord,
+        buildLink: buildDiscordLink,
+    });
+}
+export function markdownToDiscord(markdown, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "> ",
+        tableMode: options.tableMode,
+    });
+    return renderDiscordMarkdown(ir);
+}
+/**
+ * Convert markdown to chunked Discord markdown strings.
+ * Each chunk is ≤ `limit` characters of plain-text IR.
+ */
+export function markdownToDiscordChunks(markdown, limit = DISCORD_TEXT_LIMIT, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "> ",
+        tableMode: options.tableMode,
+    });
+    const chunks = chunkMarkdownIR(ir, limit);
+    return chunks.map((chunk) => renderDiscordMarkdown(chunk));
+}

package/dist/channels/manager.d.ts

@@ -0,0 +1,29 @@
+import type { Channel } from "./types.js";
+export interface ChannelSpec {
+    name: string;
+    /** Opaque fingerprint (e.g. hash of token). Change triggers stop→start cycle. */
+    fingerprint: string;
+    /** Factory that creates a fresh Channel instance. */
+    create: () => Channel;
+}
+/** Hash a token to produce a safe fingerprint (never store/log raw secrets). */
+export declare function channelFingerprint(token: string): string;
+export declare class ChannelManager {
+    private channels;
+    private byName;
+    private fingerprints;
+    private reconciling;
+    register(channel: Channel, fingerprint?: string): void;
+    /** Look up a channel by name (e.g. "telegram"). */
+    get(name: string): Channel | undefined;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    /** Stop and unregister a single channel by name. */
+    private stopOne;
+    /**
+     * Diff current channels against desired specs. Stop removed/changed channels,
+     * start new/changed ones. Self-guarding: concurrent calls are skipped
+     * (the next reloadConfig cycle will catch the mismatch).
+     */
+    reconcile(specs: ChannelSpec[]): Promise<void>;
+}