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

package/dist/tools/water.js

@@ -0,0 +1,270 @@
+/**
+ * Water level observation and tide prediction tools.
+ */
+import { z } from "zod";
+import { getWaterLevels, getWaterLevelSummaries, getTidePredictions, } from "../services/data-api.js";
+import { dateFields, DatumSchema, READ_ONLY_ANNOTATIONS, ResponseFormatSchema, StationIdSchema, TimeZoneSchema, UnitsSchema, } from "../schemas/common.js";
+import { respond, respondError } from "../format/respond.js";
+import { seriesMarkdown, timeZoneLabel } from "../format/series.js";
+import { FLAG_LEGENDS, unitLabel } from "../format/units.js";
+function metadataName(response) {
+    return response.metadata?.name;
+}
+export function registerWaterTools(server) {
+    server.registerTool("noaa_get_water_levels", {
+        title: "Get Observed Water Levels",
+        description: `Get observed water levels from a NOAA tide station as a time series.
+
+Choose the interval: "6" = standard 6-minute observations (preliminary or verified, max 31 days per request), "1" = 1-minute preliminary data (max 4 days), "hourly" = verified hourly heights (max 1 year). Heights are relative to the requested datum (MLLW by default — the US nautical chart zero).
+
+Returns per record: t (timestamp in requested time zone), v (height), s (sigma), f (quality flags, decoded in output), q (p=preliminary, v=verified). Recent data is preliminary; verification takes days to weeks.
+
+Use for: "what is the water level right now" (date=latest), storm surge analysis, comparing observed vs predicted tide. Do NOT use for future tides — use noaa_get_tide_predictions.`,
+        inputSchema: {
+            station: StationIdSchema,
+            interval: z
+                .enum(["1", "6", "hourly"])
+                .default("6")
+                .describe('Observation interval: "6" = 6-minute (standard, 31-day max), "1" = 1-minute preliminary (4-day max), "hourly" = verified hourly heights (1-year max).'),
+            datum: DatumSchema.default("MLLW"),
+            units: UnitsSchema,
+            time_zone: TimeZoneSchema,
+            ...dateFields,
+            response_format: ResponseFormatSchema,
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        try {
+            const { product, response } = await getWaterLevels(params);
+            const data = response.data ?? [];
+            const unitsLabel = `${unitLabel("water_level", params.units)} above ${params.datum}`;
+            const structured = {
+                station: params.station,
+                station_name: metadataName(response),
+                product,
+                datum: params.datum,
+                units: params.units,
+                units_label: unitsLabel,
+                time_zone: params.time_zone,
+                count: data.length,
+                data,
+            };
+            const anyVerified = data.some((d) => d.q === "v");
+            const anyPreliminary = data.some((d) => d.q === "p");
+            const legend = params.interval === "hourly"
+                ? FLAG_LEGENDS.hourly_height
+                : anyPreliminary && !anyVerified
+                    ? FLAG_LEGENDS.water_level_preliminary
+                    : FLAG_LEGENDS.water_level_verified;
+            const markdown = seriesMarkdown({
+                title: "Observed Water Levels",
+                station: params.station,
+                stationName: metadataName(response),
+                unitsLabel,
+                datum: params.datum,
+                timeZone: timeZoneLabel(params.time_zone),
+            }, [
+                "Time",
+                `Height (${unitLabel("water_level", params.units)})`,
+                "Sigma",
+                "Quality",
+                "Flags",
+            ], data.map((d) => [
+                d.t,
+                d.v,
+                d.s,
+                d.q === "v" ? "verified" : d.q === "p" ? "preliminary" : d.q,
+                d.f,
+            ]), legend);
+            return respond(params.response_format, structured, markdown);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    });
+    server.registerTool("noaa_get_water_level_summaries", {
+        title: "Get Water Level Summaries (High/Low, Daily, Monthly)",
+        description: `Get verified summary water-level products from a NOAA station:
+
+- high_low: each day's observed highs/lows with ty = HH (higher high), H, L, LL (lower low). Max 1 year per request.
+- daily_mean: daily mean levels — GREAT LAKES STATIONS ONLY; NOAA requires local standard time, which this tool applies automatically. Max 10 years.
+- daily_max_min: daily maxima/minima from hourly and 6-minute data with completeness percentages. Max 10 years.
+- monthly_mean: monthly tidal datum means (columns MHHW, MHW, MSL, MTL, MLW, MLLW, DTL, GT, MN, DHQ, DLQ, HWI, LWI, highest, lowest). Max 200 years — ideal for long-term climatology.
+
+Use for: historical extremes, mixed-tide analysis (HH vs H), long-term averages. For raw time series use noaa_get_water_levels; for future tides use noaa_get_tide_predictions.`,
+        inputSchema: {
+            station: StationIdSchema,
+            product: z
+                .enum(["high_low", "daily_mean", "daily_max_min", "monthly_mean"])
+                .describe("Summary product: high_low (daily tide extremes, 1yr max), daily_mean (Great Lakes only, 10yr), daily_max_min (10yr), monthly_mean (datum means, 200yr)."),
+            datum: DatumSchema.default("MLLW"),
+            units: UnitsSchema,
+            time_zone: TimeZoneSchema,
+            ...dateFields,
+            response_format: ResponseFormatSchema,
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        try {
+            const { response, timeZoneForced } = await getWaterLevelSummaries(params);
+            const data = response.data ?? [];
+            const unitsLabel = `${unitLabel("water_level", params.units)} above ${params.datum}`;
+            const structured = {
+                station: params.station,
+                station_name: metadataName(response),
+                product: params.product,
+                datum: params.datum,
+                units: params.units,
+                units_label: unitsLabel,
+                time_zone: timeZoneForced ? "lst" : params.time_zone,
+                time_zone_forced_to_lst: timeZoneForced || undefined,
+                count: data.length,
+                data,
+            };
+            let headers;
+            let rows;
+            let legend;
+            if (params.product === "high_low") {
+                headers = [
+                    "Time",
+                    `Height (${unitLabel("water_level", params.units)})`,
+                    "Type",
+                    "Flags",
+                ];
+                const tyLabels = {
+                    HH: "higher high",
+                    H: "high",
+                    L: "low",
+                    LL: "lower low",
+                };
+                rows = data.map((d) => {
+                    const ty = (d.ty ?? "").trim();
+                    return [d.t, d.v, ty ? `${ty} (${tyLabels[ty] ?? "?"})` : "", d.f];
+                });
+                legend = FLAG_LEGENDS.high_low;
+            }
+            else if (params.product === "monthly_mean") {
+                headers = [
+                    "Year",
+                    "Month",
+                    "Highest",
+                    "MHHW",
+                    "MSL",
+                    "MLLW",
+                    "Lowest",
+                ];
+                rows = data.map((d) => {
+                    const rec = d;
+                    return [
+                        rec.year,
+                        rec.month,
+                        rec.highest,
+                        rec.MHHW,
+                        rec.MSL,
+                        rec.MLLW,
+                        rec.lowest,
+                    ];
+                });
+                legend =
+                    'Full datum columns (MHW, MTL, MLW, DTL, GT, MN, DHQ, DLQ, HWI, LWI, inferred) are in the JSON payload (response_format "json").';
+            }
+            else {
+                headers = [
+                    "Date",
+                    `Value (${unitLabel("water_level", params.units)})`,
+                    "Flags",
+                ];
+                rows = data.map((d) => [d.t, d.v, d.f]);
+                legend = FLAG_LEGENDS.hourly_height;
+            }
+            const extra = [];
+            if (timeZoneForced) {
+                extra.push("_Note: daily_mean requires local standard time — time_zone was set to lst._");
+            }
+            const markdown = seriesMarkdown({
+                title: `Water Level Summary — ${params.product}`,
+                station: params.station,
+                stationName: metadataName(response),
+                unitsLabel,
+                datum: params.datum,
+                timeZone: timeZoneForced
+                    ? timeZoneLabel("lst")
+                    : timeZoneLabel(params.time_zone),
+                extra,
+            }, headers, rows, legend);
+            return respond(params.response_format, structured, markdown);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    });
+    server.registerTool("noaa_get_tide_predictions", {
+        title: "Get Tide Predictions",
+        description: `Get NOAA harmonic tide predictions (future or past) for a station.
+
+interval="hilo" (recommended for "when is high/low tide") returns the daily tide events with type H/L — up to 10 years per request. Other intervals (h, 1, 5, 6, 10, 15, 30, 60 minutes) return a height time series — up to 1 year per request.
+
+Heights are relative to the requested datum (MLLW default). Notes:
+- Great Lakes stations have NO tide predictions (lake levels are not tidal).
+- Subordinate stations (type "S") only support interval=hilo; use the station's reference (R) station for interval series.
+- Predictions are astronomical only — they exclude weather effects (storm surge, wind setup). Compare with noaa_get_water_levels for actual conditions.`,
+        inputSchema: {
+            station: StationIdSchema,
+            interval: z
+                .enum(["hilo", "h", "1", "5", "6", "10", "15", "30", "60"])
+                .default("hilo")
+                .describe('"hilo" = high/low tide events only (max 10-year span). "h" = hourly, or 1/5/6/10/15/30/60-minute series (max 1-year span).'),
+            datum: DatumSchema.default("MLLW"),
+            units: UnitsSchema,
+            time_zone: TimeZoneSchema,
+            ...dateFields,
+            response_format: ResponseFormatSchema,
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        try {
+            const response = await getTidePredictions(params);
+            const data = response.predictions ?? [];
+            const unitsLabel = `${unitLabel("water_level", params.units)} above ${params.datum}`;
+            const structured = {
+                station: params.station,
+                product: "predictions",
+                interval: params.interval,
+                datum: params.datum,
+                units: params.units,
+                units_label: unitsLabel,
+                time_zone: params.time_zone,
+                count: data.length,
+                predictions: data,
+            };
+            const isHilo = params.interval === "hilo";
+            const markdown = seriesMarkdown({
+                title: isHilo
+                    ? "Tide Predictions — High/Low Events"
+                    : "Tide Predictions",
+                station: params.station,
+                unitsLabel,
+                datum: params.datum,
+                timeZone: timeZoneLabel(params.time_zone),
+                extra: [
+                    "_Astronomical predictions only — actual levels also depend on weather (surge, wind)._",
+                ],
+            }, isHilo
+                ? [
+                    "Time",
+                    `Height (${unitLabel("water_level", params.units)})`,
+                    "Tide",
+                ]
+                : ["Time", `Height (${unitLabel("water_level", params.units)})`], data.map((d) => {
+                const type = d.type ?? d.ty;
+                return isHilo
+                    ? [d.t, d.v, type === "H" ? "High" : type === "L" ? "Low" : type]
+                    : [d.t, d.v];
+            }));
+            return respond(params.response_format, structured, markdown);
+        }
+        catch (error) {
+            return respondError(error);
+        }
+    });
+}

package/dist/validation/dates.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Date-parameter handling for the NOAA Data API.
+ *
+ * The API accepts exactly one of five combinations:
+ *   1. begin_date + end_date
+ *   2. begin_date + range (hours forward)
+ *   3. end_date + range (hours back)
+ *   4. date=today | latest | recent
+ *   5. range alone (hours back from now)
+ *
+ * NOAA date formats: yyyyMMdd, "yyyyMMdd HH:mm", MM/dd/yyyy, "MM/dd/yyyy HH:mm".
+ * We additionally accept ISO (yyyy-MM-dd and yyyy-MM-ddTHH:mm) and normalize it,
+ * since agents overwhelmingly produce ISO dates.
+ *
+ * Each product/interval also has a maximum span per request (e.g. 31 days for
+ * 6-minute water levels). We enforce those limits *before* calling NOAA so the
+ * agent gets an immediate, actionable error instead of an upstream failure.
+ */
+export interface DateParams {
+    date?: string;
+    begin_date?: string;
+    end_date?: string;
+    range?: number;
+}
+/**
+ * Normalize a user-supplied date string to a NOAA-accepted format.
+ * Throws with the list of accepted formats when unparseable.
+ */
+export declare function normalizeDate(input: string, paramName: string): string;
+/** Parse a normalized NOAA date string into a Date (UTC interpretation). */
+export declare function parseNoaaDate(normalized: string): Date;
+export interface NormalizedDateParams {
+    date?: string;
+    begin_date?: string;
+    end_date?: string;
+    range?: number;
+    /** Span of the request in days, when computable. */
+    spanDays?: number;
+}
+/**
+ * Validate that exactly one legal date-parameter combination was supplied,
+ * normalize formats, and compute the request span in days when possible.
+ */
+export declare function resolveDateParams(params: DateParams): NormalizedDateParams;
+/**
+ * Per-product/interval maximum request spans (days), from NOAA CO-OPS docs.
+ * Exceeding these returns an upstream error, so we fail fast with guidance.
+ */
+export declare const MAX_SPAN_DAYS: Record<string, number>;
+export declare function assertSpanWithinLimit(spanDays: number | undefined, limitKey: string, productLabel: string): void;

package/dist/validation/dates.js

@@ -0,0 +1,139 @@
+/**
+ * Date-parameter handling for the NOAA Data API.
+ *
+ * The API accepts exactly one of five combinations:
+ *   1. begin_date + end_date
+ *   2. begin_date + range (hours forward)
+ *   3. end_date + range (hours back)
+ *   4. date=today | latest | recent
+ *   5. range alone (hours back from now)
+ *
+ * NOAA date formats: yyyyMMdd, "yyyyMMdd HH:mm", MM/dd/yyyy, "MM/dd/yyyy HH:mm".
+ * We additionally accept ISO (yyyy-MM-dd and yyyy-MM-ddTHH:mm) and normalize it,
+ * since agents overwhelmingly produce ISO dates.
+ *
+ * Each product/interval also has a maximum span per request (e.g. 31 days for
+ * 6-minute water levels). We enforce those limits *before* calling NOAA so the
+ * agent gets an immediate, actionable error instead of an upstream failure.
+ */
+const SPECIAL_DATES = new Set(["today", "latest", "recent"]);
+/** NOAA-native formats we pass through untouched. */
+const NOAA_DATE_RE = /^(\d{8}|\d{2}\/\d{2}\/\d{4})( \d{2}:\d{2})?$/;
+/** ISO formats we normalize to NOAA's "yyyyMMdd HH:mm". */
+const ISO_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})([T ](\d{2}):(\d{2}))?/;
+/**
+ * Normalize a user-supplied date string to a NOAA-accepted format.
+ * Throws with the list of accepted formats when unparseable.
+ */
+export function normalizeDate(input, paramName) {
+    const trimmed = input.trim();
+    if (NOAA_DATE_RE.test(trimmed))
+        return trimmed;
+    const iso = trimmed.match(ISO_DATE_RE);
+    if (iso) {
+        const base = `${iso[1]}${iso[2]}${iso[3]}`;
+        return iso[4] ? `${base} ${iso[5]}:${iso[6]}` : base;
+    }
+    throw new Error(`Invalid ${paramName} "${input}". Accepted formats: yyyyMMdd, "yyyyMMdd HH:mm", MM/dd/yyyy, "MM/dd/yyyy HH:mm", or ISO yyyy-MM-dd[THH:mm].`);
+}
+/** Parse a normalized NOAA date string into a Date (UTC interpretation). */
+export function parseNoaaDate(normalized) {
+    let year, month, day;
+    let hour = 0, minute = 0;
+    const timeMatch = normalized.match(/ (\d{2}):(\d{2})$/);
+    if (timeMatch) {
+        hour = Number(timeMatch[1]);
+        minute = Number(timeMatch[2]);
+    }
+    const datePart = normalized.split(" ")[0];
+    if (datePart.includes("/")) {
+        const [mm, dd, yyyy] = datePart.split("/");
+        year = Number(yyyy);
+        month = Number(mm);
+        day = Number(dd);
+    }
+    else {
+        year = Number(datePart.slice(0, 4));
+        month = Number(datePart.slice(4, 6));
+        day = Number(datePart.slice(6, 8));
+    }
+    const date = new Date(Date.UTC(year, month - 1, day, hour, minute));
+    if (isNaN(date.getTime())) {
+        throw new Error(`Invalid date "${normalized}".`);
+    }
+    return date;
+}
+/**
+ * Validate that exactly one legal date-parameter combination was supplied,
+ * normalize formats, and compute the request span in days when possible.
+ */
+export function resolveDateParams(params) {
+    const { date, begin_date, end_date, range } = params;
+    if (date !== undefined) {
+        if (begin_date || end_date || range !== undefined) {
+            throw new Error("Use either `date` (today/latest/recent) OR explicit begin_date/end_date/range — not both.");
+        }
+        const lower = date.toLowerCase();
+        if (!SPECIAL_DATES.has(lower)) {
+            throw new Error(`Invalid date "${date}". The \`date\` parameter only accepts: today, latest (most recent single reading), recent (last 72 hours). For a specific day use begin_date and end_date.`);
+        }
+        return { date: lower, spanDays: lower === "recent" ? 3 : 1 };
+    }
+    const begin = begin_date !== undefined
+        ? normalizeDate(begin_date, "begin_date")
+        : undefined;
+    const end = end_date !== undefined ? normalizeDate(end_date, "end_date") : undefined;
+    if (begin && end) {
+        if (range !== undefined) {
+            throw new Error("Provide begin_date+end_date OR a range — not all three.");
+        }
+        const beginDt = parseNoaaDate(begin);
+        const endDt = parseNoaaDate(end);
+        if (endDt <= beginDt) {
+            throw new Error("end_date must be after begin_date.");
+        }
+        const spanDays = (endDt.getTime() - beginDt.getTime()) / 86_400_000;
+        return { begin_date: begin, end_date: end, spanDays };
+    }
+    if (begin && range !== undefined) {
+        return { begin_date: begin, range, spanDays: range / 24 };
+    }
+    if (end && range !== undefined) {
+        return { end_date: end, range, spanDays: range / 24 };
+    }
+    if (range !== undefined) {
+        return { range, spanDays: range / 24 };
+    }
+    if (begin || end) {
+        throw new Error("Incomplete date parameters: pair begin_date with end_date (or with range in hours), or pair end_date with range.");
+    }
+    throw new Error("Missing date parameters. Provide one of: begin_date+end_date, begin_date+range, end_date+range, range alone (hours back from now), or date=today|latest|recent.");
+}
+/**
+ * Per-product/interval maximum request spans (days), from NOAA CO-OPS docs.
+ * Exceeding these returns an upstream error, so we fail fast with guidance.
+ */
+export const MAX_SPAN_DAYS = {
+    one_minute_water_level: 4,
+    water_level: 31,
+    hourly_height: 366,
+    high_low: 366,
+    daily_mean: 3653,
+    daily_max_min: 3653,
+    monthly_mean: 73050,
+    "predictions:hilo": 3653,
+    predictions: 366,
+    currents: 7,
+    "currents_predictions:max_slack": 366,
+    currents_predictions: 31,
+    met: 31,
+    air_gap: 31,
+};
+export function assertSpanWithinLimit(spanDays, limitKey, productLabel) {
+    if (spanDays === undefined)
+        return;
+    const limit = MAX_SPAN_DAYS[limitKey];
+    if (limit !== undefined && spanDays > limit) {
+        throw new Error(`Requested span of ~${Math.ceil(spanDays)} days exceeds NOAA's ${limit}-day maximum per request for ${productLabel}. Split the request into chunks of at most ${limit} days.`);
+    }
+}

package/package.json

@@ -1,21 +1,25 @@
 {
   "name": "@ryancardin/noaa-tides-currents-mcp-server",
-  "version": "1.0.0",
-  "description": "MCP Server that interfaces with NOAA Tides and Currents API using FastMCP",
+  "version": "2.0.0",
+  "description": "MCP server for NOAA CO-OPS Tides and Currents: water levels, tide predictions, currents, meteorology, station metadata, datums, high tide flooding, sea level trends, plus sun and moon calculations",
   "main": "dist/index.js",
   "bin": {
     "noaa-mcp": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
     "start:http": "node dist/index.js --http --port 3000",
-    "start:http:3001": "node dist/index.js --http --port 3001",
-    "start:http:8080": "node dist/index.js --http --port 8080",
-    "dev": "ts-node-esm src/index.ts",
-    "dev:http": "ts-node-esm src/index.ts --http --port 3000",
+    "dev": "tsx src/index.ts",
+    "dev:http": "tsx src/index.ts --http --port 3000",
     "test": "vitest run",
+    "test:live": "node scripts/smoke-live.mjs",
     "format": "prettier --write .",
     "inspector": "npx @modelcontextprotocol/inspector ./dist/index.js"
   },
@@ -23,11 +27,15 @@
     "noaa",
     "tides",
     "currents",
+    "co-ops",
+    "water-levels",
+    "tide-predictions",
     "mcp",
-    "fastmcp",
+    "model-context-protocol",
     "api"
   ],
   "author": "Ryan Cardin",
+  "mcpName": "io.github.ryancardin15/noaa-tides-and-currents-mcp",
   "repository": {
     "type": "git",
     "url": "https://github.com/RyanCardin15/NOAA-Tides-And-Currents-MCP.git"
@@ -40,17 +48,22 @@
     "access": "public"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
   "dependencies": {
-    "axios": "^1.6.2",
-    "fastmcp": "^1.16.3",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "axios": "^1.7.9",
+    "express": "^5.0.0",
     "suncalc": "^1.9.0",
-    "zod": "^3.22.4"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@types/node": "^20.10.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.0",
     "prettier": "^3.0.3",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.3.2",
-    "vitest": "^0.34.6"
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^3.2.4"
   }
 }

package/.claude/settings.local.json

@@ -1,29 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:tidesandcurrents.noaa.gov)",
-      "WebFetch(domain:api.tidesandcurrents.noaa.gov)",
-      "WebFetch(domain:www.tidesandcurrents.noaa.gov)",
-      "WebFetch(domain:gofastmcp.com)",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:deepwiki.com)",
-      "Bash(npm run build:*)",
-      "Bash(npx fastmcp inspect:*)",
-      "Bash(ls:*)",
-      "Bash(node:*)",
-      "Bash(npm test)",
-      "Bash(rm:*)",
-      "Bash(bash -c \"git status\")",
-      "Bash(export:*)",
-      "Bash(/usr/bin/git status)",
-      "Bash(exec /bin/bash -c \"git checkout -b feature/testing-branch\")",
-      "Bash(git checkout:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(npx @modelcontextprotocol/inspector:*)",
-      "Bash(chmod:*)",
-      "Bash(npm pack:*)"
-    ],
-    "deny": []
-  }
-}

