weather-agent-mcp 0.1.4 → 0.1.6

package/.env.example

@@ -9,6 +9,7 @@ ANTHROPIC_MODEL=claude-3-5-haiku-latest
 
 # Open-Meteo base URLs (override in tests with fake server)
 OPEN_METEO_FORECAST_URL=https://api.open-meteo.com
+OPEN_METEO_ARCHIVE_URL=https://archive-api.open-meteo.com
 OPEN_METEO_GEOCODING_URL=https://geocoding-api.open-meteo.com
 
 # Agent defaults

package/README.md

@@ -58,7 +58,7 @@ sudo launchctl config user path "$HOME/.volta/bin:/usr/bin:/bin:/usr/sbin:/sbin"
 
 Без `sudo`: можно `launchctl setenv PATH "$HOME/.volta/bin:/usr/bin:/bin:/usr/sbin:/sbin"` и перезапустить Cursor (сбросится после reboot).
 
-Reload MCP. Tools: `geocode`, `getCurrentWeather`, `getForecast`, `compareWeather`.
+Reload MCP. Tools: `geocode`, `getCurrentWeather`, `getForecast`, `getHistoricalWeather`, `compareWeather`. Для ряда температур (прогноз, архив одного дня по годам, сравнение) к ответу прилагается PNG-график.
 
 ### GitHub Copilot / VS Code
 

package/dist/weather-mcp.js

