pantrybase 0.2.0 → 0.3.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pantrybase",
   "displayName": "Pantrybase",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Local-first recipe knowledge base for Claude Code: capture meal-box recipe cards from photos, search by ingredient, tag, allergen or mood, match recipes to your pantry, and synthesize new recipes. SQLite FTS5 + vector search, markdown recipes as the source of truth.",
   "author": {
     "name": "Ryan Dick"

package/README.md

@@ -79,6 +79,9 @@ steps:
 | `pb_search` | Hybrid keyword + semantic search with tag, allergen, time and review filters |
 | `pb_get_recipe` | One recipe, compact or full |
 | `pb_pantry_match` | Recipes ranked by pantry coverage, with what's missing |
+| `pb_plan_suggest` | Meal planning: recipes that share the shopping of a seed recipe or the current plan; `auto: n` fills a plan |
+| `pb_plan` | The saved meal plan (shared with the web UI): get, set, add, remove, servings |
+| `pb_plan_shopping_list` | One grocery list for the plan, by aisle with merged quantities; asks you to confirm the pantry items it relies on |
 | `pb_synthesis_context` | Source recipes and shared patterns for inventing a new recipe |
 | `pb_list_tags` | Tags and facets in use, plus the vocabulary |
 | `pb_pantry_list` / `_add` / `_remove` | Manage the pantry |
@@ -98,6 +101,7 @@ Skills: `/pantrybase:ingest` (capture cards) and `/pantrybase:cook` (find, match
 
 - **Recipes** — search with facets; recipe pages with photos, pantry ticks, steps, nutrition, allergens and lineage
 - **Pantry** — your inventory and *what can I cook*
+- **Plan** — pick a recipe, see which others share its shopping (what's already on the list, what's in the pantry, what each adds), auto-fill a week, confirm the pantry items the plan counts on, and get one grocery list by aisle
 - **Graph** — recipes, ingredients and tags as a navigable network
 - **Inbox** — drag-and-drop photo upload and the extraction queue
 - **Tags** — the whole vocabulary at a glance

package/dist/{chunk-QUWSBZ2V.js → chunk-IUQQ3I2E.js}

@@ -1925,8 +1925,8 @@ var SqliteAdapter = class {
     const where = recipeIds ? `WHERE ri.recipe_id IN (${placeholders(recipeIds.length)})` : "";
     if (recipeIds && recipeIds.length === 0) return [];
     const rows = this.s(
-      `SELECT ri.recipe_id, r.slug, r.title, ri.ingredient_id, i.canonical, ri.raw,
-              (ri.staple OR i.is_staple) AS staple, ri.optional, ri.extra
+      `SELECT ri.recipe_id, r.slug, r.title, ri.ingredient_id, i.canonical, ri.raw, ri.qty, ri.unit,
+              i.category, (ri.staple OR i.is_staple) AS staple, ri.optional, ri.extra
        FROM recipe_ingredients ri
        JOIN ingredients i ON i.id = ri.ingredient_id
        JOIN recipes r ON r.id = ri.recipe_id
@@ -3037,6 +3037,469 @@ function matchRecipes(ctx, opts = {}) {
   return { results, available: ids.size, unknown_ingredients: unknown };
 }
 
+// src/plan/plan.ts
+var PLAN_META_KEY = "meal_plan";
+function getPlan(ctx) {
+  const raw = ctx.store.getMeta(PLAN_META_KEY);
+  if (!raw) return { items: [], confirmed: [], updated_at: "" };
+  try {
+    const p = JSON.parse(raw);
+    return {
+      items: (p.items ?? []).filter((i) => ctx.store.getRecipe(i.slug)),
+      confirmed: p.confirmed ?? [],
+      updated_at: p.updated_at ?? ""
+    };
+  } catch {
+    return { items: [], confirmed: [], updated_at: "" };
+  }
+}
+function savePlan(ctx, plan) {
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const i of plan.items) {
+    if (seen.has(i.slug) || !ctx.store.getRecipe(i.slug)) continue;
+    seen.add(i.slug);
+    items.push(i.servings ? { slug: i.slug, servings: i.servings } : { slug: i.slug });
+  }
+  const stored = {
+    items,
+    confirmed: [...new Set(plan.confirmed)],
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ctx.store.setMeta(PLAN_META_KEY, JSON.stringify(stored));
+  return stored;
+}
+var CATEGORY_WEIGHT = {
+  herb: 1.5,
+  protein: 1.3,
+  seafood: 1.3,
+  vegetable: 1.2,
+  fruit: 1.2,
+  dairy: 1.2
+};
+var DEFAULT_WEIGHT = 0.7;
+function wasteWeight(category) {
+  return category && CATEGORY_WEIGHT[category] || DEFAULT_WEIGHT;
+}
+var AISLE_ORDER = [
+  "fruit & veg",
+  "meat, fish & eggs",
+  "dairy & chilled",
+  "bakery & grains",
+  "pantry",
+  "spices",
+  "other"
+];
+var AISLES = {
+  vegetable: "fruit & veg",
+  fruit: "fruit & veg",
+  herb: "fruit & veg",
+  protein: "meat, fish & eggs",
+  seafood: "meat, fish & eggs",
+  dairy: "dairy & chilled",
+  grain: "bakery & grains",
+  legume: "pantry",
+  baking: "pantry",
+  nut: "pantry",
+  stock: "pantry",
+  oil: "pantry",
+  condiment: "pantry",
+  spice: "spices",
+  seasoning: "spices"
+};
+function aisleOf(category) {
+  return category && AISLES[category] || "other";
+}
+var UNITS = {
+  g: ["g", 1],
+  gram: ["g", 1],
+  grams: ["g", 1],
+  kg: ["g", 1e3],
+  ml: ["ml", 1],
+  l: ["ml", 1e3],
+  litre: ["ml", 1e3],
+  liter: ["ml", 1e3],
+  tbsp: ["tbsp", 1],
+  tbs: ["tbsp", 1],
+  tablespoon: ["tbsp", 1],
+  tablespoons: ["tbsp", 1],
+  tsp: ["tsp", 1],
+  teaspoon: ["tsp", 1],
+  teaspoons: ["tsp", 1],
+  piece: ["", 1],
+  pieces: ["", 1],
+  pc: ["", 1],
+  pcs: ["", 1],
+  x: ["", 1],
+  whole: ["", 1],
+  tin: ["tin", 1],
+  tins: ["tin", 1],
+  can: ["tin", 1],
+  cans: ["tin", 1],
+  cup: ["cup", 1],
+  cups: ["cup", 1],
+  bunch: ["bunch", 1],
+  bunches: ["bunch", 1],
+  clove: ["clove", 1],
+  cloves: ["clove", 1],
+  sachet: ["sachet", 1],
+  sachets: ["sachet", 1],
+  pack: ["pack", 1],
+  packs: ["pack", 1],
+  packet: ["pack", 1],
+  slice: ["slice", 1],
+  slices: ["slice", 1],
+  sprig: ["sprig", 1],
+  sprigs: ["sprig", 1]
+};
+function toAmount(qty, unit, scale) {
+  if (qty === null || qty === void 0 || !Number.isFinite(qty)) return void 0;
+  const key = (unit ?? "").trim().toLowerCase();
+  const [u, mult] = UNITS[key] ?? [key, 1];
+  return { qty: qty * mult * scale, unit: u };
+}
+function fmtNumber(n) {
+  const r = Math.round(n * 10) / 10;
+  return Number.isInteger(r) ? String(r) : r.toFixed(1);
+}
+function formatAmount(parts, unmeasured = 0) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const p of parts) sums.set(p.unit, (sums.get(p.unit) ?? 0) + p.qty);
+  const out = [];
+  for (const [unit, qty] of sums) {
+    if (unit === "g" && qty >= 1e3) out.push(`${fmtNumber(qty / 1e3)} kg`);
+    else if (unit === "ml" && qty >= 1e3) out.push(`${fmtNumber(qty / 1e3)} l`);
+    else out.push(unit ? `${fmtNumber(qty)} ${unit}` : fmtNumber(qty));
+  }
+  if (unmeasured > 0 && out.length) out.push(`+${unmeasured} unmeasured`);
+  return out.length ? out.join(" + ") : null;
+}
+function loadProfiles(ctx, ids) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of ctx.store.recipeRequirements(ids)) {
+    let p = map.get(r.recipe_id);
+    if (!p) {
+      p = {
+        id: r.recipe_id,
+        slug: r.slug,
+        title: r.title,
+        required: [],
+        optional: [],
+        staples: [],
+        weight: 0
+      };
+      map.set(r.recipe_id, p);
+    }
+    if (r.staple) p.staples.push(r);
+    else if (r.optional) p.optional.push(r);
+    else {
+      p.required.push(r);
+      p.weight += wasteWeight(r.category);
+    }
+  }
+  return map;
+}
+function resolveSlugs(ctx, slugs) {
+  const ids = [];
+  const unknown = [];
+  for (const s of slugs) {
+    const rec = ctx.store.getRecipe(s);
+    if (rec) ids.push(rec.id);
+    else unknown.push(s);
+  }
+  return { ids, unknown };
+}
+var VARIETY_PENALTY = 0.15;
+var BEAM_WIDTH = 4;
+var BEAM_FANOUT = 12;
+var Planner = class {
+  constructor(ctx, usePantry) {
+    this.ctx = ctx;
+    this.avail = usePantry ? availableIngredients(ctx, {}).ids : /* @__PURE__ */ new Set();
+    this.profiles = loadProfiles(ctx);
+    for (const p of this.profiles.values()) this.bySlug.set(p.slug, p);
+    for (const s of ctx.store.listRecipes({ limit: 1e4 })) this.summaries.set(s.id, s);
+  }
+  ctx;
+  avail;
+  profiles;
+  bySlug = /* @__PURE__ */ new Map();
+  summaries = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  dishesOf(id) {
+    return this.summaries.get(id)?.tags.dish ?? [];
+  }
+  state(ids) {
+    const s = {
+      profiles: [],
+      buy: /* @__PURE__ */ new Map(),
+      buyIds: /* @__PURE__ */ new Set(),
+      pantryIds: /* @__PURE__ */ new Set(),
+      demand: 0,
+      dishes: /* @__PURE__ */ new Map(),
+      path: []
+    };
+    for (const id of ids) {
+      const p = this.profiles.get(id);
+      if (p) this.add(s, p);
+    }
+    return s;
+  }
+  add(s, p) {
+    s.profiles.push(p);
+    s.demand += p.weight;
+    for (const l of p.required) {
+      if (lineAvailable(this.ctx, l, this.avail, this.cache)) s.pantryIds.add(l.ingredient_id);
+      else if (!s.buy.has(l.ingredient_id)) {
+        s.buy.set(l.ingredient_id, l);
+        s.buyIds.add(l.ingredient_id);
+      }
+    }
+    for (const d of this.dishesOf(p.id)) s.dishes.set(d, (s.dishes.get(d) ?? 0) + 1);
+  }
+  extend(s, p, sug) {
+    const next = {
+      profiles: [...s.profiles],
+      buy: new Map(s.buy),
+      buyIds: new Set(s.buyIds),
+      pantryIds: new Set(s.pantryIds),
+      demand: s.demand,
+      dishes: new Map(s.dishes),
+      path: [...s.path, sug]
+    };
+    this.add(next, p);
+    return next;
+  }
+  evaluate(s, p, variety) {
+    const shares = [];
+    const pantry = [];
+    const fresh = [];
+    for (const l of p.required) {
+      if (lineAvailable(this.ctx, l, this.avail, this.cache)) pantry.push(l);
+      else if (lineAvailable(this.ctx, l, s.buyIds, this.cache)) shares.push(l);
+      else fresh.push(l);
+    }
+    const w = (rows) => rows.reduce((n, r) => n + wasteWeight(r.category), 0);
+    const reuse = p.weight === 0 ? 0 : (w(shares) + w(pantry)) / p.weight;
+    const repeated = this.dishesOf(p.id).filter((d) => s.dishes.has(d));
+    const penalty = variety ? repeated.length * VARIETY_PENALTY : 0;
+    const names = (rows) => [...new Set(rows.map((r) => r.canonical))];
+    return {
+      slug: p.slug,
+      title: p.title,
+      total_min: this.summaries.get(p.id)?.total_min ?? null,
+      reuse: Math.round(reuse * 100) / 100,
+      shares: names(shares),
+      from_pantry: names(pantry),
+      new: names(fresh),
+      new_cost: Math.round(w(fresh) * 10) / 10,
+      repeats: repeated.length ? repeated.join(", ") : void 0,
+      score: reuse - penalty
+    };
+  }
+  rank(s, allowed, variety) {
+    const planned = new Set(s.profiles.map((p) => p.id));
+    const out = [];
+    for (const p of this.profiles.values()) {
+      if (planned.has(p.id) || p.required.length === 0) continue;
+      if (allowed && !allowed.has(p.id)) continue;
+      out.push(this.evaluate(s, p, variety));
+    }
+    return out.sort(
+      (a, b) => b.score - a.score || a.new.length - b.new.length || b.shares.length - a.shares.length || a.title.localeCompare(b.title)
+    );
+  }
+  objective(s, variety) {
+    let repeats = 0;
+    for (const n of s.dishes.values()) if (n > 1) repeats += n - 1;
+    return this.reuse(s) - (variety ? repeats * VARIETY_PENALTY : 0);
+  }
+  reuse(s) {
+    if (s.demand === 0) return 0;
+    let bought = 0;
+    for (const l of s.buy.values()) bought += wasteWeight(l.category);
+    return Math.max(0, 1 - bought / s.demand);
+  }
+  summary(s, servings) {
+    const users = /* @__PURE__ */ new Map();
+    for (const p of s.profiles) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const l of p.required) {
+        if (s.buyIds.has(l.ingredient_id) && !seen.has(l.ingredient_id)) {
+          seen.add(l.ingredient_id);
+          users.set(l.ingredient_id, (users.get(l.ingredient_id) ?? 0) + 1);
+        }
+      }
+    }
+    return {
+      recipes: s.profiles.map((p) => ({
+        slug: p.slug,
+        title: p.title,
+        servings: servings?.get(p.slug) ?? void 0
+      })),
+      to_buy: s.buy.size,
+      from_pantry: s.pantryIds.size,
+      shared: [...users.values()].filter((n) => n >= 2).length,
+      reuse: Math.round(this.reuse(s) * 100) / 100
+    };
+  }
+};
+function planContext(ctx, opts) {
+  const slugs = [...opts.plan ?? getPlan(ctx).items.map((i) => i.slug)];
+  if (opts.seed && !slugs.includes(opts.seed)) slugs.push(opts.seed);
+  const { ids, unknown } = resolveSlugs(ctx, slugs);
+  return { ids, slugs: slugs.filter((s) => !unknown.includes(s)), unknown };
+}
+function suggestRecipes(ctx, opts = {}) {
+  const planner = new Planner(ctx, opts.use_pantry !== false);
+  const { ids, unknown } = planContext(ctx, opts);
+  const state = planner.state(ids);
+  const allowed = ctx.store.filterRecipeIds(expandFilters(ctx, opts.filters));
+  const limit = Math.min(Math.max(opts.limit ?? 10, 1), 50);
+  return {
+    plan: planner.summary(state),
+    suggestions: planner.rank(state, allowed, opts.variety !== false).slice(0, limit),
+    unknown_slugs: unknown
+  };
+}
+function autofillPlan(ctx, opts) {
+  const planner = new Planner(ctx, opts.use_pantry !== false);
+  const { ids, slugs, unknown } = planContext(ctx, opts);
+  const allowed = ctx.store.filterRecipeIds(expandFilters(ctx, opts.filters));
+  const variety = opts.variety !== false;
+  const width = Math.min(Math.max(opts.beam ?? BEAM_WIDTH, 1), 10);
+  const count = Math.min(Math.max(opts.count, 0), 14);
+  let beam = [planner.state(ids)];
+  for (let step = 0; step < count; step++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const s of beam) {
+      for (const sug of planner.rank(s, allowed, variety).slice(0, BEAM_FANOUT)) {
+        const p = planner.bySlug.get(sug.slug);
+        if (!p) continue;
+        const ns = planner.extend(s, p, sug);
+        const key = ns.profiles.map((x) => x.id).sort((a, b) => a - b).join(",");
+        if (!next.has(key)) next.set(key, ns);
+      }
+    }
+    if (next.size === 0) break;
+    beam = [...next.values()].sort(
+      (a, b) => planner.objective(b, variety) - planner.objective(a, variety) || a.buy.size - b.buy.size
+    ).slice(0, width);
+  }
+  const best = beam[0] ?? planner.state(ids);
+  return {
+    plan: planner.summary(best),
+    slugs: [...slugs, ...best.path.map((s) => s.slug)],
+    added: best.path,
+    unknown_slugs: unknown
+  };
+}
+function shoppingList(ctx, opts = {}) {
+  const stored = getPlan(ctx);
+  const items = opts.items ?? stored.items;
+  const removed = opts.out_of?.length ? removeFromPantry(ctx, opts.out_of).removed : [];
+  let confirmed = new Set(stored.confirmed);
+  for (const c of opts.confirmed ?? []) confirmed.add(c);
+  for (const r of removed) confirmed.delete(r);
+  if (opts.confirmed?.length || removed.length) {
+    confirmed = new Set(
+      savePlan(ctx, { items: opts.items ? stored.items : items, confirmed: [...confirmed] }).confirmed
+    );
+  }
+  const planner = new Planner(ctx, true);
+  const { ids, unknown } = resolveSlugs(
+    ctx,
+    items.map((i) => i.slug)
+  );
+  const state = planner.state(ids);
+  const wanted = new Map(items.map((i) => [i.slug, i.servings]));
+  const pantryQty = new Map(
+    ctx.store.pantryList().map((p) => [
+      p.ingredient_id,
+      p.qty !== null ? `${fmtNumber(p.qty)}${p.unit ? ` ${p.unit}` : ""}` : null
+    ])
+  );
+  const buy = /* @__PURE__ */ new Map();
+  const pantry = /* @__PURE__ */ new Map();
+  const optional = /* @__PURE__ */ new Map();
+  const staples = /* @__PURE__ */ new Set();
+  const recipes = [];
+  const cache = /* @__PURE__ */ new Map();
+  const put = (map, l, scale, title) => {
+    let b = map.get(l.ingredient_id);
+    if (!b) {
+      b = {
+        canonical: l.canonical,
+        category: l.category,
+        amounts: [],
+        unmeasured: 0,
+        for: /* @__PURE__ */ new Set()
+      };
+      map.set(l.ingredient_id, b);
+    }
+    const a = toAmount(l.qty, l.unit, scale);
+    if (a) b.amounts.push(a);
+    else b.unmeasured++;
+    b.for.add(title);
+  };
+  for (const p of state.profiles) {
+    const base = planner.summaries.get(p.id)?.servings ?? null;
+    const want = wanted.get(p.slug) ?? null;
+    const scale = base && want ? want / base : 1;
+    recipes.push({ slug: p.slug, title: p.title, servings: want ?? base, scale });
+    for (const l of p.required) {
+      if (lineAvailable(ctx, l, planner.avail, cache)) put(pantry, l, scale, p.title);
+      else put(buy, l, scale, p.title);
+    }
+    for (const l of p.optional) put(optional, l, scale, p.title);
+    for (const l of p.staples) staples.add(l.canonical);
+  }
+  const line = (b) => ({
+    canonical: b.canonical,
+    amount: formatAmount(b.amounts, b.unmeasured),
+    aisle: aisleOf(b.category),
+    for: [...b.for]
+  });
+  const byAisle = (a, b) => AISLE_ORDER.indexOf(a.aisle) - AISLE_ORDER.indexOf(b.aisle) || a.canonical.localeCompare(b.canonical);
+  const check = [...pantry.entries()].map(([id, b]) => ({
+    canonical: b.canonical,
+    amount: formatAmount(b.amounts, b.unmeasured),
+    for: [...b.for],
+    in_pantry: pantryQty.get(id) ?? null,
+    confirmed: confirmed.has(b.canonical)
+  })).sort((a, b) => a.canonical.localeCompare(b.canonical));
+  return {
+    recipes,
+    buy: [...buy.values()].map(line).sort(byAisle),
+    pantry_check: check,
+    needs_confirmation: check.filter((c) => !c.confirmed).map((c) => c.canonical),
+    optional: [...optional.values()].map(line).sort(byAisle),
+    staples: [...staples].sort(),
+    summary: planner.summary(state, wanted),
+    removed_from_pantry: removed,
+    unknown_slugs: unknown
+  };
+}
+function renderShoppingList(list) {
+  const out = [];
+  out.push(`Shopping list for ${list.recipes.map((r) => r.title).join(", ")}`);
+  let aisle;
+  for (const l of list.buy) {
+    if (l.aisle !== aisle) {
+      aisle = l.aisle;
+      out.push("", `${aisle[0]?.toUpperCase()}${aisle.slice(1)}`);
+    }
+    out.push(`- ${l.canonical}${l.amount ? ` \u2014 ${l.amount}` : ""}`);
+  }
+  if (list.pantry_check.length) {
+    out.push("", "From your pantry (check you have enough)");
+    for (const c of list.pantry_check)
+      out.push(`- ${c.canonical}${c.amount ? ` \u2014 ${c.amount}` : ""}${c.confirmed ? "" : " (?)"}`);
+  }
+  if (list.staples.length) out.push("", `Staples used: ${list.staples.join(", ")}`);
+  return out.join("\n");
+}
+
 // src/web/server.ts
 var MAX_JSON = 1e6;
 var MAX_UPLOAD = 6e7;
