verybot 0.1.8

package/dist/markdown/table-render.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Table rendering for Markdown IR.
+ * Extracted from ir.ts to keep modules under ~500 LOC.
+ */
+import type { MarkdownStyle, MarkdownStyleSpan, MarkdownLinkSpan } from "./ir.js";
+/** Minimal target interface for appending rendered table output. */
+export type TableTarget = {
+    text: string;
+    styles: MarkdownStyleSpan[];
+    links: MarkdownLinkSpan[];
+};
+type OpenStyle = {
+    style: MarkdownStyle;
+    start: number;
+};
+type LinkState = {
+    href: string;
+    labelStart: number;
+};
+/** A render target with open style tracking (used during cell parsing). */
+export type CellRenderTarget = TableTarget & {
+    openStyles: OpenStyle[];
+    linkStack: LinkState[];
+};
+export type TableCell = {
+    text: string;
+    styles: MarkdownStyleSpan[];
+    links: MarkdownLinkSpan[];
+};
+export type TableState = {
+    headers: TableCell[];
+    rows: TableCell[][];
+    currentRow: TableCell[];
+    currentCell: CellRenderTarget | null;
+    inHeader: boolean;
+};
+export declare function initTableState(): TableState;
+export declare function initCellTarget(): CellRenderTarget;
+export declare function finishTableCell(cell: CellRenderTarget): TableCell;
+export declare function trimCell(cell: TableCell): TableCell;
+export declare function renderTableAsBullets(target: TableTarget, table: TableState): void;
+export declare function renderTableAsCode(target: TableTarget, table: TableState, inList: boolean): void;
+export {};

package/dist/markdown/table-render.js