@@ -25217,12 +25217,12 @@ var ReadBuffer = class {
   constructor(options) {
     this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
   }
-  append(chunk) {
-    if ((this._buffer?.length ?? 0) + chunk.length > this._maxBufferSize) {
+  append(chunk2) {
+    if ((this._buffer?.length ?? 0) + chunk2.length > this._maxBufferSize) {
       this.clear();
       throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
     }
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk2]) : chunk2;
   }
   readMessage() {
     while (this._buffer) {
@@ -33905,9 +33905,9 @@ var StdioServerTransport = class {
   onclose;
   onerror;
   onmessage;
-  _ondata = (chunk) => {
+  _ondata = (chunk2) => {
     try {
-      this._readBuffer.append(chunk);
+      this._readBuffer.append(chunk2);
       this.processReadBuffer();
     } catch (error62) {
       this.onerror?.(error62);
@@ -34548,6 +34548,7 @@ async function httpJson(url2, options = {}) {
 function defaultConfig(overrides = {}) {
   return {
     forecastBaseUrl: process.env.OPEN_METEO_FORECAST_URL ?? "https://api.open-meteo.com",
+    archiveBaseUrl: process.env.OPEN_METEO_ARCHIVE_URL ?? "https://archive-api.open-meteo.com",
     geocodingBaseUrl: process.env.OPEN_METEO_GEOCODING_URL ?? "https://geocoding-api.open-meteo.com",
     timeoutMs: 1e4,
     retries: 1,
@@ -34728,8 +34729,198 @@ async function getForecast(latitude, longitude, startDate, endDate, config2 = {}
   };
 }
 
+// src/weather/history.ts
+var MAX_HISTORICAL_YEARS = 20;
+var ARCHIVE_FIRST_YEAR = 1940;
+var DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function assertHistoricalSpan(month, day, startYear, endYear) {
+  if (!Number.isInteger(month) || month < 1 || month > 12) {
+    throw new ToolError("INVALID_DATE_RANGE", `month must be 1-12. Got ${month}`, false);
+  }
+  const maxDay = DAYS_IN_MONTH[month - 1];
+  if (!Number.isInteger(day) || day < 1 || day > maxDay) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `day must be 1-${maxDay} for month ${month}. Got ${day}`,
+      false
+    );
+  }
+  if (!Number.isInteger(startYear) || !Number.isInteger(endYear)) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `startYear and endYear must be integers. Got ${startYear}..${endYear}`,
+      false
+    );
+  }
+  if (startYear < ARCHIVE_FIRST_YEAR) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `startYear must be >= ${ARCHIVE_FIRST_YEAR}. Got ${startYear}`,
+      false
+    );
+  }
+  const thisYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
+  if (endYear > thisYear) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `endYear must be <= ${thisYear}. Got ${endYear}`,
+      false
+    );
+  }
+  if (startYear > endYear) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `startYear (${startYear}) must be <= endYear (${endYear})`,
+      false
+    );
+  }
+  const span = endYear - startYear + 1;
+  if (span > MAX_HISTORICAL_YEARS) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `At most ${MAX_HISTORICAL_YEARS} years per call. Got ${span} (${startYear}..${endYear})`,
+      false
+    );
+  }
+}
+function isoDate(year, month, day) {
+  const m = String(month).padStart(2, "0");
+  const d = String(day).padStart(2, "0");
+  return `${year}-${m}-${d}`;
+}
+function isRealCalendarDate(year, month, day) {
+  const dt = new Date(Date.UTC(year, month - 1, day));
+  return dt.getUTCFullYear() === year && dt.getUTCMonth() === month - 1 && dt.getUTCDate() === day;
+}
+function num(value, label) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new ToolError("MALFORMED_RESPONSE", `Archive field ${label} is missing`, false);
+  }
+  return value;
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+async function mapPool(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    for (; ; ) {
+      const i = next;
+      next += 1;
+      if (i >= items.length) return;
+      out[i] = await fn(items[i]);
+    }
+  }
+  const workers = Math.min(limit, items.length);
+  await Promise.all(Array.from({ length: workers }, () => worker()));
+  return out;
+}
+async function fetchYear(year, month, day, latitude, longitude, cfg) {
+  const date5 = isoDate(year, month, day);
+  if (!isRealCalendarDate(year, month, day)) {
+    return { ok: false, unavailable: { year, reason: `${date5} is not a calendar date` } };
+  }
+  try {
+    const data = await meteoGet(
+      cfg.archiveBaseUrl,
+      "/v1/archive",
+      {
+        latitude,
+        longitude,
+        daily: "temperature_2m_max,temperature_2m_min,temperature_2m_mean,precipitation_sum,snowfall_sum,weather_code,wind_speed_10m_max",
+        timezone: "auto",
+        start_date: date5,
+        end_date: date5
+      },
+      cfg
+    );
+    const daily = data.daily;
+    const time3 = daily?.time?.[0];
+    if (!daily || !time3) {
+      return { ok: false, unavailable: { year, reason: `No archive data for ${date5}` } };
+    }
+    const code = num(daily.weather_code?.[0], "weather_code");
+    return {
+      ok: true,
+      timezone: data.timezone,
+      latitude: data.latitude,
+      longitude: data.longitude,
+      row: {
+        year,
+        date: time3,
+        tempMaxC: num(daily.temperature_2m_max?.[0], "temperature_2m_max"),
+        tempMinC: num(daily.temperature_2m_min?.[0], "temperature_2m_min"),
+        tempMeanC: num(daily.temperature_2m_mean?.[0], "temperature_2m_mean"),
+        precipitationMm: num(daily.precipitation_sum?.[0], "precipitation_sum"),
+        snowfallCm: num(daily.snowfall_sum?.[0], "snowfall_sum"),
+        windSpeedMaxKmh: num(daily.wind_speed_10m_max?.[0], "wind_speed_10m_max"),
+        weatherCode: code,
+        weatherDescription: describeWmo(code)
+      }
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { ok: false, unavailable: { year, reason } };
+  }
+}
+function summarize(years) {
+  const n = years.length;
+  const avg = (pick2) => round1(years.reduce((sum, y) => sum + pick2(y), 0) / n);
+  const wettest = years.reduce((best, y) => y.precipitationMm > best.precipitationMm ? y : best);
+  const warmest = years.reduce((best, y) => y.tempMaxC > best.tempMaxC ? y : best);
+  const coldest = years.reduce((best, y) => y.tempMinC < best.tempMinC ? y : best);
+  return {
+    avgTempMeanC: avg((y) => y.tempMeanC),
+    avgTempMaxC: avg((y) => y.tempMaxC),
+    avgTempMinC: avg((y) => y.tempMinC),
+    rainyDays: years.filter((y) => y.precipitationMm > 0).length,
+    wettestYear: wettest.year,
+    wettestPrecipitationMm: wettest.precipitationMm,
+    warmestYear: warmest.year,
+    warmestTempMaxC: warmest.tempMaxC,
+    coldestYear: coldest.year,
+    coldestTempMinC: coldest.tempMinC
+  };
+}
+async function getHistoricalWeather(latitude, longitude, month, day, startYear, endYear, config2 = {}) {
+  assertHistoricalSpan(month, day, startYear, endYear);
+  const cfg = defaultConfig(config2);
+  const years = Array.from({ length: endYear - startYear + 1 }, (_, i) => startYear + i);
+  const outcomes = await mapPool(
+    years,
+    5,
+    (year) => fetchYear(year, month, day, latitude, longitude, cfg)
+  );
+  const rows = outcomes.flatMap((o) => o.ok ? [o.row] : []);
+  const unavailable = outcomes.flatMap((o) => o.ok ? [] : [o.unavailable]);
+  if (rows.length === 0) {
+    const first = unavailable[0]?.reason ?? "no data";
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `Archive returned no days for ${month}/${day} in ${startYear}..${endYear}: ${first}`,
+      false,
+      { unavailable }
+    );
+  }
+  const sample = outcomes.find((o) => o.ok);
+  return {
+    latitude: sample && sample.ok ? sample.latitude : latitude,
+    longitude: sample && sample.ok ? sample.longitude : longitude,
+    timezone: sample && sample.ok ? sample.timezone : "UTC",
+    month,
+    day,
+    startYear,
+    endYear,
+    source: "open-meteo-archive",
+    years: rows,
+    unavailable,
+    summary: summarize(rows)
+  };
+}
+
 // src/weather/compare.ts
