Recipe

Recipe Skill — Receptidéer & Nya recept

Profil

Läs .claude/cowork-instructions.md om den finns. Den definierar ton och samarbetsstil. Följ den.

Syfte

Hjälp användaren brainstorma receptidéer och spara nya recept i databasen. Visa preview i chatten, skriv till databasen först när användaren säger "push".

Edits hanteras av en separat skill. Om användaren vill ändra något i ett redan publicerat recept — efterkok-reflektion, ny version, justering — invokera edit-recipe-skillen istället. Den här skillen handlar om nya recept.

Språk

Alla recept, ingredienser och instruktioner ska vara på svenska.

Miljö-detektion — Två lägen

Skillen körs i två miljöer med olika capabilities:

• Claude Code-läge (terminal på Macbook): Har direkt SSH-access till VPS:en (ssh minvps). Skriver direkt till auktoritativ databas på VPS.
• Cowork-läge (desktop-app, sandboxed): Har ingen nätverksaccess till VPS. Skriver "pending commits" till fil — Claude Code applicerar dem senare.

Detektera vid sessionsstart:

ssh -o ConnectTimeout=5 -o BatchMode=yes minvps 'echo ok' 2>/dev/null

• Exit 0 → Claude Code-läge.
• Annat → Cowork-läge.

Kommunicera tydligt med användaren i början av en arbetsflödes-sekvens vilket läge som är aktivt, särskilt vid push ("sparad direkt till VPS" vs "sparad som pending commit — växla till Claude Code för att applicera").

Databas

Schema

recipe (id, title, description, instructions, notes, image_url, tags, section, menu)
ingredient (id, name, grocery_category, notes, kitchen_staple)
recipe_ingredient (recipe_id, ingredient_id, amount, unit, note)
recipe_version (id, recipe_id, version_number, title, description, instructions, notes,
                image_url, tags, section, menu, ingredients_json, changed_at, changed_by, change_note)

Auktoritativ DB-path (Claude Code-läge)

På VPS: /opt/recipe-db/data/recipe.db. Nås via ssh minvps.

För en snabb läsning från VPS:

ssh minvps "sqlite3 /opt/recipe-db/data/recipe.db 'SELECT ...'"

För en transaktion (bygg SQL som text, pipea in):

cat sql-kommandon.sql | ssh minvps 'sqlite3 /opt/recipe-db/data/recipe.db'

Viktigt: inkapsla alla skrivoperationer i BEGIN; ... COMMIT; (eller ROLLBACK vid fel).

Lokal snapshot (Cowork-läge)

I Cowork-läge finns en lokal recipe.db i projektroten som en read-only snapshot av VPS-databasen. Skillen använder den för:

• Ingrediens-matching (best-effort: "denna ingrediens finns troligen redan")
• Preview-data (titlar av existerande recept etc.)

Skillen skriver aldrig till lokal recipe.db i Cowork-läge. All data skapas som pending-commit-JSON.

Hitta lokal DB dynamiskt:

import glob
hits = glob.glob("/sessions/*/mnt/recipe-db/recipe.db")
db_path = hits[0] if hits else None

Om snapshoten saknas/är tom: arbeta vidare med anteckning till användaren ("kunde inte läsa lokal snapshot — ingrediens-matching blir best effort; gör en scp från VPS om du vill ha aktuell data").

Läs-mönster (gäller båda lägen för lokal snapshot)

Det monterade filsystemet (Cowork) stöder inte SQLites journal-mode vid läsning med öppna handles. Använd copy-to-temp vid läsning av lokal snapshot:

import sqlite3, shutil, tempfile, os

def read_snapshot(db_path):
    tmp = tempfile.mktemp(suffix='.db')
    shutil.copy(db_path, tmp)
    conn = sqlite3.connect(tmp)
    return conn, tmp  # ansvar att stänga conn + radera tmp

Befintliga grocery_category-värden

Frukt och grönt, Fläsk, Kött, Smaksättare, Alkohol, Konserver, Mejeri, Fågel, Kolhydrater, Färdiga tillbehör, Färska örter, Baljväxter, Övrigt.

Befintliga tags-konventioner

Kommaseparerade, gemener: t.ex. italiensk,pasta eller stark, nötkött.

Arbetsflöde — Nytt recept

Steg 1 — Brainstorming

Ge kompletta receptförslag direkt (titel, beskrivning, ingredienser med mängd/enhet, numrerade instruktioner). Anpassa efter användarens önskemål. Var kreativ men praktisk — rätter man faktiskt vill laga hemma.

Steg 2 — Commit preview

När användaren gillar ett recept och vill spara:

