@squawk/mcp 0.10.0 → 0.11.0

package/README.md

@@ -98,7 +98,7 @@ version explicitly in the client config:
   "mcpServers": {
     "squawk": {
       "command": "npx",
-      "args": ["-y", "@squawk/mcp@0.10.0"]
+      "args": ["-y", "@squawk/mcp@0.11.0"]
     }
   }
 }
@@ -164,7 +164,7 @@ Pinning works the same way:
   "mcpServers": {
     "squawk": {
       "command": "npx",
-      "args": ["-y", "-p", "@squawk/icao-registry-data@0.8.10", "@squawk/mcp@0.10.0"]
+      "args": ["-y", "-p", "@squawk/icao-registry-data@0.8.10", "@squawk/mcp@0.11.0"]
     }
   }
 }
@@ -263,20 +263,22 @@ directly.
 
 ### Navaids (`@squawk/navaids` + `@squawk/navaid-data`)
 
-| Tool                        | Purpose                                         |
-| --------------------------- | ----------------------------------------------- |
-| `get_navaid_by_ident`       | Look up navaids by identifier                   |
-| `find_navaids_by_frequency` | Find navaids tuned to a given MHz/kHz frequency |
-| `find_nearest_navaids`      | Find navaids nearest a position                 |
-| `search_navaids`            | Fuzzy search by name or identifier              |
+| Tool                              | Purpose                                                  |
+| --------------------------------- | -------------------------------------------------------- |
+| `get_navaid_by_ident`             | Look up navaids by identifier                            |
+| `get_navaid_by_ident_at_position` | Look up the navaid sharing an identifier nearest a point |
+| `find_navaids_by_frequency`       | Find navaids tuned to a given MHz/kHz frequency          |
+| `find_nearest_navaids`            | Find navaids nearest a position                          |
+| `search_navaids`                  | Fuzzy search by name or identifier                       |
 
 ### Fixes (`@squawk/fixes` + `@squawk/fix-data`)
 
-| Tool                 | Purpose                       |
-| -------------------- | ----------------------------- |
-| `get_fix_by_ident`   | Look up fixes by identifier   |
-| `find_nearest_fixes` | Find fixes nearest a position |
-| `search_fixes`       | Fuzzy search by identifier    |
+| Tool                           | Purpose                                               |
+| ------------------------------ | ----------------------------------------------------- |
+| `get_fix_by_ident`             | Look up fixes by identifier                           |
+| `get_fix_by_ident_at_position` | Look up the fix sharing an identifier nearest a point |
+| `find_nearest_fixes`           | Find fixes nearest a position                         |
+| `search_fixes`                 | Fuzzy search by identifier                            |
 
 ### Airways (`@squawk/airways` + `@squawk/airway-data`)
 
@@ -299,6 +301,7 @@ Covers SIDs, STARs, and Instrument Approach Procedures (IAPs) from FAA CIFP.
 | `find_procedures_by_airport_and_runway`   | Procedures at an airport serving a specific runway (IAP runway match or RW\* transition)    |
 | `find_approaches_by_type`                 | Every IAP of a given approach classification (ILS, RNAV, VOR, etc.)                         |
 | `expand_procedure`                        | Expand a procedure into its leg sequence (with optional transition merge)                   |
+| `get_procedure_geometry`                  | Ordered drawable fix points and a GeoJSON LineString for a procedure                        |
 | `search_procedures`                       | Fuzzy search by name or identifier, optionally filtered by procedure or approach type       |
 
 ### ICAO aircraft registry (`@squawk/icao-registry` + `@squawk/icao-registry-data`)
@@ -343,6 +346,8 @@ lookup so sessions that never need it do not pay the cost.
 | ------------------------ | ---------------------------------------------------------- |
 | `parse_flightplan_route` | Parse an ICAO Item 15 route into structured route elements |
 | `compute_route_distance` | Total great-circle route distance with optional ETE        |
