@amityco/social-plus-vise 0.4.0 → 0.8.0

package/dist/tools/ast.js

@@ -0,0 +1,297 @@
+/**
+ * AST-based deterministic analysis helpers using tree-sitter.
+ *
+ * This module provides syntactic (not type-resolving) analysis for source files.
+ * It is an additive layer alongside the existing regex-based validators.
+ *
+ * Policy: When AST and regex disagree (e.g., regex matches a comment), the regex
+ * result wins for now. AST cleanup of comment false-matches is Phase 4 work.
+ *
+ * Scope: Single-file, single-step identifier resolution only.
+ * No cross-file imports, no type inference, no function boundary traversal.
+ */
+import Parser from "tree-sitter";
+import TypeScriptGrammars from "tree-sitter-typescript";
+import KotlinGrammar from "tree-sitter-kotlin";
+const { typescript: tsGrammar, tsx: tsxGrammar } = TypeScriptGrammars;
+/**
+ * Strip comments from source code using tree-sitter AST.
+ * Replaces comment spans with whitespace (preserving line structure).
+ * Returns original source unchanged if parsing fails.
+ */
+export function stripComments(language, source) {
+    try {
+        const tree = parse(language, source);
+        const commentRanges = [];
+        collectComments(tree.rootNode, commentRanges);
+        if (commentRanges.length === 0)
+            return source;
+        // Replace comment ranges with spaces (preserve newlines for line numbers)
+        const chars = source.split("");
+        for (const { start, end } of commentRanges) {
+            for (let i = start; i < end && i < chars.length; i++) {
+                if (chars[i] !== "\n")
+                    chars[i] = " ";
+            }
+        }
+        return chars.join("");
+    }
+    catch {
+        return source;
+    }
+}
+function collectComments(node, out) {
+    if (node.type === "comment" || node.type === "line_comment" || node.type === "multiline_comment" || node.type === "block_comment") {
+        out.push({ start: node.startIndex, end: node.endIndex });
+        return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            collectComments(child, out);
+    }
+}
+// Parser instances are reusable — one per language.
+const parsers = new Map();
+function getParser(language) {
+    let parser = parsers.get(language);
+    if (!parser) {
+        parser = new Parser();
+        if (language === "tsx")
+            parser.setLanguage(tsxGrammar);
+        else if (language === "kotlin")
+            parser.setLanguage(KotlinGrammar);
+        else
+            parser.setLanguage(tsGrammar);
+        parsers.set(language, parser);
+    }
+    return parser;
+}
+/**
+ * Parse source content into a tree-sitter syntax tree.
+ */
+export function parse(language, source) {
+    const parser = getParser(language);
+    return parser.parse(source);
+}
+/**
+ * Find all call expressions in the tree whose callee matches a pattern.
+ * Returns normalised callee strings and argument nodes.
+ */
+export function findCallExpressions(tree, calleePattern) {
+    const results = [];
+    walkTree(tree.rootNode, (node) => {
+        if (node.type !== "call_expression")
+            return;
+        // TypeScript: uses field names "function" and "arguments"
+        const calleeNode = node.childForFieldName("function");
+        if (calleeNode) {
+            const callee = normaliseCallee(calleeNode);
+            if (!callee || !calleePattern.test(callee))
+                return;
+            const argListNode = node.childForFieldName("arguments");
+            const args = [];
+            if (argListNode) {
+                for (let i = 0; i < argListNode.namedChildCount; i++) {
+                    const child = argListNode.namedChild(i);
+                    if (child)
+                        args.push(child);
+                }
+            }
+            results.push({ callee, node, args });
+            return;
+        }
+        // Kotlin: call_expression = navigation_expression + call_suffix
+        const navNode = node.namedChild(0);
+        const suffixNode = node.namedChild(1);
+        if (!navNode || !suffixNode || suffixNode.type !== "call_suffix")
+            return;
+        const callee = normaliseKotlinCallee(navNode);
+        if (!callee || !calleePattern.test(callee))
+            return;
+        // Extract args from call_suffix → value_arguments → value_argument nodes
+        const args = [];
+        const valArgsNode = suffixNode.namedChild(0);
+        if (valArgsNode && valArgsNode.type === "value_arguments") {
+            for (let i = 0; i < valArgsNode.namedChildCount; i++) {
+                const valArg = valArgsNode.namedChild(i);
+                if (valArg && valArg.type === "value_argument") {
+                    // The actual expression is inside value_argument
+                    const expr = valArg.namedChild(0);
+                    if (expr)
+                        args.push(expr);
+                }
+            }
+        }
+        results.push({ callee, node, args });
+    });
+    return results;
+}
+/**
+ * Resolve an AST node to its literal string value within the same file.
+ *
+ * Handles:
+ * - String literals directly → returns the string value
+ * - Identifiers that reference a const/let/var with a string literal initializer
+ *   (single-step resolution only)
+ *
+ * Returns undefined if the value cannot be statically resolved.
+ */
+export function resolveLiteralValue(node, tree) {
+    // Direct string literal
+    const directValue = extractStringLiteral(node);
+    if (directValue !== undefined)
+        return directValue;
+    // Identifier — try to resolve to declaration in same file
+    // TypeScript uses "identifier", Kotlin uses "simple_identifier"
+    if (node.type === "identifier" || node.type === "simple_identifier") {
+        const name = node.text;
+        return resolveIdentifierToLiteral(name, tree.rootNode);
+    }
+    return undefined;
+}
+/**
+ * Pick a specific named property from an object argument node.
+ * E.g., from `{ userId: HARDCODED }`, pick the value node for "userId".
+ */
+export function pickObjectProperty(objectNode, propertyName) {
+    if (objectNode.type !== "object")
+        return undefined;
+    for (let i = 0; i < objectNode.namedChildCount; i++) {
+        const prop = objectNode.namedChild(i);
+        if (!prop || prop.type !== "pair")
+            continue;
+        const key = prop.childForFieldName("key");
+        if (key && key.text === propertyName) {
+            return prop.childForFieldName("value") ?? undefined;
+        }
+    }
+    return undefined;
+}
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function walkTree(node, visit) {
+    visit(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            walkTree(child, visit);
+    }
+}
+function normaliseCallee(node) {
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "member_expression") {
+        const obj = node.childForFieldName("object");
+        const prop = node.childForFieldName("property");
+        if (obj && prop) {
+            const objName = normaliseCallee(obj);
+            return objName ? `${objName}.${prop.text}` : prop.text;
+        }
+    }
+    return undefined;
+}
+function normaliseKotlinCallee(node) {
+    if (node.type === "simple_identifier")
+        return node.text;
+    if (node.type === "navigation_expression") {
+        // navigation_expression has children: expression + navigation_suffix
+        // e.g., AmityCoreClient.login → nav_expr(simple_id("AmityCoreClient"), nav_suffix(".login"))
+        const parts = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === "simple_identifier") {
+                parts.push(child.text);
+            }
+            else if (child.type === "navigation_suffix") {
+                // navigation_suffix contains a simple_identifier after the dot
+                const id = child.namedChild(0);
+                if (id)
+                    parts.push(id.text);
+            }
+            else if (child.type === "call_expression") {
+                // Chained: obj.method1().method2 — extract the last part from the chain
+                const innerCallee = normaliseKotlinCallee(child.namedChild(0));
+                if (innerCallee)
+                    parts.push(innerCallee);
+            }
+            else {
+                const sub = normaliseKotlinCallee(child);
+                if (sub)
+                    parts.push(sub);
+            }
+        }
+        return parts.length > 0 ? parts.join(".") : undefined;
+    }
+    return node.text?.split(/\s/)[0];
+}
+function extractStringLiteral(node) {
+    if (node.type === "string") {
+        // tree-sitter-typescript: string nodes include the quotes — strip them
+        const text = node.text;
+        if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+            return text.slice(1, -1);
+        }
+        // Template literal with no interpolations
+        if (text.startsWith("`") && text.endsWith("`") && !text.includes("${")) {
+            return text.slice(1, -1);
+        }
+    }
+    // template_string without substitutions
+    if (node.type === "template_string" && node.namedChildCount === 0) {
+        const text = node.text;
+        if (text.startsWith("`") && text.endsWith("`")) {
+            return text.slice(1, -1);
+        }
+    }
+    // Kotlin: string_literal contains string_content child
+    if (node.type === "string_literal") {
+        const contentNode = node.namedChild(0);
+        if (contentNode && contentNode.type === "string_content") {
+            return contentNode.text;
+        }
+        // Simple case — strip quotes from text
+        const text = node.text;
+        if (text.startsWith('"') && text.endsWith('"')) {
+            return text.slice(1, -1);
+        }
+    }
+    return undefined;
+}
+function resolveIdentifierToLiteral(name, root) {
+    let result;
+    walkTree(root, (node) => {
+        if (result !== undefined)
+            return;
+        // TypeScript/JS: variable_declarator with name + value fields
+        if (node.type === "variable_declarator") {
+            const nameNode = node.childForFieldName("name");
+            if (!nameNode || nameNode.text !== name)
+                return;
+            const valueNode = node.childForFieldName("value");
+            if (!valueNode)
+                return;
+            const literal = extractStringLiteral(valueNode);
+            if (literal !== undefined)
+                result = literal;
+            return;
+        }
+        // Kotlin: property_declaration with variable_declaration + string_literal
+        if (node.type === "property_declaration") {
+            const varDecl = node.namedChildren.find((c) => c.type === "variable_declaration");
+            if (!varDecl)
+                return;
+            const idNode = varDecl.namedChildren.find((c) => c.type === "simple_identifier");
+            if (!idNode || idNode.text !== name)
+                return;
+            const strLit = node.namedChildren.find((c) => c.type === "string_literal");
+            if (!strLit)
+                return;
+            const literal = extractStringLiteral(strLit);
+            if (literal !== undefined)
+                result = literal;
+        }
+    });
+    return result;
+}