koishi-plugin-disaster-warning 0.1.3 → 0.1.4

package/README.md

@@ -30,6 +30,9 @@ Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警
 ### 🔁 事件去重功能
 插件具备基础的事件去重功能，防止同一地震被同一个数据源重复推送。
 
+### 🤖 ChatLuna 工具调用
+可选注册 `disaster_warning` 工具给 ChatLuna 使用，让模型主动查询近期地震、按地点/震级/时间过滤，或查看数据源连接状态。适合回答“哪里地震了”“某地最近有没有地震”“我关心的人在某地，那里安全吗”等问题。
+
 ## 🚀 安装与使用
 
 ### 安装
@@ -54,7 +57,33 @@ npm install koishi-plugin-disaster-warning
 
 `regions` 同时控制数据源连接与地震震中地区过滤。例如仅开启中国大陆和台湾、关闭日本与全球时，插件仍可连接 CENC/CWA 等相关数据源，但智利、印尼等不在已开启地区内的地震会被丢弃，不会因为由 CENC 发布就被推送。
 
-当前震中识别优先使用地名关键词，其次使用经纬度范围；无法识别且带有非空地名的地震默认视为全球事件。
+当前震中识别优先使用地名关键词，其次使用经纬度范围；无法识别且带有非空地名的地震默认视为全球事件。
+
+### ChatLuna 工具设置
+
+如果安装了 `koishi-plugin-chatluna`，可以在 `chatluna` 配置项中开启工具注册：
+
+- `chatluna.enabled`：开启后注册 ChatLuna 工具，默认关闭。
+- `chatluna.name`：工具名称，默认 `disaster_warning`。
+- `chatluna.default_source`：模型未指定来源时查询 `all`、`cenc`、`jma` 或 `usgs`。
+- `chatluna.default_days`：默认查询最近多少天。
+- `chatluna.default_limit`：默认最多返回多少条记录。
+- `chatluna.min_magnitude`：默认最低震级。
+- `chatluna.include_usgs_when_all`：综合查询时是否包含 USGS 全球地震。
+
+工具输入示例：
+
+```json
+{
+  "action": "recent_earthquakes",
+  "location": "智利",
+  "min_magnitude": 5,
+  "days": 7,
+  "limit": 5
+}
+```
+
+也可以使用 `{ "action": "status" }` 查询当前数据源连接状态。
 
 ## 📋 使用命令
 

package/lib/chatluna.d.ts

@@ -0,0 +1,41 @@
+import { Context } from 'koishi';
+import { StructuredTool } from '@langchain/core/tools';
+import type { Config } from './index';
+import { DisasterWarningService } from './service';
+type ToolSource = 'all' | 'cenc' | 'jma' | 'usgs';
+type ToolInput = {
+    action?: 'recent_earthquakes' | 'status';
+    source?: ToolSource;
+    location?: string;
+    min_magnitude?: number;
+    days?: number;
+    limit?: number;
+};
+interface ChatLunaToolConfig {
+    enabled: boolean;
+    name: string;
+    description: string;
+    default_source: ToolSource;
+    default_limit: number;
+    default_days: number;
+    min_magnitude: number;
+    include_usgs_when_all: boolean;
+}
+export declare class DisasterWarningTool extends StructuredTool<any, ToolInput, ToolInput, string> {
+    private ctx;
+    private config;
+    private service;
+    name: string;
+    description: string;
+    schema: any;
+    constructor(ctx: Context, config: Config, service: DisasterWarningService);
+    _call(input: ToolInput): Promise<string>;
+    private formatStatus;
+    private queryRecentEarthquakes;
+    private fetchSource;
+    private fetchWolfxList;
+    private fetchUsgs;
+}
+export declare function applyChatLunaTools(ctx: Context, config: Config, service: DisasterWarningService): void;
+export declare function getChatLunaConfig(config: Config): ChatLunaToolConfig;
+export {};

