lazy-gravity 0.0.4 → 0.2.0

package/dist/utils/antigravityPaths.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAntigravityCliPath = getAntigravityCliPath;
+exports.getAntigravityFallback = getAntigravityFallback;
+exports.getAntigravityCdpHint = getAntigravityCdpHint;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const APP_NAME = 'Antigravity';
+/**
+ * Get the Antigravity CLI binary path for the current platform.
+ *
+ * - macOS: /Applications/Antigravity.app/Contents/Resources/app/bin/antigravity
+ * - Windows: %LOCALAPPDATA%\Programs\Antigravity\Antigravity.exe
+ * - Linux: antigravity (assumed in PATH)
+ */
+function getAntigravityCliPath() {
+    switch (process.platform) {
+        case 'darwin':
+            return '/Applications/Antigravity.app/Contents/Resources/app/bin/antigravity';
+        case 'win32': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+            return path.join(localAppData, 'Programs', APP_NAME, `${APP_NAME}.exe`);
+        }
+        default:
+            return APP_NAME.toLowerCase();
+    }
+}
+/**
+ * Get fallback launch command and args for opening a workspace.
+ *
+ * - macOS: open -a Antigravity <path>
+ * - Windows: use full exe path with shell (handles spaces in paths)
+ * - Linux: antigravity <path>
+ */
+function getAntigravityFallback(workspacePath) {
+    switch (process.platform) {
+        case 'darwin':
+            return { command: 'open', args: ['-a', APP_NAME, workspacePath] };
+        case 'win32': {
+            const exePath = getAntigravityCliPath();
+            return { command: exePath, args: [workspacePath], options: { shell: true } };
+        }
+        default:
+            return { command: APP_NAME.toLowerCase(), args: [workspacePath] };
+    }
+}
+/**
+ * Get a platform-appropriate hint for starting Antigravity with CDP.
+ *
+ * Used in user-facing messages (Discord embeds, CLI doctor, logs).
+ */
+function getAntigravityCdpHint(port = 9222) {
+    switch (process.platform) {
+        case 'darwin':
+            return `open -a ${APP_NAME} --args --remote-debugging-port=${port}`;
+        case 'win32':
+            return `${APP_NAME}.exe --remote-debugging-port=${port}`;
+        default:
+            return `${APP_NAME.toLowerCase()} --remote-debugging-port=${port}`;
+    }
+}

package/dist/utils/configLoader.js

