npm - @sambitcreate/parsely-cli - Versions diffs - 2.1.0 → 2.3.0 - Mend

@sambitcreate/parsely-cli 2.1.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/README.md +21 -7
package/dist/app.js +45 -10
package/dist/cli.js +13 -3
package/dist/components/Banner.d.ts +1 -1
package/dist/components/Footer.d.ts +2 -2
package/dist/components/Footer.js +5 -1
package/dist/components/LandingScreen.d.ts +2 -1
package/dist/components/LandingScreen.js +13 -5
package/dist/components/LoadingScreen.js +0 -2
package/dist/components/PhaseRail.d.ts +1 -1
package/dist/components/RecipeCard.d.ts +2 -1
package/dist/components/RecipeCard.js +135 -18
package/dist/components/URLInput.d.ts +2 -1
package/dist/components/URLInput.js +30 -7
package/dist/services/scraper.d.ts +1 -0
package/dist/services/scraper.js +174 -63
package/dist/theme.d.ts +88 -41
package/dist/theme.js +122 -40
package/dist/utils/helpers.d.ts +3 -0
package/dist/utils/helpers.js +18 -0
package/dist/utils/shortcuts.d.ts +6 -0
package/dist/utils/shortcuts.js +15 -0
package/dist/utils/terminal.js +51 -2
package/dist/utils/text-layout.d.ts +1 -0
package/dist/utils/text-layout.js +63 -0
package/package.json +5 -5

package/dist/services/scraper.d.ts CHANGED Viewed

@@ -24,6 +24,7 @@ export interface ScrapeStatus {
  */
 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.

package/dist/services/scraper.js CHANGED Viewed

@@ -1,16 +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';
+    '(KHTML, like Gecko) Chrome/146.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                                                    */
 /* ------------------------------------------------------------------ */
@@ -63,7 +67,7 @@ function normalizeText(value) {
     if (!trimmed) {
         return undefined;
     }
-    const $ = cheerio.load(`<body>${trimmed}</body>`);
+    const $ = cheerio.load(`<body>${sanitizeTerminalText(trimmed)}</body>`);
     const text = $('body').text().replace(/\s+/g, ' ').trim();
     return text || undefined;
 }
@@ -91,27 +95,46 @@ function normalizeInstruction(value) {
     }
     return undefined;
 }
-function normalizeBrowserRecipe(recipe) {
+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;
-    const recipeInstructions = Array.isArray(recipe.recipeInstructions)
-        ? recipe.recipeInstructions
-            .map((step) => normalizeInstruction(step))
-            .filter((step) => Boolean(step))
-        : undefined;
     return {
         name: normalizeText(recipe.name),
-        prepTime: typeof recipe.prepTime === 'string' ? recipe.prepTime.trim() : undefined,
-        cookTime: typeof recipe.cookTime === 'string' ? recipe.cookTime.trim() : undefined,
-        totalTime: typeof recipe.totalTime === 'string' ? recipe.totalTime.trim() : undefined,
+        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,
-        source: 'browser',
+        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 = [];
@@ -134,19 +157,21 @@ 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;
-    }
-    // Try `which`
-    try {
-        const result = execSync('which chromium-browser || which chromium || which google-chrome 2>/dev/null', { encoding: 'utf-8' }).trim();
-        if (result)
-            return result;
+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.
+        }
     }
-    catch { /* not found */ }
     return null;
 }
 function createAbortError() {
@@ -165,18 +190,71 @@ async function configurePage(page) {
     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] });
+        Object.defineProperty(navigator, 'plugins', {
+            get: () => Object.assign([{}, {}, {}], { length: 3, refresh: () => { } }),
+        });
     });
 }
