@sambitcreate/parsely-cli 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# Parsely CLI
+
+A smart, interactive recipe scraper for the terminal. Parsely extracts structured recipe data (ingredients, instructions, cook times) from any recipe URL using headless Chrome with an intelligent AI fallback.
+
+Built with [Ink](https://github.com/vadimdemedes/ink) (React for CLIs) for a rich, responsive terminal UI.
+
+## Features
+
+- **Interactive TUI** — Full terminal interface built with Ink and React, featuring bordered panels, spinners, and color-coded output.
+- **Browser Scraping** — Headless Chrome via Puppeteer extracts Schema.org JSON-LD data from recipe pages, handling JavaScript-rendered content.
+- **AI Fallback** — Automatically switches to OpenAI `gpt-4o-mini` when browser scraping can't find recipe data.
+- **Structured Output** — Displays prep time, cook time, total time, ingredients, and step-by-step instructions in a clean card layout.
+- **Keyboard-Driven** — Context-aware keybind hints in the footer; press `n` for a new recipe or `q` to quit.
+
+## Preview
+
+![Parsely CLI Screenshot](screenshot.png)
+
+## Project Structure
+
+```
+parsely-cli/
+├── src/
+│   ├── cli.tsx              # Entry point — arg parsing, renders <App>
+│   ├── app.tsx              # Root component — state machine (idle → scraping → display)
+│   ├── theme.ts             # Color palette and symbols
+│   ├── components/
+│   │   ├── Banner.tsx       # ASCII art header
+│   │   ├── URLInput.tsx     # URL text input with validation
+│   │   ├── RecipeCard.tsx   # Recipe display card (times, ingredients, instructions)
+│   │   ├── ScrapingStatus.tsx # Spinner with phase updates
+│   │   ├── Footer.tsx       # Context-aware keybind hints
+│   │   ├── Welcome.tsx      # Welcome message
+│   │   └── ErrorDisplay.tsx # Error panel
+│   ├── services/
+│   │   └── scraper.ts       # Puppeteer + OpenAI scraping logic
+│   └── utils/
+│       └── helpers.ts       # ISO duration parser, config, URL validation
+├── package.json
+├── tsconfig.json
+├── run.sh                   # Quick-start launcher script
+├── .env.local               # Your OpenAI API key (create this)
+├── CLAUDE.md                # AI assistant context
+├── CODE_OF_CONDUCT.md
+└── LICENSE
+```
+
+## Setup
+
+### Prerequisites
+
+- **Node.js** v18 or later
+- **npm** v9 or later
+
+### Installation
+
+1. **Clone the repository:**
+
+   ```bash
+   git clone <your-repository-url>
+   cd parsely-cli
+   ```
+
+2. **Install dependencies:**
+
+   ```bash
+   npm install
+   ```
+
+   Uses `puppeteer-core` — no Chromium download. The CLI auto-detects system Chrome/Chromium. If none is found, browser scraping is skipped and the AI fallback is used.
+
+3. **Configure AI fallback (optional but recommended):**
+
+   Create a `.env.local` file in the project root:
+
+   ```
+   OPENAI_API_KEY="your_openai_api_key_here"
+   ```
+
+   Without this, the AI fallback will not function — browser scraping will still work for most recipe sites.
+
+## Usage
+
+### Quick Start
+
+```bash
+./run.sh
+```
+
+The launcher script installs dependencies automatically on first run, then starts the TUI.
+
+### With a URL Argument
+
+```bash
+npm start -- https://www.simplyrecipes.com/recipes/perfect_guacamole/
+```
+
+Or via the run script:
+
+```bash
+./run.sh https://www.simplyrecipes.com/recipes/perfect_guacamole/
+```
+
+### Interactive Mode
+
+Run without arguments and enter a URL when prompted:
+
+```bash
+npm start
+```
+
+### Keyboard Shortcuts
+
+| Key      | Context  | Action            |
+| -------- | -------- | ----------------- |
+| `Enter`  | Input    | Submit URL        |
+| `n`      | Display  | Scrape new recipe |
+| `q`      | Display  | Quit              |
+| `Ctrl+C` | Anywhere | Exit              |
+
+## How It Works
+
+1. **Browser Scraping** — Puppeteer launches headless Chrome, navigates to the URL, and extracts `<script type="application/ld+json">` blocks. The first Schema.org `Recipe` object found is parsed and displayed.
+
+2. **AI Fallback** — If the browser fails or no JSON-LD recipe is found, the URL is sent to OpenAI's `gpt-4o-mini` with a structured extraction prompt. The model returns recipe data as JSON.
+
+3. **Display** — Recipe data is rendered in a bordered card with color-coded sections for times, ingredients, and instructions.
+
+## Architecture
+
+The TUI is built with **Ink** (React for the terminal) following patterns inspired by [OpenCode](https://github.com/anomalyco/opencode):
+
+- **Component-based architecture** — Each UI element is an isolated React component.
+- **State machine** — The app cycles through phases: `idle` → `scraping` → `display` (or `error`).
+- **Theme system** — Centralized color palette in `theme.ts` for consistent styling.
+- **Context-aware footer** — Keybind hints update based on the current phase.
+- **Callback-driven progress** — The scraper reports phase changes to the TUI via callbacks so the spinner updates in real time.
+
+## Troubleshooting
+
+- **`Error: OpenAI API key not found`** — Create a `.env.local` file with your API key. The AI fallback requires this, but browser scraping works without it.
+- **Browser scraping skipped** — The CLI auto-detects system Chrome/Chromium. If none is found, it skips browser scraping and uses the AI fallback. Install Chrome or Chromium to enable browser scraping.
+- **No recipe found** — Some sites use non-standard recipe markup. The AI fallback handles most of these, but results depend on the OpenAI model's ability to extract the recipe.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Code of Conduct
+
+See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).

package/dist/app.d.ts

@@ -0,0 +1,5 @@
+interface AppProps {
+    initialUrl?: string;
+}
+export declare function App({ initialUrl }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { Banner } from './components/Banner.js';
+import { URLInput } from './components/URLInput.js';
+import { RecipeCard } from './components/RecipeCard.js';
+import { ScrapingStatus } from './components/ScrapingStatus.js';
+import { Footer } from './components/Footer.js';
+import { Welcome } from './components/Welcome.js';
+import { ErrorDisplay } from './components/ErrorDisplay.js';
+import { scrapeRecipe } from './services/scraper.js';
+import { theme } from './theme.js';
+export function App({ initialUrl }) {
+    const { exit } = useApp();
+    const [phase, setPhase] = useState(initialUrl ? 'scraping' : 'idle');
+    const [recipe, setRecipe] = useState(null);
+    const [scrapeStatus, setScrapeStatus] = useState(null);
+    const [error, setError] = useState('');
+    const handleScrape = useCallback(async (url) => {
+        setPhase('scraping');
+        setError('');
+        setScrapeStatus({ phase: 'browser', message: 'Starting\u2026' });
+        try {
+            const result = await scrapeRecipe(url, (status) => {
+                setScrapeStatus(status);
+            });
+            setRecipe(result);
+            setPhase('display');
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to scrape recipe');
+            setPhase('error');
+        }
+    }, []);
+    const handleNewRecipe = useCallback(() => {
+        setPhase('idle');
+        setRecipe(null);
+        setError('');
+        setScrapeStatus(null);
+    }, []);
+    // Scrape the initial URL if provided via CLI argument
+    useEffect(() => {
+        if (initialUrl) {
+            handleScrape(initialUrl);
+        }
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    // Global keybinds – only active during the display phase so they
+    // do not interfere with the text input in idle/error phases.
+    useInput((input, key) => {
+        if (phase === 'display') {
+            if (input === 'n')
+                handleNewRecipe();
+            if (input === 'q')
+                exit();
+        }
+        // Ctrl+C is handled by Ink automatically
+        if (key.escape) {
+            if (phase === 'display')
+                exit();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Banner, {}), _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'idle' && (_jsxs(_Fragment, { children: [_jsx(Welcome, {}), _jsx(URLInput, { onSubmit: handleScrape })] })), phase === 'scraping' && scrapeStatus && (_jsx(ScrapingStatus, { status: scrapeStatus })), phase === 'display' && recipe && (_jsxs(_Fragment, { children: [_jsx(RecipeCard, { recipe: recipe }), _jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { bold: true, color: theme.colors.success, children: [theme.symbols.check, " Recipe parsed successfully!"] }) })] })), phase === 'error' && (_jsxs(_Fragment, { children: [_jsx(ErrorDisplay, { message: error }), _jsx(URLInput, { onSubmit: handleScrape })] }))] }), _jsx(Footer, { phase: phase })] }));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './app.js';
+// Simple arg parsing – accept an optional recipe URL as the first positional arg
+const args = process.argv.slice(2);
+const url = args.find((a) => !a.startsWith('-'));
+// Handle --help / -h
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+  Parsely CLI — Smart recipe scraper
+
+  USAGE
+    parsely [url]
+
+  ARGUMENTS
+    url   Optional recipe URL to scrape immediately
+
+  EXAMPLES
+    parsely
+    parsely https://www.simplyrecipes.com/recipes/perfect_guacamole/
+
+  The CLI scrapes recipe data using headless Chrome with an
+  AI fallback (OpenAI gpt-4o-mini). Create a .env.local file
+  with OPENAI_API_KEY=your_key to enable the AI fallback.
+`);
+    process.exit(0);
+}
+// Handle --version / -v
+if (args.includes('--version') || args.includes('-v')) {
+    console.log('parsely-cli v2.0.0');
+    process.exit(0);
+}
+render(_jsx(App, { initialUrl: url }));

package/dist/components/Banner.d.ts

@@ -0,0 +1 @@
+export declare function Banner(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Banner.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+const LOGO = `\
+ ____   _    ____  ____  _____ _  __   __    ____ _     ___
+|  _ \\ / \\  |  _ \\/ ___|| ____| | \\ \\ / /   / ___| |   |_ _|
+| |_) / _ \\ | |_) \\___ \\|  _| | |  \\ V /   | |   | |    | |
+|  __/ ___ \\|  _ < ___) | |___| |___| |    | |___| |___ | |
+|_| /_/   \\_\\_| \\_\\____/|_____|_____|_|     \\____|_____|___|`;
+export function Banner() {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.colors.banner, bold: true, children: LOGO }), _jsxs(Text, { color: theme.colors.muted, children: ['  ', "Smart recipe scraper ", theme.symbols.dot, " v2.0"] })] }));
+}

package/dist/components/ErrorDisplay.d.ts

@@ -0,0 +1,5 @@
+interface ErrorDisplayProps {
+    message: string;
+}
+export declare function ErrorDisplay({ message }: ErrorDisplayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ErrorDisplay.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+export function ErrorDisplay({ message }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.colors.error, paddingX: 1, paddingY: 1, marginBottom: 1, children: [_jsxs(Text, { bold: true, color: theme.colors.error, children: [theme.symbols.cross, " Scraping Failed"] }), _jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(Text, { color: theme.colors.text, wrap: "wrap", children: message }) }), _jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(Text, { color: theme.colors.muted, children: "Check the URL and try again, or ensure your .env.local has a valid OPENAI_API_KEY." }) })] }));
+}

package/dist/components/Footer.d.ts

@@ -0,0 +1,6 @@
+export type AppPhase = 'idle' | 'scraping' | 'display' | 'error';
+interface FooterProps {
+    phase: AppPhase;
+}
+export declare function Footer({ phase }: FooterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Footer.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+const keybinds = {
+    idle: [
+        { key: 'enter', label: 'submit' },
+        { key: 'ctrl+c', label: 'exit' },
+    ],
+    scraping: [
+        { key: 'ctrl+c', label: 'exit' },
+    ],
+    display: [
+        { key: 'n', label: 'new recipe' },
+        { key: 'q', label: 'quit' },
+    ],
+    error: [
+        { key: 'enter', label: 'submit' },
+        { key: 'ctrl+c', label: 'exit' },
+    ],
+};
+export function Footer({ phase }) {
+    const hints = keybinds[phase];
+    return (_jsx(Box, { marginTop: 1, paddingX: 1, gap: 1, children: hints.map((hint, i) => (_jsxs(React.Fragment, { children: [i > 0 && _jsx(Text, { color: theme.colors.muted, children: theme.symbols.dot }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.primary, bold: true, children: hint.key }), _jsxs(Text, { color: theme.colors.muted, children: [" ", hint.label] })] })] }, hint.key))) }));
+}

package/dist/components/RecipeCard.d.ts

@@ -0,0 +1,6 @@
+import type { Recipe } from '../services/scraper.js';
+interface RecipeCardProps {
+    recipe: Recipe;
+}
+export declare function RecipeCard({ recipe }: RecipeCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/RecipeCard.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+import { isoToMinutes, formatMinutes } from '../utils/helpers.js';
+/**
+ * Extract instruction text from the various formats recipes use.
+ */
+function extractInstructions(recipe) {
+    const raw = recipe.recipeInstructions;
+    if (!raw)
+        return [];
+    const steps = [];
+    if (Array.isArray(raw)) {
+        for (const step of raw) {
+            if (typeof step === 'string') {
+                steps.push(step);
+            }
+            else if (typeof step === 'object' && step !== null) {
+                if ('text' in step && step.text) {
+                    steps.push(step.text);
+                }
+                else if ('itemListElement' in step && Array.isArray(step.itemListElement)) {
+                    for (const sub of step.itemListElement) {
+                        if (sub.text)
+                            steps.push(sub.text);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        steps.push(String(raw));
+    }
+    return steps;
+}
+function TimeField({ label, iso }) {
+    if (!iso)
+        return null;
+    const mins = isoToMinutes(iso);
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.colors.success, bold: true, children: label }), _jsx(Text, { color: theme.colors.text, children: formatMinutes(mins) }), _jsxs(Text, { color: theme.colors.muted, dimColor: true, children: ["(", iso, ")"] })] }));
+}
+export function RecipeCard({ recipe }) {
+    const instructions = extractInstructions(recipe);
+    const sourceLabel = recipe.source === 'browser' ? 'JSON-LD' : 'AI Fallback';
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.colors.secondary, paddingX: 1, paddingY: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.colors.secondary, children: "Recipe Extract" }), _jsxs(Text, { color: theme.colors.muted, children: [' ', "(", sourceLabel, ")"] })] }), recipe.name && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.colors.text, children: recipe.name }) })), (recipe.prepTime || recipe.cookTime || recipe.totalTime) && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(TimeField, { label: "Prep Time ", iso: recipe.prepTime }), _jsx(TimeField, { label: "Cook Time ", iso: recipe.cookTime }), _jsx(TimeField, { label: "Total Time", iso: recipe.totalTime })] })), recipe.recipeIngredient && recipe.recipeIngredient.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.colors.accent, children: "Ingredients" }), recipe.recipeIngredient.map((item, i) => (_jsxs(Text, { color: theme.colors.text, children: ['  ', theme.symbols.bullet, " ", item] }, i)))] })), instructions.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.info, children: "Instructions" }), instructions.map((step, i) => (_jsxs(Text, { color: theme.colors.text, wrap: "wrap", children: ['  ', i + 1, ". ", step] }, i)))] }))] }));
+}

package/dist/components/ScrapingStatus.d.ts

@@ -0,0 +1,6 @@
+import type { ScrapeStatus } from '../services/scraper.js';
+interface ScrapingStatusProps {
+    status: ScrapeStatus;
+}
+export declare function ScrapingStatus({ status }: ScrapingStatusProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ScrapingStatus.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { theme } from '../theme.js';
+const phaseLabel = {
+    browser: 'Browser Scraping',
+    parsing: 'Parsing HTML',
+    ai: 'AI Extraction',
+    done: 'Complete',
+    error: 'Error',
+};
+export function ScrapingStatus({ status }) {
+    const isActive = status.phase !== 'done' && status.phase !== 'error';
+    const label = phaseLabel[status.phase] ?? status.phase;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.colors.border, paddingX: 1, paddingY: 1, children: [_jsxs(Box, { gap: 1, children: [isActive && (_jsx(Text, { color: theme.colors.primary, children: _jsx(Spinner, { type: "dots" }) })), _jsx(Text, { bold: true, color: theme.colors.label, children: label })] }), _jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsx(Text, { color: theme.colors.muted, children: status.message }) })] }));
+}

package/dist/components/URLInput.d.ts

@@ -0,0 +1,5 @@
+interface URLInputProps {
+    onSubmit: (url: string) => void;
+}
+export declare function URLInput({ onSubmit }: URLInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/URLInput.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import { theme } from '../theme.js';
+import { isValidUrl } from '../utils/helpers.js';
+export function URLInput({ onSubmit }) {
+    const [value, setValue] = useState('');
+    const [error, setError] = useState('');
+    const handleSubmit = (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            setError('Please enter a URL');
+            return;
+        }
+        // Auto-prepend https:// if missing protocol
+        const url = /^https?:\/\//.test(trimmed) ? trimmed : `https://${trimmed}`;
+        if (!isValidUrl(url)) {
+            setError('Invalid URL. Please enter a valid recipe URL.');
+            return;
+        }
+        setError('');
+        setValue('');
+        onSubmit(url);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: theme.colors.borderFocus, paddingX: 1, children: [_jsx(Text, { color: theme.colors.primary, bold: true, children: '\u276F ' }), _jsx(TextInput, { value: value, onChange: (v) => {
+                            setValue(v);
+                            if (error)
+                                setError('');
+                        }, onSubmit: handleSubmit, placeholder: "Enter recipe URL..." })] }), error && (_jsx(Box, { marginLeft: 2, marginTop: 0, children: _jsxs(Text, { color: theme.colors.error, children: [theme.symbols.cross, " ", error] }) }))] }));
+}

