@cablate/mcp-google-map 0.0.4 → 0.0.6

package/dist/maps-tools/mapsTools.js

@@ -1,167 +0,0 @@
-export const SEARCH_NEARBY_TOOL = {
-    name: "search_nearby",
-    description: "搜尋附近的地點",
-    inputSchema: {
-        type: "object",
-        properties: {
-            center: {
-                type: "object",
-                properties: {
-                    value: { type: "string", description: "地址、地標名稱或經緯度座標(經緯度座標格式: lat,lng)" },
-                    isCoordinates: { type: "boolean", description: "是否為經緯度座標", default: false },
-                },
-                required: ["value"],
-                description: "搜尋中心點",
-            },
-            keyword: {
-                type: "string",
-                description: "搜尋關鍵字（例如：餐廳、咖啡廳）",
-            },
-            radius: {
-                type: "number",
-                description: "搜尋半徑（公尺）",
-                default: 1000,
-            },
-            openNow: {
-                type: "boolean",
-                description: "是否只顯示營業中的地點",
-                default: false,
-            },
-            minRating: {
-                type: "number",
-                description: "最低評分要求（0-5）",
-                minimum: 0,
-                maximum: 5,
-            },
-        },
-        required: ["center"],
-    },
-};
-export const GEOCODE_TOOL = {
-    name: "maps_geocode",
-    description: "將地址轉換為座標",
-    inputSchema: {
-        type: "object",
-        properties: {
-            address: {
-                type: "string",
-                description: "要轉換的地址或地標名稱",
-            },
-        },
-        required: ["address"],
-    },
-};
-export const REVERSE_GEOCODE_TOOL = {
-    name: "maps_reverse_geocode",
-    description: "將座標轉換為地址",
-    inputSchema: {
-        type: "object",
-        properties: {
-            latitude: {
-                type: "number",
-                description: "緯度",
-            },
-            longitude: {
-                type: "number",
-                description: "經度",
-            },
-        },
-        required: ["latitude", "longitude"],
-    },
-};
-export const DISTANCE_MATRIX_TOOL = {
-    name: "maps_distance_matrix",
-    description: "計算多個起點和終點之間的距離和時間",
-    inputSchema: {
-        type: "object",
-        properties: {
-            origins: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "起點地址或座標列表",
-            },
-            destinations: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "終點地址或座標列表",
-            },
-            mode: {
-                type: "string",
-                enum: ["driving", "walking", "bicycling", "transit"],
-                description: "交通模式",
-                default: "driving",
-            },
-        },
-        required: ["origins", "destinations"],
-    },
-};
-export const DIRECTIONS_TOOL = {
-    name: "maps_directions",
-    description: "獲取兩點之間的路線指引",
-    inputSchema: {
-        type: "object",
-        properties: {
-            origin: {
-                type: "string",
-                description: "起點地址或座標",
-            },
-            destination: {
-                type: "string",
-                description: "終點地址或座標",
-            },
-            mode: {
-                type: "string",
-                enum: ["driving", "walking", "bicycling", "transit"],
-                description: "交通模式",
-                default: "driving",
-            },
-        },
-        required: ["origin", "destination"],
-    },
-};
-export const ELEVATION_TOOL = {
-    name: "maps_elevation",
-    description: "獲取位置的海拔數據",
-    inputSchema: {
-        type: "object",
-        properties: {
-            locations: {
-                type: "array",
-                items: {
-                    type: "object",
-                    properties: {
-                        latitude: {
-                            type: "number",
-                            description: "緯度",
-                        },
-                        longitude: {
-                            type: "number",
-                            description: "經度",
-                        },
-                    },
-                    required: ["latitude", "longitude"],
-                },
-                description: "要獲取海拔數據的位置列表",
-            },
-        },
-        required: ["locations"],
-    },
-};
-export const GET_PLACE_DETAILS_TOOL = {
-    name: "get_place_details",
-    description: "獲取特定地點的詳細資訊",
-    inputSchema: {
-        type: "object",
-        properties: {
-            placeId: {
-                type: "string",
-                description: "Google Maps 地點 ID",
-            },
-        },
-        required: ["placeId"],
-    },
-};

package/dist/maps-tools/searchPlaces.js

