Recipe Integration Pipeline

Step 1: Extract Recipe

From a URL

Use web fetch tools to retrieve the page content. Extract:

• Recipe title
• Ingredient list (with quantities, units, items, and preparation states)
• Instructions/method steps
• Servings count
• Source attribution (website name)
• Any notes or tips

Recipe websites often have structured data. Look for the recipe content and ignore ads, navigation, and comments.

From Pasted Text

Parse the text directly. Identify ingredient lines (they have quantities and units) vs instruction paragraphs.

From a Photo

Use vision capabilities to read the photo. Transcribe the recipe accurately, paying close attention to quantities, fractions, and unit abbreviations. If anything is unclear or illegible, flag it and ask the user.

Step 2: Format Ingredients and Metadata

Read the full style guide before formatting:

Read: .claude/skills/recipe-integration/references/style-guide.md

The style guide has the complete formatting rules. Here's a quick summary of the most important ones:

File Naming

• Lowercase, underscores: thai_green_curry.tex
• Save to recipes/ directory

Metadata Block

\begin{recipe}[
  title    = {Recipe Title},
  servings = {N servings},
  calories = {X calories},
  source   = {Source Name},
]

Ingredients

• One per line, ending with \\
• Format: quantity unit item, state \\
• Units: tbsp (not tbs/tablespoon), tsp (not teaspoon), g, ml, cup, oz
• Fractions: \sfrac{1}{2} — mixed numbers: 1\sfrac{1}{2} (no space)
• Use \inggroup{Name} for multi-component recipes
• Ranges: en-dash -- (e.g., 1--2 tbsp)

Step 3: Rewrite Instructions

This is critical. The source recipe's instructions will come in many different voices — chatty blog posts, terse reference cards, old-fashioned cookbook prose. All must be rewritten into one consistent cookbook voice.

The Cookbook Voice

The voice is concise, imperative, warm but efficient. Think of a confident home cook giving clear directions — not a food blogger telling a story, not a chemistry textbook.

Principles:

• Imperative mood: "Heat oil in a large skillet" not "You will want to heat oil"
• One cooking stage per paragraph: Each paragraph covers one logical phase (prep, cook aromatics, simmer, finish). Blank line between paragraphs.
• No conversational filler: Cut "You will need to...", "Remember to...", "So you may...", "I like to...", "If you want..."
• Precise but not clinical: Include visual/sensory cues ("until golden brown", "until fragrant, about 1 minute") but don't over-explain
• Tips and variations go in \recipenotes: Storage instructions, make-ahead notes, substitution ideas, and serving suggestions that aren't essential to the cooking process go in \recipenotes at the end — not mixed into the instructions
• Section headers when needed: Multi-component recipes (separate sauce, filling, assembly) use {\bfseries Section Name} headers. Simple one-pot recipes don't need headers.

Before/After Example

Before (rambling, conversational):

Stir well and begin to cook on a low flame stirring often. You will need to add half cup water each time the dal thickens. Stir and continue to cook on the lowest possible heat. You can use about 1 to 2 cups water and simmer for 60 to 90 mins on a very low flame or as long as 4 to 6 hours for a more authentic taste. Remember to keep stirring and add water whenever needed. Once it is thick and creamy, you can add cream and turn off. It tastes good even without the addition of cream. If having it the next day or later, you can refrigerate.

After (concise, imperative, well-paragraphed):

Pour in the cooked dal with its stock and stir well. Reduce heat to the lowest setting and simmer, stirring often and adding water ½ cup at a time as the dal thickens. Cook for 60 to 90 minutes for a good result, or up to 4 to 6 hours for deeper flavour.

Stir in cream just before serving. Serve topped with butter, garnished with cilantro and ginger juliennes, alongside rice, naan, or roti.

\recipenotes Dal makhani improves overnight — make it a day ahead if you can. Reheat gently with a splash of water, stirring in cream once hot. Tastes great without cream as well.

Common Problems to Fix

• Wall-of-text paragraphs: Break into one stage per paragraph
• Buried tips/variations: Move to \recipenotes
• Conversational asides: Cut or rewrite in imperative voice
• Redundant repetition: Say it once, clearly
• Serving suggestions in instructions: Move to final paragraph or \recipenotes
• Vague timing: Add approximate times where helpful ("about 5 minutes")
• Old-fashioned verbose style: Modernize into clean, direct prose

