mcp-swiss 0.1.0

package/dist/modules/geodata.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geodataTools = void 0;
+exports.handleGeodata = handleGeodata;
+const http_js_1 = require("../utils/http.js");
+const BASE = "https://api3.geo.admin.ch";
+exports.geodataTools = [
+    {
+        name: "geocode",
+        description: "Convert a Swiss address or place name to coordinates (swisstopo)",
+        inputSchema: {
+            type: "object",
+            required: ["address"],
+            properties: {
+                address: { type: "string", description: "Swiss address or place name" },
+            },
+        },
+    },
+    {
+        name: "reverse_geocode",
+        description: "Convert coordinates to a Swiss address (swisstopo)",
+        inputSchema: {
+            type: "object",
+            required: ["lat", "lng"],
+            properties: {
+                lat: { type: "number", description: "Latitude (WGS84)" },
+                lng: { type: "number", description: "Longitude (WGS84)" },
+            },
+        },
+    },
+    {
+        name: "search_places",
+        description: "Search Swiss place names, localities, mountains, and geographic features",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string", description: "Place name to search" },
+                type: { type: "string", description: "Type filter: locations, featuresearch" },
+            },
+        },
+    },
+    {
+        name: "get_solar_potential",
+        description: "Get rooftop solar energy potential for a location in Switzerland",
+        inputSchema: {
+            type: "object",
+            required: ["lat", "lng"],
+            properties: {
+                lat: { type: "number", description: "Latitude (WGS84)" },
+                lng: { type: "number", description: "Longitude (WGS84)" },
+            },
+        },
+    },
+    {
+        name: "identify_location",
+        description: "Identify geographic features and data layers at a specific Swiss location",
+        inputSchema: {
+            type: "object",
+            required: ["lat", "lng"],
+            properties: {
+                lat: { type: "number", description: "Latitude (WGS84)" },
+                lng: { type: "number", description: "Longitude (WGS84)" },
+                layers: { type: "string", description: "Comma-separated layer ids (default: all visible)" },
+            },
+        },
+    },
+    {
+        name: "get_municipality",
+        description: "Get information about a Swiss municipality by name",
+        inputSchema: {
+            type: "object",
+            required: ["name"],
+            properties: {
+                name: { type: "string", description: "Municipality name" },
+            },
+        },
+    },
+];
+// Convert WGS84 to LV95 (Swiss projection) — approximate
+function wgs84ToLV95(lat, lng) {
+    // Approx conversion for API calls that need Swiss coords
+    const phiPrime = (lat * 3600 - 169028.66) / 10000;
+    const lambdaPrime = (lng * 3600 - 26782.5) / 10000;
+    const E = 2600072.37
+        + 211455.93 * lambdaPrime
+        - 10938.51 * lambdaPrime * phiPrime
+        - 0.36 * lambdaPrime * phiPrime ** 2
+        - 44.54 * lambdaPrime ** 3;
+    const N = 1200147.07
+        + 308807.95 * phiPrime
+        + 3745.25 * lambdaPrime ** 2
+        + 76.63 * phiPrime ** 2
+        - 194.56 * lambdaPrime ** 2 * phiPrime
+        + 119.79 * phiPrime ** 3;
+    return { x: E, y: N };
+}
+async function handleGeodata(name, args) {
+    switch (name) {
+        case "geocode":
+        case "search_places": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/rest/services/api/SearchServer`, {
+                searchText: args.address ?? args.query,
+                type: args.type ?? "locations",
+                sr: 4326,
+                limit: 10,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "reverse_geocode": {
+            const lat = args.lat;
+            const lng = args.lng;
+            const { x, y } = wgs84ToLV95(lat, lng);
+            const extent = `${x - 100},${y - 100},${x + 100},${y + 100}`;
+            const url = (0, http_js_1.buildUrl)(`${BASE}/rest/services/api/SearchServer`, {
+                searchText: `${lat},${lng}`,
+                type: "locations",
+                sr: 4326,
+                limit: 5,
+            });
+            void extent; // extent used in identify, not reverse geocode search
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "get_solar_potential": {
+            const lat = args.lat;
+            const lng = args.lng;
+            const extent = `${lng - 0.05},${lat - 0.05},${lng + 0.05},${lat + 0.05}`;
+            const url = (0, http_js_1.buildUrl)(`${BASE}/rest/services/all/MapServer/identify`, {
+                geometry: `${lng},${lat}`,
+                geometryType: "esriGeometryPoint",
+                layers: "all:ch.bfe.solarenergie-eignung-daecher",
+                mapExtent: extent,
+                imageDisplay: "500,500,96",
+                tolerance: 100,
+                sr: 4326,
+                returnGeometry: false,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "identify_location": {
+            const lat = args.lat;
+            const lng = args.lng;
+            const extent = `${lng - 0.05},${lat - 0.05},${lng + 0.05},${lat + 0.05}`;
+            const layers = args.layers ? `all:${args.layers}` : "all";
+            const url = (0, http_js_1.buildUrl)(`${BASE}/rest/services/all/MapServer/identify`, {
+                geometry: `${lng},${lat}`,
+                geometryType: "esriGeometryPoint",
+                layers,
+                mapExtent: extent,
+                imageDisplay: "500,500,96",
+                tolerance: 5,
+                sr: 4326,
+                returnGeometry: false,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "get_municipality": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/rest/services/api/SearchServer`, {
+                searchText: args.name,
+                type: "locations",
+                sr: 4326,
+                limit: 5,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        default:
+            throw new Error(`Unknown geodata tool: ${name}`);
+    }
+}

package/dist/modules/transport.d.ts

@@ -0,0 +1,141 @@
+export declare const transportTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            x: {
+                type: string;
+                description: string;
+            };
+            y: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            from?: undefined;
+            to?: undefined;
+            date?: undefined;
+            time?: undefined;
+            limit?: undefined;
+            isArrivalTime?: undefined;
+            station?: undefined;
+            datetime?: undefined;
+            distance?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            from: {
+                type: string;
+                description: string;
+            };
+            to: {
+                type: string;
+                description: string;
+            };
+            date: {
+                type: string;
+                description: string;
+            };
+            time: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            isArrivalTime: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            x?: undefined;
+            y?: undefined;
+            type?: undefined;
+            station?: undefined;
+            datetime?: undefined;
+            distance?: undefined;
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            station: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            datetime: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            x?: undefined;
+            y?: undefined;
+            type?: undefined;
+            from?: undefined;
+            to?: undefined;
+            date?: undefined;
+            time?: undefined;
+            isArrivalTime?: undefined;
+            distance?: undefined;
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            x: {
+                type: string;
+                description: string;
+            };
+            y: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            distance: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            type?: undefined;
+            from?: undefined;
+            to?: undefined;
+            date?: undefined;
+            time?: undefined;
+            isArrivalTime?: undefined;
+            station?: undefined;
+            datetime?: undefined;
+        };
+    };
+})[];
+export declare function handleTransport(name: string, args: Record<string, unknown>): Promise<string>;