1. Läs snapshot (Cowork) eller läs VPS (Claude Code) för ingrediens-matching.
2. Föreslå kategorisering: tags, section, menu (tema med emoji).
3. Visa preview:

📝 COMMIT PREVIEW — NYTT RECEPT
═══════════════════════════════════

📖 Recept: [titel]
   tags: [tags]
   section: [section]
   menu: [menu]

🥕 Ingredienser:
   - [namn] — [mängd] [enhet]   (ny / existerande)
   - ...

═══════════════════════════════════
Säg "push" för att spara,
eller ge feedback för att justera.

I Cowork-läge: visa inte numeriska ID:n (de tilldelas vid push mot VPS). I Claude Code-läge: visa preliminärt ID (MAX(id)+1 från VPS).

Steg 3 — Push

Claude Code-läge: Direkt mot VPS.

1. Via SSH, kör en transaktion mot /opt/recipe-db/data/recipe.db:
   • MAX(id) + 1 för nytt recept.
   • För varje ingrediens: LOWER(name)-matcha → återanvänd ID eller skapa ny.
   • INSERT i recipe.
   • INSERT i recipe_ingredient.
   • INSERT i recipe_version med version_number = 1, changed_by = 'chat', changed_at = <ISO-timestamp>, ingredients_json = <serialiserad lista>.
2. Bekräfta:

✅ Sparat på VPS! [titel] (id: [id], version: 1)
   - [X] ingredienser kopplade ([Y] nya skapade)

Cowork-läge: Skriv pending-commit.

1. Bygg commit-objekt (schema nedan), skriv till .claude/pending-commits/<ISO-timestamp>_<slug>.json.
2. Bekräfta:

📦 Pending commit skapad: [filnamn]
   Öppna Claude Code i projektmappen och säg "apply pending"
   för att skriva till VPS-databasen.

"apply pending" (endast Claude Code-läge)

När användaren säger "apply pending" eller "push pending":

1. ls .claude/pending-commits/ — om tomt, rapportera det.
2. Visa batch-preview: en rad per commit med filnamn, operation, titel.
3. Vid bekräftelse, för varje fil:
   • Parsa JSON.
   • Kör push-flödet ovan (just nu bara operation: "create" — edits hanteras av edit-recipe-skillen via HTTP-API och ligger inte i pending-kön).
   • Vid success: mv <fil> .claude/applied-commits/.
   • Vid error: rapportera, låt filen ligga kvar.
4. Rapportera slutresultat:

✅ Applicerat [N] pending commits
⚠️  [M] kvar i pending (se fel ovan)

Pending-commit JSON-schema

{
  "schema_version": "1",
  "operation": "create",
  "title": "Snabbtacos med halloumi",
  "description": "...",
  "instructions": "1. ...\n2. ...",
  "notes": null,
  "image_url": null,
  "tags": "vegetariskt,tacos",
  "section": "Tacos",
  "menu": "🌮 Mexikanskt",
  "ingredients": [
    {
      "name": "halloumi",
      "amount": "250",
      "unit": "g",
      "note": "",
      "kitchen_staple": 0,
      "grocery_category": "Mejeri"
    }
  ],
  "created_at": "2026-04-19T22:30:00Z",
  "created_by": "cowork"
}

Filnamn: .claude/pending-commits/<YYYY-MM-DDTHH-MM-SSZ>_<slug>.json. slug = lowercase, bindestreck istället för mellanslag, ASCII-safe.

Notera: operation: "update" används inte längre i pending-commit-flödet — edits hanteras av edit-recipe-skillen via HTTP-API. Den här skillen ska bara producera create-commits.

Viktiga regler

• ID-hantering: Läs alltid MAX(id) från auktoritativ DB (VPS i Claude Code-läge) innan insert. Aldrig hårdkodade ID:n.
• Ingrediensmatchning: Case-insensitive (LOWER(name)) för att undvika dubbletter.
• Nya ingredienser: kitchen_staple = 1 för vanliga skafferisaker (salt, peppar, olja, etc.), annars 0.
• Instruktioner: Numrerade steg, separerade med newlines.
• image_url: Lämna som NULL (hanteras via webb-UI).
• notes: NULL om inget speciellt.
• Transaktioner: Alla skrivningar inom BEGIN; ... COMMIT; (ROLLBACK vid fel).
• Visa alltid preview innan push — aldrig direkt till DB utan bekräftelse.
• Versionshistorik: Varje push (nytt eller edit) loggar en rad i recipe_version.
• Lokal snapshot skrivs aldrig: I Cowork-läge är lokal recipe.db strikt read-only. All skrivning går till pending-commit-fil.
• Edits → annan skill: Om användaren vill ändra ett befintligt recept, säg "Det här är edit-recipe-territorium — invokera den" istället för att gå vidare.