@@ -92,6 +92,8 @@ function mergeConfig(persisted) {
     const workspaceBaseDir = expandTilde(rawDir);
     const guildId = process.env.GUILD_ID ?? persisted.guildId ?? undefined;
     const autoApproveFileEdits = resolveBoolean(process.env.AUTO_APPROVE_FILE_EDITS, persisted.autoApproveFileEdits, false);
+    const logLevel = resolveLogLevel(process.env.LOG_LEVEL, persisted.logLevel);
+    const extractionMode = resolveExtractionMode(process.env.EXTRACTION_MODE, persisted.extractionMode);
     return {
         discordToken: token,
         clientId,
@@ -99,6 +101,8 @@ function mergeConfig(persisted) {
         allowedUserIds,
         workspaceBaseDir,
         autoApproveFileEdits,
+        logLevel,
+        extractionMode,
     };
 }
 function resolveAllowedUserIds(persisted) {
@@ -114,6 +118,20 @@ function resolveAllowedUserIds(persisted) {
     }
     return [];
 }
+const VALID_LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'none'];
+function resolveLogLevel(envValue, persistedValue) {
+    const raw = envValue?.toLowerCase() ?? persistedValue;
+    if (raw && VALID_LOG_LEVELS.includes(raw)) {
+        return raw;
+    }
+    return 'info';
+}
+function resolveExtractionMode(envValue, persistedValue) {
+    const raw = envValue ?? persistedValue;
+    if (raw === 'legacy')
+        return 'legacy';
+    return 'structured';
+}
 function resolveBoolean(envValue, persistedValue, defaultValue) {
     if (envValue !== undefined)
         return envValue.toLowerCase() === 'true';

package/dist/utils/discordButtonUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableAllButtons = disableAllButtons;
+const discord_js_1 = require("discord.js");
+/**
+ * Disable all buttons in message component rows.
+ * Shared utility used by interaction handlers and detector callbacks.
+ */
+function disableAllButtons(components) {
+    return components
+        .map((row) => {
+        const rowAny = row;
+        if (!Array.isArray(rowAny.components))
+            return null;
+        const nextRow = new discord_js_1.ActionRowBuilder();
+        const disabledButtons = rowAny.components
+            .map((component) => {
+            const componentType = component?.type ?? component?.data?.type;
+            if (componentType !== 2)
+                return null;
+            const payload = typeof component?.toJSON === 'function'
+                ? component.toJSON()
+                : component;
+            return discord_js_1.ButtonBuilder.from(payload).setDisabled(true);
+        })
+            .filter((button) => button !== null);
+        if (disabledButtons.length === 0)
+            return null;
+        nextRow.addComponents(...disabledButtons);
+        return nextRow;
+    })
+        .filter((row) => row !== null);
+}

package/dist/utils/discordFormatter.js

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatForDiscord = formatForDiscord;
 exports.splitOutputAndLogs = splitOutputAndLogs;
+exports.separateOutputForDelivery = separateOutputForDelivery;
 exports.sanitizeActivityLines = sanitizeActivityLines;
 /** Known UI chrome literal strings (exact match after trim + lowercase) */
 const UI_CHROME_LITERALS = new Set([
@@ -54,6 +55,9 @@ const UI_CHROME_REGEXES = [
     /^[a-z0-9._-]+\s*\/\s*[a-z0-9._-]+$/i, // MCP server/tool format: "jina-mcp-server / search_web"
     /^full output written to\b/i, // tool result redirect: "Full output written to ..."
     /^output\.[a-z0-9._-]+(?:#l\d+(?:-\d+)?)?$/i, // output file ref: "output.txt#L1-131"
+    /^\s*\{\s*$/, // lone JSON opening brace
+    /^\s*\}\s*$/, // lone JSON closing brace
+    /^\s*"[^"]*"\s*:\s*/, // JSON key-value line: "query": "..."
 ];
 /**
  * Check if a line is UI chrome (not real assistant output).
@@ -71,17 +75,31 @@ function isUiChromeLine(line) {
     }
     return false;
 }
+/** Regex matching file references like src/bot/index.ts:54 or tests/utils/config.ts.
+ *  Consumes one trailing space so the replacement `\`ref\`` doesn't leave a double space. */
+const FILE_REF_REGEX = /(?<![`/\\])(\b[a-zA-Z][\w.-]*(?:\/[\w.-]+)+(?::\d+(?:-\d+)?)?)\s?(?!`)/g;
 /**
  * Format text for Discord Embed display.
  * Wraps table lines and tree lines in code blocks.
+ * Wraps file references (e.g. src/bot/index.ts:54) in inline code backticks.
  */
 function formatForDiscord(text) {
     const lines = text.split('\n');
     const result = [];
     let inSpecialBlock = false;
+    let inCodeBlock = false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const trimmed = line.trim();
+        if (trimmed.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            result.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            result.push(line);
+            continue;
+        }
         const isTableLine = (trimmed.startsWith('|') && trimmed.endsWith('|') && trimmed.length > 2) ||
             /^\|[\s\-:]+\|/.test(trimmed);
         const isTreeLine = /[├└│┌┐┘┤┬┴┼]/.test(line) ||
@@ -99,10 +117,10 @@ function formatForDiscord(text) {
         else if (!isSpecialLine && inSpecialBlock) {
             result.push('```');
             inSpecialBlock = false;
-            result.push(line);
+            result.push(wrapFileReferences(line));
         }
         else {
-            result.push(line);
+            result.push(wrapFileReferences(line));
         }
     }
     if (inSpecialBlock) {
@@ -110,47 +128,162 @@ function formatForDiscord(text) {
     }
     return result.join('\n');
 }
+/**
+ * Wrap file references (e.g. src/bot/index.ts:54) in inline code backticks.
+ */
+function wrapFileReferences(line) {
+    return line.replace(FILE_REF_REGEX, '`$1`');
+}
+/** Check if a line is an MCP tool call format (server / tool_name) */
+function isMcpFormatLine(line) {
+    return /^[a-z0-9._-]+\s*\/\s*[a-z0-9._-]+$/i.test(line);
+}
+/**
+ * Check if a line is a multi-word activity log (e.g. "Analyzing current workspace").
+ * Used only by splitOutputAndLogs — NOT by sanitizeActivityLines, which needs
+ * to keep these lines in the activity log output.
+ */
+function isActivityLogLine(line) {
+    const trimmed = (line || '').trim();
+    if (!trimmed)
+        return false;
+    return /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)\s+.+/i.test(trimmed)
+        && trimmed.length <= 220;
+}
 /**
  * Split raw text into output (real content) and logs (UI chrome).
  * Code blocks are always preserved as output.
+ *
+ * When tool call blocks are detected (MCP format lines), applies a
+ * "last paragraph wins" heuristic: only the final block of non-chrome
+ * text is treated as the assistant's answer; everything between tool
+ * call regions is treated as thinking text and moved to logs.
  */
 function splitOutputAndLogs(rawText) {
     const normalized = (rawText || '').replace(/\r/g, '');
     if (!normalized.trim()) {
         return { output: '', logs: '' };
     }
-    const outputLines = [];
-    const logLines = [];
-    let inCodeBlock = false;
     const lines = normalized.split('\n');
+    const classes = [];
+    let inCodeBlock = false;
     for (const line of lines) {
         const trimmed = (line || '').trim();
         if (trimmed.startsWith('```')) {
             inCodeBlock = !inCodeBlock;
-            outputLines.push(line);
+            classes.push('code');
             continue;
         }
         if (inCodeBlock) {
-            outputLines.push(line);
+            classes.push('code');
             continue;
         }
         if (!trimmed) {
-            outputLines.push(line);
+            classes.push('blank');
             continue;
         }
-        if (isUiChromeLine(trimmed)) {
-            logLines.push(trimmed);
+        if (isUiChromeLine(trimmed) || isActivityLogLine(trimmed)) {
+            classes.push('chrome');
         }
         else {
-            outputLines.push(line);
+            classes.push('output');
+        }
+    }
+    // Check if tool calls are present — triggers "last paragraph wins" heuristic
+    const hasMcpCalls = lines.some((l, i) => classes[i] === 'chrome' && isMcpFormatLine(l.trim()));
+    if (!hasMcpCalls) {
+        // Simple path: no tool calls, line-by-line separation
+        const outputLines = [];
+        const logLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (classes[i] === 'chrome') {
+                logLines.push(lines[i].trim());
+            }
+            else {
+                outputLines.push(lines[i]);
+            }
+        }
+        return {
+            output: collapseBlankLines(outputLines.join('\n')),
+            logs: collapseBlankLines(logLines.join('\n')),
+        };
+    }
+    // Complex path: tool calls present — only the LAST paragraph is output.
+    // Scan bottom-up to find the last non-chrome text line.
+    let lastOutputEnd = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (classes[i] === 'output' || classes[i] === 'code') {
+            lastOutputEnd = i;
+            break;
         }
     }
-    const normalizeText = (text) => text
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
+    if (lastOutputEnd === -1) {
+        // No output lines at all
+        const logLines = lines.filter((_, i) => classes[i] === 'chrome').map((l) => l.trim());
+        return { output: '', logs: collapseBlankLines(logLines.join('\n')) };
+    }
+    // Walk upward from lastOutputEnd to find the start of the final paragraph.
+    // Stop at any blank line or chrome line — in the legacy tool-call path, only
+    // the immediate last paragraph is preserved as output. Multi-paragraph final
+    // answers are handled correctly by the structured extraction mode (Phase 1).
+    let lastOutputStart = lastOutputEnd;
+    for (let i = lastOutputEnd - 1; i >= 0; i--) {
+        if (classes[i] === 'blank' || classes[i] === 'chrome') {
+            break;
+        }
+        if (classes[i] === 'output' || classes[i] === 'code') {
+            lastOutputStart = i;
+        }
+    }
+    const outputLines = [];
+    const logLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (i >= lastOutputStart && i <= lastOutputEnd) {
+            // Inside the final answer block — keep non-chrome lines as output
+            if (classes[i] !== 'chrome') {
+                outputLines.push(lines[i]);
+            }
+            else {
+                logLines.push(lines[i].trim());
+            }
+        }
+        else if (classes[i] === 'chrome' || classes[i] === 'output') {
+            // Outside the final block — chrome or thinking text → logs
+            logLines.push(lines[i].trim());
+        }
+        // blank lines outside the final block are dropped
+    }
+    return {
+        output: collapseBlankLines(outputLines.join('\n')),
+        logs: collapseBlankLines(logLines.join('\n')),
+    };
+}
+/** Collapse 3+ consecutive newlines to 2, and trim */
+function collapseBlankLines(text) {
+    return text.replace(/\n{3,}/g, '\n\n').trim();
+}
+/**
+ * Separate raw text into output and logs, choosing between DOM-structured
+ * extraction and legacy string-based separation.
+ *
+ * When domSource is 'dom-structured', DOM results are used directly.
+ * When domSource is 'legacy-fallback', falls back to splitOutputAndLogs().
+ */
+function separateOutputForDelivery(options) {
+    const { rawText, domSource, domOutputText, domActivityLines } = options;
+    if (domSource === 'dom-structured' && domOutputText !== undefined) {
+        return {
+            source: 'dom-structured',
+            output: domOutputText,
+            logs: (domActivityLines ?? []).join('\n'),
+        };
+    }
+    // Fallback to legacy string-based separation
+    const separated = splitOutputAndLogs(rawText);
     return {
-        output: normalizeText(outputLines.join('\n')),
-        logs: normalizeText(logLines.join('\n')),
+        source: 'legacy-fallback',
+        output: separated.output,
+        logs: separated.logs,
     };
 }
 /**

package/dist/utils/htmlToDiscordMarkdown.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Lightweight HTML-to-Discord-Markdown converter.
+ * Runs on Node.js (no browser DOM required).
+ * Converts common HTML tags to Discord-compatible Markdown.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlToDiscordMarkdown = htmlToDiscordMarkdown;
+/**
+ * Convert an HTML string to Discord-compatible Markdown.
+ *
+ * Supported conversions:
+ * - <h1>-<h3> → # - ###
+ * - <strong>/<b> → **...**
+ * - <em>/<i> → *...*
+ * - <code> → `...`
+ * - <pre><code> → ```\n...\n```
+ * - <ol><li> → 1. item
+ * - <ul><li> → - item
+ * - <p> → \n\n
+ * - <br> → \n
+ * - <span class="context-scope-mention"> → `text`
+ * - Elements with file-path title attribute → title + text
+ * - <style> → removed entirely
+ * - All other tags → stripped, text preserved
+ */
+function htmlToDiscordMarkdown(html) {
+    if (!html)
+        return '';
+    let result = html;
+    // Remove <style> tags and their content
+    result = result.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+    // Handle <br> and <br/>
+    result = result.replace(/<br\s*\/?>/gi, '\n');
+    // Handle <hr>
+    result = result.replace(/<hr\s*\/?>/gi, '\n---\n');
+    // Handle headings (h1-h3)
+    result = result.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, (_m, content) => `\n# ${stripTags(content).trim()}\n`);
+    result = result.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, (_m, content) => `\n## ${stripTags(content).trim()}\n`);
+    result = result.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, (_m, content) => `\n### ${stripTags(content).trim()}\n`);
+    // Handle <pre><code> blocks (must come before inline <code>)
+    // Extract language from class="language-xxx" if present.
+    // Do NOT decode entities here — let the final decodeEntities() handle them
+    // after stripTags() has run, to avoid decoded < > being stripped as tags.
+    result = result.replace(/<pre[^>]*>\s*<code(?:\s+class="language-([^"]*)")?[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/gi, (_m, lang, content) => `\n\`\`\`${lang || ''}\n${content}\n\`\`\`\n`);
+    // Handle inline <code>
+    result = result.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+    // Handle <strong> and <b>
+    result = result.replace(/<(?:strong|b)(?:\s[^>]*)?>((?: |\s|[^<]|<(?!\/(?:strong|b)>))*)<\/(?:strong|b)>/gi, '**$1**');
+    // Handle <em> and <i>
+    result = result.replace(/<(?:em|i)(?:\s[^>]*)?>((?: |\s|[^<]|<(?!\/(?:em|i)>))*)<\/(?:em|i)>/gi, '*$1*');
+    // Handle <span class="context-scope-mention"> → `text`
+    result = result.replace(/<span[^>]*class="[^"]*context-scope-mention[^"]*"[^>]*>([\s\S]*?)<\/span>/gi, (_m, text) => `\`${stripTags(text).trim()}\``);
+    // Handle elements with title attribute containing file paths
+    // e.g. <div title="src/bot/index.ts">:54</div> → src/bot/index.ts:54
+    result = result.replace(/<(?:div|span|a)[^>]*\btitle="([^"]*)"[^>]*>([\s\S]*?)<\/(?:div|span|a)>/gi, (_m, title, text) => {
+        if (looksLikeFilePath(title)) {
+            return `${title}${stripTags(text).trim()}`;
+        }
+        return stripTags(text);
+    });
+    // Handle <p> and <div> BEFORE list processing so <li> content is clean text
+    result = result.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '$1\n\n');
+    result = result.replace(/<div[^>]*>([\s\S]*?)<\/div>/gi, '$1\n');
+    // Handle lists — process innermost first to support nesting.
+    // Loop up to 5 times to peel nested lists from inside out.
+    for (let iteration = 0; iteration < 5; iteration++) {
+        if (!/<(?:ul|ol)\b/i.test(result))
+            break;
+        // Process innermost <ul> (no nested <ul>/<ol> inside)
+        result = result.replace(/<ul[^>]*>((?:(?!<\/?(?:ul|ol)\b)[\s\S])*?)<\/ul>/gi, (_m, content) => {
+            const items = content.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_lm, text) => formatListItem('- ', text));
+            return `\n${items}`;
+        });
+        // Process innermost <ol> (no nested <ul>/<ol> inside)
+        result = result.replace(/<ol[^>]*>((?:(?!<\/?(?:ul|ol)\b)[\s\S])*?)<\/ol>/gi, (_m, content) => {
+            let counter = 0;
+            const items = content.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_lm, text) => {
+                counter++;
+                return formatListItem(`${counter}. `, text);
+            });
+            return `\n${items}`;
+        });
+    }
+    // Strip remaining HTML tags
+    result = stripTags(result);
+    // Decode HTML entities
+    result = decodeEntities(result);
+    // Escape double underscores outside code blocks/inline code to prevent
+    // Discord from interpreting __dirname, __proto__ etc. as underline markup.
+    result = escapeDoubleUnderscores(result);
+    // Clean up excessive whitespace
+    result = result.replace(/\n{3,}/g, '\n\n');
+    result = result.trim();
+    return result;
+}
+/**
+ * Format a list item: strip tags, then indent any lines that are
+ * already-processed nested list items (starting with - or 1.).
+ */
+function formatListItem(prefix, rawContent) {
+    const cleaned = stripTags(rawContent).trim();
+    if (!cleaned)
+        return '';
+    const lines = cleaned.split('\n').filter((l) => l.trim());
+    if (lines.length === 0)
+        return '';
+    // First line gets the bullet prefix
+    const result = [prefix + lines[0]];
+    // Subsequent lines: indent by 2 spaces (nested content)
+    for (let i = 1; i < lines.length; i++) {
+        const trimmed = lines[i].trimStart();
+        // Already a list marker from inner processing — indent it
+        if (/^[-•]/.test(trimmed) || /^\d+\.\s/.test(trimmed)) {
+            result.push('  ' + trimmed);
+        }
+        else if (trimmed.startsWith('```')) {
+            // Code block fence — indent
+            result.push('  ' + trimmed);
+        }
+        else {
+            // Continuation text — indent
+            result.push('  ' + trimmed);
+        }
+    }
+    return result.join('\n') + '\n';
+}
+/** Check if a string looks like a file path */
+function looksLikeFilePath(value) {
+    if (!value)
+        return false;
+    // Must contain at least one / and end with an extension-like pattern
+    return /^[a-zA-Z0-9._\-/]+\.[a-zA-Z0-9]+$/.test(value) && value.includes('/');
+}
+/** Strip all HTML tags from a string */
+function stripTags(html) {
+    return html.replace(/<[^>]+>/g, '');
+}
+/** Decode common HTML entities and generic numeric entities */
+function decodeEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&#x27;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_m, hex) => String.fromCodePoint(parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_m, dec) => String.fromCodePoint(parseInt(dec, 10)));
+}
+/**
+ * Escape double underscores outside code blocks and inline code
+ * to prevent Discord from interpreting them as underline markup.
+ * e.g. __dirname → \_\_dirname
+ */
+function escapeDoubleUnderscores(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let inCodeBlock = false;
+    for (const line of lines) {
+        if (line.trimStart().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            result.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            result.push(line);
+            continue;
+        }
+        // Outside code blocks: escape __ that are NOT inside inline backticks
+        // Split by backtick-delimited segments, only escape outside backticks
+        const parts = line.split(/(`[^`]*`)/g);
+        const escaped = parts.map((part, idx) => {
+            // Odd indices are inside backticks — leave as-is
+            if (idx % 2 === 1)
+                return part;
+            // Even indices are outside backticks — escape __
+            return part.replace(/__/g, '\\_\\_');
+        });
+        result.push(escaped.join(''));
+    }
+    return result.join('\n');
+}

package/dist/utils/logBuffer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBuffer = exports.LogBuffer = void 0;
+const MAX_ENTRIES = 200;
+// Strip ANSI escape codes for clean buffer storage
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_REGEX, '');
+}
+class LogBuffer {
+    buffer = [];
+    head = 0;
+    count = 0;
+    append(level, message) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message: stripAnsi(message),
+        };
+        if (this.count < MAX_ENTRIES) {
+            this.buffer.push(entry);
+            this.count++;
+        }
+        else {
+            this.buffer[this.head] = entry;
+        }
+        this.head = (this.head + 1) % MAX_ENTRIES;
+    }
+    getRecent(count, levelFilter) {
+        const all = [];
+        for (let i = 0; i < this.count; i++) {
+            const idx = (this.head - this.count + i + MAX_ENTRIES * 2) % MAX_ENTRIES;
+            all.push(this.buffer[idx]);
+        }
+        const filtered = levelFilter
+            ? all.filter((e) => e.level === levelFilter)
+            : all;
+        return filtered.slice(-count);
+    }
+    clear() {
+        this.buffer.length = 0;
+        this.head = 0;
+        this.count = 0;
+    }
+}
+exports.LogBuffer = LogBuffer;
+exports.logBuffer = new LogBuffer();