mcp-marmiton 1.0.4 → 1.2.0

package/README.md

@@ -71,6 +71,15 @@ original: half a sachet at factor 0.667 becomes a third of a sachet, never a who
 one. And scaling never **silently drops** an ingredient by rounding it to zero,
 which is why small amounts come back as fractions.
 
+Ranges are read as one quantity: "2 à 3 gousses" doubled reads "4 à 6 gousses",
+and `amount` reports the upper bound, since that is what a cook buys.
+
+Below a quarter there is nothing a kitchen can measure, so the amount is clamped
+up and **the line stops holding its share of the recipe**. Half a sachet of
+baking powder against three pots of flour comes out four times too strong that
+way, so the ingredient and the response both say it happened rather than leaving
+you to find out in the oven.
+
 `scale_ingredients` exposes the same logic **without any network request**, so it
 also works on a recipe pasted from somewhere else.
 
@@ -157,6 +166,19 @@ and use your judgement.
 
 This is an unofficial project, with no affiliation to or endorsement by Marmiton.
 
+## Contributing
+
+Bugs, questions and ideas all belong in
+[the issue tracker](https://github.com/smeet666/mcp-marmiton/issues). Pull requests
+are welcome; please open an issue first so we can agree on what the right
+answer is before you write it. [CONTRIBUTING.md](CONTRIBUTING.md) has the
+detail, and [SECURITY.md](SECURITY.md) covers anything exploitable.
+
+## Support
+
+These servers are free and stay free. If one of them saved you an afternoon,
+you can [buy me a coffee](https://buymeacoffee.com/smeet666).
+
 ## License
 
 MIT. See [LICENSE](./LICENSE). The license covers this source code only, not the
@@ -229,6 +251,16 @@ l'originale : un demi-sachet au facteur 0,667 devient un tiers de sachet, jamais
 sachet entier. Et l'adaptation ne **supprime jamais** un ingrédient en l'arrondissant
 à zéro, d'où les fractions pour les petites quantités.
 
+Les fourchettes sont lues comme une seule quantité : « 2 à 3 gousses » doublé
+donne « 4 à 6 gousses », et `amount` renvoie la borne haute, celle que l'on
+achète.
+
+Sous un quart, il n'y a plus rien qu'une cuisine puisse mesurer : la quantité est
+alors remontée et **la ligne cesse de tenir sa part de la recette**. Un demi-sachet
+de levure face à trois pots de farine ressort ainsi quatre fois trop dosé, donc
+l'ingrédient et la réponse le disent, plutôt que de vous le laisser découvrir au
+four.
+
 `scale_ingredients` expose la même logique **sans aucune requête réseau**, ce qui
 permet aussi d'adapter une recette venue d'ailleurs.
 

package/dist/index.js

@@ -4,7 +4,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/version.ts
-var PKG_VERSION = "1.0.4";
+var PKG_VERSION = "1.2.0";
 var REPO_URL = "https://github.com/smeet666/mcp-marmiton";
 
 // src/config.ts
@@ -646,19 +646,26 @@ var MarmitonClient = class {
    */
   async search(query) {
     const url = buildSearchUrl(query);
-    const { html, cached } = await this.fetchPage(url);
-    return { data: parseSearchPage(html, url), cached };
+    return this.fetchParsed(url, (html) => parseSearchPage(html, url));
   }
   async getRecipe(ref) {
     const { id, url } = resolveRecipeRef(ref);
-    const { html, cached } = await this.fetchPage(url);
-    return { data: parseRecipePage(html, { id, url }), cached };
+    return this.fetchParsed(url, (html) => parseRecipePage(html, { id, url }));
   }
-  async fetchPage(url) {
+  /**
+   * Fetch, parse, then cache. In that order: a page that could not be read is
+   * never stored, so a bad minute at Marmiton cannot be replayed from memory for
+   * the rest of the cache lifetime, leaving the tool unable to recover after
+   * the site comes back.
+   *
+   * The cached value is the parsed result rather than the raw page, which also
+   * keeps a few hundred kilobytes of markup per entry out of memory.
+   */
+  async fetchParsed(url, parse) {
     const hit = this.cache.get(url);
     if (hit !== void 0) {
       this.logger.debug(`cache hit ${url}`);
-      return { html: hit, cached: true };
+      return { data: hit, cached: true };
     }
     const html = await fetchHtml(url, {
       config: this.config,
@@ -666,8 +673,9 @@ var MarmitonClient = class {
       logger: this.logger,
       ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
     });
-    this.cache.set(url, html);
-    return { html, cached: false };
+    const data = parse(html);
+    this.cache.set(url, data);
+    return { data, cached: false };
   }
 };
 
@@ -677,22 +685,22 @@ import { z as z2 } from "zod";
 // src/recipe/units.ts
 var UNITS = {
   // Mass
-  g: { canonical: "g", kind: "measured" },
-  gr: { canonical: "g", kind: "measured" },
-  gramme: { canonical: "g", kind: "measured" },
-  grammes: { canonical: "g", kind: "measured" },
-  kg: { canonical: "kg", kind: "measured" },
-  kilo: { canonical: "kg", kind: "measured" },
-  kilos: { canonical: "kg", kind: "measured" },
-  kilogramme: { canonical: "kg", kind: "measured" },
-  mg: { canonical: "mg", kind: "measured" },
+  g: { canonical: "g", kind: "measured", symbol: true },
+  gr: { canonical: "g", kind: "measured", symbol: true },
+  gramme: { canonical: "g", kind: "measured", symbol: true },
+  grammes: { canonical: "g", kind: "measured", symbol: true },
+  kg: { canonical: "kg", kind: "measured", symbol: true },
+  kilo: { canonical: "kg", kind: "measured", symbol: true },
+  kilos: { canonical: "kg", kind: "measured", symbol: true },
+  kilogramme: { canonical: "kg", kind: "measured", symbol: true },
+  mg: { canonical: "mg", kind: "measured", symbol: true },
   // Volume
-  ml: { canonical: "ml", kind: "measured" },
-  cl: { canonical: "cl", kind: "measured" },
-  dl: { canonical: "dl", kind: "measured" },
-  l: { canonical: "l", kind: "measured" },
-  litre: { canonical: "l", kind: "measured" },
-  litres: { canonical: "l", kind: "measured" },
+  ml: { canonical: "ml", kind: "measured", symbol: true },
+  cl: { canonical: "cl", kind: "measured", symbol: true },
+  dl: { canonical: "dl", kind: "measured", symbol: true },
+  l: { canonical: "l", kind: "measured", symbol: true },
+  litre: { canonical: "l", kind: "measured", symbol: true },
+  litres: { canonical: "l", kind: "measured", symbol: true },
   // Spoons and cups: real measures, but only in sensible fractions.
   "cuillere a soupe": {
     canonical: "cuill\xE8re \xE0 soupe",
@@ -776,6 +784,12 @@ var DEMOTIONS = {
   cl: { to: "ml", per: 10 },
   g: { to: "mg", per: 1e3 }
 };
+function demoteUnit(unit) {
+  const step = DEMOTIONS[unit.canonical];
+  if (!step) return null;
+  const target = lookupUnit(step.to);
+  return target ? { unit: target, per: step.per } : null;
+}
 function convertToReadableUnit(unit, amount) {
   if (unit.kind !== "measured" || !Number.isFinite(amount) || amount <= 0) {
     return { amount, unit };
@@ -793,9 +807,9 @@ function convertToReadableUnit(unit, amount) {
   return { amount, unit };
 }
 function formatUnit(unit, amount) {
+  if (unit.symbol) return unit.canonical;
   if (amount < 2) return unit.canonical;
   if (unit.plural) return unit.plural;
-  if (/^[a-z]{1,3}$/.test(unit.canonical)) return unit.canonical;
   return `${unit.canonical}s`;
 }
 
@@ -845,9 +859,18 @@ function parseLeadingQuantity(text) {
 function parseIngredient(line) {
   const original = line;
   const text = line.trim();
-  const quantity = parseLeadingQuantity(text);
+  const range = parseLeadingRange(text);
+  const quantity = range ?? parseLeadingQuantity(text);
   if (!quantity) {
-    return { original, amount: null, unit: null, unitText: null, item: text };
+    return {
+      original,
+      amount: null,
+      amountMax: null,
+      rangeSeparator: null,
+      unit: null,
+      unitText: null,
+      item: text
+    };
   }
   let rest = text.slice(quantity.length).trimStart();
   let unit = null;
@@ -864,7 +887,31 @@ function parseIngredient(line) {
     }
   }
   const item = rest.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").trim();
-  return { original, amount: quantity.amount, unit, unitText, item };
+  return {
+    original,
+    amount: quantity.amount,
+    amountMax: range?.max ?? null,
+    rangeSeparator: range?.separator ?? null,
+    unit,
+    unitText,
+    item
+  };
+}
+function parseLeadingRange(text) {
+  const low = parseLeadingQuantity(text);
+  if (!low) return null;
+  const after = text.slice(low.length);
+  const separator = /^\s*(à|a|ou|-|–|—|\/)\s*/.exec(after);
+  if (!separator) return null;
+  if (separator[1] === "/") return null;
+  const high = parseLeadingQuantity(after.slice(separator[0].length));
+  if (!high || high.amount <= low.amount) return null;
+  return {
+    amount: low.amount,
+    max: high.amount,
+    separator: separator[1],
+    length: low.length + separator[0].length + high.length
+  };
 }
 function formatAmount(amount, options = {}) {
   if (!Number.isFinite(amount)) return "";
@@ -899,17 +946,38 @@ function roundMeasured(value) {
   if (value >= 1) return roundTo(value, 0.5);
   return Math.round(value * 100) / 100;
 }
-function roundCountable(value, allowHalves) {
-  if (value <= 0) return 0;
+var SMALLEST_USABLE_FRACTION = 0.25;
+function roundCountable(value, allowHalves, ceiling) {
+  if (value <= 0) return { value: 0, clamped: false };
   if (value < 1) {
-    const USABLE_FRACTIONS = [0.25, 1 / 3, 0.5, 2 / 3, 0.75];
-    let closest = USABLE_FRACTIONS[0];
-    for (const fraction of USABLE_FRACTIONS) {
-      if (Math.abs(value - fraction) < Math.abs(value - closest)) closest = fraction;
+    const candidates = [SMALLEST_USABLE_FRACTION, 1 / 3, 0.5, 2 / 3, 0.75, 1].filter(
+      (candidate) => candidate <= Math.max(ceiling, SMALLEST_USABLE_FRACTION)
+    );
+    let closest = candidates[0];
+    for (const candidate of candidates) {
+      if (Math.abs(value - candidate) < Math.abs(value - closest)) closest = candidate;
     }
-    return Math.round(closest * 100) / 100;
+    return {
+      value: Math.round(closest * 100) / 100,
+      clamped: value < SMALLEST_USABLE_FRACTION
+    };
   }
-  return allowHalves ? roundTo(value, 0.5) : Math.round(value);
+  return { value: allowHalves ? roundTo(value, 0.5) : Math.round(value), clamped: false };
+}
+function roundMeasuredInUsableUnit(unit, raw) {
+  let current = unit;
+  let value = raw;
+  while (value > 0 && value < 1) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    value *= step.per;
+    current = step.unit;
+  }
+  const rounded = roundMeasured(value);
+  return {
+    amount: rounded === 0 && value > 0 ? Number(value.toPrecision(2)) : rounded,
+    unit: current
+  };
 }
 function agreeWithAmount(item, amount) {
   if (!item) return item;
@@ -927,6 +995,12 @@ function agreeWithAmount(item, amount) {
   }
   return words.join(" ");
 }
+var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
+function joinItem(item) {
+  if (!item) return "";
+  const elides = /^[aeiouàâäéèêëîïôöûü]/i.test(item) || MUTE_H_WORDS.test(item);
+  return elides ? ` d'${item}` : ` de ${item}`;
+}
 function scaleIngredient(line, options) {
   const { factor } = options;
   const parsed = parseIngredient(line);
@@ -937,6 +1011,7 @@ function scaleIngredient(line, options) {
       amount: null,
       unit: null,
       scaling: "unscaled",
+      adjusted: false,
       note: "No quantity given; adjust to taste."
     };
   }
@@ -948,41 +1023,47 @@ function scaleIngredient(line, options) {
       amount: parsed.amount,
       unit: parsed.unit?.canonical ?? null,
       scaling: "unscaled",
+      adjusted: false,
       note: "Measure is approximate by nature; adjust to taste."
     };
   }
-  const raw = parsed.amount * factor;
-  let amount;
-  let scaling;
-  let unit = parsed.unit;
-  if (kind === "measured") {
-    const converted = convertToReadableUnit(parsed.unit, roundMeasured(raw));
-    amount = converted.amount;
-    unit = converted.unit;
-    scaling = "scaled";
-  } else if (kind === "portioned") {
+  const scaleBound = (source) => {
+    const raw = source * factor;
+    if (kind === "measured") {
+      const converted = roundMeasuredInUsableUnit(parsed.unit, raw);
+      const readable = convertToReadableUnit(converted.unit, converted.amount);
+      return { amount: readable.amount, unit: readable.unit, raw, clamped: false };
+    }
     const allowHalves = /cuillère|verre|tasse|bol/.test(parsed.unit?.canonical ?? "");
-    amount = roundCountable(raw, allowHalves);
-    scaling = "rounded";
-  } else {
-    amount = roundCountable(raw, false);
-    scaling = "rounded";
-  }
+    const ceiling = factor < 1 ? source : Number.POSITIVE_INFINITY;
+    const rounded = roundCountable(raw, allowHalves, ceiling);
+    return { amount: rounded.value, unit: parsed.unit, raw, clamped: rounded.clamped };
+  };
+  const low = scaleBound(parsed.amount);
+  const high = parsed.amountMax === null ? null : scaleBound(parsed.amountMax);
+  const amount = high?.amount ?? low.amount;
+  const unit = high?.unit ?? low.unit;
+  const scaling = kind === "measured" ? "scaled" : "rounded";
   const unitLabel = unit ? ` ${formatUnit(unit, amount)}` : "";
-  const separator = unit ? " de " : " ";
   const itemText = unit ? parsed.item : agreeWithAmount(parsed.item, amount);
-  const item = itemText ? `${separator}${itemText}` : "";
-  const amountText = formatAmount(amount, { fractions: kind !== "measured" });
+  const item = unit ? joinItem(parsed.item) : itemText ? ` ${itemText}` : "";
+  const asText = (value) => formatAmount(value, { fractions: kind !== "measured" });
+  const amountText = high === null ? asText(low.amount) : parsed.rangeSeparator === "-" || parsed.rangeSeparator === "\u2013" || parsed.rangeSeparator === "\u2014" ? `${asText(low.amount)}${parsed.rangeSeparator}${asText(high.amount)}` : `${asText(low.amount)} ${parsed.rangeSeparator} ${asText(high.amount)}`;
   const text = `${amountText}${unitLabel}${item}`.trim();
+  const bounds = high === null ? [low] : [low, high];
+  const adjusted = bounds.some((bound) => Math.abs(bound.raw - bound.amount) > 0.01);
   const result = {
     original: parsed.original,
     text,
     amount,
     unit: unit?.canonical ?? null,
-    scaling
+    scaling,
+    adjusted
   };
-  if (scaling === "rounded" && Math.abs(raw - amount) > 0.01) {
-    result.note = `Rounded from ${formatAmount(Math.round(raw * 100) / 100)}.`;
+  if (bounds.some((bound) => bound.clamped)) {
+    result.note = `Clamped up to ${formatAmount(SMALLEST_USABLE_FRACTION)} from ${formatAmount(Math.round(low.raw * 1e3) / 1e3)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`;
+  } else if (scaling === "rounded" && adjusted) {
+    result.note = `Rounded from ${formatAmount(Math.round(low.raw * 100) / 100)}.`;
   }
   return result;
 }
@@ -997,7 +1078,8 @@ function passthroughIngredients(lines) {
       text: parsed.original,
       amount: parsed.amount,
       unit: parsed.unit?.canonical ?? null,
-      scaling: "unscaled"
+      scaling: "unscaled",
+      adjusted: false
     };
   });
 }
@@ -1015,11 +1097,19 @@ var scaledIngredientSchema = z.object({
   scaling: z.enum(["scaled", "rounded", "unscaled"]).describe(
     "'scaled' was multiplied cleanly. 'rounded' was multiplied then rounded to something countable. 'unscaled' was left alone, either because it carries no quantity or because the measure is approximate by nature."
   ),
-  note: z.string().optional().describe("Why the line was rounded or left alone.")
+  adjusted: z.boolean().describe(
+    "True when rounding moved the value away from the exact product. A line can be 'rounded' and still land exactly, as three eggs doubled land on six."
+  ),
+  note: z.string().optional().describe("Why the line was rounded, clamped or left alone.")
 });
-function ok(structured, text) {
+function ok(structured, text, notes = []) {
+  const trailer = notes.map((note) => `Note: ${note}`).join("\n");
+  const budget = MAX_TEXT_MIRROR_CHARS - (trailer ? trailer.length + 2 : 0);
+  const body = truncate(text, Math.max(0, budget));
   return {
-    content: [{ type: "text", text: truncate(text, MAX_TEXT_MIRROR_CHARS) }],
+    content: [{ type: "text", text: trailer ? `${body}
+
+${trailer}` : body }],
     structuredContent: structured
   };
 }
@@ -1111,8 +1201,21 @@ async function runGetRecipe(client, args) {
       notes.push(
         `Quantities rescaled from ${originalCount} to ${args.servings} ${unit} (factor ${Math.round(factor * 100) / 100}).`
       );
-      if (ingredients.some((entry) => entry.scaling === "rounded")) {
-        notes.push("Some quantities were rounded to remain usable; see the 'scaling' field.");
+      const roundedCount = ingredients.filter(
+        (entry) => entry.scaling === "rounded" && entry.adjusted
+      ).length;
+      if (roundedCount > 0) {
+        notes.push(
+          `${roundedCount} quantity(ies) were rounded to remain usable; see the 'scaling' field.`
+        );
+      }
+      const clampedCount = ingredients.filter(
+        (entry) => /clamped up/i.test(entry.note ?? "")
+      ).length;
+      if (clampedCount > 0) {
+        notes.push(
+          `${clampedCount} quantity(ies) fell below the smallest amount worth measuring and were clamped up, so their proportions no longer match the published recipe.`
+        );
       }
       if (ingredients.some((entry) => entry.scaling === "unscaled")) {
         notes.push("Some ingredients carry no usable quantity and were left as published.");
@@ -1165,14 +1268,20 @@ async function runGetRecipe(client, args) {
       args.servings !== void 0 && factor !== null ? `Pour ${args.servings} ${data.recipeYield.unit ?? "portions"} (recette pr\xE9vue pour ${data.recipeYield.text}).` : `Recette pour ${data.recipeYield.text || "portions non pr\xE9cis\xE9es"}.`,
       times
     ].filter(Boolean).join("\n");
+    const rescaled = args.servings !== void 0 && factor !== null;
     const ingredientLines = ingredients.map((entry) => {
-      const flag = entry.scaling === "unscaled" ? " (non ajust\xE9)" : "";
+      const flag = rescaled && entry.scaling === "unscaled" ? " (non ajust\xE9)" : "";
       return `- ${entry.text}${flag}`;
     }).join("\n");
-    return ok(structured, `${header}
-
-Ingr\xE9dients:
-${ingredientLines}`);
+    const stepLines = data.steps.map((step, index) => `${index + 1}. ${step}`).join("\n");
+    const body = [
+      header,
+      `Ingr\xE9dients:
+${ingredientLines}`,
+      stepLines ? `Pr\xE9paration:
+${stepLines}` : ""
+    ].filter(Boolean).join("\n\n");
+    return ok(structured, body, notes);
   } catch (error) {
     return toToolError(error);
   }
@@ -1198,15 +1307,26 @@ var scaleIngredientsOutputShape = {
   factor: z3.number(),
   ingredients: z3.array(scaledIngredientSchema),
   scaled_count: z3.number().int(),
-  rounded_count: z3.number().int(),
+  rounded_count: z3.number().int().describe(
+    "Lines whose value rounding moved away from the exact product, not lines that could have been rounded."
+  ),
   unscaled_count: z3.number().int(),
   notes: z3.array(z3.string())
 };
+function formatFactor(factor) {
+  return String(Number(factor.toPrecision(3)));
+}
 function runScaleIngredients(args) {
   try {
     let factor;
+    const notes = [];
     if (args.factor !== void 0) {
       factor = args.factor;
+      if (args.from_servings !== void 0 || args.to_servings !== void 0) {
+        notes.push(
+          "'factor' was given alongside 'from_servings'/'to_servings'. 'factor' was applied and the pair ignored; send only one of the two to remove the ambiguity."
+        );
+      }
     } else if (args.from_servings !== void 0 && args.to_servings !== void 0) {
       factor = args.to_servings / args.from_servings;
     } else {
@@ -1218,10 +1338,12 @@ function runScaleIngredients(args) {
     const ingredients = scaleIngredients(args.ingredients, { factor });
     const counts = {
       scaled: ingredients.filter((entry) => entry.scaling === "scaled").length,
-      rounded: ingredients.filter((entry) => entry.scaling === "rounded").length,
-      unscaled: ingredients.filter((entry) => entry.scaling === "unscaled").length
+      // Lines that were actually moved, rather than lines that merely belong to
+      // the roundable category: at a factor of 100 every egg lands whole.
+      rounded: ingredients.filter((entry) => entry.scaling === "rounded" && entry.adjusted).length,
+      unscaled: ingredients.filter((entry) => entry.scaling === "unscaled").length,
+      clamped: ingredients.filter((entry) => /clamped up/i.test(entry.note ?? "")).length
     };
-    const notes = [];
     if (counts.rounded > 0) {
       notes.push(
         `${counts.rounded} quantity(ies) were rounded to stay usable, rather than left as fractions.`
@@ -1232,8 +1354,13 @@ function runScaleIngredients(args) {
         `${counts.unscaled} line(s) carry no usable quantity and were returned unchanged; adjust to taste.`
       );
     }
+    if (counts.clamped > 0) {
+      notes.push(
+        `${counts.clamped} quantity(ies) fell below the smallest amount worth measuring and were clamped up, so their proportions no longer match the original recipe.`
+      );
+    }
     const structured = {
-      factor: Math.round(factor * 1e3) / 1e3,
+      factor: Number(factor.toPrecision(3)),
       ingredients,
       scaled_count: counts.scaled,
       rounded_count: counts.rounded,
@@ -1244,8 +1371,8 @@ function runScaleIngredients(args) {
       const flag = entry.scaling === "unscaled" ? " (non ajust\xE9)" : "";
       return `- ${entry.text}${flag}`;
     }).join("\n");
-    return ok(structured, `Facteur ${Math.round(factor * 100) / 100}:
-${lines}`);
+    return ok(structured, `Facteur ${formatFactor(factor)}:
+${lines}`, notes);
   } catch (error) {
     return toToolError(error);
   }