@showmeonmap/mcp 0.3.2 → 0.4.0

package/dist/toolMeta.js

@@ -72,6 +72,12 @@ export const MCP_TOOL_META = {
         long_running: false,
         rationale: 'Adds a new derived layer; original layer untouched.',
     },
+    focus_area: {
+        requires_confirmation: false,
+        destructive: false,
+        long_running: false,
+        rationale: 'Filters or derives a layer to a server-resolved named area; reversible via undo/clear_filters.',
+    },
     query_features: {
         requires_confirmation: false,
         destructive: false,

package/dist/tools.js

@@ -207,6 +207,8 @@ function envelope(baseUrl, mapId, workspace, mapPlan, nextActionStrings, extras
         })),
         ...(extras.outOfScope ? { outOfScope: extras.outOfScope } : {}),
         ...(extras.clarification ? { clarification: extras.clarification } : {}),
+        ...(extras.opsApplied ? { opsApplied: extras.opsApplied } : {}),
+        ...(extras.contextAnswer ? { contextAnswer: extras.contextAnswer } : {}),
     };
 }
 function toContent(obj) {
@@ -240,6 +242,7 @@ const INVALID_INPUT_HINTS = {
     add_layer: 'Required: map_id, layerPlan (object), rationale. Optional: intent (enum). No other fields accepted.',
     filter_layer: 'Required: map_id, layerId, predicate (object), rationale. Optional: append (boolean), intent (enum).',
     select_within: 'Required: map_id, sourceLayerId, newLayerId, selection ({type:Polygon|MultiPolygon, coordinates}), rationale. Optional: inheritStyle.',
+    focus_area: 'Required: map_id, layerId, areaRef ({kind:"corridor", street, from?, to?} | {kind:"place", name} | {kind:"aroundIntersection", street, cross}), rationale. Optional: mode (filter|select|clip). Pass NAMES — the server resolves geometry from OSM.',
     query_features: 'Required: map_id, layerId, predicate (object), rationale. Optional: limit (1–1000 integer).',
     remove_layer: 'Required: map_id, layerId, rationale, confirmed:true (destructive — layer ids are tombstoned).',
     clear_filters: 'Required: map_id, layerId, rationale, confirmed:true (sensitive — autonomous filter wipe).',
@@ -500,7 +503,7 @@ const READ_ONLY_TOOLS = new Set([
 ]);
 // Tools that reach external/open-world data sources, vs operating purely on
 // already-loaded workspace state.
-const OPEN_WORLD_TOOLS = new Set(['build_map', 'mutate_map', 'add_layer', 'add_fusion_layer']);
+const OPEN_WORLD_TOOLS = new Set(['build_map', 'mutate_map', 'add_layer', 'add_fusion_layer', 'focus_area']);
 // Mutating-but-idempotent setters: re-applying the same call converges to the
 // same state (unlike append-style build_map / add_annotation / tag / undo).
 const IDEMPOTENT_SETTERS = new Set([
@@ -958,6 +961,70 @@ export function createServer(opts) {
         };
         return toContent(await applyOp(map_id, op));
     }));
+    const focusAreaAreaRefShape = z.discriminatedUnion('kind', [
+        z.object({ kind: z.literal('place'), name: z.string().min(1) }),
+        z.object({
+            kind: z.literal('corridor'),
+            street: z.string().min(1),
+            from: z.string().min(1).optional(),
+            to: z.string().min(1).optional(),
+            bufferMeters: z.number().min(30).max(1000).optional(),
+        }),
+        z.object({
+            kind: z.literal('aroundIntersection'),
+            street: z.string().min(1),
+            cross: z.string().min(1),
+            radiusMeters: z.number().min(50).max(5000).optional(),
+        }),
+    ]);
+    const focusAreaShape = {
+        map_id: z.string().min(1),
+        layerId: z.string().min(1),
+        areaRef: focusAreaAreaRefShape,
+        mode: z
+            .enum(['filter', 'select', 'clip'])
+            .optional()
+            .describe('filter (default): hide features outside, reversible. select: copy matches into a new layer. clip: new layer with geometry trimmed at the boundary.'),
+        rationale: rationaleSchema,
+    };
+    registerTool('focus_area', {
+        title: 'Focus a layer on a named area',
+        description: 'Refine an existing layer to a NAMED area the server resolves from OpenStreetMap — a street corridor ("Broadway from Arbutus Street to Main Street"), a place ("Mount Pleasant"), or an intersection surroundings. Pass names only, never coordinates; unresolvable names return a clarification with real nearby candidates instead of guessed geometry. Emits ordinary undoable ops (filter / new layer + camera) and a grounded summary like "kept 37 of 150 features". Costs 1 credit when a mutation lands; clarifications are refunded.',
+        inputSchema: focusAreaShape,
+    }, withValidation('focus_area', focusAreaShape, async ({ map_id, layerId, areaRef, mode, rationale }) => {
+        const entry = await store.get(map_id);
+        if (!entry)
+            throw new Error(`Unknown map_id "${map_id}". Call build_map first.`);
+        logRationale('focus_area', map_id, rationale, { opKind: `focus_area:${areaRef.kind ?? 'unknown'}:${mode ?? 'filter'}` });
+        const resp = (await apiFetch(baseUrl, apiKey, '/api/workspace/focus-area', {
+            workspace: entry.workspace,
+            layerId,
+            areaRef,
+            ...(mode ? { mode } : {}),
+            rationale,
+        }));
+        if (!resp.ok) {
+            throw new Error(`focus_area failed: ${resp.error?.kind ?? 'unknown'} — ${resp.error?.message ?? 'no detail'}`);
+        }
+        // Honest resolver failure: nothing changed; surface the clarification.
+        if (resp.mutated === false) {
+            return toContent(envelope(baseUrl, map_id, entry.workspace, entry.mapPlan, undefined, { ...(resp.clarification ? { clarification: resp.clarification } : {}) }));
+        }
+        await store.put(map_id, {
+            workspace: resp.workspace ?? entry.workspace,
+            mapPlan: resp.mapPlan ?? entry.mapPlan,
+            layerFilters: resp.layerFilters ?? {},
+            createdAt: entry.createdAt,
+            lastAccessed: Date.now(),
+        });
+        const focusedPlan = (resp.mapPlan ?? entry.mapPlan);
+        const shared = await persistShareableMap(baseUrl, apiKey, map_id, focusedPlan, rationale);
+        return toContent(envelope(baseUrl, map_id, (resp.workspace ?? entry.workspace), focusedPlan, undefined, {
+            ...(resp.opsApplied ? { opsApplied: resp.opsApplied } : {}),
+            ...(resp.contextAnswer ? { contextAnswer: resp.contextAnswer } : {}),
+            ...(shared ? {} : { shareUnpersisted: true }),
+        }));
+    }));
     const queryFeaturesShape = {
         map_id: z.string().min(1),
         layerId: z.string().min(1),

package/dist/workspaceOpsSpec.md

@@ -57,6 +57,7 @@ Every op carries common fields:
 | `renameLayer`        | `{ oldLayerId, newLayerId }` — re-keys filters. newLayerId must be unique (incl. tombstones).         |
 | `restyleLayer`       | `{ layerId, color?: string, opacity?: number }` — within-palette style change.                         |
 | `subsetToSelection`  | `{ sourceLayerId, newLayerId, selection: GeoJSONPolygon, inheritStyle?: boolean }`                    |
+| `clipLayer`          | `{ sourceLayerId, newLayerId, clip: GeoJSONPolygon, inheritStyle?: boolean }` — new layer with geometry TRIMMED at the clip boundary (crossing lines keep only their inside span; polygons intersected; outside features dropped). Requires an inline-geojson source. Prefer the `focus_area` tool for NAMED areas — it resolves streets/places server-side so you never hand-build the polygon. |
 | `setCamera`          | `{ camera: CameraPlan }` — latest setCamera op wins on replay.                                          |
 | `setBasemap`         | `{ basemap: 'light'\|'dark'\|'streets'\|'satellite'\|'engineering' }`                                 |
 | `setTime`            | `{ field, rangeStart, rangeEnd, format?: 'unix_ms'\|'iso'\|'integer' }`                                |
@@ -92,8 +93,9 @@ exceeds the GPU's expressiveness (e.g. spatial `within`).
 ### Spatial predicates
 
 ```ts
-{ op: 'within', geometry: { type: 'Polygon', coordinates: [[ [lng,lat], ... ]] } }
+{ op: 'within', geometry: { type: 'Polygon', coordinates: [[ [lng,lat], ... ]] } }   // feature ENTIRELY inside
 { op: 'intersects', layerId: 'country_borders' }                  // intersect with another layer's geometry
+{ op: 'intersects', geometry: { type: 'Polygon', coordinates: [[ ... ]] } }          // intersect an inline polygon — keeps features crossing the boundary (e.g. a street-corridor focus); pass EXACTLY ONE of layerId | geometry
 { op: 'withinDistance', center: [lng, lat], meters: 5000 }
 { op: 'bbox', box: [west, south, east, north] }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@showmeonmap/mcp",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "mcpName": "com.showmeonmap/maps",
   "description": "MCP server for ShowMeOnMap \u2014 geospatial visualization tools for any MCP-speaking agent (Claude Desktop, Cursor, Zed, ChatGPT Apps SDK)",
   "type": "module",