@sambitcreate/parsely-cli 2.0.0 → 2.2.0

package/dist/components/Welcome.js

@@ -1,6 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { Panel } from './Panel.js';
 import { theme } from '../theme.js';
-export function Welcome() {
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingX: 1, children: [_jsx(Text, { color: theme.colors.text, children: "Paste a recipe URL below to extract ingredients and instructions." }), _jsx(Text, { color: theme.colors.muted, children: "Uses browser scraping with AI fallback for best results." })] }));
+export function Welcome({ compact = false, minimal = false }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Panel, { title: minimal ? 'Paste a recipe page to extract the cookable bits.' : 'Turn any recipe page into a clean cooking brief.', eyebrow: "Recipe deck", accentColor: theme.colors.primary, children: _jsx(Text, { color: theme.colors.text, children: minimal
+                        ? 'Parsely pulls out timing, ingredients, and steps without the surrounding clutter.'
+                        : 'Parsely strips away popups, rambling intros, and clutter so you can focus on timing, ingredients, and steps.' }) }), !minimal && (_jsxs(Panel, { title: "What happens next", eyebrow: "Workflow", accentColor: theme.colors.secondary, marginTop: 1, children: [_jsxs(Text, { color: theme.colors.text, children: [theme.symbols.bullet, " Try JSON-LD and other structured recipe markup first."] }), _jsxs(Text, { color: theme.colors.text, children: [theme.symbols.bullet, " Fall back to AI only when the page needs rescue."] }), _jsxs(Text, { color: theme.colors.text, children: [theme.symbols.bullet, " Plate the result in a terminal-friendly cooking layout."] }), !compact && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.muted, children: "Tip: most dedicated recipe sites work immediately if they publish Schema.org metadata." }) }))] }))] }));
 }

package/dist/hooks/useDisplayPalette.d.ts

@@ -0,0 +1 @@
+export declare function useDisplayPalette(color: string): void;

package/dist/hooks/useDisplayPalette.js

@@ -0,0 +1,15 @@
+import { useStdout } from 'ink';
+import { useEffect } from 'react';
+import { resetDefaultTerminalBackground, setDefaultTerminalBackground, shouldUseDisplayPalette, } from '../utils/terminal.js';
+export function useDisplayPalette(color) {
+    const { stdout, write } = useStdout();
+    useEffect(() => {
+        if (!stdout.isTTY || !shouldUseDisplayPalette()) {
+            return;
+        }
+        write(setDefaultTerminalBackground(color));
+        return () => {
+            write(resetDefaultTerminalBackground());
+        };
+    }, [color, stdout, write]);
+}

package/dist/hooks/useTerminalViewport.d.ts

@@ -0,0 +1,6 @@
+interface Viewport {
+    width: number;
+    height: number;
+}
+export declare function useTerminalViewport(): Viewport;
+export {};

package/dist/hooks/useTerminalViewport.js

@@ -0,0 +1,23 @@
+import { useStdout } from 'ink';
+import { useEffect, useState } from 'react';
+function getViewport(stdout) {
+    return {
+        width: stdout.columns ?? 100,
+        height: stdout.rows ?? 32,
+    };
+}
+export function useTerminalViewport() {
+    const { stdout } = useStdout();
+    const [viewport, setViewport] = useState(() => getViewport(stdout));
+    useEffect(() => {
+        const onResize = () => {
+            setViewport(getViewport(stdout));
+        };
+        onResize();
+        stdout.on('resize', onResize);
+        return () => {
+            stdout.off('resize', onResize);
+        };
+    }, [stdout]);
+    return viewport;
+}

package/dist/services/scraper.d.ts

@@ -18,9 +18,17 @@ export interface ScrapeStatus {
     message: string;
     recipe?: Recipe;
 }
+/**
+ * Walk through JSON-LD script blocks and return the first Recipe object found.
+ * Handles direct Recipe type, @graph arrays, and nested lists.
+ */
+export declare function findRecipeJson(scripts: string[]): Record<string, unknown> | null;
+export declare function containsBrowserChallenge(html: string): boolean;
+export declare function normalizeAiRecipe(recipe: Record<string, unknown>): Recipe;
+export declare function extractRecipeFromHtml(html: string): Recipe | null;
 /**
  * Scrape a recipe from the given URL.
  * Tries Puppeteer-based browser scraping first, falls back to OpenAI.
  * Calls `onStatus` with progress updates so the TUI can reflect each phase.
  */
-export declare function scrapeRecipe(url: string, onStatus: (status: ScrapeStatus) => void): Promise<Recipe>;
+export declare function scrapeRecipe(url: string, onStatus: (status: ScrapeStatus) => void, signal?: AbortSignal): Promise<Recipe>;

package/dist/services/scraper.js

@@ -1,9 +1,20 @@
 import puppeteer from 'puppeteer-core';
 import * as cheerio from 'cheerio';
 import OpenAI from 'openai';
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { loadConfig } from '../utils/helpers.js';
+import { constants as fsConstants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import { loadConfig, normalizeRecipeUrl, sanitizeTerminalText } from '../utils/helpers.js';
+const BROWSER_ARGS = [
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-blink-features=AutomationControlled',
+];
+const BROWSER_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
+    '(KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36';
+const PAGE_TIMEOUT_MS = 20_000;
+const NETWORK_IDLE_TIMEOUT_MS = 5_000;
+const AI_TIMEOUT_MS = 30_000;
+const AI_SOURCE_LIMIT = 120_000;
 /* ------------------------------------------------------------------ */
 /*  JSON-LD helpers                                                    */
 /* ------------------------------------------------------------------ */
@@ -11,7 +22,7 @@ import { loadConfig } from '../utils/helpers.js';
  * Walk through JSON-LD script blocks and return the first Recipe object found.
  * Handles direct Recipe type, @graph arrays, and nested lists.
  */
-function findRecipeJson(scripts) {
+export function findRecipeJson(scripts) {
     for (const raw of scripts) {
         let data;
         try {
@@ -43,6 +54,98 @@ function findRecipeJson(scripts) {
     }
     return null;
 }
+export function containsBrowserChallenge(html) {
+    return html.includes('cf_chl') ||
+        html.includes('window._cf_chl_opt') ||
+        html.includes('cf-mitigated');
+}
+function normalizeText(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const $ = cheerio.load(`<body>${sanitizeTerminalText(trimmed)}</body>`);
+    const text = $('body').text().replace(/\s+/g, ' ').trim();
+    return text || undefined;
+}
+function normalizeInstruction(value) {
+    if (typeof value === 'string') {
+        return normalizeText(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const text = normalizeText(value.text);
+    const itemListElement = Array.isArray(value.itemListElement)
+        ? value.itemListElement
+            .map((item) => {
+            const normalized = normalizeText(item?.text);
+            return normalized ? { text: normalized } : null;
+        })
+            .filter((item) => item !== null)
+        : undefined;
+    if (text) {
+        return { text, ...(itemListElement && itemListElement.length > 0 ? { itemListElement } : {}) };
+    }
+    if (itemListElement && itemListElement.length > 0) {
+        return { itemListElement };
+    }
+    return undefined;
+}
+function normalizeInstructions(value) {
+    if (Array.isArray(value)) {
+        const steps = value
+            .map((step) => normalizeInstruction(step))
+            .filter((step) => Boolean(step));
+        return steps.length > 0 ? steps : undefined;
+    }
+    const single = normalizeInstruction(value);
+    return single ? [single] : undefined;
+}
+function normalizeRecipePayload(recipe, source) {
+    const recipeIngredient = Array.isArray(recipe.recipeIngredient)
+        ? recipe.recipeIngredient
+            .map((item) => normalizeText(item))
+            .filter((item) => Boolean(item))
+        : undefined;
+    return {
+        name: normalizeText(recipe.name),
+        prepTime: typeof recipe.prepTime === 'string' ? sanitizeTerminalText(recipe.prepTime.trim()) : undefined,
+        cookTime: typeof recipe.cookTime === 'string' ? sanitizeTerminalText(recipe.cookTime.trim()) : undefined,
+        totalTime: typeof recipe.totalTime === 'string' ? sanitizeTerminalText(recipe.totalTime.trim()) : undefined,
+        recipeIngredient,
+        recipeInstructions: normalizeInstructions(recipe.recipeInstructions),
+        source,
+    };
+}
+function normalizeBrowserRecipe(recipe) {
+    return normalizeRecipePayload(recipe, 'browser');
+}
+export function normalizeAiRecipe(recipe) {
+    return normalizeRecipePayload(recipe, 'ai');
+}
+function hasRecipeContent(recipe) {
+    return Boolean(recipe.name ||
+        recipe.prepTime ||
+        recipe.cookTime ||
+        recipe.totalTime ||
+        recipe.recipeIngredient?.length ||
+        recipe.recipeInstructions?.length);
+}
+export function extractRecipeFromHtml(html) {
+    const $ = cheerio.load(html);
+    const scripts = [];
+    $('script[type="application/ld+json"]').each((_index, element) => {
+        const text = $(element).text();
+        if (text)
+            scripts.push(text);
+    });
+    const recipe = findRecipeJson(scripts);
+    return recipe ? normalizeBrowserRecipe(recipe) : null;
+}
 /* ------------------------------------------------------------------ */
 /*  Chrome detection                                                   */
 /* ------------------------------------------------------------------ */
@@ -54,86 +157,203 @@ const CHROME_PATHS = [
     '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
     '/Applications/Chromium.app/Contents/MacOS/Chromium',
 ];
-function findChrome() {
-    // Check well-known paths
-    for (const p of CHROME_PATHS) {
-        if (existsSync(p))
-            return p;
+async function findChrome() {
+    const candidates = [
+        process.env['PUPPETEER_EXECUTABLE_PATH'],
+        process.env['CHROME_PATH'],
+        ...CHROME_PATHS,
+    ].filter((path) => Boolean(path));
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, fsConstants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next well-known location.
+        }
+    }
+    return null;
+}
+function createAbortError() {
+    const error = new Error('Scrape aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError();
     }
-    // Try `which`
+}
+async function configurePage(page) {
+    await page.setUserAgent(BROWSER_USER_AGENT);
+    await page.setExtraHTTPHeaders({ 'accept-language': 'en-US,en;q=0.9' });
+    await page.evaluateOnNewDocument(() => {
+        Object.defineProperty(navigator, 'webdriver', { get: () => false });
+        Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+        Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3] });
+    });
+}
+function createTimedSignal(signal, timeoutMs) {
+    const controller = new AbortController();
+    if (signal?.aborted) {
+        controller.abort();
+    }
+    const onAbort = () => controller.abort();
+    signal?.addEventListener('abort', onAbort, { once: true });
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', onAbort);
+        },
+    };
+}
+function formatTimeoutError(message, signal) {
+    return signal?.aborted ? createAbortError() : new Error(message);
+}
+function limitAiSource(value) {
+    return value.trim().slice(0, AI_SOURCE_LIMIT);
+}
+async function fetchAiSource(url, signal) {
+    throwIfAborted(signal);
+    const { signal: timedSignal, cleanup } = createTimedSignal(signal, PAGE_TIMEOUT_MS);
     try {
-        const result = execSync('which chromium-browser || which chromium || which google-chrome 2>/dev/null', { encoding: 'utf-8' }).trim();
-        if (result)
-            return result;
+        const response = await fetch(url, {
+            headers: {
+                'accept-language': 'en-US,en;q=0.9',
+                'user-agent': BROWSER_USER_AGENT,
+            },
+            signal: timedSignal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to load recipe page for AI fallback (${response.status})`);
+        }
+        return limitAiSource(await response.text());
+    }
+    catch (error) {
+        if (timedSignal.aborted) {
+            throw formatTimeoutError('Timed out loading recipe page for AI fallback', signal);
+        }
+        throw error;
+    }
+    finally {
+        cleanup();
     }
-    catch { /* not found */ }
-    return null;
 }
 /* ------------------------------------------------------------------ */
 /*  Scraping strategies                                                */
 /* ------------------------------------------------------------------ */
-async function scrapeWithBrowser(url) {
-    const chromePath = findChrome();
+async function scrapeWithBrowser(url, onStatus, signal) {
+    throwIfAborted(signal);
+    const chromePath = await findChrome();
     if (!chromePath)
-        return null; // No browser available – skip to AI
+        return { recipe: null }; // No browser available – skip to AI
     let browser = null;
+    let settledHtml;
+    const onAbort = async () => {
+        if (browser) {
+            try {
+                await browser.close();
+            }
+            catch {
+                // Ignore close errors when aborting.
+            }
+        }
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
     try {
         browser = await puppeteer.launch({
             headless: true,
             executablePath: chromePath,
-            args: ['--no-sandbox', '--disable-setuid-sandbox'],
+            args: BROWSER_ARGS,
         });
+        throwIfAborted(signal);
         const page = await browser.newPage();
-        await page.goto(url, { waitUntil: 'networkidle2', timeout: 10_000 });
+        await configurePage(page);
+        onStatus?.({ phase: 'browser', message: 'Loading recipe page…' });
+        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: PAGE_TIMEOUT_MS });
+        await page.waitForNetworkIdle({ idleTime: 500, timeout: NETWORK_IDLE_TIMEOUT_MS }).catch(() => undefined);
+        throwIfAborted(signal);
         const html = await page.content();
-        await browser.close();
-        browser = null;
-        const $ = cheerio.load(html);
-        const scripts = [];
-        $('script[type="application/ld+json"]').each((_i, el) => {
-            const text = $(el).text();
-            if (text)
-                scripts.push(text);
-        });
-        const recipe = findRecipeJson(scripts);
-        if (!recipe)
-            return null;
-        return { ...recipe, source: 'browser' };
+        if (containsBrowserChallenge(html)) {
+            onStatus?.({ phase: 'browser', message: 'Browser challenge detected, retrying page parsing…' });
+            await page.waitForFunction(() => !document.documentElement.outerHTML.includes('cf_chl'), { timeout: 5_000 }).catch(() => undefined);
+        }
+        throwIfAborted(signal);
+        settledHtml = await page.content();
+        onStatus?.({ phase: 'parsing', message: 'Scanning recipe schema and JSON-LD blocks…' });
+        return {
+            recipe: extractRecipeFromHtml(settledHtml),
+            html: settledHtml,
+        };
     }
-    catch {
+    catch (error) {
+        if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+            throw createAbortError();
+        }
+        onStatus?.({ phase: 'browser', message: 'Browser extraction failed. Preparing AI fallback…' });
+        return { recipe: null, html: settledHtml };
+    }
+    finally {
+        signal?.removeEventListener('abort', onAbort);
         if (browser) {
             try {
                 await browser.close();
             }
-            catch { /* noop */ }
+            catch {
+                // Ignore close errors during teardown.
+            }
         }
-        return null;
     }
 }
-async function scrapeWithAI(url) {
+async function scrapeWithAI(url, pageSource, signal) {
+    throwIfAborted(signal);
     const { openaiApiKey } = loadConfig();
     if (!openaiApiKey || openaiApiKey === 'YOUR_API_KEY_HERE') {
         throw new Error('OpenAI API key not found. Create a .env.local file with OPENAI_API_KEY=your_key');
     }
     const client = new OpenAI({ apiKey: openaiApiKey });
-    const response = await client.chat.completions.create({
-        model: 'gpt-4o-mini',
-        messages: [
-            {
-                role: 'system',
-                content: 'You are a recipe scraper. Extract cookTime, prepTime, totalTime, ' +
-                    'recipeIngredient, and recipeInstructions from the provided URL. ' +
-                    'Return the data in a valid JSON object.',
-            },
-            { role: 'user', content: `Scrape this recipe: ${url}` },
-        ],
-        response_format: { type: 'json_object' },
-    });
+    const { signal: timedSignal, cleanup } = createTimedSignal(signal, AI_TIMEOUT_MS);
+    let response;
+    try {
+        response = await client.chat.completions.create({
+            model: 'gpt-4o-mini',
+            messages: [
+                {
+                    role: 'system',
+                    content: 'You extract recipe data from supplied page content. Use only the provided page content. ' +
+                        'Return a JSON object with optional name, prepTime, cookTime, totalTime, recipeIngredient, and recipeInstructions fields.',
+                },
+                {
+                    role: 'user',
+                    content: `Recipe URL: ${url}\n\n` +
+                        'Page content:\n' +
+                        pageSource,
+                },
+            ],
+            response_format: { type: 'json_object' },
+        }, { signal: timedSignal });
+    }
+    catch (error) {
+        if (timedSignal.aborted) {
+            throw formatTimeoutError('AI recipe extraction timed out', signal);
+        }
+        throw error;
+    }
+    finally {
+        cleanup();
+    }
     const content = response.choices[0]?.message?.content;
     if (!content)
         throw new Error('AI returned empty response');
-    const recipe = JSON.parse(content);
-    return { ...recipe, source: 'ai' };
+    const recipe = normalizeAiRecipe(JSON.parse(content));
+    if (!hasRecipeContent(recipe)) {
+        throw new Error('AI could not extract recipe data from the page');
+    }
+    return recipe;
 }
 /* ------------------------------------------------------------------ */
 /*  Public orchestrator                                                */
@@ -143,22 +363,34 @@ async function scrapeWithAI(url) {
  * Tries Puppeteer-based browser scraping first, falls back to OpenAI.
  * Calls `onStatus` with progress updates so the TUI can reflect each phase.
  */
-export async function scrapeRecipe(url, onStatus) {
+export async function scrapeRecipe(url, onStatus, signal) {
+    const normalizedUrl = normalizeRecipeUrl(url);
+    if (!normalizedUrl) {
+        const error = new Error('Invalid URL. Please enter a valid http or https recipe URL.');
+        onStatus({ phase: 'error', message: error.message });
+        throw error;
+    }
     // Phase 1 – browser scraping
     onStatus({ phase: 'browser', message: 'Launching browser\u2026' });
-    const browserResult = await scrapeWithBrowser(url);
-    if (browserResult) {
-        onStatus({ phase: 'done', message: 'Recipe found!', recipe: browserResult });
-        return browserResult;
+    const browserResult = await scrapeWithBrowser(normalizedUrl, onStatus, signal);
+    if (browserResult.recipe) {
+        onStatus({ phase: 'done', message: 'Recipe found!', recipe: browserResult.recipe });
+        return browserResult.recipe;
     }
     // Phase 2 – AI fallback
     onStatus({ phase: 'ai', message: 'Falling back to AI scraper\u2026' });
     try {
-        const aiResult = await scrapeWithAI(url);
+        const pageSource = browserResult.html && browserResult.html.trim()
+            ? limitAiSource(browserResult.html)
+            : await fetchAiSource(normalizedUrl, signal);
+        const aiResult = await scrapeWithAI(normalizedUrl, pageSource, signal);
         onStatus({ phase: 'done', message: 'Recipe extracted via AI!', recipe: aiResult });
         return aiResult;
     }
     catch (error) {
+        if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+            throw createAbortError();
+        }
         const message = error instanceof Error ? error.message : 'Unknown error occurred';
         onStatus({ phase: 'error', message });
         throw error;

package/dist/theme.d.ts

@@ -1,31 +1,91 @@
-/**
- * Parsely CLI theme - color palette and symbols for the TUI.
- * Inspired by OpenCode's semantic theming approach.
- */
-export declare const theme: {
-    readonly colors: {
-        readonly primary: "#00d4aa";
-        readonly secondary: "#ff6b9d";
-        readonly accent: "#ffd93d";
-        readonly text: "#e0e0e0";
-        readonly muted: "#6272a4";
-        readonly error: "#ff5555";
-        readonly success: "#50fa7b";
-        readonly warning: "#f1fa8c";
-        readonly info: "#8be9fd";
-        readonly banner: "#50fa7b";
-        readonly border: "#6272a4";
-        readonly borderFocus: "#00d4aa";
-        readonly label: "#bd93f9";
+export type ThemeMode = 'light' | 'dark';
+declare const themes: {
+    readonly light: {
+        readonly mode: "light";
+        readonly colors: {
+            readonly brand: "#009c3f";
+            readonly primary: "#0aa043";
+            readonly secondary: "#ffbf69";
+            readonly accent: "#ff7f50";
+            readonly text: "#17311d";
+            readonly muted: "#5f7564";
+            readonly subtle: "#7a8b7a";
+            readonly error: "#c24141";
+            readonly success: "#0aa043";
+            readonly warning: "#b7791f";
+            readonly info: "#2563eb";
+            readonly banner: "#009c3f";
+            readonly border: "#b7cbb3";
+            readonly borderFocus: "#0aa043";
+            readonly label: "#b7791f";
+            readonly chip: "#e4efe0";
+            readonly recipePaper: "#FDFFF7";
+            readonly recipeText: "#0aa043";
+            readonly recipeMuted: "#5f7564";
+            readonly recipeSubtle: "#43684b";
+            readonly recipeBorder: "#0aa043";
+            readonly recipeSoft: "#dcead5";
+            readonly recipePanel: "#f7fbef";
+        };
+        readonly symbols: {
+            readonly bullet: "•";
+            readonly arrow: "→";
+            readonly check: "✓";
+            readonly cross: "✗";
+            readonly dot: "·";
+            readonly ellipsis: "…";
+            readonly line: "─";
+            readonly active: "◉";
+            readonly pending: "○";
+            readonly skip: "−";
+        };
     };
-    readonly symbols: {
-        readonly bullet: "•";
-        readonly arrow: "→";
-        readonly check: "✓";
-        readonly cross: "✗";
-        readonly dot: "·";
-        readonly ellipsis: "…";
-        readonly line: "─";
+    readonly dark: {
+        readonly mode: "dark";
+        readonly colors: {
+            readonly brand: "#009c3f";
+            readonly primary: "#86c06c";
+            readonly secondary: "#ffbf69";
+            readonly accent: "#ff7f50";
+            readonly text: "#e7eef8";
+            readonly muted: "#97a3b0";
+            readonly subtle: "#64748b";
+            readonly error: "#ff7b7b";
+            readonly success: "#7bd389";
+            readonly warning: "#ffd166";
+            readonly info: "#6ec5ff";
+            readonly banner: "#e7eef8";
+            readonly border: "#2c394d";
+            readonly borderFocus: "#86c06c";
+            readonly label: "#ffbf69";
+            readonly chip: "#192132";
+            readonly recipePaper: "#0F1729";
+            readonly recipeText: "#8de58b";
+            readonly recipeMuted: "#b7c2d4";
+            readonly recipeSubtle: "#8b99ad";
+            readonly recipeBorder: "#009c3f";
+            readonly recipeSoft: "#2b3c34";
+            readonly recipePanel: "#111b30";
+        };
+        readonly symbols: {
+            readonly bullet: "•";
+            readonly arrow: "→";
+            readonly check: "✓";
+            readonly cross: "✗";
+            readonly dot: "·";
+            readonly ellipsis: "…";
+            readonly line: "─";
+            readonly active: "◉";
+            readonly pending: "○";
+            readonly skip: "−";
+        };
     };
 };
-export type Theme = typeof theme;
+export type Theme = (typeof themes)[ThemeMode];
+export declare function resolveInitialThemeMode(env?: NodeJS.ProcessEnv): ThemeMode;
+export declare function detectPreferredThemeMode(env?: NodeJS.ProcessEnv): Promise<ThemeMode>;
+export declare function getTheme(mode: ThemeMode): Theme;
+export declare function setActiveTheme(mode: ThemeMode): Theme;
+export declare function toggleThemeMode(mode: ThemeMode): ThemeMode;
+export declare const theme: Theme;
+export {};