pantrybase 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,915 @@
+import {
+  ALL_CATEGORIES,
+  IMAGE_SIDES,
+  INGEST_STATUSES,
+  MODEL_MAX_PX,
+  SOURCE_KINDS,
+  addToPantry,
+  availableIngredients,
+  closeAllContexts,
+  finalizeAttach,
+  imageForModel,
+  importPaths,
+  listPantry,
+  log,
+  matchRecipes,
+  maybeScanInbox,
+  mergeImages,
+  nextBatch,
+  normalizeName,
+  normalizeRecipe,
+  openContext,
+  packageVersion,
+  planAttach,
+  prepareRecipe,
+  recipeFileExists,
+  recipeInputSchema,
+  reconcile,
+  removeFromPantry,
+  resolveItem,
+  resolveItems,
+  rotateItem,
+  scoreRecipes,
+  searchRecipes,
+  startUiServer,
+  viewItems,
+  writeRecipeFile
+} from "./chunk-QUWSBZ2V.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/register.ts
+import { z } from "zod";
+
+// src/mcp/define-tool.ts
+function defineTool(def) {
+  return def;
+}
+function text(value) {
+  const body = typeof value === "string" ? value : JSON.stringify(value);
+  return { content: [{ type: "text", text: body }] };
+}
+function errorResult(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+
+// src/mcp/register.ts
+var projectRootField = {
+  project_root: z.string().optional().describe("Project directory whose ./pantrybase data to use (default: the server's cwd)")
+};
+function registerTools(server, tools2) {
+  for (const tool of tools2) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        inputSchema: { ...tool.schema, ...projectRootField }
+      },
+      async (args) => {
+        const { project_root, ...rest } = args;
+        try {
+          const ctx = openContext(project_root);
+          ctx.embedder?.load().then(
+            () => ctx.embedQueue.kick(0),
+            () => {
+            }
+          );
+          ctx.sync();
+          await maybeScanInbox(ctx);
+          return await tool.handler(rest, ctx);
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          log(`${tool.name} failed:`, msg);
+          return errorResult(`${tool.name}: ${msg}`);
+        }
+      }
+    );
+  }
+}
+
+// src/mcp/tools/pb_get_recipe.ts
+import { z as z2 } from "zod";
+var pb_get_recipe_default = defineTool({
+  name: "pb_get_recipe",
+  description: "Fetch one recipe by slug. 'compact' (default) gives everything needed to cook or compare it \u2014 ingredients (raw + canonical), step text, tags, allergens, nutrition \u2014 without file metadata or per-step graph detail; 'full' returns the complete stored record.",
+  schema: {
+    slug: z2.string(),
+    format: z2.enum(["compact", "full"]).optional()
+  },
+  handler: ({ slug, format }, ctx) => {
+    const r = ctx.store.getRecipe(slug);
+    if (!r) return errorResult(`no recipe with slug "${slug}"`);
+    if (format === "full") return text(r);
+    const {
+      file_path: _f,
+      file_mtime: _m,
+      file_size: _z,
+      content_hash: _h,
+      id: _id,
+      created_at: _c,
+      updated_at: _u,
+      extraction,
+      ingredients,
+      steps,
+      ...rest
+    } = r;
+    return text({
+      ...rest,
+      ingredients: ingredients.map((i) => ({
+        raw: i.raw,
+        canonical: i.canonical,
+        prep: i.prep,
+        optional: i.optional,
+        source: i.source,
+        staple: i.staple
+      })),
+      steps: steps.map((s) => s.title ? `${s.title}: ${s.text}` : s.text),
+      needs_review: extraction?.needs_review || void 0,
+      uncertain: extraction?.uncertain?.length ? extraction.uncertain : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_inbox_image.ts
+import path from "path";
+import { z as z3 } from "zod";
+var pb_inbox_image_default = defineTool({
+  name: "pb_inbox_image",
+  description: "Show one queued (or archived) photo as an image, resized for reading (long edge \u2264 1600px by default; ask for up to 2400 if small print is unreadable). HEIC is converted automatically. If the text runs sideways or upside down, fix it with pb_inbox_rotate and look again.",
+  schema: {
+    id: z3.number().int(),
+    max_px: z3.number().int().min(400).max(2400).optional()
+  },
+  handler: async ({ id, max_px }, ctx) => {
+    const [item] = ctx.store.ingestByIds([id]);
+    if (!item) return errorResult(`no photo #${id}`);
+    const img = await imageForModel(path.join(ctx.paths.data, item.path), max_px ?? MODEL_MAX_PX);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: item.id,
+            name: item.original_name,
+            status: item.status,
+            captured_at: item.captured_at,
+            shown: `${img.width}x${img.height}`
+          })
+        },
+        { type: "image", data: img.data.toString("base64"), mimeType: img.mimeType }
+      ]
+    };
+  }
+});
+
+// src/mcp/tools/pb_inbox_list.ts
+import { z as z4 } from "zod";
+var pb_inbox_list_default = defineTool({
+  name: "pb_inbox_list",
+  description: "Photo queue counts plus a page of photos (optionally by status: pending, done, skipped, failed), in capture order.",
+  schema: {
+    status: z4.enum(INGEST_STATUSES).optional(),
+    limit: z4.number().int().min(1).max(200).optional().describe("default 20"),
+    offset: z4.number().int().min(0).optional()
+  },
+  handler: ({ status, limit, offset }, ctx) => {
+    const items = ctx.store.listIngest({ status, limit: limit ?? 20, offset });
+    return text({
+      counts: ctx.store.ingestCounts(),
+      items: viewItems(items, ctx.store.allIngest())
+    });
+  }
+});
+
+// src/mcp/tools/pb_inbox_next.ts
+import { z as z5 } from "zod";
+var pb_inbox_next_default = defineTool({
+  name: "pb_inbox_next",
+  description: "The next pending inbox photos in capture order, plus queue progress. Cards are usually shot front then back (a back has no title), so look at the photos in order with pb_inbox_image, group the ones that belong to one card, and save it with pb_save_recipe {ingest:[{id, side}]}. `retake_of` flags a near-identical photo: attach it as an extra image or skip it with pb_inbox_resolve. `rotation_hint` flags a photo whose shape differs from the rest \u2014 rotate it with pb_inbox_rotate if it reads sideways.",
+  schema: {
+    window: z5.number().int().min(1).max(12).optional().describe("How many photos to return (default 4)")
+  },
+  handler: ({ window }, ctx) => {
+    const { progress, items } = nextBatch(ctx, window ?? 4);
+    if (items.length === 0) return text({ progress, items: [], done: true });
+    return text({ progress, items });
+  }
+});
+
+// src/mcp/tools/pb_inbox_resolve.ts
+import { z as z6 } from "zod";
+var pb_inbox_resolve_default = defineTool({
+  name: "pb_inbox_resolve",
+  description: "Set aside photos you won't save: 'skipped' (retake, not a recipe, duplicate of a saved card) or 'failed' (unreadable \u2014 say why); 'pending' puts them back in the queue. Files move to inbox/skipped/ or inbox/failed/ with the reason beside them, so the state survives rebuilds. Photos attached to a recipe can't be resolved.",
+  schema: {
+    ids: z6.array(z6.number().int()).min(1),
+    status: z6.enum(["skipped", "failed", "pending"]),
+    reason: z6.string().optional().describe('e.g. "retake of #12", "back of card too blurry"')
+  },
+  handler: ({ ids, status, reason }, ctx) => {
+    const r = resolveItems(ctx, ids, status, reason);
+    return text({ ...r, queue: ctx.store.ingestCounts() });
+  }
+});
+
+// src/mcp/tools/pb_inbox_rotate.ts
+import { z as z7 } from "zod";
+var pb_inbox_rotate_default = defineTool({
+  name: "pb_inbox_rotate",
+  description: "Turn a photo upright when its text runs sideways or upside down (camera orientation flags are already applied, so this is for photos whose pixels are rotated). Degrees are clockwise: text reading bottom-to-top needs 90, upside down needs 180, top-to-bottom needs 270. The file is fixed on disk (HEIC becomes JPEG), so the archive, thumbnails and retake detection all see the upright photo. Call before pb_inbox_image when pb_inbox_next gives a rotation_hint, or after a photo shows up sideways; view it again to confirm.",
+  schema: {
+    id: z7.number().int(),
+    degrees: z7.union([z7.literal(90), z7.literal(180), z7.literal(270)])
+  },
+  handler: async ({ id, degrees }, ctx) => text({ rotated: degrees, item: await rotateItem(ctx, id, degrees) })
+});
+
+// src/mcp/tools/pb_ingest_source.ts
+import { z as z8 } from "zod";
+var pb_ingest_source_default = defineTool({
+  name: "pb_ingest_source",
+  description: "Copy recipe photos (JPEG, PNG, WebP, HEIC, TIFF) from files or folders into pantrybase/inbox/ for extraction. Originals are never moved or changed; photos already known (same bytes) are skipped. Folders are searched recursively by default. Returns counts and the queue state; then work through it with pb_inbox_next.",
+  schema: {
+    paths: z8.array(z8.string()).min(1).describe("Files or folders; relative to the project, absolute, or ~/\u2026"),
+    recursive: z8.boolean().optional()
+  },
+  handler: async ({ paths, recursive }, ctx) => {
+    const r = await importPaths(ctx, paths, { recursive });
+    return text({
+      copied: r.copied,
+      already_known: r.already_known,
+      unsupported_files: r.unsupported,
+      missing: r.missing.length ? r.missing : void 0,
+      duplicates_parked: r.scan.duplicates.length || void 0,
+      unreadable: r.scan.errors.length ? r.scan.errors : void 0,
+      queue: ctx.store.ingestCounts()
+    });
+  }
+});
+
+// src/mcp/tools/pb_list_tags.ts
+import { z as z9 } from "zod";
+var pb_list_tags_default = defineTool({
+  name: "pb_list_tags",
+  description: "Tags and facets in use, with recipe counts, grouped by category. With vocabulary:true also returns the allowed vocabulary (closed categories list every value). Call once before a batch of saves and reuse existing values.",
+  schema: {
+    category: z9.enum(ALL_CATEGORIES).optional(),
+    vocabulary: z9.boolean().optional()
+  },
+  handler: ({ category, vocabulary }, ctx) => {
+    const used = {};
+    for (const t of ctx.store.listTags(category)) {
+      const bucket = used[t.category] ?? {};
+      bucket[t.name] = t.count;
+      used[t.category] = bucket;
+    }
+    if (!vocabulary) return text(used);
+    const vocab = ctx.vocab.summary();
+    return text({
+      used,
+      vocabulary: category ? { [category]: vocab[category] } : vocab
+    });
+  }
+});
+
+// src/mcp/tools/pb_merge_ingredients.ts
+import { z as z10 } from "zod";
+
+// src/ingredients/merge.ts
+import fs from "fs";
+import { isMap, isSeq, parseDocument, YAMLMap, YAMLSeq } from "yaml";
+function toRecipe(r) {
+  const {
+    id: _id,
+    created_at: _c,
+    updated_at: _u,
+    file_path: _f,
+    file_mtime: _m,
+    file_size: _s,
+    content_hash: _h,
+    ...recipe
+  } = r;
+  return recipe;
+}
+function renameIn(recipe, from, into) {
+  let changed = false;
+  const swap = (name) => {
+    if (name === from) {
+      changed = true;
+      return into;
+    }
+    return name;
+  };
+  for (const ing of recipe.ingredients) {
+    ing.canonical = swap(ing.canonical);
+    if (ing.alternatives) ing.alternatives = ing.alternatives.map(swap);
+    for (const c of ing.components ?? []) c.canonical = swap(c.canonical);
+  }
+  for (const step of recipe.steps) if (step.uses) step.uses = [...new Set(step.uses.map(swap))];
+  return changed;
+}
+function persistAlias(file, from, into) {
+  const doc = parseDocument(fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "{}\n");
+  const root = doc.contents;
+  if (!isMap(root)) return;
+  const map = root;
+  const scalar = (n) => String(n?.value ?? n);
+  const carried = [];
+  const old = map.get(from, true);
+  if (isMap(old)) {
+    const aliases2 = old.get("aliases", true);
+    if (isSeq(aliases2))
+      for (const a of aliases2.items) carried.push(scalar(a));
+  }
+  if (map.has(from)) map.delete(from);
+  let target = map.get(into, true);
+  if (!isMap(target)) {
+    const fresh = new YAMLMap();
+    fresh.flow = true;
+    map.set(into, fresh);
+    target = fresh;
+  }
+  const entry = target;
+  let aliases = entry.get("aliases", true);
+  if (!isSeq(aliases)) {
+    const fresh = new YAMLSeq();
+    fresh.flow = true;
+    entry.set("aliases", fresh);
+    aliases = fresh;
+  }
+  const seq = aliases;
+  const existing = new Set(seq.items.map(scalar));
+  for (const a of [from, ...carried]) if (!existing.has(a)) seq.add(a);
+  fs.writeFileSync(file, doc.toString({ lineWidth: 0, flowCollectionPadding: false }));
+}
+function mergeIngredients(ctx, fromName, intoName) {
+  const from = ctx.store.getIngredient(normalizeName(fromName));
+  if (!from) throw new Error(`unknown ingredient "${fromName}"`);
+  const into = resolveItem(ctx, intoName, true)?.row;
+  if (!into) throw new Error(`cannot resolve "${intoName}"`);
+  if (from.id === into.id) throw new Error(`"${fromName}" is already "${into.canonical}"`);
+  const pantryMoved = ctx.store.pantryList().some((p) => p.ingredient_id === from.id);
+  const updated = [];
+  for (const slug of ctx.store.recipesUsingIngredient(from.id)) {
+    const rec = ctx.store.getRecipe(slug);
+    if (!rec) continue;
+    const recipe = toRecipe(rec);
+    if (renameIn(recipe, from.canonical, into.canonical)) {
+      writeRecipeFile(ctx.paths, recipe);
+      updated.push(slug);
+    }
+  }
+  ctx.store.mergeIngredientRows(from.id, into.id);
+  ctx.store.addAlias(into.id, from.canonical);
+  persistAlias(ctx.paths.ingredientsYaml, from.canonical, into.canonical);
+  ctx.refresh();
+  reconcile(ctx);
+  return {
+    from: from.canonical,
+    into: into.canonical,
+    recipes_updated: updated,
+    pantry_moved: pantryMoved
+  };
+}
+
+// src/mcp/tools/pb_merge_ingredients.ts
+var pb_merge_ingredients_default = defineTool({
+  name: "pb_merge_ingredients",
+  description: "Merge an ingredient into another when they are the same thing (e.g. 'pitted dates' into 'dates'). Rewrites every recipe file that uses it, moves aliases and the pantry entry, and records the alias in ingredients.yaml so future saves resolve to the target. Check pb_save_recipe's new_ingredients after a batch for candidates.",
+  schema: {
+    from: z10.string().min(1),
+    into: z10.string().min(1)
+  },
+  handler: ({ from, into }, ctx) => text(mergeIngredients(ctx, from, into))
+});
+
+// src/mcp/tools/pb_open_ui.ts
+var pb_open_ui_default = defineTool({
+  name: "pb_open_ui",
+  description: "Start (or find) the local pantrybase web UI for this project and return its URL \u2014 search with facets, recipe pages, the pantry and 'what can I cook', photo upload and the inbox queue, and the knowledge graph explorer. Give the user the URL; it is served on 127.0.0.1 only.",
+  schema: {},
+  handler: async (_args, ctx) => {
+    const ui = await startUiServer(ctx, { version: packageVersion() });
+    return text({ url: ui.url, data_dir: ctx.paths.data });
+  }
+});
+
+// src/mcp/tools/pb_pantry.ts
+import { z as z11 } from "zod";
+var pb_pantry_list = defineTool({
+  name: "pb_pantry_list",
+  description: "What's in the pantry: canonical ingredient names with optional quantity, unit and note.",
+  schema: {},
+  handler: (_args, ctx) => {
+    const items = listPantry(ctx);
+    return text({
+      count: items.length,
+      items: items.map((p) => ({
+        name: p.canonical,
+        qty: p.qty ?? void 0,
+        unit: p.unit ?? void 0,
+        note: p.note ?? void 0
+      }))
+    });
+  }
+});
+var pb_pantry_add = defineTool({
+  name: "pb_pantry_add",
+  description: "Add items to the pantry (or update their quantity). Names are matched to the ingredient catalog (aliases, plurals and regional names: 'eggs', 'baby marrow', 'spring onions'); unknown names become new ingredients.",
+  schema: {
+    items: z11.array(
+      z11.object({
+        name: z11.string().min(1),
+        qty: z11.number().nullable().optional(),
+        unit: z11.string().nullable().optional(),
+        note: z11.string().nullable().optional()
+      })
+    ).min(1)
+  },
+  handler: ({ items }, ctx) => text({ added: addToPantry(ctx, items), total: listPantry(ctx).length })
+});
+var pb_pantry_remove = defineTool({
+  name: "pb_pantry_remove",
+  description: "Remove items from the pantry by name, or everything with all:true.",
+  schema: {
+    names: z11.array(z11.string()).optional(),
+    all: z11.boolean().optional()
+  },
+  handler: ({ names, all }, ctx) => {
+    if (all) return text({ cleared: ctx.store.pantryClear() });
+    return text({ ...removeFromPantry(ctx, names ?? []), total: listPantry(ctx).length });
+  }
+});
+
+// src/mcp/tools/pb_pantry_match.ts
+import { z as z12 } from "zod";
+var pb_pantry_match_default = defineTool({
+  name: "pb_pantry_match",
+  description: "What can I cook? Ranks recipes by how much of their required ingredients the pantry covers (staples like salt, oil and 'from your kitchen' items, and optional items, never count against a recipe; printed alternatives and the parts of composite ingredients do count). Add `ingredients` for things you have right now; use_pantry:false to match only those. Returns coverage, what's missing, and near misses (1\u20132 items short).",
+  schema: {
+    ingredients: z12.array(z12.string()).optional(),
+    use_pantry: z12.boolean().optional().describe("default true"),
+    min_coverage: z12.number().min(0).max(1).optional().describe("default 0.5"),
+    max_missing: z12.number().int().min(0).optional(),
+    limit: z12.number().int().min(1).max(50).optional().describe("default 10"),
+    tags: z12.partialRecord(z12.enum(ALL_CATEGORIES), z12.array(z12.string())).optional(),
+    exclude_allergens: z12.array(z12.string()).optional(),
+    max_total_min: z12.number().optional()
+  },
+  handler: ({ ingredients, use_pantry, min_coverage, max_missing, limit, ...filters }, ctx) => {
+    const r = matchRecipes(ctx, {
+      ingredients,
+      use_pantry,
+      min_coverage: min_coverage ?? 0.5,
+      max_missing,
+      limit,
+      filters
+    });
+    return text({
+      available_ingredients: r.available,
+      unknown_ingredients: r.unknown_ingredients.length ? r.unknown_ingredients : void 0,
+      results: r.results.map((m) => ({
+        slug: m.slug,
+        title: m.title,
+        coverage: m.coverage,
+        have: `${m.have}/${m.need}`,
+        missing: m.missing.map((x) => x.canonical),
+        near_miss: m.near_miss || void 0
+      }))
+    });
+  }
+});
+
+// src/mcp/tools/pb_providers.ts
+import { z as z13 } 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')
+  },
+  handler: ({ id }, ctx) => {
+    if (!id) {
+      return text(
+        ctx.providers.list().map((p2) => ({
+          id: p2.id,
+          name: p2.name,
+          country: p2.country,
+          recognise: p2.recognise
+        }))
+      );
+    }
+    const p = ctx.providers.get(id);
+    if (!p)
+      return errorResult(
+        `no provider "${id}"; known: ${ctx.providers.list().map((x) => x.id).join(", ")}`
+      );
+    const summary = ctx.vocab.summary(25);
+    return text(
+      [
+        p.guide.trim(),
+        "",
+        "## Server-side rules (applied automatically on save)",
+        `- Plan labels \u2192 tags: ${JSON.stringify(p.plan_labels)}`,
+        `- Brands stripped from canonical names: ${p.brands.join(", ") || "none"}`,
+        `- Kitchen items treated as equipment: ${Object.keys(p.equipment_terms).join(", ") || "none"}`,
+        `- Nutrition basis default: ${p.nutrition_basis}; default servings: ${p.default_servings ?? "none"}`,
+        `- Upright card shape: ${p.orientation ?? "varies"} (photos that don't match are flagged with rotation_hint; fix them with pb_inbox_rotate)`,
+        "",
+        "## Tag vocabulary (closed = only these values; open = top values, new ones allowed)",
+        ...Object.entries(summary).map(
+          ([cat, v]) => `- ${cat} (${v.mode}): ${v.values.join(", ")}`
+        )
+      ].join("\n")
+    );
+  }
+});
+
+// src/mcp/tools/pb_rebuild.ts
+import { z as z14 } 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()
+  },
+  handler: ({ full, reembed }, ctx) => {
+    const reloaded = ctx.refresh(true);
+    const result = reconcile(ctx, { full: full ?? false, reembed: reembed ?? false });
+    return text({ reloaded, ...result });
+  }
+});
+
+// src/mcp/tools/pb_save_recipe.ts
+import { z as z15 } from "zod";
+
+// src/files/slug.ts
+var MAX_SLUG = 60;
+function slugify(title) {
+  const base = title.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/['’]/g, "").replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  let slug = base.slice(0, MAX_SLUG).replace(/-+$/g, "");
+  if (!slug) slug = "recipe";
+  return slug;
+}
+function uniqueSlug(base, exists) {
+  if (!exists(base)) return base;
+  for (let n = 2; n < 1e3; n++) {
+    const candidate = `${base}-${n}`;
+    if (!exists(candidate)) return candidate;
+  }
+  throw new Error(`could not find a free slug for ${base}`);
+}
+
+// src/recipes/service.ts
+function saveRecipe(ctx, input, opts = {}) {
+  const ingest = opts.ingest ?? [];
+  if (ingest.length) {
+    const items = ctx.store.ingestByIds(ingest.map((i) => i.id));
+    const slugs = new Set(items.map((i) => i.recipe_slug));
+    const first = items[0];
+    const owner = first?.recipe_slug ? ctx.store.getRecipe(first.recipe_slug) : void 0;
+    const sameRecipe = owner !== void 0 && (input.slug === owner.slug || normalizeName(input.title) === normalizeName(owner.title));
+    if (items.length === ingest.length && items.every((i) => i.status === "done") && slugs.size === 1 && owner && sameRecipe && // An update that changes the recipe is a real save, not a retry.
+    !input.slug) {
+      return { saved: false, already_ingested: true, slug: owner.slug };
+    }
+  }
+  const existing = input.slug ? ctx.store.getRecipe(input.slug) : void 0;
+  if (!existing && !opts.allow_duplicate) {
+    const dups = ctx.store.findDuplicates(
+      input.title,
+      input.ingredients.map((i) => normalizeName(i.canonical))
+    );
+    if (dups.length > 0) return { saved: false, duplicate_of: dups };
+  }
+  const slug = existing ? existing.slug : uniqueSlug(
+    input.slug ?? slugify(input.title),
+    (s) => ctx.store.getRecipe(s) !== void 0 || recipeFileExists(ctx.paths, s)
+  );
+  const plan = planAttach(ctx, slug, ingest);
+  if (plan.errors.length) return { saved: false, error: plan.errors.join("; ") };
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const source = input.source ?? existing?.source ?? { kind: "manual" };
+  const recipe = normalizeRecipe(
+    {
+      ...input,
+      source: { ...source, ingested: source.ingested ?? existing?.source.ingested ?? today }
+    },
+    slug
+  );
+  if (plan.targets.length || existing) {
+    const merged = mergeImages(
+      {
+        images: [...existing?.images ?? [], ...recipe.images],
+        extraction: existing?.extraction
+      },
+      plan.targets,
+      recipe.extraction?.images
+    );
+    recipe.images = merged.images;
+    if (merged.extraction.length) {
+      recipe.extraction = { ...recipe.extraction ?? {}, images: merged.extraction };
+    }
+  }
+  const prepared = prepareRecipe(ctx, recipe);
+  const file = writeRecipeFile(ctx.paths, prepared.recipe);
+  ctx.store.upsertRecipe(prepared.recipe, file, prepared.ingredientIds);
+  finalizeAttach(ctx, slug, plan.targets);
+  ctx.embedQueue.kick();
+  const { provider, ...vocabulary } = prepared.report;
+  const unknownDerived = prepared.recipe.derived_from.filter(
+    (s) => s !== slug && !ctx.store.getRecipe(s)
+  );
+  return {
+    ...unknownDerived.length ? { unknown_derived_from: unknownDerived } : {},
+    saved: true,
+    slug,
+    file: file.file_path,
+    updated: existing !== void 0,
+    new_ingredients: prepared.resolution.created,
+    aliased: prepared.resolution.aliased.map(({ from, to }) => ({ from, to })),
+    vocabulary,
+    provider_rules: provider,
+    unmatched_uses: prepared.unmatched_uses,
+    needs_review: prepared.recipe.extraction?.needs_review ?? false,
+    images: prepared.recipe.images
+  };
+}
+
+// src/mcp/tools/pb_save_recipe.ts
+var pb_save_recipe_default = defineTool({
+  name: "pb_save_recipe",
+  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(
+      "Inbox photos of this card, e.g. [{id: 12, side: 'front'}, {id: 13, side: 'back'}]"
+    ),
+    allow_duplicate: z15.boolean().optional()
+  },
+  handler: ({ allow_duplicate, ingest, ...input }, ctx) => {
+    return text(saveRecipe(ctx, input, { allow_duplicate, ingest }));
+  }
+});
+
+// src/mcp/tools/pb_search.ts
+import { z as z16 } 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()
+  },
+  handler: async ({ query, limit, mode, ...filters }, ctx) => {
+    const res = await searchRecipes(ctx, { query, limit, mode, filters });
+    return text({
+      count: res.results.length,
+      vector_used: res.vector_used,
+      results: res.results.map((r) => ({
+        slug: r.slug,
+        title: r.title,
+        subtitle: r.subtitle,
+        blurb: r.blurb,
+        active_min: r.active_min,
+        total_min: r.total_min,
+        tags: r.tags,
+        allergens: r.allergens.length ? r.allergens : void 0,
+        needs_review: r.needs_review || void 0,
+        score: r.score,
+        matched: r.matched
+      }))
+    });
+  }
+});
+
+// src/mcp/tools/pb_stats.ts
+var pb_stats_default = defineTool({
+  name: "pb_stats",
+  description: "Counts of recipes, ingredients, tags, indexed chunks and vectors, plus data paths and model state.",
+  schema: {},
+  handler: (_args, ctx) => {
+    return text({
+      ...ctx.store.stats(),
+      inbox: ctx.store.ingestCounts(),
+      providers: ctx.providers.list().map((p) => p.id),
+      data_dir: ctx.paths.data,
+      embeddings: ctx.embedder ? ctx.embedder.ready ? "ready" : "not loaded" : "disabled"
+    });
+  }
+});
+
+// src/mcp/tools/pb_synthesis_context.ts
+import { z as z17 } from "zod";
+
+// src/synthesis/context.ts
+var STEP_CHARS = 220;
+function qtyText(i) {
+  const amount = [i.qty, i.unit].filter((x) => x !== void 0 && x !== null && x !== "").join(" ");
+  return `${amount ? `${amount} ` : ""}${i.canonical}${i.prep ? ` (${i.prep})` : ""}${i.optional ? " [optional]" : ""}${i.staple ? " [staple]" : ""}`;
+}
+function compactRecipe(r) {
+  return {
+    slug: r.slug,
+    title: r.title,
+    subtitle: r.subtitle,
+    blurb: r.blurb,
+    serves: r.servings ?? void 0,
+    minutes: r.time.total ?? void 0,
+    tags: {
+      cuisine: r.tags.cuisine,
+      dish: r.tags.dish,
+      flavor: r.tags.flavor,
+      texture: r.tags.texture,
+      protein: r.tags.protein,
+      diet: r.tags.diet
+    },
+    ingredients: r.ingredients.map(qtyText),
+    steps: r.steps.map((s) => {
+      const text2 = s.text.length > STEP_CHARS ? `${s.text.slice(0, STEP_CHARS - 1)}\u2026` : s.text;
+      const tech = s.techniques?.length ? ` [${s.techniques.join(", ")}]` : "";
+      return `${text2}${tech}`;
+    }),
+    tips: r.tips.length ? r.tips : void 0
+  };
+}
+function top(counts, n, min = 1) {
+  return [...counts.entries()].filter(([, c]) => c >= min).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, n);
+}
+function bump(map, key) {
+  if (key) map.set(key, (map.get(key) ?? 0) + 1);
+}
+async function synthesisContext(ctx, opts) {
+  const n = Math.min(Math.max(opts.n ?? 5, 1), 12);
+  const picked = [];
+  const how = [];
+  for (const s of opts.slugs ?? [])
+    if (ctx.store.getRecipe(s) && !picked.includes(s)) picked.push(s);
+  if (opts.slugs?.length) how.push("given slugs");
+  if (picked.length < n && opts.query) {
+    const res = await searchRecipes(ctx, {
+      query: opts.query,
+      filters: opts.filters,
+      limit: n * 3
+    });
+    let candidates = res.results.map((r) => r.slug);
+    if (opts.use_pantry || opts.ingredients?.length) {
+      const { ids } = availableIngredients(ctx, opts);
+      const scores = new Map(
+        scoreRecipes(
+          ctx,
+          ids,
+          res.results.map((r) => r.id)
+        ).map((m) => [m.slug, m.coverage])
+      );
+      candidates = candidates.map((slug, rank) => ({ slug, score: 1 / (rank + 1) + (scores.get(slug) ?? 0) })).sort((a, b) => b.score - a.score).map((c) => c.slug);
+      how.push("search re-ranked by pantry coverage");
+    } else {
+      how.push(`search${res.vector_used ? " (hybrid)" : " (keyword)"}`);
+    }
+    for (const s of candidates) if (picked.length < n && !picked.includes(s)) picked.push(s);
+  } else if (picked.length < n && (opts.use_pantry || opts.ingredients?.length)) {
+    for (const m of matchRecipes(ctx, { ...opts, limit: n * 2 }).results) {
+      if (picked.length < n && !picked.includes(m.slug)) picked.push(m.slug);
+    }
+    how.push("pantry match");
+  } else if (picked.length < n && !opts.slugs?.length) {
+    for (const r of (await searchRecipes(ctx, { filters: opts.filters, limit: n })).results) {
+      if (picked.length < n && !picked.includes(r.slug)) picked.push(r.slug);
+    }
+    how.push("filters");
+  }
+  const recipes = picked.map((s) => ctx.store.getRecipe(s)).filter((r) => !!r);
+  const ingredientCounts = /* @__PURE__ */ new Map();
+  const techniqueCounts = /* @__PURE__ */ new Map();
+  const cuisineCounts = /* @__PURE__ */ new Map();
+  const flavorCounts = /* @__PURE__ */ new Map();
+  const pairs = /* @__PURE__ */ new Map();
+  for (const r of recipes) {
+    const core = [
+      ...new Set(r.ingredients.filter((i) => !i.staple).map((i) => i.canonical))
+    ].sort();
+    for (const c of core) bump(ingredientCounts, c);
+    for (let i = 0; i < core.length; i++) {
+      for (let j = i + 1; j < core.length; j++) bump(pairs, `${core[i]} + ${core[j]}`);
+    }
+    for (const t of new Set(r.steps.flatMap((s) => s.techniques ?? []))) bump(techniqueCounts, t);
+    for (const c of r.tags.cuisine ?? []) bump(cuisineCounts, c);
+    for (const f of r.tags.flavor ?? []) bump(flavorCounts, f);
+  }
+  let pantry;
+  if (opts.use_pantry || opts.ingredients?.length) {
+    const { ids, unknown } = availableIngredients(ctx, opts);
+    const haveNames = new Set(
+      [...ingredientCounts.keys()].filter((name) => {
+        const row = ctx.store.getIngredient(name);
+        return row ? ids.has(row.id) : false;
+      })
+    );
+    pantry = {
+      have: [...haveNames].sort(),
+      missing_common: top(ingredientCounts, 30).map(([name]) => name).filter((name) => !haveNames.has(name)).slice(0, 12),
+      unknown
+    };
+  }
+  return {
+    selected_by: how.join(", ") || "none",
+    recipes: recipes.map(compactRecipe),
+    patterns: {
+      common_ingredients: top(ingredientCounts, 15, recipes.length > 2 ? 2 : 1).map(
+        ([k, v]) => `${k} \xD7${v}`
+      ),
+      common_pairings: top(pairs, 10, 2).map(([k, v]) => `${k} \xD7${v}`),
+      techniques: top(techniqueCounts, 10).map(([k, v]) => `${k} \xD7${v}`),
+      cuisines: top(cuisineCounts, 6).map(([k]) => k),
+      flavors: top(flavorCounts, 8).map(([k]) => k)
+    },
+    pantry,
+    to_save: `Write a new recipe drawing on these (don't copy one). Save it with pb_save_recipe: source {kind: 'synthesized'}, derived_from: [${recipes.map((r) => `'${r.slug}'`).join(", ")}] (only the ones you actually drew on), no provider, structured ingredients (source 'kitchen' for what the pantry has) and steps with techniques/uses, tags, and a blurb.`
+  };
+}
+
+// src/mcp/tools/pb_synthesis_context.ts
+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)")
+  },
+  handler: async ({ query, slugs, use_pantry, ingredients, n, ...filters }, ctx) => text(await synthesisContext(ctx, { query, slugs, use_pantry, ingredients, n, filters }))
+});
+
+// src/mcp/tools/index.ts
+var tools = [
+  // find and cook
+  pb_search_default,
+  pb_get_recipe_default,
+  pb_pantry_match_default,
+  pb_synthesis_context_default,
+  pb_list_tags_default,
+  // pantry
+  pb_pantry_list,
+  pb_pantry_add,
+  pb_pantry_remove,
+  // capture
+  pb_providers_default,
+  pb_ingest_source_default,
+  pb_inbox_next_default,
+  pb_inbox_image_default,
+  pb_inbox_rotate_default,
+  pb_inbox_resolve_default,
+  pb_inbox_list_default,
+  pb_save_recipe_default,
+  // maintenance
+  pb_open_ui_default,
+  pb_merge_ingredients_default,
+  pb_stats_default,
+  pb_rebuild_default
+];
+
+// src/server.ts
+var pkg = { version: packageVersion() };
+async function main() {
+  if (process.argv.includes("--probe")) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, name: "pantrybase", version: pkg.version, node: process.version, tools: tools.map((t) => t.name) })}
+`
+    );
+    return;
+  }
+  const server = new McpServer({ name: "pantrybase", version: pkg.version });
+  registerTools(server, tools);
+  const shutdown = () => {
+    closeAllContexts();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.stdin.on("end", shutdown);
+  await server.connect(new StdioServerTransport());
+  log(`pantrybase ${pkg.version} serving ${tools.length} tools over stdio`);
+}
+main().catch((e) => {
+  log("fatal:", e);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map