weather-agent-mcp 0.1.5 → 0.1.6

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`, `getHistoricalWeather`, `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);
@@ -34956,6 +34956,293 @@ async function compareWeather(locations, startDate, endDate, config2 = {}) {
   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() : {
@@ -34965,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
   };
 }
@@ -35157,7 +35448,7 @@ 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);
       }
@@ -35181,7 +35472,7 @@ function createWeatherMcpServer() {
           startYear,
           endYear
         );
-        return okResult(result);
+        return okResult(result, chartForHistory(result));
       } catch (err) {
         return errResult(err);
       }
@@ -35198,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);
       }
@@ -35206,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.5",
+  "version": "0.1.6",
   "description": "Model-agnostic AI agent with MCP tools over Open-Meteo",
   "type": "module",
   "engines": {