optave-codegraph 3.13.0

package/src/extractors/python.ts

@@ -0,0 +1,439 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import {
+  findChild,
+  findParentNode,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  pythonVisibility,
+  setTypeMapEntry,
+} from './helpers.js';
+
+/** Built-in globals that start with uppercase but are not user-defined types. */
+const BUILTIN_GLOBALS_PY: Set<string> = new Set([
+  // Uppercase builtins that would false-positive on the factory heuristic
+  'Exception',
+  'BaseException',
+  'ValueError',
+  'TypeError',
+  'KeyError',
+  'IndexError',
+  'AttributeError',
+  'RuntimeError',
+  'OSError',
+  'IOError',
+  'FileNotFoundError',
+  'PermissionError',
+  'NotImplementedError',
+  'StopIteration',
+  'GeneratorExit',
+  'SystemExit',
+  'KeyboardInterrupt',
+  'ArithmeticError',
+  'LookupError',
+  'UnicodeError',
+  'UnicodeDecodeError',
+  'UnicodeEncodeError',
+  'ImportError',
+  'ModuleNotFoundError',
+  'ConnectionError',
+  'TimeoutError',
+  'OverflowError',
+  'ZeroDivisionError',
+  'NameError',
+  'SyntaxError',
+  'RecursionError',
+  'MemoryError',
+  // Common standard library uppercase classes
+  'Path',
+  'PurePath',
+  'OrderedDict',
+  'Counter',
+  'Decimal',
+  'Fraction',
+]);
+
+/**
+ * Extract symbols from Python files.
+ */
+export function extractPythonSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkPythonNode(tree.rootNode, ctx);
+  extractPythonTypeMap(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkPythonNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_definition':
+      handlePyFunctionDef(node, ctx);
+      break;
+    case 'class_definition':
+      handlePyClassDef(node, ctx);
+      break;
+    case 'decorated_definition':
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) walkPythonNode(child, ctx);
+      }
+      return;
+    case 'call':
+      handlePyCall(node, ctx);
+      break;
+    case 'import_statement':
+      handlePyImport(node, ctx);
+      break;
+    case 'expression_statement':
+      handlePyExpressionStmt(node, ctx);
+      break;
+    case 'import_from_statement':
+      handlePyImportFrom(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkPythonNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handlePyFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const decorators: string[] = [];
+  if (node.previousSibling && node.previousSibling.type === 'decorator') {
+    decorators.push(node.previousSibling.text);
+  }
+  const parentClass = findPythonParentClass(node);
+  const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+  const kind = parentClass ? 'method' : 'function';
+  const fnChildren = extractPythonParameters(node, parentClass !== null);
+  ctx.definitions.push({
+    name: fullName,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    decorators,
+    children: fnChildren.length > 0 ? fnChildren : undefined,
+    visibility: pythonVisibility(nameNode.text),
+  });
+}
+
+function handlePyClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const clsChildren = extractPythonClassProperties(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: clsChildren.length > 0 ? clsChildren : undefined,
+  });
+  const superclasses = node.childForFieldName('superclasses') || findChild(node, 'argument_list');
+  if (superclasses) {
+    for (let i = 0; i < superclasses.childCount; i++) {
+      const child = superclasses.child(i);
+      if (child && child.type === 'identifier') {
+        ctx.classes.push({
+          name: nameNode.text,
+          extends: child.text,
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handlePyCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const fn = node.childForFieldName('function');
+  if (!fn) return;
+  let callName: string | null = null;
+  let receiver: string | undefined;
+  if (fn.type === 'identifier') callName = fn.text;
+  else if (fn.type === 'attribute') {
+    const attr = fn.childForFieldName('attribute');
+    if (attr) callName = attr.text;
+    const obj = fn.childForFieldName('object');
+    if (obj) receiver = obj.text;
+  }
+  if (callName) {
+    const call: Call = { name: callName, line: node.startPosition.row + 1 };
+    if (receiver) call.receiver = receiver;
+    ctx.calls.push(call);
+  }
+}
+
+function handlePyImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const names: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && (child.type === 'dotted_name' || child.type === 'aliased_import')) {
+      const name =
+        child.type === 'aliased_import'
+          ? (child.childForFieldName('alias') || child.childForFieldName('name'))?.text
+          : child.text;
+      if (name) names.push(name);
+    }
+  }
+  if (names.length > 0)
+    ctx.imports.push({
+      source: names[0] ?? '',
+      names,
+      line: node.startPosition.row + 1,
+      pythonImport: true,
+    });
+}
+
+function handlePyExpressionStmt(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  if (node.parent && node.parent.type === 'module') {
+    const assignment = findChild(node, 'assignment');
+    if (assignment) {
+      const left = assignment.childForFieldName('left');
+      if (left && left.type === 'identifier' && /^[A-Z_][A-Z0-9_]*$/.test(left.text)) {
+        ctx.definitions.push({
+          name: left.text,
+          kind: 'constant',
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handlePyImportFrom(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  let source = '';
+  const names: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'dotted_name' || child.type === 'relative_import') {
+      if (!source) source = child.text;
+      else names.push(child.text);
+    }
+    if (child.type === 'aliased_import') {
+      const n = child.childForFieldName('name') || child.child(0);
+      if (n) names.push(n.text);
+    }
+    if (child.type === 'wildcard_import') names.push('*');
+  }
+  if (source)
+    ctx.imports.push({ source, names, line: node.startPosition.row + 1, pythonImport: true });
+}
+
+// ── Python-specific helpers ─────────────────────────────────────────────────
+
+function extractPythonParameters(fnNode: TreeSitterNode, isMethod: boolean): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramsNode = fnNode.childForFieldName('parameters') || findChild(fnNode, 'parameters');
+  if (!paramsNode) return params;
+  for (let i = 0; i < paramsNode.childCount; i++) {
+    const child = paramsNode.child(i);
+    if (!child) continue;
+    const param = extractSinglePyParam(child);
+    if (!param) continue;
+    if (isMethod && (param.name === 'self' || param.name === 'cls')) continue;
+    params.push(param);
+  }
+  return params;
+}
+
+/** Extract a single parameter declaration from a parameter node. */
+function extractSinglePyParam(child: TreeSitterNode): SubDeclaration | null {
+  const t = child.type;
+  if (t === 'identifier') {
+    return { name: child.text, kind: 'parameter', line: child.startPosition.row + 1 };
+  }
+  if (t === 'typed_parameter' || t === 'default_parameter' || t === 'typed_default_parameter') {
+    const nameNode = child.childForFieldName('name') || child.child(0);
+    if (nameNode && nameNode.type === 'identifier') {
+      return { name: nameNode.text, kind: 'parameter', line: child.startPosition.row + 1 };
+    }
+  }
+  if (t === 'list_splat_pattern' || t === 'dictionary_splat_pattern') {
+    return extractSplatParam(child);
+  }
+  return null;
+}
+
+/** Extract the identifier name from a *args or **kwargs splat pattern. */
+function extractSplatParam(node: TreeSitterNode): SubDeclaration | null {
+  for (let j = 0; j < node.childCount; j++) {
+    const inner = node.child(j);
+    if (inner && inner.type === 'identifier') {
+      return { name: inner.text, kind: 'parameter', line: node.startPosition.row + 1 };
+    }
+  }
+  return null;
+}
+
+/** Extract class-level assignment properties from expression statements. */
+function extractClassAssignment(
+  child: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const assignment = findChild(child, 'assignment');
+  if (!assignment) return;
+  const left = assignment.childForFieldName('left');
+  if (left?.type !== 'identifier' || seen.has(left.text)) return;
+  seen.add(left.text);
+  props.push({
+    name: left.text,
+    kind: 'property',
+    line: child.startPosition.row + 1,
+    visibility: pythonVisibility(left.text),
+  });
+}
+
+/** If node is an __init__ method, walk its body for self.x assignments. */
+function extractInitProperties(
+  node: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const fnName = node.childForFieldName('name');
+  if (fnName?.text !== '__init__') return;
+  const initBody = node.childForFieldName('body') || findChild(node, 'block');
+  if (initBody) walkInitBody(initBody, seen, props);
+}
+
+function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration[] {
+  const props: SubDeclaration[] = [];
+  const seen = new Set<string>();
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'block');
+  if (!body) return props;
+
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child) continue;
+
+    if (child.type === 'expression_statement') {
+      extractClassAssignment(child, seen, props);
+    } else if (child.type === 'function_definition') {
+      extractInitProperties(child, seen, props);
+    } else if (child.type === 'decorated_definition') {
+      for (let j = 0; j < child.childCount; j++) {
+        const inner = child.child(j);
+        if (inner && inner.type === 'function_definition') {
+          extractInitProperties(inner, seen, props);
+        }
+      }
+    }
+  }
+  return props;
+}
+
+function walkInitBody(bodyNode: TreeSitterNode, seen: Set<string>, props: SubDeclaration[]): void {
+  for (let i = 0; i < bodyNode.childCount; i++) {
+    const stmt = bodyNode.child(i);
+    if (stmt?.type !== 'expression_statement') continue;
+    const assignment = findChild(stmt, 'assignment');
+    if (!assignment) continue;
+    const left = assignment.childForFieldName('left');
+    if (left?.type !== 'attribute') continue;
+    const obj = left.childForFieldName('object');
+    const attr = left.childForFieldName('attribute');
+    if (obj && obj.text === 'self' && attr && attr.type === 'identifier' && !seen.has(attr.text)) {
+      seen.add(attr.text);
+      props.push({
+        name: attr.text,
+        kind: 'property',
+        line: stmt.startPosition.row + 1,
+        visibility: pythonVisibility(attr.text),
+      });
+    }
+  }
+}
+
+function extractPythonTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  extractPythonTypeMapDepth(node, ctx, 0);
+}
+
+/** Handle typed_parameter or typed_default_parameter for type map. */
+function handlePyTypedParam(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const isDefault = node.type === 'typed_default_parameter';
+  const nameNode = isDefault ? node.childForFieldName('name') : node.child(0);
+  const typeNode = node.childForFieldName('type');
+  if (nameNode?.type !== 'identifier' || !typeNode) return;
+  if (nameNode.text === 'self' || nameNode.text === 'cls') return;
+  const typeName = extractPythonTypeName(typeNode);
+  if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
+}
+
+/** Handle assignment for constructor/factory type inference. */
+function handlePyAssignmentType(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const left = node.childForFieldName('left');
+  const right = node.childForFieldName('right');
+  if (left?.type !== 'identifier' || !right || right.type !== 'call') return;
+
+  const fn = right.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'identifier') {
+    const name = fn.text;
+    if (name[0] && name[0] !== name[0].toLowerCase()) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, name, 1.0);
+    }
+  } else if (fn.type === 'attribute') {
+    const obj = fn.childForFieldName('object');
+    if (obj?.type !== 'identifier') return;
+    const objName = obj.text;
+    if (objName[0] && objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS_PY.has(objName)) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, objName, 0.7);
+    }
+  }
+}
+
+function extractPythonTypeMapDepth(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  depth: number,
+): void {
+  if (depth >= MAX_WALK_DEPTH) return;
+
+  if (node.type === 'typed_parameter' || node.type === 'typed_default_parameter') {
+    handlePyTypedParam(node, ctx);
+  } else if (node.type === 'assignment') {
+    handlePyAssignmentType(node, ctx);
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractPythonTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractPythonTypeName(typeNode: TreeSitterNode): string | null {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'identifier') return typeNode.text;
+  if (t === 'attribute') return typeNode.text; // module.Type
+  // Generic: List[int] → subscript → value is identifier
+  if (t === 'subscript') {
+    const value = typeNode.childForFieldName('value');
+    return value ? value.text : null;
+  }
+  // None type, string, etc → skip
+  if (t === 'none' || t === 'string') return null;
+  return null;
+}
+
+const PY_CLASS_TYPES = ['class_definition'] as const;
+function findPythonParentClass(node: TreeSitterNode): string | null {
+  return findParentNode(node, PY_CLASS_TYPES);
+}

package/src/extractors/r.ts

@@ -0,0 +1,275 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import {
+  findChild,
+  findFirstChildOfTypes,
+  nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
+  stripQuotes,
+} from './helpers.js';
+
+/**
+ * Extract symbols from R files.
+ *
+ * tree-sitter-r grammar (r-lib/tree-sitter-r) notes:
+ * - Assignments: binary_operator with `<-` or `=` operator
+ * - Functions: function_definition as RHS of assignment
+ * - Calls: call node with function/arguments fields
+ * - Imports: library() and require() calls
+ * - S4 classes: setClass(), setRefClass()
+ */
+export function extractRSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkRNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkRNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'binary_operator':
+      handleBinaryOp(node, ctx);
+      break;
+    case 'call':
+      handleCall(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkRNode(child, ctx);
+  }
+}
+
+function handleBinaryOp(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // binary_operator: child[0]=LHS, child[1]=operator (<- or =), child[2]=RHS
+  if (node.childCount < 3) return;
+
+  const lhs = node.child(0);
+  const op = node.child(1);
+  const rhs = node.child(2);
+
+  if (!lhs || !op || !rhs) return;
+  if (op.text !== '<-' && op.text !== '=' && op.text !== '<<-') return;
+  if (lhs.type !== 'identifier') return;
+
+  if (rhs.type === 'function_definition') {
+    const params = extractRParams(rhs);
+    ctx.definitions.push({
+      name: lhs.text,
+      kind: 'function',
+      line: nodeStartLine(node),
+      endLine: nodeEndLine(node),
+      children: params.length > 0 ? params : undefined,
+    });
+  } else {
+    // Variable assignment — only record top-level
+    if (node.parent?.type === 'program') {
+      ctx.definitions.push({
+        name: lhs.text,
+        kind: 'variable',
+        line: nodeStartLine(node),
+        endLine: nodeEndLine(node),
+      });
+    }
+  }
+}
+
+function extractRParams(funcDef: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramsNode = findChild(funcDef, 'parameters');
+  if (!paramsNode) return params;
+
+  for (let i = 0; i < paramsNode.childCount; i++) {
+    const child = paramsNode.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter') {
+      // parameter node has name and possibly default value
+      const nameNode = child.childForFieldName('name') || findChild(child, 'identifier');
+      if (nameNode) {
+        params.push({ name: nameNode.text, kind: 'parameter', line: nodeStartLine(child) });
+      } else if (child.text && child.text !== ',' && child.text !== '(' && child.text !== ')') {
+        // Some grammars have the param as plain text
+        params.push({ name: child.text, kind: 'parameter', line: nodeStartLine(child) });
+      }
+    }
+    if (child.type === 'identifier') {
+      params.push({ name: child.text, kind: 'parameter', line: nodeStartLine(child) });
+    }
+  }
+  return params;
+}
+
+function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // call: child[0]=function, then arguments
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  const funcName = funcNode.text;
+
+  // library() and require() are imports
+  if (funcName === 'library' || funcName === 'require') {
+    handleLibraryCall(node, ctx);
+    return;
+  }
+
+  // source() is a file import
+  if (funcName === 'source') {
+    handleSourceCall(node, ctx);
+    return;
+  }
+
+  // setClass / setRefClass for S4
+  if (funcName === 'setClass' || funcName === 'setRefClass') {
+    handleSetClass(node, ctx);
+    return;
+  }
+
+  if (funcName === 'setGeneric') {
+    handleSetGeneric(node, ctx);
+    return;
+  }
+
+  if (funcName === 'setMethod') {
+    handleSetMethod(node, ctx);
+    return;
+  }
+
+  // Regular call
+  if (funcNode.type === 'identifier') {
+    pushCall(ctx, node, funcName);
+  } else if (funcNode.type === 'namespace_operator') {
+    // pkg::func
+    const parts = funcName.split('::');
+    if (parts.length >= 2) {
+      pushCall(ctx, node, parts[parts.length - 1]!, {
+        receiver: parts.slice(0, -1).join('::'),
+      });
+    }
+  }
+}
+
+function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Find the package name in arguments. For named arguments like
+  // `library(package = dplyr)`, prefer the field-named `value` child of the
+  // `argument` node so we extract `dplyr` (the value), not `package` (the
+  // parameter name). Keeps native (Rust) and WASM extractors in parity.
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'arguments') {
+      for (let j = 0; j < child.childCount; j++) {
+        const arg = child.child(j);
+        if (!arg) continue;
+        if (arg.type === 'identifier') {
+          pushImport(ctx, node, arg.text, [arg.text]);
+          return;
+        }
+        if (arg.type === 'string' || arg.type === 'string_content') {
+          const text = stripQuotes(arg.text);
+          pushImport(ctx, node, text, [text]);
+          return;
+        }
+        // Argument might be wrapped
+        if (arg.type === 'argument') {
+          // Prefer the `value` field (correct for named arguments).
+          const valueNode = arg.childForFieldName('value');
+          let pick: TreeSitterNode | null = null;
+          if (valueNode && (valueNode.type === 'string' || valueNode.type === 'identifier')) {
+            pick = valueNode;
+          } else {
+            // Fallback: skip the parameter-name child if the grammar exposes
+            // it via the `name` field, then pick the first string/identifier.
+            const nameNode = arg.childForFieldName('name');
+            for (let k = 0; k < arg.childCount; k++) {
+              const inner = arg.child(k);
+              if (!inner) continue;
+              if (nameNode && inner.id === nameNode.id) continue;
+              if (inner.type === 'string' || inner.type === 'identifier') {
+                pick = inner;
+                break;
+              }
+            }
+          }
+          if (pick) {
+            const text = stripQuotes(pick.text);
+            pushImport(ctx, node, text, [text]);
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+function handleSourceCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // source() only accepts string literals — `source(varname)` is not an import.
+  const path = firstStringArgument(node);
+  if (path === null) return;
+  pushImport(ctx, node, path, ['source']);
+}
+
+function handleSetClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: nodeStartLine(node),
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleSetGeneric(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: nodeStartLine(node),
+    endLine: nodeEndLine(node),
+  });
+}
+
+// setMethod("greet", "Person", function(x) ...) registers an implementation of
+// the generic `greet` — it is not a new top-level definition. Emitting a
+// definition here produced two `function` nodes with the same name (one from
+// setGeneric, one from setMethod) and broke resolution. Emit a call edge to
+// the generic instead; the method body's calls are still picked up by the
+// recursive walk of the anonymous function argument.
+function handleSetMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  pushCall(ctx, node, name);
+}
+
+// tree-sitter-r wraps each positional argument in an `argument` node that
+// contains the actual `string` (or `identifier`) child, so the inner string
+// must be unwrapped — checking `child.type === 'string'` directly misses it.
+// Mirrors `first_argument_value` in the Rust extractor for parity.
+function firstStringArgument(node: TreeSitterNode): string | null {
+  const args = findFirstChildOfTypes(node, ['arguments']);
+  if (!args) return null;
+  for (let j = 0; j < args.childCount; j++) {
+    const arg = args.child(j);
+    if (!arg) continue;
+    if (arg.type === 'string') {
+      return stripQuotes(arg.text);
+    }
+    if (arg.type === 'argument') {
+      const valueNode = arg.childForFieldName('value');
+      if (valueNode && valueNode.type === 'string') return stripQuotes(valueNode.text);
+      const innerStr = findFirstChildOfTypes(arg, ['string']);
+      if (innerStr) return stripQuotes(innerStr.text);
+    }
+  }
+  return null;
+}