code-auditor-mcp 2.6.2 → 3.0.1

package/dist/utils/reactDetection.js

@@ -1,8 +1,66 @@
 /**
  * React Component Detection Utilities
  * Provides AST-based detection of React components and their properties
+ *
+ * ## Migration: TypeScript Compiler API → tree-sitter
+ *
+ * ### Capability regressions (documented per Spec 08 plan Step 2.5):
+ *
+ * | Check                    | TS API approach                     | tree-sitter approach              | Honest outcome |
+ * |--------------------------|-------------------------------------|-----------------------------------|----------------|
+ * | Prop type from interface | `checker.getTypeAtLocation()`       | Parse type annotation as string   | Recovers for inline types; loses cross-file interface resolution |
+ * | `PropTypes.oneOf`        | Type string from checker            | Match call pattern textually      | Full parity — doesn't need checker |
+ * | Symbol resolution        | `checker.getSymbolAtLocation()`     | Not possible without checker      | Lost — falls through to parameter destructuring heuristics |
  */
-import * as ts from 'typescript';
+import { findNodes, getNodeText, getLineAndColumn } from '../languages/adapterBridge.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Get raw text from a tree-sitter node (stored on ASTNode.raw). */
+function rawText(node) {
+    return node.raw?.text ?? '';
+}
+/** Check if a tree-sitter node type is a function-like declaration. */
+function isFunctionType(type) {
+    return type === 'function_declaration' || type === 'function_expression' || type === 'arrow_function';
+}
+/** Check if a tree-sitter node type is a JSX node. */
+function isJsxType(type) {
+    return type === 'jsx_element' || type === 'jsx_fragment' || type === 'jsx_self_closing_element';
+}
+/**
+ * Check if a name follows React component naming convention (PascalCase)
+ */
+function isComponentName(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+/**
+ * Check if a hook name is a built-in React hook
+ */
+function isBuiltInHook(hookName) {
+    const builtInHooks = [
+        'useState', 'useEffect', 'useContext', 'useReducer', 'useCallback',
+        'useMemo', 'useRef', 'useImperativeHandle', 'useLayoutEffect',
+        'useDebugValue', 'useId', 'useDeferredValue', 'useTransition',
+        'useSyncExternalStore', 'useInsertionEffect'
+    ];
+    return builtInHooks.includes(hookName);
+}
+/**
+ * Find the first child of a given type.
+ */
+function findChildOfType(node, type) {
+    return node.children?.find(c => c.type === type);
+}
+/**
+ * Find all children of a given type.
+ */
+function findChildrenOfType(node, type) {
+    return node.children?.filter(c => c.type === type) ?? [];
+}
+// ---------------------------------------------------------------------------
+// Component detection
+// ---------------------------------------------------------------------------
 /**
  * Check if a node is any type of React component
  */
@@ -13,17 +71,22 @@ export function isReactComponent(node) {
  * Check if a node is a functional React component
  */
 export function isFunctionalComponent(node) {
-    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+    if (node.type === 'function_declaration' || node.type === 'function_expression') {
         return returnsJSX(node);
     }
-    if (ts.isArrowFunction(node)) {
+    if (node.type === 'arrow_function') {
         return returnsJSX(node);
     }
     // Check for variable declarations with arrow functions
-    if (ts.isVariableStatement(node)) {
-        const declaration = node.declarationList.declarations[0];
-        if (declaration && declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-            return returnsJSX(declaration.initializer);
+    // tree-sitter: lexical_declaration / variable_declaration → variable_declarator
+    if (node.type === 'lexical_declaration' || node.type === 'variable_declaration') {
+        const declarator = findChildOfType(node, 'variable_declarator');
+        if (declarator) {
+            // Find the value/initializer (non-identifier child)
+            const initializer = declarator.children?.find(c => c.type !== 'identifier' && c.type !== 'type_annotation');
+            if (initializer && initializer.type === 'arrow_function') {
+                return returnsJSX(initializer);
+            }
         }
     }
     return false;
@@ -32,120 +95,157 @@ export function isFunctionalComponent(node) {
  * Check if a node returns JSX elements
  */
 export function returnsJSX(node) {
-    let hasJSX = false;
-    function visit(child) {
-        if (ts.isJsxElement(child) || ts.isJsxFragment(child) ||
-            ts.isJsxSelfClosingElement(child)) {
-            hasJSX = true;
-        }
-        // Check return statements
-        if (ts.isReturnStatement(child) && child.expression) {
-            if (ts.isJsxElement(child.expression) ||
-                ts.isJsxFragment(child.expression) ||
-                ts.isJsxSelfClosingElement(child.expression)) {
-                hasJSX = true;
-            }
-        }
-        if (!hasJSX) {
-            ts.forEachChild(child, visit);
+    // Check for JSX elements anywhere in the subtree
+    const jsxNodes = findNodes(node, n => isJsxType(n.type));
+    if (jsxNodes.length > 0)
+        return true;
+    // Check for return statements containing JSX
+    const returnNodes = findNodes(node, n => n.type === 'return_statement');
+    for (const ret of returnNodes) {
+        for (const child of ret.children ?? []) {
+            if (isJsxType(child.type))
+                return true;
         }
     }
-    ts.forEachChild(node, visit);
-    return hasJSX;
+    return false;
 }
 /**
  * Check if a node is a class component extending React.Component
  */
 export function isClassComponent(node) {
-    if (!ts.isClassDeclaration(node)) {
+    if (node.type !== 'class_declaration')
         return false;
-    }
-    // Check if class extends React.Component or React.PureComponent
-    if (node.heritageClauses) {
-        for (const clause of node.heritageClauses) {
-            if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-                for (const type of clause.types) {
-                    const expression = type.expression;
-                    // Check for React.Component or React.PureComponent
-                    if (ts.isPropertyAccessExpression(expression)) {
-                        const obj = expression.expression;
-                        const prop = expression.name;
-                        if (ts.isIdentifier(obj) && obj.text === 'React' &&
-                            ts.isIdentifier(prop) && (prop.text === 'Component' || prop.text === 'PureComponent')) {
-                            return true;
-                        }
-                    }
-                    // Check for Component (when imported directly)
-                    if (ts.isIdentifier(expression) &&
-                        (expression.text === 'Component' || expression.text === 'PureComponent')) {
+    // Check heritage clauses for extends React.Component / PureComponent
+    for (const child of node.children ?? []) {
+        if (child.type !== 'heritage_clause')
+            continue;
+        // Check if this is an 'extends' clause (not 'implements')
+        const raw = child.raw;
+        if (!raw?.children)
+            continue;
+        const isExtends = raw.children.some(c => !c.isNamed && c.type === 'extends');
+        if (!isExtends)
+            continue;
+        // Check each type in the extends clause
+        for (const typeNode of child.children ?? []) {
+            if (typeNode.type === 'member_expression') {
+                // React.Component or React.PureComponent
+                const parts = typeNode.children ?? [];
+                if (parts.length >= 2) {
+                    const obj = parts[0];
+                    const prop = parts[parts.length - 1];
+                    if (obj.type === 'identifier' && rawText(obj) === 'React' &&
+                        prop.type === 'property_identifier' &&
+                        (rawText(prop) === 'Component' || rawText(prop) === 'PureComponent')) {
                         return true;
                     }
                 }
             }
+            if (typeNode.type === 'identifier') {
+                const name = rawText(typeNode);
+                if (name === 'Component' || name === 'PureComponent') {
+                    return true;
+                }
+            }
         }
     }
     return false;
 }
+// ---------------------------------------------------------------------------
+// Hook extraction
+// ---------------------------------------------------------------------------
 /**
  * Extract hooks usage from a component node
  */
-export function extractHooks(node, sourceFile) {
+export function extractHooks(node) {
     const hooks = [];
-    function visit(child) {
-        if (ts.isCallExpression(child)) {
-            const expression = child.expression;
-            // Check for hook calls (functions starting with 'use')
-            if (ts.isIdentifier(expression) && expression.text.startsWith('use')) {
-                const line = sourceFile.getLineAndCharacterOfPosition(expression.getStart()).line + 1;
+    // Find all call expressions in the component
+    const callExprs = findNodes(node, n => n.type === 'call_expression');
+    for (const call of callExprs) {
+        // The expression being called is the first child (identifier or member_expression)
+        const callee = call.children?.[0];
+        if (!callee)
+            continue;
+        if (callee.type === 'identifier') {
+            const name = rawText(callee);
+            if (name.startsWith('use')) {
+                const { line } = getLineAndColumn(callee);
                 hooks.push({
-                    name: expression.text,
+                    name,
                     line,
-                    customHook: !isBuiltInHook(expression.text)
+                    customHook: !isBuiltInHook(name)
                 });
             }
         }
-        ts.forEachChild(child, visit);
     }
-    ts.forEachChild(node, visit);
     return hooks;
 }
+// ---------------------------------------------------------------------------
+// Prop type extraction
+// ---------------------------------------------------------------------------
 /**
- * Check if a hook name is a built-in React hook
+ * Extract props from a TypeScript type literal / object_type node.
  */
-function isBuiltInHook(hookName) {
-    const builtInHooks = [
-        'useState', 'useEffect', 'useContext', 'useReducer', 'useCallback',
-        'useMemo', 'useRef', 'useImperativeHandle', 'useLayoutEffect',
-        'useDebugValue', 'useId', 'useDeferredValue', 'useTransition',
-        'useSyncExternalStore', 'useInsertionEffect'
-    ];
-    return builtInHooks.includes(hookName);
+function extractPropsFromTypeLiteral(typeLiteral) {
+    const props = [];
+    for (const member of typeLiteral.children ?? []) {
+        if (member.type !== 'property_signature')
+            continue;
+        const nameNode = member.children?.find(c => c.type === 'identifier' || c.type === 'property_identifier');
+        if (!nameNode)
+            continue;
+        const typeChild = member.children?.find(c => c.type === 'type_annotation');
+        const typeStr = typeChild ? getNodeText(typeChild, '') || rawText(typeChild) : 'any';
+        // Check for optional marker
+        const raw = member.raw;
+        const hasQuestion = raw?.children?.some(c => !c.isNamed && c.type === '?') ?? false;
+        props.push({
+            name: rawText(nameNode),
+            type: typeStr,
+            required: !hasQuestion,
+            hasDefault: false
+        });
+    }
+    return props;
 }
 /**
  * Extract prop types from a component (TypeScript interfaces/types)
+ *
+ * NOTE: Cross-file interface resolution via TypeChecker is NOT available
+ * with tree-sitter. We recover inline types and parameter destructuring,
+ * but type references (e.g. `React.FC<Props>`) without inline definition
+ * will fall through to parameter heuristics.
  */
-export function extractPropTypes(node, sourceFile, typeChecker) {
+export function extractPropTypes(node) {
     const props = [];
     // Handle variable declarations with type annotations (e.g., const Button: React.FC<Props>)
-    if (ts.isVariableDeclaration(node) && node.type && node.initializer) {
-        // Check if it's a React.FC<Props> type
-        if (ts.isTypeReferenceNode(node.type) && node.type.typeArguments?.length) {
-            const propsType = node.type.typeArguments[0];
-            if (ts.isTypeReferenceNode(propsType) && ts.isIdentifier(propsType.typeName)) {
-                // This is a reference to a Props interface, but without TypeChecker we can't resolve it
-                // Instead, check the function parameters for destructured props
-                if (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) {
-                    const firstParam = node.initializer.parameters[0];
-                    if (firstParam && ts.isObjectBindingPattern(firstParam.name)) {
-                        for (const element of firstParam.name.elements) {
-                            if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
-                                props.push({
-                                    name: element.name.text,
-                                    type: 'any',
-                                    required: !element.dotDotDotToken && !element.initializer,
-                                    hasDefault: !!element.initializer
-                                });
-                            }
+    if (node.type === 'variable_declarator') {
+        const typeAnnot = findChildOfType(node, 'type_annotation');
+        const initializer = node.children?.find(c => c.type !== 'identifier' && c.type !== 'type_annotation');
+        // If there's a type annotation, extract props from destructured parameters
+        if (initializer && (initializer.type === 'arrow_function' || initializer.type === 'function_expression')) {
+            const params = findChildOfType(initializer, 'formal_parameters');
+            if (params) {
+                const firstParam = params.children?.[0];
+                if (firstParam) {
+                    // Check for destructured parameter (object pattern)
+                    if (firstParam.type === 'object_pattern' || firstParam.type === 'object_binding_pattern') {
+                        for (const element of firstParam.children ?? []) {
+                            if (element.type !== 'binding_element' && element.type !== 'pair_pattern' &&
+                                element.type !== 'shorthand_property_identifier_pattern')
+                                continue;
+                            const nameNode = element.children?.find(c => c.type === 'identifier' || c.type === 'property_identifier');
+                            if (!nameNode)
+                                continue;
+                            const raw = element.raw;
+                            const hasRest = raw?.children?.some(c => !c.isNamed && c.type === '...') ?? false;
+                            const hasDefault = element.children?.some(c => c.type !== 'identifier' && c.type !== 'property_identifier') ?? false;
+                            props.push({
+                                name: rawText(nameNode),
+                                type: 'any',
+                                required: !hasRest && !hasDefault,
+                                hasDefault
+                            });
                         }
                     }
                 }
@@ -153,57 +253,60 @@ export function extractPropTypes(node, sourceFile, typeChecker) {
         }
     }
     // For functional components, check the first parameter
-    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
-        const firstParam = node.parameters[0];
-        if (firstParam) {
-            // Check if parameter is destructured (common React pattern)
-            if (ts.isObjectBindingPattern(firstParam.name)) {
-                for (const element of firstParam.name.elements) {
-                    if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+    if (isFunctionType(node.type)) {
+        const params = findChildOfType(node, 'formal_parameters');
+        if (params) {
+            const firstParam = params.children?.[0];
+            if (firstParam) {
+                // Check if parameter is destructured
+                if (firstParam.type === 'object_pattern' || firstParam.type === 'object_binding_pattern') {
+                    for (const element of firstParam.children ?? []) {
+                        if (element.type !== 'binding_element' && element.type !== 'shorthand_property_identifier_pattern')
+                            continue;
+                        const nameNode = element.children?.find(c => c.type === 'identifier' || c.type === 'property_identifier');
+                        if (!nameNode)
+                            continue;
+                        const raw = element.raw;
+                        const hasRest = raw?.children?.some(c => !c.isNamed && c.type === '...') ?? false;
+                        const hasDefault = element.children?.some(c => c.type !== 'identifier' && c.type !== 'property_identifier') ?? false;
                         props.push({
-                            name: element.name.text,
-                            type: 'any', // Without full type resolution
-                            required: !element.dotDotDotToken && !element.initializer,
-                            hasDefault: !!element.initializer
+                            name: rawText(nameNode),
+                            type: 'any',
+                            required: !hasRest && !hasDefault,
+                            hasDefault
                         });
                     }
                 }
-            }
-            // Extract props from type annotation
-            if (firstParam.type) {
-                if (ts.isTypeLiteralNode(firstParam.type)) {
-                    extractPropsFromTypeLiteral(firstParam.type, props);
-                }
-                else if (ts.isTypeReferenceNode(firstParam.type) && typeChecker) {
-                    // Handle interface references
-                    const symbol = typeChecker.getSymbolAtLocation(firstParam.type.typeName);
-                    if (symbol) {
-                        const type = typeChecker.getTypeOfSymbolAtLocation(symbol, firstParam.type);
-                        const propSymbols = type.getProperties();
-                        for (const propSymbol of propSymbols) {
-                            const propType = typeChecker.getTypeOfSymbolAtLocation(propSymbol, propSymbol.valueDeclaration);
-                            props.push({
-                                name: propSymbol.getName(),
-                                type: typeChecker.typeToString(propType),
-                                required: !(propSymbol.flags & ts.SymbolFlags.Optional),
-                                hasDefault: false // TODO: Detect default props
-                            });
-                        }
+                // Extract props from type annotation on parameter
+                const typeAnnot = findChildOfType(firstParam, 'type_annotation');
+                if (typeAnnot && typeAnnot.children?.[0]) {
+                    const typeNode = typeAnnot.children[0];
+                    if (typeNode.type === 'object_type' || typeNode.type === 'type_literal') {
+                        props.push(...extractPropsFromTypeLiteral(typeNode));
                     }
+                    // NOTE: type_reference (interface references) can't be resolved
+                    // without TypeChecker — this is a known tree-sitter limitation.
                 }
             }
         }
     }
-    // For class components, check Props interface/type
-    if (ts.isClassDeclaration(node) && node.heritageClauses) {
-        // Look for Props type in extends clause (e.g., React.Component<Props>)
-        for (const clause of node.heritageClauses) {
-            if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-                for (const type of clause.types) {
-                    if (type.typeArguments && type.typeArguments.length > 0) {
-                        const propsType = type.typeArguments[0];
-                        if (ts.isTypeLiteralNode(propsType)) {
-                            extractPropsFromTypeLiteral(propsType, props);
+    // For class components, check Props in extends clause
+    if (node.type === 'class_declaration') {
+        for (const child of node.children ?? []) {
+            if (child.type !== 'heritage_clause')
+                continue;
+            const raw = child.raw;
+            const isExtends = raw?.children?.some(c => !c.isNamed && c.type === 'extends') ?? false;
+            if (!isExtends)
+                continue;
+            for (const typeNode of child.children ?? []) {
+                if (typeNode.type === 'generic_type') {
+                    // React.Component<Props> — type_arguments contain the props type
+                    const typeArgs = findChildOfType(typeNode, 'type_arguments');
+                    if (typeArgs?.children) {
+                        const firstArg = typeArgs.children[0];
+                        if (firstArg?.type === 'object_type' || firstArg?.type === 'type_literal') {
+                            props.push(...extractPropsFromTypeLiteral(firstArg));
                         }
                     }
                 }
@@ -212,131 +315,140 @@ export function extractPropTypes(node, sourceFile, typeChecker) {
     }
     return props;
 }
+// ---------------------------------------------------------------------------
+// Component import extraction
+// ---------------------------------------------------------------------------
 /**
- * Extract props from a TypeScript type literal
+ * Extract component imports from an AST.
  */
-function extractPropsFromTypeLiteral(typeLiteral, props) {
-    for (const member of typeLiteral.members) {
-        if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
-            props.push({
-                name: member.name.text,
-                type: member.type ? member.type.getText() : 'any',
-                required: !member.questionToken,
-                hasDefault: false
-            });
-        }
-    }
-}
-/**
- * Extract component imports from a source file
- */
-export function extractComponentImports(sourceFile) {
+export function extractComponentImports(astRoot) {
     const imports = [];
-    function visit(node) {
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier)) {
-                const importPath = moduleSpecifier.text;
-                // Check if it's likely a component import (local files, not node_modules)
-                if (importPath.startsWith('.') || importPath.startsWith('/')) {
-                    const importClause = node.importClause;
-                    if (importClause) {
-                        // Default import
-                        if (importClause.name) {
-                            const name = importClause.name.text;
-                            if (isComponentName(name)) {
-                                imports.push({
-                                    name,
-                                    path: importPath,
-                                    isDefault: true
-                                });
-                            }
-                        }
-                        // Named imports
-                        if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-                            for (const element of importClause.namedBindings.elements) {
-                                const name = element.name.text;
-                                if (isComponentName(name)) {
-                                    imports.push({
-                                        name,
-                                        path: importPath,
-                                        isDefault: false
-                                    });
-                                }
-                            }
+    const importNodes = findNodes(astRoot, n => n.type === 'import_statement');
+    for (const imp of importNodes) {
+        // Find module specifier (string child)
+        const moduleNode = findChildOfType(imp, 'string');
+        if (!moduleNode)
+            continue;
+        const rawSpecifier = rawText(moduleNode);
+        const importPath = rawSpecifier.replace(/^["']|["']$/g, '');
+        // Only check local imports (not node_modules)
+        if (!importPath.startsWith('.') && !importPath.startsWith('/'))
+            continue;
+        const importClause = findChildOfType(imp, 'import_clause');
+        if (!importClause)
+            continue;
+        // Default import (identifier child of import_clause)
+        for (const child of importClause.children ?? []) {
+            if (child.type === 'identifier') {
+                const name = rawText(child);
+                if (isComponentName(name)) {
+                    imports.push({ name, path: importPath, isDefault: true });
+                }
+            }
+            // Named imports
+            if (child.type === 'named_imports') {
+                for (const spec of child.children ?? []) {
+                    if (spec.type !== 'import_specifier')
+                        continue;
+                    // The last identifier in the specifier is the local name
+                    const identifiers = spec.children?.filter(c => c.type === 'identifier') ?? [];
+                    const localName = identifiers[identifiers.length - 1];
+                    if (localName) {
+                        const name = rawText(localName);
+                        if (isComponentName(name)) {
+                            imports.push({ name, path: importPath, isDefault: false });
                         }
                     }
                 }
             }
         }
-        ts.forEachChild(node, visit);
     }
-    visit(sourceFile);
     return imports;
 }
-/**
- * Check if a name follows React component naming convention (PascalCase)
- */
-function isComponentName(name) {
-    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
-}
+// ---------------------------------------------------------------------------
+// Component type detection
+// ---------------------------------------------------------------------------
 /**
  * Detect the specific type of component (functional, class, memo, forwardRef)
  */
 export function detectComponentType(node) {
-    // Check for memo wrapped components
-    if (ts.isCallExpression(node)) {
-        const expression = node.expression;
-        if ((ts.isIdentifier(expression) && expression.text === 'memo') ||
-            (ts.isPropertyAccessExpression(expression) &&
-                ts.isIdentifier(expression.expression) && expression.expression.text === 'React' &&
-                ts.isIdentifier(expression.name) && expression.name.text === 'memo')) {
-            return 'memo';
-        }
-        // Check for forwardRef
-        if ((ts.isIdentifier(expression) && expression.text === 'forwardRef') ||
-            (ts.isPropertyAccessExpression(expression) &&
-                ts.isIdentifier(expression.expression) && expression.expression.text === 'React' &&
-                ts.isIdentifier(expression.name) && expression.name.text === 'forwardRef')) {
-            return 'forwardRef';
+    // Check for call expression wrapping (memo, forwardRef)
+    if (node.type === 'call_expression') {
+        const callee = node.children?.[0];
+        if (callee) {
+            if (callee.type === 'identifier') {
+                const name = rawText(callee);
+                if (name === 'memo')
+                    return 'memo';
+                if (name === 'forwardRef')
+                    return 'forwardRef';
+            }
+            if (callee.type === 'member_expression') {
+                const parts = callee.children ?? [];
+                if (parts.length >= 2) {
+                    const obj = parts[0];
+                    const prop = parts[parts.length - 1];
+                    if (obj.type === 'identifier' && rawText(obj) === 'React') {
+                        const propName = rawText(prop);
+                        if (propName === 'memo')
+                            return 'memo';
+                        if (propName === 'forwardRef')
+                            return 'forwardRef';
+                    }
+                }
+            }
         }
     }
-    if (isClassComponent(node)) {
+    if (isClassComponent(node))
         return 'class';
-    }
-    if (isFunctionalComponent(node)) {
+    if (isFunctionalComponent(node))
         return 'functional';
-    }
     return null;
 }
+// ---------------------------------------------------------------------------
+// Component name extraction
+// ---------------------------------------------------------------------------
 /**
  * Get component name from various declaration patterns
  */
 export function getComponentName(node) {
     // Function declaration
-    if (ts.isFunctionDeclaration(node) && node.name) {
-        return node.name.text;
+    if (node.type === 'function_declaration') {
+        const nameNode = findChildOfType(node, 'identifier');
+        if (nameNode)
+            return rawText(nameNode);
     }
     // Class declaration
-    if (ts.isClassDeclaration(node) && node.name) {
-        return node.name.text;
+    if (node.type === 'class_declaration') {
+        const nameNode = findChildOfType(node, 'identifier');
+        if (nameNode)
+            return rawText(nameNode);
     }
-    // Variable declaration with arrow function or function expression
-    if (ts.isVariableStatement(node)) {
-        const declaration = node.declarationList.declarations[0];
-        if (declaration && ts.isIdentifier(declaration.name)) {
-            return declaration.name.text;
+    // Variable declaration / lexical declaration
+    if (node.type === 'lexical_declaration' || node.type === 'variable_declaration') {
+        const declarator = findChildOfType(node, 'variable_declarator');
+        if (declarator) {
+            const nameNode = declarator.children?.find(c => c.type === 'identifier');
+            if (nameNode)
+                return rawText(nameNode);
         }
     }
-    // Variable declaration (direct)
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-        return node.name.text;
+    // Variable declarator (direct)
+    if (node.type === 'variable_declarator') {
+        const nameNode = node.children?.find(c => c.type === 'identifier');
+        if (nameNode)
+            return rawText(nameNode);
     }
     // For memo/forwardRef wrapped components, try to extract from the argument
-    if (ts.isCallExpression(node) && node.arguments.length > 0) {
-        const firstArg = node.arguments[0];
-        if (ts.isFunctionExpression(firstArg) && firstArg.name) {
-            return firstArg.name.text;
+    if (node.type === 'call_expression') {
+        const args = findChildOfType(node, 'arguments');
+        if (args?.children) {
+            const firstArg = args.children[0];
+            if (firstArg?.type === 'function_expression') {
+                const nameNode = findChildOfType(firstArg, 'identifier');
+                if (nameNode)
+                    return rawText(nameNode);
+            }
         }
     }
     return 'AnonymousComponent';