mcp-recipes 1.2.0 → 1.3.0

package/dist/sources/client.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var PKG_VERSION = "1.2.0";
+var PKG_VERSION = "1.3.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -94,11 +94,17 @@ var RecipesError = class extends Error {
     this.details = details;
   }
 };
+var notFound = (message, details) => new RecipesError("not_found", message, details ?? {});
 var invalidInput = (message, hint) => new RecipesError("invalid_input", message, hint ? { hint } : {});
+var rateLimited = (message, details) => new RecipesError("rate_limited", message, {
+  hint: "Wait a moment and ask again. This says nothing about whether the recipe exists.",
+  ...details
+});
 var parseFailure = (message, details) => new RecipesError("parse_failure", message, {
   hint: `A site may have changed how it answers. Please report this at ${ISSUES_URL} with the arguments you used.`,
   ...details
 });
+var networkError = (message, details) => new RecipesError("network_error", message, details ?? {});
 var timeout = (message, details) => new RecipesError("timeout", message, details ?? {});
 function toRecipesError(error) {
   if (error instanceof RecipesError) return error;
@@ -109,6 +115,30 @@ function toRecipesError(error) {
   const details = raw && typeof raw.details === "object" && raw.details !== null ? raw.details : {};
   return new RecipesError(known ?? "network_error", message, details);
 }
+function fromSource(error, sourceName) {
+  if (error instanceof RecipesError) return error;
+  const known = toRecipesError(error);
+  const reported = known.message.replace(/\s+/g, " ").trim();
+  const opening = known.code === "not_found" ? `${sourceName} holds nothing under this name.` : `${sourceName} could not be read.`;
+  const message = reported === "" ? opening : `${opening} It reports: "${reported}"`;
+  const details = {};
+  if (known.details.url !== void 0) details.url = known.details.url;
+  if (known.details.status !== void 0) details.status = known.details.status;
+  switch (known.code) {
+    case "not_found":
+      return notFound(message, details);
+    case "invalid_input":
+      return invalidInput(message);
+    case "rate_limited":
+      return rateLimited(message, details);
+    case "parse_failure":
+      return parseFailure(message, details);
+    case "timeout":
+      return timeout(message, details);
+    default:
+      return networkError(message, details);
+  }
+}
 
 // src/sources/adapter.ts
 function text(value) {
@@ -341,6 +371,9 @@ function cookbookDetail(payload) {
     yieldUnit: text(recipe.yieldUnit) ?? span.unit,
     ingredients: textList(recipe.ingredients),
     steps: textList(recipe.steps),
+    // The page's own headings, which the reader reports. An answer holding no
+    // ingredient line uses them to say whether the page announced a list.
+    publishedSections: Array.isArray(recipe.sectionTitles) ? textList(recipe.sectionTitles) : null,
     // The Cookbook publishes one time for a recipe rather than splitting it.
     prepMinutes: null,
     cookMinutes: null,
@@ -458,6 +491,10 @@ function marmitonDetail(payload) {
     yieldUnit: span.unit ?? text(yields.unit),
     ingredients: textList(recipe.ingredients),
     steps: textList(recipe.steps),
+    // The reader hands over the parts of a page it recognised and not the
+    // headings the page carries, so there is nothing here to say how it is
+    // laid out.
+    publishedSections: null,
     prepMinutes: count(recipe.prepMinutes),
     cookMinutes: count(recipe.cookMinutes),
     totalMinutes: count(recipe.totalMinutes),
@@ -510,6 +547,473 @@ function selectSources(sources, wanted) {
   return chosen;
 }
 
+// src/sources/wordings.ts
+var MAX_WORDINGS_PER_SOURCE = 3;
+var FRENCH_FRAME = /* @__PURE__ */ new Set([
+  "a",
+  "ai",
+  "aimerais",
+  "au",
+  "aurais",
+  "auriez",
+  "aux",
+  "avec",
+  "avons",
+  "bcp",
+  "beaucoup",
+  "bien",
+  "bonjour",
+  "bonne",
+  "bonnes",
+  "cherche",
+  "chercher",
+  "cherchez",
+  "connais",
+  "connaissez",
+  "coucou",
+  "ce",
+  "ces",
+  "cette",
+  "comment",
+  "d",
+  "dans",
+  "de",
+  "des",
+  "du",
+  "en",
+  "est",
+  "et",
+  "facile",
+  "faire",
+  "fais",
+  "fait",
+  "idee",
+  "idees",
+  "id\xE9e",
+  "id\xE9es",
+  "j",
+  "je",
+  "l",
+  "la",
+  "le",
+  "les",
+  "ma",
+  "meilleur",
+  "meilleure",
+  "merci",
+  "mes",
+  "mon",
+  "ou",
+  "par",
+  "peux",
+  "plait",
+  "pla\xEEt",
+  "plus",
+  "pour",
+  "qu",
+  "que",
+  "quel",
+  "quelle",
+  "quelles",
+  "quels",
+  "qui",
+  "rapide",
+  "recette",
+  "recettes",
+  "recherche",
+  "s",
+  "salut",
+  "se",
+  "si",
+  "simple",
+  "sommes",
+  "souhaite",
+  "stp",
+  "suis",
+  "sur",
+  "svp",
+  "tres",
+  "tr\xE8s",
+  "un",
+  "une",
+  "veux",
+  "voudrais",
+  "vous",
+  "\xE0"
+]);
+var ENGLISH_FRAME = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "am",
+  "an",
+  "and",
+  "any",
+  "anything",
+  "are",
+  "at",
+  "be",
+  "best",
+  "by",
+  "can",
+  "could",
+  "do",
+  "does",
+  "easy",
+  "find",
+  "for",
+  "from",
+  "get",
+  "good",
+  "hello",
+  "hi",
+  "how",
+  "i",
+  "in",
+  "into",
+  "is",
+  "it",
+  "like",
+  "looking",
+  "make",
+  "making",
+  "me",
+  "my",
+  "need",
+  "of",
+  "on",
+  "or",
+  "please",
+  "quick",
+  "recipe",
+  "recipes",
+  "should",
+  "simple",
+  "some",
+  "something",
+  "suggest",
+  "thank",
+  "thanks",
+  "that",
+  "the",
+  "less",
+  "over",
+  "than",
+  "to",
+  "under",
+  "want",
+  "what",
+  "which",
+  "will",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+var CONDITION_UNITS = /* @__PURE__ */ new Set([
+  "calorie",
+  "calories",
+  "couvert",
+  "couverts",
+  "heure",
+  "heures",
+  "kcal",
+  "min",
+  "mins",
+  "minute",
+  "minutes",
+  "part",
+  "parts",
+  "people",
+  "person",
+  "persons",
+  "personne",
+  "personnes",
+  "portion",
+  "portions",
+  "serving",
+  "servings"
+]);
+var NEGATORS = /* @__PURE__ */ new Set([
+  "aucun",
+  "aucune",
+  "avoid",
+  "avoiding",
+  "eviter",
+  "evite",
+  "evitez",
+  "exclude",
+  "excluding",
+  "exclure",
+  "except",
+  "ni",
+  "no",
+  "non",
+  "not",
+  "pas",
+  "sans",
+  "sauf",
+  "without",
+  "zero"
+]);
+var HEALTH_MARKERS = /* @__PURE__ */ new Set([
+  "allergene",
+  "allergenes",
+  "allergen",
+  "allergens",
+  "allergic",
+  "allergie",
+  "allergies",
+  "allergique",
+  "allergiques",
+  "allergy",
+  "celiac",
+  "coeliaque",
+  "intolerance",
+  "intolerances",
+  "intolerant",
+  "intolerante",
+  "intolerantes",
+  "intolerants"
+]);
+var DIETS = /* @__PURE__ */ new Set([
+  "casher",
+  "cetogene",
+  "halal",
+  "kascher",
+  "keto",
+  "ketogenic",
+  "kosher",
+  "paleo",
+  "pescatarian",
+  "pescetarien",
+  "pescetarienne",
+  "vegan",
+  "vegane",
+  "veganes",
+  "vegans",
+  "vegetalien",
+  "vegetalienne",
+  "vegetaliennes",
+  "vegetaliens",
+  "vegetarian",
+  "vegetarians",
+  "vegetarien",
+  "vegetarienne",
+  "vegetariennes",
+  "vegetariens",
+  "veggie"
+]);
+var CONDITION_ENDS = /* @__PURE__ */ new Set([
+  "et",
+  "and",
+  "ou",
+  "or",
+  "pour",
+  "for",
+  "avec",
+  "with",
+  "mais",
+  "but",
+  "dans",
+  "sur"
+]);
+var CONDITION_JOINERS = /* @__PURE__ */ new Set([
+  "a",
+  "au",
+  "aux",
+  "d",
+  "de",
+  "des",
+  "du",
+  "from",
+  "l",
+  "la",
+  "le",
+  "les",
+  "my",
+  "of",
+  "the",
+  "to"
+]);
+var FOOD_LINKERS = /* @__PURE__ */ new Set(["d", "de", "des", "du", "of"]);
+var CONDITION_WORDS = 3;
+var SERVING_PHRASES = [
+  /\bpour\s+(\d{1,3})\s*(?:personnes?|parts?|couverts?)\b/iu,
+  /\bfor\s+(\d{1,3})\s*(?:people|persons?|servings?|portions?)\b/iu,
+  /\bserves?\s+(\d{1,3})\b/iu,
+  /\b(\d{1,3})\s*(?:personnes?|people|servings?)\b/iu
+];
+var FREE_OF = /\b([\p{L}]{3,})[\s-]?free\b/iu;
+function foldWord(word) {
+  return word.toLowerCase().normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/œ/gu, "oe");
+}
+function readQuestion(question) {
+  const words = tokenise(question);
+  const conditions = [];
+  const dish = [];
+  const state = (named, kind) => {
+    const trimmed = named === null ? null : named.trim();
+    if (trimmed === "") return;
+    if (conditions.some((held) => held.named === trimmed && held.kind === kind)) return;
+    conditions.push({ named: trimmed, kind });
+  };
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index];
+    const key = foldWord(word);
+    const hyphen = word.indexOf("-");
+    if (hyphen > 0 && NEGATORS.has(foldWord(word.slice(0, hyphen)))) {
+      state(word.slice(hyphen + 1), "excluded");
+      continue;
+    }
+    const free = FREE_OF.exec(word);
+    if (free) {
+      state(free[1], "excluded");
+      continue;
+    }
+    if (key === "free") {
+      const scope = scopeOf(words, index, dish);
+      if (scope.named !== null) {
+        state(scope.named, "excluded");
+        index = scope.next - 1;
+      }
+      continue;
+    }
+    if (NEGATORS.has(key)) {
+      const forward = takeFood(words, index + 1);
+      state(forward.named === "" ? null : forward.named, "excluded");
+      index = forward.next - 1;
+      continue;
+    }
+    if (HEALTH_MARKERS.has(key)) {
+      const scope = scopeOf(words, index, dish);
+      state(scope.named, "allergy");
+      index = scope.next - 1;
+      continue;
+    }
+    if (DIETS.has(key)) {
+      state(word, "diet");
+      continue;
+    }
+    if (FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key)) continue;
+    if (FRENCH_FRAME.has(word) || ENGLISH_FRAME.has(word)) continue;
+    if (/^\d+$/.test(word)) continue;
+    if (word.length < 2) continue;
+    if (CONDITION_UNITS.has(word)) continue;
+    if (!dish.includes(word)) dish.push(word);
+  }
+  return { dish, conditions };
+}
+function scopeOf(words, marker, dish) {
+  if (CONDITION_JOINERS.has(foldWord(words[marker + 1] ?? ""))) {
+    const forward = takeFood(words, marker + 1);
+    return { named: forward.named === "" ? null : forward.named, next: forward.next };
+  }
+  const before = words[marker - 1];
+  if (before !== void 0) {
+    const held = dish.lastIndexOf(before);
+    if (held !== -1) {
+      dish.splice(held, 1);
+      return { named: before, next: marker + 1 };
+    }
+  }
+  return { named: null, next: marker + 1 };
+}
+function takeFood(words, from) {
+  let index = from;
+  while (index < words.length && isFiller(words[index])) index += 1;
+  const named = [];
+  while (index < words.length && named.length < CONDITION_WORDS) {
+    if (!namesFood(words[index])) break;
+    named.push(words[index]);
+    index += 1;
+    const beyond = words[index + 1];
+    if (named.length + 2 <= CONDITION_WORDS && FOOD_LINKERS.has(foldWord(words[index] ?? "")) && beyond !== void 0 && namesFood(beyond)) {
+      named.push(words[index]);
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return { named: named.join(" "), next: index };
+}
+function isFiller(word) {
+  const key = foldWord(word);
+  return CONDITION_JOINERS.has(key) || FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key);
+}
+function namesFood(word) {
+  const key = foldWord(word);
+  if (key.length < 2) return false;
+  if (/^\d+$/.test(key)) return false;
+  if (key === "free") return false;
+  if (CONDITION_ENDS.has(key)) return false;
+  if (NEGATORS.has(key) || HEALTH_MARKERS.has(key)) return false;
+  if (CONDITION_UNITS.has(key)) return false;
+  return !(FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key));
+}
+function readConditions(question) {
+  const { conditions } = readQuestion(question);
+  let servings = null;
+  for (const phrase of SERVING_PHRASES) {
+    const found = phrase.exec(question);
+    if (found) {
+      const value = Number(found[1]);
+      if (Number.isFinite(value) && value > 0) {
+        servings = value;
+        break;
+      }
+    }
+  }
+  return { conditions, servings };
+}
+function deriveWordings(question) {
+  const asked = tidy(question);
+  const wordings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const offer = (candidate, derivation) => {
+    const clean = tidy(candidate);
+    if (clean === "") return;
+    const key = clean.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    wordings.push({ query: clean, derivation });
+  };
+  offer(asked, "the words as asked, condition words included");
+  const dish = dishWords(asked);
+  offer(
+    dish.join(" "),
+    "the words naming the dish, with the words framing the question and the conditions set aside, because a page is named for what it holds"
+  );
+  offer(
+    dish[0] ?? "",
+    "the leading dish word on its own, because an index that requires every word given returns nothing for a phrase and a great deal for the word naming the dish"
+  );
+  return wordings.slice(0, MAX_WORDINGS_PER_SOURCE);
+}
+function namesDish(title, question) {
+  const words = namingWords(question);
+  if (words.length === 0) return true;
+  return dishWordsMissing(title, question).length < words.length;
+}
+function dishWordsMissing(title, question) {
+  const haystack = ` ${fold(title)} `;
+  return namingWords(question).filter((word) => !haystack.includes(` ${fold(word)}`));
+}
+function namingWords(question) {
+  return dishWords(question).filter((word) => word.length > 2);
+}
+function fold(value) {
+  return value.normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/œ/gu, "oe").toLowerCase().replace(/[^a-z0-9]+/g, " ");
+}
+function dishWords(question) {
+  return readQuestion(question).dish;
+}
+function tokenise(value) {
+  return value.toLowerCase().replace(/['’]/gu, " ").split(/[^\p{L}\p{N}-]+/u).map((word) => word.replace(/^-+|-+$/g, "")).filter((word) => word !== "");
+}
+function tidy(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
 // src/sources/client.ts
 var MAX_LIMIT_PER_SOURCE = 25;
 function withGuarantees(config) {
@@ -542,9 +1046,7 @@ function withDeadline(work, ms, source) {
   const alarm = new Promise((_resolve, reject) => {
     timer = setTimeout(
       () => reject(
-        timeout(
-          `${source.name} did not answer within ${ms}ms and was left out of this answer.`
-        )
+        timeout(`${source.name} did not answer within ${ms}ms and was left out of this answer.`)
       ),
       ms
     );
@@ -563,7 +1065,20 @@ function reportOf(attempt, count2) {
     skipped: attempt.skipped,
     mixesReferencePages: attempt.source.mixesReferencePages,
     cached: attempt.cached,
-    error: attempt.error
+    error: attempt.error,
+    wordings: attempt.wordings,
+    preferredByName: attempt.preferredByName
+  };
+}
+function heldBack(wording, because) {
+  return {
+    query: wording.query,
+    derivation: wording.derivation,
+    ran: false,
+    count: null,
+    added: null,
+    notRunBecause: because,
+    error: null
   };
 }
 function interleave(groups) {
@@ -623,15 +1138,22 @@ var RecipesClient = class {
    * source rather than as long as all of them. Whichever of them fail, the rest
    * still come back, and the report says which was which.
    */
-  async searchRecipes(query, limitPerSource, wanted) {
+  async searchRecipes(query, limitPerSource, wanted, options = {}) {
     const trimmed = query.trim();
     if (trimmed === "") {
       throw invalidInput("A search needs something to look for.", "Name a dish or an ingredient.");
     }
+    if (!/[\p{L}\p{N}]/u.test(trimmed)) {
+      throw invalidInput(
+        `"${trimmed}" carries no letter and no digit, so there is no word to search for.`,
+        "Name a dish or an ingredient."
+      );
+    }
     const chosen = selectSources(this.sources, wanted);
     const limit = Math.max(1, Math.min(MAX_LIMIT_PER_SOURCE, Math.trunc(limitPerSource)));
+    const fanOut = options.fanOut ?? true;
     const attempts = await Promise.all(
-      chosen.map((source) => this.searchOne(source, trimmed, limit))
+      chosen.map((source) => this.searchOne(source, trimmed, limit, fanOut))
     );
     const groups = attempts.map((attempt) => attempt.rows.slice(0, limit));
     return {
@@ -639,40 +1161,135 @@ var RecipesClient = class {
       reports: attempts.map((attempt, index) => reportOf(attempt, groups[index].length))
     };
   }
-  async searchOne(source, query, limit) {
-    try {
-      const read = await withDeadline(source.search(query, limit), this.deadlineMs, source);
-      if (read.skipped > 0) {
-        this.logger.warn(
-          `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+  /**
+   * Ask one source the question in several wordings, and union what comes back.
+   *
+   * The wordings go out one after another rather than together, because each
+   * source is paced and a burst would spend the whole ladder's politeness at
+   * once. They stop early: a wording is only sent when the ones before it left
+   * the source short of what was asked for, so the ordinary case where the
+   * question names a dish costs one request.
+   *
+   * Each wording is a different search rather than a further page of the same
+   * one. One of these sites serves a single page of results and disallows
+   * paging past it, so a second page is never asked for, here or anywhere else.
+   */
+  async searchOne(source, question, limit, fanOut) {
+    const derived = deriveWordings(question);
+    const wordings = [];
+    const rows = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cached = false;
+    let skipped = 0;
+    let reportedTotal = null;
+    let reportedTotalMeans = null;
+    let answered = false;
+    let failure = null;
+    let onTopic = 0;
+    for (const [index, wording] of derived.entries()) {
+      if (index > 0 && !fanOut) {
+        wordings.push(
+          heldBack(wording, "fan_out was turned off, so only the words as asked were sent")
         );
+        continue;
       }
-      return {
-        source,
-        rows: read.rows,
-        cached: read.cached,
-        reportedTotal: read.reportedTotal,
-        reportedTotalMeans: read.reportedTotalMeans,
-        skipped: read.skipped,
-        error: null
-      };
-    } catch (error) {
-      const known = toRecipesError(error);
-      this.logger.warn(`${source.name} did not answer: [${known.code}] ${known.message}`);
-      return {
-        source,
-        rows: [],
-        cached: false,
-        reportedTotal: null,
-        reportedTotalMeans: null,
-        skipped: 0,
-        error: {
+      if (index >= MAX_WORDINGS_PER_SOURCE) {
+        wordings.push(
+          heldBack(
+            wording,
+            `the ceiling of ${MAX_WORDINGS_PER_SOURCE} searches of one source was reached`
+          )
+        );
+        continue;
+      }
+      if (failure !== null) {
+        wordings.push(
+          heldBack(wording, `${source.name} did not answer the wording before this one`)
+        );
+        continue;
+      }
+      if (onTopic >= limit) {
+        wordings.push(
+          heldBack(
+            wording,
+            "the wordings already sent returned as many rows naming the dish as were asked for"
+          )
+        );
+        continue;
+      }
+      try {
+        const read = await withDeadline(
+          source.search(wording.query, limit),
+          this.deadlineMs,
+          source
+        );
+        answered = true;
+        cached = cached || read.cached;
+        skipped += read.skipped;
+        if (reportedTotal === null && reportedTotalMeans === null) {
+          reportedTotal = read.reportedTotal;
+          reportedTotalMeans = read.reportedTotalMeans;
+        }
+        if (read.skipped > 0) {
+          this.logger.warn(
+            `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+          );
+        }
+        let added = 0;
+        for (const row of read.rows) {
+          if (seen.has(row.id)) continue;
+          seen.add(row.id);
+          rows.push(row);
+          added += 1;
+          if (namesDish(row.title, question)) onTopic += 1;
+        }
+        wordings.push({
+          query: wording.query,
+          derivation: wording.derivation,
+          ran: true,
+          count: read.rows.length,
+          added,
+          notRunBecause: null,
+          error: null
+        });
+      } catch (error) {
+        const known = fromSource(error, source.name);
+        this.logger.warn(
+          `${source.name} did not answer "${wording.query}": [${known.code}] ${known.message}`
+        );
+        const reason = {
           code: known.code,
           message: known.message,
           ...known.details.hint ? { hint: known.details.hint } : {}
-        }
-      };
+        };
+        wordings.push({
+          query: wording.query,
+          derivation: wording.derivation,
+          ran: true,
+          count: null,
+          added: null,
+          notRunBecause: null,
+          error: reason
+        });
+        failure = reason;
+      }
     }
+    const contributing = wordings.filter((attempt) => (attempt.added ?? 0) > 0).length;
+    const ordered = contributing > 1 ? [
+      ...rows.filter((row) => namesDish(row.title, question)),
+      ...rows.filter((row) => !namesDish(row.title, question))
+    ] : rows;
+    return {
+      source,
+      rows: ordered,
+      preferredByName: contributing > 1,
+      cached,
+      reportedTotal,
+      reportedTotalMeans,
+      skipped,
+      error: answered ? null : failure,
+      wordings
+    };
   }
   /**
    * Read one recipe, from whichever source the identifier names.
@@ -691,16 +1308,20 @@ var RecipesClient = class {
       );
       return { recipe: outcome.recipe, cached: outcome.cached, read };
     } catch (error) {
-      throw toRecipesError(error);
+      throw fromSource(error, read.source.name);
     }
   }
 };
 export {
   MAX_LIMIT_PER_SOURCE,
+  MAX_WORDINGS_PER_SOURCE,
   RecipesClient,
   SOURCE_IDS,
+  deriveWordings,
   interleave,
+  namesDish,
   namespacedId,
+  readConditions,
   resolveId
 };
 //# sourceMappingURL=client.js.map