feat: pantry notes/categories, ingredient-alias matching, cook-log edit/delete, fork-list popover (v0.83.0)

Pantry: notes + category fields (collapsible grouping like the shopping list), a "Merge duplicates" cleanup action, and fixed quantity display precision (was showing raw decimal(10,4) strings like "0.3333 kg" everywhere — pantry, shopping list, print views, Markdown exports).

Ingredient-alias matching: the ingredients table (canonical name + aliases) existed but was never populated or used. Seeded ~10 bilingual EN/FR staples and wired resolution into pantry add/edit, can-cook scoring, auto-deduct-on-cook, and shopping-list pantry-awareness, so "sel"/"sel fin"/"table salt" are recognized as the same ingredient.

Cook log: entries from "Mark cooked" can now be edited and deleted (previously log-only, no fix-a-mistake path). The "Cooked N times" text is a hover tooltip listing every date and opens a full manage sheet on click.

Also: the "Forked by N others" backlink is now a click-to-open popover instead of an always-inline list.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

apps/web/app/api/v1/pantry/[id]/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { db, pantryItems, eq, and } from "@epicure/db";
 import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { findIngredientIdByName } from "@/lib/ingredient-match";
 
 type Params = { params: Promise<{ id: string }> };
 
@@ -18,15 +19,23 @@ export async function PUT(req: NextRequest, { params }: Params) {
     rawName: z.string().min(1).max(200).optional(),
     quantity: z.string().nullable().optional(),
     unit: z.string().nullable().optional(),
+    notes: z.string().max(500).nullable().optional(),
+    aisle: z.string().max(50).nullable().optional(),
     expiresAt: z.string().datetime().nullable().optional(),
   }).safeParse(body);
   if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
 
   const data = parsed.data;
+  // Renaming can change which canonical ingredient this item resolves to
+  // (e.g. "sel" -> "sel de table") — re-resolve whenever rawName changes,
+  // rather than leaving a stale link from the item's original name.
+  const ingredientId = data.rawName ? await findIngredientIdByName(data.rawName) : undefined;
   await db.update(pantryItems).set({
-    ...(data.rawName && { rawName: data.rawName }),
+    ...(data.rawName && { rawName: data.rawName, ingredientId }),
     ...(data.quantity !== undefined && { quantity: data.quantity ?? undefined }),
     ...(data.unit !== undefined && { unit: data.unit ?? undefined }),
+    ...(data.notes !== undefined && { notes: data.notes ?? undefined }),
+    ...(data.aisle !== undefined && { aisle: data.aisle ?? undefined }),
     ...(data.expiresAt !== undefined && { expiresAt: data.expiresAt ? new Date(data.expiresAt) : undefined }),
   }).where(eq(pantryItems.id, id));
 

