verybot 0.1.3

package/dist/logger.js

@@ -0,0 +1,104 @@
+import winston from "winston";
+import Transport from "winston-transport";
+const { combine, timestamp, printf, colorize } = winston.format;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+// ANSI escape codes
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const GREEN = "\x1b[32m";
+const BOLD = "\x1b[1m";
+// Map raw level names to message colors
+const MESSAGE_COLORS = {
+    error: RED,
+    warn: YELLOW,
+};
+// Detect user message lines: "  [user] ..." (from loop.ts role logging)
+const USER_MSG_RE = /^(.*)\[user\]\s+(.*)$/s;
+const logFormat = printf(({ level, message, timestamp }) => {
+    // strip ANSI from level to get raw name for color lookup
+    const rawLevel = level.replace(ANSI_RE, "");
+    const msg = String(message);
+    // Highlight user messages in bold green
+    const userMatch = msg.match(USER_MSG_RE);
+    if (userMatch) {
+        const [, prefix, body] = userMatch;
+        return `${DIM}${timestamp}${RESET} [${level}] ${prefix}${BOLD}${GREEN}[user]${RESET} ${GREEN}${body}${RESET}`;
+    }
+    const msgColor = MESSAGE_COLORS[rawLevel] ?? "";
+    const msgReset = msgColor ? RESET : "";
+    return `${DIM}${timestamp}${RESET} [${level}] ${msgColor}${msg}${msgReset}`;
+});
+// --------------- Ring buffer for UI log streaming ---------------
+const LOG_BUFFER_SIZE = 500;
+/** Pattern sources for secrets — fresh RegExp per call to avoid /g lastIndex state. */
+const SENSITIVE_PATTERN_SOURCES = [
+    { source: "Bearer\\s+[A-Za-z0-9\\-._~+/]+=*", flags: "g" },
+    { source: "token=[A-Za-z0-9\\-._~+/]+", flags: "gi" },
+    { source: "(?:api[_-]?key|secret|password|credential)[\\s=:]+\\S+", flags: "gi" },
+    // Common API key prefixes (OpenAI, Anthropic, GitHub, Stripe, etc.)
+    { source: "(?:sk|pk)[-_][A-Za-z0-9\\-._]{20,}", flags: "g" },
+    { source: "ghp_[A-Za-z0-9]{36}", flags: "g" },
+    // Connection strings with embedded passwords
+    { source: "[a-z]+://[^:]+:[^@]+@", flags: "gi" },
+];
+function redactSensitive(msg) {
+    let out = msg;
+    for (const { source, flags } of SENSITIVE_PATTERN_SOURCES) {
+        out = out.replace(new RegExp(source, flags), "[REDACTED]");
+    }
+    return out;
+}
+const logBuffer = new Array(LOG_BUFFER_SIZE);
+let ringHead = 0; // next write index
+let ringCount = 0; // total entries in buffer
+const logSubscribers = new Set();
+/**
+ * Register a subscriber for real-time log entries.
+ * Returns an unsubscribe function.
+ */
+export function addLogSubscriber(cb) {
+    logSubscribers.add(cb);
+    return () => { logSubscribers.delete(cb); };
+}
+/** Return a snapshot of the current log buffer in chronological order. */
+export function getLogBuffer() {
+    if (ringCount === 0)
+        return [];
+    if (ringCount < LOG_BUFFER_SIZE)
+        return logBuffer.slice(0, ringCount);
+    // Buffer is full — oldest entry starts at ringHead
+    return [...logBuffer.slice(ringHead), ...logBuffer.slice(0, ringHead)];
+}
+/**
+ * Custom Winston transport that feeds the ring buffer and notifies
+ * subscribed UI clients only.
+ */
+class UiBroadcastTransport extends Transport {
+    log(info, next) {
+        const raw = String(info.message).replace(ANSI_RE, "");
+        const entry = {
+            ts: info.timestamp ?? new Date().toISOString(),
+            level: info.level.replace(ANSI_RE, ""),
+            message: redactSensitive(raw),
+        };
+        // Ring buffer: O(1) insert via index wrapping
+        logBuffer[ringHead] = entry;
+        ringHead = (ringHead + 1) % LOG_BUFFER_SIZE;
+        if (ringCount < LOG_BUFFER_SIZE)
+            ringCount++;
+        for (const cb of logSubscribers)
+            cb(entry);
+        next();
+    }
+}
+// ----------------------------------------------------------------
+export const logger = winston.createLogger({
+    level: process.env.LOG_LEVEL ?? "info",
+    format: combine(timestamp({ format: "HH:mm:ss" }), colorize(), logFormat),
+    transports: [
+        new winston.transports.Console(),
+        new UiBroadcastTransport(),
+    ],
+});

