openclaw-server 0.1.0

package/src/weather/location-catalog.ts

@@ -0,0 +1,166 @@
+import type { WeatherLocation } from "./types.js";
+
+type BuiltInWeatherLocation = WeatherLocation & {
+  aliases: string[];
+};
+
+export const builtInWeatherLocations: BuiltInWeatherLocation[] = [
+  {
+    name: "天津",
+    latitude: 39.0851,
+    longitude: 117.1994,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "天津",
+    aliases: ["天津", "天津市", "tianjin"],
+  },
+  {
+    name: "北京",
+    latitude: 39.9042,
+    longitude: 116.4074,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "北京",
+    aliases: ["北京", "北京市", "beijing"],
+  },
+  {
+    name: "上海",
+    latitude: 31.2304,
+    longitude: 121.4737,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "上海",
+    aliases: ["上海", "上海市", "shanghai"],
+  },
+  {
+    name: "重庆",
+    latitude: 29.4316,
+    longitude: 106.9123,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "重庆",
+    aliases: ["重庆", "重庆市", "chongqing"],
+  },
+  {
+    name: "广州",
+    latitude: 23.1291,
+    longitude: 113.2644,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "广东",
+    aliases: ["广州", "广州市", "guangzhou"],
+  },
+  {
+    name: "深圳",
+    latitude: 22.5431,
+    longitude: 114.0579,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "广东",
+    aliases: ["深圳", "深圳市", "shenzhen"],
+  },
+  {
+    name: "成都",
+    latitude: 30.5728,
+    longitude: 104.0668,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "四川",
+    aliases: ["成都", "成都市", "chengdu"],
+  },
+  {
+    name: "杭州",
+    latitude: 30.2741,
+    longitude: 120.1551,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "浙江",
+    aliases: ["杭州", "杭州市", "hangzhou"],
+  },
+  {
+    name: "南京",
+    latitude: 32.0603,
+    longitude: 118.7969,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "江苏",
+    aliases: ["南京", "南京市", "nanjing"],
+  },
+  {
+    name: "武汉",
+    latitude: 30.5928,
+    longitude: 114.3055,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "湖北",
+    aliases: ["武汉", "武汉市", "wuhan"],
+  },
+  {
+    name: "西安",
+    latitude: 34.3416,
+    longitude: 108.9398,
+    timezone: "Asia/Shanghai",
+    country: "CN",
+    admin1: "陕西",
+    aliases: ["西安", "西安市", "xian", "xi an"],
+  },
+  {
+    name: "香港",
+    latitude: 22.3193,
+    longitude: 114.1694,
+    timezone: "Asia/Hong_Kong",
+    country: "HK",
+    admin1: "香港",
+    aliases: ["香港", "hong kong"],
+  },
+  {
+    name: "台北",
+    latitude: 25.033,
+    longitude: 121.5654,
+    timezone: "Asia/Taipei",
+    country: "TW",
+    admin1: "台北",
+    aliases: ["台北", "taipei"],
+  },
+];
+
+function normalizeAlias(text: string): string {
+  return text
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, "");
+}
+
+export function matchBuiltInWeatherLocation(text: string): WeatherLocation | undefined {
+  const normalized = normalizeAlias(text);
+  if (!normalized) {
+    return undefined;
+  }
+
+  let bestMatch: BuiltInWeatherLocation | undefined;
+  let bestLength = 0;
+  for (const location of builtInWeatherLocations) {
+    for (const alias of location.aliases) {
+      const normalizedAlias = normalizeAlias(alias);
+      if (!normalizedAlias || !normalized.includes(normalizedAlias)) {
+        continue;
+      }
+      if (normalizedAlias.length <= bestLength) {
+        continue;
+      }
+      bestMatch = location;
+      bestLength = normalizedAlias.length;
+    }
+  }
+
+  if (!bestMatch) {
+    return undefined;
+  }
+
+  const { aliases: _aliases, ...location } = bestMatch;
+  return location;
+}
+
+export function listBuiltInWeatherAliases(): string[] {
+  return builtInWeatherLocations.flatMap((location) => location.aliases);
+}

package/src/weather/open-meteo-provider.ts