@@ -0,0 +1,219 @@
+/**
+ * Table rendering for Markdown IR.
+ * Extracted from ir.ts to keep modules under ~500 LOC.
+ */
+export function initTableState() {
+    return {
+        headers: [],
+        rows: [],
+        currentRow: [],
+        currentCell: null,
+        inHeader: false,
+    };
+}
+export function initCellTarget() {
+    return {
+        text: "",
+        styles: [],
+        openStyles: [],
+        links: [],
+        linkStack: [],
+    };
+}
+function closeRemainingStyles(target) {
+    for (let i = target.openStyles.length - 1; i >= 0; i -= 1) {
+        const open = target.openStyles[i];
+        const end = target.text.length;
+        if (end > open.start) {
+            target.styles.push({
+                start: open.start,
+                end,
+                style: open.style,
+            });
+        }
+    }
+    target.openStyles = [];
+}
+export function finishTableCell(cell) {
+    closeRemainingStyles(cell);
+    return {
+        text: cell.text,
+        styles: cell.styles,
+        links: cell.links,
+    };
+}
+export function trimCell(cell) {
+    const text = cell.text;
+    let start = 0;
+    let end = text.length;
+    while (start < end && /\s/.test(text[start] ?? "")) {
+        start += 1;
+    }
+    while (end > start && /\s/.test(text[end - 1] ?? "")) {
+        end -= 1;
+    }
+    if (start === 0 && end === text.length) {
+        return cell;
+    }
+    const trimmedText = text.slice(start, end);
+    const trimmedLength = trimmedText.length;
+    const trimmedStyles = [];
+    for (const span of cell.styles) {
+        const sliceStart = Math.max(0, span.start - start);
+        const sliceEnd = Math.min(trimmedLength, span.end - start);
+        if (sliceEnd > sliceStart) {
+            trimmedStyles.push({ start: sliceStart, end: sliceEnd, style: span.style });
+        }
+    }
+    const trimmedLinks = [];
+    for (const span of cell.links) {
+        const sliceStart = Math.max(0, span.start - start);
+        const sliceEnd = Math.min(trimmedLength, span.end - start);
+        if (sliceEnd > sliceStart) {
+            trimmedLinks.push({ start: sliceStart, end: sliceEnd, href: span.href });
+        }
+    }
+    return { text: trimmedText, styles: trimmedStyles, links: trimmedLinks };
+}
+function appendCell(target, cell) {
+    if (!cell.text) {
+        return;
+    }
+    const start = target.text.length;
+    target.text += cell.text;
+    for (const span of cell.styles) {
+        target.styles.push({
+            start: start + span.start,
+            end: start + span.end,
+            style: span.style,
+        });
+    }
+    for (const link of cell.links) {
+        target.links.push({
+            start: start + link.start,
+            end: start + link.end,
+            href: link.href,
+        });
+    }
+}
+export function renderTableAsBullets(target, table) {
+    const headers = table.headers.map(trimCell);
+    const rows = table.rows.map((row) => row.map(trimCell));
+    if (headers.length === 0 && rows.length === 0) {
+        return;
+    }
+    const useFirstColAsLabel = headers.length > 1 && rows.length > 0;
+    if (useFirstColAsLabel) {
+        for (const row of rows) {
+            if (row.length === 0) {
+                continue;
+            }
+            const rowLabel = row[0];
+            if (rowLabel?.text) {
+                const labelStart = target.text.length;
+                appendCell(target, rowLabel);
+                const labelEnd = target.text.length;
+                if (labelEnd > labelStart) {
+                    target.styles.push({ start: labelStart, end: labelEnd, style: "bold" });
+                }
+                target.text += "\n";
+            }
+            for (let i = 1; i < row.length; i++) {
+                const header = headers[i];
+                const value = row[i];
+                if (!value?.text) {
+                    continue;
+                }
+                target.text += "\u2022 ";
+                if (header?.text) {
+                    appendCell(target, header);
+                    target.text += ": ";
+                }
+                else {
+                    target.text += `Column ${i}: `;
+                }
+                appendCell(target, value);
+                target.text += "\n";
+            }
+            target.text += "\n";
+        }
+    }
+    else {
+        for (const row of rows) {
+            for (let i = 0; i < row.length; i++) {
+                const header = headers[i];
+                const value = row[i];
+                if (!value?.text) {
+                    continue;
+                }
+                target.text += "\u2022 ";
+                if (header?.text) {
+                    appendCell(target, header);
+                    target.text += ": ";
+                }
+                appendCell(target, value);
+                target.text += "\n";
+            }
+            target.text += "\n";
+        }
+    }
+}
+export function renderTableAsCode(target, table, inList) {
+    const headers = table.headers.map(trimCell);
+    const rows = table.rows.map((row) => row.map(trimCell));
+    const columnCount = Math.max(headers.length, ...rows.map((row) => row.length));
+    if (columnCount === 0) {
+        return;
+    }
+    const widths = Array.from({ length: columnCount }, () => 0);
+    const updateWidths = (cells) => {
+        for (let i = 0; i < columnCount; i += 1) {
+            const cell = cells[i];
+            const width = cell?.text.length ?? 0;
+            if (widths[i] < width) {
+                widths[i] = width;
+            }
+        }
+    };
+    updateWidths(headers);
+    for (const row of rows) {
+        updateWidths(row);
+    }
+    const codeStart = target.text.length;
+    const appendRow = (cells) => {
+        target.text += "|";
+        for (let i = 0; i < columnCount; i += 1) {
+            target.text += " ";
+            const cell = cells[i];
+            if (cell) {
+                appendCell(target, cell);
+            }
+            const pad = widths[i] - (cell?.text.length ?? 0);
+            if (pad > 0) {
+                target.text += " ".repeat(pad);
+            }
+            target.text += " |";
+        }
+        target.text += "\n";
+    };
+    const appendDivider = () => {
+        target.text += "|";
+        for (let i = 0; i < columnCount; i += 1) {
+            const dashCount = Math.max(3, widths[i]);
+            target.text += ` ${"-".repeat(dashCount)} |`;
+        }
+        target.text += "\n";
+    };
+    appendRow(headers);
+    appendDivider();
+    for (const row of rows) {
+        appendRow(row);
+    }
+    const codeEnd = target.text.length;
+    if (codeEnd > codeStart) {
+        target.styles.push({ start: codeStart, end: codeEnd, style: "code_block" });
+    }
+    if (!inList) {
+        target.text += "\n";
+    }
+}

