@cyanheads/openfoodfacts-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,290 @@
+<div align="center">
+  <h1>@cyanheads/openfoodfacts-mcp-server</h1>
+  <p><b>Look up food products by barcode, search by ingredient or nutrition filter, compare products side-by-side, and browse the canonical tag vocabulary via MCP. STDIO or Streamable HTTP.</b>
+  <div>4 Tools</div>
+  </p>
+</div>
+
+<div align="center">
+
+[![Version](https://img.shields.io/badge/Version-0.1.0-blue.svg?style=flat-square)](./CHANGELOG.md) [![License](https://img.shields.io/badge/License-Apache%202.0-orange.svg?style=flat-square)](./LICENSE) [![Docker](https://img.shields.io/badge/Docker-ghcr.io-2496ED?style=flat-square&logo=docker&logoColor=white)](https://github.com/users/cyanheads/packages/container/package/openfoodfacts-mcp-server) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-^1.29.0-green.svg?style=flat-square)](https://modelcontextprotocol.io/) [![npm](https://img.shields.io/npm/v/@cyanheads/openfoodfacts-mcp-server?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/@cyanheads/openfoodfacts-mcp-server) [![TypeScript](https://img.shields.io/badge/TypeScript-^5.9.3-3178C6.svg?style=flat-square)](https://www.typescriptlang.org/) [![Bun](https://img.shields.io/badge/Bun-v1.3.0-blueviolet.svg?style=flat-square)](https://bun.sh/)
+
+</div>
+
+<div align="center">
+
+[![Install in Claude Desktop](https://img.shields.io/badge/Install_in-Claude_Desktop-D97757?style=for-the-badge&logo=anthropic&logoColor=white)](https://github.com/cyanheads/openfoodfacts-mcp-server/releases/latest/download/openfoodfacts-mcp-server.mcpb) [![Install in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=openfoodfacts-mcp-server&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBjeWFuaGVhZHMvb3BlbmZvb2RmYWN0cy1tY3Atc2VydmVyIl19) [![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=for-the-badge&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect?url=vscode:mcp/install?%7B%22name%22%3A%22openfoodfacts-mcp-server%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40cyanheads%2Fopenfoodfacts-mcp-server%22%5D%7D)
+
+[![Framework](https://img.shields.io/badge/Built%20on-@cyanheads/mcp--ts--core-67E8F9?style=flat-square)](https://www.npmjs.com/package/@cyanheads/mcp-ts-core)
+
+</div>
+
+---
+
+## Tools
+
+Four tools for working with [Open Food Facts](https://world.openfoodfacts.org/) — a free, crowd-sourced database of 3M+ packaged food products:
+
+| Tool | Description |
+|:-----|:------------|
+| `off_get_product` | Fetch a packaged food product by barcode. Returns name, brand, quantity, ingredients, allergens, additives, Nutri-Score, NOVA group, Green-Score, nutrition per 100g/serving, categories, labels, and data completeness. |
+| `off_search_products` | Search by text query and/or structured tag filters (category, brand, label, Nutri-Score grade, NOVA group, country). Returns summary rows with barcodes for follow-up lookups. |
+| `off_compare_products` | Side-by-side nutrition and scoring comparison for 2–10 products by barcode. Returns a normalized table of energy, macros, salt, Nutri-Score, NOVA, and Green-Score. |
+| `off_browse_taxonomy` | Browse and search the canonical tag vocabulary (categories, labels, allergens, additives, countries, NOVA groups, Nutri-Score grades) for use as filter values in `off_search_products`. |
+
+### `off_get_product`
+
+Fetch a packaged food product by barcode (EAN-13 or UPC).
+
+- Accepts 8–14 digit barcodes (EAN-13, EAN-8, UPC-A, UPC-E)
+- Returns ingredients (raw text and parsed list with percent estimates, vegan/vegetarian flags), all 14 major allergens as tag IDs, E-number additives, Nutri-Score a–e, NOVA 1–4, Green-Score/Eco-Score, full nutriments per 100g and per serving, categories/labels/packaging/origins as canonical tag IDs, front image URL, and data completeness score (0–1)
+- Optional `fields` parameter restricts the response to a subset (e.g., scores only, or nutrition only)
+- Open Food Facts is crowd-sourced — a missing field means "not yet entered by contributors," not that the attribute is absent from the actual product
+- `found: false` means no contributor has recorded this barcode yet — not a product defect
+
+---
+
+### `off_search_products`
+
+Search Open Food Facts by text and/or structured tag filters.
+
+- Full-text search across product names, brands, and ingredients
+- Structured filters: `categories_tag`, `brands_tag`, `labels_tag`, `nutrition_grade` (a–e), `nova_group` (1–4), `countries_tag`
+- All filter values are canonical tag IDs — use `off_browse_taxonomy` to resolve human terms (e.g., "organic" → `en:organic`)
+- Pagination via `page` (1-based) and `page_size` (1–50, default 20); response includes `total` count for computing total pages
+- Returns summary rows (barcode, name, brand, Nutri-Score, NOVA, categories) — use `off_get_product` for full label data
+- Result counts reflect contributed products, not total products on the market
+- Search rate-limited to ~10 requests/min by the Open Food Facts API
+
+---
+
+### `off_compare_products`
+
+Side-by-side nutrition and scoring comparison for 2–10 barcodes.
+
+- Fetches all products in parallel
+- Returns a normalized comparison table: energy (kcal/100g), fat, saturated fat, sugars, salt, protein, fiber, Nutri-Score, NOVA group, and Green-Score
+- Missing nutrition data is preserved as `null` — comparisons are not imputed or estimated
+- `not_found` list identifies barcodes with no contributor record (partial results are not an error)
+- For batches of 5+ products, the comparison table is registered as a canvas dataframe for downstream SQL queries (`secedgar_dataframe_query`-style analytics)
+
+---
+
+### `off_browse_taxonomy`
+
+Browse the canonical Open Food Facts tag vocabulary before building `off_search_products` filters.
+
+- Facets: `categories`, `labels`, `allergens`, `additives`, `countries`, `nova_groups`, `nutrition_grades`
+- Optional `search` parameter: case-insensitive substring match against tag ID or display name (e.g., `"gluten"` → `en:gluten`, `en:no-gluten`, `en:no-added-gluten`)
+- Taxonomy is embedded (not fetched live) because the OFF taxonomy API is unavailable to anonymous bot clients at current traffic levels
+- Categories facet has 200K+ entries — always include a `search` term when browsing categories
+- `limit` controls results returned (1–100, default 20)
+
+---
+
+## Features
+
+Built on [`@cyanheads/mcp-ts-core`](https://www.npmjs.com/package/@cyanheads/mcp-ts-core):
+
+- Declarative tool definitions — single file per tool, framework handles registration and validation
+- Unified error handling — handlers throw, framework catches, classifies, and formats
+- Pluggable auth: `none`, `jwt`, `oauth`
+- Swappable storage backends: `in-memory`, `filesystem`, `Supabase`, `Cloudflare KV/R2/D1`
+- Structured logging with optional OpenTelemetry tracing
+- STDIO and Streamable HTTP transports
+
+Open Food Facts-specific:
+
+- No API key required — the identifying `User-Agent` header (required by OFF terms) is baked into the service layer
+- Token-bucket rate limiting per endpoint class: product reads (~100/min), search (~10/min)
+- Automatic retry (3 attempts, 500ms base) with HTML error page detection for 503 during high load
+- Nutriments normalized from raw hyphenated keys (`energy-kcal_100g`) to underscore form — only the `_100g` and `_serving` variants are returned
+- Embedded tag taxonomy for `off_browse_taxonomy` — curated 200+ category subset, full allergen/label/additive vocabularies
+
+Agent-friendly output:
+
+- `found` field on every product response — explicit `false` when a barcode has no contributor record, not a thrown error
+- Missing fields signal incomplete crowd-sourced data, not product attribute absence — surfaced in descriptions and format output
+- Computed scores (Nutri-Score, NOVA, Green-Score) returned as-is with regional caveat notes — not interpreted or normalized to health claims
+- `not_found` list in `off_compare_products` allows partial batch comparisons without request failure
+
+## Getting started
+
+No API key is required. Add the following to your MCP client configuration file.
+
+```json
+{
+  "mcpServers": {
+    "openfoodfacts": {
+      "type": "stdio",
+      "command": "bunx",
+      "args": ["@cyanheads/openfoodfacts-mcp-server@latest"],
+      "env": {
+        "MCP_TRANSPORT_TYPE": "stdio",
+        "MCP_LOG_LEVEL": "info"
+      }
+    }
+  }
+}
+```
+
+Or with npx (no Bun required):
+
+```json
+{
+  "mcpServers": {
+    "openfoodfacts": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@cyanheads/openfoodfacts-mcp-server@latest"],
+      "env": {
+        "MCP_TRANSPORT_TYPE": "stdio",
+        "MCP_LOG_LEVEL": "info"
+      }
+    }
+  }
+}
+```
+
+Or with Docker:
+
+```json
+{
+  "mcpServers": {
+    "openfoodfacts": {
+      "type": "stdio",
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm",
+        "-e", "MCP_TRANSPORT_TYPE=stdio",
+        "ghcr.io/cyanheads/openfoodfacts-mcp-server:latest"
+      ]
+    }
+  }
+}
+```
+
+For Streamable HTTP, set the transport and start the server:
+
+```sh
+MCP_TRANSPORT_TYPE=http MCP_HTTP_PORT=3010 bun run start:http
+# Server listens at http://localhost:3010/mcp
+```
+
+### Prerequisites
+
+- [Bun v1.3.0](https://bun.sh/) or higher (or Node.js v24+).
+- No API key needed. The server sends an identifying `User-Agent` to comply with Open Food Facts' terms of service — this is baked in and requires no configuration.
+
+### Installation
+
+1. **Clone the repository:**
+
+```sh
+git clone https://github.com/cyanheads/openfoodfacts-mcp-server.git
+```
+
+2. **Navigate into the directory:**
+
+```sh
+cd openfoodfacts-mcp-server
+```
+
+3. **Install dependencies:**
+
+```sh
+bun install
+```
+
+4. **Configure environment:**
+
+```sh
+cp .env.example .env
+# edit .env if you need to override rate limits or the base URL
+```
+
+## Configuration
+
+All configuration is validated at startup via Zod schemas in `src/config/server-config.ts`.
+
+| Variable | Description | Default |
+|:---------|:------------|:--------|
+| `OFF_BASE_URL` | Open Food Facts API base URL. Override for local testing against a mock server. | `https://world.openfoodfacts.org` |
+| `OFF_RATE_LIMIT_PRODUCT` | Product read rate limit (requests/min). | `100` |
+| `OFF_RATE_LIMIT_SEARCH` | Search rate limit (requests/min). | `10` |
+| `MCP_TRANSPORT_TYPE` | Transport: `stdio` or `http`. | `stdio` |
+| `MCP_HTTP_PORT` | HTTP server port. | `3010` |
+| `MCP_AUTH_MODE` | Auth mode: `none`, `jwt`, or `oauth`. | `none` |
+| `MCP_LOG_LEVEL` | Log level (`debug`, `info`, `warning`, `error`). | `info` |
+| `LOGS_DIR` | Log file directory (Node.js only). | `<project-root>/logs` |
+| `OTEL_ENABLED` | Enable [OpenTelemetry instrumentation](https://github.com/cyanheads/mcp-ts-core/tree/main/docs/telemetry). | `false` |
+
+See [`.env.example`](./.env.example) for the full list of optional overrides.
+
+> **Attribution:** Open Food Facts data is released under the [Open Database License (ODbL) 1.0](https://opendatacommons.org/licenses/odbl/1.0/). Downstream use must cite [Open Food Facts](https://world.openfoodfacts.org/).
+
+## Running the server
+
+### Local development
+
+- **Build and run:**
+
+  ```sh
+  # One-time build
+  bun run rebuild
+
+  # Run the built server
+  bun run start:stdio
+  # or
+  bun run start:http
+  ```
+
+- **Run checks and tests:**
+
+  ```sh
+  bun run devcheck   # Lint, format, typecheck, security
+  bun run test       # Vitest test suite
+  bun run lint:mcp   # Validate MCP definitions against spec
+  ```
+
+### Docker
+
+```sh
+docker build -t openfoodfacts-mcp-server .
+docker run --rm -p 3010:3010 openfoodfacts-mcp-server
+```
+
+The Dockerfile defaults to HTTP transport, stateless session mode, and logs to `/var/log/openfoodfacts-mcp-server`. OpenTelemetry peer dependencies are installed by default — build with `--build-arg OTEL_ENABLED=false` to omit them.
+
+## Project structure
+
+| Directory | Purpose |
+|:----------|:--------|
+| `src/index.ts` | `createApp()` entry point — registers tools and inits services. |
+| `src/config` | Server-specific environment variable parsing and validation with Zod. |
+| `src/mcp-server/tools` | Tool definitions (`*.tool.ts`). |
+| `src/services/openfoodfacts` | Open Food Facts API client — HTTP, rate limiting, retry, field normalization. |
+| `src/services/taxonomy` | Embedded tag vocabulary service for `off_browse_taxonomy`. |
+| `tests/` | Unit and integration tests mirroring `src/`. |
+
+## Development guide
+
+See [`CLAUDE.md`](./CLAUDE.md) for development guidelines and architectural rules. The short version:
+
+- Handlers throw, framework catches — no `try/catch` in tool logic
+- Use `ctx.log` for request-scoped logging, `ctx.state` for tenant-scoped storage
+- Register new tools via the barrel in `src/mcp-server/tools/definitions/index.ts`
+- Wrap external API calls: validate raw → normalize to domain type → return output schema; never fabricate missing fields
+
+## Contributing
+
+Issues and pull requests are welcome. Run checks and tests before submitting:
+
+```sh
+bun run devcheck
+bun run test
+```
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE) for details.

package/changelog/0.1.x/0.1.0.md

@@ -0,0 +1,15 @@
+---
+summary: "Initial release — 4 tools for barcode lookup, product search, side-by-side comparison, and taxonomy browsing across the Open Food Facts database (3M+ products, keyless, ODbL 1.0)."
+breaking: false
+---
+
+# 0.1.0 — 2026-05-30
+
+## Added
+
+- **`off_get_product`** — fetch a product by EAN-13 or UPC barcode; returns name, brand, quantity, ingredients (raw text + parsed list with vegan/vegetarian flags), allergen and additive tags, Nutri-Score (a–e), NOVA group (1–4), Green-Score, normalized nutrition per 100g and per serving, category/label/packaging/origins tags, image URL, and data-completeness score. Inline sparsity caveats clarify crowd-sourced absence vs. attribute absence. Optional `fields` parameter scopes the API request to a subset of fields.
+- **`off_search_products`** — search by free-text query or structured tag filters (category, brand, label, Nutri-Score grade, NOVA group, country). Text and filter paths are mutually exclusive (documented in description). Returns paginated summary rows (barcode, name, brand, scores, categories) for triage; full detail via `off_get_product`. Empty-result enrichment notice guides query broadening.
+- **`off_compare_products`** — parallel side-by-side comparison of 2–10 products by barcode; returns a normalized table of energy, fat, saturated fat, sugars, salt, protein, fiber, Nutri-Score, NOVA, and Green-Score. Missing values preserved as absent; low-completeness products flagged in `format()` output.
+- **`off_browse_taxonomy`** — search the embedded canonical tag vocabulary across 7 facets (categories, labels, allergens, additives, countries, nova_groups, nutrition_grades). Returns `id` + display name + approximate product count. Taxonomy is embedded because the OFF taxonomy API is unavailable to anonymous bot clients.
+- **Open Food Facts v2 HTTP client** — keyless access via identifying User-Agent (`openfoodfacts-mcp-server/0.1.0`); per-endpoint rate limiting (100 req/min for product reads, 10 req/min for search); retry with exponential back-off on 5xx; field-scoped requests to minimize payload size.
+- **ODbL 1.0 attribution** embedded in every `format()` output surface and tool descriptions.

package/changelog/template.md

@@ -0,0 +1,127 @@
+---
+# FORMAT REFERENCE — do not edit. Copy this file to
+# `changelog/<major.minor>.x/<version>.md` (e.g. `changelog/0.8.x/0.8.6.md`)
+# to author a new release. Set that file's H1 to `# <version> — YYYY-MM-DD`
+# with a concrete date.
+
+# Required. One-line GitHub Release-style headline. 350 character cap.
+# Default short and scannable. Don't pad, don't stitch unrelated changes with
+# semicolons — pick the headline. Quotes required: unquoted YAML treats `: `
+# inside the value as a key separator and fails GitHub's strict parser.
+summary: ""
+
+# Set `true` when consumers must change code to upgrade: API removals,
+# signature changes, config renames, behavior changes that break existing
+# usage. Flagged as `Breaking` in the rollup.
+breaking: false
+
+# Set `true` if this release contains any security fix. Pairs with the
+# `## Security` section below. Flagged as `Security` in the rollup so
+# users can triage upgrade urgency at a glance.
+security: false
+
+# Optional free-form notes for maintenance agents processing this release.
+# Not rendered in CHANGELOG — consumed by agents running `maintenance` on
+# downstream servers. Use for adoption instructions that don't fit the
+# human-facing sections: new files to create, fields to populate, one-time
+# migration steps. Omit the field entirely when there's nothing to say.
+# agent-notes: |
+#   <instructions for downstream maintenance agents>
+---
+
+# <version> — YYYY-MM-DD
+
+<!--
+  AUTHORING GUIDE — applies to the new per-version file you create from this
+  template.
+
+  Audience: someone scanning release notes to decide what affects them. Lead
+  each bullet with the symbol or concept name in **bold** so they can skip
+  what's irrelevant and zoom in on what's not.
+
+  Tone: terse, fact-dense, not verbose. Default to one sentence per bullet —
+  name the symbol, state what changed, stop. Use a second sentence only when
+  it carries weight. If a bullet feels long, it is.
+
+  Cut: mechanism walkthroughs (those belong in JSDoc, CLAUDE.md/AGENTS.md, or the
+  relevant skill), ceremonial framings ("This release introduces…",
+  backwards-compat paragraphs), file-by-file test enumerations, internal
+  implementation notes. Prefer code/symbol names over English re-explanations.
+
+  Narrative intro: skip by default. Add one short sentence only when the
+  release theme genuinely needs framing the bullets can't carry.
+
+  Sections: Keep a Changelog order — Added, Changed, Deprecated, Removed,
+  Fixed, Security. Include only sections with entries; delete the rest
+  (including the commented-out scaffolding below). Don't ship empty headers.
+
+  Include: every distinct fact a reader needs to adopt or audit the release —
+  new exports, signatures, lint rule IDs, env vars, breaking changes, version
+  bumps on shipped skills. Nothing more.
+
+  Links: link issues, PRs, docs, or skills where they help a reader jump to
+  context. Once per item per entry — don't re-link the same issue in summary,
+  narrative, and bullet. Skip links for inline symbol names; code spans speak
+  for themselves.
+
+  Issue/PR URLs: use full URLs. GitHub's bare `#NN` auto-link only resolves
+  inside its own UI, not in npm reads or local editors.
+
+      [#38](https://github.com/cyanheads/mcp-ts-core/issues/38)   ← issue
+      [#42](https://github.com/cyanheads/mcp-ts-core/pull/42)     ← PR
+
+  Verify numbers exist before linking (`gh issue view NN`, `gh pr view NN`).
+  Never speculate on a future number — `#42` for an upcoming PR silently
+  resolves to whatever real item already owns 42, and timeline previews pull
+  in that unrelated item's metadata.
+
+  TAG ANNOTATIONS — the annotated tag body renders as the GitHub Release body
+  via `gh release create --notes-from-tag`. The tag is a derivative of this
+  changelog entry — a condensed, scannable version, not a copy. Format:
+
+    <theme — omit version number, GitHub prepends it>
+                                                          ← blank line
+    <1-2 sentence context: what this release does>
+                                                          ← blank line
+    Dependency bumps:                                     ← section header
+                                                          ← blank line
+    - `@cyanheads/mcp-ts-core` ^0.9.1 → ^0.9.6          ← bullet
+                                                          ← blank line
+    Changed:                                              ← only sections with entries
+                                                          ← blank line
+    - `format()` output includes `query` in text mode
+                                                          ← blank line
+    Added:
+                                                          ← blank line
+    - `manifest.json` scaffolded for MCPB bundle support
+    - Install badges (Claude Desktop, Cursor, VS Code)
+                                                          ← blank line
+    <N> tests pass; `bun run devcheck` clean.             ← footer
+
+  Never a flat comma-separated string. Always structured markdown with
+  sections. The tag must scan well as a rendered GitHub Release page.
+-->
+
+## Added
+
+-
+
+## Changed
+
+-
+
+<!-- ## Deprecated
+
+- -->
+
+<!-- ## Removed
+
+- -->
+
+## Fixed
+
+-
+
+<!-- ## Security
+
+- -->

package/dist/config/server-config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Server-specific configuration for the Open Food Facts MCP server.
+ * @module config/server-config
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+declare const ServerConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    rateLimitProduct: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    rateLimitSearch: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ServerConfig = z.infer<typeof ServerConfigSchema>;
+/** Lazy-parsed server config from environment variables. */
+export declare function getServerConfig(): ServerConfig;
+export {};
+//# sourceMappingURL=server-config.d.ts.map

package/dist/config/server-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../src/config/server-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,QAAA,MAAM,kBAAkB;;;;iBAiBtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D,4DAA4D;AAC5D,wBAAgB,eAAe,IAAI,YAAY,CAO9C"}

package/dist/config/server-config.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Server-specific configuration for the Open Food Facts MCP server.
+ * @module config/server-config
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+import { parseEnvConfig } from '@cyanheads/mcp-ts-core/config';
+const ServerConfigSchema = z.object({
+    baseUrl: z
+        .string()
+        .default('https://world.openfoodfacts.org')
+        .describe('Open Food Facts API base URL'),
+    rateLimitProduct: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .default(100)
+        .describe('Product read rate limit (requests/min)'),
+    rateLimitSearch: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .default(10)
+        .describe('Search rate limit (requests/min)'),
+});
+let _config;
+/** Lazy-parsed server config from environment variables. */
+export function getServerConfig() {
+    _config ??= parseEnvConfig(ServerConfigSchema, {
+        baseUrl: 'OFF_BASE_URL',
+        rateLimitProduct: 'OFF_RATE_LIMIT_PRODUCT',
+        rateLimitSearch: 'OFF_RATE_LIMIT_SEARCH',
+    });
+    return _config;
+}
+//# sourceMappingURL=server-config.js.map

package/dist/config/server-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.js","sourceRoot":"","sources":["../../src/config/server-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,OAAO,CAAC,iCAAiC,CAAC;SAC1C,QAAQ,CAAC,8BAA8B,CAAC;IAC3C,gBAAgB,EAAE,CAAC,CAAC,MAAM;SACvB,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,OAAO,CAAC,GAAG,CAAC;SACZ,QAAQ,CAAC,wCAAwC,CAAC;IACrD,eAAe,EAAE,CAAC,CAAC,MAAM;SACtB,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,kCAAkC,CAAC;CAChD,CAAC,CAAC;AAIH,IAAI,OAAiC,CAAC;AAEtC,4DAA4D;AAC5D,MAAM,UAAU,eAAe;IAC7B,OAAO,KAAK,cAAc,CAAC,kBAAkB,EAAE;QAC7C,OAAO,EAAE,cAAc;QACvB,gBAAgB,EAAE,wBAAwB;QAC1C,eAAe,EAAE,uBAAuB;KACzC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview openfoodfacts-mcp-server MCP server entry point.
+ * @module index
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview openfoodfacts-mcp-server MCP server entry point.
+ * @module index
+ */
+import { createApp } from '@cyanheads/mcp-ts-core';
+import { allToolDefinitions } from './mcp-server/tools/definitions/index.js';
+import { initOpenFoodFactsService } from './services/openfoodfacts/openfoodfacts-service.js';
+import { initTaxonomyService } from './services/taxonomy/taxonomy-service.js';
+await createApp({
+    tools: allToolDefinitions,
+    instructions: 'Use the off_* tools to query Open Food Facts — a free, crowd-sourced global food product database covering 3M+ products. ' +
+        'Primary workflow: off_get_product for barcode lookup (EAN-13/UPC), off_search_products to find products by text or tags, ' +
+        'off_compare_products for side-by-side nutrition comparison, off_browse_taxonomy to resolve human terms to canonical tag IDs. ' +
+        'Data is crowd-sourced — missing fields mean "not yet entered," not that the attribute is absent. ' +
+        'Computed scores (Nutri-Score, NOVA, Green-Score) carry regional caveats. ' +
+        'No API key required. Data under ODbL 1.0 — cite Open Food Facts in downstream use.',
+    setup() {
+        initOpenFoodFactsService();
+        initTaxonomyService();
+    },
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mDAAmD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAE9E,MAAM,SAAS,CAAC;IACd,KAAK,EAAE,kBAAkB;IACzB,YAAY,EACV,2HAA2H;QAC3H,2HAA2H;QAC3H,+HAA+H;QAC/H,mGAAmG;QACnG,2EAA2E;QAC3E,oFAAoF;IACtF,KAAK;QACH,wBAAwB,EAAE,CAAC;QAC3B,mBAAmB,EAAE,CAAC;IACxB,CAAC;CACF,CAAC,CAAC"}

package/dist/mcp-server/tools/definitions/browse-taxonomy.tool.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Tool definition for browsing Open Food Facts canonical tag vocabularies.
+ * @module mcp-server/tools/definitions/browse-taxonomy
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+export declare const offBrowseTaxonomyTool: import("@cyanheads/mcp-ts-core").ToolDefinition<z.ZodObject<{
+    facet: z.ZodEnum<{
+        categories: "categories";
+        labels: "labels";
+        allergens: "allergens";
+        additives: "additives";
+        countries: "countries";
+        nova_groups: "nova_groups";
+        nutrition_grades: "nutrition_grades";
+    }>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    facet: z.ZodString;
+    tags: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        products: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    total_in_facet: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, undefined, undefined>;
+//# sourceMappingURL=browse-taxonomy.tool.d.ts.map

package/dist/mcp-server/tools/definitions/browse-taxonomy.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browse-taxonomy.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/browse-taxonomy.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAGjD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;wCAiHhC,CAAC"}

package/dist/mcp-server/tools/definitions/browse-taxonomy.tool.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Tool definition for browsing Open Food Facts canonical tag vocabularies.
+ * @module mcp-server/tools/definitions/browse-taxonomy
+ */
+import { tool, z } from '@cyanheads/mcp-ts-core';
+import { getTaxonomyService } from '../../../services/taxonomy/taxonomy-service.js';
+export const offBrowseTaxonomyTool = tool('off_browse_taxonomy', {
+    title: 'Browse Food Facts Taxonomy',
+    description: 'Browse and search the canonical tag vocabulary for Open Food Facts filter facets. Returns tag IDs and display names for use as filter values in off_search_products. Covers categories, labels/certifications, allergens, additives, countries, NOVA groups, and Nutri-Score grades. The taxonomy is embedded — not fetched live — because the OFF taxonomy API is unavailable to anonymous bot clients. Tag IDs use the "en:" prefix convention (e.g. "en:organic", "en:gluten-free", "en:milk"). Always use these tag IDs as filter values, not plain English terms.',
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    input: z.object({
+        facet: z
+            .enum([
+            'categories',
+            'labels',
+            'allergens',
+            'additives',
+            'countries',
+            'nova_groups',
+            'nutrition_grades',
+        ])
+            .describe('"categories" covers food categories (en:cheeses, en:breakfast-cereals). "labels" covers certifications (en:organic, en:fair-trade). "allergens" covers declared allergens (en:milk, en:gluten). "additives" covers E-numbers (en:e322). "countries" covers country-of-sale tags (en:france). "nova_groups" and "nutrition_grades" return the complete fixed vocabularies.'),
+        search: z
+            .string()
+            .optional()
+            .describe('Case-insensitive substring filter against tag ID or display name. Example: "gluten" returns en:gluten, en:no-gluten. Omit to list all entries for the facet (may be large for categories).'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(20)
+            .describe('Maximum entries to return (1–100, default 20). Categories has many entries — always provide a search term when browsing categories.'),
+    }),
+    output: z.object({
+        facet: z.string().describe('The facet name that was queried (echoes the input).'),
+        tags: z
+            .array(z
+            .object({
+            id: z
+                .string()
+                .describe('Canonical tag ID (e.g. "en:organic"). Use this value in off_search_products filter parameters.'),
+            name: z.string().describe('Human-readable display name (e.g. "Organic").'),
+            products: z
+                .number()
+                .optional()
+                .describe('Approximate count of products with this tag. Not available for all facets.'),
+        })
+            .describe('A single taxonomy tag entry with its canonical ID and display name.'))
+            .describe('Matching tag entries.'),
+        total_in_facet: z
+            .number()
+            .optional()
+            .describe('Total entries in this facet before search filtering. Large for categories.'),
+    }),
+    handler(input, ctx) {
+        const svc = getTaxonomyService();
+        const result = svc.search(input.facet, input.search && input.search.trim().length > 0 ? input.search.trim() : undefined, input.limit);
+        ctx.log.info('Taxonomy browsed', {
+            facet: input.facet,
+            search: input.search,
+            returned: result.tags.length,
+            total: result.total_in_facet,
+        });
+        return {
+            facet: result.facet,
+            tags: result.tags,
+            total_in_facet: result.total_in_facet,
+        };
+    },
+    format: (result) => {
+        const lines = [
+            `## ${result.facet} (${result.tags.length} entries${result.total_in_facet !== undefined ? ` of ${result.total_in_facet} total` : ''})\n`,
+        ];
+        if (result.tags.length === 0) {
+            lines.push('No matching tags found. Try a different search term.');
+            return [{ type: 'text', text: lines.join('\n') }];
+        }
+        for (const tag of result.tags) {
+            const products = tag.products !== undefined ? ` (~${tag.products.toLocaleString()} products)` : '';
+            lines.push(`- \`${tag.id}\` — ${tag.name}${products}`);
+        }
+        lines.push('\n*Use the `id` values (e.g. "en:organic") as filter parameters in off_search_products.*');
+        return [{ type: 'text', text: lines.join('\n') }];
+    },
+});
+//# sourceMappingURL=browse-taxonomy.tool.js.map