+| `get_route_geometry`     | Ordered drawable points and a GeoJSON LineString           |
+| `get_route_timing`       | Per-leg wind-corrected timing, ETE, and fuel/endurance     |
 
 ### Flight computer (`@squawk/flight-math`)
 

package/dist/tools/fixes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../src/tools/fixes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoBzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAoHxD"}
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../src/tools/fixes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoBzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwJxD"}

package/dist/tools/fixes.js

@@ -36,6 +36,34 @@ export function registerFixTools(server) {
             structuredContent: { fixes },
         };
     });
+    server.registerTool('get_fix_by_ident_at_position', {
+        title: 'Get fix by identifier nearest a position',
+        description: 'Looks up the single US fix/waypoint sharing the given identifier that lies nearest to a geographic position. The same fix identifier can be published in more than one ICAO region; this disambiguates the collision by proximity to a known point such as a map-click location or an adjacent route waypoint. When toleranceNm is provided, matches farther than that distance are excluded and the result is null; when omitted, the nearest match wins regardless of distance. Returns null when no fix carries the identifier.',
+        inputSchema: {
+            ident: z.string().min(1).describe('Fix identifier (case-insensitive).'),
+            lat: z
+                .number()
+                .min(-90)
+                .max(90)
+                .describe('Latitude of the reference position in decimal degrees (WGS84).'),
+            lon: z
+                .number()
+                .min(-180)
+                .max(180)
+                .describe('Longitude of the reference position in decimal degrees (WGS84).'),
+            toleranceNm: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Maximum great-circle distance in nautical miles. Omit to let the nearest match win regardless of distance.'),
+        },
+    }, ({ ident, lat, lon, toleranceNm }) => {
+        const fix = fixResolver.byIdentAtPosition(ident, lat, lon, toleranceNm) ?? null;
+        return {
+            content: [{ type: 'text', text: JSON.stringify(fix, null, 2) }],
+            structuredContent: { fix },
+        };
+    });
     server.registerTool('find_nearest_fixes', {
         title: 'Find nearest fixes',
         description: 'Finds US fixes/waypoints near a geographic position, sorted by great-circle distance in nautical miles.',

package/dist/tools/flightplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flightplan.d.ts","sourceRoot":"","sources":["../../src/tools/flightplan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAazE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA4D/D"}
+{"version":3,"file":"flightplan.d.ts","sourceRoot":"","sources":["../../src/tools/flightplan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmBzE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAgJ/D"}

package/dist/tools/flightplan.js

@@ -6,7 +6,7 @@
  * package's `resolvers` module.
  */
 import { z } from 'zod';
-import { computeRouteDistance, createFlightplanResolver } from '@squawk/flightplan';
+import { computeRouteDistance, computeRouteTiming, createFlightplanResolver, extractRoutePoints, routeToLineString, } from '@squawk/flightplan';
 import { airportResolver, airwayResolver, fixResolver, navaidResolver, procedureResolver, } from '../resolvers.js';
 /**
  * Registers flight plan parsing and route distance tools on the given MCP
@@ -41,7 +41,7 @@ export function registerFlightplanTools(server) {
     });
     server.registerTool('compute_route_distance', {
         title: 'Compute route distance and ETE',
-        description: 'Parses a flight plan route string and computes the total great-circle distance in nautical miles, the ordered list of legs with cumulative distance, and (when groundSpeedKt is supplied) the estimated time enroute in hours. Uses FAA-published per-segment distances on airway segments when available; otherwise falls back to great-circle computation. Unresolved tokens are surfaced separately so the caller can decide whether to trust the total.',
+        description: 'Parses a flight plan route string and computes the total great-circle distance in nautical miles, the ordered list of legs with cumulative distance, and (when groundSpeedKt is supplied) the estimated time enroute in hours. Each leg carries the from/to point labels and their latitude/longitude in decimal degrees, so the result doubles as a drawable leg-by-leg geometry. Uses FAA-published per-segment distances on airway segments when available; otherwise falls back to great-circle computation. Unresolved tokens are surfaced separately so the caller can decide whether to trust the total. To get the route as a single ordered point sequence or a GeoJSON LineString for map rendering, use get_route_geometry instead.',
         inputSchema: {
             routeString: z
                 .string()
@@ -61,4 +61,70 @@ export function registerFlightplanTools(server) {
             structuredContent: { result },
         };
     });
+    server.registerTool('get_route_geometry', {
+        title: 'Get drawable route geometry',
+        description: 'Parses a flight plan route string and returns its drawable geometry: the ordered sequence of geographic points (each with a label and latitude/longitude in decimal degrees) and a GeoJSON LineString ready to render as a polyline on a map. Airway and SID/STAR segments are expanded into their constituent fixes, and consecutive duplicate points (e.g. an airway entry fix that matches the preceding waypoint) are suppressed. LineString coordinates follow the GeoJSON [lon, lat] ordering. The lineString field is omitted when the route yields fewer than two drawable points, since a LineString requires at least two positions. Use compute_route_distance instead when you need leg distances or estimated time enroute.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+        },
+    }, ({ routeString }) => {
+        const route = resolver.parse(routeString);
+        const points = extractRoutePoints(route);
+        const lineString = routeToLineString(route);
+        const result = { points, lineString };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
+    server.registerTool('get_route_timing', {
+        title: 'Compute wind-corrected route timing',
+        description: 'Parses a flight plan route string and computes per-leg, wind-corrected timing. For each leg it solves the wind triangle from the leg true course, the given true airspeed, and a uniform wind, yielding true heading, wind correction angle, and ground speed, then estimated time enroute (and fuel burn when fuelBurnPerHr is given). Supply a uniform wind via the optional wind object (direction the wind blows FROM in degrees true, and speed in knots) applied to every leg; omit it to time the route as calm, where ground speed equals true airspeed. When fuelBurnPerHr and fuelAvailable are both given, the result also reports endurance in hours and whether fuel is sufficient for the total time enroute. A leg whose ground speed is not positive (a pure headwind equal to true airspeed) is left untimed, which makes the route ETE and fuel totals null. Use compute_route_distance for plain distance or a single constant-ground-speed ETE without wind correction.',
+        inputSchema: {
+            routeString: z
+                .string()
+                .min(1)
+                .describe('Whitespace-separated route string in ICAO Item 15 conventions.'),
+            trueAirspeedKt: z
+                .number()
+                .positive()
+                .describe('True airspeed in knots flown on every leg.'),
+            wind: z
+                .object({
+                directionDeg: z
+                    .number()
+                    .min(0)
+                    .max(360)
+                    .describe('Direction the wind blows FROM in degrees true (0-360).'),
+                speedKt: z.number().nonnegative().describe('Wind speed in knots.'),
+            })
+                .optional()
+                .describe('Uniform wind applied to every leg. Omit to time the route as calm (ground speed equals true airspeed).'),
+            fuelBurnPerHr: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Optional fuel burn rate per hour in any consistent unit. When given, per-leg and total fuel are computed.'),
+            fuelAvailable: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Optional fuel on board in the same unit as fuelBurnPerHr. With the burn rate, enables endurance and fuel-sufficiency reporting.'),
+        },
+    }, ({ routeString, trueAirspeedKt, wind, fuelBurnPerHr, fuelAvailable }) => {
+        const route = resolver.parse(routeString);
+        const result = computeRouteTiming(route, {
+            trueAirspeedKt,
+            ...(wind !== undefined ? { windProvider: () => wind } : {}),
+            ...(fuelBurnPerHr !== undefined ? { fuelBurnPerHr } : {}),
+            ...(fuelAvailable !== undefined ? { fuelAvailable } : {}),
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: { result },
+        };
+    });
 }

package/dist/tools/navaids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navaids.d.ts","sourceRoot":"","sources":["../../src/tools/navaids.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAyJ3D"}
+{"version":3,"file":"navaids.d.ts","sourceRoot":"","sources":["../../src/tools/navaids.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6L3D"}

package/dist/tools/navaids.js

@@ -38,6 +38,34 @@ export function registerNavaidTools(server) {
             structuredContent: { navaids },
         };
     });
+    server.registerTool('get_navaid_by_ident_at_position', {
+        title: 'Get navaid by identifier nearest a position',
+        description: 'Looks up the single US navaid sharing the given identifier that lies nearest to a geographic position. Multiple navaids can publish the same identifier (a co-located NDB and VOR/DME, or two distant stations reusing a code); this disambiguates them by proximity to a known point such as a map-click location or an adjacent route waypoint. When toleranceNm is provided, matches farther than that distance are excluded and the result is null; when omitted, the nearest match wins regardless of distance. Returns null when no navaid carries the identifier.',
+        inputSchema: {
+            ident: z.string().min(1).describe('Navaid identifier (case-insensitive).'),
+            lat: z
+                .number()
+                .min(-90)
+                .max(90)
+                .describe('Latitude of the reference position in decimal degrees (WGS84).'),
+            lon: z
+                .number()
+                .min(-180)
+                .max(180)
+                .describe('Longitude of the reference position in decimal degrees (WGS84).'),
+            toleranceNm: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Maximum great-circle distance in nautical miles. Omit to let the nearest match win regardless of distance.'),
+        },
+    }, ({ ident, lat, lon, toleranceNm }) => {
+        const navaid = navaidResolver.byIdentAtPosition(ident, lat, lon, toleranceNm) ?? null;
+        return {
+            content: [{ type: 'text', text: JSON.stringify(navaid, null, 2) }],
+            structuredContent: { navaid },
+        };
+    });
     server.registerTool('find_navaids_by_frequency', {
         title: 'Find navaids by frequency',
         description: 'Finds US navaids tuned to a given frequency. VOR-family navaids (VOR, VORTAC, VOR/DME, TACAN, DME, VOT) use MHz; NDB-family navaids (NDB, NDB/DME, MARINE_NDB) use kHz. Filter by navaid types when needed to disambiguate the unit.',

package/dist/tools/procedures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../src/tools/procedures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgCzE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsN9D"}
+{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../src/tools/procedures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAiCzE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAgQ9D"}

package/dist/tools/procedures.js

@@ -5,6 +5,7 @@
  * `@squawk/procedure-data`.
  */
 import { z } from 'zod';
+import { expansionToLineString, extractLegPoints } from '@squawk/procedures';
 import { procedureResolver } from '../resolvers.js';
 /** All {@link ProcedureType} values, used for input validation. */
 const PROCEDURE_TYPE_VALUES = ['SID', 'STAR', 'IAP'];
@@ -127,7 +128,7 @@ export function registerProcedureTools(server) {
     });
     server.registerTool('expand_procedure', {
         title: 'Expand a procedure into an ordered leg sequence',
-        description: "Expands a procedure at an airport into an ordered leg sequence. Without a transition name, returns the procedure's common route. With a transition name, merges the named transition's legs with the common route in flying order (SID: common then transition for enroute exits, transition then common for runway transitions; STAR: transition then common for enroute entries; IAP: approach transition then final approach segment). Returns null when the airport, procedure, or transition is not found.",
+        description: "Expands a procedure at an airport into an ordered leg sequence. Without a transition name, returns the procedure's common route. With a transition name, merges the named transition's legs with the common route in flying order (SID: common then transition for enroute exits, transition then common for runway transitions; STAR: transition then common for enroute entries; IAP: approach transition then final approach segment). Returns null when the airport, procedure, or transition is not found. To get just the drawable point sequence or a GeoJSON LineString for map rendering, use get_procedure_geometry instead.",
         inputSchema: {
             airportId: z.string().min(1).describe('Airport identifier (case-insensitive).'),
             identifier: z.string().min(1).describe('CIFP procedure identifier (case-insensitive).'),
@@ -155,6 +156,42 @@ export function registerProcedureTools(server) {
             structuredContent: { expansion },
         };
     });
+    server.registerTool('get_procedure_geometry', {
+        title: 'Get drawable procedure geometry',
+        description: 'Expands a procedure at an airport (optionally merging a named transition, exactly like expand_procedure) and returns its drawable geometry: the ordered sequence of fix points (each with a label and latitude/longitude in decimal degrees) and a GeoJSON LineString ready to render as a polyline on a map. Only legs that terminate at a known fix contribute a point; ARINC 424 legs that end at an altitude, DME distance, radial, intercept, or manual event (CA, FA, VA, CD, FD, VD, CR, VR, CI, VI, FM, VM, and the HA/HM holds) carry no coordinate and are skipped, so the line breaks across them and is an approximation rather than a precise flyable track. Consecutive duplicate points are suppressed. LineString coordinates follow the GeoJSON [lon, lat] ordering. The lineString field is omitted when fewer than two fix points are drawable. Returns null when the airport, procedure, or transition is not found. Use expand_procedure instead when you need the full leg fields (constraints, courses, path terminators) rather than just geometry.',
+        inputSchema: {
+            airportId: z
+                .string()
+                .min(1)
+                .describe('Airport identifier (ICAO or FAA, case-insensitive).'),
+            identifier: z.string().min(1).describe('CIFP procedure identifier (case-insensitive).'),
+            transitionName: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Optional transition name. Omit to use just the common route.'),
+        },
+    }, ({ airportId, identifier, transitionName }) => {
+        const expansion = procedureResolver.expand(airportId, identifier, transitionName);
+        if (expansion === undefined) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Could not expand procedure "${identifier}" at "${airportId}"${transitionName ? ` with transition "${transitionName}"` : ''}.`,
+                    },
+                ],
+                structuredContent: { points: null, lineString: null },
+            };
+        }
+        const points = extractLegPoints(expansion.legs);
+        const lineString = expansionToLineString(expansion.legs);
+        const result = { points, lineString };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
     server.registerTool('search_procedures', {
         title: 'Search procedures by name or identifier',
         description: 'Fuzzy-searches US instrument procedures (SIDs, STARs, IAPs) across identifier and name. Matching is case-insensitive and tolerant of prefixes, substrings, subsequences, and small typos. Each result carries a match score in [0, 1] (1 is an exact match) and the matched field; results are returned best-match first.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squawk/mcp",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Model Context Protocol server exposing squawk's aviation libraries as tools for LLM clients",
   "author": "Neil Cochran",
@@ -48,18 +48,18 @@
     "@squawk/airway-data": "^0.5.3",
     "@squawk/airways": "^0.5.0",
     "@squawk/fix-data": "^0.6.3",
-    "@squawk/fixes": "^0.4.0",
+    "@squawk/fixes": "^0.5.0",
     "@squawk/flight-math": "^0.5.3",
-    "@squawk/flightplan": "^0.5.1",
+    "@squawk/flightplan": "^0.6.0",
     "@squawk/geo": "^0.4.3",
     "@squawk/icao-registry": "^0.5.1",
     "@squawk/navaid-data": "^0.6.3",
-    "@squawk/navaids": "^0.5.0",
+    "@squawk/navaids": "^0.6.0",
     "@squawk/notams": "^0.3.5",
     "@squawk/procedure-data": "^0.7.2",
-    "@squawk/procedures": "^0.6.0",
+    "@squawk/procedures": "^0.7.0",
     "@squawk/types": "^0.8.0",
-    "@squawk/weather": "^0.5.5",
+    "@squawk/weather": "^0.6.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {