@steipete/oracle 1.1.0 → 1.2.0

package/dist/src/browser/actions/modelSelection.js

@@ -9,7 +9,8 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
     const result = outcome.result?.value;
     switch (result?.status) {
         case 'already-selected':
-        case 'switched': {
+        case 'switched':
+        case 'switched-best-effort': {
             const label = result.label ?? desiredModel;
             logger(`Model picker: ${label}`);
             return;
@@ -24,18 +25,26 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
         }
     }
 }
+/**
+ * Builds the DOM expression that runs inside the ChatGPT tab to select a model.
+ * The string is evaluated inside Chrome, so keep it self-contained and well-commented.
+ */
 function buildModelSelectionExpression(targetModel) {
     const matchers = buildModelMatchersLiteral(targetModel);
     const labelLiteral = JSON.stringify(matchers.labelTokens);
     const idLiteral = JSON.stringify(matchers.testIdTokens);
+    const primaryLabelLiteral = JSON.stringify(targetModel);
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     return `(() => {
+    // Capture the selectors and matcher literals up front so the browser expression stays pure.
     const BUTTON_SELECTOR = '${MODEL_BUTTON_SELECTOR}';
     const LABEL_TOKENS = ${labelLiteral};
     const TEST_IDS = ${idLiteral};
-    const CLICK_INTERVAL_MS = 50;
-    const MAX_WAIT_MS = 12000;
+    const PRIMARY_LABEL = ${primaryLabelLiteral};
+    const INITIAL_WAIT_MS = 150;
+    const REOPEN_INTERVAL_MS = 400;
+    const MAX_WAIT_MS = 20000;
     const normalizeText = (value) => {
       if (!value) {
         return '';
@@ -46,6 +55,12 @@ function buildModelSelectionExpression(targetModel) {
         .replace(/\\s+/g, ' ')
         .trim();
     };
+    // Normalize every candidate token to keep fuzzy matching deterministic.
+    const normalizedTarget = normalizeText(PRIMARY_LABEL);
+    const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
+      .map((token) => normalizeText(token))
+      .filter(Boolean);
+    const targetWords = normalizedTarget.split(' ').filter(Boolean);
 
     const button = document.querySelector(BUTTON_SELECTOR);
     if (!button) {
@@ -54,6 +69,7 @@ function buildModelSelectionExpression(targetModel) {
 
     let lastPointerClick = 0;
     const pointerClick = () => {
+      // Some menus ignore synthetic click events.
       const down = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
       const up = new PointerEvent('pointerup', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
       const click = new MouseEvent('click', { bubbles: true });
@@ -86,64 +102,109 @@ function buildModelSelectionExpression(targetModel) {
       return false;
     };
 
-    const findOption = () => {
+    const scoreOption = (normalizedText, testid) => {
+      // Assign a score to every node so we can pick the most likely match without brittle equality checks.
+      if (!normalizedText && !testid) {
+        return 0;
+      }
+      let score = 0;
+      const normalizedTestId = (testid ?? '').toLowerCase();
+      if (normalizedTestId && TEST_IDS.some((id) => normalizedTestId.includes(id))) {
+        score += 1000;
+      }
+      if (normalizedText && normalizedTarget) {
+        if (normalizedText === normalizedTarget) {
+          score += 500;
+        } else if (normalizedText.startsWith(normalizedTarget)) {
+          score += 420;
+        } else if (normalizedText.includes(normalizedTarget)) {
+          score += 380;
+        }
+      }
+      for (const token of normalizedTokens) {
+        // Reward partial matches to the expanded label/token set.
+        if (token && normalizedText.includes(token)) {
+          const tokenWeight = Math.min(120, Math.max(10, token.length * 4));
+          score += tokenWeight;
+        }
+      }
+      if (targetWords.length > 1) {
+        let missing = 0;
+        for (const word of targetWords) {
+          if (!normalizedText.includes(word)) {
+            missing += 1;
+          }
+        }
+        score -= missing * 12;
+      }
+      return Math.max(score, 0);
+    };
+
+    const findBestOption = () => {
+      // Walk through every menu item and keep whichever earns the highest score.
+      let bestMatch = null;
       const menus = Array.from(document.querySelectorAll(${menuContainerLiteral}));
       for (const menu of menus) {
         const buttons = Array.from(menu.querySelectorAll(${menuItemLiteral}));
         for (const option of buttons) {
-          const testid = (option.getAttribute('data-testid') ?? '').toLowerCase();
           const text = option.textContent ?? '';
           const normalizedText = normalizeText(text);
-          const matchesTestId = testid && TEST_IDS.some((id) => testid.includes(id));
-          const matchesText = LABEL_TOKENS.some((token) => {
-            const normalizedToken = normalizeText(token);
-            if (!normalizedToken) {
-              return false;
-            }
-            return normalizedText.includes(normalizedToken);
-          });
-          if (matchesTestId || matchesText) {
-            return option;
+          const testid = option.getAttribute('data-testid') ?? '';
+          const score = scoreOption(normalizedText, testid);
+          if (score <= 0) {
+            continue;
+          }
+          const label = getOptionLabel(option);
+          if (!bestMatch || score > bestMatch.score) {
+            bestMatch = { node: option, label, score };
           }
         }
       }
-      return null;
+      return bestMatch;
     };
 
-    pointerClick();
     return new Promise((resolve) => {
       const start = performance.now();
       const ensureMenuOpen = () => {
         const menuOpen = document.querySelector('[role="menu"], [data-radix-collection-root]');
-        if (!menuOpen && performance.now() - lastPointerClick > 300) {
+        if (!menuOpen && performance.now() - lastPointerClick > REOPEN_INTERVAL_MS) {
           pointerClick();
         }
       };
-      const attempt = () => {
+
+      // Open once and wait a tick before first scan.
+      pointerClick();
+      const openDelay = () => new Promise((r) => setTimeout(r, INITIAL_WAIT_MS));
+      let initialized = false;
+      const attempt = async () => {
+        if (!initialized) {
+          initialized = true;
+          await openDelay();
+        }
         ensureMenuOpen();
-        const option = findOption();
-        if (option) {
-          if (optionIsSelected(option)) {
-            resolve({ status: 'already-selected', label: getOptionLabel(option) });
+        const match = findBestOption();
+        if (match) {
+          if (optionIsSelected(match.node)) {
+            resolve({ status: 'already-selected', label: match.label });
             return;
           }
-          option.click();
-          resolve({ status: 'switched', label: getOptionLabel(option) });
+          match.node.click();
+          resolve({ status: 'switched', label: match.label });
           return;
         }
         if (performance.now() - start > MAX_WAIT_MS) {
           resolve({ status: 'option-not-found' });
           return;
         }
-        if (performance.now() - lastPointerClick > 500) {
-          pointerClick();
-        }
-        setTimeout(attempt, CLICK_INTERVAL_MS);
+        setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
       };
       attempt();
     });
   })()`;
 }
