verybot 0.1.8

package/dist/channels/commands.js

@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// Structured command result — channels format parts with their own escaping
+// ---------------------------------------------------------------------------
+const LEARN_COMMAND = "/learn";
+const REMEMBER_COMMAND = "/remember";
+const REMEMBER_USAGE = `${REMEMBER_COMMAND} <fact>`;
+export class CommandRouter {
+    opts;
+    activeTeams = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Resolve the active team for a channel, falling back to configured defaultTeamId. */
+    resolveTeamId(channelId) {
+        return this.activeTeams.get(channelId) ?? this.opts.defaultTeamId;
+    }
+    /**
+     * 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);
+        }
+        if (this.opts.onLearn) {
+            if (lower === LEARN_COMMAND || lower.startsWith(`${LEARN_COMMAND} `)) {
+                const topic = trimmed.slice(LEARN_COMMAND.length).trim();
+                return this.handleLearn(channelType, channelId, topic || undefined);
+            }
+        }
+        if (this.opts.onRemember) {
+            if (lower === REMEMBER_COMMAND || lower.startsWith(`${REMEMBER_COMMAND} `)) {
+                const fact = trimmed.slice(REMEMBER_COMMAND.length).trim();
+                return this.handleRemember(channelType, channelId, fact);
+            }
+        }
+        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 }, "."],
+        };
+    }
+    /** Handle /learn [topic]. */
+    async handleLearn(channelType, channelId, topic) {
+        if (!this.opts.onLearn) {
+            return { parts: ["Memory is not enabled"] };
+        }
+        let result;
+        try {
+            result = await this.opts.onLearn(channelType, channelId, topic, this.resolveTeamId(channelId));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to save memory";
+            return { parts: [msg] };
+        }
+        if (result.extracted === 0) {
+            return result.topic
+                ? { parts: ['No learnable facts found about "', result.topic, '" in the current session.'] }
+                : { parts: ["No learnable facts found in the current session."] };
+        }
+        const topicSuffix = result.topic ? ` about "${result.topic}"` : "";
+        const summary = result.saved > 0
+            ? `Learned ${result.saved} ${pluralize("fact", result.saved)}${topicSuffix}.`
+            : `Found ${result.extracted} ${pluralize("fact", result.extracted)}${topicSuffix}, but all were already known.`;
+        if (result.savedFacts.length === 0) {
+            return { parts: [summary] };
+        }
+        const factLines = result.savedFacts.map((fact) => `• ${fact}`).join("\n");
+        return { parts: [`${summary}\n${factLines}`] };
+    }
+    /** Handle /remember [fact]. */
+    async handleRemember(channelType, channelId, fact) {
+        if (!this.opts.onRemember) {
+            return { parts: ["Memory is not enabled"] };
+        }
+        if (!fact) {
+            return { parts: ["Usage: ", { code: REMEMBER_USAGE }] };
+        }
+        try {
+            const result = await this.opts.onRemember(channelType, channelId, fact, this.resolveTeamId(channelId));
+            return result.saved
+                ? { parts: ['Learned: "', result.fact, '"'] }
+                : { parts: ['Already known: "', result.fact, '"'] };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to save memory";
+            return { parts: [msg] };
+        }
+    }
+}
+function pluralize(word, count) {
+    return count === 1 ? word : `${word}s`;
+}

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

