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

package/dist/sun-service.d.ts

@@ -1,184 +0,0 @@
-import { z } from 'zod';
-/**
- * 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;
-}
-/**
- * Parameters for getting sun times
- */
-export declare const SunTimesParamsSchema: z.ZodObject<{
-    date: z.ZodOptional<z.ZodString>;
-    latitude: z.ZodNumber;
-    longitude: z.ZodNumber;
-    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
-    timezone: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    latitude: number;
-    longitude: number;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-    timezone?: string | undefined;
-}, {
-    latitude: number;
-    longitude: number;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-    timezone?: string | undefined;
-}>;
-export type SunTimesParams = z.infer<typeof SunTimesParamsSchema>;
-/**
- * Parameters for getting sun times for a date range
- */
-export declare const SunTimesRangeParamsSchema: z.ZodObject<{
-    start_date: z.ZodString;
-    end_date: z.ZodString;
-    latitude: z.ZodNumber;
-    longitude: z.ZodNumber;
-    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
-    timezone: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    latitude: number;
-    longitude: number;
-    start_date: string;
-    end_date: string;
-    format?: "text" | "json" | undefined;
-    timezone?: string | undefined;
-}, {
-    latitude: number;
-    longitude: number;
-    start_date: string;
-    end_date: string;
-    format?: "text" | "json" | undefined;
-    timezone?: string | undefined;
-}>;
-export type SunTimesRangeParams = z.infer<typeof SunTimesRangeParamsSchema>;
-/**
- * Parameters for getting sun position
- */
-export declare const SunPositionParamsSchema: z.ZodObject<{
-    date: z.ZodOptional<z.ZodString>;
-    time: z.ZodOptional<z.ZodString>;
-    latitude: z.ZodNumber;
-    longitude: z.ZodNumber;
-    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
-}, "strip", z.ZodTypeAny, {
-    latitude: number;
-    longitude: number;
-    time?: string | undefined;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-}, {
-    latitude: number;
-    longitude: number;
-    time?: string | undefined;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-}>;
-export type SunPositionParams = z.infer<typeof SunPositionParamsSchema>;
-/**
- * Parameters for finding the next sun event
- */
-export declare const NextSunEventParamsSchema: z.ZodObject<{
-    event: z.ZodNativeEnum<typeof SunEventType>;
-    date: z.ZodOptional<z.ZodString>;
-    latitude: z.ZodNumber;
-    longitude: z.ZodNumber;
-    count: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
-    timezone: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    event: SunEventType;
-    latitude: number;
-    longitude: number;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-    count?: number | undefined;
-    timezone?: string | undefined;
-}, {
-    event: SunEventType;
-    latitude: number;
-    longitude: number;
-    date?: string | undefined;
-    format?: "text" | "json" | undefined;
-    count?: number | undefined;
-    timezone?: string | undefined;
-}>;
-export type NextSunEventParams = z.infer<typeof NextSunEventParamsSchema>;
-/**
- * Service for sun calculations
- */
-export declare class SunService {
-    /**
-     * Get sun times for a specific date and location
-     * @param params Parameters for the request
-     * @returns Sun times information
-     */
-    getSunTimes(params: SunTimesParams): SunTimesInfo;
-    /**
-     * Get sun times for a date range
-     * @param params Parameters for the request
-     * @returns Array of sun times information
-     */
-    getSunTimesRange(params: SunTimesRangeParams): SunTimesInfo[];
-    /**
-     * Get sun position for a specific date, time, and location
-     * @param params Parameters for the request
-     * @returns Sun position information
-     */
-    getSunPosition(params: SunPositionParams): SunPositionInfo;
-    /**
-     * Get the next occurrence(s) of a specific sun event
-     * @param params Parameters for the request
-     * @returns Array of dates for the next occurrences of the specified event
-     */
-    getNextSunEvent(params: NextSunEventParams): {
-        date: string;
-        time: string;
-        event: string;
-    }[];
-}

package/dist/sun-service.js

