@geometra/mcp 1.19.10 → 1.19.12

package/dist/session.d.ts

@@ -61,6 +61,23 @@ export interface CompactUiContext {
     scrollY?: number;
     focusedNode?: CompactUiNode;
 }
+export interface NodeContextModel {
+    prompt?: string;
+    section?: string;
+}
+export interface NodeVisibilityModel {
+    intersectsViewport: boolean;
+    fullyVisible: boolean;
+    offscreenAbove: boolean;
+    offscreenBelow: boolean;
+    offscreenLeft: boolean;
+    offscreenRight: boolean;
+}
+export interface NodeScrollHintModel {
+    status: 'visible' | 'partial' | 'offscreen';
+    revealDeltaX: number;
+    revealDeltaY: number;
+}
 export type PageSectionKind = 'landmark' | 'form' | 'dialog' | 'list';
 export type PageArchetype = 'shell' | 'form' | 'dialog' | 'results' | 'content' | 'dashboard';
 interface PageSectionSummaryBase {
@@ -136,6 +153,9 @@ export interface PageFieldModel {
     value?: string;
     state?: A11yNode['state'];
     validation?: A11yNode['validation'];
+    context?: NodeContextModel;
+    visibility?: NodeVisibilityModel;
+    scrollHint?: NodeScrollHintModel;
     bounds?: {
         x: number;
         y: number;
@@ -148,6 +168,9 @@ export interface PageActionModel {
     role: string;
     name?: string;
     state?: A11yNode['state'];
+    context?: NodeContextModel;
+    visibility?: NodeVisibilityModel;
+    scrollHint?: NodeScrollHintModel;
     bounds?: {
         x: number;
         y: number;
@@ -179,10 +202,38 @@ export interface PageSectionDetail {
     summary: {
         headingCount: number;
         fieldCount: number;
+        requiredFieldCount: number;
+        invalidFieldCount: number;
         actionCount: number;
         listCount: number;
         itemCount: number;
     };
+    page: {
+        fields: {
+            offset: number;
+            returned: number;
+            total: number;
+            hasMore: boolean;
+        };
+        actions: {
+            offset: number;
+            returned: number;
+            total: number;
+            hasMore: boolean;
+        };
+        lists: {
+            offset: number;
+            returned: number;
+            total: number;
+            hasMore: boolean;
+        };
+        items: {
+            offset: number;
+            returned: number;
+            total: number;
+            hasMore: boolean;
+        };
+    };
     headings: PageHeadingModel[];
     fields: PageFieldModel[];
     actions: PageActionModel[];
@@ -368,9 +419,15 @@ export declare function buildPageModel(root: A11yNode, options?: {
 export declare function expandPageSection(root: A11yNode, id: string, options?: {
     maxHeadings?: number;
     maxFields?: number;
+    fieldOffset?: number;
+    onlyRequiredFields?: boolean;
+    onlyInvalidFields?: boolean;
     maxActions?: number;
+    actionOffset?: number;
     maxLists?: number;
+    listOffset?: number;
     maxItems?: number;
+    itemOffset?: number;
     maxTextPreview?: number;
     includeBounds?: boolean;
 }): PageSectionDetail | null;

package/dist/session.js

@@ -743,8 +743,103 @@ function primaryAction(node) {
         bounds: cloneBounds(node.bounds),
     };
 }
-function toFieldModel(node, includeBounds = true) {
+function buildVisibility(bounds, viewport) {
+    const visibleLeft = Math.max(0, bounds.x);
+    const visibleTop = Math.max(0, bounds.y);
+    const visibleRight = Math.min(viewport.width, bounds.x + bounds.width);
+    const visibleBottom = Math.min(viewport.height, bounds.y + bounds.height);
+    const hasVisibleIntersection = visibleRight > visibleLeft && visibleBottom > visibleTop;
+    const fullyVisible = bounds.x >= 0 &&
+        bounds.y >= 0 &&
+        bounds.x + bounds.width <= viewport.width &&
+        bounds.y + bounds.height <= viewport.height;
+    return {
+        intersectsViewport: hasVisibleIntersection,
+        fullyVisible,
+        offscreenAbove: bounds.y + bounds.height <= 0,
+        offscreenBelow: bounds.y >= viewport.height,
+        offscreenLeft: bounds.x + bounds.width <= 0,
+        offscreenRight: bounds.x >= viewport.width,
+    };
+}
+function buildScrollHint(bounds, viewport) {
+    const visibility = buildVisibility(bounds, viewport);
+    return {
+        status: visibility.fullyVisible ? 'visible' : visibility.intersectsViewport ? 'partial' : 'offscreen',
+        revealDeltaX: Math.round(bounds.x + bounds.width / 2 - viewport.width / 2),
+        revealDeltaY: Math.round(bounds.y + bounds.height / 2 - viewport.height / 2),
+    };
+}
+function ancestorNodes(root, path) {
+    const out = [];
+    let current = root;
+    for (const index of path) {
+        out.push(current);
+        if (!current.children[index])
+            break;
+        current = current.children[index];
+    }
+    return out;
+}
+function countGroupedChoiceControls(node) {
+    return collectDescendants(node, candidate => candidate.role === 'radio' || candidate.role === 'checkbox' || candidate.role === 'button').length;
+}
+function nearestPromptText(container, target) {
+    const candidates = collectDescendants(container, candidate => (candidate.role === 'heading' || candidate.role === 'text') &&
+        !!sanitizeInlineName(candidate.name, 120) &&
+        pathKey(candidate.path) !== pathKey(target.path));
+    const normalizedTarget = normalizeUiText(target.name ?? '');
+    const best = candidates
+        .filter(candidate => candidate.bounds.y <= target.bounds.y + 8)
+        .map(candidate => {
+        const text = sanitizeInlineName(candidate.name, 120);
+        if (!text)
+            return null;
+        if (normalizeUiText(text) === normalizedTarget)
+            return null;
+        const dy = Math.max(0, target.bounds.y - candidate.bounds.y);
+        const dx = Math.abs(target.bounds.x - candidate.bounds.x);
+        const headingBonus = candidate.role === 'heading' ? -32 : 0;
+        return { text, score: dy * 4 + dx + headingBonus };
+    })
+        .filter((candidate) => !!candidate)
+        .sort((a, b) => a.score - b.score)[0];
+    return best?.text;
+}
+function nodeContext(root, node) {
+    const ancestors = ancestorNodes(root, node.path);
+    let prompt;
+    for (let index = ancestors.length - 1; index >= 0; index--) {
+        const ancestor = ancestors[index];
+        const grouped = countGroupedChoiceControls(ancestor) >= 2;
+        if (grouped || ancestor.role === 'group' || ancestor.role === 'form' || ancestor.role === 'dialog') {
+            prompt = nearestPromptText(ancestor, node);
+            if (prompt)
+                break;
+        }
+    }
+    let section;
+    for (let index = ancestors.length - 1; index >= 0; index--) {
+        const ancestor = ancestors[index];
+        const kind = sectionKindForNode(ancestor);
+        if (!kind)
+            continue;
+        section = sectionDisplayName(ancestor, kind);
+        if (section)
+            break;
+    }
+    if (!prompt && !section)
+        return undefined;
+    return {
+        ...(prompt ? { prompt } : {}),
+        ...(section ? { section } : {}),
+    };
+}
+function toFieldModel(root, node, includeBounds = true) {
     const value = sanitizeInlineName(node.value, 120);
+    const context = nodeContext(root, node);
+    const visibility = buildVisibility(node.bounds, root.bounds);
+    const scrollHint = buildScrollHint(node.bounds, root.bounds);
     return {
         id: nodeIdForPath(node.path),
         role: node.role,
@@ -752,15 +847,24 @@ function toFieldModel(node, includeBounds = true) {
         ...(value ? { value } : {}),
         ...(cloneState(node.state) ? { state: cloneState(node.state) } : {}),
         ...(cloneValidation(node.validation) ? { validation: cloneValidation(node.validation) } : {}),
+        ...(context ? { context } : {}),
+        visibility,
+        scrollHint,
         ...(includeBounds ? { bounds: cloneBounds(node.bounds) } : {}),
     };
 }
-function toActionModel(node, includeBounds = true) {
+function toActionModel(root, node, includeBounds = true) {
+    const context = nodeContext(root, node);
+    const visibility = buildVisibility(node.bounds, root.bounds);
+    const scrollHint = buildScrollHint(node.bounds, root.bounds);
     return {
         id: nodeIdForPath(node.path),
         role: node.role,
         ...(sanitizeInlineName(node.name, 80) ? { name: sanitizeInlineName(node.name, 80) } : {}),
         ...(cloneState(node.state) ? { state: cloneState(node.state) } : {}),
+        ...(context ? { context } : {}),
+        visibility,
+        scrollHint,
         ...(includeBounds ? { bounds: cloneBounds(node.bounds) } : {}),
     };
 }
@@ -931,9 +1035,15 @@ export function expandPageSection(root, id, options) {
         return null;
     const maxHeadings = options?.maxHeadings ?? 6;
     const maxFields = options?.maxFields ?? 18;
+    const fieldOffset = Math.max(0, options?.fieldOffset ?? 0);
+    const onlyRequiredFields = options?.onlyRequiredFields ?? false;
+    const onlyInvalidFields = options?.onlyInvalidFields ?? false;
     const maxActions = options?.maxActions ?? 12;
+    const actionOffset = Math.max(0, options?.actionOffset ?? 0);
     const maxLists = options?.maxLists ?? 8;
+    const listOffset = Math.max(0, options?.listOffset ?? 0);
     const maxItems = options?.maxItems ?? 20;
+    const itemOffset = Math.max(0, options?.itemOffset ?? 0);
     const maxTextPreview = options?.maxTextPreview ?? 6;
     const includeBounds = options?.includeBounds ?? false;
     const headingsAll = sortByBounds(collectDescendants(node, candidate => candidate.role === 'heading' && !!sanitizeInlineName(candidate.name, 80)));
@@ -943,6 +1053,19 @@ export function expandPageSection(root, id, options) {
     const itemsAll = actualKind === 'list'
         ? sortByBounds(collectDescendants(node, candidate => candidate.role === 'listitem'))
         : [];
+    const requiredFieldCount = fieldsAll.filter(field => field.state?.required).length;
+    const invalidFieldCount = fieldsAll.filter(field => field.state?.invalid).length;
+    const filteredFields = fieldsAll.filter(field => {
+        if (onlyRequiredFields && !field.state?.required)
+            return false;
+        if (onlyInvalidFields && !field.state?.invalid)
+            return false;
+        return true;
+    });
+    const pageFields = filteredFields.slice(fieldOffset, fieldOffset + maxFields);
+    const pageActions = actionsAll.slice(actionOffset, actionOffset + maxActions);
+    const pageLists = nestedListsAll.slice(listOffset, listOffset + maxLists);
+    const pageItems = itemsAll.slice(itemOffset, itemOffset + maxItems);
     const name = sectionDisplayName(node, actualKind);
     return {
         id: sectionIdForPath(actualKind, node.path),
@@ -953,15 +1076,49 @@ export function expandPageSection(root, id, options) {
         summary: {
             headingCount: headingsAll.length,
             fieldCount: fieldsAll.length,
+            requiredFieldCount,
+            invalidFieldCount,
             actionCount: actionsAll.length,
             listCount: nestedListsAll.length,
             itemCount: itemsAll.length,
         },
+        page: {
+            fields: {
+                offset: fieldOffset,
+                returned: pageFields.length,
+                total: filteredFields.length,
+                hasMore: fieldOffset + pageFields.length < filteredFields.length,
+            },
+            actions: {
+                offset: actionOffset,
+                returned: pageActions.length,
+                total: actionsAll.length,
+                hasMore: actionOffset + pageActions.length < actionsAll.length,
+            },
+            lists: {
+                offset: listOffset,
+                returned: pageLists.length,
+                total: nestedListsAll.length,
+                hasMore: listOffset + pageLists.length < nestedListsAll.length,
+            },
+            items: {
+                offset: itemOffset,
+                returned: pageItems.length,
+                total: itemsAll.length,
+                hasMore: itemOffset + pageItems.length < itemsAll.length,
+            },
+        },
         headings: headingModels(node, maxHeadings, includeBounds),
-        fields: fieldsAll.slice(0, maxFields).map(field => toFieldModel(field, includeBounds)),
-        actions: actionsAll.slice(0, maxActions).map(action => toActionModel(action, includeBounds)),
-        lists: nestedListSummaries(node, maxLists, node.path),
-        items: itemsAll.slice(0, maxItems).map(item => ({
+        fields: pageFields.map(field => toFieldModel(root, field, includeBounds)),
+        actions: pageActions.map(action => toActionModel(root, action, includeBounds)),
+        lists: pageLists.map(list => ({
+            id: sectionIdForPath('list', list.path),
+            role: list.role,
+            ...(sectionDisplayName(list, 'list') ? { name: sectionDisplayName(list, 'list') } : {}),
+            bounds: cloneBounds(list.bounds),
+            itemCount: collectDescendants(list, candidate => candidate.role === 'listitem').length,
+        })),
+        items: pageItems.map(item => ({
             id: nodeIdForPath(item.path),
             ...(listItemName(item) ? { name: listItemName(item) } : {}),
             ...(includeBounds ? { bounds: cloneBounds(item.bounds) } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.10",
+  "version": "1.19.12",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "ui-testing"
   ],
   "dependencies": {
-    "@geometra/proxy": "^1.19.10",
+    "@geometra/proxy": "^1.19.12",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"