package/dist/components/Welcome.d.ts

@@ -0,0 +1 @@
+export declare function Welcome(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Welcome.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+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." })] }));
+}

package/dist/services/scraper.d.ts

@@ -0,0 +1,26 @@
+export interface Recipe {
+    name?: string;
+    prepTime?: string;
+    cookTime?: string;
+    totalTime?: string;
+    recipeIngredient?: string[];
+    recipeInstructions?: Array<string | {
+        text?: string;
+        itemListElement?: Array<{
+            text?: string;
+        }>;
+    }>;
+    source: 'browser' | 'ai';
+}
+export type ScrapePhase = 'browser' | 'parsing' | 'ai' | 'done' | 'error';
+export interface ScrapeStatus {
+    phase: ScrapePhase;
+    message: string;
+    recipe?: Recipe;
+}
+/**
+ * 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>;

package/dist/services/scraper.js

@@ -0,0 +1,166 @@
+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';
+/* ------------------------------------------------------------------ */
+/*  JSON-LD helpers                                                    */
+/* ------------------------------------------------------------------ */
+/**
+ * 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) {
+    for (const raw of scripts) {
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const candidates = Array.isArray(data)
+            ? data
+            : [data];
+        // Use index-based loop because we may push into candidates as we go
+        for (let i = 0; i < candidates.length; i++) {
+            const obj = candidates[i];
+            // Expand @graph
+            if (obj['@graph']) {
+                const graph = obj['@graph'];
+                const items = Array.isArray(graph)
+                    ? graph
+                    : [graph];
+                candidates.push(...items);
+            }
+            const recipeType = obj['@type'];
+            if (recipeType === 'Recipe' ||
+                (Array.isArray(recipeType) && recipeType.includes('Recipe'))) {
+                return obj;
+            }
+        }
+    }
+    return null;
+}
+/* ------------------------------------------------------------------ */
+/*  Chrome detection                                                   */
+/* ------------------------------------------------------------------ */
+const CHROME_PATHS = [
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/google-chrome',
+    '/usr/bin/chromium-browser',
+    '/usr/bin/chromium',
+    '/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;
+    }
+    catch { /* not found */ }
+    return null;
+}
+/* ------------------------------------------------------------------ */
+/*  Scraping strategies                                                */
+/* ------------------------------------------------------------------ */
+async function scrapeWithBrowser(url) {
+    const chromePath = findChrome();
+    if (!chromePath)
+        return null; // No browser available – skip to AI
+    let browser = null;
+    try {
+        browser = await puppeteer.launch({
+            headless: true,
+            executablePath: chromePath,
+            args: ['--no-sandbox', '--disable-setuid-sandbox'],
+        });
+        const page = await browser.newPage();
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 10_000 });
+        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' };
+    }
+    catch {
+        if (browser) {
+            try {
+                await browser.close();
+            }
+            catch { /* noop */ }
+        }
+        return null;
+    }
+}
+async function scrapeWithAI(url) {
+    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 content = response.choices[0]?.message?.content;
+    if (!content)
+        throw new Error('AI returned empty response');
+    const recipe = JSON.parse(content);
+    return { ...recipe, source: 'ai' };
+}
+/* ------------------------------------------------------------------ */
+/*  Public orchestrator                                                */
+/* ------------------------------------------------------------------ */
+/**
+ * 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 async function scrapeRecipe(url, onStatus) {
+    // 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;
+    }
+    // Phase 2 – AI fallback
+    onStatus({ phase: 'ai', message: 'Falling back to AI scraper\u2026' });
+    try {
+        const aiResult = await scrapeWithAI(url);
+        onStatus({ phase: 'done', message: 'Recipe extracted via AI!', recipe: aiResult });
+        return aiResult;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        onStatus({ phase: 'error', message });
+        throw error;
+    }
+}

package/dist/theme.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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";
+    };
+    readonly symbols: {
+        readonly bullet: "•";
+        readonly arrow: "→";
+        readonly check: "✓";
+        readonly cross: "✗";
+        readonly dot: "·";
+        readonly ellipsis: "…";
+        readonly line: "─";
+    };
+};
+export type Theme = typeof theme;

package/dist/theme.js

@@ -0,0 +1,30 @@
+/**
+ * Parsely CLI theme - color palette and symbols for the TUI.
+ * Inspired by OpenCode's semantic theming approach.
+ */
+export const theme = {
+    colors: {
+        primary: '#00d4aa',
+        secondary: '#ff6b9d',
+        accent: '#ffd93d',
+        text: '#e0e0e0',
+        muted: '#6272a4',
+        error: '#ff5555',
+        success: '#50fa7b',
+        warning: '#f1fa8c',
+        info: '#8be9fd',
+        banner: '#50fa7b',
+        border: '#6272a4',
+        borderFocus: '#00d4aa',
+        label: '#bd93f9',
+    },
+    symbols: {
+        bullet: '\u2022',
+        arrow: '\u2192',
+        check: '\u2713',
+        cross: '\u2717',
+        dot: '\u00B7',
+        ellipsis: '\u2026',
+        line: '\u2500',
+    },
+};

