mcp-recipes 2.0.0 → 3.0.1

package/dist/sources/client.js

@@ -2,7 +2,7 @@
 import process from "process";
 
 // src/version.ts
-var PKG_VERSION = "2.0.0";
+var PKG_VERSION = "3.0.1";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -214,7 +214,10 @@ function example(sources) {
 }
 
 // src/sources/registry.ts
+import { GoodFoodClient } from "mcp-bbc-goodfood/client";
 import { MarmitonClient } from "mcp-marmiton/client";
+import { PtitchefClient } from "mcp-ptitchef/client";
+import { SupertoinetteClient } from "mcp-supertoinette/client";
 import { CookbookClient } from "mcp-wikibooks-cookbook/client";
 
 // src/sources/adapter.ts
@@ -416,12 +419,176 @@ function cookbookDetail(payload) {
     nutrition: publishedFigures(recipe.nutrition),
     equipment: textList(recipe.equipment),
     tips: textList(recipe.tips),
+    // The Cookbook publishes no resting time, says nothing about how a page
+    // lays its method out, and keeps nothing behind a subscription.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    withheld: null,
     // A licence is only stated when both halves of it arrived: a name with no
     // address, or an address with no name, is not terms anyone can follow.
     license: licenseTitle && licenseUrl ? { title: licenseTitle, url: licenseUrl } : null
   };
 }
 