package/dist/markdown/tables.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Table mode resolution for markdown rendering.
+ * Adapted from verybot markdown-tables.
+ */
+import type { MarkdownTableMode } from "./ir.js";
+/**
+ * Resolve the markdown table mode for a given channel.
+ *
+ * Resolution order:
+ *   1. Explicit per-channel config (`channelTableMode`)
+ *   2. Channel-specific default (signal/whatsapp → "bullets")
+ *   3. Global default ("code")
+ */
+export declare function resolveMarkdownTableMode(params: {
+    channel: string;
+    channelTableMode?: MarkdownTableMode | string | null;
+}): MarkdownTableMode;

package/dist/markdown/tables.js

@@ -0,0 +1,27 @@
+/**
+ * Table mode resolution for markdown rendering.
+ * Adapted from verybot markdown-tables.
+ */
+/** Per-channel defaults. */
+const DEFAULT_TABLE_MODES = new Map([
+    ["signal", "bullets"],
+    ["whatsapp", "bullets"],
+]);
+/** Fallback for channels not in the default map. */
+const GLOBAL_DEFAULT = "code";
+const isMarkdownTableMode = (value) => value === "off" || value === "bullets" || value === "code";
+/**
+ * Resolve the markdown table mode for a given channel.
+ *
+ * Resolution order:
+ *   1. Explicit per-channel config (`channelTableMode`)
+ *   2. Channel-specific default (signal/whatsapp → "bullets")
+ *   3. Global default ("code")
+ */
+export function resolveMarkdownTableMode(params) {
+    const { channel, channelTableMode } = params;
+    if (isMarkdownTableMode(channelTableMode)) {
+        return channelTableMode;
+    }
+    return DEFAULT_TABLE_MODES.get(channel) ?? GLOBAL_DEFAULT;
+}

package/dist/memory/embedding.d.ts

@@ -0,0 +1,16 @@
+export interface EmbeddingProvider {
+    id: string;
+    model: string;
+    /** Returns embedding vector, or undefined if model is not ready yet. */
+    embed(text: string): Promise<number[] | undefined>;
+    embedBatch(texts: string[]): Promise<(number[] | undefined)[]>;
+    /** True once the model is downloaded and loaded. */
+    ready: boolean;
+}
+/**
+ * Create a local embedding provider using node-llama-cpp.
+ * The model is downloaded and loaded in the background — embed() returns
+ * undefined until ready, so the system falls back to FTS5-only search.
+ * Returns null if node-llama-cpp is not installed.
+ */
+export declare function createEmbeddingProvider(provider: "local" | "none", modelPath?: string): Promise<EmbeddingProvider | null>;

package/dist/memory/embedding.js

