open-primitive-mcp 1.0.0

package/sources/flights.js

@@ -0,0 +1,125 @@
+const fetch = require('node-fetch');
+
+const AIRLINES = [
+  { name: 'Delta', iata: 'DL', hubs: ['ATL', 'MSP', 'DTW', 'SLC'] },
+  { name: 'United', iata: 'UA', hubs: ['ORD', 'EWR', 'IAH', 'DEN', 'SFO'] },
+  { name: 'American', iata: 'AA', hubs: ['DFW', 'CLT', 'MIA', 'PHX', 'ORD'] },
+  { name: 'Southwest', iata: 'WN', hubs: ['DAL', 'MDW', 'BWI', 'LAS', 'DEN'] },
+  { name: 'Alaska', iata: 'AS', hubs: ['SEA', 'PDX', 'SFO'] },
+  { name: 'JetBlue', iata: 'B6', hubs: ['JFK', 'BOS', 'FLL'] },
+  { name: 'Allegiant', iata: 'G4', hubs: ['LAS', 'SFB', 'PIE'] },
+  { name: 'Frontier', iata: 'F9', hubs: ['DEN', 'LAS', 'MCO'] },
+];
+
+const HUB_COORDS = {
+  ATL: [33.64, -84.43], MSP: [44.88, -93.22], DTW: [42.21, -83.35], SLC: [40.79, -111.98],
+  ORD: [41.97, -87.91], EWR: [40.69, -74.17], IAH: [29.98, -95.34], DEN: [39.86, -104.67],
+  SFO: [37.62, -122.38], DFW: [32.90, -97.04], CLT: [35.21, -80.94], MIA: [25.79, -80.29],
+  PHX: [33.43, -112.01], DAL: [32.85, -96.85], MDW: [41.79, -87.75], BWI: [39.18, -76.67],
+  LAS: [36.08, -115.15], SEA: [47.45, -122.31], PDX: [45.59, -122.60],
+  JFK: [40.64, -73.78], BOS: [42.36, -71.01], FLL: [26.07, -80.15],
+  SFB: [28.78, -81.24], PIE: [27.91, -82.69], MCO: [28.43, -81.31],
+};
+
+async function fetchWithTimeout(url, ms = 10000) {
+  const ctrl = new AbortController();
+  const id = setTimeout(() => ctrl.abort(), ms);
+  try {
+    const res = await fetch(url, { signal: ctrl.signal, headers: { 'User-Agent': 'OpenPrimitive/1.0' } });
+    clearTimeout(id);
+    return res;
+  } catch (e) {
+    clearTimeout(id);
+    return null;
+  }
+}
+
+async function getFaaDelays() {
+  const res = await fetchWithTimeout('https://nasstatus.faa.gov/api/airport-status-information', 10000);
+  if (!res) return {};
+  try {
+    const text = await res.text();
+    const delays = {};
+    const airportPattern = /IATA>(\w{3})<.*?Reason>(.*?)<.*?avgDelay>(.*?)</gs;
+    let match;
+    while ((match = airportPattern.exec(text)) !== null) {
+      delays[match[1]] = { reason: match[2], delay: match[3] };
+    }
+    return delays;
+  } catch { return {}; }
+}
+
+async function getWeather(hub) {
+  const coords = HUB_COORDS[hub];
+  if (!coords) return null;
+  const url = `https://api.open-meteo.com/v1/forecast?latitude=${coords[0]}&longitude=${coords[1]}&daily=weather_code,precipitation_sum&timezone=America/New_York&forecast_days=4`;
+  const res = await fetchWithTimeout(url, 8000);
+  if (!res) return null;
+  try {
+    const data = await res.json();
+    return {
+      hub,
+      daily: data.daily ? data.daily.weather_code.map((code, i) => ({
+        day: i + 1,
+        weatherCode: code,
+        precipitation: data.daily.precipitation_sum[i]
+      })) : []
+    };
+  } catch { return null; }
+}
+
+// Exported query functions
+
+async function getAirlines() {
+  const [faaDelays, ...weatherResults] = await Promise.all([
+    getFaaDelays(),
+    ...AIRLINES.map(a => getWeather(a.hubs[0]))
+  ]);
+
+  return {
+    domain: 'flights',
+    source: 'FAA NAS + Open-Meteo',
+    source_url: 'https://nasstatus.faa.gov',
+    freshness: new Date().toISOString(),
+    airlines: AIRLINES.map((airline, i) => {
+      const hubDelays = airline.hubs
+        .filter(h => faaDelays[h])
+        .map(h => ({ airport: h, ...faaDelays[h] }));
+      const weather = weatherResults[i];
+      return {
+        name: airline.name,
+        iata: airline.iata,
+        hubs: airline.hubs,
+        delays: hubDelays,
+        hasDelays: hubDelays.length > 0,
+        weather: weather ? weather.daily : [],
+        primaryHub: airline.hubs[0],
+      };
+    })
+  };
+}
+
+async function getAirline(iata) {
+  const airline = AIRLINES.find(a => a.iata.toUpperCase() === iata.toUpperCase());
+  if (!airline) return null;
+  const [faaDelays, weather] = await Promise.all([
+    getFaaDelays(),
+    getWeather(airline.hubs[0])
+  ]);
+  const hubDelays = airline.hubs
+    .filter(h => faaDelays[h])
+    .map(h => ({ airport: h, ...faaDelays[h] }));
+  return {
+    domain: 'flights',
+    source: 'FAA NAS + Open-Meteo',
+    freshness: new Date().toISOString(),
+    name: airline.name,
+    iata: airline.iata,
+    hubs: airline.hubs,
+    delays: hubDelays,
+    hasDelays: hubDelays.length > 0,
+    weather: weather ? weather.daily : [],
+  };
+}
+
+module.exports = { getAirlines, getAirline, AIRLINES };

package/sources/food.js

@@ -0,0 +1,74 @@
+const fetch = require('node-fetch');
+
+const FDA_BASE = 'https://api.fda.gov/food/enforcement.json';
+
+async function fetchWithTimeout(url, ms = 10000) {
+  const ctrl = new AbortController();
+  const id = setTimeout(() => ctrl.abort(), ms);
+  try {
+    const res = await fetch(url, { signal: ctrl.signal });
+    clearTimeout(id);
+    if (!res.ok && res.status !== 404) return null;
+    if (res.status === 404) return { meta: { results: { total: 0 } }, results: [] };
+    return await res.json();
+  } catch {
+    clearTimeout(id);
+    return null;
+  }
+}
+
+async function getRecent() {
+  const now = new Date();
+  const start = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
+  const fmt = d => d.toISOString().slice(0, 10).replace(/-/g, '');
+  const url = `${FDA_BASE}?search=status:"Ongoing"+AND+report_date:[${fmt(start)}+TO+${fmt(now)}]&sort=report_date:desc&limit=20`;
+  const data = await fetchWithTimeout(url);
+  if (!data) return { error: 'FDA API unavailable' };
+  return {
+    domain: 'food',
+    source: 'FDA Enforcement',
+    source_url: 'https://api.fda.gov',
+    freshness: new Date().toISOString(),
+    total: data.meta ? data.meta.results.total : 0,
+    recalls: (data.results || []).map(r => ({
+      product: r.product_description,
+      firm: r.recalling_firm,
+      classification: r.classification,
+      status: r.status,
+      reason: r.reason_for_recall,
+      distribution: r.distribution_pattern,
+      date: r.recall_initiation_date,
+      quantity: r.product_quantity,
+      recallNumber: r.recall_number,
+    })),
+  };
+}
+
+async function search(query) {
+  if (!query) return { error: 'query is required' };
+  const encoded = encodeURIComponent(query);
+  const url = `${FDA_BASE}?search=product_description:"${encoded}"+OR+recalling_firm:"${encoded}"&sort=report_date:desc&limit=20`;
+  const data = await fetchWithTimeout(url);
+  if (!data) return { error: 'FDA API unavailable' };
+  return {
+    domain: 'food',
+    source: 'FDA Enforcement',
+    source_url: 'https://api.fda.gov',
+    freshness: new Date().toISOString(),
+    query,
+    total: data.meta ? data.meta.results.total : 0,
+    recalls: (data.results || []).map(r => ({
+      product: r.product_description,
+      firm: r.recalling_firm,
+      classification: r.classification,
+      status: r.status,
+      reason: r.reason_for_recall,
+      distribution: r.distribution_pattern,
+      date: r.recall_initiation_date,
+      quantity: r.product_quantity,
+      recallNumber: r.recall_number,
+    })),
+  };
+}
+
+module.exports = { getRecent, search };

package/sources/health.js

@@ -0,0 +1,102 @@
+const fetch = require('node-fetch');
+
+const EUTILS_BASE = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+const USER_AGENT = 'OpenPrimitive/1.0 (contact: davehamiltonj@gmail.com)';
+
+const ODS_SHEETS = {
+  'vitamin d': 'VitaminD', 'vitamin c': 'VitaminC', 'vitamin b12': 'VitaminB12',
+  'vitamin a': 'VitaminA', 'vitamin b6': 'VitaminB6', 'vitamin e': 'VitaminE',
+  'vitamin k': 'VitaminK', 'zinc': 'Zinc', 'iron': 'Iron', 'magnesium': 'Magnesium',
+  'calcium': 'Calcium', 'potassium': 'Potassium', 'selenium': 'Selenium',
+  'iodine': 'Iodine', 'omega-3': 'Omega3FattyAcids', 'fish oil': 'Omega3FattyAcids',
+  'probiotics': 'Probiotics', 'melatonin': 'Melatonin', 'ashwagandha': 'Ashwagandha',
+  'turmeric': 'Turmeric', 'curcumin': 'Turmeric', 'creatine': 'Creatine',
+  'collagen': 'Collagen', 'coq10': 'CoenzymeQ10', 'ginkgo': 'Ginkgo',
+  'ginseng': 'Ginseng', 'echinacea': 'Echinacea', 'garlic': 'Garlic',
+  'glucosamine': 'Glucosamine',
+};
+
+async function fetchWithTimeout(url, ms = 10000) {
+  const ctrl = new AbortController();
+  const id = setTimeout(() => ctrl.abort(), ms);
+  try {
+    const res = await fetch(url, {
+      signal: ctrl.signal,
+      headers: { 'User-Agent': USER_AGENT },
+    });
+    clearTimeout(id);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    clearTimeout(id);
+    return null;
+  }
+}
+
+function getOdsUrl(query) {
+  const q = query.toLowerCase();
+  for (const [key, val] of Object.entries(ODS_SHEETS)) {
+    if (q.includes(key) || key.includes(q)) {
+      return `https://ods.od.nih.gov/factsheets/${val}-HealthProfessional/`;
+    }
+  }
+  return null;
+}
+
+function evidenceLevel(count) {
+  if (count >= 500) return { level: 'strong', label: 'Strong research signal' };
+  if (count >= 50) return { level: 'moderate', label: 'Moderate research signal' };
+  if (count >= 10) return { level: 'limited', label: 'Limited research signal' };
+  if (count >= 1) return { level: 'weak', label: 'Weak research signal' };
+  return { level: 'none', label: 'No studies found' };
+}
+
+async function searchHealth(query) {
+  if (!query) return { error: 'Search query required' };
+
+  const searchUrl = `${EUTILS_BASE}/esearch.fcgi?db=pubmed&retmode=json&retmax=5&sort=pub_date&term=${encodeURIComponent(query)}[Title/Abstract]`;
+  const searchData = await fetchWithTimeout(searchUrl);
+  if (!searchData) return { error: 'PubMed unavailable' };
+
+  const result = searchData.esearchresult;
+  const count = parseInt(result.count || 0);
+  const ids = result.idlist || [];
+
+  let studies = [];
+  if (ids.length > 0) {
+    const summaryUrl = `${EUTILS_BASE}/esummary.fcgi?db=pubmed&retmode=json&id=${ids.join(',')}`;
+    const summaryData = await fetchWithTimeout(summaryUrl);
+    if (summaryData && summaryData.result) {
+      studies = ids.map(id => {
+        const s = summaryData.result[id];
+        if (!s) return null;
+        return {
+          id,
+          title: s.title,
+          journal: s.fulljournalname || s.source,
+          pubDate: s.pubdate,
+          authors: s.authors && s.authors.length > 0
+            ? (s.authors.length > 1 ? `${s.authors[0].name} et al.` : s.authors[0].name)
+            : 'Unknown',
+          url: `https://pubmed.ncbi.nlm.nih.gov/${id}/`,
+        };
+      }).filter(Boolean);
+    }
+  }
+
+  const evidence = evidenceLevel(count);
+  return {
+    domain: 'health',
+    source: 'PubMed/MEDLINE',
+    source_url: 'https://pubmed.ncbi.nlm.nih.gov',
+    freshness: new Date().toISOString(),
+    query,
+    totalStudies: count,
+    evidence: evidence.label,
+    evidenceLevel: evidence.level,
+    odsUrl: getOdsUrl(query),
+    studies,
+  };
+}
+
+module.exports = { searchHealth };

package/sources/hospitals.js

@@ -0,0 +1,115 @@
+const fetch = require('node-fetch');
+
+const CMS_BASE = 'https://data.cms.gov/provider-data/api/1/datastore/query';
+const RESOURCES = {
+  general: 'xubh-q36u',
+  mortality: 'ynj2-r877',
+  readmissions: '632h-zaca',
+  experience: 'dgck-syfz',
+};
+
+async function cmsQuery(resourceId, filters, limit = 10) {
+  const url = `${CMS_BASE}/${resourceId}/0`;
+  const ctrl = new AbortController();
+  const id = setTimeout(() => ctrl.abort(), 10000);
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      signal: ctrl.signal,
+      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+      body: JSON.stringify({ limit, offset: 0, filters, sort: [], keys: true }),
+    });
+    clearTimeout(id);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.results || [];
+  } catch {
+    clearTimeout(id);
+    return [];
+  }
+}
+
+function normalizeComparison(val) {
+  if (!val) return null;
+  const v = val.toLowerCase();
+  if (v.includes('better')) return 'better';
+  if (v.includes('worse')) return 'worse';
+  if (v.includes('same') || v.includes('no different')) return 'same';
+  return null;
+}
+
+async function searchHospitals(query) {
+  if (!query) return { error: 'Search query required' };
+
+  const isZip = /^\d{5}$/.test(query);
+  const property = isZip ? 'zip_code' : 'hospital_name';
+  const operator = isZip ? '=' : 'CONTAINS';
+
+  const results = await cmsQuery(RESOURCES.general, {
+    conditions: [{ property, value: query, operator }],
+  });
+
+  return {
+    domain: 'hospitals',
+    source: 'CMS Care Compare',
+    source_url: 'https://data.cms.gov',
+    freshness: new Date().toISOString(),
+    query,
+    results: results.map(h => ({
+      providerId: h.provider_id || h.facility_id,
+      name: h.hospital_name || h.facility_name,
+      city: h.city,
+      state: h.state,
+      zip: h.zip_code,
+      overallRating: h.overall_rating || null,
+      type: h.hospital_type,
+      phone: h.phone_number,
+    })),
+    count: results.length,
+  };
+}
+
+async function getHospital(providerId) {
+  if (!providerId) return { error: 'Provider ID required' };
+
+  const [general, mortality, readmissions, experience] = await Promise.all([
+    cmsQuery(RESOURCES.general, { conditions: [{ property: 'provider_id', value: providerId, operator: '=' }] }, 1),
+    cmsQuery(RESOURCES.mortality, { conditions: [{ property: 'facility_id', value: providerId, operator: '=' }] }),
+    cmsQuery(RESOURCES.readmissions, { conditions: [{ property: 'facility_id', value: providerId, operator: '=' }] }),
+    cmsQuery(RESOURCES.experience, { conditions: [{ property: 'facility_id', value: providerId, operator: '=' }] }),
+  ]);
+
+  const info = general[0] || {};
+
+  return {
+    domain: 'hospitals',
+    source: 'CMS Care Compare',
+    source_url: 'https://data.cms.gov',
+    freshness: new Date().toISOString(),
+    providerId,
+    name: info.hospital_name || info.facility_name || '',
+    city: info.city || '',
+    state: info.state || '',
+    zip: info.zip_code || '',
+    phone: info.phone_number || '',
+    type: info.hospital_type || '',
+    overallRating: info.overall_rating || null,
+    mortality: mortality.filter(m => /mortality|death/i.test(m.measure_name || m.measure_id || '')).map(m => ({
+      measure: m.measure_name,
+      score: m.score,
+      comparison: normalizeComparison(m.compared_to_national),
+    })),
+    readmissions: readmissions.filter(r => /readmission|return/i.test(r.measure_name || r.measure_id || '')).map(r => ({
+      measure: r.measure_name,
+      score: r.score,
+      comparison: normalizeComparison(r.compared_to_national),
+    })),
+    patientExperience: experience.filter(e => /summary|overall|linear/i.test(e.hcahps_measure_id || e.measure_id || '')).map(e => ({
+      measure: e.hcahps_question || e.measure_name,
+      score: e.patient_survey_star_rating || e.score,
+      comparison: normalizeComparison(e.patient_survey_star_rating_footnote),
+    })),
+  };
+}
+
+module.exports = { searchHospitals, getHospital };

package/sources/jobs.js

@@ -0,0 +1,77 @@
+const fetch = require('node-fetch');
+
+const BLS_API = 'https://api.bls.gov/publicAPI/v2/timeseries/data/';
+
+// Common series IDs:
+// LNS14000000  — Unemployment rate (seasonally adjusted)
+// CUUR0000SA0  — CPI, all urban consumers (seasonally adjusted)
+// CES0000000001 — Total nonfarm payrolls (seasonally adjusted)
+
+function fetchWithTimeout(url, options, timeout = 10000) {
+  return Promise.race([
+    fetch(url, options),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('BLS API request timed out')), timeout)
+    )
+  ]);
+}
+
+async function fetchSeries(seriesId) {
+  const now = new Date();
+  const endYear = now.getFullYear().toString();
+  const startYear = (now.getFullYear() - 1).toString();
+
+  const res = await fetchWithTimeout(BLS_API, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      seriesid: [seriesId],
+      startyear: startYear,
+      endyear: endYear
+    })
+  });
+
+  if (!res.ok) {
+    throw new Error('BLS API returned ' + res.status);
+  }
+
+  const json = await res.json();
+
+  if (json.status !== 'REQUEST_SUCCEEDED' || !json.Results || !json.Results.series || !json.Results.series.length) {
+    throw new Error('BLS API error: ' + (json.message || 'no data'));
+  }
+
+  const series = json.Results.series[0];
+  const data = series.data || [];
+
+  // BLS returns newest first
+  const points = data.map(d => ({
+    year: d.year,
+    month: d.period.replace('M', ''),
+    value: d.value
+  }));
+
+  const latest = points[0] || null;
+
+  return {
+    domain: 'jobs',
+    source: 'Bureau of Labor Statistics',
+    source_url: 'https://www.bls.gov/',
+    freshness: latest ? latest.year + '-' + latest.month : null,
+    series: seriesId,
+    latest: latest,
+    history: points
+  };
+}
+
+async function getUnemployment() {
+  const result = await fetchSeries('LNS14000000');
+  result.series = 'unemployment_rate';
+  return result;
+}
+
+async function getSeriesData(seriesId) {
+  return fetchSeries(seriesId);
+}
+
+module.exports = { getUnemployment, getSeriesData };

package/sources/location.js

@@ -0,0 +1,54 @@
+const demographics = require('./demographics');
+const safety = require('./safety');
+
+async function getLocationProfile(zip) {
+  if (!/^\d{5}$/.test(zip)) return { error: 'Valid 5-digit ZIP code required' };
+
+  const [demoData, safetyData] = await Promise.allSettled([
+    demographics.getByZip(zip),
+    safety.getSafetyProfile(zip),
+  ]);
+
+  const demo = demoData.status === 'fulfilled' ? demoData.value : null;
+  const safe = safetyData.status === 'fulfilled' ? safetyData.value : null;
+
+  const population = demo ? demo.population : null;
+  const medianIncome = demo ? demo.medianIncome : null;
+  const safetyScore = safe ? safe.safetyScore : null;
+
+  const parts = [`ZIP ${zip}`];
+  if (population) parts.push(`population ${population.toLocaleString()}`);
+  if (medianIncome && medianIncome > 0) parts.push(`median income $${medianIncome.toLocaleString()}`);
+  if (safetyScore !== null) parts.push(`safety score ${safetyScore}/100`);
+  const summary = parts.join(', ');
+
+  return {
+    domain: 'location',
+    source: 'Census + EPA + CMS',
+    source_url: 'https://api.openprimitive.com',
+    freshness: new Date().toISOString(),
+    zip,
+    demographics: {
+      population,
+      medianIncome,
+      povertyRate: demo ? demo.povertyRate : null,
+      collegeRate: demo ? demo.collegeRate : null,
+      medianHomeValue: demo ? demo.medianHomeValue : null,
+      medianRent: demo ? demo.medianRent : null,
+    },
+    safety: {
+      score: safetyScore,
+      water: {
+        systemCount: safe ? safe.water.systemCount : null,
+        healthViolations: safe ? safe.water.healthViolations : null,
+      },
+      hospitals: {
+        count: safe ? safe.hospitals.count : null,
+        avgRating: safe ? safe.hospitals.averageRating : null,
+      },
+    },
+    summary,
+  };
+}
+
+module.exports = { getLocationProfile };

package/sources/nutrition.js

@@ -0,0 +1,91 @@
+const fetch = require('node-fetch');
+
+const USDA_BASE = 'https://api.nal.usda.gov/fdc/v1';
+const API_KEY = process.env.USDA_API_KEY || 'DEMO_KEY';
+
+const KEY_NUTRIENTS = [
+  { id: 1008, name: 'Calories', unit: 'kcal' },
+  { id: 1003, name: 'Protein', unit: 'g' },
+  { id: 1004, name: 'Total Fat', unit: 'g' },
+  { id: 1005, name: 'Carbohydrates', unit: 'g' },
+  { id: 1079, name: 'Fiber', unit: 'g' },
+  { id: 2000, name: 'Sugar', unit: 'g' },
+  { id: 1093, name: 'Sodium', unit: 'mg' },
+];
+
+async function fetchWithTimeout(url, ms = 10000) {
+  const ctrl = new AbortController();
+  const id = setTimeout(() => ctrl.abort(), ms);
+  try {
+    const res = await fetch(url, { signal: ctrl.signal });
+    clearTimeout(id);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    clearTimeout(id);
+    return null;
+  }
+}
+
+function extractNutrients(foodNutrients) {
+  if (!foodNutrients) return [];
+  return KEY_NUTRIENTS.map(kn => {
+    const match = foodNutrients.find(fn =>
+      (fn.nutrientId === kn.id) || (fn.nutrient && fn.nutrient.id === kn.id)
+    );
+    return {
+      name: kn.name,
+      amount: match ? (match.value != null ? match.value : match.amount) || 0 : 0,
+      unit: kn.unit,
+    };
+  });
+}
+
+async function searchFood(query) {
+  if (!query) return { error: 'query is required' };
+  const encoded = encodeURIComponent(query);
+  const url = `${USDA_BASE}/foods/search?query=${encoded}&pageSize=10&api_key=${API_KEY}`;
+  const data = await fetchWithTimeout(url);
+  if (!data) return { error: 'USDA FoodData Central API unavailable' };
+  return {
+    domain: 'nutrition',
+    source: 'USDA FoodData Central',
+    source_url: 'https://fdc.nal.usda.gov',
+    freshness: new Date().toISOString(),
+    query,
+    total: data.totalHits || 0,
+    results: (data.foods || []).map(f => ({
+      fdcId: f.fdcId,
+      description: f.description,
+      brandName: f.brandName || null,
+      dataType: f.dataType,
+      nutrients: extractNutrients(f.foodNutrients),
+    })),
+  };
+}
+
+async function getFood(fdcId) {
+  if (!fdcId) return { error: 'fdcId is required' };
+  const url = `${USDA_BASE}/food/${fdcId}?api_key=${API_KEY}`;
+  const data = await fetchWithTimeout(url);
+  if (!data) return { error: 'USDA FoodData Central API unavailable' };
+  return {
+    domain: 'nutrition',
+    source: 'USDA FoodData Central',
+    source_url: 'https://fdc.nal.usda.gov',
+    freshness: new Date().toISOString(),
+    fdcId: data.fdcId,
+    description: data.description,
+    brandName: data.brandName || null,
+    dataType: data.dataType,
+    servingSize: data.servingSize || null,
+    servingSizeUnit: data.servingSizeUnit || null,
+    nutrients: (data.foodNutrients || []).map(fn => ({
+      name: fn.nutrient ? fn.nutrient.name : fn.name,
+      amount: fn.amount != null ? fn.amount : 0,
+      unit: fn.nutrient ? fn.nutrient.unitName : fn.unitName,
+    })),
+  };
+}
+
+module.exports = { searchFood, getFood };