@@ -3125,6 +3588,20 @@ async function thumbnail(abs, width) {
   thumbCache.set(key, buf);
   return buf;
 }
+function planView(ctx) {
+  const plan = getPlan(ctx);
+  const ids = plan.items.map((i) => ctx.store.getRecipe(i.slug)?.id).filter((x) => x !== void 0);
+  const summaries = new Map(ctx.store.summariesByIds(ids).map((s) => [s.slug, s]));
+  const { plan: summary } = suggestRecipes(ctx, {
+    plan: plan.items.map((i) => i.slug),
+    limit: 1
+  });
+  return {
+    items: plan.items.map((i) => ({ ...i, recipe: summaries.get(i.slug) ?? null })),
+    confirmed: plan.confirmed,
+    summary
+  };
+}
 function routes(ctx, version) {
   const r = (method, pattern, handler) => ({
     method,
@@ -3136,6 +3613,7 @@ function routes(ctx, version) {
       ...ctx.store.stats(),
       inbox: ctx.store.ingestCounts(),
       pantry: listPantry(ctx).length,
+      plan: getPlan(ctx).items.length,
       providers: ctx.providers.list().map((p) => ({ id: p.id, name: p.name })),
       data_dir: ctx.paths.data,
       embeddings: ctx.embedder ? ctx.embedder.ready ? "ready" : "loading" : "disabled",
@@ -3207,6 +3685,31 @@ function routes(ctx, version) {
         filters: filtersFrom(url)
       });
     }),
+    // Meal plan: the saved plan plus its summary, with recipe summaries for the UI.
+    r("GET", /^\/api\/plan$/, () => planView(ctx)),
+    r("PUT", /^\/api\/plan$/, async (req) => {
+      const body = await readJson(req);
+      if (!Array.isArray(body.items)) throw new HttpError(400, "items required");
+      savePlan(ctx, { items: body.items, confirmed: getPlan(ctx).confirmed });
+      return planView(ctx);
+    }),
+    r("GET", /^\/api\/plan\/suggest$/, (_req, url) => {
+      const p = url.searchParams;
+      const common = {
+        seed: p.get("seed") ?? void 0,
+        plan: csv(p.get("plan")),
+        variety: p.get("variety") !== "0",
+        use_pantry: p.get("use_pantry") !== "0",
+        filters: filtersFrom(url)
+      };
+      const auto = num2(p.get("auto"));
+      if (auto) return autofillPlan(ctx, { ...common, count: auto });
+      return suggestRecipes(ctx, { ...common, limit: num2(p.get("limit")) ?? 12 });
+    }),
+    r("POST", /^\/api\/plan\/shopping$/, async (req) => {
+      const body = await readJson(req);
+      return shoppingList(ctx, body);
+    }),
     r(
       "GET",
       /^\/api\/ingredients$/,
@@ -3424,6 +3927,12 @@ export {
   availableIngredients,
   scoreRecipes,
   matchRecipes,
+  getPlan,
+  savePlan,
+  suggestRecipes,
+  autofillPlan,
+  shoppingList,
+  renderShoppingList,
   startUiServer
 };
-//# sourceMappingURL=chunk-QUWSBZ2V.js.map
+//# sourceMappingURL=chunk-IUQQ3I2E.js.map

package/dist/cli.js

@@ -12,7 +12,7 @@ import {
   resolveProjectRoot,
   searchRecipes,
   startUiServer
-} from "./chunk-QUWSBZ2V.js";
+} from "./chunk-IUQQ3I2E.js";
 
 // src/cli.ts
 import { spawn } from "child_process";