@@ -0,0 +1,66 @@
+import { logger } from "../logger.js";
+const DEFAULT_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
+function normalizeEmbedding(vec) {
+    const sanitized = vec.map((v) => (Number.isFinite(v) ? v : 0));
+    const magnitude = Math.sqrt(sanitized.reduce((sum, v) => sum + v * v, 0));
+    if (magnitude < 1e-10)
+        return sanitized;
+    return sanitized.map((v) => v / magnitude);
+}
+/**
+ * Create a local embedding provider using node-llama-cpp.
+ * The model is downloaded and loaded in the background — embed() returns
+ * undefined until ready, so the system falls back to FTS5-only search.
+ * Returns null if node-llama-cpp is not installed.
+ */
+export async function createEmbeddingProvider(provider, modelPath) {
+    if (provider === "none")
+        return null;
+    let nodeLlamaCpp;
+    try {
+        nodeLlamaCpp = await import("node-llama-cpp");
+    }
+    catch {
+        logger.warn("node-llama-cpp not installed. Falling back to FTS5-only search.");
+        return null;
+    }
+    const { getLlama, resolveModelFile, LlamaLogLevel } = nodeLlamaCpp;
+    let ctx = null;
+    const resolvedModel = modelPath || DEFAULT_MODEL;
+    const ep = {
+        id: "local",
+        model: resolvedModel,
+        ready: false,
+        async embed(text) {
+            if (!ctx)
+                return undefined;
+            const result = await ctx.getEmbeddingFor(text);
+            return normalizeEmbedding(Array.from(result.vector));
+        },
+        async embedBatch(texts) {
+            if (!ctx)
+                return texts.map(() => undefined);
+            return Promise.all(texts.map(async (t) => {
+                const result = await ctx.getEmbeddingFor(t);
+                return normalizeEmbedding(Array.from(result.vector));
+            }));
+        },
+    };
+    // Background init — download model + load context, never blocks startup
+    (async () => {
+        try {
+            logger.info(`Embedding model loading in background (${resolvedModel})...`);
+            const llama = await getLlama({ logLevel: LlamaLogLevel.error });
+            const resolved = await resolveModelFile(resolvedModel);
+            const model = await llama.loadModel({ modelPath: resolved });
+            ctx = await model.createEmbeddingContext();
+            ep.ready = true;
+            logger.info("Embedding model ready.");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`Embedding model failed to load: ${msg}. Using FTS5-only search.`);
+        }
+    })();
+    return ep;
+}

package/dist/memory/explicit.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryStore } from "./store.js";
+import type { EmbeddingProvider } from "./embedding.js";
+export declare const MAX_EXPLICIT_FACT_LENGTH = 2000;
+export interface SaveExplicitMemoryInput {
+    fact: string;
+    source: string;
+    teamId?: string;
+}
+export interface SaveExplicitMemoryResult {
+    saved: boolean;
+    fact: string;
+}
+/**
+ * Save one user-provided fact to long-term memory with consistent validation.
+ */
+export declare function saveExplicitMemory(store: MemoryStore, embeddingProvider: EmbeddingProvider | null, input: SaveExplicitMemoryInput): Promise<SaveExplicitMemoryResult>;

package/dist/memory/explicit.js

@@ -0,0 +1,29 @@
+import { randomUUID } from "crypto";
+export const MAX_EXPLICIT_FACT_LENGTH = 2000;
+/**
+ * Save one user-provided fact to long-term memory with consistent validation.
+ */
+export async function saveExplicitMemory(store, embeddingProvider, input) {
+    if (typeof input.fact !== "string") {
+        throw new Error("fact is required");
+    }
+    const fact = input.fact.trim();
+    if (fact.length === 0) {
+        throw new Error("fact cannot be empty");
+    }
+    if (fact.length > MAX_EXPLICIT_FACT_LENGTH) {
+        throw new Error(`fact exceeds maximum length of ${MAX_EXPLICIT_FACT_LENGTH}`);
+    }
+    const embedding = embeddingProvider
+        ? await embeddingProvider.embed(fact) ?? undefined
+        : undefined;
+    const saved = store.save({
+        id: randomUUID(),
+        fact,
+        source: input.source,
+        timestamp: Date.now(),
+        teamId: input.teamId,
+        embedding,
+    });
+    return { saved, fact };
+}

package/dist/memory/extractor.d.ts

@@ -0,0 +1,13 @@
+import { type LanguageModel, type ModelMessage } from "ai";
+interface ExtractFactOptions {
+    /** If set, only return facts related to this topic. */
+    topic?: string;
+    /** Number of recent messages to inspect. */
+    maxMessages?: number;
+}
+/**
+ * Extract memorable facts from a conversation using an LLM.
+ * Returns an array of fact strings, or empty if nothing worth remembering.
+ */
+export declare function extractFacts(model: LanguageModel, messages: ModelMessage[], options?: ExtractFactOptions): Promise<string[]>;
+export {};

package/dist/memory/extractor.js