+// src/sources/goodfood.ts
+var GOODFOOD_PROFILE = {
+  id: "goodfood",
+  name: "BBC Good Food",
+  homeUrl: "https://www.bbcgoodfood.com",
+  language: "en",
+  attribution: "Source: BBC Good Food",
+  // The search serves recipe pages; a question aimed at the site's reviews and
+  // buying guides is answered with recipes all the same.
+  mixesReferencePages: false
+};
+var SITE_URL2 = /^https?:\/\/(?:www\.)?bbcgoodfood\.com\//i;
+var REFERENCE = /^recipes\/[^/]+$/;
+var DOT_SEGMENT = /(?:^|\/)\.\.?(?:\/|$)/;
+var LEADING_SLASH = /^\/+/;
+function asReference(raw) {
+  const path = raw.replace(LEADING_SLASH, "");
+  return REFERENCE.test(path) && !DOT_SEGMENT.test(`/${path}`) ? path : null;
+}
+function meansFor(report) {
+  if (count(report.total_available) === null) {
+    return null;
+  }
+  return report.total_is_ceiling === true ? "recipes BBC Good Food says its catalogue matches this wording, cut at the largest number of rows one search will serve, so it states a floor rather than a count" : "recipes BBC Good Food says its whole catalogue matches this wording; it counts the catalogue rather than the rows served";
+}
+function nutritionPanel(recipe) {
+  const facts = Array.isArray(recipe.nutrition) ? recipe.nutrition : [];
+  const kept = {};
+  for (const fact of facts) {
+    const label = text(fact?.label);
+    const value = count(fact?.value);
+    if (label === null || value === null) {
+      continue;
+    }
+    const unit = text(fact?.unit);
+    kept[label] = unit === null ? String(value) : `${value} ${unit}`;
+  }
+  const per = text(recipe.nutrition_per);
+  if (Object.keys(kept).length === 0) {
+    return null;
+  }
+  if (per !== null) {
+    kept.per = per;
+  }
+  return kept;
+}
+function goodfoodAdapter(reader) {
+  return {
+    ...GOODFOOD_PROFILE,
+    claims(raw) {
+      if (SITE_URL2.test(raw)) {
+        const path2 = asReference(new URL(raw).pathname);
+        return path2 === null ? null : { reference: path2, why: "the address is a BBC Good Food recipe page", guess: false };
+      }
+      const path = asReference(raw);
+      return path === null ? null : {
+        reference: path,
+        why: "the path is the shape BBC Good Food mints for a recipe",
+        guess: false
+      };
+    },
+    async search(query, limit) {
+      const outcome = await reader.searchRecipes(query, { limit });
+      const report = outcome.data ?? {};
+      const list = rowsOf(report.results, GOODFOOD_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(GOODFOOD_PROFILE.id, id),
+          source: GOODFOOD_PROFILE.id,
+          sourceName: GOODFOOD_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          // A row carries a title and a picture and no prose.
+          excerpt: null
+        });
+      }
+      return {
+        rows,
+        skipped,
+        reportedTotal: count(report.total_available),
+        reportedTotalMeans: meansFor(report),
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: goodfoodDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function goodfoodDetail(payload) {
+  const recipe = payload ?? {};
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const value = count(recipe.rating);
+  const groups = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  const lines = [];
+  for (const group of groups) {
+    const heading = text(group?.heading);
+    if (heading !== null) {
+      lines.push(heading);
+    }
+    for (const entry of group?.ingredients ?? []) {
+      const line = text(entry?.text);
+      if (line !== null) {
+        lines.push(line);
+      }
+    }
+  }
+  return {
+    ...detailBase(GOODFOOD_PROFILE),
+    id: namespacedId(GOODFOOD_PROFILE.id, required(recipe.id, "id", GOODFOOD_PROFILE)),
+    title: required(recipe.title, "title", GOODFOOD_PROFILE),
+    url: required(recipe.url, "url", GOODFOOD_PROFILE),
+    // A row carries the picture; the recipe page's own is not read.
+    imageUrl: null,
+    yieldCount: count(recipe.yield_count) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit,
+    ingredients: lines,
+    steps: Array.isArray(recipe.steps) ? recipe.steps.filter((step) => typeof step === "string") : [],
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site publishes no resting time of its own.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    // The page carries these and the site sells access to them. What is said
+    // here is what the site did, so an answer never reports a wall as a page
+    // this server could not read.
+    withheld: recipe.premium === true ? {
+      parts: ["ingredients", "method"],
+      why: "BBC Good Food keeps this recipe's ingredients and method for its subscribers, and publishes its title, its times, its rating and its nutrition"
+    } : null,
+    // The site files a recipe under collections rather than under one category
+    // on the page itself.
+    category: null,
+    author: text(recipe.author),
+    rating: value === null ? null : { value, count: count(recipe.rating_count), max: 5 },
+    nutrition: nutritionPanel(recipe),
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
 // src/sources/marmiton.ts
 var ABSOLUTE_URL = /^https?:\/\//i;
 var MARMITON_PROFILE = {
@@ -433,8 +600,8 @@ var MARMITON_PROFILE = {
   // Every page the search returns is a recipe.
   mixesReferencePages: false
 };
-var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
-var REFERENCE = /^\d+$/;
+var SITE_URL3 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
+var REFERENCE2 = /^\d+$/;
 async function readSearch(reader, query) {
   try {
     return await reader.search(query);
@@ -450,10 +617,10 @@ function marmitonAdapter(reader) {
   return {
     ...MARMITON_PROFILE,
     claims(raw) {
-      if (SITE_URL2.test(raw)) {
+      if (SITE_URL3.test(raw)) {
         return { reference: raw, why: "the address is a Marmiton page", guess: false };
       }
-      if (REFERENCE.test(raw)) {
+      if (REFERENCE2.test(raw)) {
         return {
           reference: raw,
           why: "a bare number is the shape Marmiton mints",
@@ -537,14 +704,277 @@ function marmitonDetail(payload) {
     nutrition: publishedFigures(recipe.nutrition),
     equipment: [],
     tips: [],
+    // Marmiton publishes no resting time, no word on how it lays its method
+    // out, and keeps nothing back.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    withheld: null,
     // Marmiton states no licence on a recipe page, and silence is not a grant.
     license: null
   };
 }
 
+// src/sources/ptitchef.ts
+var PTITCHEF_PROFILE = {
+  id: "ptitchef",
+  name: "Ptitchef",
+  homeUrl: "https://www.ptitchef.com",
+  language: "fr",
+  attribution: "Source: Ptitchef",
+  // Every row a listing serves names a recipe; a topic the site answers with a
+  // guide of its own groups recipes under headings rather than mixing in pages
+  // about ingredients.
+  mixesReferencePages: false
+};
+var SITE_URL4 = /^https?:\/\/(?:www\.)?ptitchef\.com\//i;
+var REFERENCE3 = /^recettes\/[^/]+\/[^/]+-fid-\d+$/;
+var DOT_SEGMENT2 = /(?:^|\/)\.\.?(?:\/|$)/;
+var LEADING_SLASH2 = /^\/+/;
+function asReference2(raw) {
+  const path = raw.replace(LEADING_SLASH2, "");
+  return REFERENCE3.test(path) && !DOT_SEGMENT2.test(`/${path}`) ? path : null;
+}
+function meansFor2(listing) {
+  if (count(listing.total_available) === null) {
+    return null;
+  }
+  switch (listing.kind) {
+    case "topic":
+    case "category":
+    case "standing":
+      return "recipes Ptitchef says the category page it answered this wording with holds; it counts that page rather than what the words matched";
+    case "free_text":
+    case "fridge":
+      return "rows Ptitchef served on the single page it answered this wording with; the site offers no more for it";
+    case "recipe":
+      return "the one recipe Ptitchef answered this wording with, by opening its page";
+    default:
+      return null;
+  }
+}
+function ptitchefAdapter(reader) {
+  return {
+    ...PTITCHEF_PROFILE,
+    claims(raw) {
+      if (SITE_URL4.test(raw)) {
+        const path2 = asReference2(new URL(raw).pathname);
+        return path2 === null ? null : { reference: path2, why: "the address is a Ptitchef recipe page", guess: false };
+      }
+      const path = asReference2(raw);
+      return path === null ? null : {
+        reference: path,
+        why: "the path is the shape Ptitchef mints for a recipe",
+        guess: false
+      };
+    },
+    async search(query) {
+      const outcome = await reader.searchRecipes(query);
+      const listing = outcome.data ?? {};
+      const list = rowsOf(listing.results, PTITCHEF_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(PTITCHEF_PROFILE.id, id),
+          source: PTITCHEF_PROFILE.id,
+          sourceName: PTITCHEF_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          excerpt: text(summary?.ingredients_preview)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        reportedTotal: count(listing.total_available),
+        reportedTotalMeans: meansFor2(listing),
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: ptitchefDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function ptitchefDetail(payload) {
+  const recipe = payload ?? {};
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const value = count(recipe.rating);
+  const steps = Array.isArray(recipe.steps) ? recipe.steps : [];
+  const lines = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  return {
+    ...detailBase(PTITCHEF_PROFILE),
+    id: namespacedId(PTITCHEF_PROFILE.id, required(recipe.id, "id", PTITCHEF_PROFILE)),
+    title: required(recipe.title, "title", PTITCHEF_PROFILE),
+    url: required(recipe.url, "url", PTITCHEF_PROFILE),
+    imageUrl: text(recipe.image_url),
+    yieldCount: count(recipe.yield_count) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: text(recipe.yield_unit) ?? span.unit,
+    ingredients: lines.filter((line) => typeof line === "string"),
+    // A step carries a picture of itself, which is not part of the method.
+    steps: steps.map((step) => text(step?.text)).filter((step) => step !== null),
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site publishes no resting time of its own.
+    restMinutes: null,
+    stepsAsOneBlock: typeof recipe.steps_are_one_block === "boolean" ? recipe.steps_are_one_block : null,
+    withheld: null,
+    category: text(recipe.category),
+    author: text(recipe.author),
+    // The site prints two counts beside a rating, one of readers who rated and
+    // one of readers who wrote. Only the first is what a rating rests on, and
+    // adding them would count twice anyone who did both.
+    rating: value === null ? null : { value, count: count(recipe.rating_count), max: 5 },
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
+// src/sources/supertoinette.ts
+var SUPERTOINETTE_PROFILE = {
+  id: "supertoinette",
+  name: "Supertoinette",
+  homeUrl: "https://www.supertoinette.com",
+  language: "fr",
+  attribution: "Source: Supertoinette",
+  // The reader sets aside any row that opens onto something other than a
+  // recipe, so what arrives here is recipes.
+  mixesReferencePages: false
+};
+var SITE_RECIPE_URL = /^https?:\/\/(?:www\.)?supertoinette\.com\/recette\/([1-9][0-9]{0,9})\//i;
+var REFERENCE4 = /^[1-9][0-9]{0,9}$/;
+function supertoinetteAdapter(reader) {
+  return {
+    ...SUPERTOINETTE_PROFILE,
+    claims(raw) {
+      const address = SITE_RECIPE_URL.exec(raw);
+      if (address?.[1]) {
+        return {
+          reference: address[1],
+          why: "the address is a Supertoinette recipe page",
+          guess: false
+        };
+      }
+      if (REFERENCE4.test(raw)) {
+        return {
+          reference: raw,
+          why: "a bare number is the shape Supertoinette mints",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query) {
+      const outcome = await reader.searchRecipes({ query, page: 1, category: null });
+      const listing = outcome.data?.listing ?? {};
+      const list = rowsOf(listing.results, SUPERTOINETTE_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(SUPERTOINETTE_PROFILE.id, id),
+          source: SUPERTOINETTE_PROFILE.id,
+          sourceName: SUPERTOINETTE_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          excerpt: text(summary?.description)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // The site prints no total anywhere on a search page. The rows of one
+        // page are not put here in its place: the site pages, so they would
+        // understate what it holds rather than count it.
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: supertoinetteDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function supertoinetteDetail(payload) {
+  const recipe = payload ?? {};
+  const rating = recipe.rating;
+  const value = count(rating?.value);
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const lines = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  return {
+    ...detailBase(SUPERTOINETTE_PROFILE),
+    id: namespacedId(SUPERTOINETTE_PROFILE.id, required(recipe.id, "id", SUPERTOINETTE_PROFILE)),
+    title: required(recipe.title, "title", SUPERTOINETTE_PROFILE),
+    url: required(recipe.url, "url", SUPERTOINETTE_PROFILE),
+    imageUrl: text(recipe.images?.[0]),
+    yieldCount: span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit,
+    // The whole line as printed, headings included: a heading dropped would
+    // merge two groups of a recipe that may each call for the same thing.
+    // The ingredient page the site links a line to is not carried, since the
+    // site links the wrong page often enough that pairing recipes by it would
+    // pair the wrong recipes.
+    ingredients: lines.map((line) => text(line?.raw)).filter((line) => line !== null),
+    steps: textList(recipe.steps),
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site prints this on its own, and its own total already holds it.
+    // Adding it to anything here would count it twice.
+    restMinutes: count(recipe.rest_minutes),
+    // The reader hands over the steps it read and says nothing about whether
+    // the page numbered them.
+    stepsAsOneBlock: null,
+    withheld: null,
+    category: text(recipe.category),
+    author: text(recipe.author),
+    // The scale is published, so a value is never read against a guess.
+    rating: value === null ? null : { value, count: count(rating?.count), max: count(rating?.scale) },
+    // This site publishes no nutrition panel at all, so there is nothing here
+    // to repeat. An empty panel would read as a page that printed one and left
+    // every figure out.
+    nutrition: null,
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
 // src/sources/registry.ts
-var SOURCE_IDS = [MARMITON_PROFILE.id, COOKBOOK_PROFILE.id];
-function buildSources(config, readers = {}) {
+var PAGE_READ_BOUNDS = { maxBodyBytes: 8e6, budgetMs: 6e4 };
+function buildSources(config, readers, logger) {
   const shared = {
     userAgent: config.userAgent,
     minIntervalMs: config.minIntervalMs,
@@ -556,9 +986,18 @@ function buildSources(config, readers = {}) {
   };
   const marmitonOptions = { config: shared };
   const cookbookOptions = { config: shared };
+  const ptitchefOptions = {
+    config: { ...shared, ...PAGE_READ_BOUNDS },
+    logger
+  };
+  const goodfoodOptions = { config: shared, logger };
+  const supertoinetteOptions = { config: shared, logger };
   return [
     marmitonAdapter(readers.marmiton ?? new MarmitonClient(marmitonOptions)),
-    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions))
+    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions)),
+    ptitchefAdapter(readers.ptitchef ?? new PtitchefClient(ptitchefOptions)),
+    goodfoodAdapter(readers.goodfood ?? new GoodFoodClient(goodfoodOptions)),
+    supertoinetteAdapter(readers.supertoinette ?? new SupertoinetteClient(supertoinetteOptions))
   ];
 }
 function selectSources(sources, wanted) {
@@ -1175,7 +1614,7 @@ var RecipesClient = class {
   constructor(options = {}) {
     this.config = withGuarantees({ ...loadConfig(), ...options.config });
     this.logger = options.logger ?? createLogger(this.config.logLevel);
-    this.sources = options.sources ?? buildSources(this.config, options.readers ?? {});
+    this.sources = options.sources ?? buildSources(this.config, options.readers ?? {}, this.logger);
   }
   /** What every source sees this client call itself. */
   get userAgent() {