package/lib/chatluna.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisasterWarningTool = void 0;
+exports.applyChatLunaTools = applyChatLunaTools;
+exports.getChatLunaConfig = getChatLunaConfig;
+const koishi_1 = require("koishi");
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const logger = new koishi_1.Logger('disaster-chatluna');
+const sourceSchema = zod_1.z.enum(['all', 'cenc', 'jma', 'usgs']);
+const actionSchema = zod_1.z.enum(['recent_earthquakes', 'status']);
+const toolSchema = zod_1.z.object({
+    action: actionSchema.optional().describe('操作类型：recent_earthquakes 查询近期地震，status 查询数据源连接状态。默认 recent_earthquakes。'),
+    source: sourceSchema.optional().describe('数据源：all 综合查询，cenc 中国地震台网列表，jma 日本气象厅列表，usgs USGS 全球地震。默认使用插件配置。'),
+    location: zod_1.z.string().optional().describe('可选，地点关键词、国家、地区或城市，例如“四川”“台湾”“日本”“智利”“Chile”。'),
+    min_magnitude: zod_1.z.number().min(0).max(10).optional().describe('可选，最低震级，默认使用插件配置。'),
+    days: zod_1.z.number().int().min(1).max(30).optional().describe('可选，查询最近多少天，默认使用插件配置，最多 30 天。'),
+    limit: zod_1.z.number().int().min(1).max(50).optional().describe('可选，最多返回多少条地震记录，默认使用插件配置。')
+});
+const DEFAULT_CHATLUNA_CONFIG = {
+    enabled: false,
+    name: 'disaster_warning',
+    description: '查询近期地震和灾害预警数据源状态，可按地点、震级、时间范围过滤。适合回答“哪里地震了”“某地最近有没有地震”“关心的人所在地区是否有地震”等问题。',
+    default_source: 'all',
+    default_limit: 8,
+    default_days: 7,
+    min_magnitude: 4,
+    include_usgs_when_all: true
+};
+class DisasterWarningTool extends tools_1.StructuredTool {
+    constructor(ctx, config, service) {
+        super({});
+        this.ctx = ctx;
+        this.config = config;
+        this.service = service;
+        this.schema = toolSchema;
+        const cfg = getChatLunaConfig(config);
+        this.name = normalizeToolName(cfg.name);
+        this.description = cfg.description.trim() || DEFAULT_CHATLUNA_CONFIG.description;
+    }
+    async _call(input) {
+        const action = input.action || 'recent_earthquakes';
+        try {
+            if (action === 'status') {
+                return JSON.stringify(this.formatStatus(), null, 2);
+            }
+            const cfg = getChatLunaConfig(this.config);
+            const options = {
+                source: input.source || cfg.default_source,
+                location: input.location?.trim() || undefined,
+                minMagnitude: input.min_magnitude ?? cfg.min_magnitude,
+                days: clamp(input.days ?? cfg.default_days, 1, 30),
+                limit: clamp(input.limit ?? cfg.default_limit, 1, 50)
+            };
+            const result = await this.queryRecentEarthquakes(options);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.warn(`ChatLuna tool call failed: ${message}`);
+            return `灾害预警查询失败：${message}`;
+        }
+    }
+    formatStatus() {
+        const status = this.service.getStatus();
+        return {
+            type: 'disaster_warning_status',
+            generated_at: new Date().toISOString(),
+            sources: Object.entries(status).map(([name, item]) => ({
+                name,
+                connected: item.connected,
+                retry_count: item.retryCount,
+                url: item.url
+            }))
+        };
+    }
+    async queryRecentEarthquakes(options) {
+        const cfg = getChatLunaConfig(this.config);
+        const sources = expandSources(options.source, cfg.include_usgs_when_all);
+        const settled = await Promise.allSettled(sources.map((source) => this.fetchSource(source, options)));
+        const errors = [];
+        const records = [];
+        settled.forEach((item, index) => {
+            const source = sources[index];
+            if (item.status === 'fulfilled') {
+                records.push(...item.value);
+            }
+            else {
+                const message = item.reason instanceof Error ? item.reason.message : String(item.reason);
+                errors.push({ source, message });
+            }
+        });
+        const terms = buildSearchTerms(options.location);
+        const filtered = records
+            .filter((record) => record.magnitude === undefined || record.magnitude >= options.minMagnitude)
+            .filter((record) => isWithinDays(record.time, options.days))
+            .filter((record) => matchesLocation(record, terms))
+            .sort((a, b) => timeValue(b.time) - timeValue(a.time))
+            .slice(0, options.limit);
+        return compact({
+            type: 'recent_earthquakes',
+            generated_at: new Date().toISOString(),
+            query: {
+                source: options.source,
+                expanded_sources: sources,
+                location: options.location,
+                min_magnitude: options.minMagnitude,
+                days: options.days,
+                limit: options.limit
+            },
+            count: filtered.length,
+            earthquakes: filtered,
+            errors: errors.length ? errors : undefined,
+            note: '地震查询工具用于对话查询，不会改变群推送过滤配置。regions.global 关闭时仍可通过工具主动查询全球地震。'
+        });
+    }
+    fetchSource(source, options) {
+        if (source === 'cenc')
+            return this.fetchWolfxList('cenc');
+        if (source === 'jma')
+            return this.fetchWolfxList('jma');
+        if (source === 'usgs')
+            return this.fetchUsgs(options);
+        return Promise.resolve([]);
+    }
+    async fetchWolfxList(type) {
+        const cache = this.service.getEqListCache();
+        let data = cache[type];
+        if (!data || Object.keys(data).length === 0) {
+            const url = type === 'cenc'
+                ? 'https://api.wolfx.jp/cenc_eqlist.json'
+                : 'https://api.wolfx.jp/jma_eqlist.json';
+            data = await this.ctx.http.get(url);
+        }
+        const keys = Object.keys(data || {})
+            .filter((key) => /^No\d+$/.test(key))
+            .sort((a, b) => Number(a.slice(2)) - Number(b.slice(2)));
+        return keys
+            .map((key) => parseWolfxRecord(type, data[key]))
+            .filter((record) => Boolean(record));
+    }
+    async fetchUsgs(options) {
+        const url = new URL('https://earthquake.usgs.gov/fdsnws/event/1/query');
+        url.searchParams.set('format', 'geojson');
+        url.searchParams.set('orderby', 'time');
+        url.searchParams.set('starttime', new Date(Date.now() - options.days * 86400000).toISOString());
+        url.searchParams.set('minmagnitude', String(options.minMagnitude));
+        url.searchParams.set('limit', String(Math.min(Math.max(options.limit * 5, 50), 200)));
+        const data = await this.ctx.http.get(url.toString());
+        const features = Array.isArray(data?.features) ? data.features : [];
+        return features.map(parseUsgsFeature).filter((record) => Boolean(record));
+    }
+}
+exports.DisasterWarningTool = DisasterWarningTool;
+function applyChatLunaTools(ctx, config, service) {
+    ctx.on('ready', () => {
+        const cfg = getChatLunaConfig(config);
+        if (!cfg.enabled)
+            return;
+        const chatluna = ctx.chatluna;
+        if (!chatluna?.platform?.registerTool) {
+            logger.warn('未检测到 ChatLuna 服务，跳过注册灾害预警工具。');
+            return;
+        }
+        const toolName = normalizeToolName(cfg.name);
+        ctx.effect(() => chatluna.platform.registerTool(toolName, {
+            description: cfg.description.trim() || DEFAULT_CHATLUNA_CONFIG.description,
+            selector() {
+                return true;
+            },
+            createTool() {
+                return new DisasterWarningTool(ctx, config, service);
+            },
+            meta: {
+                source: 'extension',
+                group: 'disaster-warning',
+                tags: ['disaster', 'earthquake', 'warning'],
+                defaultAvailability: {
+                    enabled: true,
+                    main: true,
+                    chatluna: true,
+                    characterScope: 'all'
+                }
+            }
+        }));
+        logger.info(`已注册 ChatLuna 灾害预警工具：${toolName}`);
+    });
+}
+function getChatLunaConfig(config) {
+    return {
+        ...DEFAULT_CHATLUNA_CONFIG,
+        ...(config.chatluna || {})
+    };
+}
+function normalizeToolName(name) {
+    const normalized = (name || DEFAULT_CHATLUNA_CONFIG.name).trim();
+    return normalized || DEFAULT_CHATLUNA_CONFIG.name;
+}
+function expandSources(source, includeUsgsWhenAll) {
+    if (source !== 'all')
+        return [source];
+    return includeUsgsWhenAll ? ['cenc', 'jma', 'usgs'] : ['cenc', 'jma'];
+}
+function parseWolfxRecord(type, item) {
+    if (!item || typeof item !== 'object')
+        return null;
+    const magnitude = toNumber(item.magnitude);
+    return compact({
+        source: type,
+        source_name: type === 'cenc' ? 'CENC 中国地震台网' : 'JMA 日本气象厅',
+        id: item.md5 || item.id,
+        time: normalizeTime(item.time),
+        location: item.location || item.hypocenter || '',
+        magnitude,
+        depth_km: parseDepth(item.depth),
+        intensity: item.intensity ? String(item.intensity) : undefined,
+        scale: item.shindo ? String(item.shindo) : undefined,
+        latitude: toNumber(item.latitude),
+        longitude: toNumber(item.longitude)
+    });
+}
+function parseUsgsFeature(feature) {
+    const props = feature?.properties || {};
+    const coordinates = feature?.geometry?.coordinates || [];
+    if (!props.place && props.mag === undefined)
+        return null;
+    return compact({
+        source: 'usgs',
+        source_name: 'USGS',
+        id: feature.id,
+        time: props.time ? new Date(props.time).toISOString() : undefined,
+        location: props.place || '',
+        magnitude: toNumber(props.mag),
+        depth_km: toNumber(coordinates[2]),
+        latitude: toNumber(coordinates[1]),
+        longitude: toNumber(coordinates[0]),
+        url: props.url
+    });
+}
+function normalizeTime(value) {
+    if (!value)
+        return undefined;
+    const text = String(value).trim();
+    const date = new Date(text.replace(/\//g, '-'));
+    if (!Number.isFinite(date.getTime()))
+        return text;
+    return date.toISOString();
+}
+function parseDepth(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const match = String(value).match(/-?\d+(?:\.\d+)?/);
+    return match ? Number(match[0]) : undefined;
+}
+function toNumber(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const num = Number(value);
+    return Number.isFinite(num) ? num : undefined;
+}
+function isWithinDays(time, days) {
+    const value = timeValue(time);
+    if (!value)
+        return true;
+    return value >= Date.now() - days * 86400000;
+}
+function timeValue(time) {
+    if (!time)
+        return 0;
+    const value = new Date(time).getTime();
+    return Number.isFinite(value) ? value : 0;
+}
+function matchesLocation(record, terms) {
+    if (!terms.length)
+        return true;
+    const haystack = normalizeText([
+        record.location,
+        record.source_name,
+        record.latitude,
+        record.longitude
+    ].filter((item) => item !== undefined).join(' '));
+    return terms.some((term) => haystack.includes(term));
+}
+function buildSearchTerms(location) {
+    if (!location)
+        return [];
+    const base = normalizeText(location);
+    const aliases = {
+        '智利': ['chile'],
+        '印尼': ['indonesia'],
+        '印度尼西亚': ['indonesia'],
+        '菲律宾': ['philippines'],
+        '秘鲁': ['peru'],
+        '墨西哥': ['mexico'],
+        '阿根廷': ['argentina'],
+        '土耳其': ['turkey'],
+        '希腊': ['greece'],
+        '俄罗斯': ['russia'],
+        '美国': ['unitedstates', 'usa'],
+        '阿拉斯加': ['alaska'],
+        '加州': ['california'],
+        '新西兰': ['newzealand'],
+        '巴布亚': ['papua'],
+        '汤加': ['tonga'],
+        '斐济': ['fiji'],
+        '瓦努阿图': ['vanuatu'],
+        '日本': ['japan'],
+        '台湾': ['taiwan', '臺灣', '台灣'],
+        '中国': ['china'],
+        '四川': ['sichuan'],
+        '云南': ['yunnan'],
+        '西藏': ['tibet', 'xizang'],
+        '新疆': ['xinjiang'],
+        '青海': ['qinghai'],
+        '甘肃': ['gansu']
+    };
+    const terms = new Set([base]);
+    for (const [key, values] of Object.entries(aliases)) {
+        if (base.includes(normalizeText(key))) {
+            values.forEach((value) => terms.add(normalizeText(value)));
+        }
+    }
+    return Array.from(terms).filter(Boolean);
+}
+function normalizeText(value) {
+    return String(value ?? '').toLowerCase().replace(/[\s,，、()（）-]/g, '');
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function compact(value) {
+    if (Array.isArray(value))
+        return value.map((item) => compact(item));
+    if (!value || typeof value !== 'object')
+        return value;
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === undefined || item === null || item === '')
+            continue;
+        const next = compact(item);
+        if (Array.isArray(next) && next.length === 0)
+            continue;
+        out[key] = next;
+    }
+    return out;
+}

package/lib/index.d.ts

@@ -24,6 +24,16 @@ export interface Config {
         min_intensity_for_push: number;
         min_scale_for_push: number;
     };
+    chatluna: {
+        enabled: boolean;
+        name: string;
+        description: string;
+        default_source: 'all' | 'cenc' | 'jma' | 'usgs';
+        default_limit: number;
+        default_days: number;
+        min_magnitude: number;
+        include_usgs_when_all: boolean;
+    };
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -5,10 +5,11 @@ exports.apply = apply;
 const koishi_1 = require("koishi");
 const service_1 = require("./service");
 const commands_1 = require("./commands");
+const chatluna_1 = require("./chatluna");
 exports.name = 'disaster-warning';
 exports.inject = {
     required: ['http'],
-    optional: ['database']
+    optional: ['database', 'chatluna']
 };
 exports.Config = koishi_1.Schema.object({
     target_groups: koishi_1.Schema.array(koishi_1.Schema.string())
@@ -32,10 +33,26 @@ exports.Config = koishi_1.Schema.object({
         min_intensity_for_push: koishi_1.Schema.number().default(4.0).description('推送烈度门槛（中国）：最大烈度达到此值则推送'),
         min_scale_for_push: koishi_1.Schema.number().default(4.0).description('推送震度门槛（日本）：最大震度达到此值则推送（4 = 震度4）'),
     }).description('过滤阈值（地震类事件，海啸/气象不受此限制）'),
+    chatluna: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().default(false).description('开启后注册 ChatLuna 工具，供模型主动查询近期地震与数据源状态'),
+        name: koishi_1.Schema.string().default('disaster_warning').description('ChatLuna 工具名称'),
+        description: koishi_1.Schema.string().default('查询近期地震和灾害预警数据源状态，可按地点、震级、时间范围过滤。适合回答“哪里地震了”“某地最近有没有地震”“关心的人所在地区是否有地震”等问题。').description('ChatLuna 工具描述'),
+        default_source: koishi_1.Schema.union([
+            koishi_1.Schema.const('all').description('综合 CENC / JMA / USGS'),
+            koishi_1.Schema.const('cenc').description('中国地震台网 / Wolfx CENC'),
+            koishi_1.Schema.const('jma').description('日本气象厅 / Wolfx JMA'),
+            koishi_1.Schema.const('usgs').description('USGS 全球地震')
+        ]).default('all').description('模型未指定数据源时的默认查询源'),
+        default_limit: koishi_1.Schema.number().default(8).min(1).max(50).description('模型未指定 limit 时最多返回多少条'),
+        default_days: koishi_1.Schema.number().default(7).min(1).max(30).description('模型未指定 days 时查询最近多少天'),
+        min_magnitude: koishi_1.Schema.number().default(4.0).min(0).max(10).description('模型未指定 min_magnitude 时的最低震级'),
+        include_usgs_when_all: koishi_1.Schema.boolean().default(true).description('default_source/all 查询时是否包含 USGS 全球地震')
+    }).description('ChatLuna 工具调用'),
 });
 function apply(ctx, config) {
     const service = new service_1.DisasterWarningService(ctx, config);
     ctx.on('ready', () => service.start());
     ctx.on('dispose', () => service.stop());
     (0, commands_1.applyCommands)(ctx, config, service);
+    (0, chatluna_1.applyChatLunaTools)(ctx, config, service);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koishi-plugin-disaster-warning",
-    "version": "0.1.3",
+    "version": "0.1.4",
     "description": "Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）",
     "contributors": [
         "lumia.wang <fenglian19980510@gmail.com>"
@@ -27,12 +27,14 @@
         "chatbot",
         "koishi",
         "plugin",
+        "chatluna",
         "disaster",
         "earthquake",
         "warning"
     ],
     "peerDependencies": {
-        "koishi": "^4.18.0"
+        "koishi": "^4.18.0",
+        "koishi-plugin-chatluna": "^1.3.0 || ^1.4.0-alpha.0"
     },
     "devDependencies": {
         "@types/node": "^20.0.0",
@@ -50,11 +52,19 @@
                 "http"
             ],
             "optional": [
-                "database"
+                "database",
+                "chatluna"
             ]
         }
     },
     "dependencies": {
-        "ws": "^8.18.0"
+        "@langchain/core": "^0.3.80",
+        "ws": "^8.18.0",
+        "zod": "^3.25.76"
+    },
+    "peerDependenciesMeta": {
+        "koishi-plugin-chatluna": {
+            "optional": true
+        }
     }
 }