@@ -0,0 +1,82 @@
+import { generateText } from "ai";
+import { logger } from "../logger.js";
+const MAX_RECENT_MESSAGES = 10;
+function buildExtractionPrompt(topic) {
+    const topicSection = topic
+        ? `\nFOCUS MODE:
+- Only include facts directly related to this topic: "${topic}".
+- If no relevant facts are found for this topic, return [].
+`
+        : "";
+    return `You extract memorable facts from conversations.
+
+Review the conversation and identify facts worth remembering long-term about the user.${topicSection}
+
+INCLUDE:
+- Personal preferences (likes, dislikes, habits)
+- Important context (name, job, location, family, timezone)
+- Goals, projects, and recurring topics
+- Communication preferences
+
+EXCLUDE:
+- Transient requests ("search for X", "open this URL")
+- Generic small talk or greetings
+- Tool usage details or technical artifacts
+- Information the user explicitly asked to forget
+
+Return ONLY a JSON array of short fact strings. Each fact should be a single sentence.
+If there are no memorable facts, return an empty array: []
+
+Example output:
+["User's name is Alice", "User prefers dark mode", "User works as a backend engineer"]`;
+}
+/**
+ * Extract memorable facts from a conversation using an LLM.
+ * Returns an array of fact strings, or empty if nothing worth remembering.
+ */
+export async function extractFacts(model, messages, options = {}) {
+    // Only look at recent messages to avoid redundant extraction
+    const maxMessages = options.maxMessages ?? MAX_RECENT_MESSAGES;
+    const recent = messages.slice(-maxMessages);
+    const formatted = recent
+        .map((m) => {
+        if (m.role === "user") {
+            const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            return `User: ${content}`;
+        }
+        if (m.role === "assistant") {
+            const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            return `Assistant: ${content}`;
+        }
+        return null;
+    })
+        .filter(Boolean)
+        .join("\n");
+    if (!formatted.trim())
+        return [];
+    try {
+        const { text } = await generateText({
+            model,
+            system: buildExtractionPrompt(options.topic),
+            prompt: formatted,
+        });
+        // Parse JSON array from response (handle markdown code blocks and surrounding prose)
+        const cleaned = text.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+        // Try to find a JSON array in the response — the model sometimes wraps it in prose
+        const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
+        if (!arrayMatch) {
+            // No array found — model returned plain text, nothing to extract
+            return [];
+        }
+        const parsed = JSON.parse(arrayMatch[0]);
+        if (!Array.isArray(parsed)) {
+            logger.warn("Fact extraction returned non-array");
+            return [];
+        }
+        return parsed.filter((f) => typeof f === "string" && f.trim().length > 0);
+    }
+    catch (err) {
+        logger.warn(`Fact extraction failed: ${err instanceof Error ? err.message : err}`);
+        return [];
+    }
+}

package/dist/memory/search.d.ts

@@ -0,0 +1,15 @@
+import type { MemoryStore } from "./store.js";
+import type { EmbeddingProvider } from "./embedding.js";
+export interface SearchOptions {
+    limit?: number;
+    embeddingProvider?: EmbeddingProvider | null;
+    /** Restrict results to memories from this session source. */
+    source?: string;
+    /** When set, returns only team-specific memories. */
+    teamId?: string;
+}
+/**
+ * Hybrid memory search: runs FTS5 keyword search and (optionally) vector
+ * similarity search in parallel, then merges and deduplicates results.
+ */
+export declare function searchMemory(store: MemoryStore, query: string, options?: SearchOptions): Promise<string[]>;

package/dist/memory/search.js