@@ -0,0 +1,221 @@
+import { matchBuiltInWeatherLocation } from "./location-catalog.js";
+import type { WeatherDay, WeatherForecast, WeatherLocation, WeatherProvider } from "./types.js";
+
+type FetchLike = typeof fetch;
+
+type OpenMeteoGeocodeResponse = {
+  results?: Array<{
+    name?: string;
+    latitude?: number;
+    longitude?: number;
+    timezone?: string;
+    country_code?: string;
+    admin1?: string;
+  }>;
+};
+
+type OpenMeteoForecastResponse = {
+  daily?: {
+    time?: string[];
+    weather_code?: number[];
+    temperature_2m_max?: number[];
+    temperature_2m_min?: number[];
+    precipitation_probability_max?: number[];
+    precipitation_sum?: number[];
+  };
+};
+
+function dayOffset(day: WeatherDay): number {
+  switch (day) {
+    case "today":
+      return 0;
+    case "tomorrow":
+      return 1;
+    case "day_after_tomorrow":
+      return 2;
+    case "in_three_days":
+      return 3;
+  }
+}
+
+function dayLabel(day: WeatherDay): string {
+  switch (day) {
+    case "today":
+      return "今天";
+    case "tomorrow":
+      return "明天";
+    case "day_after_tomorrow":
+      return "后天";
+    case "in_three_days":
+      return "大后天";
+  }
+}
+
+function describeWeatherCode(code: number | undefined): string {
+  switch (code) {
+    case 0:
+      return "晴";
+    case 1:
+      return "晴间多云";
+    case 2:
+      return "多云";
+    case 3:
+      return "阴";
+    case 45:
+    case 48:
+      return "有雾";
+    case 51:
+    case 53:
+    case 55:
+      return "毛毛雨";
+    case 56:
+    case 57:
+      return "冻毛毛雨";
+    case 61:
+    case 63:
+    case 65:
+      return "有雨";
+    case 66:
+    case 67:
+      return "冻雨";
+    case 71:
+    case 73:
+    case 75:
+      return "有雪";
+    case 77:
+      return "阵雪";
+    case 80:
+    case 81:
+    case 82:
+      return "阵雨";
+    case 85:
+    case 86:
+      return "阵雪";
+    case 95:
+      return "雷暴";
+    case 96:
+    case 99:
+      return "强对流";
+    default:
+      return "天气多变";
+  }
+}
+
+async function readJson<T>(response: Response): Promise<T> {
+  if (!response.ok) {
+    throw new Error(`Weather upstream failed with status ${response.status}`);
+  }
+  return (await response.json()) as T;
+}
+
+function renderLocationName(location: WeatherLocation): string {
+  if (location.admin1 && location.admin1 !== location.name) {
+    return `${location.name}`;
+  }
+  return location.name;
+}
+
+export class OpenMeteoWeatherProvider implements WeatherProvider {
+  constructor(
+    private readonly options: {
+      fetchImpl?: FetchLike;
+      geocodingBaseUrl?: string;
+      forecastBaseUrl?: string;
+      timeoutMs?: number;
+    } = {},
+  ) {}
+
+  async lookupForecast(params: {
+    locationQuery: string;
+    day: WeatherDay;
+  }): Promise<WeatherForecast> {
+    const location = await this.resolveLocation(params.locationQuery);
+    const offset = dayOffset(params.day);
+    const forecastUrl = new URL(
+      this.options.forecastBaseUrl ?? "https://api.open-meteo.com/v1/forecast",
+    );
+    forecastUrl.searchParams.set("latitude", String(location.latitude));
+    forecastUrl.searchParams.set("longitude", String(location.longitude));
+    forecastUrl.searchParams.set(
+      "daily",
+      "weather_code,temperature_2m_max,temperature_2m_min,precipitation_probability_max,precipitation_sum",
+    );
+    forecastUrl.searchParams.set("forecast_days", String(offset + 1));
+    forecastUrl.searchParams.set("timezone", location.timezone || "auto");
+
+    const forecast = await this.fetchJson<OpenMeteoForecastResponse>(forecastUrl);
+    const daily = forecast.daily;
+    const localDate = daily?.time?.[offset];
+    const temperatureMax = daily?.temperature_2m_max?.[offset];
+    const temperatureMin = daily?.temperature_2m_min?.[offset];
+    if (
+      !localDate ||
+      temperatureMax === undefined ||
+      temperatureMin === undefined
+    ) {
+      throw new Error(`Missing ${dayLabel(params.day)} weather data for ${params.locationQuery}`);
+    }
+
+    return {
+      day: params.day,
+      localDate,
+      summary: describeWeatherCode(daily?.weather_code?.[offset]),
+      temperatureMin,
+      temperatureMax,
+      precipitationProbabilityMax: daily?.precipitation_probability_max?.[offset],
+      precipitationSum: daily?.precipitation_sum?.[offset],
+      location: {
+        ...location,
+        name: renderLocationName(location),
+      },
+      source: "open-meteo",
+    };
+  }
+
+  private async resolveLocation(locationQuery: string): Promise<WeatherLocation> {
+    const builtIn = matchBuiltInWeatherLocation(locationQuery);
+    if (builtIn) {
+      return builtIn;
+    }
+
+    const geocodeUrl = new URL(
+      this.options.geocodingBaseUrl ?? "https://geocoding-api.open-meteo.com/v1/search",
+    );
+    geocodeUrl.searchParams.set("name", locationQuery.trim());
+    geocodeUrl.searchParams.set("count", "5");
+    geocodeUrl.searchParams.set("language", "zh");
+    geocodeUrl.searchParams.set("format", "json");
+
+    const geocode = await this.fetchJson<OpenMeteoGeocodeResponse>(geocodeUrl);
+    const result = geocode.results?.find(
+      (item) =>
+        typeof item.name === "string" &&
+        typeof item.latitude === "number" &&
+        typeof item.longitude === "number",
+    );
+    if (!result || !result.name) {
+      throw new Error(`Location not found: ${locationQuery}`);
+    }
+
+    return {
+      name: result.name,
+      latitude: result.latitude!,
+      longitude: result.longitude!,
+      timezone: result.timezone,
+      country: result.country_code,
+      admin1: result.admin1,
+    };
+  }
+
+  private async fetchJson<T>(url: URL): Promise<T> {
+    const fetchImpl = this.options.fetchImpl ?? globalThis.fetch;
+    const timeoutMs = this.options.timeoutMs ?? 8_000;
+    const response = await fetchImpl(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: {
+        Accept: "application/json",
+      },
+    });
+    return readJson<T>(response);
+  }
+}

