aws-iam-ls 0.0.0

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

@@ -0,0 +1,9 @@
+import type { CursorContext, Position, StatementContext } from './base.ts';
+import { TreeBase } from './base.ts';
+export declare class TreeJson extends TreeBase {
+    #private;
+    static init(): Promise<TreeJson>;
+    getCursorContext(uri: string, position: Position): CursorContext | null;
+    getStatementContext(uri: string, position: Position): StatementContext | null;
+    getSiblingKeys(uri: string, position: Position): string[];
+}

package/src/lib/treesitter/json.js

@@ -0,0 +1,376 @@
+import { resolve } from 'node:path';
+import { Language } from 'web-tree-sitter';
+import { TreeBase } from "./base.js";
+export class TreeJson extends TreeBase {
+    static async init() {
+        const grammarDir = resolve(import.meta.dirname, '../../grammars');
+        const language = await Language.load(resolve(grammarDir, 'tree-sitter-json.wasm'));
+        return new TreeJson(language);
+    }
+    getCursorContext(uri, position) {
+        const node = this.getNodeAtPosition(uri, position);
+        if (!node)
+            return null;
+        const nodeBefore = position.column > 0 ? this.getNodeAtPosition(uri, { line: position.line, column: position.column - 1 }) : null;
+        // Cursor right after closing quote — no completions
+        if (this.#isCursorAfterClosingQuote(nodeBefore))
+            return null;
+        // Cursor inside an array but outside any string — no completions
+        if (this.#isCursorOutsideStringInArray(node, nodeBefore))
+            return null;
+        // JSON requires cursor to be inside a string (after/within quotes)
+        if (!this.#isInsideString(node) && (!nodeBefore || !this.#isInsideString(nodeBefore)))
+            return null;
+        let statementObject = this.#findStatementObject(node);
+        if (!statementObject && nodeBefore) {
+            statementObject = this.#findStatementObject(nodeBefore);
+        }
+        if (!statementObject)
+            return null;
+        const context1 = this.#resolveCursorContext(node, statementObject, position);
+        const context2 = nodeBefore ? this.#resolveCursorContext(nodeBefore, statementObject, position) : null;
+        return this.#pickBestCursorContext(context1, context2);
+    }
+    getStatementContext(uri, position) {
+        const node = this.getNodeAtPosition(uri, position);
+        if (!node)
+            return null;
+        let statementObject = this.#findStatementObject(node);
+        if (!statementObject && position.column > 0) {
+            const nodeBefore = this.getNodeAtPosition(uri, { line: position.line, column: position.column - 1 });
+            if (nodeBefore)
+                statementObject = this.#findStatementObject(nodeBefore);
+        }
+        if (!statementObject)
+            return null;
+        return this.#extractStatementContext(statementObject);
+    }
+    getSiblingKeys(uri, position) {
+        const node = this.getNodeAtPosition(uri, position);
+        if (!node)
+            return [];
+        let statementObject = this.#findStatementObject(node);
+        if (!statementObject && position.column > 0) {
+            const nodeBefore = this.getNodeAtPosition(uri, { line: position.line, column: position.column - 1 });
+            if (nodeBefore)
+                statementObject = this.#findStatementObject(nodeBefore);
+        }
+        if (!statementObject)
+            return [];
+        return this.#collectExistingKeys(this.#findInnermostObject(node, statementObject));
+    }
+    #resolveCursorContext(node, statementObject, position) {
+        const cursorPath = this.#buildCursorPath(node, statementObject, position);
+        return { ...cursorPath, policyFormat: 'standard' };
+    }
+    #pickBestCursorContext(a, b) {
+        if (!a)
+            return b;
+        if (!b)
+            return a;
+        if (a.partial === '' && b.partial !== '')
+            return b;
+        if (a.partial === '' && b.partial === '' && b.keys.length > a.keys.length)
+            return b;
+        return a;
+    }
+    /**
+     * Walk up from cursor to statement object, building the chain of pair
+     * keys crossed along the way.
+     */
+    #buildCursorPath(cursorNode, statementObject, position) {
+        const keys = [];
+        let role = null;
+        let previous = null;
+        let current = cursorNode;
+        while (current && current.id !== statementObject.id) {
+            if (current.type === 'object' && role === null) {
+                role = 'key';
+            }
+            if (current.type === 'pair') {
+                const pairKey = this.#getPairKeyText(current);
+                if (role === null) {
+                    if (previous && current.namedChildren[0] && previous.id === current.namedChildren[0].id) {
+                        role = 'key';
+                    }
+                    else {
+                        role = 'value';
+                        if (pairKey)
+                            keys.unshift(pairKey);
+                    }
+                }
+                else {
+                    if (pairKey)
+                        keys.unshift(pairKey);
+                }
+            }
+            previous = current;
+            current = current.parent;
+        }
+        // When cursor falls on the statementObject (e.g., after an incomplete pair like
+        // "Effect": ), check if a child pair is on the same line — if so, the cursor
+        // is in that pair's value area.
+        if (role === null && cursorNode.id === statementObject.id) {
+            const pairOnLine = statementObject.namedChildren.find((child) => child.type === 'pair' && child.startPosition.row === position.line);
+            if (pairOnLine) {
+                const pairKey = this.#getPairKeyText(pairOnLine);
+                if (pairKey) {
+                    keys.unshift(pairKey);
+                    role = 'value';
+                }
+            }
+        }
+        if (role === null)
+            role = 'key';
+        const partial = this.#extractPartial(cursorNode, position);
+        return { keys, role, partial };
+    }
+    /**
+     * Walk up from a node to find an object that sits inside a Statement array.
+     */
+    #findStatementObject(node) {
+        let current = node;
+        while (current) {
+            if (current.type === 'object' && this.#isInsideStatementArray(current)) {
+                return current;
+            }
+            current = current.parent;
+        }
+        return null;
+    }
+    /**
+     * Check that an object is a direct child of an array whose parent pair
+     * has the key "Statement".
+     */
+    #isInsideStatementArray(object) {
+        if (object.parent?.type !== 'array')
+            return false;
+        const pair = object.parent.parent;
+        if (pair?.type !== 'pair')
+            return false;
+        return this.#getPairKeyText(pair) === 'Statement';
+    }
+    /**
+     * Get the text content of a pair's key (first named child string).
+     */
+    #getPairKeyText(pair) {
+        const keyString = pair.namedChildren[0];
+        if (keyString?.type !== 'string')
+            return null;
+        const content = keyString.namedChildren.find((child) => child.type === 'string_content');
+        return content?.text ?? null;
+    }
+    /**
+     * Find the first object between node and stmtObject (inclusive of node).
+     */
+    #findInnermostObject(node, statementObject) {
+        let current = node;
+        while (current && current.id !== statementObject.id) {
+            if (current.type === 'object')
+                return current;
+            current = current.parent;
+        }
+        return statementObject;
+    }
+    /**
+     * Collect all key names from pair children of an object.
+     */
+    #collectExistingKeys(object) {
+        return object.namedChildren
+            .filter((child) => child.type === 'pair')
+            .map((pair) => this.#getPairKeyText(pair))
+            .filter((key) => key !== null);
+    }
+    /**
+     * Check if a node is inside a string (i.e. cursor is after/within quotes).
+     */
+    #isInsideString(node) {
+        let current = node;
+        while (current) {
+            if (current.type === 'string' || current.type === 'string_content')
+                return true;
+            if (current.type === '"') {
+                // Opening quote means cursor is inside the string; closing quote means outside.
+                const parent = current.parent;
+                if (parent?.type === 'string' && current.id === parent.lastChild?.id)
+                    return false;
+                return true;
+            }
+            if (current.type === 'pair' || current.type === 'object' || current.type === 'array')
+                return false;
+            current = current.parent;
+        }
+        return false;
+    }
+    /**
+     * Check if the cursor is right after a closing quote. The node at the cursor
+     * position may still be inside the string, but the user has finished the string.
+     */
+    #isCursorAfterClosingQuote(nodeBefore) {
+        if (!nodeBefore || nodeBefore.type !== '"')
+            return false;
+        const parent = nodeBefore.parent;
+        if (parent?.type !== 'string')
+            return false;
+        return nodeBefore.id === parent.lastChild?.id;
+    }
+    /**
+     * Check if the cursor is inside an array value but not inside any string.
+     * This is the case for the known `json_no-quote` test failures where the cursor
+     * is between array elements or after `[` but before any `"`.
+     */
+    #isCursorOutsideStringInArray(node, nodeBefore) {
+        const target = nodeBefore ?? node;
+        let current = target;
+        while (current) {
+            if (current.type === 'string' || current.type === 'string_content')
+                return false;
+            if (current.type === 'array')
+                return !this.#isInsideString(node) && (!nodeBefore || !this.#isInsideString(nodeBefore));
+            if (current.type === 'object')
+                return false;
+            current = current.parent;
+        }
+        return false;
+    }
+    /**
+     * Extract the partial text the user has typed, from the nearest string_content
+     * node up to the cursor position.
+     */
+    #extractPartial(node, position) {
+        let current = node;
+        while (current) {
+            if (current.type === 'string_content') {
+                if (position.line === current.startPosition.row) {
+                    return current.text.slice(0, position.column - current.startPosition.column);
+                }
+                return current.text;
+            }
+            if (current.type === 'object' || current.type === 'pair')
+                break;
+            current = current.parent;
+        }
+        return '';
+    }
+    /**
+     * Read string values from a JSON pair's value (string or array of strings).
+     */
+    #readPairStringValues(pair) {
+        const valueNode = pair.namedChildren[1];
+        if (!valueNode)
+            return [];
+        if (valueNode.type === 'string') {
+            const content = valueNode.namedChildren.find((child) => child.type === 'string_content');
+            return content?.text ? [content.text] : [];
+        }
+        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(content.text);
+            }
+            return values;
+        }
+        return [];
+    }
+    /**
+     * Extract the statement structure from a JSON statement object.
+     */
+    #extractStatementContext(statementObject) {
+        const context = {};
+        for (const child of statementObject.namedChildren) {
+            if (child.type !== 'pair')
+                continue;
+            const key = this.#getPairKeyText(child);
+            if (key === 'Sid') {
+                const values = this.#readPairStringValues(child);
+                if (values.length > 0)
+                    context.Sid = values[0];
+            }
+            else if (key === 'Effect') {
+                const values = this.#readPairStringValues(child);
+                if (values.length > 0)
+                    context.Effect = values[0];
+            }
+            else if (key === 'Action') {
+                context.Action = this.#readPairStringValues(child);
+            }
+            else if (key === 'NotAction') {
+                context.NotAction = this.#readPairStringValues(child);
+            }
+            else if (key === 'Resource') {
+                context.Resource = this.#readPairStringValues(child);
+            }
+            else if (key === 'NotResource') {
+                context.NotResource = this.#readPairStringValues(child);
+            }
+            else if (key === 'Principal' || key === 'NotPrincipal') {
+                const value = this.#readPrincipalValue(child);
+                if (value) {
+                    if (key === 'Principal')
+                        context.Principal = value;
+                    else
+                        context.NotPrincipal = value;
+                }
+            }
+            else if (key === 'Condition') {
+                context.Condition = this.#readConditionValue(child);
+            }
+        }
+        return context;
+    }
+    /**
+     * Read a Principal/NotPrincipal value: either "*" or a mapping of type → values.
+     */
+    #readPrincipalValue(pair) {
+        const values = this.#readPairStringValues(pair);
+        if (values.length === 1 && values[0] === '*')
+            return '*';
+        const valueNode = pair.namedChildren[1];
+        if (!valueNode || valueNode.type !== 'object')
+            return null;
+        const result = {};
+        for (const child of valueNode.namedChildren) {
+            if (child.type !== 'pair')
+                continue;
+            const typeKey = this.#getPairKeyText(child);
+            if (typeKey)
+                result[typeKey] = this.#readPairStringValues(child);
+        }
+        return Object.keys(result).length > 0 ? result : null;
+    }
+    /**
+     * Read a Condition block: mapping of operator → (mapping of key → values).
+     */
+    #readConditionValue(pair) {
+        const result = {};
+        const valueNode = pair.namedChildren[1];
+        if (!valueNode || valueNode.type !== 'object')
+            return result;
+        for (const operatorPair of valueNode.namedChildren) {
+            if (operatorPair.type !== 'pair')
+                continue;
+            const operator = this.#getPairKeyText(operatorPair);
+            if (!operator)
+                continue;
+            const innerObject = operatorPair.namedChildren[1];
+            if (!innerObject || innerObject.type !== 'object') {
+                result[operator] = {};
+                continue;
+            }
+            const keys = {};
+            for (const keyPair of innerObject.namedChildren) {
+                if (keyPair.type !== 'pair')
+                    continue;
+                const conditionKey = this.#getPairKeyText(keyPair);
+                if (conditionKey)
+                    keys[conditionKey] = this.#readPairStringValues(keyPair);
+            }
+            result[operator] = keys;
+        }
+        return result;
+    }
+}

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

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