package/dist/utils/helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Convert an ISO 8601 duration string (e.g. "PT1H30M") to total minutes.
+ * Returns -1 when the input is not parseable.
+ */
+export declare function isoToMinutes(duration: string | undefined): number;
+/**
+ * Format minutes into a human-readable string (e.g. "1h 30m").
+ */
+export declare function formatMinutes(mins: number): string;
+/**
+ * Load environment configuration from .env.local.
+ */
+export declare function loadConfig(): {
+    openaiApiKey?: string;
+};
+/**
+ * Basic URL validation.
+ */
+export declare function isValidUrl(url: string): boolean;

package/dist/utils/helpers.js

@@ -0,0 +1,51 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+/**
+ * Convert an ISO 8601 duration string (e.g. "PT1H30M") to total minutes.
+ * Returns -1 when the input is not parseable.
+ */
+export function isoToMinutes(duration) {
+    if (!duration || typeof duration !== 'string')
+        return -1;
+    const match = duration.match(/^P(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/);
+    if (!match)
+        return -1;
+    const days = parseInt(match[1] || '0', 10);
+    const hours = parseInt(match[2] || '0', 10);
+    const minutes = parseInt(match[3] || '0', 10);
+    const seconds = parseInt(match[4] || '0', 10);
+    return days * 1440 + hours * 60 + minutes + Math.ceil(seconds / 60);
+}
+/**
+ * Format minutes into a human-readable string (e.g. "1h 30m").
+ */
+export function formatMinutes(mins) {
+    if (mins < 0)
+        return 'N/A';
+    if (mins < 60)
+        return `${mins} min`;
+    const h = Math.floor(mins / 60);
+    const m = mins % 60;
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+/**
+ * Load environment configuration from .env.local.
+ */
+export function loadConfig() {
+    config({ path: resolve(process.cwd(), '.env.local') });
+    return {
+        openaiApiKey: process.env['OPENAI_API_KEY'],
+    };
+}
+/**
+ * Basic URL validation.
+ */
+export function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@sambitcreate/parsely-cli",
+  "version": "2.0.0",
+  "description": "A smart recipe scraper CLI with interactive TUI built on Ink",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "parsely": "dist/cli.js"
+  },
+  "scripts": {
+    "start": "tsx src/cli.tsx",
+    "dev": "tsx watch src/cli.tsx",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "node dist/cli.js --version",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "recipe",
+    "scraper",
+    "cli",
+    "tui",
+    "ink",
+    "terminal"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sambitcreate/parsely-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sambitcreate/parsely-cli/issues"
+  },
+  "homepage": "https://github.com/sambitcreate/parsely-cli#readme",
+  "dependencies": {
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1",
+    "puppeteer-core": "^24.2.1",
+    "openai": "^4.82.0",
+    "cheerio": "^1.0.0",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "tsx": "^4.19.2",
+    "@types/react": "^18.3.18"
+  },
+  "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316"
+}