apps/web/app/api/v1/pantry/bulk/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { db, pantryItems, eq } from "@epicure/db";
 import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { loadIngredientAliasIndex, resolveIngredientKey, findIngredientIdByName } from "@/lib/ingredient-match";
 
 const Schema = z.object({
   items: z.array(z.object({
@@ -20,14 +21,15 @@ export async function POST(req: NextRequest) {
   if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
 
   const userId = session!.user.id;
-  const existing = await db.query.pantryItems.findMany({
-    where: eq(pantryItems.userId, userId),
-  });
+  const [existing, aliasIndex] = await Promise.all([
+    db.query.pantryItems.findMany({ where: eq(pantryItems.userId, userId) }),
+    loadIngredientAliasIndex(),
+  ]);
 
   for (const incoming of parsed.data.items) {
-    const key = incoming.rawName.toLowerCase();
+    const key = resolveIngredientKey(incoming.rawName, aliasIndex);
     const match = existing.find(
-      (e) => e.rawName.toLowerCase() === key && (e.unit ?? "") === (incoming.unit ?? "")
+      (e) => resolveIngredientKey(e.rawName, aliasIndex) === key && (e.unit ?? "") === (incoming.unit ?? "")
     );
 
     if (match) {
@@ -41,13 +43,18 @@ export async function POST(req: NextRequest) {
       }
       // if quantities aren't numeric, leave as-is (item already exists)
     } else {
-      await db.insert(pantryItems).values({
+      const ingredientId = await findIngredientIdByName(incoming.rawName);
+      const created = {
         id: crypto.randomUUID(),
         userId,
+        ingredientId,
         rawName: incoming.rawName,
         quantity: incoming.quantity,
         unit: incoming.unit,
-      });
+      };
+      await db.insert(pantryItems).values(created);
+      // Later items in this same batch can now also match this one.
+      existing.push({ ...created, notes: null, aisle: null, expiresAt: null, quantity: created.quantity ?? null, unit: created.unit ?? null, createdAt: new Date() });
     }
   }
 

apps/web/app/api/v1/pantry/merge-duplicates/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, pantryItems, eq, asc, inArray } from "@epicure/db";
+import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { loadIngredientAliasIndex, resolveIngredientKey } from "@/lib/ingredient-match";
+
+function normalizeUnit(unit: string | null): string {
+  return (unit ?? "").trim().toLowerCase();
+}
+
+/**
+ * One-shot cleanup for pantry items that turn out to be the same ingredient
+ * under different names ("sel", "sel fin", "sel de table") — a case the
+ * alias index (lib/ingredient-match.ts) only prevents going forward, not
+ * for rows added before it existed. Groups by resolved ingredient key +
+ * normalized unit; for any group with more than one row, merges into the
+ * oldest row and deletes the rest.
+ *
+ * Quantities are only summed when every row in the group has a parseable
+ * quantity — mixing a known and an unknown amount would silently invent a
+ * number, so the first known quantity is kept instead. Notes are
+ * concatenated (nothing is dropped); expiresAt keeps the soonest date
+ * (the conservative choice — better to under-promise freshness than over).
+ */
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSessionOrApiKey(req);
+  if (response) return response;
+  const userId = session!.user.id;
+
+  const [items, aliasIndex] = await Promise.all([
+    db.query.pantryItems.findMany({ where: eq(pantryItems.userId, userId), orderBy: asc(pantryItems.createdAt) }),
+    loadIngredientAliasIndex(),
+  ]);
+
+  const groups = new Map<string, typeof items>();
+  for (const item of items) {
+    const key = `${resolveIngredientKey(item.rawName, aliasIndex)}::${normalizeUnit(item.unit)}`;
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+
+  let mergedGroups = 0;
+  let removed = 0;
+  const idsToDelete: string[] = [];
+
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    mergedGroups++;
+
+    const [survivor, ...rest] = group;
+    const quantities = group.map((i) => (i.quantity ? parseFloat(i.quantity) : null));
+    const allParseable = quantities.every((q) => q !== null && !isNaN(q));
+    const mergedQuantity = allParseable
+      ? String(quantities.reduce((sum, q) => sum! + q!, 0))
+      : quantities.find((q) => q !== null && !isNaN(q))?.toString() ?? survivor!.quantity;
+
+    const mergedNotes = [...new Set(group.map((i) => i.notes?.trim()).filter((n): n is string => !!n))].join("; ") || null;
+    const mergedAisle = group.find((i) => i.aisle)?.aisle ?? null;
+    const mergedIngredientId = group.find((i) => i.ingredientId)?.ingredientId ?? null;
+    const expiryDates = group.map((i) => i.expiresAt).filter((d): d is Date => d !== null);
+    const mergedExpiresAt = expiryDates.length > 0 ? new Date(Math.min(...expiryDates.map((d) => d.getTime()))) : null;
+
+    await db.update(pantryItems).set({
+      quantity: mergedQuantity,
+      notes: mergedNotes,
+      aisle: mergedAisle,
+      ingredientId: mergedIngredientId,
+      expiresAt: mergedExpiresAt,
+    }).where(eq(pantryItems.id, survivor!.id));
+
+    idsToDelete.push(...rest.map((i) => i.id));
+    removed += rest.length;
+  }
+
+  if (idsToDelete.length > 0) {
+    await db.delete(pantryItems).where(inArray(pantryItems.id, idsToDelete));
+  }
+
+  return NextResponse.json({ mergedGroups, removed });
+}

apps/web/app/api/v1/pantry/route.ts

@@ -2,11 +2,14 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { db, pantryItems, eq, desc, sql } from "@epicure/db";
 import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { findIngredientIdByName } from "@/lib/ingredient-match";
 
 const Schema = z.object({
   rawName: z.string().min(1).max(200),
   quantity: z.string().optional(),
   unit: z.string().optional(),
+  notes: z.string().max(500).optional(),
+  aisle: z.string().max(50).optional(),
   expiresAt: z.string().datetime().optional(),
 });
 
@@ -47,12 +50,16 @@ export async function POST(req: NextRequest) {
   if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
 
   const id = crypto.randomUUID();
+  const ingredientId = await findIngredientIdByName(parsed.data.rawName);
   await db.insert(pantryItems).values({
     id,
     userId: session!.user.id,
+    ingredientId,
     rawName: parsed.data.rawName,
     quantity: parsed.data.quantity,
     unit: parsed.data.unit,
+    notes: parsed.data.notes,
+    aisle: parsed.data.aisle,
     expiresAt: parsed.data.expiresAt ? new Date(parsed.data.expiresAt) : undefined,
   });
 

apps/web/app/api/v1/recipes/[id]/cooked/[logId]/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, cookingHistory, eq, and, isNull } from "@epicure/db";
+import { requireSessionOrApiKey } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ id: string; logId: string }> };
+
+const PatchSchema = z.object({
+  servings: z.number().int().min(1).max(1000).nullable().optional(),
+  notes: z.string().max(2000).nullable().optional(),
+  cookedAt: z.string().optional(),
+});
+
+// Plain (non-batch) cook log entries only — see the sibling GET's comment.
+// Editing/deleting never touches pantry quantities: the deduction (if any)
+// already happened at creation time and isn't reversible from here.
+export async function PATCH(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSessionOrApiKey(req);
+  if (response) return response;
+  const { id, logId } = await params;
+
+  const log = await db.query.cookingHistory.findFirst({
+    where: and(eq(cookingHistory.id, logId), eq(cookingHistory.recipeId, id), eq(cookingHistory.userId, session!.user.id), isNull(cookingHistory.batchDishId)),
+  });
+  if (!log) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const parsed = PatchSchema.safeParse(await req.json().catch(() => null));
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const data = parsed.data;
+  const cookedAt = data.cookedAt ? new Date(data.cookedAt) : undefined;
+
+  await db.update(cookingHistory).set({
+    ...(data.servings !== undefined && { servings: data.servings ?? undefined }),
+    ...(data.notes !== undefined && { notes: data.notes ?? undefined }),
+    ...(cookedAt && !isNaN(cookedAt.getTime()) && { cookedAt }),
+  }).where(eq(cookingHistory.id, logId));
+
+  return NextResponse.json({ updated: true });
+}
+
+export async function DELETE(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSessionOrApiKey(req);
+  if (response) return response;
+  const { id, logId } = await params;
+
+  await db.delete(cookingHistory).where(
+    and(eq(cookingHistory.id, logId), eq(cookingHistory.recipeId, id), eq(cookingHistory.userId, session!.user.id), isNull(cookingHistory.batchDishId))
+  );
+
+  return new NextResponse(null, { status: 204 });
+}

apps/web/app/api/v1/recipes/[id]/cooked/route.ts

@@ -1,10 +1,28 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { db, recipes, cookingHistory, pantryItems, recipeIngredients, recipeBatchDishes, eq, and } from "@epicure/db";
+import { db, recipes, cookingHistory, pantryItems, recipeIngredients, recipeBatchDishes, eq, and, desc, isNull } from "@epicure/db";
 import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { loadIngredientAliasIndex, resolveIngredientKey } from "@/lib/ingredient-match";
 
 type Params = { params: Promise<{ id: string }> };
 
+// Plain (non-batch) cook log entries only — batch-cook dishes have their
+// own per-dish "cooked" indicator (dishCookedAtMap in the recipe page) and
+// aren't meant to be edited/removed one at a time here.
+export async function GET(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSessionOrApiKey(req);
+  if (response) return response;
+  const { id } = await params;
+
+  const logs = await db.query.cookingHistory.findMany({
+    where: and(eq(cookingHistory.recipeId, id), eq(cookingHistory.userId, session!.user.id), isNull(cookingHistory.batchDishId)),
+    orderBy: desc(cookingHistory.cookedAt),
+    columns: { id: true, cookedAt: true, servings: true, notes: true },
+  });
+
+  return NextResponse.json({ data: logs });
+}
+
 const Schema = z.object({
   servings: z.number().int().min(1).max(1000).optional(),
   notes: z.string().max(2000).optional(),
@@ -48,9 +66,10 @@ export async function POST(req: NextRequest, { params }: Params) {
   }
 
   const cookedAt = data.cookedAt ? new Date(data.cookedAt) : new Date();
+  const logId = crypto.randomUUID();
 
   await db.insert(cookingHistory).values({
-    id: crypto.randomUUID(),
+    id: logId,
     userId,
     recipeId: id,
     batchDishId: data.batchDishId,
@@ -70,11 +89,12 @@ export async function POST(req: NextRequest, { params }: Params) {
     const userPantry = await db.query.pantryItems.findMany({
       where: eq(pantryItems.userId, userId),
     });
+    const aliasIndex = await loadIngredientAliasIndex();
 
     for (const ing of ings) {
-      const key = ing.rawName.toLowerCase();
+      const key = resolveIngredientKey(ing.rawName, aliasIndex);
       const pantryItem = userPantry.find(
-        (p) => p.rawName.toLowerCase() === key && (p.unit ?? "") === (ing.unit ?? "")
+        (p) => resolveIngredientKey(p.rawName, aliasIndex) === key && (p.unit ?? "") === (ing.unit ?? "")
       );
       if (!pantryItem) continue;
 
@@ -97,5 +117,5 @@ export async function POST(req: NextRequest, { params }: Params) {
     }
   }
 
-  return NextResponse.json({ logged: true }, { status: 201 });
+  return NextResponse.json({ logged: true, id: logId }, { status: 201 });
 }

apps/web/app/api/v1/shopping-lists/route.ts

@@ -4,6 +4,7 @@ import { db, shoppingLists, shoppingListItems, mealPlans, mealPlanEntries, recip
 import { requireSessionOrApiKey } from "@/lib/api-auth";
 import { applyPantryToItems, mergeIngredients } from "@/lib/pantry-shopping-match";
 import { guessAisle } from "@/lib/grocery-categories";
+import { loadIngredientAliasIndex } from "@/lib/ingredient-match";
 
 const CreateSchema = z.object({
   name: z.string().min(1).max(100),
@@ -63,8 +64,11 @@ export async function POST(req: NextRequest) {
         // Reduce/flag quantities already covered by the user's pantry. Conservative: never silently
         // drops an item — fully-covered items are still inserted, flagged `inPantry`, so nothing
         // disappears from view without the user seeing it.
-        const pantry = await db.query.pantryItems.findMany({ where: eq(pantryItems.userId, session!.user.id) });
-        items = applyPantryToItems(mergedItems, pantry);
+        const [pantry, aliasIndex] = await Promise.all([
+          db.query.pantryItems.findMany({ where: eq(pantryItems.userId, session!.user.id) }),
+          loadIngredientAliasIndex(),
+        ]);
+        items = applyPantryToItems(mergedItems, pantry, aliasIndex);
       }
     }
   }