@@ -0,0 +1,57 @@
+import { logger } from "../logger.js";
+const VECTOR_WEIGHT = 0.7;
+const TEXT_WEIGHT = 0.3;
+/**
+ * Hybrid memory search: runs FTS5 keyword search and (optionally) vector
+ * similarity search in parallel, then merges and deduplicates results.
+ */
+export async function searchMemory(store, query, options = {}) {
+    const limit = options.limit ?? 5;
+    try {
+        const { source, teamId } = options;
+        // FTS5 keyword search (always available)
+        const textResults = store.searchByText(query, limit, source, teamId);
+        // Vector search (only if embeddings available)
+        let vectorResults = [];
+        if (options.embeddingProvider && store.hasVectorSearch) {
+            try {
+                const embedding = await options.embeddingProvider.embed(query);
+                if (embedding) {
+                    vectorResults = store.searchByVector(embedding, limit, source, teamId);
+                }
+            }
+            catch (err) {
+                logger.warn(`Vector search failed: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        // Merge and deduplicate
+        const scored = new Map();
+        // Score vector results (higher rank = higher score, inversely proportional to index)
+        for (let i = 0; i < vectorResults.length; i++) {
+            const r = vectorResults[i];
+            const vectorScore = 1 - i / vectorResults.length; // 1.0 → ~0.0
+            scored.set(r.id, { fact: r.fact, score: VECTOR_WEIGHT * vectorScore });
+        }
+        // Score text results and merge
+        for (let i = 0; i < textResults.length; i++) {
+            const r = textResults[i];
+            const textScore = 1 - i / textResults.length;
+            const existing = scored.get(r.id);
+            if (existing) {
+                existing.score += TEXT_WEIGHT * textScore;
+            }
+            else {
+                scored.set(r.id, { fact: r.fact, score: TEXT_WEIGHT * textScore });
+            }
+        }
+        // Sort by combined score, return top N facts
+        return Array.from(scored.values())
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((r) => r.fact);
+    }
+    catch (err) {
+        logger.error(`Memory search error: ${err instanceof Error ? err.message : err}`);
+        return [];
+    }
+}

package/dist/memory/session-learning.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel, ModelMessage } from "ai";
+import type { MemoryStore } from "./store.js";
+import type { EmbeddingProvider } from "./embedding.js";
+export interface LearnSessionMemoriesInput {
+    model: LanguageModel;
+    memoryStore: MemoryStore;
+    embeddingProvider: EmbeddingProvider | null;
+    sessionKey: string;
+    messages: ModelMessage[];
+    teamId?: string;
+    topic?: string;
+}
+export interface LearnSessionMemoriesResult {
+    topic?: string;
+    extracted: number;
+    saved: number;
+    skipped: number;
+    savedFacts: string[];
+}
+/**
+ * Extract and save learnable facts from session messages.
+ */
+export declare function learnSessionMemories(input: LearnSessionMemoriesInput): Promise<LearnSessionMemoriesResult>;

package/dist/memory/session-learning.js

@@ -0,0 +1,55 @@
+import { extractFacts } from "./extractor.js";
+import { saveExplicitMemory } from "./explicit.js";
+const MAX_LEARN_SOURCE_MESSAGES = 40;
+/**
+ * Extract and save learnable facts from session messages.
+ */
+export async function learnSessionMemories(input) {
+    const topic = normalizeTopic(input.topic);
+    const extractedFacts = await extractFacts(input.model, input.messages, {
+        topic,
+        maxMessages: MAX_LEARN_SOURCE_MESSAGES,
+    });
+    if (extractedFacts.length === 0) {
+        return {
+            topic,
+            extracted: 0,
+            saved: 0,
+            skipped: 0,
+            savedFacts: [],
+        };
+    }
+    const savedFacts = [];
+    let skipped = 0;
+    for (const fact of extractedFacts) {
+        try {
+            const result = await saveExplicitMemory(input.memoryStore, input.embeddingProvider, {
+                fact,
+                source: input.sessionKey,
+                teamId: input.teamId,
+            });
+            if (result.saved) {
+                savedFacts.push(result.fact);
+            }
+            else {
+                skipped++;
+            }
+        }
+        catch {
+            skipped++;
+        }
+    }
+    return {
+        topic,
+        extracted: extractedFacts.length,
+        saved: savedFacts.length,
+        skipped,
+        savedFacts,
+    };
+}
+function normalizeTopic(topic) {
+    if (typeof topic !== "string")
+        return undefined;
+    const trimmed = topic.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}