@@ -0,0 +1,29 @@
+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>;
+    onLearn?: (channelType: string, channelId: string, topic?: string, teamId?: string) => Promise<{
+        topic?: string;
+        extracted: number;
+        saved: number;
+        skipped: number;
+        savedFacts: string[];
+    }>;
+    onRemember?: (channelType: string, channelId: string, fact: string, teamId?: string) => Promise<{
+        saved: boolean;
+        fact: string;
+    }>;
+    /** 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,159 @@
+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, onLearn, onRemember, 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, onLearn, onRemember, 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);
+                    try {
+                        await onMessage({
+                            channelType: "discord",
+                            channelId,
+                            userId,
+                            text,
+                            teamId: commands.resolveTeamId(channelId),
+                        }, channel);
+                    }
+                    finally {
+                        stopTyping(channelId);
+                    }
+                }
+                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>;
+}

package/dist/channels/manager.js

@@ -0,0 +1,100 @@
+import { createHash } from "crypto";
+import { logger } from "../logger.js";
+/** Hash a token to produce a safe fingerprint (never store/log raw secrets). */
+export function channelFingerprint(token) {
+    return createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
+/** Settle delay between stopping an old channel and starting the replacement.
+ *  Telegram's getUpdates long-poll needs ~2s to release server-side. */
+const SETTLE_MS = 2_000;
+export class ChannelManager {
+    channels = [];
+    byName = new Map();
+    fingerprints = new Map();
+    reconciling = false;
+    register(channel, fingerprint) {
+        this.channels.push(channel);
+        this.byName.set(channel.name, channel);
+        if (fingerprint)
+            this.fingerprints.set(channel.name, fingerprint);
+    }
+    /** Look up a channel by name (e.g. "telegram"). */
+    get(name) {
+        return this.byName.get(name);
+    }
+    async startAll() {
+        for (const ch of this.channels) {
+            try {
+                await ch.start();
+                logger.info(`Channel started: ${ch.name}`);
+            }
+            catch (err) {
+                logger.error(`Failed to start channel ${ch.name}: ${err}`);
+            }
+        }
+    }
+    async stopAll() {
+        await Promise.all(this.channels.map((c) => c.stop()));
+    }
+    /** Stop and unregister a single channel by name. */
+    async stopOne(name) {
+        const ch = this.byName.get(name);
+        if (!ch)
+            return false;
+        try {
+            await ch.stop();
+            logger.info(`Channel stopped: ${name}`);
+        }
+        catch (err) {
+            logger.error(`Failed to stop channel ${name}: ${err}`);
+        }
+        this.byName.delete(name);
+        this.fingerprints.delete(name);
+        this.channels = this.channels.filter((c) => c.name !== name);
+        return true;
+    }
+    /**
+     * 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).
+     */
+    async reconcile(specs) {
+        if (this.reconciling) {
+            logger.info("Channel reconcile already in progress, skipping");
+            return;
+        }
+        this.reconciling = true;
+        try {
+            const desired = new Map(specs.map((s) => [s.name, s]));
+            // Stop channels that are no longer in config
+            for (const name of [...this.byName.keys()]) {
+                if (!desired.has(name)) {
+                    await this.stopOne(name);
+                }
+            }
+            // Add or replace channels whose fingerprint changed
+            for (const [name, spec] of desired) {
+                if (this.fingerprints.get(name) === spec.fingerprint)
+                    continue;
+                const hadExisting = await this.stopOne(name);
+                // Settle delay so server-side connections release (e.g. Telegram long-poll)
+                if (hadExisting) {
+                    await new Promise((r) => setTimeout(r, SETTLE_MS));
+                }
+                try {
+                    const channel = spec.create();
+                    await channel.start();
+                    this.register(channel, spec.fingerprint);
+                    logger.info(`Channel hot-reloaded: ${name}`);
+                }
+                catch (err) {
+                    // Don't register — next reconcile will retry since no fingerprint is stored
+                    logger.error(`Failed to start channel ${name} during reconcile: ${err}`);
+                }
+            }
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { Channel, MessageHandler } from "../types.js";
+import type { MarkdownTableMode } from "../../markdown/ir.js";
+export interface SlackSchedulerOpts {
+    /** Register a Slack channel as a connected scheduler channel. */
+    connectScheduler: (teamId: string, channelId: string, sendFn: (text: string) => Promise<void>) => string;
+    /** Unregister a Slack channel from the scheduler. */
+    disconnectScheduler: (teamId: string, key: string) => void;
+}
+/** Callback that resolves the current table mode from config at send time. */
+export type ResolveTableMode = () => MarkdownTableMode;
+export interface CreateSlackChannelOpts {
+    botToken: string;
+    appToken: string;
+    onMessage: MessageHandler;
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    onLearn?: (channelType: string, channelId: string, topic?: string, teamId?: string) => Promise<{
+        topic?: string;
+        extracted: number;
+        saved: number;
+        skipped: number;
+        savedFacts: string[];
+    }>;
+    onRemember?: (channelType: string, channelId: string, fact: string, teamId?: string) => Promise<{
+        saved: boolean;
+        fact: string;
+    }>;
+    /** 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;
+    schedulerOpts?: SlackSchedulerOpts;
+    resolveTableMode?: ResolveTableMode;
+}
+export declare function createSlackChannel(opts: CreateSlackChannelOpts): Channel;