+export function buildModelMatchersLiteralForTest(targetModel) {
+    return buildModelMatchersLiteral(targetModel);
+}
 function buildModelMatchersLiteral(targetModel) {
     const base = targetModel.trim().toLowerCase();
     const labelTokens = new Set();
@@ -164,6 +225,28 @@ function buildModelMatchersLiteral(targetModel) {
     push(`chatgpt ${dotless}`, labelTokens);
     push(`gpt ${base}`, labelTokens);
     push(`gpt ${dotless}`, labelTokens);
+    // Numeric variations (5.1 ↔ 51 ↔ gpt-5-1)
+    if (base.includes('5.1') || base.includes('5-1') || base.includes('51')) {
+        push('5.1', labelTokens);
+        push('gpt-5.1', labelTokens);
+        push('gpt5.1', labelTokens);
+        push('gpt-5-1', labelTokens);
+        push('gpt5-1', labelTokens);
+        push('gpt51', labelTokens);
+        push('chatgpt 5.1', labelTokens);
+        testIdTokens.add('gpt-5-1');
+        testIdTokens.add('gpt5-1');
+        testIdTokens.add('gpt51');
+    }
+    // Pro / research variants
+    if (base.includes('pro')) {
+        push('proresearch', labelTokens);
+        push('research grade', labelTokens);
+        push('advanced reasoning', labelTokens);
+        testIdTokens.add('gpt-5-pro');
+        testIdTokens.add('pro');
+        testIdTokens.add('proresearch');
+    }
     base
         .split(/\s+/)
         .map((token) => token.trim())
@@ -175,8 +258,10 @@ function buildModelMatchersLiteral(targetModel) {
     push(hyphenated, testIdTokens);
     push(collapsed, testIdTokens);
     push(dotless, testIdTokens);
+    // data-testid values observed in the ChatGPT picker (e.g., model-switcher-gpt-5-pro)
     push(`model-switcher-${hyphenated}`, testIdTokens);
     push(`model-switcher-${collapsed}`, testIdTokens);
+    push(`model-switcher-${dotless}`, testIdTokens);
     if (!labelTokens.size) {
         labelTokens.add(base);
     }
@@ -188,3 +273,6 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens: Array.from(testIdTokens).filter(Boolean),
     };
 }
+export function buildModelSelectionExpressionForTest(targetModel) {
+    return buildModelSelectionExpression(targetModel);
+}

package/dist/src/browser/cookies.js

@@ -177,7 +177,7 @@ async function attemptSqliteRebuild() {
     }
     attemptedSqliteRebuild = true;
     if (process.env.ORACLE_ALLOW_SQLITE_REBUILD !== '1') {
-        console.warn('[oracle] sqlite3 bindings missing. Set ORACLE_ALLOW_SQLITE_REBUILD=1 if you want Oracle to attempt an automatic rebuild, or run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root` manually.');
+        console.warn('[oracle] sqlite3 bindings missing. Set ORACLE_ALLOW_SQLITE_REBUILD=1 if you want oracle to attempt an automatic rebuild, or run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root` manually.');
         return false;
     }
     const pnpmCommand = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';

package/dist/src/browser/index.js

@@ -64,6 +64,7 @@ export async function runBrowserMode(options) {
         await Promise.all(domainEnablers);
         await Network.clearBrowserCookies();
         if (config.cookieSync) {
+            logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; approve it to stay signed in or rerun with --browser-no-cookie-sync / --browser-allow-cookie-errors.');
             const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, config.allowCookieErrors ?? false);
             logger(cookieCount > 0
                 ? `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
@@ -155,7 +156,7 @@ export async function runBrowserMode(options) {
             logger(`Chrome window closed before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
-        throw new Error('Chrome window closed before Oracle finished. Please keep it open until completion.', {
+        throw new Error('Chrome window closed before oracle finished. Please keep it open until completion.', {
             cause: normalizedError,
         });
     }

package/dist/src/browser/prompt.js

@@ -1,14 +1,14 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { readFiles, createFileSections, DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from '../oracle.js';
+import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS } from '../oracle.js';
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
     const files = await readFilesFn(runOptions.file ?? [], { cwd });
     const basePrompt = (runOptions.prompt ?? '').trim();
     const userPrompt = basePrompt;
-    const systemPrompt = runOptions.system?.trim() || DEFAULT_SYSTEM_PROMPT;
+    const systemPrompt = runOptions.system?.trim() || '';
     const sections = createFileSections(files, cwd);
     const lines = ['[SYSTEM]', systemPrompt, '', '[USER]', userPrompt, ''];
     sections.forEach((section) => {
@@ -43,7 +43,8 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             sizeBytes: Buffer.byteLength(section.content, 'utf8'),
         }));
     const MAX_BROWSER_ATTACHMENTS = 10;
-    if (!inlineFiles && attachments.length > MAX_BROWSER_ATTACHMENTS) {
+    const shouldBundle = !inlineFiles && (runOptions.browserBundleFiles || attachments.length > MAX_BROWSER_ATTACHMENTS);
+    if (shouldBundle) {
         const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-browser-bundle-'));
         const bundlePath = path.join(bundleDir, 'attachments-bundle.txt');
         const bundleLines = [];
@@ -57,7 +58,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         attachments.length = 0;
         attachments.push({
             path: bundlePath,
-            displayPath: 'attachments-bundle.txt',
+            displayPath: bundlePath,
             sizeBytes: Buffer.byteLength(bundleText, 'utf8'),
         });
     }
@@ -81,7 +82,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         attachments,
         inlineFileCount,
         tokenEstimateIncludesInlineFiles,
-        bundled: !inlineFiles && attachments.length === 1 && sections.length > MAX_BROWSER_ATTACHMENTS && attachments[0]?.displayPath
+        bundled: shouldBundle && attachments.length === 1 && attachments[0]?.displayPath
             ? { originalCount: sections.length, bundlePath: attachments[0].displayPath }
             : null,
     };

package/dist/src/browser/sessionRunner.js

@@ -16,14 +16,14 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             const attachmentList = promptArtifacts.attachments.map((attachment) => attachment.displayPath).join(', ');
             log(chalk.dim(`[verbose] Browser attachments: ${attachmentList}`));
             if (promptArtifacts.bundled) {
-                log(chalk.yellow(`[browser] More than 10 files provided; bundled ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath} to satisfy ChatGPT upload limits.`));
+                log(chalk.yellow(`[browser] Bundled ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath}.`));
             }
         }
         else if (runOptions.file && runOptions.file.length > 0 && runOptions.browserInlineFiles) {
             log(chalk.dim('[verbose] Browser inline file fallback enabled (pasting file contents).'));
         }
     }
-    const headerLine = `Oracle (${cliVersion}) launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens`;
+    const headerLine = `oracle (${cliVersion}) launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens`;
     const automationLogger = ((message) => {
         if (typeof message === 'string') {
             log(message);
@@ -56,6 +56,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         log(browserResult.answerMarkdown || browserResult.answerText || chalk.dim('(no text output)'));
         log('');
     }
+    const answerText = browserResult.answerMarkdown || browserResult.answerText || '';
     const usage = {
         inputTokens: promptArtifacts.estimatedInputTokens,
         outputTokens: browserResult.answerTokens,
@@ -76,5 +77,6 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromePort: browserResult.chromePort,
             userDataDir: browserResult.userDataDir,
         },
+        answerText,
     };
 }

package/dist/src/cli/dryRun.js

@@ -40,20 +40,56 @@ async function runBrowserDryRun({ runOptions, cwd, version, log, }, deps) {
     const suffix = buildTokenEstimateSuffix(artifacts);
     const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
-    logBrowserFileSummary(artifacts, log);
+    logBrowserFileSummary(artifacts, log, 'dry-run');
 }
-function logBrowserFileSummary(artifacts, log) {
+function logBrowserFileSummary(artifacts, log, label) {
     if (artifacts.attachments.length > 0) {
-        log(chalk.bold('[dry-run] Attachments to upload:'));
+        const prefix = artifacts.bundled ? `[${label}] Bundled upload:` : `[${label}] Attachments to upload:`;
+        log(chalk.bold(prefix));
         artifacts.attachments.forEach((attachment) => {
             log(`  • ${formatAttachmentLabel(attachment)}`);
         });
+        if (artifacts.bundled) {
+            log(chalk.dim(`  (bundled ${artifacts.bundled.originalCount} files into ${artifacts.bundled.bundlePath})`));
+        }
         return;
     }
     if (artifacts.inlineFileCount > 0) {
-        log(chalk.bold('[dry-run] Inline file content:'));
+        log(chalk.bold(`[${label}] Inline file content:`));
         log(`  • ${artifacts.inlineFileCount} file${artifacts.inlineFileCount === 1 ? '' : 's'} pasted directly into the composer.`);
         return;
     }
-    log(chalk.dim('[dry-run] No files attached.'));
+    log(chalk.dim(`[${label}] No files attached.`));
+}
+export async function runBrowserPreview({ runOptions, cwd, version, previewMode, log, }, deps = {}) {
+    const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
+    const artifacts = await assemblePromptImpl(runOptions, { cwd });
+    const suffix = buildTokenEstimateSuffix(artifacts);
+    const headerLine = `[preview] Oracle (${version}) browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+    log(chalk.cyan(headerLine));
+    logBrowserFileSummary(artifacts, log, 'preview');
+    if (previewMode === 'json' || previewMode === 'full') {
+        const attachmentSummary = artifacts.attachments.map((attachment) => ({
+            path: attachment.path,
+            displayPath: attachment.displayPath,
+            sizeBytes: attachment.sizeBytes,
+        }));
+        const previewPayload = {
+            model: runOptions.model,
+            engine: 'browser',
+            composerText: artifacts.composerText,
+            attachments: attachmentSummary,
+            inlineFileCount: artifacts.inlineFileCount,
+            bundled: artifacts.bundled,
+            tokenEstimate: artifacts.estimatedInputTokens,
+        };
+        log('');
+        log(chalk.bold('Preview JSON'));
+        log(JSON.stringify(previewPayload, null, 2));
+    }
+    if (previewMode === 'full') {
+        log('');
+        log(chalk.bold('Composer Text'));
+        log(artifacts.composerText || chalk.dim('(empty prompt)'));
+    }
 }

package/dist/src/cli/engine.js

@@ -1,3 +1,10 @@
+export function defaultWaitPreference(model, engine) {
+    // gpt-5-pro (API) can take up to 10 minutes; default to non-blocking
+    if (engine === 'api' && model === 'gpt-5-pro') {
+        return false;
+    }
+    return true; // browser or gpt-5.1 are fast enough to block by default
+}
 /**
  * Determine which engine to use based on CLI flags and the environment.
  *

package/dist/src/cli/help.js

@@ -47,7 +47,7 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet('•')} Oracle starts empty—open with a short project briefing (stack, services, build steps), spell out the question and prior attempts, and why it matters; the more explanation and context you provide, the better the response will be.`,
         `${colors.bullet('•')} Oracle is one-shot: it does not remember prior runs, so start fresh each time with full context.`,
         `${colors.bullet('•')} Run ${colors.accent('--files-report')} to inspect token spend before hitting the API.`,
-        `${colors.bullet('•')} Non-preview runs spawn detached sessions so they keep streaming even if your terminal closes — reattach anytime via ${colors.accent('pnpm oracle session <slug>')}.`,
+        `${colors.bullet('•')} Non-preview runs spawn detached sessions (especially gpt-5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,
         `${colors.bullet('•')} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,
         `${colors.bullet('•')} Finished sessions auto-hide preamble logs when reattached; raw timestamps remain in the saved log file.`,
         `${colors.bullet('•')} Need hidden flags? Run ${colors.accent(`${program.name()} --help --verbose`)} to list search/token/browser overrides.`,

package/dist/src/cli/hiddenAliases.js

@@ -0,0 +1,17 @@
+/**
+ * Normalize hidden alias flags so they behave like their primary counterparts.
+ *
+ * - `--message` maps to `--prompt` when no prompt is provided.
+ * - `--include` extends the `--file` list.
+ */
+export function applyHiddenAliases(options, setOptionValue) {
+    if (options.include && options.include.length > 0) {
+        const mergedFiles = [...(options.file ?? []), ...options.include];
+        options.file = mergedFiles;
+        setOptionValue?.('file', mergedFiles);
+    }
+    if (!options.prompt && options.message) {
+        options.prompt = options.message;
+        setOptionValue?.('prompt', options.message);
+    }
+}

package/dist/src/cli/markdownRenderer.js

@@ -1,4 +1,82 @@
+import chalk from 'chalk';
 import { render as renderMarkdown } from 'markdansi';
+import { bundledLanguages, bundledThemes, createHighlighter, } from 'shiki';
+const DEFAULT_THEME = 'github-dark';
+const HIGHLIGHT_LANGS = ['ts', 'tsx', 'js', 'jsx', 'json', 'swift'];
+const SUPPORTED_LANG_ALIASES = {
+    ts: 'ts',
+    typescript: 'ts',
+    tsx: 'tsx',
+    js: 'js',
+    javascript: 'js',
+    jsx: 'jsx',
+    json: 'json',
+    swift: 'swift',
+};
+const shikiPromise = createHighlighter({
+    themes: [bundledThemes[DEFAULT_THEME]],
+    langs: HIGHLIGHT_LANGS.map((lang) => bundledLanguages[lang]),
+});
+let shiki = null;
+void shikiPromise
+    .then((instance) => {
+    shiki = instance;
+})
+    .catch(() => {
+    shiki = null;
+});
+export async function ensureShikiReady() {
+    if (shiki)
+        return;
+    try {
+        shiki = await shikiPromise;
+    }
+    catch {
+        shiki = null;
+    }
+}
+function normalizeLanguage(lang) {
+    if (!lang)
+        return null;
+    const key = lang.toLowerCase();
+    return SUPPORTED_LANG_ALIASES[key] ?? null;
+}
+function styleToken(text, fontStyle = 0) {
+    let styled = text;
+    if (fontStyle & 1)
+        styled = chalk.italic(styled);
+    if (fontStyle & 2)
+        styled = chalk.bold(styled);
+    if (fontStyle & 4)
+        styled = chalk.underline(styled);
+    if (fontStyle & 8)
+        styled = chalk.strikethrough(styled);
+    return styled;
+}
+function shikiHighlighter(code, lang) {
+    if (!process.stdout.isTTY || !shiki)
+        return code;
+    const normalizedLang = normalizeLanguage(lang);
+    if (!normalizedLang)
+        return code;
+    try {
+        if (!shiki.getLoadedLanguages().includes(normalizedLang)) {
+            return code;
+        }
+        const { tokens } = shiki.codeToTokens(code, { lang: normalizedLang, theme: DEFAULT_THEME });
+        return tokens
+            .map((line) => line
+            .map((token) => {
+            const colored = token.color ? chalk.hex(token.color)(token.content) : token.content;
+            return styleToken(colored, token.fontStyle);
+        })
+            .join(''))
+            .join('\n');
+    }
+    catch {
+        return code;
+    }
+}
 export function renderMarkdownAnsi(markdown) {
     try {
         const color = Boolean(process.stdout.isTTY);
@@ -9,6 +87,7 @@ export function renderMarkdownAnsi(markdown) {
             width,
             wrap: true,
             hyperlinks,
+            highlighter: color ? shikiHighlighter : undefined,
         });
     }
     catch {