@ryancardin/noaa-tides-currents-mcp-server 2.0.0 → 2.1.0

package/dist/tools/parameter-tools.js

@@ -1,77 +0,0 @@
-import { ParameterSchema } from '../interfaces/parameters.js';
-/**
- * Register parameter tools with the MCP server
- */
-export function registerParameterTools(server, parametersService) {
-    /**
-     * Add parameter definitions tool
-     */
-    server.addTool({
-        name: 'get_parameter_definitions',
-        description: 'Get information about valid parameter values for NOAA API requests',
-        parameters: ParameterSchema,
-        execute: async (params) => {
-            try {
-                const { parameter } = params;
-                // If no parameter specified, return all parameter types and their descriptions
-                if (!parameter) {
-                    return JSON.stringify({
-                        time_zones: parametersService.getTimeZones(),
-                        datums: parametersService.getDatums(),
-                        units: parametersService.getUnits(),
-                        tide_intervals: parametersService.getTidePredictionIntervals(),
-                        current_intervals: parametersService.getCurrentPredictionIntervals(),
-                        velocity_types: parametersService.getVelocityTypes(),
-                        products: parametersService.getMeteorologicalProducts(),
-                        station_types: parametersService.getStationTypes(),
-                        date_formats: parametersService.getDateFormats(),
-                        output_formats: parametersService.getOutputFormats()
-                    });
-                }
-                // Return specific parameter information based on the parameter type
-                let result;
-                switch (parameter) {
-                    case 'time_zones':
-                        result = parametersService.getTimeZones();
-                        break;
-                    case 'datums':
-                        result = parametersService.getDatums();
-                        break;
-                    case 'units':
-                        result = parametersService.getUnits();
-                        break;
-                    case 'tide_intervals':
-                        result = parametersService.getTidePredictionIntervals();
-                        break;
-                    case 'current_intervals':
-                        result = parametersService.getCurrentPredictionIntervals();
-                        break;
-                    case 'velocity_types':
-                        result = parametersService.getVelocityTypes();
-                        break;
-                    case 'products':
-                        result = parametersService.getMeteorologicalProducts();
-                        break;
-                    case 'station_types':
-                        result = parametersService.getStationTypes();
-                        break;
-                    case 'date_formats':
-                        result = parametersService.getDateFormats();
-                        break;
-                    case 'output_formats':
-                        result = parametersService.getOutputFormats();
-                        break;
-                    default:
-                        throw new Error(`Unknown parameter type: ${parameter}`);
-                }
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get parameter definitions: ${error.message}`);
-                }
-                throw new Error('Failed to get parameter definitions');
-            }
-        }
-    });
-}

package/dist/tools/station-tools.d.ts

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { NoaaService } from '../services/noaa-service.js';
-/**
- * Register station-related tools with the MCP server
- */
-export declare function registerStationTools(server: FastMCP, noaaService: NoaaService): void;

package/dist/tools/station-tools.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-import { StationSchema, UnitsSchema } from '../schemas/common.js';
-/**
- * Register station-related tools with the MCP server
- */
-export function registerStationTools(server, noaaService) {
-    // Add stations tool
-    server.addTool({
-        name: 'get_stations',
-        description: 'Get list of stations',
-        parameters: z.object({
-            type: z.string().optional().describe('Station type (waterlevels, currents, etc.)'),
-            format: z.enum(['json', 'xml']).optional().describe('Output format (json, xml)'),
-            units: UnitsSchema,
-        }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getStations(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get stations: ${error.message}`);
-                }
-                throw new Error('Failed to get stations');
-            }
-        }
-    });
-    // Add station details tool
-    server.addTool({
-        name: 'get_station_details',
-        description: 'Get detailed information about a station',
-        parameters: z.object({
-            station: StationSchema,
-            format: z.enum(['json', 'xml']).optional().describe('Output format (json, xml)'),
-            units: UnitsSchema,
-        }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getStationDetails(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get station details: ${error.message}`);
-                }
-                throw new Error('Failed to get station details');
-            }
-        }
-    });
-}

package/dist/tools/sun-tools.d.ts

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { SunService } from '../services/sun-service.js';
-/**
- * Register sun-related tools with the MCP server
- */
-export declare function registerSunTools(server: FastMCP, sunService: SunService): void;

package/dist/tools/sun-tools.js

@@ -1,109 +0,0 @@
-import { SunTimesParamsSchema, SunTimesRangeParamsSchema, SunPositionParamsSchema, NextSunEventParamsSchema } from '../interfaces/sun.js';
-/**
- * Register sun-related tools with the MCP server
- */
-export function registerSunTools(server, sunService) {
-    // Add sun times tool
-    server.addTool({
-        name: 'get_sun_times',
-        description: 'Get sun rise/set and other sun event times for a specific date and location',
-        parameters: SunTimesParamsSchema,
-        execute: async (params) => {
-            try {
-                const result = sunService.getSunTimes(params);
-                if (params.format === 'text') {
-                    let text = `Sun times for ${result.date} at latitude ${params.latitude}, longitude ${params.longitude}:\n`;
-                    text += `Sunrise: ${result.sunrise || 'N/A'}\n`;
-                    text += `Sunset: ${result.sunset || 'N/A'}\n`;
-                    text += `Day length: ${Math.floor(result.dayLength / 60)}h ${Math.round(result.dayLength % 60)}m\n`;
-                    text += `Solar noon: ${result.solarNoon || 'N/A'}\n`;
-                    text += `Dawn: ${result.dawn || 'N/A'}\n`;
-                    text += `Dusk: ${result.dusk || 'N/A'}\n`;
-                    return text;
-                }
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get sun times: ${error.message}`);
-                }
-                throw new Error('Failed to get sun times');
-            }
-        }
-    });
-    // Add sun times range tool
-    server.addTool({
-        name: 'get_sun_times_range',
-        description: 'Get sun rise/set and other sun event times for a date range and location',
-        parameters: SunTimesRangeParamsSchema,
-        execute: async (params) => {
-            try {
-                const results = sunService.getSunTimesRange(params);
-                if (params.format === 'text') {
-                    let text = `Sun times from ${params.start_date} to ${params.end_date} at latitude ${params.latitude}, longitude ${params.longitude}:\n\n`;
-                    results.forEach(result => {
-                        text += `Date: ${result.date}\n`;
-                        text += `Sunrise: ${result.sunrise || 'N/A'}\n`;
-                        text += `Sunset: ${result.sunset || 'N/A'}\n`;
-                        text += `Day length: ${Math.floor(result.dayLength / 60)}h ${Math.round(result.dayLength % 60)}m\n\n`;
-                    });
-                    return text;
-                }
-                return JSON.stringify(results);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get sun times range: ${error.message}`);
-                }
-                throw new Error('Failed to get sun times range');
-            }
-        }
-    });
-    // Add sun position tool
-    server.addTool({
-        name: 'get_sun_position',
-        description: 'Get sun position information for a specific date, time, and location',
-        parameters: SunPositionParamsSchema,
-        execute: async (params) => {
-            try {
-                const result = sunService.getSunPosition(params);
-                if (params.format === 'text') {
-                    let text = `Sun position for ${result.date} ${result.time} at latitude ${params.latitude}, longitude ${params.longitude}:\n`;
-                    text += `Azimuth: ${result.azimuth.toFixed(2)}°\n`;
-                    text += `Altitude: ${result.altitude.toFixed(2)}°\n`;
-                    text += `Declination: ${result.declination.toFixed(2)}°\n`;
-                    text += `Right Ascension: ${result.rightAscension.toFixed(2)}h\n`;
-                    return text;
-                }
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get sun position: ${error.message}`);
-                }
-                throw new Error('Failed to get sun position');
-            }
-        }
-    });
-    // Add next sun event tool
-    server.addTool({
-        name: 'get_next_sun_event',
-        description: 'Get the next occurrence(s) of a specific sun event',
-        parameters: NextSunEventParamsSchema,
-        execute: async (params) => {
-            try {
-                const results = sunService.getNextSunEvent(params);
-                if (params.format === 'text') {
-                    return results.map(result => `Next ${result.event}: ${result.date} at ${result.time}`).join('\n');
-                }
-                return JSON.stringify(results);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get next sun event: ${error.message}`);
-                }
-                throw new Error('Failed to get next sun event');
-            }
-        }
-    });
-}

package/dist/tools/water-tools.d.ts

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { NoaaService } from '../services/noaa-service.js';
-/**
- * Register water-related tools with the MCP server
- */
-export declare function registerWaterTools(server: FastMCP, noaaService: NoaaService): void;

package/dist/tools/water-tools.js

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-import { StationSchema, DateSchema, BeginDateSchema, EndDateSchema, RangeSchema, DatumSchema, UnitsSchema, TimeZoneSchema, FormatSchema, BinSchema, IntervalSchema, refineDateParams, dateRefinementMessage } from '../schemas/common.js';
-/**
- * Register water-related tools with the MCP server
- */
-export function registerWaterTools(server, noaaService) {
-    // Add water levels tool
-    server.addTool({
-        name: 'get_water_levels',
-        description: 'Get water level data for a station',
-        parameters: z.object({
-            station: StationSchema,
-            date: DateSchema,
-            begin_date: BeginDateSchema,
-            end_date: EndDateSchema,
-            range: RangeSchema,
-            datum: DatumSchema,
-            units: UnitsSchema,
-            time_zone: TimeZoneSchema,
-            format: FormatSchema,
-        }).refine(refineDateParams, { message: dateRefinementMessage }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getWaterLevels(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get water levels: ${error.message}`);
-                }
-                throw new Error('Failed to get water levels');
-            }
-        }
-    });
-    // Add tide predictions tool
-    server.addTool({
-        name: 'get_tide_predictions',
-        description: 'Get tide prediction data',
-        parameters: z.object({
-            station: StationSchema,
-            begin_date: BeginDateSchema,
-            end_date: EndDateSchema,
-            date: DateSchema,
-            range: RangeSchema,
-            datum: DatumSchema,
-            units: UnitsSchema,
-            time_zone: TimeZoneSchema,
-            interval: IntervalSchema,
-            format: FormatSchema,
-        }).refine(refineDateParams, { message: dateRefinementMessage }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getTidePredictions(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get tide predictions: ${error.message}`);
-                }
-                throw new Error('Failed to get tide predictions');
-            }
-        }
-    });
-    // Add currents tool
-    server.addTool({
-        name: 'get_currents',
-        description: 'Get currents data for a station',
-        parameters: z.object({
-            station: StationSchema,
-            date: DateSchema,
-            begin_date: BeginDateSchema,
-            end_date: EndDateSchema,
-            range: RangeSchema,
-            bin: BinSchema,
-            units: UnitsSchema,
-            time_zone: TimeZoneSchema,
-            format: FormatSchema,
-        }).refine(refineDateParams, { message: dateRefinementMessage }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getCurrents(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get currents: ${error.message}`);
-                }
-                throw new Error('Failed to get currents');
-            }
-        }
-    });
-    // Add current predictions tool
-    server.addTool({
-        name: 'get_current_predictions',
-        description: 'Get current predictions',
-        parameters: z.object({
-            station: StationSchema,
-            date: DateSchema,
-            begin_date: BeginDateSchema,
-            end_date: EndDateSchema,
-            range: RangeSchema,
-            bin: BinSchema,
-            interval: z.string().optional().describe('Interval (MAX_SLACK or a number for minutes)'),
-            vel_type: z.enum(['speed_dir', 'default']).optional().describe('Velocity type (speed_dir or default)'),
-            units: UnitsSchema,
-            time_zone: TimeZoneSchema,
-            format: FormatSchema,
-        }).refine(refineDateParams, { message: dateRefinementMessage }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getCurrentPredictions(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get current predictions: ${error.message}`);
-                }
-                throw new Error('Failed to get current predictions');
-            }
-        }
-    });
-    // Add meteorological data tool
-    server.addTool({
-        name: 'get_meteorological_data',
-        description: 'Get meteorological data',
-        parameters: z.object({
-            station: StationSchema,
-            product: z.string().min(1).describe('Product (air_temperature, wind, etc.)'),
-            date: DateSchema,
-            begin_date: BeginDateSchema,
-            end_date: EndDateSchema,
-            range: RangeSchema,
-            units: UnitsSchema,
-            time_zone: TimeZoneSchema,
-            format: FormatSchema,
-        }).refine(refineDateParams, { message: dateRefinementMessage }),
-        execute: async (params) => {
-            try {
-                const result = await noaaService.getMeteorologicalData(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get meteorological data: ${error.message}`);
-                }
-                throw new Error('Failed to get meteorological data');
-            }
-        }
-    });
-}