@ryancardin/noaa-tides-currents-mcp-server 1.0.0

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,150 @@
+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');
+            }
+        }
+    });
+}

package/dist/types/moon.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Moon phase names and their approximate ranges
+ */
+export declare enum MoonPhaseName {
+    NEW_MOON = "New Moon",
+    WAXING_CRESCENT = "Waxing Crescent",
+    FIRST_QUARTER = "First Quarter",
+    WAXING_GIBBOUS = "Waxing Gibbous",
+    FULL_MOON = "Full Moon",
+    WANING_GIBBOUS = "Waning Gibbous",
+    LAST_QUARTER = "Last Quarter",
+    WANING_CRESCENT = "Waning Crescent"
+}
+/**
+ * Moon phase information
+ */
+export interface MoonPhaseInfo {
+    date: string;
+    phase: number;
+    phaseName: MoonPhaseName;
+    illumination: number;
+    age: number;
+    distance: number;
+    diameter: number;
+    isWaxing: boolean;
+}

package/dist/types/moon.js

@@ -0,0 +1,14 @@
+/**
+ * Moon phase names and their approximate ranges
+ */
+export var MoonPhaseName;
+(function (MoonPhaseName) {
+    MoonPhaseName["NEW_MOON"] = "New Moon";
+    MoonPhaseName["WAXING_CRESCENT"] = "Waxing Crescent";
+    MoonPhaseName["FIRST_QUARTER"] = "First Quarter";
+    MoonPhaseName["WAXING_GIBBOUS"] = "Waxing Gibbous";
+    MoonPhaseName["FULL_MOON"] = "Full Moon";
+    MoonPhaseName["WANING_GIBBOUS"] = "Waning Gibbous";
+    MoonPhaseName["LAST_QUARTER"] = "Last Quarter";
+    MoonPhaseName["WANING_CRESCENT"] = "Waning Crescent";
+})(MoonPhaseName || (MoonPhaseName = {}));

package/dist/types/sun.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Sun event types
+ */
+export declare enum SunEventType {
+    SUNRISE = "sunrise",
+    SUNSET = "sunset",
+    DAWN = "dawn",
+    DUSK = "dusk",
+    SOLAR_NOON = "solarNoon",
+    NIGHT_START = "night",
+    NIGHT_END = "nightEnd",
+    GOLDEN_HOUR_START = "goldenHourStart",
+    GOLDEN_HOUR_END = "goldenHourEnd",
+    NAUTICAL_DAWN = "nauticalDawn",
+    NAUTICAL_DUSK = "nauticalDusk",
+    ASTRONOMICAL_DAWN = "astronomicalDawn",
+    ASTRONOMICAL_DUSK = "astronomicalDusk"
+}
+/**
+ * Sun times information
+ */
+export interface SunTimesInfo {
+    date: string;
+    sunrise: string | null;
+    sunset: string | null;
+    solarNoon: string | null;
+    dawn: string | null;
+    dusk: string | null;
+    nightStart: string | null;
+    nightEnd: string | null;
+    goldenHourStart: string | null;
+    goldenHourEnd: string | null;
+    nauticalDawn: string | null;
+    nauticalDusk: string | null;
+    astronomicalDawn: string | null;
+    astronomicalDusk: string | null;
+    dayLength: number;
+}
+/**
+ * Sun position information
+ */
+export interface SunPositionInfo {
+    date: string;
+    time: string;
+    azimuth: number;
+    altitude: number;
+    declination: number;
+    rightAscension: number;
+}

package/dist/types/sun.js

@@ -0,0 +1,19 @@
+/**
+ * Sun event types
+ */
+export var SunEventType;
+(function (SunEventType) {
+    SunEventType["SUNRISE"] = "sunrise";
+    SunEventType["SUNSET"] = "sunset";
+    SunEventType["DAWN"] = "dawn";
+    SunEventType["DUSK"] = "dusk";
+    SunEventType["SOLAR_NOON"] = "solarNoon";
+    SunEventType["NIGHT_START"] = "night";
+    SunEventType["NIGHT_END"] = "nightEnd";
+    SunEventType["GOLDEN_HOUR_START"] = "goldenHourStart";
+    SunEventType["GOLDEN_HOUR_END"] = "goldenHourEnd";
+    SunEventType["NAUTICAL_DAWN"] = "nauticalDawn";
+    SunEventType["NAUTICAL_DUSK"] = "nauticalDusk";
+    SunEventType["ASTRONOMICAL_DAWN"] = "astronomicalDawn";
+    SunEventType["ASTRONOMICAL_DUSK"] = "astronomicalDusk";
+})(SunEventType || (SunEventType = {}));