mcp-recipes 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2026-08-07
+
+### Changed
+
+- A mass stated behind the thing counted is read as the size of one of them.
+  "1 dinde de 3 kg" names one bird and says what it weighs, and multiplying the
+  count answered a dinner for twelve with a bird and a half. Lines of that shape
+  come back as the page published them, with a note saying the figure gives a
+  size and that more people means a bigger bird. A container keeps counting:
+  "2 boîtes de 400 g de tomates" states what one boîte holds and goes on to name
+  what is in it, and an equivalence such as "450 g (1 livre) de spaghetti"
+  restates one quantity twice and is scaled on both sides.
+
+- A comparison tells apart the two moments a source can fail in. Searching and
+  then opening the version a search offered are two different readings, and a
+  source missing from a comparison was described as one whose search did not
+  answer whichever of the two had happened. Every row of `per_source` now
+  carries a `read` field saying what became of the version that source offered,
+  and the notes name the moment that failed.
+
+- A search Marmiton answers with nothing is counted as an answer. Marmiton
+  serves a 404 on its results page when no recipe matches, and reading that as a
+  failed source put "Marmiton did not answer" in front of a reader for a search
+  Marmiton had answered. Every other failure stays a failure, so a site that
+  cannot be reached is never read as a site that holds nothing.
+
+- A list of results carrying none of the words asked for says so. A source
+  ranking a title on the letters it opens with answers "chameau farci" with a
+  chapeau and a gâteau château. When no title returned carries a word of the
+  query, the answer names that, and the rows read as candidates to check.
+
 ## [1.1.0] - 2026-08-07
 
 ### Changed

package/dist/index.js

@@ -7,7 +7,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/version.ts
-var PKG_VERSION = "1.1.0";
+var PKG_VERSION = "1.2.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -379,6 +379,15 @@ var MARMITON_PROFILE = {
 };
 var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
 var REFERENCE = /^\d+$/;