package/src/weather/parser.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { extractWeatherDay, extractWeatherLocation, parseWeatherQuery } from "./parser.js";
+
+describe("weather parser", () => {
+  it("parses a city and day from direct Chinese weather queries", () => {
+    const query = parseWeatherQuery("天津明天天气如何");
+    expect(query.isWeatherQuery).toBe(true);
+    expect(query.location).toBe("天津");
+    expect(query.day).toBe("tomorrow");
+  });
+
+  it("keeps day parsing even when only the date is provided", () => {
+    expect(extractWeatherDay("明天")).toBe("tomorrow");
+    expect(extractWeatherLocation("明天")).toBeUndefined();
+  });
+
+  it("extracts English city names from weather prompts", () => {
+    const query = parseWeatherQuery("weather in tianjin tomorrow");
+    expect(query.isWeatherQuery).toBe(true);
+    expect(query.location).toBe("tianjin");
+    expect(query.day).toBe("tomorrow");
+  });
+});

package/src/weather/parser.ts

@@ -0,0 +1,102 @@
+import { listBuiltInWeatherAliases } from "./location-catalog.js";
+import type { WeatherDay, WeatherQuery } from "./types.js";
+
+const WEATHER_HINT_PATTERN =
+  /(天气预报|天气情况|天气|气温|温度|weather forecast|forecast|weather|temperature|rain|snow)/iu;
+
+const DAY_PATTERNS: Array<{ pattern: RegExp; day: WeatherDay }> = [
+  { pattern: /大后天/iu, day: "in_three_days" },
+  { pattern: /后天|day after tomorrow|the day after tomorrow/iu, day: "day_after_tomorrow" },
+  { pattern: /明天|tomorrow/iu, day: "tomorrow" },
+  { pattern: /今天|today/iu, day: "today" },
+];
+
+function cleanupCandidate(text: string): string {
+  return text
+    .normalize("NFKC")
+    .replace(
+      /(帮我|帮忙|麻烦你|麻烦|请问|问下|问问|查一下|查查|查个|查|看下|看看|想知道|我想知道|告诉我一下|告诉我|请帮我|请帮忙)/giu,
+      " ",
+    )
+    .replace(
+      /(天气预报|天气情况|天气怎么样|天气如何|天气咋样|天气怎样|天气|气温|温度|weather forecast|forecast|weather|temperature)/giu,
+      " ",
+    )
+    .replace(/(今天|明天|后天|大后天|today|tomorrow|day after tomorrow|the day after tomorrow)/giu, " ")
+    .replace(/(如何|怎么样|咋样|怎样|情况|会不会下雨|下雨吗|下雪吗|会下雪吗|多少度)/giu, " ")
+    .replace(/\b(in|for|at|on)\b/giu, " ")
+    .replace(/[?？!！,，.。:："'`]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function extractLocationFromCatalog(text: string): string | undefined {
+  const normalized = text
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, "");
+  if (!normalized) {
+    return undefined;
+  }
+
+  let bestMatch = "";
+  for (const alias of listBuiltInWeatherAliases()) {
+    const normalizedAlias = alias
+      .normalize("NFKC")
+      .toLowerCase()
+      .replace(/[^\p{L}\p{N}]+/gu, "");
+    if (!normalizedAlias || !normalized.includes(normalizedAlias)) {
+      continue;
+    }
+    if (normalizedAlias.length <= bestMatch.length) {
+      continue;
+    }
+    bestMatch = alias;
+  }
+
+  return bestMatch || undefined;
+}
+
+function extractLooseLocation(text: string): string | undefined {
+  const candidate = cleanupCandidate(text);
+  if (!candidate) {
+    return undefined;
+  }
+
+  const chineseChunks = candidate.match(/[\u3400-\u9fff]{2,12}(?:市|区|县|州|省)?/gu);
+  if (chineseChunks?.length) {
+    return chineseChunks.sort((left, right) => right.length - left.length)[0]?.trim();
+  }
+
+  const english = candidate
+    .replace(/\b(the|city|forecast|weather)\b/giu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!english) {
+    return undefined;
+  }
+
+  return english;
+}
+
+export function extractWeatherDay(text: string): WeatherDay | undefined {
+  for (const item of DAY_PATTERNS) {
+    if (item.pattern.test(text)) {
+      return item.day;
+    }
+  }
+  return undefined;
+}
+
+export function extractWeatherLocation(text: string): string | undefined {
+  return extractLocationFromCatalog(text) ?? extractLooseLocation(text);
+}
+
+export function parseWeatherQuery(text: string): WeatherQuery {
+  const isWeatherQuery = WEATHER_HINT_PATTERN.test(text);
+  return {
+    isWeatherQuery,
+    location: extractWeatherLocation(text),
+    day: extractWeatherDay(text),
+  };
+}

package/src/weather/service.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from "vitest";
+import { WeatherService } from "./service.js";
+import type { WeatherProvider } from "./types.js";
+
+function createProvider(): WeatherProvider {
+  return {
+    lookupForecast: vi.fn().mockResolvedValue({
+      day: "tomorrow",
+      localDate: "2026-03-13",
+      summary: "多云",
+      temperatureMin: 4,
+      temperatureMax: 12,
+      precipitationProbabilityMax: 20,
+      location: {
+        name: "天津",
+        latitude: 39.0851,
+        longitude: 117.1994,
+        timezone: "Asia/Shanghai",
+      },
+      source: "open-meteo",
+    }),
+  };
+}
+
+describe("WeatherService", () => {
+  it("asks for the missing day before looking up weather", async () => {
+    const provider = createProvider();
+    const service = new WeatherService(provider);
+
+    const firstInspection = service.inspectMessage({ userId: "u1", text: "天津天气怎么样" });
+    expect(firstInspection.shouldHandle).toBe(true);
+    expect(firstInspection.missing).toBe("day");
+
+    const firstReply = await service.processMessage({ userId: "u1", text: "天津天气怎么样" });
+    expect(firstReply.intent).toBe("clarify");
+    expect(firstReply.reply).toContain("天津");
+    expect(provider.lookupForecast).not.toHaveBeenCalled();
+
+    const secondReply = await service.processMessage({ userId: "u1", text: "明天" });
+    expect(secondReply.intent).toBe("weather_forecast");
+    expect(secondReply.reply).toContain("天津明天多云");
+    expect(provider.lookupForecast).toHaveBeenCalledWith({
+      locationQuery: "天津",
+      day: "tomorrow",
+    });
+  });
+
+  it("asks for both slots when the user only asks about weather", async () => {
+    const service = new WeatherService(createProvider());
+    const reply = await service.processMessage({ userId: "u2", text: "天气怎么样" });
+    expect(reply.intent).toBe("clarify");
+    expect(reply.reply).toContain("哪个城市");
+  });
+});