verybot 0.1.3

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/extractor.d.ts

@@ -0,0 +1,6 @@
+import { type LanguageModel, type ModelMessage } from "ai";
+/**
+ * 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[]): Promise<string[]>;

package/dist/memory/extractor.js

@@ -0,0 +1,72 @@
+import { generateText } from "ai";
+import { logger } from "../logger.js";
+const EXTRACTION_PROMPT = `You extract memorable facts from conversations.
+
+Review the conversation and identify facts worth remembering long-term about the user.
+
+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) {
+    // Only look at recent messages (last 10) to avoid redundant extraction
+    const recent = messages.slice(-10);
+    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: EXTRACTION_PROMPT,
+            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/store.d.ts

@@ -0,0 +1,34 @@
+import type { MemoryEntry } from "./types.js";
+export declare class MemoryStore {
+    private db;
+    private vectorEnabled;
+    private vecTableCreated;
+    private constructor();
+    /** Async factory — loads sqlite-vec extension if available. */
+    static create(dbPath: string): Promise<MemoryStore>;
+    get hasVectorSearch(): boolean;
+    private createSchema;
+    /** Add team_id column if it doesn't exist yet (idempotent). */
+    private migrateTeamId;
+    private loadVecExtension;
+    private ensureVecTable;
+    /** Save a memory entry. Returns false if duplicate or near-duplicate fact exists. */
+    save(entry: MemoryEntry): boolean;
+    /** Full-text search using FTS5/BM25. Optionally scoped to a source and/or team. */
+    searchByText(query: string, limit?: number, source?: string, teamId?: string): MemoryEntry[];
+    /** Vector similarity search using sqlite-vec. Optionally scoped to a source and/or team. */
+    searchByVector(embedding: number[], limit?: number, source?: string, teamId?: string): MemoryEntry[];
+    /** Delete a single memory by its ID. Optionally verify team ownership. Returns true if found and deleted. */
+    deleteById(id: string, teamId?: string): boolean;
+    /**
+     * Paginated list of memories for a specific team (or global if teamId is null).
+     * Intended for CRUD management (listing/deleting).
+     */
+    listByTeam(teamId: string | null, limit?: number, offset?: number): {
+        entries: MemoryEntry[];
+        total: number;
+    };
+    /** Delete all memories from a given session source. Returns count deleted. */
+    deleteBySource(source: string): number;
+    close(): void;
+}