pantrybase 0.2.0 → 0.3.0

package/dist/server.js

@@ -5,9 +5,11 @@ import {
   MODEL_MAX_PX,
   SOURCE_KINDS,
   addToPantry,
+  autofillPlan,
   availableIngredients,
   closeAllContexts,
   finalizeAttach,
+  getPlan,
   imageForModel,
   importPaths,
   listPantry,
@@ -26,15 +28,19 @@ import {
   recipeInputSchema,
   reconcile,
   removeFromPantry,
+  renderShoppingList,
   resolveItem,
   resolveItems,
   rotateItem,
+  savePlan,
   scoreRecipes,
   searchRecipes,
+  shoppingList,
   startUiServer,
+  suggestRecipes,
   viewItems,
   writeRecipeFile
-} from "./chunk-QUWSBZ2V.js";
+} from "./chunk-IUQQ3I2E.js";
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -482,13 +488,163 @@ var pb_pantry_match_default = defineTool({
   }
 });
 
-// src/mcp/tools/pb_providers.ts
+// src/mcp/tools/pb_plan.ts
 import { z as z13 } from "zod";
+var pb_plan_default = defineTool({
+  name: "pb_plan",
+  description: "The saved meal plan (shared with the web UI). get: the planned recipes and how much they share. set: replace the plan with `slugs`. add / remove: adjust it. clear: empty it. `servings` sets the portions wanted per recipe (quantities on the shopping list scale from the recipe's own servings).",
+  schema: {
+    action: z13.enum(["get", "set", "add", "remove", "clear"]),
+    slugs: z13.array(z13.string()).optional(),
+    servings: z13.record(z13.string(), z13.number().positive()).optional().describe("slug \u2192 portions wanted, e.g. {'harissa-chicken-traybake': 4}")
+  },
+  handler: ({ action, slugs, servings }, ctx) => {
+    const current = getPlan(ctx);
+    let items = current.items;
+    if (action === "clear") items = [];
+    else if (action === "set") items = (slugs ?? []).map((slug) => ({ slug }));
+    else if (action === "add") {
+      if (!slugs?.length) return errorResult("slugs required");
+      const have = new Set(items.map((i) => i.slug));
+      items = [...items, ...slugs.filter((s) => !have.has(s)).map((slug) => ({ slug }))];
+    } else if (action === "remove") {
+      if (!slugs?.length) return errorResult("slugs required");
+      const drop = new Set(slugs);
+      items = items.filter((i) => !drop.has(i.slug));
+    }
+    if (servings) {
+      items = items.map((i) => servings[i.slug] ? { ...i, servings: servings[i.slug] } : i);
+    }
+    const unknown = (slugs ?? []).filter((s) => !ctx.store.getRecipe(s));
+    const saved = action === "get" ? current : savePlan(ctx, { items, confirmed: current.confirmed });
+    const { plan } = suggestRecipes(ctx, { plan: saved.items.map((i) => i.slug), limit: 1 });
+    return text({
+      recipes: saved.items.map((i) => ({
+        slug: i.slug,
+        title: plan.recipes.find((r) => r.slug === i.slug)?.title,
+        servings: i.servings ?? void 0
+      })),
+      to_buy: plan.to_buy,
+      from_pantry: plan.from_pantry,
+      shared: plan.shared,
+      reuse: plan.reuse,
+      confirmed_pantry: saved.confirmed.length ? saved.confirmed : void 0,
+      unknown_slugs: unknown.length ? unknown : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_plan_shopping_list.ts
+import { z as z14 } from "zod";
+var pb_plan_shopping_list_default = defineTool({
+  name: "pb_plan_shopping_list",
+  description: "Grocery list for the saved plan (or `slugs`): distinct items to buy with merged quantities, grouped by aisle, each with the recipes that use it. `pantry_check` lists the pantry items the plan relies on \u2014 ask the user to confirm those are really there before the list is final; pass the ones they confirm as `confirmed` and the ones they're out of as `out_of` (those leave the pantry and move onto the list). `needs_confirmation` is empty once everything is settled. Staples (salt, oil\u2026) are listed separately.",
+  schema: {
+    slugs: z14.array(z14.string()).optional().describe("defaults to the saved plan"),
+    servings: z14.record(z14.string(), z14.number().positive()).optional().describe("slug \u2192 portions wanted; scales quantities"),
+    confirmed: z14.array(z14.string()).optional().describe("pantry items the user confirmed"),
+    out_of: z14.array(z14.string()).optional().describe("pantry items the user is out of"),
+    format: z14.enum(["json", "text"]).optional().describe("default json; text is paste-ready")
+  },
+  handler: ({ slugs, servings, confirmed, out_of, format }, ctx) => {
+    const items = slugs?.map((slug) => ({ slug, servings: servings?.[slug] ?? null }));
+    const list = shoppingList(ctx, { items, confirmed, out_of });
+    if (format === "text") return text(renderShoppingList(list));
+    return text({
+      recipes: list.recipes.map((r) => ({
+        title: r.title,
+        servings: r.servings ?? void 0,
+        scaled: r.scale !== 1 ? `\xD7${Math.round(r.scale * 100) / 100}` : void 0
+      })),
+      buy: list.buy.map((l) => ({
+        item: l.canonical,
+        amount: l.amount ?? void 0,
+        aisle: l.aisle,
+        for: l.for
+      })),
+      pantry_check: list.pantry_check.map((c) => ({
+        item: c.canonical,
+        amount: c.amount ?? void 0,
+        in_pantry: c.in_pantry ?? void 0,
+        for: c.for,
+        confirmed: c.confirmed
+      })),
+      needs_confirmation: list.needs_confirmation.length ? list.needs_confirmation : void 0,
+      optional: list.optional.length ? list.optional.map((l) => l.canonical) : void 0,
+      staples: list.staples,
+      summary: {
+        to_buy: list.summary.to_buy,
+        from_pantry: list.summary.from_pantry,
+        shared: list.summary.shared,
+        reuse: list.summary.reuse
+      },
+      removed_from_pantry: list.removed_from_pantry.length ? list.removed_from_pantry : void 0,
+      unknown_slugs: list.unknown_slugs.length ? list.unknown_slugs : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_plan_suggest.ts
+import { z as z15 } from "zod";
+var pb_plan_suggest_default = defineTool({
+  name: "pb_plan_suggest",
+  description: "Meal planning around shared ingredients. Given a seed recipe and/or the current plan, ranks recipes by how much of their shopping is already covered \u2014 `shares` (already on the list for another planned recipe), `from_pantry`, and `new` (what they would add). `reuse` is the covered share (0\u20131), weighted so fresh items count more than dry goods. Repeating a planned dish is penalised unless variety:false. With `auto: n` it instead fills the plan with n more recipes that minimise the whole list (beam search) and returns the resulting slugs \u2014 save them with pb_plan. Nothing is saved by this tool.",
+  schema: {
+    seed: z15.string().optional().describe("recipe slug to plan around"),
+    plan: z15.array(z15.string()).optional().describe("slugs already planned; defaults to the saved plan"),
+    auto: z15.number().int().min(1).max(14).optional().describe("fill the plan with this many more"),
+    limit: z15.number().int().min(1).max(50).optional().describe("default 8"),
+    variety: z15.boolean().optional().describe("default true"),
+    use_pantry: z15.boolean().optional().describe("default true"),
+    tags: z15.partialRecord(z15.enum(ALL_CATEGORIES), z15.array(z15.string())).optional(),
+    exclude_allergens: z15.array(z15.string()).optional(),
+    exclude_ingredients: z15.array(z15.string()).optional(),
+    max_total_min: z15.number().optional()
+  },
+  handler: ({ seed, plan, auto, limit, variety, use_pantry, ...filters }, ctx) => {
+    if (auto) {
+      const r2 = autofillPlan(ctx, { seed, plan, count: auto, variety, use_pantry, filters });
+      return text({
+        plan_slugs: r2.slugs,
+        added: r2.added.map((s) => ({
+          slug: s.slug,
+          title: s.title,
+          reuse: s.reuse,
+          shares: s.shares,
+          from_pantry: s.from_pantry,
+          new: s.new,
+          repeats: s.repeats
+        })),
+        summary: r2.plan,
+        unknown_slugs: r2.unknown_slugs.length ? r2.unknown_slugs : void 0,
+        next: "Show the user the plan; when they agree, pb_plan {action:'set', slugs: plan_slugs}."
+      });
+    }
+    const r = suggestRecipes(ctx, { seed, plan, limit: limit ?? 8, variety, use_pantry, filters });
+    return text({
+      plan: r.plan,
+      suggestions: r.suggestions.map((s) => ({
+        slug: s.slug,
+        title: s.title,
+        total_min: s.total_min ?? void 0,
+        reuse: s.reuse,
+        shares: s.shares,
+        from_pantry: s.from_pantry,
+        new: s.new,
+        repeats: s.repeats
+      })),
+      unknown_slugs: r.unknown_slugs.length ? r.unknown_slugs : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_providers.ts
+import { z as z16 } from "zod";
 var pb_providers_default = defineTool({
   name: "pb_providers",
   description: "Meal-box provider profiles. Without `id`: list them (id, name, how to recognise a card). With `id`: the extraction guide for that provider's cards plus the tag vocabulary \u2014 read it once before extracting a batch of cards.",
   schema: {
-    id: z13.string().optional().describe('e.g. "ucook"; "generic" for anything else')
+    id: z16.string().optional().describe('e.g. "ucook"; "generic" for anything else')
   },
   handler: ({ id }, ctx) => {
     if (!id) {
@@ -528,13 +684,13 @@ var pb_providers_default = defineTool({
 });
 
 // src/mcp/tools/pb_rebuild.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 var pb_rebuild_default = defineTool({
   name: "pb_rebuild",
   description: "Re-sync the index from pantrybase/recipes/*.md (markdown is the source of truth), reloading ingredients.yaml, vocabulary.yaml and provider profiles. Default is incremental (mtime/hash); full:true re-parses every file (use after editing the vocabulary or catalog); reembed:true also recomputes all embeddings.",
   schema: {
-    full: z14.boolean().optional(),
-    reembed: z14.boolean().optional()
+    full: z17.boolean().optional(),
+    reembed: z17.boolean().optional()
   },
   handler: ({ full, reembed }, ctx) => {
     const reloaded = ctx.refresh(true);
@@ -544,7 +700,7 @@ var pb_rebuild_default = defineTool({
 });
 
 // src/mcp/tools/pb_save_recipe.ts
-import { z as z15 } from "zod";
+import { z as z18 } from "zod";
 
 // src/files/slug.ts
 var MAX_SLUG = 60;
@@ -645,10 +801,10 @@ var pb_save_recipe_default = defineTool({
   description: "Save a recipe (new or, with `slug`, an update). Writes pantrybase/recipes/<slug>.md as the source of truth and indexes it. For meal-box cards read pb_providers {id} first and follow its guide; set provider.id so its rules apply. Pass `ingest` with every inbox photo of the card ({id, side}) \u2014 they are archived to images/<slug>/ and marked done; re-sending already-attached photos is a safe no-op. Ingredients need `raw` (as printed) and `canonical` (generic singular name, no brand) plus source box|kitchen. Steps are objects {title, text, techniques, uses, equipment, temp_c, minutes} (plain strings are accepted). Tags by category (protein, diet, starch, flavor, texture, cuisine, dish, meal, method, time, season, other) are normalised against the vocabulary. Write a `blurb` in your own words for semantic search and record unreadable fields in extraction.uncertain. Returns {saved, slug, \u2026} or {saved:false, duplicate_of:[\u2026]} \u2014 if it is a different recipe pass allow_duplicate:true; if it is the same card, attach the photos to that slug or skip them.",
   schema: {
     ...recipeInputSchema.shape,
-    ingest: z15.array(z15.object({ id: z15.number().int(), side: z15.enum(IMAGE_SIDES) })).optional().describe(
+    ingest: z18.array(z18.object({ id: z18.number().int(), side: z18.enum(IMAGE_SIDES) })).optional().describe(
       "Inbox photos of this card, e.g. [{id: 12, side: 'front'}, {id: 13, side: 'back'}]"
     ),
-    allow_duplicate: z15.boolean().optional()
+    allow_duplicate: z18.boolean().optional()
   },
   handler: ({ allow_duplicate, ingest, ...input }, ctx) => {
     return text(saveRecipe(ctx, input, { allow_duplicate, ingest }));
@@ -656,22 +812,22 @@ var pb_save_recipe_default = defineTool({
 });
 
 // src/mcp/tools/pb_search.ts
-import { z as z16 } from "zod";
+import { z as z19 } from "zod";
 var pb_search_default = defineTool({
   name: "pb_search",
   description: "Search recipes: hybrid keyword + semantic ranking (RRF) over title, blurb, ingredients and method, with filters. Omit `query` to just filter/browse. Tag filters accept any category \u2014 assigned tags (cuisine, diet, dish, protein, flavor\u2026) and derived facets (allergen, equipment, technique, chef, provider, plan); parents expand (cuisine:asian matches thai). Returns compact summaries; use pb_get_recipe for details.",
   schema: {
-    query: z16.string().optional().describe("Free text: dish, ingredient, technique, mood, occasion\u2026"),
-    limit: z16.number().int().min(1).max(100).optional().describe("default 10"),
-    tags: z16.partialRecord(z16.enum(ALL_CATEGORIES), z16.array(z16.string())).optional().describe("e.g. {cuisine:['thai'], diet:['vegetarian']} \u2014 OR within a category, AND across"),
-    exclude_allergens: z16.array(z16.string()).optional().describe('e.g. ["dairy", "tree-nuts"]'),
-    exclude_ingredients: z16.array(z16.string()).optional(),
-    max_total_min: z16.number().optional(),
-    max_active_min: z16.number().optional().describe("Hands-on minutes"),
-    provider: z16.string().optional(),
-    source_kind: z16.enum(SOURCE_KINDS).optional(),
-    needs_review: z16.boolean().optional().describe("true = only recipes flagged for review"),
-    mode: z16.enum(["hybrid", "lexical", "semantic"]).optional()
+    query: z19.string().optional().describe("Free text: dish, ingredient, technique, mood, occasion\u2026"),
+    limit: z19.number().int().min(1).max(100).optional().describe("default 10"),
+    tags: z19.partialRecord(z19.enum(ALL_CATEGORIES), z19.array(z19.string())).optional().describe("e.g. {cuisine:['thai'], diet:['vegetarian']} \u2014 OR within a category, AND across"),
+    exclude_allergens: z19.array(z19.string()).optional().describe('e.g. ["dairy", "tree-nuts"]'),
+    exclude_ingredients: z19.array(z19.string()).optional(),
+    max_total_min: z19.number().optional(),
+    max_active_min: z19.number().optional().describe("Hands-on minutes"),
+    provider: z19.string().optional(),
+    source_kind: z19.enum(SOURCE_KINDS).optional(),
+    needs_review: z19.boolean().optional().describe("true = only recipes flagged for review"),
+    mode: z19.enum(["hybrid", "lexical", "semantic"]).optional()
   },
   handler: async ({ query, limit, mode, ...filters }, ctx) => {
     const res = await searchRecipes(ctx, { query, limit, mode, filters });
@@ -712,7 +868,7 @@ var pb_stats_default = defineTool({
 });
 
 // src/mcp/tools/pb_synthesis_context.ts
-import { z as z17 } from "zod";
+import { z as z20 } from "zod";
 
 // src/synthesis/context.ts
 var STEP_CHARS = 220;
@@ -846,14 +1002,14 @@ var pb_synthesis_context_default = defineTool({
   name: "pb_synthesis_context",
   description: "Material for inventing a new recipe from the collection: a few relevant source recipes in compact form, the ingredients, pairings, techniques, cuisines and flavours they share, and (with use_pantry) what the pantry covers and what is commonly missing. Pick sources by `query`, explicit `slugs`, pantry fit, or tag filters. Then write the recipe and save it with pb_save_recipe (source.kind 'synthesized', derived_from the slugs you drew on).",
   schema: {
-    query: z17.string().optional().describe('What to make, e.g. "quick spicy noodle dinner"'),
-    slugs: z17.array(z17.string()).optional(),
-    use_pantry: z17.boolean().optional(),
-    ingredients: z17.array(z17.string()).optional().describe("Extra things available right now"),
-    tags: z17.partialRecord(z17.enum(ALL_CATEGORIES), z17.array(z17.string())).optional(),
-    exclude_allergens: z17.array(z17.string()).optional(),
-    max_total_min: z17.number().optional(),
-    n: z17.number().int().min(1).max(12).optional().describe("Number of source recipes (default 5)")
+    query: z20.string().optional().describe('What to make, e.g. "quick spicy noodle dinner"'),
+    slugs: z20.array(z20.string()).optional(),
+    use_pantry: z20.boolean().optional(),
+    ingredients: z20.array(z20.string()).optional().describe("Extra things available right now"),
+    tags: z20.partialRecord(z20.enum(ALL_CATEGORIES), z20.array(z20.string())).optional(),
+    exclude_allergens: z20.array(z20.string()).optional(),
+    max_total_min: z20.number().optional(),
+    n: z20.number().int().min(1).max(12).optional().describe("Number of source recipes (default 5)")
   },
   handler: async ({ query, slugs, use_pantry, ingredients, n, ...filters }, ctx) => text(await synthesisContext(ctx, { query, slugs, use_pantry, ingredients, n, filters }))
 });
@@ -870,6 +1026,10 @@ var tools = [
   pb_pantry_list,
   pb_pantry_add,
   pb_pantry_remove,
+  // meal planning
+  pb_plan_suggest_default,
+  pb_plan_default,
+  pb_plan_shopping_list_default,
   // capture
   pb_providers_default,
   pb_ingest_source_default,