package/dist/markdown/chunk.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple text chunker for splitting outbound messages into platform-sized pieces.
+ * Simple text chunker — only the core chunkText function.
+ */
+/**
+ * Split text into chunks up to `limit` characters.
+ * Prefers breaking at newlines, then whitespace, then hard-splits.
+ */
+export declare function chunkText(text: string, limit: number): string[];

package/dist/markdown/chunk.js

@@ -0,0 +1,52 @@
+/**
+ * Simple text chunker for splitting outbound messages into platform-sized pieces.
+ * Simple text chunker — only the core chunkText function.
+ */
+/**
+ * Split text into chunks up to `limit` characters.
+ * Prefers breaking at newlines, then whitespace, then hard-splits.
+ */
+export function chunkText(text, limit) {
+    if (!text) {
+        return [];
+    }
+    if (limit <= 0) {
+        return [text];
+    }
+    if (text.length <= limit) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit);
+        // 1) Prefer a newline break inside the window.
+        let breakIdx = window.lastIndexOf("\n");
+        // 2) Otherwise prefer the last whitespace (word boundary).
+        if (breakIdx <= 0) {
+            for (let i = window.length - 1; i >= 0; i--) {
+                if (/\s/.test(window[i])) {
+                    breakIdx = i;
+                    break;
+                }
+            }
+        }
+        // 3) Fallback: hard break exactly at the limit.
+        if (breakIdx <= 0) {
+            breakIdx = limit;
+        }
+        const rawChunk = remaining.slice(0, breakIdx);
+        const chunk = rawChunk.trimEnd();
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        // If we broke on whitespace/newline, skip that separator.
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        remaining = remaining.slice(nextStart).trimStart();
+    }
+    if (remaining.length) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}

package/dist/markdown/ir.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Markdown Intermediate Representation (IR) parser.
+ * Markdown IR parser — standalone with no external deps
+ * beyond markdown-it.
+ */
+/** How to render tables: off = ignore, bullets = key/value list, code = ASCII table. */
+export type MarkdownTableMode = "off" | "bullets" | "code";
+export type MarkdownStyle = "bold" | "italic" | "strikethrough" | "code" | "code_block" | "spoiler";
+export type MarkdownStyleSpan = {
+    start: number;
+    end: number;
+    style: MarkdownStyle;
+};
+export type MarkdownLinkSpan = {
+    start: number;
+    end: number;
+    href: string;
+};
+export type MarkdownIR = {
+    text: string;
+    styles: MarkdownStyleSpan[];
+    links: MarkdownLinkSpan[];
+};
+export type MarkdownParseOptions = {
+    linkify?: boolean;
+    enableSpoilers?: boolean;
+    headingStyle?: "none" | "bold";
+    blockquotePrefix?: string;
+    autolink?: boolean;
+    tableMode?: MarkdownTableMode;
+};
+export declare function markdownToIR(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
+export declare function markdownToIRWithMeta(markdown: string, options?: MarkdownParseOptions): {
+    ir: MarkdownIR;
+    hasTables: boolean;
+};
+export declare function chunkMarkdownIR(ir: MarkdownIR, limit: number): MarkdownIR[];