package/src/lib/treesitter/manager.js

@@ -0,0 +1,66 @@
+import { TreeHcl } from "./hcl.js";
+import { TreeJson } from "./json.js";
+import { TreeYaml } from "./yaml.js";
+const languages = {
+    yaml: TreeYaml,
+    json: TreeJson,
+    hcl: TreeHcl,
+};
+export class TreeManager {
+    #trees = {
+        yaml: null,
+        json: null,
+        hcl: null,
+    };
+    #uriToFormat = new Map();
+    async openDocument(uri, content, languageId) {
+        const format = TreeManager.#detectFormat(uri, languageId);
+        if (!format)
+            return;
+        this.#uriToFormat.set(uri, format);
+        if (!this.#trees[format]) {
+            this.#trees[format] = await languages[format].init();
+        }
+        this.#trees[format].openDocument(uri, content);
+    }
+    async updateDocument(uri, content) {
+        const format = this.#uriToFormat.get(uri);
+        if (!format)
+            return;
+        if (!this.#trees[format]) {
+            this.#trees[format] = await languages[format].init();
+        }
+        this.#trees[format].updateDocument(uri, content);
+    }
+    closeDocument(uri) {
+        const format = this.#uriToFormat.get(uri);
+        if (!format)
+            return;
+        if (this.#trees[format]) {
+            this.#trees[format].closeDocument(uri);
+        }
+        this.#uriToFormat.delete(uri);
+    }
+    getLanguageHandler(uri) {
+        const format = this.#uriToFormat.get(uri);
+        if (!format)
+            return null;
+        return this.#trees[format] || null;
+    }
+    static #detectFormat(uri, languageId) {
+        const id = languageId.toLowerCase();
+        if (id.startsWith('yaml'))
+            return 'yaml';
+        if (id.startsWith('json'))
+            return 'json';
+        if (id === 'terraform' || id === 'hcl' || id === 'tofu')
+            return 'hcl';
+        if (uri.endsWith('.yaml') || uri.endsWith('.yml'))
+            return 'yaml';
+        if (uri.endsWith('.json'))
+            return 'json';
+        if (uri.endsWith('.tf') || uri.endsWith('.tofu'))
+            return 'hcl';
+        return undefined;
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { CursorContext, Position, StatementContext } from './base.ts';
+import { TreeBase } from './base.ts';
+export declare class TreeYaml extends TreeBase {
+    #private;
+    static init(): Promise<TreeYaml>;
+    getCursorContext(uri: string, position: Position): CursorContext | null;
+    getStatementContext(uri: string, position: Position): StatementContext | null;
+    getSiblingKeys(uri: string, position: Position): string[];
+}