package/dist/modules/transport.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportTools = void 0;
+exports.handleTransport = handleTransport;
+const http_js_1 = require("../utils/http.js");
+const BASE = "https://transport.opendata.ch/v1";
+exports.transportTools = [
+    {
+        name: "search_stations",
+        description: "Search for Swiss public transport stations/stops by name or coordinates",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Station name to search for" },
+                x: { type: "number", description: "Longitude (WGS84)" },
+                y: { type: "number", description: "Latitude (WGS84)" },
+                type: { type: "string", description: "Filter: all, station, poi, address" },
+            },
+        },
+    },
+    {
+        name: "get_connections",
+        description: "Get train/bus connections between two Swiss locations",
+        inputSchema: {
+            type: "object",
+            required: ["from", "to"],
+            properties: {
+                from: { type: "string", description: "Departure station/address" },
+                to: { type: "string", description: "Arrival station/address" },
+                date: { type: "string", description: "Date YYYY-MM-DD (default: today)" },
+                time: { type: "string", description: "Time HH:MM (default: now)" },
+                limit: { type: "number", description: "Number of connections (1-16, default: 4)" },
+                isArrivalTime: { type: "boolean", description: "True if time is arrival time" },
+            },
+        },
+    },
+    {
+        name: "get_departures",
+        description: "Get live departures from a Swiss transport station",
+        inputSchema: {
+            type: "object",
+            required: ["station"],
+            properties: {
+                station: { type: "string", description: "Station name" },
+                limit: { type: "number", description: "Number of departures (default: 10)" },
+                datetime: { type: "string", description: "DateTime YYYY-MM-DDTHH:MM (default: now)" },
+            },
+        },
+    },
+    {
+        name: "get_arrivals",
+        description: "Get live arrivals at a Swiss transport station",
+        inputSchema: {
+            type: "object",
+            required: ["station"],
+            properties: {
+                station: { type: "string", description: "Station name" },
+                limit: { type: "number", description: "Number of arrivals (default: 10)" },
+                datetime: { type: "string", description: "DateTime YYYY-MM-DDTHH:MM (default: now)" },
+            },
+        },
+    },
+    {
+        name: "get_nearby_stations",
+        description: "Find Swiss public transport stations near given coordinates",
+        inputSchema: {
+            type: "object",
+            required: ["x", "y"],
+            properties: {
+                x: { type: "number", description: "Longitude (WGS84)" },
+                y: { type: "number", description: "Latitude (WGS84)" },
+                limit: { type: "number", description: "Number of results (default: 10)" },
+                distance: { type: "number", description: "Max distance in meters" },
+            },
+        },
+    },
+];
+async function handleTransport(name, args) {
+    switch (name) {
+        case "search_stations": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/locations`, {
+                query: args.query,
+                x: args.x,
+                y: args.y,
+                type: args.type,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data.stations, null, 2);
+        }
+        case "get_connections": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/connections`, {
+                from: args.from,
+                to: args.to,
+                date: args.date,
+                time: args.time,
+                limit: args.limit,
+                isArrivalTime: args.isArrivalTime ? 1 : undefined,
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data.connections, null, 2);
+        }
+        case "get_departures": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/stationboard`, {
+                station: args.station,
+                limit: args.limit,
+                datetime: args.datetime,
+                type: "departure",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify({ station: data.station, departures: data.stationboard }, null, 2);
+        }
+        case "get_arrivals": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/stationboard`, {
+                station: args.station,
+                limit: args.limit,
+                datetime: args.datetime,
+                type: "arrival",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify({ station: data.station, arrivals: data.stationboard }, null, 2);
+        }
+        case "get_nearby_stations": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/locations`, {
+                x: args.x,
+                y: args.y,
+                type: "station",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data.stations, null, 2);
+        }
+        default:
+            throw new Error(`Unknown transport tool: ${name}`);
+    }
+}

package/dist/modules/weather.d.ts

@@ -0,0 +1,50 @@
+export declare const weatherTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            station: {
+                type: string;
+                description: string;
+            };
+            start_date?: undefined;
+            end_date?: undefined;
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            station?: undefined;
+            start_date?: undefined;
+            end_date?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            station: {
+                type: string;
+                description: string;
+            };
+            start_date: {
+                type: string;
+                description: string;
+            };
+            end_date: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+})[];
+export declare function handleWeather(name: string, args: Record<string, unknown>): Promise<string>;

package/dist/modules/weather.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weatherTools = void 0;
+exports.handleWeather = handleWeather;
+const http_js_1 = require("../utils/http.js");
+const BASE = "https://api.existenz.ch/apiv1";
+exports.weatherTools = [
+    {
+        name: "get_weather",
+        description: "Get current weather conditions at a Swiss MeteoSwiss station (e.g. BER=Bern, ZUE=Zürich, LUG=Lugano)",
+        inputSchema: {
+            type: "object",
+            required: ["station"],
+            properties: {
+                station: { type: "string", description: "Station code (e.g. BER, ZUE, LUG, GVE, SMA)" },
+            },
+        },
+    },
+    {
+        name: "list_weather_stations",
+        description: "List all available MeteoSwiss weather stations in Switzerland",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_weather_history",
+        description: "Get historical weather data for a Swiss station",
+        inputSchema: {
+            type: "object",
+            required: ["station", "start_date", "end_date"],
+            properties: {
+                station: { type: "string", description: "Station code (e.g. BER)" },
+                start_date: { type: "string", description: "Start date YYYY-MM-DD" },
+                end_date: { type: "string", description: "End date YYYY-MM-DD" },
+            },
+        },
+    },
+    {
+        name: "get_water_level",
+        description: "Get current river or lake water level and temperature at a Swiss hydrological station",
+        inputSchema: {
+            type: "object",
+            required: ["station"],
+            properties: {
+                station: { type: "string", description: "Hydro station ID (e.g. 2135 for Aare/Bern, 2243 for Rhine/Basel)" },
+            },
+        },
+    },
+    {
+        name: "list_hydro_stations",
+        description: "List all available BAFU hydrological monitoring stations (rivers and lakes) in Switzerland",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_water_history",
+        description: "Get historical river/lake water level data for a Swiss hydrological station",
+        inputSchema: {
+            type: "object",
+            required: ["station", "start_date", "end_date"],
+            properties: {
+                station: { type: "string", description: "Hydro station ID" },
+                start_date: { type: "string", description: "Start date YYYY-MM-DD" },
+                end_date: { type: "string", description: "End date YYYY-MM-DD" },
+            },
+        },
+    },
+];
+async function handleWeather(name, args) {
+    switch (name) {
+        case "get_weather": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/smn/latest`, {
+                locations: args.station,
+                app: "mcp-swiss",
+                version: "0.1.0",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "list_weather_stations": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/smn/locations`, { app: "mcp-swiss" });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "get_weather_history": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/smn/daterange`, {
+                locations: args.station,
+                startdt: args.start_date,
+                enddt: args.end_date,
+                app: "mcp-swiss",
+                version: "0.1.0",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "get_water_level": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/hydro/latest`, {
+                locations: args.station,
+                app: "mcp-swiss",
+                version: "0.1.0",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "list_hydro_stations": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/hydro/locations`, { app: "mcp-swiss" });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        case "get_water_history": {
+            const url = (0, http_js_1.buildUrl)(`${BASE}/hydro/daterange`, {
+                locations: args.station,
+                startdt: args.start_date,
+                enddt: args.end_date,
+                app: "mcp-swiss",
+                version: "0.1.0",
+            });
+            const data = await (0, http_js_1.fetchJSON)(url);
+            return JSON.stringify(data, null, 2);
+        }
+        default:
+            throw new Error(`Unknown weather tool: ${name}`);
+    }
+}

package/dist/utils/http.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchJSON<T>(url: string, options?: RequestInit): Promise<T>;
+export declare function buildUrl(base: string, params: Record<string, string | number | boolean | undefined>): string;

package/dist/utils/http.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchJSON = fetchJSON;
+exports.buildUrl = buildUrl;
+async function fetchJSON(url, options) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            "Accept": "application/json",
+            "User-Agent": "mcp-swiss/0.1.0",
+            ...(options?.headers ?? {}),
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText} — ${url}`);
+    }
+    return response.json();
+}
+function buildUrl(base, params) {
+    const url = new URL(base);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== "") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url.toString();
+}