@vellumai/assistant 0.4.29 → 0.4.31

package/src/__tests__/get-weather.test.ts

@@ -1,393 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  executeGetWeather,
-  weatherCodeToDescription,
-} from "../tools/weather/service.js";
-
-// ---------------------------------------------------------------------------
-// Helper: build a mock fetch that returns predefined geocoding & weather data
-// ---------------------------------------------------------------------------
-
-function createMockFetch(options?: {
-  geoResults?: unknown[];
-  geoStatus?: number;
-  geoError?: Error;
-  forecastData?: unknown;
-  forecastStatus?: number;
-  forecastError?: Error;
-}): typeof globalThis.fetch {
-  const {
-    geoResults,
-    geoStatus = 200,
-    geoError,
-    forecastData,
-    forecastStatus = 200,
-    forecastError,
-  } = options ?? {};
-
-  const defaultGeoResults = [
-    {
-      name: "San Francisco",
-      latitude: 37.7749,
-      longitude: -122.4194,
-      country: "United States",
-      admin1: "California",
-    },
-  ];
-
-  // Generate 48 hourly entries starting from 2025-01-15T00:00
-  const hourlyTimes: string[] = [];
-  const hourlyTemps: number[] = [];
-  const hourlyCodes: number[] = [];
-  const hourlyIsDay: number[] = [];
-  for (let i = 0; i < 48; i++) {
-    const h = i % 24;
-    hourlyTimes.push(
-      `2025-01-${15 + Math.floor(i / 24)}T${String(h).padStart(2, "0")}:00`,
-    );
-    hourlyTemps.push(10 + Math.sin(i / 4) * 5);
-    hourlyCodes.push(i % 3 === 0 ? 0 : 2);
-    hourlyIsDay.push(h >= 7 && h < 19 ? 1 : 0);
-  }
-
-  const defaultForecastData = {
-    current: {
-      time: "2025-01-15T08:00",
-      temperature_2m: 15.0,
-      relative_humidity_2m: 72,
-      apparent_temperature: 13.5,
-      weather_code: 2,
-      wind_speed_10m: 18.0,
-      wind_direction_10m: 270,
-    },
-    current_units: {
-      temperature_2m: "\u00B0C",
-      relative_humidity_2m: "%",
-      apparent_temperature: "\u00B0C",
-      wind_speed_10m: "km/h",
-      wind_direction_10m: "\u00B0",
-    },
-    hourly: {
-      time: hourlyTimes,
-      temperature_2m: hourlyTemps,
-      weather_code: hourlyCodes,
-      is_day: hourlyIsDay,
-    },
-    hourly_units: {
-      temperature_2m: "\u00B0C",
-      weather_code: "wmo code",
-      is_day: "",
-    },
-    daily: {
-      time: [
-        "2025-01-15",
-        "2025-01-16",
-        "2025-01-17",
-        "2025-01-18",
-        "2025-01-19",
-      ],
-      weather_code: [2, 61, 3, 0, 1],
-      temperature_2m_max: [17.0, 14.0, 16.0, 19.0, 20.0],
-      temperature_2m_min: [10.0, 8.0, 9.0, 11.0, 12.0],
-      precipitation_probability_max: [10, 80, 30, 0, 5],
-    },
-    daily_units: {
-      temperature_2m_max: "\u00B0C",
-      temperature_2m_min: "\u00B0C",
-      precipitation_probability_max: "%",
-    },
-  };
-
-  return (async (url: string | URL | Request) => {
-    const urlStr =
-      typeof url === "string" ? url : url instanceof URL ? url.href : url.url;
-
-    if (urlStr.includes("geocoding-api.open-meteo.com")) {
-      if (geoError) throw geoError;
-      return new Response(
-        JSON.stringify({ results: geoResults ?? defaultGeoResults }),
-        {
-          status: geoStatus,
-          headers: { "content-type": "application/json" },
-        },
-      );
-    }
-
-    if (urlStr.includes("api.open-meteo.com")) {
-      if (forecastError) throw forecastError;
-      return new Response(JSON.stringify(forecastData ?? defaultForecastData), {
-        status: forecastStatus,
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    return new Response("Not found", { status: 404 });
-  }) as typeof globalThis.fetch;
-}
-
-// ---------------------------------------------------------------------------
-// Weather code mapping
-// ---------------------------------------------------------------------------
-
-describe("weatherCodeToDescription", () => {
-  test("maps clear sky (code 0)", () => {
-    expect(weatherCodeToDescription(0)).toBe("Clear sky");
-  });
-
-  test("maps partly cloudy (code 2)", () => {
-    expect(weatherCodeToDescription(2)).toBe("Partly cloudy");
-  });
-
-  test("maps moderate rain (code 63)", () => {
-    expect(weatherCodeToDescription(63)).toBe("Moderate rain");
-  });
-
-  test("maps heavy snowfall (code 75)", () => {
-    expect(weatherCodeToDescription(75)).toBe("Heavy snowfall");
-  });
-
-  test("maps thunderstorm (code 95)", () => {
-    expect(weatherCodeToDescription(95)).toBe("Thunderstorm");
-  });
-
-  test("maps thunderstorm with heavy hail (code 99)", () => {
-    expect(weatherCodeToDescription(99)).toBe("Thunderstorm with heavy hail");
-  });
-
-  test("returns Unknown for unrecognized codes", () => {
-    expect(weatherCodeToDescription(42)).toBe("Unknown");
-    expect(weatherCodeToDescription(100)).toBe("Unknown");
-    expect(weatherCodeToDescription(-1)).toBe("Unknown");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Geocoding parsing
-// ---------------------------------------------------------------------------
-
-describe("geocoding parsing", () => {
-  test("extracts location name, admin1, and country from geocoding results", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain(
-      "San Francisco, California, United States",
-    );
-    expect(result.content).toContain("37.7749");
-    expect(result.content).toContain("-122.4194");
-  });
-
-  test("handles location without admin1", async () => {
-    const mockFetch = createMockFetch({
-      geoResults: [
-        {
-          name: "Tokyo",
-          latitude: 35.6762,
-          longitude: 139.6503,
-          country: "Japan",
-        },
-      ],
-    });
-    const result = await executeGetWeather({ location: "Tokyo" }, mockFetch);
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Tokyo, Japan");
-  });
-
-  test("handles location without country", async () => {
-    const mockFetch = createMockFetch({
-      geoResults: [{ name: "Somewhere", latitude: 0, longitude: 0 }],
-    });
-    const result = await executeGetWeather(
-      { location: "Somewhere" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Weather for Somewhere");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Weather output formatting
-// ---------------------------------------------------------------------------
-
-describe("weather output formatting", () => {
-  test("returns current conditions in fahrenheit by default", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    // 15C = 59F
-    expect(result.content).toContain("59\u00B0F");
-    expect(result.content).toContain("Humidity: 72%");
-    expect(result.content).toContain("Partly cloudy");
-  });
-
-  test("returns current conditions in celsius when requested", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco", units: "celsius" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("15\u00B0C");
-    expect(result.content).toContain("Humidity: 72%");
-  });
-
-  test("includes 10-day forecast by default", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("10-Day Forecast");
-    expect(result.content).toContain("2025-01-15");
-    expect(result.content).toContain("2025-01-19");
-    expect(result.content).toContain("Precip");
-  });
-
-  test("wind speed is converted to mph in fahrenheit mode", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    // 18 km/h ~= 11 mph
-    expect(result.content).toContain("11 mph");
-    expect(result.content).toContain("W");
-  });
-
-  test("wind speed stays in km/h in celsius mode", async () => {
-    const mockFetch = createMockFetch();
-    const result = await executeGetWeather(
-      { location: "San Francisco", units: "celsius" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("18 km/h");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Error handling
-// ---------------------------------------------------------------------------
-
-describe("error handling", () => {
-  test("returns error for missing location", async () => {
-    const result = await executeGetWeather({});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("location is required");
-  });
-
-  test("returns error for empty location", async () => {
-    const result = await executeGetWeather({ location: "" });
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("location is required");
-  });
-
-  test("returns error for whitespace-only location", async () => {
-    const result = await executeGetWeather({ location: "   " });
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("location is required");
-  });
-
-  test("returns error for invalid units", async () => {
-    const result = await executeGetWeather({
-      location: "NYC",
-      units: "kelvin",
-    });
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('units must be "celsius" or "fahrenheit"');
-  });
-
-  test("returns error when location is not found", async () => {
-    const mockFetch = createMockFetch({ geoResults: [] });
-    const result = await executeGetWeather(
-      { location: "xyznonexistent" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Could not find location");
-  });
-
-  test("returns error when geocoding returns no results array", async () => {
-    // Return empty object with no results key
-    const emptyGeoFetch = (async () => {
-      return new Response(JSON.stringify({}), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    }) as unknown as typeof globalThis.fetch;
-
-    const result = await executeGetWeather(
-      { location: "unknown" },
-      emptyGeoFetch,
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Could not find location");
-  });
-
-  test("returns error when geocoding API returns non-200", async () => {
-    const mockFetch = createMockFetch({ geoStatus: 500 });
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Geocoding API returned HTTP 500");
-  });
-
-  test("returns error when weather API returns non-200", async () => {
-    const mockFetch = createMockFetch({ forecastStatus: 503 });
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Weather API returned HTTP 503");
-  });
-
-  test("returns error when geocoding fetch throws", async () => {
-    const mockFetch = createMockFetch({ geoError: new Error("Network error") });
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Geocoding request failed");
-    expect(result.content).toContain("Network error");
-  });
-
-  test("returns error when weather fetch throws", async () => {
-    const mockFetch = createMockFetch({
-      forecastError: new Error("Connection refused"),
-    });
-    const result = await executeGetWeather(
-      { location: "San Francisco" },
-      mockFetch,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Weather forecast request failed");
-    expect(result.content).toContain("Connection refused");
-  });
-});

package/src/__tests__/weather-skill-regression.test.ts

@@ -1,276 +0,0 @@
-import { afterAll, describe, expect, test } from "bun:test";
-
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-
-import { __resetRegistryForTesting, getTool } from "../tools/registry.js";
-import type { ToolContext } from "../tools/types.js";
-import {
-  weatherCodeToDescription,
-  weatherCodeToSFSymbol,
-} from "../tools/weather/service.js";
-
-// ---------------------------------------------------------------------------
-// Regression tests: ensure the skill-loaded path produces the same results
-// as the legacy hardcoded path after the weather tool migration.
-// ---------------------------------------------------------------------------
-
-// Clean up after this file to prevent contamination of later test files.
-afterAll(() => {
-  __resetRegistryForTesting();
-});
-
-const CONFIG_DIR = join(
-  dirname(import.meta.dirname!),
-  "config",
-  "bundled-skills",
-  "weather",
-);
-
-describe("weather skill script wrapper", () => {
-  test("exports a run function without registering get_weather in the tool registry", async () => {
-    // Before importing the wrapper, verify get_weather is not in the registry.
-    expect(getTool("get_weather")).toBeUndefined();
-
-    // Dynamic import of the skill wrapper — it should NOT trigger any
-    // registerTool side-effect (the wrapper delegates to the service module).
-    const mod =
-      await import("../config/bundled-skills/weather/tools/get-weather.js");
-    expect(typeof mod.run).toBe("function");
-
-    // After importing, the registry should still be clean — no side-effect.
-    expect(getTool("get_weather")).toBeUndefined();
-  });
-
-  test("run function delegates to executeGetWeather from the service module", async () => {
-    const mod =
-      await import("../config/bundled-skills/weather/tools/get-weather.js");
-
-    // Provide a minimal mock fetch and minimal input to verify delegation.
-    const mockFetch = (async (url: string | URL | Request) => {
-      const urlStr =
-        typeof url === "string"
-          ? url
-          : url instanceof URL
-            ? url.href
-            : (url as Request).url;
-
-      if (urlStr.includes("geocoding-api.open-meteo.com")) {
-        return new Response(
-          JSON.stringify({
-            results: [
-              {
-                name: "TestCity",
-                latitude: 0,
-                longitude: 0,
-                country: "Testland",
-              },
-            ],
-          }),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      }
-
-      if (urlStr.includes("api.open-meteo.com")) {
-        return new Response(
-          JSON.stringify({
-            current: {
-              time: "2025-01-15T08:00",
-              temperature_2m: 20,
-              relative_humidity_2m: 50,
-              apparent_temperature: 19,
-              weather_code: 0,
-              wind_speed_10m: 10,
-              wind_direction_10m: 180,
-            },
-            current_units: {
-              temperature_2m: "°C",
-              relative_humidity_2m: "%",
-              apparent_temperature: "°C",
-              wind_speed_10m: "km/h",
-              wind_direction_10m: "°",
-            },
-            hourly: {
-              time: [],
-              temperature_2m: [],
-              weather_code: [],
-              is_day: [],
-            },
-            hourly_units: {
-              temperature_2m: "°C",
-              weather_code: "wmo code",
-              is_day: "",
-            },
-            daily: {
-              time: [],
-              weather_code: [],
-              temperature_2m_max: [],
-              temperature_2m_min: [],
-              precipitation_probability_max: [],
-            },
-            daily_units: {
-              temperature_2m_max: "°C",
-              temperature_2m_min: "°C",
-              precipitation_probability_max: "%",
-            },
-          }),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      }
-
-      return new Response("Not found", { status: 404 });
-    }) as typeof globalThis.fetch;
-
-    // Temporarily replace globalThis.fetch so the wrapper picks it up
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = mockFetch;
-    try {
-      const result = await mod.run({ location: "TestCity" }, {
-        proxyToolResolver: undefined,
-      } as unknown as ToolContext);
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("TestCity");
-      expect(result.content).toContain("Clear sky");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-});
-
-describe("weather TOOLS.json manifest", () => {
-  const manifest = JSON.parse(
-    readFileSync(join(CONFIG_DIR, "TOOLS.json"), "utf-8"),
-  );
-
-  test("has version 1", () => {
-    expect(manifest.version).toBe(1);
-  });
-
-  test("declares exactly one tool", () => {
-    expect(manifest.tools).toHaveLength(1);
-  });
-
-  test("tool is named get_weather", () => {
-    expect(manifest.tools[0].name).toBe("get_weather");
-  });
-
-  test("tool has correct description", () => {
-    expect(manifest.tools[0].description).toBe(
-      "Get current weather conditions and forecast for a location",
-    );
-  });
-
-  test("tool executor points to the skill script wrapper", () => {
-    expect(manifest.tools[0].executor).toBe("tools/get-weather.ts");
-  });
-
-  test("tool execution_target is host", () => {
-    expect(manifest.tools[0].execution_target).toBe("host");
-  });
-
-  test("input schema matches the legacy tool definition", () => {
-    const schema = manifest.tools[0].input_schema;
-    expect(schema.type).toBe("object");
-    expect(schema.required).toEqual(["location"]);
-
-    // location property
-    expect(schema.properties.location).toBeDefined();
-    expect(schema.properties.location.type).toBe("string");
-
-    // units property
-    expect(schema.properties.units).toBeDefined();
-    expect(schema.properties.units.type).toBe("string");
-    expect(schema.properties.units.enum).toEqual(["celsius", "fahrenheit"]);
-
-    // days property
-    expect(schema.properties.days).toBeDefined();
-    expect(schema.properties.days.type).toBe("number");
-  });
-});
-
-describe("weather service module isolation", () => {
-  test("executeGetWeather is importable without registerTool side effects", async () => {
-    // Importing the service module should NOT call registerTool — only the
-    // legacy get-weather.ts module does that.
-    const mod = await import("../tools/weather/service.js");
-    expect(typeof mod.executeGetWeather).toBe("function");
-    expect(typeof mod.weatherCodeToDescription).toBe("function");
-    expect(typeof mod.weatherCodeToSFSymbol).toBe("function");
-  });
-
-  test("weatherCodeToDescription returns correct values for all major code families", () => {
-    // Clear/cloudy family
-    expect(weatherCodeToDescription(0)).toBe("Clear sky");
-    expect(weatherCodeToDescription(1)).toBe("Mainly clear");
-    expect(weatherCodeToDescription(2)).toBe("Partly cloudy");
-    expect(weatherCodeToDescription(3)).toBe("Overcast");
-
-    // Fog family
-    expect(weatherCodeToDescription(45)).toBe("Foggy");
-    expect(weatherCodeToDescription(48)).toBe("Depositing rime fog");
-
-    // Drizzle family
-    expect(weatherCodeToDescription(51)).toBe("Light drizzle");
-    expect(weatherCodeToDescription(53)).toBe("Moderate drizzle");
-    expect(weatherCodeToDescription(55)).toBe("Dense drizzle");
-
-    // Freezing drizzle
-    expect(weatherCodeToDescription(56)).toBe("Light freezing drizzle");
-    expect(weatherCodeToDescription(57)).toBe("Dense freezing drizzle");
-
-    // Rain family
-    expect(weatherCodeToDescription(61)).toBe("Slight rain");
-    expect(weatherCodeToDescription(63)).toBe("Moderate rain");
-    expect(weatherCodeToDescription(65)).toBe("Heavy rain");
-
-    // Freezing rain
-    expect(weatherCodeToDescription(66)).toBe("Light freezing rain");
-    expect(weatherCodeToDescription(67)).toBe("Heavy freezing rain");
-
-    // Snow family
-    expect(weatherCodeToDescription(71)).toBe("Slight snowfall");
-    expect(weatherCodeToDescription(73)).toBe("Moderate snowfall");
-    expect(weatherCodeToDescription(75)).toBe("Heavy snowfall");
-    expect(weatherCodeToDescription(77)).toBe("Snow grains");
-
-    // Shower family
-    expect(weatherCodeToDescription(80)).toBe("Slight rain showers");
-    expect(weatherCodeToDescription(81)).toBe("Moderate rain showers");
-    expect(weatherCodeToDescription(82)).toBe("Violent rain showers");
-    expect(weatherCodeToDescription(85)).toBe("Slight snow showers");
-    expect(weatherCodeToDescription(86)).toBe("Heavy snow showers");
-
-    // Thunderstorm family
-    expect(weatherCodeToDescription(95)).toBe("Thunderstorm");
-    expect(weatherCodeToDescription(96)).toBe("Thunderstorm with slight hail");
-    expect(weatherCodeToDescription(99)).toBe("Thunderstorm with heavy hail");
-
-    // Unknown codes
-    expect(weatherCodeToDescription(-1)).toBe("Unknown");
-    expect(weatherCodeToDescription(42)).toBe("Unknown");
-    expect(weatherCodeToDescription(100)).toBe("Unknown");
-  });
-
-  test("weatherCodeToSFSymbol returns correct icons and respects isDay", () => {
-    // Day/night variants for clear sky
-    expect(weatherCodeToSFSymbol(0, true)).toBe("sun.max.fill");
-    expect(weatherCodeToSFSymbol(0, false)).toBe("moon.fill");
-
-    // Day/night variants for partly cloudy
-    expect(weatherCodeToSFSymbol(2, true)).toBe("cloud.sun.fill");
-    expect(weatherCodeToSFSymbol(2, false)).toBe("cloud.moon.fill");
-
-    // Overcast has no day/night variant
-    expect(weatherCodeToSFSymbol(3, true)).toBe("cloud.fill");
-    expect(weatherCodeToSFSymbol(3, false)).toBe("cloud.fill");
-
-    // Snow
-    expect(weatherCodeToSFSymbol(75, true)).toBe("snowflake");
-
-    // Thunderstorm
-    expect(weatherCodeToSFSymbol(95, true)).toBe("cloud.bolt.fill");
-
-    // Default isDay=true when omitted
-    expect(weatherCodeToSFSymbol(0)).toBe("sun.max.fill");
-  });
-});