@@ -1,144 +0,0 @@
-import { GoogleMapsTools } from "./toolclass.js";
-export class PlacesSearcher {
-    constructor() {
-        this.mapsTools = new GoogleMapsTools();
-    }
-    async searchNearby(params) {
-        try {
-            const location = await this.mapsTools.getLocation(params.center);
-            console.error(location);
-            const places = await this.mapsTools.searchNearbyPlaces({
-                location,
-                keyword: params.keyword,
-                radius: params.radius,
-                openNow: params.openNow,
-                minRating: params.minRating,
-            });
-            return {
-                location: location,
-                success: true,
-                data: places.map((place) => ({
-                    name: place.name,
-                    place_id: place.place_id,
-                    address: place.formatted_address,
-                    location: place.geometry.location,
-                    rating: place.rating,
-                    total_ratings: place.user_ratings_total,
-                    open_now: place.opening_hours?.open_now,
-                })),
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "搜尋時發生錯誤",
-            };
-        }
-    }
-    async getPlaceDetails(placeId) {
-        try {
-            const details = await this.mapsTools.getPlaceDetails(placeId);
-            return {
-                success: true,
-                data: {
-                    name: details.name,
-                    address: details.formatted_address,
-                    location: details.geometry?.location,
-                    rating: details.rating,
-                    total_ratings: details.user_ratings_total,
-                    open_now: details.opening_hours?.open_now,
-                    phone: details.formatted_phone_number,
-                    website: details.website,
-                    price_level: details.price_level,
-                    reviews: details.reviews?.map((review) => ({
-                        rating: review.rating,
-                        text: review.text,
-                        time: review.time,
-                        author_name: review.author_name,
-                    })),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "獲取詳細資訊時發生錯誤",
-            };
-        }
-    }
-    async geocode(address) {
-        try {
-            const result = await this.mapsTools.geocode(address);
-            return {
-                success: true,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "地址轉換座標時發生錯誤",
-            };
-        }
-    }
-    async reverseGeocode(latitude, longitude) {
-        try {
-            const result = await this.mapsTools.reverseGeocode(latitude, longitude);
-            return {
-                success: true,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "座標轉換地址時發生錯誤",
-            };
-        }
-    }
-    async calculateDistanceMatrix(origins, destinations, mode = "driving") {
-        try {
-            const result = await this.mapsTools.calculateDistanceMatrix(origins, destinations, mode);
-            return {
-                success: true,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "計算距離矩陣時發生錯誤",
-            };
-        }
-    }
-    async getDirections(origin, destination, mode = "driving") {
-        try {
-            const result = await this.mapsTools.getDirections(origin, destination, mode);
-            return {
-                success: true,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "獲取路線指引時發生錯誤",
-            };
-        }
-    }
-    async getElevation(locations) {
-        try {
-            const result = await this.mapsTools.getElevation(locations);
-            return {
-                success: true,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "獲取海拔數據時發生錯誤",
-            };
-        }
-    }
-}

package/dist/maps-tools/toolclass.js

@@ -1,248 +0,0 @@
-import { Client, Language } from "@googlemaps/google-maps-services-js";
-import dotenv from "dotenv";
-// 確保環境變數被載入
-dotenv.config();
-export class GoogleMapsTools {
-    constructor() {
-        this.defaultLanguage = Language.zh_TW;
-        this.client = new Client({});
-        if (!process.env.GOOGLE_MAPS_API_KEY) {
-            throw new Error("Google Maps API Key is required");
-        }
-    }
-    async searchNearbyPlaces(params) {
-        const searchParams = {
-            location: params.location,
-            radius: params.radius || 1000,
-            keyword: params.keyword,
-            opennow: params.openNow,
-            language: this.defaultLanguage,
-            key: process.env.GOOGLE_MAPS_API_KEY || "",
-        };
-        try {
-            const response = await this.client.placesNearby({
-                params: searchParams,
-            });
-            let results = response.data.results;
-            // 如果有最低評分要求，進行過濾
-            if (params.minRating) {
-                results = results.filter((place) => (place.rating || 0) >= (params.minRating || 0));
-            }
-            return results;
-        }
-        catch (error) {
-            console.error("Error in searchNearbyPlaces:", error);
-            throw new Error("搜尋附近地點時發生錯誤");
-        }
-    }
-    async getPlaceDetails(placeId) {
-        try {
-            const response = await this.client.placeDetails({
-                params: {
-                    place_id: placeId,
-                    fields: ["name", "rating", "formatted_address", "opening_hours", "reviews", "geometry", "formatted_phone_number", "website", "price_level", "photos"],
-                    language: this.defaultLanguage,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                },
-            });
-            return response.data.result;
-        }
-        catch (error) {
-            console.error("Error in getPlaceDetails:", error);
-            throw new Error("獲取地點詳細資訊時發生錯誤");
-        }
-    }
-    async geocodeAddress(address) {
-        try {
-            const response = await this.client.geocode({
-                params: {
-                    address: address,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                    language: this.defaultLanguage,
-                },
-            });
-            if (response.data.results.length === 0) {
-                throw new Error("找不到該地址的位置");
-            }
-            const result = response.data.results[0];
-            const location = result.geometry.location;
-            return {
-                lat: location.lat,
-                lng: location.lng,
-                formatted_address: result.formatted_address,
-                place_id: result.place_id,
-            };
-        }
-        catch (error) {
-            console.error("Error in geocodeAddress:", error);
-            throw new Error("地址轉換座標時發生錯誤");
-        }
-    }
-    parseCoordinates(coordString) {
-        const coords = coordString.split(",").map((c) => parseFloat(c.trim()));
-        if (coords.length !== 2 || isNaN(coords[0]) || isNaN(coords[1])) {
-            throw new Error("無效的座標格式，請使用「緯度,經度」格式");
-        }
-        return { lat: coords[0], lng: coords[1] };
-    }
-    async getLocation(center) {
-        if (center.isCoordinates) {
-            return this.parseCoordinates(center.value);
-        }
-        return this.geocodeAddress(center.value);
-    }
-    // 新增公開方法用於地址轉座標
-    async geocode(address) {
-        try {
-            const result = await this.geocodeAddress(address);
-            return {
-                location: { lat: result.lat, lng: result.lng },
-                formatted_address: result.formatted_address || "",
-                place_id: result.place_id || "",
-            };
-        }
-        catch (error) {
-            console.error("Error in geocode:", error);
-            throw new Error("地址轉換座標時發生錯誤");
-        }
-    }
-    async reverseGeocode(latitude, longitude) {
-        try {
-            const response = await this.client.reverseGeocode({
-                params: {
-                    latlng: { lat: latitude, lng: longitude },
-                    language: this.defaultLanguage,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                },
-            });
-            if (response.data.results.length === 0) {
-                throw new Error("找不到該座標的地址");
-            }
-            const result = response.data.results[0];
-            return {
-                formatted_address: result.formatted_address,
-                place_id: result.place_id,
-                address_components: result.address_components,
-            };
-        }
-        catch (error) {
-            console.error("Error in reverseGeocode:", error);
-            throw new Error("座標轉換地址時發生錯誤");
-        }
-    }
-    async calculateDistanceMatrix(origins, destinations, mode = "driving") {
-        try {
-            const response = await this.client.distancematrix({
-                params: {
-                    origins: origins,
-                    destinations: destinations,
-                    mode: mode,
-                    language: this.defaultLanguage,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                },
-            });
-            const result = response.data;
-            if (result.status !== "OK") {
-                throw new Error(`距離矩陣計算失敗: ${result.status}`);
-            }
-            const distances = [];
-            const durations = [];
-            result.rows.forEach((row) => {
-                const distanceRow = [];
-                const durationRow = [];
-                row.elements.forEach((element) => {
-                    if (element.status === "OK") {
-                        distanceRow.push({
-                            value: element.distance.value,
-                            text: element.distance.text,
-                        });
-                        durationRow.push({
-                            value: element.duration.value,
-                            text: element.duration.text,
-                        });
-                    }
-                    else {
-                        distanceRow.push(null);
-                        durationRow.push(null);
-                    }
-                });
-                distances.push(distanceRow);
-                durations.push(durationRow);
-            });
-            return {
-                distances: distances,
-                durations: durations,
-                origin_addresses: result.origin_addresses,
-                destination_addresses: result.destination_addresses,
-            };
-        }
-        catch (error) {
-            console.error("Error in calculateDistanceMatrix:", error);
-            throw new Error("計算距離矩陣時發生錯誤");
-        }
-    }
-    async getDirections(origin, destination, mode = "driving") {
-        try {
-            const response = await this.client.directions({
-                params: {
-                    origin: origin,
-                    destination: destination,
-                    mode: mode,
-                    language: this.defaultLanguage,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                },
-            });
-            const result = response.data;
-            if (result.status !== "OK") {
-                throw new Error(`路線指引獲取失敗: ${result.status}`);
-            }
-            if (result.routes.length === 0) {
-                throw new Error("找不到路線");
-            }
-            const route = result.routes[0];
-            const legs = route.legs[0];
-            return {
-                routes: result.routes,
-                summary: route.summary,
-                total_distance: {
-                    value: legs.distance.value,
-                    text: legs.distance.text,
-                },
-                total_duration: {
-                    value: legs.duration.value,
-                    text: legs.duration.text,
-                },
-            };
-        }
-        catch (error) {
-            console.error("Error in getDirections:", error);
-            throw new Error("獲取路線指引時發生錯誤");
-        }
-    }
-    async getElevation(locations) {
-        try {
-            const formattedLocations = locations.map((loc) => ({
-                lat: loc.latitude,
-                lng: loc.longitude,
-            }));
-            const response = await this.client.elevation({
-                params: {
-                    locations: formattedLocations,
-                    key: process.env.GOOGLE_MAPS_API_KEY || "",
-                },
-            });
-            const result = response.data;
-            if (result.status !== "OK") {
-                throw new Error(`海拔數據獲取失敗: ${result.status}`);
-            }
-            return result.results.map((item, index) => ({
-                elevation: item.elevation,
-                location: formattedLocations[index],
-            }));
-        }
-        catch (error) {
-            console.error("Error in getElevation:", error);
-            throw new Error("獲取海拔數據時發生錯誤");
-        }
-    }
-}