+async function readSearch(reader, query) {
+  try {
+    return await reader.search(query);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "not_found") return { data: [], cached: false };
+    throw error;
+  }
+}
 function marmitonAdapter(reader) {
   return {
     ...MARMITON_PROFILE,
@@ -396,7 +405,7 @@ function marmitonAdapter(reader) {
       return null;
     },
     async search(query) {
-      const outcome = await reader.search(query);
+      const outcome = await readSearch(reader, query);
       const list = rowsOf(outcome.data, MARMITON_PROFILE);
       const rows = [];
       let skipped = 0;
@@ -1256,6 +1265,21 @@ var APPROXIMATION_PREFIX = {
   en: /^(?:~|\u2248|about|approx\.?|approximately|around|roughly)\s*/i,
   fr: /^(?:~|\u2248|environ|approximativement|\u00e0 peu pr\u00e8s|a peu pres)\s*/i
 };
+var CONTAINER_CONTENTS = /^\s*(?:de\s|d'|du\s|des\s)/i;
+function statesItemSize(item) {
+  const attached = /\s+de\s+(?=\d)/i.exec(item);
+  if (!attached) return false;
+  const named = item.slice(0, attached.index).trim();
+  if (!named || /\d/.test(named)) return false;
+  return isStatedSize(item.slice(attached.index + attached[0].length));
+}
+function isStatedSize(text2) {
+  const size = parseLeadingQuantity(text2, "fr");
+  if (!size) return false;
+  const measure = takeUnit(text2.slice(size.length).trimStart(), "fr");
+  if (!measure.unit || measure.unit.kind !== "measured") return false;
+  return !CONTAINER_CONTENTS.test(measure.rest);
+}
 var PER_PERSON = {
   en: /\bper\s+(?:person|head|serving|guest|diner)\b/i,
   fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i
@@ -1453,6 +1477,9 @@ function parseIngredient(line, choice = "auto") {
   rest = bracketed.rest;
   const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
   if (slashed) rest = slashed.rest;
+  const item = stripItemLead(rest, language);
+  if (language === "fr" && !leading.unit && statesItemSize(item)) return empty("itemSize");
+  if (language === "fr" && leading.partitive && isStatedSize(item)) return empty("itemSize");
   return {
     original,
     language,
@@ -1507,12 +1534,12 @@ function readCountMultiplier(text2) {
 }
 function takeLeadingUnit(text2, language, fromArticle) {
   const taken = takeUnit(text2, language);
-  if (taken.unit) return taken;
+  if (taken.unit) return { ...taken, partitive: false };
   if (language === "fr" && fromArticle) {
     const measure = readPartitiveMeasure(text2);
-    if (measure) return { unit: measure.unit, rest: measure.rest };
+    if (measure) return { unit: measure.unit, rest: measure.rest, partitive: true };
   }
-  return taken;
+  return { ...taken, partitive: false };
 }
 function stripItemLead(text2, language) {
   if (language === "fr") {
@@ -2045,6 +2072,7 @@ function scaleAlternative(tail, options) {
 }
 var HELD_BACK_NOTE = {
   sizeQualifier: "The figures here give the size of one item rather than how many, so the line is left as published.",
+  itemSize: "The measure standing behind the item gives the size of one of them rather than how many, so the line is left as published. Serving more people is a matter of taking a bigger one, and serving fewer a smaller one.",
   perPerson: "This line already states an amount for one person, and the factor is what changes how many people the recipe serves, so the line is left as published.",
   ambiguousDecimal: "The comma in this number marks thousands in one convention and the decimal point in another, and the line gives no sign which was meant, so it is left as published."
 };
@@ -2235,7 +2263,13 @@ var reportSchema = z.object({
     code: z.string(),
     message: z.string(),
     hint: z.string().optional()
-  }).nullable().describe("Why this source did not answer. Null when it did.")
+  }).nullable().describe("Why this source did not answer. Null when it did."),
+  read: z.object({
+    status: z.enum(["read", "failed"]),
+    error: z.object({ code: z.string(), message: z.string(), hint: z.string().optional() }).nullable()
+  }).nullable().describe(
+    "What became of the row this source offered, once it was opened. Null when no row was opened, which is what a search that did not answer and a search holding nothing both come to. A search and a read are two moments, and this is the second one."
+  )
 });
 var ingredientSchema = z.object({
   text: z.string().describe("The line as it now reads."),
@@ -2285,9 +2319,15 @@ function toReportPayload(report) {
     reported_total_means: report.reportedTotalMeans,
     skipped: report.skipped,
     cached: report.cached,
-    error: report.error ?? null
+    error: report.error ?? null,
+    // A search alone opens nothing, so only a tool that reads a row fills this
+    // in, through `withRead`.
+    read: null
   };
 }
+function withRead(payload, read) {
+  return { ...payload, read };
+}
 function reportNotes(reports) {
   const notes = [];
   const answered = reports.filter((report) => report.status === "answered");
@@ -2721,14 +2761,19 @@ async function runCompareRecipes(client, args) {
     const reads = await Promise.allSettled(offered.map(([, id]) => client.getRecipe(id)));
     const recipes = [];
     const unread = /* @__PURE__ */ new Map();
+    const opened = /* @__PURE__ */ new Set();
     reads.forEach((read, index) => {
       const source = offered[index][0];
+      opened.add(source);
       if (read.status === "fulfilled") {
         recipes.push(read.value.recipe);
         return;
       }
       const reason = read.reason;
-      unread.set(source, `${reason?.code ?? "network_error"}: ${reason?.message ?? "unknown"}`);
+      unread.set(source, {
+        code: reason?.code ?? "network_error",
+        message: reason?.message ?? "unknown"
+      });
     });
     const views = recipes.map(
       (recipe) => buildRecipeView(recipe, {
@@ -2756,11 +2801,15 @@ async function runCompareRecipes(client, args) {
       const failedRead = unread.get(report.source);
       if (report.status === "failed") {
         notes.push(
-          `${report.name} is missing from this comparison because its search did not answer, not because it holds nothing.`
+          `${report.name} is missing from this comparison because its search did not answer (${quoteForeign(
+            `${report.error?.code ?? "unknown"}: ${report.error?.message ?? "unknown"}`
+          )}). Nothing here is evidence about what it holds.`
         );
       } else if (failedRead) {
         notes.push(
-          `${report.name} offered a recipe and it could not be read (${quoteForeign(failedRead)}), so its version is missing rather than absent.`
+          `${report.name}'s search answered and offered a version, and that version could not be read (${quoteForeign(
+            `${failedRead.code}: ${failedRead.message}`
+          )}). The failure is in the reading, so nothing here says whether ${report.name} holds this dish.`
         );
       } else {
         notes.push(
@@ -2817,7 +2866,17 @@ ${shownDifferences.map((line) => `- ${line}`).join("\n")}${moreDifferences > 0 ?
         dish: args.dish,
         versions: payloads,
         differences,
-        per_source: merged.reports.map(toReportPayload),
+        // Two moments per source, told apart: whether the search answered, and
+        // what became of the row it offered.
+        per_source: merged.reports.map((report) => {
+          const payload = toReportPayload(report);
+          if (!opened.has(report.source)) return payload;
+          const failedRead = unread.get(report.source);
+          return withRead(
+            payload,
+            failedRead ? { status: "failed", error: { code: failedRead.code, message: failedRead.message } } : { status: "read", error: null }
+          );
+        }),
         notes
       },
       summary,
@@ -3029,6 +3088,13 @@ var searchRecipesOutput = z7.object({
   notes: z7.array(z7.string())
 });
 var WORDS_BEFORE_SAYING_SO = 4;
+function titleCarries(title, query) {
+  const fold = (text2) => text2.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/œ/g, "oe").toLowerCase().replace(/[^a-z0-9]+/g, " ");
+  const haystack = ` ${fold(title)} `;
+  const words = fold(query).split(" ").filter((word) => word.length > 2);
+  if (words.length === 0) return true;
+  return words.some((word) => haystack.includes(` ${word}`));
+}
 async function runSearchRecipes(client, args) {
   try {
     const merged = await client.searchRecipes(
@@ -3046,6 +3112,11 @@ async function runSearchRecipes(client, args) {
         "This query went to each source as free text and no filter was applied to it. Words like 'vegan' or 'under 300 calories' help only where a source's own index happens to match them, so read the rows rather than assuming they meet every condition."
       );
     }
+    if (results.length > 0 && !results.some((row) => titleCarries(row.title, args.query))) {
+      notes.push(
+        `No title here carries a word of "${args.query}". These rows are what the sources ranked for that spelling, so read them as candidates to check rather than as recipes for the dish.`
+      );
+    }
     if (results.length === 0 && answered.length === merged.reports.length) {
       notes.push(
         "Every source answered and none holds anything under this wording. Try the dish's name in another language, or name a main ingredient instead."