+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 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();
+    }
+}
 /* ------------------------------------------------------------------ */
 /*  Scraping strategies                                                */
 /* ------------------------------------------------------------------ */
 async function scrapeWithBrowser(url, onStatus, signal) {
     throwIfAborted(signal);
-    const chromePath = findChrome();
+    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 {
@@ -198,8 +276,8 @@ async function scrapeWithBrowser(url, onStatus, signal) {
         const page = await browser.newPage();
         await configurePage(page);
         onStatus?.({ phase: 'browser', message: 'Loading recipe page…' });
-        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 20_000 });
-        await page.waitForNetworkIdle({ idleTime: 500, timeout: 5_000 }).catch(() => undefined);
+        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();
         if (containsBrowserChallenge(html)) {
@@ -207,53 +285,77 @@ async function scrapeWithBrowser(url, onStatus, signal) {
             await page.waitForFunction(() => !document.documentElement.outerHTML.includes('cf_chl'), { timeout: 5_000 }).catch(() => undefined);
         }
         throwIfAborted(signal);
-        const settledHtml = await page.content();
+        settledHtml = await page.content();
         onStatus?.({ phase: 'parsing', message: 'Scanning recipe schema and JSON-LD blocks…' });
-        await browser.close();
-        browser = null;
-        return extractRecipeFromHtml(settledHtml);
+        return {
+            recipe: extractRecipeFromHtml(settledHtml),
+            html: settledHtml,
+        };
     }
     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;
-    }
-    finally {
-        signal?.removeEventListener('abort', onAbort);
     }
 }
-async function scrapeWithAI(url, signal) {
+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' },
-    }, { signal });
+    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                                                */
@@ -264,17 +366,26 @@ async function scrapeWithAI(url, signal) {
  * Calls `onStatus` with progress updates so the TUI can reflect each phase.
  */
 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, onStatus, signal);
-    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, signal);
+        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;
     }

package/dist/theme.d.ts CHANGED Viewed