Step 4: Calculate Nutrition (Optional)

If the environment variables EDAMAM_APP_ID and EDAMAM_APP_KEY are set, use the nutrition script with --embed to calculate nutrition and store the full dataset as comments in the .tex file:

python .claude/skills/recipe-integration/scripts/nutrition.py \
  --tex recipes/new_recipe.tex \
  --embed

This submits the full recipe to the Edamam Nutrition Analysis API (POST /api/nutrition-details) in a single request, displays per-serving calories and macros, and embeds all 35+ nutrient fields (vitamins, minerals, fat breakdown, diet/health labels) as a JSON comment block in the .tex file. The embedded data is invisible in the compiled book but available for future use (e.g., a nutrition appendix). Servings are auto-detected from the .tex metadata. Optional ingredients (garnishes, "to taste", "if desired") are excluded.

The script converts LaTeX fractions to decimals before querying the API (e.g., 1\sfrac{1}{2} becomes 1.5, \sfrac{3}{4} becomes 0.75). This avoids ambiguous fraction strings like 11/2 being misread by the API.

Get API credentials at https://developer.edamam.com/admin/applications

If no API credentials are available, you have two options:

• Estimate calories based on your knowledge and note it's estimated
• Leave the calories field empty and inform the user

When you get the calorie result, update the recipe's calories metadata field.

Step 5: Verify with Separate Agent

This step is mandatory. After rewriting, spawn a separate verification agent that receives both the original source recipe and the new formatted version. The verifier is independent — it has not seen the rewriting process and checks with fresh eyes.

Verification Agent Prompt

Send the following to a subagent (or, in environments without subagents, perform the verification as a clearly separated second pass):

You are a recipe verification agent. You have been given an ORIGINAL recipe and a
REWRITTEN version. Your job is to verify that the rewrite is faithful to the original.

Check the following:

1. INGREDIENTS ACCURACY
   - Every ingredient in the original appears in the rewrite (same item, same quantity)
   - No quantities have been changed (watch for unit conversions gone wrong)
   - No ingredients have been added that weren't in the original
   - No ingredients have been silently dropped

2. INSTRUCTIONS ACCURACY
   - Every cooking step in the original is present in the rewrite
   - Temperatures have not changed
   - Cooking times have not changed
   - The order of operations is preserved
   - No steps have been silently dropped or merged incorrectly
   - Technique details are preserved (e.g., "fold" not changed to "stir")

3. METADATA ACCURACY
   - Title matches (or is a reasonable standardization)
   - Servings count is preserved
   - Source attribution is preserved
   - Calorie count is preserved (if present in original)

Report:
- PASS if the rewrite is faithful
- FAIL with specific issues if anything was changed, dropped, or added incorrectly
- WARN for anything ambiguous that the user should review

Be strict. The rewrite should improve clarity and consistency, not change the recipe.

What to Send the Verifier

ORIGINAL:
[paste the full original .tex file or source text]

REWRITTEN:
[paste the full new .tex file]

Handling Verification Results

• PASS: Proceed to insertion
• WARN: Note the warnings in the summary for the user
• FAIL: Fix the issues before proceeding. Re-verify after fixing.

Step 6: Structural Integrity Checks

In addition to the verification agent, run these automated checks:

Ingredient–Instruction Cross-Reference

For each ingredient, verify it appears (by name or synonym) in the instructions. Flag ingredients that are listed but never referenced — they might be garnishes (acceptable) or actually missing from instructions (problem).

Structural Checks

• Every ingredient line ends with \\
• \inggroup{} names match {\bfseries} section headers in instructions (if applicable)
• Fractions use \sfrac{}{} not plain text fractions
• Units are standardized (tbsp not tbs, tsp not teaspoon, etc.)
• No \textbf{} anywhere — only {\bfseries} for headers, \recipenotes for notes
• Recipe metadata has all required fields (title, servings, source)
• File has proper LaTeX structure (matching begin/end tags)

Run the automated verifier script:

python .claude/skills/recipe-integration/scripts/verify_recipe.py recipes/new_recipe.tex

Step 7: Tag for Recipe Index

The recipe index includes ingredient-based sub-categories. Recipes are tagged via the tags metadata key.

Available Tags

• Lentils and Dal — lentils, dal, split peas, moong, masoor
• Beans — kidney beans, black beans, pinto beans, rajma, refried beans (NOT chickpeas)
• Chickpeas — chickpeas, chana, falafel, hummus
• Tofu — tofu as a featured ingredient
• Paneer — paneer as a featured ingredient
• Tempeh — tempeh as a featured ingredient
• Potatoes — potatoes as a hero/primary ingredient (not a minor addition)
• Chocolate — chocolate/cocoa as the defining ingredient

Tagging Process

1. Run the auto-tagger to get initial suggestions:

python .claude/skills/recipe-integration/scripts/add_tags.py --dry-run

2. Review the suggestions. The script uses keyword matching which can produce false positives. Apply these judgment rules:

   • A recipe should only be tagged for an ingredient if that ingredient is a hero/defining part of the dish — not a minor addition
   • A recipe can have multiple tags (e.g., {Lentils and Dal, Potatoes}) — each tag generates a separate index entry
   • Component recipes (spice mixes, sauces) generally should NOT be tagged unless the ingredient truly defines them
   • When in doubt, leave the tag off — a smaller, curated index is more useful than an exhaustive one

3. If the auto-tagger's suggestions look correct, run without --dry-run to apply. Otherwise, set the tags manually in the recipe metadata:

\begin{recipe}[
  ...
  tags     = {Tofu, Potatoes},
]

Step 8: Insert into Cookbook

1. Save the .tex file to the recipes/ directory
2. Determine the correct chapter in main.tex:
   • Breakfast and Brunch — morning dishes, muffins, eggs
   • Sides and Appetizers — salads (as sides), appetizers, snacks
   • Soups and Salads — soups and main-course salads
   • Mains — entrees, curries, pastas, sandwiches, bowls
   • Components — base ingredients used in other recipes (pastes, seasonings, cheese)
   • Desserts — sweets, cakes, cookies, bars
3. Add \input{recipes/filename} in the appropriate position within that chapter
4. Place it logically near similar recipes (e.g., Indian curries together, pastas together)

Step 9: Compile the PDF

After inserting the recipe, recompile the cookbook PDF. The cookbook uses fontspec for custom fonts, so it must be compiled with XeLaTeX (not pdfLaTeX):

latexmk -xelatex -interaction=nonstopmode main.tex

Verify the build succeeds and check the final page count in the output.

Step 10: Confirm with User

Before considering the task done, present a summary:

• Recipe title and file name
• Which chapter it was added to
• Calorie count
• Tags assigned (or "none" if no ingredient tags apply)
• Verification result (PASS/WARN/FAIL and any notes)
• Any integrity warnings from the automated checks

Ask the user to confirm or request changes.

Handling Edge Cases

• Duplicate recipes: Check if a recipe with a very similar title already exists. If so, inform the user and suggest naming conventions (e.g., chana_masala2.tex).
• Component recipes: If the recipe is a base component (spice mix, paste, cheese), add it to the Components chapter and use \label{components:keyname}.
• Book sources: Format as source = {{\normalfont Book Title} by Author (p. N)}
• Cross-references: If the recipe references other recipes in the cookbook (e.g., uses ginger garlic paste), add \pageref{} links.
• Very long recipes: These are fine — the paracol layout handles multi-page recipes.
• Recipes with no clear servings: Ask the user. Don't guess.

Available Components for Cross-Reference

These component recipes exist in the cookbook and can be referenced:

• \pageref{components:gingergarlicpaste} — Ginger Garlic Paste
• \pageref{components:taco_seasoning} — Taco Seasoning
• \pageref{components:paneer} — Paneer
• \pageref{components:paneer_spice_mix} — Paneer Spice Mix

If a new recipe uses one of these components, reference it in the ingredient line:

4\sfrac{1}{2} tsp ginger garlic paste (p.~\pageref{components:gingergarlicpaste}) \\