nutrition-cli 1.0.0__tar.gz

nutrition_cli-1.0.0/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.so
+.venv/
+venv/
+env/
+.env
+*.env
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+.coverage
+*.whl

nutrition_cli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Ruiz
+
+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.

nutrition_cli-1.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: nutrition-cli
+Version: 1.0.0
+Summary: CLI tool for nutrition data lookup from USDA and Open Food Facts
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: responses; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# nutrition-cli
+
+CLI tool for nutrition data lookup, powered by [USDA FoodData Central](https://fdc.nal.usda.gov/) and [Open Food Facts](https://world.openfoodfacts.org/). Also ships as an [OpenClaw](https://github.com/openclaw) skill for AI-assisted nutrition queries.
+
+## Install
+
+### Via ClawHub (recommended for OpenClaw users)
+
+```
+claw install nutrition-cli
+```
+
+This installs both the CLI tool and the OpenClaw skill that lets your agent answer nutrition questions automatically.
+
+### Via pip
+
+```
+pip install nutrition-cli
+```
+
+## Quick start
+
+```bash
+# Look up a food
+nutrition search "chicken breast" --grams 200
+
+# Scan a barcode
+nutrition barcode 3017624010701
+
+# Compare foods
+nutrition compare "white rice" "brown rice" "quinoa"
+
+# Calculate a meal
+nutrition meal "200g chicken breast" "150g rice" "1 avocado" --rda
+
+# Calories burned
+nutrition burn running 30 --weight 70
+
+# Daily targets
+nutrition daily --sex female --age 25 --weight 60 --activity moderate
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nutrition search QUERY` | Look up nutrition for any food |
+| `nutrition barcode CODE` | Look up by barcode (EAN-8/13, UPC-A) |
+| `nutrition compare FOOD1 FOOD2 ...` | Side-by-side comparison (2-5 foods) |
+| `nutrition meal "Xg food" ...` | Sum nutrition across a meal |
+| `nutrition burn ACTIVITY MINUTES` | Estimate calories burned |
+| `nutrition daily` | Personalized daily intake targets |
+| `nutrition config set` | Set API key or defaults |
+
+All commands support `--format json` for machine-readable output and `--grams` for custom serving sizes.
+
+## Rate limits
+
+No API key is required. The tool uses USDA's `DEMO_KEY` (50 requests/day per IP) and Open Food Facts (unlimited, no key needed).
+
+If you hit the USDA rate limit, get a free personal key in 30 seconds:
+
+1. Sign up at https://fdc.nal.usda.gov/api-key-signup
+2. Run: `nutrition config set --usda-key YOUR_KEY`
+
+This raises your limit to 1,000 requests/hour.
+
+## Data sources
+
+- **USDA FoodData Central** — generic foods (SR Legacy, Foundation) and branded products. US government data, high quality.
+- **Open Food Facts** — community-contributed product database with barcode lookup, Nutri-Score, NOVA classification, allergen data, and vegan/vegetarian status.
+
+The CLI prefers USDA SR Legacy/Foundation results for generic food queries and falls back to Open Food Facts automatically.
+
+## License
+
+MIT

nutrition_cli-1.0.0/README.md

@@ -0,0 +1,77 @@
+# nutrition-cli
+
+CLI tool for nutrition data lookup, powered by [USDA FoodData Central](https://fdc.nal.usda.gov/) and [Open Food Facts](https://world.openfoodfacts.org/). Also ships as an [OpenClaw](https://github.com/openclaw) skill for AI-assisted nutrition queries.
+
+## Install
+
+### Via ClawHub (recommended for OpenClaw users)
+
+```
+claw install nutrition-cli
+```
+
+This installs both the CLI tool and the OpenClaw skill that lets your agent answer nutrition questions automatically.
+
+### Via pip
+
+```
+pip install nutrition-cli
+```
+
+## Quick start
+
+```bash
+# Look up a food
+nutrition search "chicken breast" --grams 200
+
+# Scan a barcode
+nutrition barcode 3017624010701
+
+# Compare foods
+nutrition compare "white rice" "brown rice" "quinoa"
+
+# Calculate a meal
+nutrition meal "200g chicken breast" "150g rice" "1 avocado" --rda
+
+# Calories burned
+nutrition burn running 30 --weight 70
+
+# Daily targets
+nutrition daily --sex female --age 25 --weight 60 --activity moderate
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nutrition search QUERY` | Look up nutrition for any food |
+| `nutrition barcode CODE` | Look up by barcode (EAN-8/13, UPC-A) |
+| `nutrition compare FOOD1 FOOD2 ...` | Side-by-side comparison (2-5 foods) |
+| `nutrition meal "Xg food" ...` | Sum nutrition across a meal |
+| `nutrition burn ACTIVITY MINUTES` | Estimate calories burned |
+| `nutrition daily` | Personalized daily intake targets |
+| `nutrition config set` | Set API key or defaults |
+
+All commands support `--format json` for machine-readable output and `--grams` for custom serving sizes.
+
+## Rate limits
+
+No API key is required. The tool uses USDA's `DEMO_KEY` (50 requests/day per IP) and Open Food Facts (unlimited, no key needed).
+
+If you hit the USDA rate limit, get a free personal key in 30 seconds:
+
+1. Sign up at https://fdc.nal.usda.gov/api-key-signup
+2. Run: `nutrition config set --usda-key YOUR_KEY`
+
+This raises your limit to 1,000 requests/hour.
+
+## Data sources
+
+- **USDA FoodData Central** — generic foods (SR Legacy, Foundation) and branded products. US government data, high quality.
+- **Open Food Facts** — community-contributed product database with barcode lookup, Nutri-Score, NOVA classification, allergen data, and vegan/vegetarian status.
+
+The CLI prefers USDA SR Legacy/Foundation results for generic food queries and falls back to Open Food Facts automatically.
+
+## License
+
+MIT

nutrition_cli-1.0.0/nutrition_cli/__init__.py

@@ -0,0 +1 @@
+"""nutrition-cli — CLI tool for nutrition data lookup."""

nutrition_cli-1.0.0/nutrition_cli/__main__.py

@@ -0,0 +1,276 @@
+"""CLI entrypoint for nutrition-cli."""
+
+import json
+import re
+
+import click
+
+from . import config, format, search
+from .rda import MET_TABLE, get_rda
+from .usda import RateLimitError
+
+
+@click.group()
+def cli():
+    """Nutrition data lookup from USDA and Open Food Facts."""
+
+
+# --- config ---
+
+
+@cli.group("config")
+def config_cmd():
+    """Manage nutrition-cli configuration."""
+
+
+@config_cmd.command("set")
+@click.option("--usda-key", default=None, help="Personal USDA FoodData Central API key.")
+@click.option("--default-grams", default=None, type=float, help="Default serving size in grams.")
+def config_set(usda_key, default_grams):
+    """Save configuration values."""
+    if usda_key is None and default_grams is None:
+        # Show current config status
+        data = config.load_config()
+        has_key = "usda_key" in data
+        grams = data.get("default_grams", 100)
+        click.echo(f"  USDA key : {'configured' if has_key else 'not set (using DEMO_KEY)'}")
+        click.echo(f"  Default g: {grams}")
+        return
+
+    if usda_key is not None:
+        config.set("usda_key", usda_key)
+        click.echo("  USDA API key saved.")
+    if default_grams is not None:
+        config.set("default_grams", default_grams)
+        click.echo(f"  Default serving size set to {default_grams}g.")
+
+
+# --- search ---
+
+
+@cli.command("search")
+@click.argument("query")
+@click.option("--grams", "-g", default=None, type=float, help="Serving size in grams.")
+@click.option("--format", "fmt", type=click.Choice(["summary", "json"]), default="summary")
+@click.option("--rda", "show_rda", is_flag=True, help="Show daily intake percentage.")
+@click.option("--sex", type=click.Choice(["male", "female"]), default="male")
+@click.option("--age", type=int, default=30)
+def search_cmd(query, grams, fmt, show_rda, sex, age):
+    """Look up nutrition data for a food."""
+    if grams is None:
+        grams = config.get("default_grams", 100)
+
+    try:
+        result = search.lookup(query, grams)
+    except RateLimitError as e:
+        click.echo(format.format_error_rate_limit(e.retry_after), err=True)
+        raise SystemExit(1)
+
+    if fmt == "json":
+        click.echo(json.dumps(result, indent=2))
+    else:
+        click.echo(format.nutrition_block(result))
+        if show_rda:
+            rda = get_rda(sex, age)
+            click.echo()
+            click.echo(format.rda_progress(result, rda))
+
+
+
+# --- barcode ---
+
+
+@cli.command()
+@click.argument("barcode")
+@click.option("--grams", "-g", default=None, type=float, help="Serving size in grams.")
+@click.option("--format", "fmt", type=click.Choice(["summary", "json"]), default="summary")
+def barcode(barcode, grams, fmt):
+    """Look up a product by barcode (EAN-8/EAN-13/UPC-A)."""
+    if grams is None:
+        grams = config.get("default_grams", 100)
+
+    from . import openfoodfacts
+    product = openfoodfacts.get_by_barcode(barcode)
+    if product is None:
+        raise click.ClickException(
+            f"Barcode '{barcode}' not found in Open Food Facts. "
+            "Try searching by name: nutrition search <name>"
+        )
+
+    result = openfoodfacts.parse_product(product, grams)
+
+    if fmt == "json":
+        click.echo(json.dumps(result, indent=2))
+    else:
+        click.echo(format.nutrition_block(result))
+
+
+# --- compare ---
+
+
+@cli.command()
+@click.argument("foods", nargs=-1, required=True)
+@click.option("--grams", "-g", default=None, type=float, help="Serving size in grams.")
+@click.option("--format", "fmt", type=click.Choice(["summary", "json"]), default="summary")
+def compare(foods, grams, fmt):
+    """Compare nutrition data for 2-5 foods."""
+    if len(foods) < 2:
+        raise click.ClickException("Provide at least 2 foods to compare.")
+    if len(foods) > 5:
+        raise click.ClickException("Compare supports up to 5 foods.")
+
+    if grams is None:
+        grams = config.get("default_grams", 100)
+
+    try:
+        results = search.lookup_multi(list(foods), grams)
+    except RateLimitError as e:
+        click.echo(format.format_error_rate_limit(e.retry_after), err=True)
+        raise SystemExit(1)
+
+    if fmt == "json":
+        click.echo(json.dumps(results, indent=2))
+    else:
+        click.echo(format.compare_table(results))
+
+
+# --- meal ---
+
+
+def _parse_meal_arg(arg: str, default_grams: float) -> tuple[str, float]:
+    """Parse '200g chicken' into (query, grams). Falls back to default_grams."""
+    m = re.match(r"^(\d+\.?\d*)\s*g\s+(.+)$", arg, re.IGNORECASE)
+    if m:
+        return m.group(2), float(m.group(1))
+    return arg, default_grams
+
+
+@cli.command()
+@click.argument("items", nargs=-1, required=True)
+@click.option("--grams", "-g", default=None, type=float, help="Default serving size in grams.")
+@click.option("--rda", "show_rda", is_flag=True, help="Show daily intake percentage.")
+@click.option("--format", "fmt", type=click.Choice(["summary", "json"]), default="summary")
+@click.option("--sex", type=click.Choice(["male", "female"]), default="male")
+@click.option("--age", type=int, default=30)
+def meal(items, grams, show_rda, fmt, sex, age):
+    """Calculate nutrition for a full meal. Use '200g chicken' syntax for portions."""
+    if grams is None:
+        grams = config.get("default_grams", 100)
+
+    results = []
+    errors = []
+    for item in items:
+        query, item_grams = _parse_meal_arg(item, grams)
+        try:
+            results.append(search.lookup(query, item_grams))
+        except RateLimitError as e:
+            click.echo(format.format_error_rate_limit(e.retry_after), err=True)
+            raise SystemExit(1)
+        except click.ClickException as e:
+            errors.append(f"  - {query}: {e.format_message()}")
+
+    if errors:
+        click.echo("Some lookups failed:", err=True)
+        for err in errors:
+            click.echo(err, err=True)
+
+    if not results:
+        raise click.ClickException("No foods could be looked up.")
+
+    if fmt == "json":
+        click.echo(json.dumps(results, indent=2))
+    else:
+        for r in results:
+            click.echo(format.nutrition_block(r))
+            click.echo()
+        click.echo(format.meal_summary(results))
+        if show_rda:
+            # Build combined food dict for RDA
+            keys = ["kcal", "protein", "fat", "carbs", "fiber"]
+            combined = {}
+            for key in keys:
+                values = [r.get(key) for r in results if r.get(key) is not None]
+                combined[key] = round(sum(values), 1) if values else None
+            rda = get_rda(sex, age)
+            click.echo()
+            click.echo(format.rda_progress(combined, rda))
+
+
+# --- burn ---
+
+
+@cli.command()
+@click.argument("activity")
+@click.argument("duration", type=float)
+@click.option("--weight", "-w", default=None, type=float, help="Body weight in kg.")
+def burn(activity, duration, weight):
+    """Estimate calories burned for an activity."""
+    if weight is None:
+        weight = config.get("default_weight", 75)
+
+    activity_lower = activity.lower()
+    met = MET_TABLE.get(activity_lower)
+    if met is None:
+        available = ", ".join(sorted(MET_TABLE.keys()))
+        raise click.ClickException(
+            f"Unknown activity '{activity}'. Available: {available}"
+        )
+
+    calories = round(met * weight * (duration / 60), 1)
+    click.echo(f"  {activity.capitalize()} for {duration:.0f} min ({weight}kg)")
+    click.echo(f"  Estimated burn: {calories} kcal")
+
+    # Show equivalent in another activity
+    walking_met = MET_TABLE["walking"]
+    walking_min = round(calories / (walking_met * weight) * 60, 0)
+    click.echo(f"  Equivalent to {walking_min:.0f} min of walking")
+
+
+# --- daily ---
+
+
+@cli.command()
+@click.option("--sex", type=click.Choice(["male", "female"]), default="male")
+@click.option("--age", type=int, default=30)
+@click.option("--weight", "-w", type=float, default=75, help="Body weight in kg.")
+@click.option("--height", type=float, default=175, help="Height in cm.")
+@click.option(
+    "--activity",
+    type=click.Choice(["sedentary", "light", "moderate", "active"]),
+    default="moderate",
+)
+def daily(sex, age, weight, height, activity):
+    """Show recommended daily nutrition intake (Harris-Benedict TDEE)."""
+    # Harris-Benedict BMR
+    if sex == "male":
+        bmr = 88.362 + (13.397 * weight) + (4.799 * height) - (5.677 * age)
+    else:
+        bmr = 447.593 + (9.247 * weight) + (3.098 * height) - (4.330 * age)
+
+    multipliers = {
+        "sedentary": 1.2,
+        "light": 1.375,
+        "moderate": 1.55,
+        "active": 1.725,
+    }
+    tdee = round(bmr * multipliers[activity])
+
+    # Macro split: 30% protein, 25% fat, 45% carbs
+    protein_g = round(tdee * 0.30 / 4, 1)
+    fat_g = round(tdee * 0.25 / 9, 1)
+    carbs_g = round(tdee * 0.45 / 4, 1)
+
+    rda = get_rda(sex, age)
+    fiber_g = rda["fiber_g"]
+
+    click.echo(f"  Daily targets ({sex}, age {age}, {weight}kg, {height}cm, {activity}):")
+    click.echo(f"  {'=' * 40}")
+    click.echo(f"  Calories : {tdee} kcal")
+    click.echo(f"  Protein  : {protein_g}g")
+    click.echo(f"  Fat      : {fat_g}g")
+    click.echo(f"  Carbs    : {carbs_g}g")
+    click.echo(f"  Fiber    : {fiber_g}g")
+
+
+if __name__ == "__main__":
+    cli()

nutrition_cli-1.0.0/nutrition_cli/config.py

@@ -0,0 +1,40 @@
+"""Persistent config management at ~/.config/nutrition-cli/config.json."""
+
+import json
+from pathlib import Path
+
+
+def get_config_path() -> Path:
+    """Return config file path, creating parent dirs if missing."""
+    path = Path.home() / ".config" / "nutrition-cli" / "config.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def load_config() -> dict:
+    """Read config JSON. Returns {} if file missing or invalid."""
+    path = get_config_path()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(data: dict) -> None:
+    """Write config dict as JSON with indent=2."""
+    path = get_config_path()
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def get(key: str, default=None):
+    """Read one key from config."""
+    return load_config().get(key, default)
+
+
+def set(key: str, value: str) -> None:
+    """Load config, update one key, save."""
+    data = load_config()
+    data[key] = value
+    save_config(data)

nutrition_cli-1.0.0/nutrition_cli/format.py

@@ -0,0 +1,159 @@
+"""All output formatting. Returns strings — never prints directly."""
+
+
+def _val(value, unit="g", width=7) -> str:
+    """Format a nutrient value, showing dash for None."""
+    if value is None:
+        return "\u2014".rjust(width)
+    return f"{value}{unit}".rjust(width)
+
+
+def _source_label(food: dict) -> str:
+    """Build source label from food dict."""
+    source = food.get("source", "")
+    data_type = food.get("data_type", "")
+    brand = food.get("brand", "")
+    if data_type:
+        return f"{source} ({data_type})"
+    if brand:
+        return f"{source} ({brand})"
+    return source
+
+
+def nutrition_block(food: dict) -> str:
+    """Format a single food lookup result."""
+    lines = []
+    lines.append(f"  {food['name']}")
+    lines.append(f"  Source   : {_source_label(food)}")
+
+    if food.get("nutriscore"):
+        lines.append(f"  Nutri-Score: {food['nutriscore']}")
+    if food.get("nova_group"):
+        lines.append(f"  NOVA     : {food['nova_group']}")
+
+    lines.append(f"  Serving  : {food['grams']}g")
+    lines.append("  " + "\u2500" * 35)
+
+    lines.append(f"  Calories : {_val(food.get('kcal'), ' kcal')}")
+    lines.append(f"  Protein  : {_val(food.get('protein'))}")
+
+    fat_str = _val(food.get("fat"))
+    sat = food.get("saturated_fat")
+    if sat is not None:
+        fat_str += f"  (sat. {sat}g)"
+    lines.append(f"  Fat      : {fat_str}")
+
+    lines.append(f"  Carbs    : {_val(food.get('carbs'))}")
+    lines.append(f"  Fiber    : {_val(food.get('fiber'))}")
+    lines.append(f"  Sugar    : {_val(food.get('sugar'))}")
+
+    sodium_key = "sodium_mg" if "sodium_mg" in food else "salt_mg"
+    sodium_label = "Sodium" if sodium_key == "sodium_mg" else "Salt"
+    lines.append(f"  {sodium_label:9s}: {_val(food.get(sodium_key), ' mg')}")
+
+    allergens = food.get("allergens", [])
+    if allergens:
+        lines.append(f"  Allergens: {', '.join(allergens)}")
+
+    return "\n".join(lines)
+
+
+def compare_table(foods: list[dict]) -> str:
+    """Aligned comparison table for 2-5 foods."""
+    label_width = 12
+    col_width = 20
+
+    # Truncate food names
+    names = [f["name"][:18] for f in foods]
+
+    lines = []
+    header = " " * label_width + "".join(n.rjust(col_width) for n in names)
+    lines.append(header)
+    lines.append("\u2500" * (label_width + col_width * len(foods)))
+
+    rows = [
+        ("Calories", "kcal", " kcal"),
+        ("Protein", "protein", "g"),
+        ("Fat", "fat", "g"),
+        ("Carbs", "carbs", "g"),
+        ("Fiber", "fiber", "g"),
+        ("Sugar", "sugar", "g"),
+    ]
+
+    for label, key, unit in rows:
+        row = label.ljust(label_width)
+        for f in foods:
+            val = f.get(key)
+            if val is None:
+                row += "\u2014".rjust(col_width)
+            else:
+                row += f"{val}{unit}".rjust(col_width)
+        lines.append(row)
+
+    return "\n".join(lines)
+
+
+def meal_summary(foods: list[dict], label: str = "Meal total") -> str:
+    """Sum nutrients across foods and format as a totals block."""
+    keys = ["kcal", "protein", "fat", "saturated_fat", "carbs", "fiber", "sugar"]
+    totals = {}
+    total_grams = 0.0
+
+    for key in keys:
+        values = [f.get(key) for f in foods if f.get(key) is not None]
+        totals[key] = round(sum(values), 1) if values else None
+
+    for f in foods:
+        total_grams += f.get("grams", 0)
+
+    total_food = {
+        "name": label,
+        "source": f"{len(foods)} items",
+        "grams": total_grams,
+        **totals,
+    }
+    return nutrition_block(total_food)
+
+
+def rda_progress(food: dict, rda: dict) -> str:
+    """Show percentage of daily recommended intake with ASCII bars."""
+    bar_width = 20
+    lines = []
+
+    target_cal = rda["calories"]
+    lines.append(f"  Daily intake contribution ({target_cal} kcal target):")
+
+    rows = [
+        ("Calories", "kcal", rda["calories"], " kcal"),
+        ("Protein", "protein", rda["protein_g"], "g"),
+        ("Fat", "fat", rda["fat_g"], "g"),
+        ("Carbs", "carbs", rda["carbs_g"], "g"),
+        ("Fiber", "fiber", rda["fiber_g"], "g"),
+    ]
+
+    for label, key, daily, unit in rows:
+        val = food.get(key)
+        if val is None:
+            pct = 0.0
+        else:
+            pct = (val / daily * 100) if daily > 0 else 0.0
+
+        filled = min(int(pct / 100 * bar_width), bar_width)
+        empty = bar_width - filled
+        bar = "\u2588" * filled + "\u2591" * empty
+
+        val_str = f"{val}{unit}" if val is not None else "\u2014"
+        lines.append(f"  {label:9s} {bar}  {val_str:>10s}  ({pct:.1f}%)")
+
+    return "\n".join(lines)
+
+
+def format_error_rate_limit(retry_after: int) -> str:
+    """Format rate limit error with upgrade instructions."""
+    minutes = max(1, retry_after // 60)
+    return (
+        f"  Rate limit reached (USDA DEMO_KEY: 50 requests/day).\n"
+        f"  Try again in {minutes} minutes, or upgrade in 30 seconds:\n"
+        f"  \u2192 Get a free key: https://fdc.nal.usda.gov/api-key-signup\n"
+        f"  \u2192 Then run: nutrition config set --usda-key YOUR_KEY"
+    )