-function summarize(forecast) {
+function summarize2(forecast) {
   const n = forecast.days.length || 1;
   const avgTempMaxC = forecast.days.reduce((s, d) => s + d.tempMaxC, 0) / n;
   const avgTempMinC = forecast.days.reduce((s, d) => s + d.tempMinC, 0) / n;
@@ -34758,13 +34949,300 @@ async function compareWeather(locations, startDate, endDate, config2 = {}) {
       return {
         name: loc.name,
         forecast,
-        summary: summarize(forecast)
+        summary: summarize2(forecast)
       };
     })
   );
   return { startDate, endDate, locations: results };
 }
 
+// src/weather/temperature-chart.ts
+import { deflateSync } from "node:zlib";
+var CHART_WIDTH = 720;
+var CHART_HEIGHT = 360;
+var BG = [247, 244, 239];
+var PLOT = [255, 252, 247];
+var GRID = [220, 214, 204];
+var INK = [70, 64, 56];
+var SERIES_COLORS = [
+  [196, 90, 58],
+  [47, 111, 163],
+  [62, 122, 90],
+  [140, 90, 160],
+  [176, 132, 48]
+];
+var PAD_L = 56;
+var PAD_R = 20;
+var PAD_T = 40;
+var PAD_B = 44;
+function pickAxisLabels(count, maxLabels = 6) {
+  if (count <= 0) return [];
+  if (count <= maxLabels) return Array.from({ length: count }, (_, i) => i);
+  const indices = /* @__PURE__ */ new Set([0, count - 1]);
+  const inner = maxLabels - 1;
+  for (let i = 1; i < inner; i++) {
+    indices.add(Math.round(i * (count - 1) / inner));
+  }
+  return [...indices].sort((a, b) => a - b);
+}
+function renderTemperatureChart(labels, series) {
+  if (labels.length < 2 || series.length === 0) return null;
+  const aligned = series.map((s) => ({ name: s.name, values: s.values.slice(0, labels.length) })).filter((s) => finiteCount(s.values) >= 2);
+  if (aligned.length === 0) return null;
+  const finite = aligned.flatMap((s) => s.values.filter((v) => isFiniteNumber(v)));
+  let yMin = Math.min(...finite);
+  let yMax = Math.max(...finite);
+  if (yMax - yMin < 1) {
+    yMin -= 1;
+    yMax += 1;
+  } else {
+    const pad = (yMax - yMin) * 0.08;
+    yMin -= pad;
+    yMax += pad;
+  }
+  const pixels = new Uint8Array(CHART_WIDTH * CHART_HEIGHT * 3);
+  fill(pixels, BG);
+  const plotW = CHART_WIDTH - PAD_L - PAD_R;
+  const plotH = CHART_HEIGHT - PAD_T - PAD_B;
+  fillRect(pixels, PAD_L, PAD_T, plotW, plotH, PLOT);
+  const yTicks = 4;
+  for (let t = 0; t <= yTicks; t++) {
+    const y = PAD_T + Math.round(plotH * t / yTicks);
+    hLine(pixels, PAD_L, PAD_L + plotW, y, GRID);
+    const value = yMax - (yMax - yMin) * t / yTicks;
+    drawText(pixels, formatTemp(value), 4, y - 4, INK, 1);
+  }
+  vLine(pixels, PAD_L, PAD_T, PAD_T + plotH, INK);
+  hLine(pixels, PAD_L, PAD_L + plotW, PAD_T + plotH, INK);
+  const xIndex = (i) => PAD_L + Math.round(i * plotW / Math.max(labels.length - 1, 1));
+  const yOf = (v) => PAD_T + Math.round(plotH * (1 - (v - yMin) / (yMax - yMin)));
+  for (const index of pickAxisLabels(labels.length)) {
+    const x = xIndex(index);
+    vLine(pixels, x, PAD_T + plotH, PAD_T + plotH + 4, INK);
+    const caption = labels[index] ?? "";
+    drawText(pixels, caption, x - textWidth(caption, 1) / 2, PAD_T + plotH + 8, INK, 1);
+  }
+  aligned.forEach((s, seriesIndex) => {
+    const color = SERIES_COLORS[seriesIndex % SERIES_COLORS.length];
+    let prev = null;
+    for (let i = 0; i < labels.length; i++) {
+      const value = s.values[i];
+      if (!isFiniteNumber(value)) {
+        prev = null;
+        continue;
+      }
+      const point = { x: xIndex(i), y: yOf(value) };
+      if (prev) drawLine(pixels, prev.x, prev.y, point.x, point.y, color);
+      fillRect(pixels, point.x - 2, point.y - 2, 5, 5, color);
+      prev = point;
+    }
+  });
+  let legendX = PAD_L;
+  for (let i = 0; i < aligned.length; i++) {
+    const color = SERIES_COLORS[i % SERIES_COLORS.length];
+    const name = aligned[i].name;
+    fillRect(pixels, legendX, 14, 14, 8, color);
+    drawText(pixels, name, legendX + 18, 12, INK, 2);
+    legendX += 18 + textWidth(name, 2) + 16;
+  }
+  return encodePng(pixels, CHART_WIDTH, CHART_HEIGHT);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function finiteCount(values) {
+  return values.filter((v) => isFiniteNumber(v)).length;
+}
+function formatTemp(value) {
+  const rounded = Math.round(value);
+  return `${rounded}`;
+}
+function fill(pixels, color) {
+  for (let i = 0; i < pixels.length; i += 3) {
+    pixels[i] = color[0];
+    pixels[i + 1] = color[1];
+    pixels[i + 2] = color[2];
+  }
+}
+function setPixel(pixels, x, y, color) {
+  if (x < 0 || y < 0 || x >= CHART_WIDTH || y >= CHART_HEIGHT) return;
+  const i = (y * CHART_WIDTH + x) * 3;
+  pixels[i] = color[0];
+  pixels[i + 1] = color[1];
+  pixels[i + 2] = color[2];
+}
+function fillRect(pixels, x, y, w, h, color) {
+  for (let yy = y; yy < y + h; yy++) {
+    for (let xx = x; xx < x + w; xx++) setPixel(pixels, xx, yy, color);
+  }
+}
+function hLine(pixels, x0, x1, y, color) {
+  const from = Math.min(x0, x1);
+  const to = Math.max(x0, x1);
+  for (let x = from; x <= to; x++) setPixel(pixels, x, y, color);
+}
+function vLine(pixels, x, y0, y1, color) {
+  const from = Math.min(y0, y1);
+  const to = Math.max(y0, y1);
+  for (let y = from; y <= to; y++) setPixel(pixels, x, y, color);
+}
+function drawLine(pixels, x0, y0, x1, y1, color) {
+  let x = x0;
+  let y = y0;
+  const dx = Math.abs(x1 - x0);
+  const sx = x0 < x1 ? 1 : -1;
+  const dy = -Math.abs(y1 - y0);
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx + dy;
+  for (; ; ) {
+    fillRect(pixels, x - 1, y - 1, 3, 3, color);
+    if (x === x1 && y === y1) break;
+    const e2 = 2 * err;
+    if (e2 >= dy) {
+      err += dy;
+      x += sx;
+    }
+    if (e2 <= dx) {
+      err += dx;
+      y += sy;
+    }
+  }
+}
+var FONT = {
+  " ": [0, 0, 0, 0, 0, 0, 0],
+  "-": [0, 0, 0, 31, 0, 0, 0],
+  ".": [0, 0, 0, 0, 0, 12, 12],
+  "/": [1, 2, 4, 8, 16, 0, 0],
+  "0": [14, 17, 19, 21, 25, 17, 14],
+  "1": [4, 12, 4, 4, 4, 4, 14],
+  "2": [14, 17, 1, 2, 4, 8, 31],
+  "3": [30, 1, 1, 14, 1, 1, 30],
+  "4": [2, 6, 10, 18, 31, 2, 2],
+  "5": [31, 16, 16, 30, 1, 1, 30],
+  "6": [14, 16, 16, 30, 17, 17, 14],
+  "7": [31, 1, 2, 4, 8, 8, 8],
+  "8": [14, 17, 17, 14, 17, 17, 14],
+  "9": [14, 17, 17, 15, 1, 1, 14],
+  A: [14, 17, 17, 31, 17, 17, 17],
+  B: [30, 17, 17, 30, 17, 17, 30],
+  C: [14, 17, 16, 16, 16, 17, 14],
+  D: [30, 17, 17, 17, 17, 17, 30],
+  E: [31, 16, 16, 30, 16, 16, 31],
+  F: [31, 16, 16, 30, 16, 16, 16],
+  G: [14, 17, 16, 23, 17, 17, 14],
+  H: [17, 17, 17, 31, 17, 17, 17],
+  I: [14, 4, 4, 4, 4, 4, 14],
+  J: [7, 2, 2, 2, 2, 18, 12],
+  K: [17, 18, 20, 24, 20, 18, 17],
+  L: [16, 16, 16, 16, 16, 16, 31],
+  M: [17, 27, 21, 21, 17, 17, 17],
+  N: [17, 25, 21, 19, 17, 17, 17],
+  O: [14, 17, 17, 17, 17, 17, 14],
+  P: [30, 17, 17, 30, 16, 16, 16],
+  Q: [14, 17, 17, 17, 21, 18, 13],
+  R: [30, 17, 17, 30, 20, 18, 17],
+  S: [15, 16, 16, 14, 1, 1, 30],
+  T: [31, 4, 4, 4, 4, 4, 4],
+  U: [17, 17, 17, 17, 17, 17, 14],
+  V: [17, 17, 17, 17, 17, 10, 4],
+  W: [17, 17, 17, 21, 21, 21, 10],
+  X: [17, 17, 10, 4, 10, 17, 17],
+  Y: [17, 17, 10, 4, 4, 4, 4],
+  Z: [31, 1, 2, 4, 8, 16, 31],
+  a: [0, 0, 14, 1, 15, 17, 15],
+  b: [16, 16, 30, 17, 17, 17, 30],
+  c: [0, 0, 14, 16, 16, 17, 14],
+  d: [1, 1, 15, 17, 17, 17, 15],
+  e: [0, 0, 14, 17, 31, 16, 14],
+  f: [6, 8, 28, 8, 8, 8, 8],
+  g: [0, 0, 15, 17, 15, 1, 14],
+  h: [16, 16, 22, 25, 17, 17, 17],
+  i: [4, 0, 12, 4, 4, 4, 14],
+  j: [2, 0, 6, 2, 2, 18, 12],
+  k: [16, 16, 18, 20, 24, 20, 18],
+  l: [12, 4, 4, 4, 4, 4, 14],
+  m: [0, 0, 26, 21, 21, 17, 17],
+  n: [0, 0, 22, 25, 17, 17, 17],
+  o: [0, 0, 14, 17, 17, 17, 14],
+  p: [0, 0, 30, 17, 30, 16, 16],
+  q: [0, 0, 15, 17, 15, 1, 1],
+  r: [0, 0, 22, 25, 16, 16, 16],
+  s: [0, 0, 15, 16, 14, 1, 30],
+  t: [8, 8, 28, 8, 8, 9, 6],
+  u: [0, 0, 17, 17, 17, 19, 13],
+  v: [0, 0, 17, 17, 17, 10, 4],
+  w: [0, 0, 17, 17, 21, 21, 10],
+  x: [0, 0, 17, 10, 4, 10, 17],
+  y: [0, 0, 17, 17, 15, 1, 14],
+  z: [0, 0, 31, 2, 4, 8, 31]
+};
+function glyph(ch) {
+  return FONT[ch];
+}
+function textWidth(text, scale) {
+  let width = 0;
+  for (const ch of text) {
+    if (!glyph(ch)) continue;
+    width += 6 * scale;
+  }
+  return width;
+}
+function drawText(pixels, text, x, y, color, scale) {
+  let cursor = Math.round(x);
+  for (const ch of text) {
+    const rows = glyph(ch);
+    if (!rows) continue;
+    for (let row = 0; row < rows.length; row++) {
+      const bits = rows[row] ?? 0;
+      for (let col = 0; col < 5; col++) {
+        if ((bits & 1 << 4 - col) === 0) continue;
+        fillRect(pixels, cursor + col * scale, y + row * scale, scale, scale, color);
+      }
+    }
+    cursor += 6 * scale;
+  }
+}
+function encodePng(pixels, width, height) {
+  const stride = width * 3;
+  const raw = Buffer.alloc((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    const offset = y * (stride + 1);
+    raw[offset] = 0;
+    Buffer.from(pixels.buffer, pixels.byteOffset + y * stride, stride).copy(raw, offset + 1);
+  }
+  const compressed = deflateSync(raw);
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", compressed),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function chunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const name = Buffer.from(type, "ascii");
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([name, data])), 0);
+  return Buffer.concat([length, name, data, crc]);
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      const mask = -(crc & 1);
+      crc = crc >>> 1 ^ 3988292384 & mask;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
 // src/mcp-server/error-envelope.ts
 function toErrorText(err) {
   const envelope = isAppError(err) ? err.toEnvelope() : {
@@ -34774,9 +35252,13 @@ function toErrorText(err) {
   };
   return JSON.stringify(envelope);
 }
-function okResult(output2) {
+function okResult(output2, image) {
+  const content = [{ type: "text", text: JSON.stringify(output2) }];
+  if (image) {
+    content.push({ type: "image", data: image.data, mimeType: image.mimeType });
+  }
   return {
-    content: [{ type: "text", text: JSON.stringify(output2) }],
+    content,
     structuredContent: output2
   };
 }
@@ -34844,6 +35326,55 @@ var ForecastOutputSchema = external_exports.object({
   endDate: external_exports.string(),
   days: external_exports.array(DailyForecastSchema)
 });
+var HistoricalWeatherInputSchema = external_exports.object({
+  latitude: external_exports.number().min(-90).max(90),
+  longitude: external_exports.number().min(-180).max(180),
+  month: external_exports.number().int().min(1).max(12).describe("Calendar month, 1-12"),
+  day: external_exports.number().int().min(1).max(31).describe("Day of month"),
+  startYear: external_exports.number().int().describe("First year, inclusive"),
+  endYear: external_exports.number().int().describe("Last year, inclusive")
+});
+var HistoricalYearSchema = external_exports.object({
+  year: external_exports.number(),
+  date: external_exports.string(),
+  tempMaxC: external_exports.number(),
+  tempMinC: external_exports.number(),
+  tempMeanC: external_exports.number(),
+  precipitationMm: external_exports.number(),
+  snowfallCm: external_exports.number(),
+  windSpeedMaxKmh: external_exports.number(),
+  weatherCode: external_exports.number(),
+  weatherDescription: external_exports.string()
+});
+var HistoricalWeatherOutputSchema = external_exports.object({
+  latitude: external_exports.number(),
+  longitude: external_exports.number(),
+  timezone: external_exports.string(),
+  month: external_exports.number(),
+  day: external_exports.number(),
+  startYear: external_exports.number(),
+  endYear: external_exports.number(),
+  source: external_exports.literal("open-meteo-archive"),
+  years: external_exports.array(HistoricalYearSchema),
+  unavailable: external_exports.array(
+    external_exports.object({
+      year: external_exports.number(),
+      reason: external_exports.string()
+    })
+  ),
+  summary: external_exports.object({
+    avgTempMeanC: external_exports.number(),
+    avgTempMaxC: external_exports.number(),
+    avgTempMinC: external_exports.number(),
+    rainyDays: external_exports.number(),
+    wettestYear: external_exports.number(),
+    wettestPrecipitationMm: external_exports.number(),
+    warmestYear: external_exports.number(),
+    warmestTempMaxC: external_exports.number(),
+    coldestYear: external_exports.number(),
+    coldestTempMinC: external_exports.number()
+  })
+});
 var CompareWeatherInputSchema = external_exports.object({
   locations: external_exports.array(LocationSchema).min(2).describe("Locations to compare"),
   startDate: external_exports.string().describe("Start date YYYY-MM-DD"),
@@ -34917,7 +35448,31 @@ function createWeatherMcpServer() {
     async ({ latitude, longitude, startDate, endDate }) => {
       try {
         const result = await getForecast(latitude, longitude, startDate, endDate);
-        return okResult(result);
+        return okResult(result, chartForForecast(result));
+      } catch (err) {
+        return errResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "getHistoricalWeather",
+    {
+      title: "Historical weather on a calendar day",
+      description: "Get historical daily weather for the same calendar day across startYear..endYear (inclusive, at most 20 years) from the Open-Meteo archive (ERA5 reanalysis, not a single weather station). Use for questions like 'what was the weather on 28 September for the last 10 years'. Returns per-year min/mean/max temperature (\xB0C), precipitation (mm), snowfall (cm), max wind (km/h), WMO description, plus summary stats. Years that are not a real date (e.g. 29 Feb) or not yet in the archive (about a 5-day delay) are listed in unavailable. Do not use getForecast for dates older than the forecast window.",
+      inputSchema: HistoricalWeatherInputSchema,
+      outputSchema: HistoricalWeatherOutputSchema
+    },
+    async ({ latitude, longitude, month, day, startYear, endYear }) => {
+      try {
+        const result = await getHistoricalWeather(
+          latitude,
+          longitude,
+          month,
+          day,
+          startYear,
+          endYear
+        );
+        return okResult(result, chartForHistory(result));
       } catch (err) {
         return errResult(err);
       }
@@ -34934,7 +35489,7 @@ function createWeatherMcpServer() {
     async ({ locations, startDate, endDate }) => {
       try {
         const result = await compareWeather(locations, startDate, endDate);
-        return okResult(result);
+        return okResult(result, chartForCompare(result));
       } catch (err) {
         return errResult(err);
       }
@@ -34942,6 +35497,50 @@ function createWeatherMcpServer() {
   );
   return server;
 }
+function pngBlock(png) {
+  if (!png) return void 0;
+  return { data: png.toString("base64"), mimeType: "image/png" };
+}
+function shortDate(iso) {
+  return iso.slice(5);
+}
+function chartForForecast(result) {
+  return pngBlock(
+    renderTemperatureChart(
+      result.days.map((day) => shortDate(day.date)),
+      [
+        { name: "min", values: result.days.map((day) => day.tempMinC) },
+        { name: "max", values: result.days.map((day) => day.tempMaxC) }
+      ]
+    )
+  );
+}
+function chartForHistory(result) {
+  return pngBlock(
+    renderTemperatureChart(
+      result.years.map((year) => String(year.year)),
+      [
+        { name: "min", values: result.years.map((year) => year.tempMinC) },
+        { name: "mean", values: result.years.map((year) => year.tempMeanC) },
+        { name: "max", values: result.years.map((year) => year.tempMaxC) }
+      ]
+    )
+  );
+}
+function chartForCompare(result) {
+  const labels = result.locations[0]?.forecast.days.map((day) => day.date) ?? [];
+  return pngBlock(
+    renderTemperatureChart(
+      labels.map(shortDate),
+      result.locations.map((location) => ({
+        name: location.name,
+        values: labels.map(
+          (date5) => location.forecast.days.find((day) => day.date === date5)?.tempMaxC ?? null
+        )
+      }))
+    )
+  );
+}
 
 // src/mcp-server/index.ts
 void serveStdio(() => createWeatherMcpServer(), {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weather-agent-mcp",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Model-agnostic AI agent with MCP tools over Open-Meteo",
   "type": "module",
   "engines": {