@@ -1,44 +1,91 @@
-/**
- * Parsely CLI theme - color palette and symbols for the TUI.
- * Tuned for a warm, food-forward terminal UI.
- */
-export declare const theme: {
-    readonly colors: {
-        readonly brand: "#009c3f";
-        readonly primary: "#86c06c";
-        readonly secondary: "#ffbf69";
-        readonly accent: "#ff7f50";
-        readonly text: "#f6f2ea";
-        readonly muted: "#97a3b0";
-        readonly subtle: "#536170";
-        readonly error: "#ff6b6b";
-        readonly success: "#7bd389";
-        readonly warning: "#ffd166";
-        readonly info: "#6ec5ff";
-        readonly banner: "#f6f2ea";
-        readonly border: "#3a4654";
-        readonly borderFocus: "#86c06c";
-        readonly label: "#ffbf69";
-        readonly chip: "#24303b";
-        readonly recipePaper: "#FDFFF7";
-        readonly recipeText: "#0aa043";
-        readonly recipeMuted: "#8b9689";
-        readonly recipeSubtle: "#5f7564";
-        readonly recipeBorder: "#0aa043";
-        readonly recipeSoft: "#dcead5";
-        readonly recipePanel: "#f7fbef";
+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 active: "◉";
-        readonly pending: "○";
-        readonly skip: "−";
+    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 {};

package/dist/theme.js CHANGED Viewed

@@ -1,43 +1,125 @@
-/**
- * Parsely CLI theme - color palette and symbols for the TUI.
- * Tuned for a warm, food-forward terminal UI.
- */
-export const theme = {
-    colors: {
-        brand: '#009c3f',
-        primary: '#86c06c',
-        secondary: '#ffbf69',
-        accent: '#ff7f50',
-        text: '#f6f2ea',
-        muted: '#97a3b0',
-        subtle: '#536170',
-        error: '#ff6b6b',
-        success: '#7bd389',
-        warning: '#ffd166',
-        info: '#6ec5ff',
-        banner: '#f6f2ea',
-        border: '#3a4654',
-        borderFocus: '#86c06c',
-        label: '#ffbf69',
-        chip: '#24303b',
-        recipePaper: '#FDFFF7',
-        recipeText: '#0aa043',
-        recipeMuted: '#8b9689',
-        recipeSubtle: '#5f7564',
-        recipeBorder: '#0aa043',
-        recipeSoft: '#dcead5',
-        recipePanel: '#f7fbef',
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const symbols = {
+    bullet: '\u2022',
+    arrow: '\u2192',
+    check: '\u2713',
+    cross: '\u2717',
+    dot: '\u00B7',
+    ellipsis: '\u2026',
+    line: '\u2500',
+    active: '\u25c9',
+    pending: '\u25cb',
+    skip: '\u2212',
+};
+const themes = {
+    light: {
+        mode: 'light',
+        colors: {
+            brand: '#009c3f',
+            primary: '#0aa043',
+            secondary: '#ffbf69',
+            accent: '#ff7f50',
+            text: '#17311d',
+            muted: '#5f7564',
+            subtle: '#7a8b7a',
+            error: '#c24141',
+            success: '#0aa043',
+            warning: '#b7791f',
+            info: '#2563eb',
+            banner: '#009c3f',
+            border: '#b7cbb3',
+            borderFocus: '#0aa043',
+            label: '#b7791f',
+            chip: '#e4efe0',
+            recipePaper: '#FDFFF7',
+            recipeText: '#0aa043',
+            recipeMuted: '#5f7564',
+            recipeSubtle: '#43684b',
+            recipeBorder: '#0aa043',
+            recipeSoft: '#dcead5',
+            recipePanel: '#f7fbef',
+        },
+        symbols,
     },
-    symbols: {
-        bullet: '\u2022',
-        arrow: '\u2192',
-        check: '\u2713',
-        cross: '\u2717',
-        dot: '\u00B7',
-        ellipsis: '\u2026',
-        line: '\u2500',
-        active: '\u25c9',
-        pending: '\u25cb',
-        skip: '\u2212',
+    dark: {
+        mode: 'dark',
+        colors: {
+            brand: '#009c3f',
+            primary: '#86c06c',
+            secondary: '#ffbf69',
+            accent: '#ff7f50',
+            text: '#e7eef8',
+            muted: '#97a3b0',
+            subtle: '#64748b',
+            error: '#ff7b7b',
+            success: '#7bd389',
+            warning: '#ffd166',
+            info: '#6ec5ff',
+            banner: '#e7eef8',
+            border: '#2c394d',
+            borderFocus: '#86c06c',
+            label: '#ffbf69',
+            chip: '#192132',
+            recipePaper: '#0F1729',
+            recipeText: '#8de58b',
+            recipeMuted: '#b7c2d4',
+            recipeSubtle: '#8b99ad',
+            recipeBorder: '#009c3f',
+            recipeSoft: '#2b3c34',
+            recipePanel: '#111b30',
+        },
+        symbols,
     },
 };
+function inferThemeModeFromColorEnv(env) {
+    const colorfgbg = env['COLORFGBG'];
+    if (!colorfgbg) {
+        return null;
+    }
+    const backgroundCode = Number.parseInt(colorfgbg.split(';').at(-1) ?? '', 10);
+    if (!Number.isFinite(backgroundCode)) {
+        return null;
+    }
+    return backgroundCode <= 6 || backgroundCode === 8 ? 'dark' : 'light';
+}
+export function resolveInitialThemeMode(env = process.env) {
+    const override = env['PARSELY_THEME'];
+    if (override === 'light' || override === 'dark') {
+        return override;
+    }
+    return inferThemeModeFromColorEnv(env) ?? 'light';
+}
+export async function detectPreferredThemeMode(env = process.env) {
+    const initial = resolveInitialThemeMode(env);
+    if (env['PARSELY_THEME'] === 'light' || env['PARSELY_THEME'] === 'dark' || env['COLORFGBG']) {
+        return initial;
+    }
+    if (process.platform !== 'darwin') {
+        return initial;
+    }
+    try {
+        const { stdout } = await execFileAsync('defaults', ['read', '-g', 'AppleInterfaceStyle']);
+        return stdout.trim() === 'Dark' ? 'dark' : 'light';
+    }
+    catch {
+        return initial;
+    }
+}
+let activeTheme = themes[resolveInitialThemeMode()];
+export function getTheme(mode) {
+    return themes[mode];
+}
+export function setActiveTheme(mode) {
+    activeTheme = themes[mode];
+    return activeTheme;
+}
+export function toggleThemeMode(mode) {
+    return mode === 'dark' ? 'light' : 'dark';
+}
+export const theme = new Proxy({}, {
+    get(_target, property) {
+        return activeTheme[property];
+    },
+});