aws-iam-language-server 0.0.9 → 0.0.11

package/src/lib/treesitter/hcl.js

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
 import { Language } from 'web-tree-sitter';
-import { TreeBase } from "./base.js";
+import { nodeRange, TreeBase } from "./base.js";
 export class TreeHcl extends TreeBase {
     static async init() {
         const grammarDir = resolve(import.meta.dirname, '../../grammars');
@@ -65,6 +65,267 @@ export class TreeHcl extends TreeBase {
         }
         return [];
     }
+    getAllPolicyDocuments(uri) {
+        const tree = this.getTree(uri);
+        if (!tree)
+            return [];
+        const root = tree.rootNode;
+        const results = [];
+        // Block mode: statement { ... } — group by parent data block's body
+        const blocks = this.#findAllStatementBlocks(root);
+        const blockGroups = new Map();
+        for (const block of blocks) {
+            const parentBody = block.parent;
+            if (!parentBody || parentBody.type !== 'body')
+                continue;
+            const existing = blockGroups.get(parentBody.id);
+            if (existing) {
+                existing.blocks.push(block);
+            }
+            else {
+                blockGroups.set(parentBody.id, { parentBody, blocks: [block] });
+            }
+        }
+        for (const group of blockGroups.values()) {
+            results.push({
+                range: nodeRange(group.parentBody),
+                policyFormat: 'hcl-block',
+                statements: group.blocks.map((block) => {
+                    const body = block.namedChildren.find((child) => child.type === 'body');
+                    return {
+                        range: nodeRange(block),
+                        entries: body ? this.#buildBlockStatementEntries(body) : [],
+                    };
+                }),
+            });
+        }
+        // Jsonencode mode: jsonencode({ Statement = [...] }) — group by parent tuple
+        const objects = this.#findAllJsonencodeStatementObjects(root);
+        const tupleGroups = new Map();
+        for (const object of objects) {
+            const tuple = this.#findParentTuple(object);
+            if (!tuple)
+                continue;
+            const existing = tupleGroups.get(tuple.id);
+            if (existing) {
+                existing.objects.push(object);
+            }
+            else {
+                tupleGroups.set(tuple.id, { tuple, objects: [object] });
+            }
+        }
+        for (const group of tupleGroups.values()) {
+            results.push({
+                range: nodeRange(group.tuple),
+                policyFormat: 'standard',
+                statements: group.objects.map((object) => ({
+                    range: nodeRange(object),
+                    entries: this.#buildJsonencodeStatementEntries(object),
+                })),
+            });
+        }
+        return results;
+    }
+    #findParentTuple(object) {
+        let current = object.parent;
+        while (current && (current.type === 'collection_value' || current.type === 'expression')) {
+            current = current.parent;
+        }
+        return current?.type === 'tuple' ? current : null;
+    }
+    #findAllStatementBlocks(root) {
+        const results = [];
+        const visit = (node) => {
+            if (node.type === 'block' && this.#getBlockIdentifier(node) === 'statement') {
+                results.push(node);
+                return; // skip descendants
+            }
+            for (const child of node.namedChildren) {
+                visit(child);
+            }
+        };
+        visit(root);
+        return results;
+    }
+    #findAllJsonencodeStatementObjects(root) {
+        const results = [];
+        const visit = (node) => {
+            if (node.type === 'object' && this.#isInsideStatementTuple(node)) {
+                results.push(node);
+                return; // skip descendants
+            }
+            for (const child of node.namedChildren) {
+                visit(child);
+            }
+        };
+        visit(root);
+        return results;
+    }
+    #buildBlockStatementEntries(body) {
+        const entries = [];
+        for (const child of body.namedChildren) {
+            if (child.type === 'attribute') {
+                const id = child.namedChildren.find((c) => c.type === 'identifier');
+                if (!id)
+                    continue;
+                const keyRange = nodeRange(id);
+                const expression = child.namedChildren.find((c) => c.type === 'expression');
+                const values = expression ? this.#readExpressionStatementValues(expression) : [];
+                const valueRange = expression
+                    ? nodeRange(expression)
+                    : {
+                        start: { line: child.endPosition.row, column: child.endPosition.column },
+                        end: { line: child.endPosition.row, column: child.endPosition.column },
+                    };
+                entries.push({ key: id.text, keyRange, values, valueRange });
+            }
+            else if (child.type === 'block') {
+                const blockId = this.#getBlockIdentifier(child);
+                if (!blockId)
+                    continue;
+                const keyIdNode = child.namedChildren.find((c) => c.type === 'identifier');
+                const keyRange = keyIdNode ? nodeRange(keyIdNode) : nodeRange(child);
+                const blockBody = child.namedChildren.find((c) => c.type === 'body');
+                const children = blockBody ? this.#buildBlockStatementEntries(blockBody) : [];
+                const valueRange = blockBody ? nodeRange(blockBody) : nodeRange(child);
+                entries.push({ key: blockId, keyRange, values: [], valueRange, children });
+            }
+        }
+        return entries;
+    }
+    #readExpressionStatementValues(expression) {
+        // Single string literal
+        const literal = expression.namedChildren.find((child) => child.type === 'literal_value');
+        if (literal) {
+            const string = literal.namedChildren.find((child) => child.type === 'string_lit');
+            const template = string?.namedChildren.find((child) => child.type === 'template_literal');
+            if (template?.text)
+                return [{ text: template.text, range: nodeRange(template) }];
+            return [];
+        }
+        // Tuple of strings
+        let tuple = expression.namedChildren.find((child) => child.type === 'tuple');
+        if (!tuple) {
+            const collectionValue = expression.namedChildren.find((child) => child.type === 'collection_value');
+            tuple = collectionValue?.namedChildren.find((child) => child.type === 'tuple') ?? undefined;
+        }
+        if (tuple) {
+            const values = [];
+            for (const element of tuple.namedChildren) {
+                const elementExpression = element.type === 'expression' ? element : null;
+                const elementLiteral = elementExpression?.namedChildren.find((child) => child.type === 'literal_value');
+                const elementString = elementLiteral?.namedChildren.find((child) => child.type === 'string_lit');
+                const elementTemplate = elementString?.namedChildren.find((child) => child.type === 'template_literal');
+                if (elementTemplate?.text)
+                    values.push({ text: elementTemplate.text, range: nodeRange(elementTemplate) });
+            }
+            return values;
+        }
+        return [];
+    }
+    #buildJsonencodeStatementEntries(object) {
+        const entries = [];
+        for (const child of object.namedChildren) {
+            if (child.type !== 'object_elem')
+                continue;
+            const key = this.#getObjectElemKey(child);
+            if (!key)
+                continue;
+            const keyExpression = child.namedChildren.find((c) => c.type === 'expression');
+            const keyId = keyExpression?.namedChildren
+                .find((c) => c.type === 'variable_expr')
+                ?.namedChildren.find((c) => c.type === 'identifier');
+            const keyRange = keyId ? nodeRange(keyId) : nodeRange(child);
+            const expressions = child.namedChildren.filter((c) => c.type === 'expression');
+            const valueExpression = expressions.length >= 2 ? expressions[1] : null;
+            const values = valueExpression ? this.#readJsonencodeExpressionStatementValues(valueExpression) : [];
+            const valueRange = valueExpression
+                ? nodeRange(valueExpression)
+                : {
+                    start: { line: child.endPosition.row, column: child.endPosition.column },
+                    end: { line: child.endPosition.row, column: child.endPosition.column },
+                };
+            const nestedKeys = new Set(['Condition', 'Principal', 'NotPrincipal']);
+            let children;
+            if (nestedKeys.has(key) && valueExpression) {
+                let nestedObject = valueExpression.namedChildren.find((c) => c.type === 'object');
+                if (!nestedObject) {
+                    const collectionValue = valueExpression.namedChildren.find((c) => c.type === 'collection_value');
+                    nestedObject = collectionValue?.namedChildren.find((c) => c.type === 'object') ?? undefined;
+                }
+                if (nestedObject) {
+                    children = this.#buildJsonencodeNestedEntries(nestedObject);
+                }
+            }
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
+    #readJsonencodeExpressionStatementValues(expression) {
+        // Single string literal
+        const literal = expression.namedChildren.find((child) => child.type === 'literal_value');
+        if (literal) {
+            const string = literal.namedChildren.find((child) => child.type === 'string_lit');
+            const template = string?.namedChildren.find((child) => child.type === 'template_literal');
+            if (template?.text)
+                return [{ text: template.text, range: nodeRange(template) }];
+            return [];
+        }
+        // Tuple
+        let tuple = expression.namedChildren.find((child) => child.type === 'tuple');
+        if (!tuple) {
+            const collectionValue = expression.namedChildren.find((child) => child.type === 'collection_value');
+            tuple = collectionValue?.namedChildren.find((child) => child.type === 'tuple') ?? undefined;
+        }
+        if (tuple) {
+            const values = [];
+            for (const element of tuple.namedChildren) {
+                const elementExpression = element.type === 'expression' ? element : null;
+                const elementLiteral = elementExpression?.namedChildren.find((child) => child.type === 'literal_value');
+                const elementString = elementLiteral?.namedChildren.find((child) => child.type === 'string_lit');
+                const elementTemplate = elementString?.namedChildren.find((child) => child.type === 'template_literal');
+                if (elementTemplate?.text)
+                    values.push({ text: elementTemplate.text, range: nodeRange(elementTemplate) });
+            }
+            return values;
+        }
+        return [];
+    }
+    #buildJsonencodeNestedEntries(object) {
+        const entries = [];
+        for (const child of object.namedChildren) {
+            if (child.type !== 'object_elem')
+                continue;
+            const key = this.#getObjectElemKey(child);
+            if (!key)
+                continue;
+            const keyExpression = child.namedChildren.find((c) => c.type === 'expression');
+            const keyId = keyExpression?.namedChildren
+                .find((c) => c.type === 'variable_expr')
+                ?.namedChildren.find((c) => c.type === 'identifier');
+            const keyRange = keyId ? nodeRange(keyId) : nodeRange(child);
+            const expressions = child.namedChildren.filter((c) => c.type === 'expression');
+            const valueExpression = expressions.length >= 2 ? expressions[1] : null;
+            const values = valueExpression ? this.#readJsonencodeExpressionStatementValues(valueExpression) : [];
+            const valueRange = valueExpression
+                ? nodeRange(valueExpression)
+                : {
+                    start: { line: child.endPosition.row, column: child.endPosition.column },
+                    end: { line: child.endPosition.row, column: child.endPosition.column },
+                };
+            let nestedObject;
+            if (valueExpression) {
+                nestedObject = valueExpression.namedChildren.find((c) => c.type === 'object');
+                if (!nestedObject) {
+                    const collectionValue = valueExpression.namedChildren.find((c) => c.type === 'collection_value');
+                    nestedObject = collectionValue?.namedChildren.find((c) => c.type === 'object') ?? undefined;
+                }
+            }
+            const children = nestedObject ? this.#buildJsonencodeNestedEntries(nestedObject) : undefined;
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
     // ---------------------------------------------------------------------------
     // Jsonencode mode — object/object_elem/tuple, PascalCase keys, same as JSON
     // ---------------------------------------------------------------------------

package/src/lib/treesitter/json.d.ts

@@ -1,4 +1,4 @@
-import type { CursorContext, Position, StatementContext } from './base.ts';
+import type { CursorContext, PolicyDocumentNode, Position, StatementContext } from './base.ts';
 import { TreeBase } from './base.ts';
 export declare class TreeJson extends TreeBase {
     #private;
@@ -6,4 +6,5 @@ export declare class TreeJson extends TreeBase {
     getCursorContext(uri: string, position: Position): CursorContext | null;
     getStatementContext(uri: string, position: Position): StatementContext | null;
     getSiblingKeys(uri: string, position: Position): string[];
+    getAllPolicyDocuments(uri: string): PolicyDocumentNode[];
 }

package/src/lib/treesitter/json.js

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
 import { Language } from 'web-tree-sitter';
-import { TreeBase } from "./base.js";
+import { nodeRange, TreeBase } from "./base.js";
 export class TreeJson extends TreeBase {
     static async init() {
         const grammarDir = resolve(import.meta.dirname, '../../grammars');
@@ -59,6 +59,131 @@ export class TreeJson extends TreeBase {
             return [];
         return this.#collectExistingKeys(this.#findInnermostObject(node, statementObject));
     }
+    getAllPolicyDocuments(uri) {
+        const tree = this.getTree(uri);
+        if (!tree)
+            return [];
+        const objects = this.#findAllStatementObjects(tree.rootNode);
+        // Group by parent array (each Statement array = one policy document)
+        const groups = new Map();
+        for (const object of objects) {
+            const array = object.parent;
+            if (!array || array.type !== 'array')
+                continue;
+            const existing = groups.get(array.id);
+            if (existing) {
+                existing.objects.push(object);
+            }
+            else {
+                groups.set(array.id, { array, objects: [object] });
+            }
+        }
+        const results = [];
+        for (const group of groups.values()) {
+            results.push({
+                range: nodeRange(group.array),
+                policyFormat: 'standard',
+                statements: group.objects.map((object) => ({
+                    range: nodeRange(object),
+                    entries: this.#buildStatementEntries(object),
+                })),
+            });
+        }
+        return results;
+    }
+    #findAllStatementObjects(root) {
+        const results = [];
+        const visit = (node) => {
+            if (node.type === 'object' && this.#isInsideStatementArray(node)) {
+                results.push(node);
+                return; // skip descendants
+            }
+            for (const child of node.namedChildren) {
+                visit(child);
+            }
+        };
+        visit(root);
+        return results;
+    }
+    #buildStatementEntries(object) {
+        const entries = [];
+        for (const child of object.namedChildren) {
+            if (child.type !== 'pair')
+                continue;
+            const key = this.#getPairKeyText(child);
+            if (!key)
+                continue;
+            const keyString = child.namedChildren[0];
+            const keyRange = keyString ? nodeRange(keyString) : nodeRange(child);
+            const values = this.#readPairStatementValues(child);
+            const valueRange = this.#getPairValueRange(child);
+            const nestedKeys = new Set(['Condition', 'Principal', 'NotPrincipal']);
+            let children;
+            if (nestedKeys.has(key)) {
+                const valueNode = child.namedChildren[1];
+                if (valueNode?.type === 'object') {
+                    children = this.#buildNestedEntries(valueNode);
+                }
+            }
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
+    #buildNestedEntries(object) {
+        const entries = [];
+        for (const child of object.namedChildren) {
+            if (child.type !== 'pair')
+                continue;
+            const key = this.#getPairKeyText(child);
+            if (!key)
+                continue;
+            const keyString = child.namedChildren[0];
+            const keyRange = keyString ? nodeRange(keyString) : nodeRange(child);
+            const values = this.#readPairStatementValues(child);
+            const valueRange = this.#getPairValueRange(child);
+            const valueNode = child.namedChildren[1];
+            let children;
+            if (valueNode?.type === 'object') {
+                children = this.#buildNestedEntries(valueNode);
+            }
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
+    #readPairStatementValues(pair) {
+        const valueNode = pair.namedChildren[1];
+        if (!valueNode)
+            return [];
+        if (valueNode.type === 'string') {
+            const content = valueNode.namedChildren.find((child) => child.type === 'string_content');
+            if (!content?.text)
+                return [];
+            return [{ text: content.text, range: nodeRange(content) }];
+        }
+        if (valueNode.type === 'array') {
+            const values = [];
+            for (const element of valueNode.namedChildren) {
+                if (element.type !== 'string')
+                    continue;
+                const content = element.namedChildren.find((child) => child.type === 'string_content');
+                if (content?.text) {
+                    values.push({ text: content.text, range: nodeRange(content) });
+                }
+            }
+            return values;
+        }
+        return [];
+    }
+    #getPairValueRange(pair) {
+        const valueNode = pair.namedChildren[1];
+        if (!valueNode) {
+            return {
+                start: { line: pair.endPosition.row, column: pair.endPosition.column },
+                end: { line: pair.endPosition.row, column: pair.endPosition.column },
+            };
+        }
+        return nodeRange(valueNode);
+    }
     #resolveCursorContext(node, statementObject, position) {
         const cursorPath = this.#buildCursorPath(node, statementObject, position);
         return { ...cursorPath, policyFormat: 'standard' };

package/src/lib/treesitter/manager.d.ts

@@ -1,7 +1,9 @@
+import type { Connection } from 'vscode-languageserver';
 import type { TreeBase } from './base.ts';
 export type DocumentFormat = 'yaml' | 'json' | 'hcl';
 export declare class TreeManager {
     #private;
+    constructor(connection: Connection);
     openDocument(uri: string, content: string, languageId: string): Promise<void>;
     updateDocument(uri: string, content: string): Promise<void>;
     closeDocument(uri: string): void;

package/src/lib/treesitter/manager.js

@@ -13,7 +13,12 @@ export class TreeManager {
         hcl: null,
     };
     #uriToFormat = new Map();
+    #connection;
+    constructor(connection) {
+        this.#connection = connection;
+    }
     async openDocument(uri, content, languageId) {
+        this.#connection.console.info(`Opening document: ${uri} with language ID: ${languageId}`);
         const format = TreeManager.#detectFormat(uri, languageId);
         if (!format)
             return;
@@ -24,6 +29,7 @@ export class TreeManager {
         this.#trees[format].openDocument(uri, content);
     }
     async updateDocument(uri, content) {
+        this.#connection.console.debug(`Updating document: ${uri} with length: ${content.length}`);
         const format = this.#uriToFormat.get(uri);
         if (!format)
             return;
@@ -33,6 +39,7 @@ export class TreeManager {
         this.#trees[format].updateDocument(uri, content);
     }
     closeDocument(uri) {
+        this.#connection.console.info(`Closing document: ${uri}`);
         const format = this.#uriToFormat.get(uri);
         if (!format)
             return;

package/src/lib/treesitter/yaml.d.ts

@@ -1,4 +1,4 @@
-import type { CursorContext, Position, StatementContext } from './base.ts';
+import type { CursorContext, PolicyDocumentNode, Position, StatementContext } from './base.ts';
 import { TreeBase } from './base.ts';
 export declare class TreeYaml extends TreeBase {
     #private;
@@ -6,4 +6,5 @@ export declare class TreeYaml extends TreeBase {
     getCursorContext(uri: string, position: Position): CursorContext | null;
     getStatementContext(uri: string, position: Position): StatementContext | null;
     getSiblingKeys(uri: string, position: Position): string[];
+    getAllPolicyDocuments(uri: string): PolicyDocumentNode[];
 }

package/src/lib/treesitter/yaml.js

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
 import { Language } from 'web-tree-sitter';
-import { TreeBase } from "./base.js";
+import { nodeRange, TreeBase } from "./base.js";
 export class TreeYaml extends TreeBase {
     static async init() {
         const grammarDir = resolve(import.meta.dirname, '../../grammars');
@@ -61,6 +61,140 @@ export class TreeYaml extends TreeBase {
             return [];
         return this.#collectExistingKeysAtPath(match.mapping, cursorPath.keys);
     }
+    getAllPolicyDocuments(uri) {
+        const root = this.getTree(uri)?.rootNode;
+        if (!root)
+            return [];
+        const mappings = this.#findAllStatementMappings(root);
+        // Group by parent block_sequence (each sequence = one policy document)
+        const groups = new Map();
+        for (const mapping of mappings) {
+            const sequence = this.#getParentStatementSequence(mapping);
+            if (!sequence)
+                continue;
+            const existing = groups.get(sequence.id);
+            if (existing) {
+                existing.mappings.push(mapping);
+            }
+            else {
+                groups.set(sequence.id, { sequence, mappings: [mapping] });
+            }
+        }
+        const results = [];
+        for (const group of groups.values()) {
+            results.push({
+                range: nodeRange(group.sequence),
+                policyFormat: 'standard',
+                statements: group.mappings.map((mapping) => ({
+                    range: nodeRange(mapping),
+                    entries: this.#buildStatementEntries(mapping),
+                })),
+            });
+        }
+        return results;
+    }
+    #buildStatementEntries(mapping) {
+        const entries = [];
+        for (const child of mapping.namedChildren) {
+            if (child.type !== 'block_mapping_pair')
+                continue;
+            const key = this.#getPairKeyText(child);
+            if (!key)
+                continue;
+            const keyFlow = child.namedChildren.find((c) => c.type === 'flow_node');
+            const keyRange = keyFlow ? nodeRange(keyFlow) : nodeRange(child);
+            const values = this.#readPairStatementValues(child);
+            const valueRange = this.#getPairValueRange(child);
+            const nestedKeys = new Set(['Condition', 'Principal', 'NotPrincipal']);
+            let children;
+            if (nestedKeys.has(key)) {
+                const nestedMapping = this.#findValueBlockMapping(child);
+                if (nestedMapping) {
+                    children = this.#buildNestedEntries(nestedMapping);
+                }
+            }
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
+    #buildNestedEntries(mapping) {
+        const entries = [];
+        for (const child of mapping.namedChildren) {
+            if (child.type !== 'block_mapping_pair')
+                continue;
+            const key = this.#getPairKeyText(child);
+            if (!key)
+                continue;
+            const keyFlow = child.namedChildren.find((c) => c.type === 'flow_node');
+            const keyRange = keyFlow ? nodeRange(keyFlow) : nodeRange(child);
+            const values = this.#readPairStatementValues(child);
+            const valueRange = this.#getPairValueRange(child);
+            // Recurse for deeper nesting (Condition operator → key → values)
+            const nestedMapping = this.#findValueBlockMapping(child);
+            let children;
+            if (nestedMapping) {
+                children = this.#buildNestedEntries(nestedMapping);
+            }
+            entries.push({ key, keyRange, values, valueRange, ...(children ? { children } : {}) });
+        }
+        return entries;
+    }
+    #readPairStatementValues(pair) {
+        if (pair.namedChildren.length < 2)
+            return [];
+        const valueNode = pair.namedChildren[1];
+        // Direct flow_node scalar
+        if (valueNode.type === 'flow_node') {
+            return this.#flowNodeToStatementValue(valueNode);
+        }
+        // block_node wrapping
+        const inner = valueNode.type === 'block_node' ? (valueNode.namedChildren[0] ?? null) : valueNode;
+        if (!inner)
+            return [];
+        if (inner.type === 'flow_node') {
+            return this.#flowNodeToStatementValue(inner);
+        }
+        // Block sequence
+        if (inner.type === 'block_sequence') {
+            const values = [];
+            for (const item of inner.namedChildren) {
+                if (item.type !== 'block_sequence_item')
+                    continue;
+                const flowNode = item.namedChildren.find((child) => child.type === 'flow_node');
+                if (flowNode) {
+                    values.push(...this.#flowNodeToStatementValue(flowNode));
+                }
+            }
+            return values;
+        }
+        // Flow sequence
+        if (inner.type === 'flow_sequence') {
+            const values = [];
+            for (const flowItem of inner.namedChildren) {
+                if (flowItem.type !== 'flow_node')
+                    continue;
+                values.push(...this.#flowNodeToStatementValue(flowItem));
+            }
+            return values;
+        }
+        return [];
+    }
+    #flowNodeToStatementValue(flowNode) {
+        const text = this.#getScalarText(flowNode);
+        if (text === null)
+            return [];
+        return [{ text, range: nodeRange(flowNode) }];
+    }
+    #getPairValueRange(pair) {
+        if (pair.namedChildren.length < 2) {
+            // No value — zero-width range at key end
+            return {
+                start: { line: pair.endPosition.row, column: pair.endPosition.column },
+                end: { line: pair.endPosition.row, column: pair.endPosition.column },
+            };
+        }
+        return nodeRange(pair.namedChildren[1]);
+    }
     /**
      * Traverse the tree from root, collecting every block_mapping that sits inside
      * a Statement sequence. Skip descendants of matched mappings (they can't nest).
@@ -661,6 +795,21 @@ export class TreeYaml extends TreeBase {
                 const keyText = this.#getScalarText(child);
                 if (!keyText)
                     continue;
+                // Cursor within the key text — still typing the key
+                if (position.column < child.endPosition.column) {
+                    const partial = keyText.slice(0, position.column - child.startPosition.column);
+                    return {
+                        keys: [],
+                        role: 'key',
+                        partial,
+                        value: partial,
+                        policyFormat: 'standard',
+                    };
+                }
+                // Cursor at key end — key is complete but ":" hasn't been typed yet
+                if (position.column === child.endPosition.column) {
+                    return null;
+                }
                 return {
                     keys: [keyText],
                     role: 'value',