package/CLAUDE.md

@@ -1,71 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Development Commands
-
-### Building and Running
-- `npm run build` - Build TypeScript to JavaScript in `dist/` directory
-- `npm start` - Start the MCP server (requires build first)
-- `npm run dev` - Run in development mode with ts-node-esm
-- `npm run format` - Format code with Prettier
-- `npm test` - Run tests with Vitest
-
-### Testing and Development
-- `npx fastmcp dev dist/index.js` - Test server with fastmcp CLI
-- `npx fastmcp inspect dist/index.js` - Inspect server capabilities
-
-## Architecture Overview
-
-This is a FastMCP server that provides tools for accessing NOAA Tides and Currents data, moon phase information, and sun position calculations.
-
-### Core Structure
-- **Entry Point**: `src/index.ts` - Creates server, registers tools, and starts stdio transport
-- **Server Configuration**: `src/server/config.ts` - FastMCP server setup with fixed stdio transport
-- **Tool Registration**: `src/tools/index.ts` - Centralized tool registration hub
-
-### Service Layer
-The application follows a service-oriented architecture:
-- `NoaaService` - Handles all NOAA API interactions (data and metadata APIs)
-- `MoonPhaseService` - Calculates moon phases and lunar information
-- `SunService` - Calculates sun position, rise/set times using suncalc library
-- `NoaaParametersService` - Provides parameter definitions for NOAA API
-
-### Tool Categories
-Tools are organized by functional area:
-- **Water Tools** (`water-tools.ts`) - Water levels, tide predictions, currents
-- **Station Tools** (`station-tools.ts`) - Station metadata and information
-- **Moon Tools** (`moon-tools.ts`) - Moon phase calculations
-- **Sun Tools** (`sun-tools.ts`) - Sun position and event calculations
-- **Parameter Tools** (`parameter-tools.ts`) - API parameter definitions
-
-### Data Validation
-- Uses Zod schemas for parameter validation in `src/schemas/common.ts`
-- Common validation patterns for dates, stations, units, formats, etc.
-- Refined validation for date parameter combinations
-
-### API Integration
-- **NOAA Data API**: `https://api.tidesandcurrents.noaa.gov/api/prod/datagetter`
-- **NOAA Metadata API**: `https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi`
-- Uses axios for HTTP requests with proper error handling
-
-### Key Dependencies
-- `fastmcp` - MCP server framework
-- `axios` - HTTP client for NOAA API calls
-- `suncalc` - Sun position and timing calculations
-- `zod` - Schema validation
-- TypeScript with ES modules and Node16 module resolution
-
-## Important Implementation Notes
-
-### MCP Server Configuration
-The server uses stdio transport exclusively - do not modify to use other transports as this is designed for MCP client integration.
-
-### Error Handling
-NOAA API errors are caught and re-thrown with structured error messages including status codes and response data.
-
-### Date Handling
-The codebase supports multiple date formats and has specific validation logic for date parameter combinations (date vs begin_date/end_date).
-
-### Tool Organization
-Each tool category has its own registration function that accepts the server instance and relevant service(s). This modular approach makes it easy to add new tools or modify existing ones.

package/Dockerfile

@@ -1,14 +0,0 @@
-# Generated by https://smithery.ai. See: https://smithery.ai/docs/config#dockerfile
-FROM node:lts-alpine
-WORKDIR /app
-
-# Install dependencies
-COPY package*.json ./
-RUN npm install --ignore-scripts
-
-# Copy source code and build the project
-COPY . .
-RUN npm run build
-
-# Start the server in stdio mode
-CMD [ "npm", "start" ]

package/smithery.yaml

@@ -1,16 +0,0 @@
-# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml
-
-startCommand:
-  type: stdio
-  configSchema:
-    # Minimal JSON Schema for configuration
-    type: object
-    properties: {}
-  exampleConfig: {}
-  commandFunction:
-    # Simple command to start the MCP server on stdio without additional configuration
-    |-
-    () => ({
-      command: 'node',
-      args: ['dist/index.js']
-    })