@@ -1,218 +0,0 @@
-import SunCalc from 'suncalc';
-import { z } from 'zod';
-/**
- * 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 = {}));
-/**
- * Parameters for getting sun times
- */
-export const SunTimesParamsSchema = z.object({
-    date: z.string().optional().describe('Date to get sun times for (YYYY-MM-DD format). Defaults to current date.'),
-    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
-    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
-    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
-    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
-});
-/**
- * Parameters for getting sun times for a date range
- */
-export const SunTimesRangeParamsSchema = z.object({
-    start_date: z.string().describe('Start date (YYYY-MM-DD format)'),
-    end_date: z.string().describe('End date (YYYY-MM-DD format)'),
-    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
-    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
-    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
-    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
-});
-/**
- * Parameters for getting sun position
- */
-export const SunPositionParamsSchema = z.object({
-    date: z.string().optional().describe('Date to get sun position for (YYYY-MM-DD format). Defaults to current date.'),
-    time: z.string().optional().describe('Time to get sun position for (HH:MM:SS format). Defaults to current time.'),
-    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
-    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
-    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)')
-});
-/**
- * Parameters for finding the next sun event
- */
-export const NextSunEventParamsSchema = z.object({
-    event: z.nativeEnum(SunEventType).describe('Sun event to find'),
-    date: z.string().optional().describe('Starting date (YYYY-MM-DD format). Defaults to current date.'),
-    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
-    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
-    count: z.number().positive().optional().describe('Number of occurrences to return. Defaults to 1.'),
-    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
-    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
-});
-/**
- * Service for sun calculations
- */
-export class SunService {
-    /**
-     * Get sun times for a specific date and location
-     * @param params Parameters for the request
-     * @returns Sun times information
-     */
-    getSunTimes(params) {
-        const date = params.date ? new Date(params.date) : new Date();
-        const { latitude, longitude } = params;
-        // Get sun times data
-        const sunTimes = SunCalc.getTimes(date, latitude, longitude);
-        // Format times or return null if not available
-        const formatTime = (time) => {
-            if (!time || isNaN(time.getTime()))
-                return null;
-            if (params.timezone) {
-                try {
-                    return time.toLocaleTimeString('en-US', { timeZone: params.timezone });
-                }
-                catch (error) {
-                    // If timezone is invalid, fall back to ISO string
-                    console.warn(`Invalid timezone: ${params.timezone}. Using UTC.`);
-                }
-            }
-            return time.toISOString();
-        };
-        // Calculate day length in minutes
-        const sunrise = sunTimes.sunrise;
-        const sunset = sunTimes.sunset;
-        let dayLength = 0;
-        if (sunrise && sunset && !isNaN(sunrise.getTime()) && !isNaN(sunset.getTime())) {
-            dayLength = (sunset.getTime() - sunrise.getTime()) / (60 * 1000);
-        }
-        return {
-            date: date.toISOString().split('T')[0],
-            sunrise: formatTime(sunTimes.sunrise),
-            sunset: formatTime(sunTimes.sunset),
-            solarNoon: formatTime(sunTimes.solarNoon),
-            dawn: formatTime(sunTimes.dawn),
-            dusk: formatTime(sunTimes.dusk),
-            nightStart: formatTime(sunTimes.night),
-            nightEnd: formatTime(sunTimes.nightEnd),
-            goldenHourStart: formatTime(sunTimes.goldenHour),
-            goldenHourEnd: formatTime(sunTimes.goldenHourEnd),
-            nauticalDawn: formatTime(sunTimes.nauticalDawn),
-            nauticalDusk: formatTime(sunTimes.nauticalDusk),
-            astronomicalDawn: formatTime(sunTimes.astronomicalDawn),
-            astronomicalDusk: formatTime(sunTimes.astronomicalDusk),
-            dayLength
-        };
-    }
-    /**
-     * Get sun times for a date range
-     * @param params Parameters for the request
-     * @returns Array of sun times information
-     */
-    getSunTimesRange(params) {
-        const startDate = new Date(params.start_date);
-        const endDate = new Date(params.end_date);
-        if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
-            throw new Error('Invalid date format. Please use YYYY-MM-DD format.');
-        }
-        if (startDate > endDate) {
-            throw new Error('Start date must be before end date.');
-        }
-        const result = [];
-        const currentDate = new Date(startDate);
-        while (currentDate <= endDate) {
-            result.push(this.getSunTimes({
-                date: currentDate.toISOString().split('T')[0],
-                latitude: params.latitude,
-                longitude: params.longitude,
-                timezone: params.timezone
-            }));
-            // Move to next day
-            currentDate.setDate(currentDate.getDate() + 1);
-        }
-        return result;
-    }
-    /**
-     * Get sun position for a specific date, time, and location
-     * @param params Parameters for the request
-     * @returns Sun position information
-     */
-    getSunPosition(params) {
-        const date = params.date ? new Date(params.date) : new Date();
-        // If time is provided, set it on the date object
-        if (params.time) {
-            const [hours, minutes, seconds] = params.time.split(':').map(Number);
-            date.setHours(hours || 0, minutes || 0, seconds || 0);
-        }
-        const { latitude, longitude } = params;
-        // Get sun position data
-        const position = SunCalc.getPosition(date, latitude, longitude);
-        // Calculate additional astronomical data
-        const declination = Math.asin(Math.sin(23.44 * Math.PI / 180) * Math.sin(position.azimuth));
-        const rightAscension = Math.atan2(Math.cos(23.44 * Math.PI / 180) * Math.sin(position.azimuth), Math.cos(position.azimuth));
-        return {
-            date: date.toISOString().split('T')[0],
-            time: date.toISOString().split('T')[1].split('.')[0],
-            azimuth: position.azimuth * (180 / Math.PI), // Convert to degrees
-            altitude: position.altitude * (180 / Math.PI), // Convert to degrees
-            declination: declination * (180 / Math.PI), // Convert to degrees
-            rightAscension: rightAscension * (180 / Math.PI) // Convert to degrees
-        };
-    }
-    /**
-     * Get the next occurrence(s) of a specific sun event
-     * @param params Parameters for the request
-     * @returns Array of dates for the next occurrences of the specified event
-     */
-    getNextSunEvent(params) {
-        const startDate = params.date ? new Date(params.date) : new Date();
-        const count = params.count || 1;
-        const { latitude, longitude, event } = params;
-        const results = [];
-        let currentDate = new Date(startDate);
-        // Find the next occurrences
-        while (results.length < count) {
-            // Get sun times for the current date
-            const sunTimes = SunCalc.getTimes(currentDate, latitude, longitude);
-            const eventTime = sunTimes[event];
-            // If the event time is valid and in the future
-            if (eventTime && !isNaN(eventTime.getTime()) && eventTime > startDate) {
-                let timeString = eventTime.toISOString();
-                // Format time based on timezone if provided
-                if (params.timezone) {
-                    try {
-                        timeString = eventTime.toLocaleTimeString('en-US', { timeZone: params.timezone });
-                    }
-                    catch (error) {
-                        // If timezone is invalid, fall back to ISO string
-                        console.warn(`Invalid timezone: ${params.timezone}. Using UTC.`);
-                    }
-                }
-                results.push({
-                    date: eventTime.toISOString().split('T')[0],
-                    time: timeString.split('T')[1]?.split('.')[0] || timeString,
-                    event
-                });
-            }
-            // Move to next day
-            currentDate.setDate(currentDate.getDate() + 1);
-            // Safety check to prevent infinite loops
-            if (results.length === 0 && currentDate.getTime() - startDate.getTime() > 366 * 24 * 60 * 60 * 1000) {
-                throw new Error('Could not find the specified sun event within a year.');
-            }
-        }
-        return results;
-    }
-}

package/dist/tools/derived-product-tools.d.ts

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { DpapiService } from '../services/dpapi-service.js';
-/**
- * Register derived product tools with the MCP server
- */
-export declare function registerDerivedProductTools(server: FastMCP, dpapiService: DpapiService): void;

package/dist/tools/derived-product-tools.js

@@ -1,168 +0,0 @@
-import { SeaLevelTrendsSchema, ExtremeWaterLevelsSchema, HighTideFloodingDailySchema, HighTideFloodingMonthlySchema, HighTideFloodingSeasonalSchema, HighTideFloodingAnnualSchema, HighTideFloodingProjectionsSchema, HighTideFloodingLikelihoodsSchema, TopTenWaterLevelsSchema } from '../schemas/dpapi.js';
-/**
- * Register derived product tools with the MCP server
- */
-export function registerDerivedProductTools(server, dpapiService) {
-    // Sea Level Trends tool
-    server.addTool({
-        name: 'get_sea_level_trends',
-        description: 'Get sea level trends and error margins for a station',
-        parameters: SeaLevelTrendsSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getSeaLevelTrends(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get sea level trends: ${error.message}`);
-                }
-                throw new Error('Failed to get sea level trends');
-            }
-        }
-    });
-    // Extreme Water Levels tool
-    server.addTool({
-        name: 'get_extreme_water_levels',
-        description: 'Get extreme water levels and exceedance probabilities for a station',
-        parameters: ExtremeWaterLevelsSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getExtremeWaterLevels(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get extreme water levels: ${error.message}`);
-                }
-                throw new Error('Failed to get extreme water levels');
-            }
-        }
-    });
-    // High Tide Flooding Daily tool
-    server.addTool({
-        name: 'get_high_tide_flooding_daily',
-        description: 'Get high tide flooding daily count data for a station',
-        parameters: HighTideFloodingDailySchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingDaily(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding daily data: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding daily data');
-            }
-        }
-    });
-    // High Tide Flooding Monthly tool
-    server.addTool({
-        name: 'get_high_tide_flooding_monthly',
-        description: 'Get high tide flooding monthly count data for a station',
-        parameters: HighTideFloodingMonthlySchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingMonthly(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding monthly data: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding monthly data');
-            }
-        }
-    });
-    // High Tide Flooding Seasonal tool
-    server.addTool({
-        name: 'get_high_tide_flooding_seasonal',
-        description: 'Get high tide flooding seasonal count data for a station',
-        parameters: HighTideFloodingSeasonalSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingSeasonal(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding seasonal data: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding seasonal data');
-            }
-        }
-    });
-    // High Tide Flooding Annual tool
-    server.addTool({
-        name: 'get_high_tide_flooding_annual',
-        description: 'Get high tide flooding annual count data for a station',
-        parameters: HighTideFloodingAnnualSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingAnnual(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding annual data: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding annual data');
-            }
-        }
-    });
-    // High Tide Flooding Projections tool
-    server.addTool({
-        name: 'get_high_tide_flooding_projections',
-        description: 'Get high tide flooding decadal projections for sea level rise scenarios',
-        parameters: HighTideFloodingProjectionsSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingProjections(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding projections: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding projections');
-            }
-        }
-    });
-    // High Tide Flooding Likelihoods tool
-    server.addTool({
-        name: 'get_high_tide_flooding_likelihoods',
-        description: 'Get high tide flooding daily likelihoods for a station',
-        parameters: HighTideFloodingLikelihoodsSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getHighTideFloodingLikelihoods(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get high tide flooding likelihoods: ${error.message}`);
-                }
-                throw new Error('Failed to get high tide flooding likelihoods');
-            }
-        }
-    });
-    // Top Ten Water Levels tool
-    server.addTool({
-        name: 'get_top_ten_water_levels',
-        description: 'Get top ten highest or lowest water levels for a station',
-        parameters: TopTenWaterLevelsSchema,
-        execute: async (params) => {
-            try {
-                const result = await dpapiService.getTopTenWaterLevels(params);
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get top ten water levels: ${error.message}`);
-                }
-                throw new Error('Failed to get top ten water levels');
-            }
-        }
-    });
-}

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

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { MoonPhaseService } from '../services/moon-phase-service.js';
-/**
- * Register moon-related tools with the MCP server
- */
-export declare function registerMoonTools(server: FastMCP, moonPhaseService: MoonPhaseService): void;

package/dist/tools/moon-tools.js

@@ -1,69 +0,0 @@
-import { MoonPhaseParamsSchema, MoonPhasesRangeParamsSchema, NextMoonPhaseParamsSchema } from '../interfaces/moon.js';
-/**
- * Register moon-related tools with the MCP server
- */
-export function registerMoonTools(server, moonPhaseService) {
-    // Add moon phase tool
-    server.addTool({
-        name: 'get_moon_phase',
-        description: 'Get moon phase information for a specific date',
-        parameters: MoonPhaseParamsSchema,
-        execute: async (params) => {
-            try {
-                const result = moonPhaseService.getMoonPhase(params);
-                if (params.format === 'text') {
-                    return `Moon phase for ${result.date}: ${result.phaseName} (${(result.illumination * 100).toFixed(1)}% illuminated)`;
-                }
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get moon phase: ${error.message}`);
-                }
-                throw new Error('Failed to get moon phase');
-            }
-        }
-    });
-    // Add moon phases range tool
-    server.addTool({
-        name: 'get_moon_phases_range',
-        description: 'Get moon phase information for a date range',
-        parameters: MoonPhasesRangeParamsSchema,
-        execute: async (params) => {
-            try {
-                const results = moonPhaseService.getMoonPhasesRange(params);
-                if (params.format === 'text') {
-                    return results.map(result => `${result.date}: ${result.phaseName} (${(result.illumination * 100).toFixed(1)}% illuminated)`).join('\n');
-                }
-                return JSON.stringify(results);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get moon phases: ${error.message}`);
-                }
-                throw new Error('Failed to get moon phases');
-            }
-        }
-    });
-    // Add next moon phase tool
-    server.addTool({
-        name: 'get_next_moon_phase',
-        description: 'Get the next occurrence(s) of a specific moon phase',
-        parameters: NextMoonPhaseParamsSchema,
-        execute: async (params) => {
-            try {
-                const results = moonPhaseService.getNextMoonPhase(params);
-                if (params.format === 'text') {
-                    return results.map(result => `Next ${result.phase}: ${result.date}`).join('\n');
-                }
-                return JSON.stringify(results);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to get next moon phase: ${error.message}`);
-                }
-                throw new Error('Failed to get next moon phase');
-            }
-        }
-    });
-}

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

@@ -1,6 +0,0 @@
-import { FastMCP } from 'fastmcp';
-import { NoaaParametersService } from '../services/noaa-parameters-service.js';
-/**
- * Register parameter tools with the MCP server
- */
-export declare function registerParameterTools(server: FastMCP, parametersService: NoaaParametersService): void;