fix(extractors): guard empty-text identifiers and isolate extractor crashes (#972)

* fix(extractors): guard empty-text identifiers and isolate extractor crashes

The JavaScript extractor's factory-call type-map path called
`objName[0]!.toLowerCase()` without guarding for empty strings. When
tree-sitter produces a partial or corrupted tree the identifier's `text`
can be `''`, which makes `objName[0]` undefined and crashes with
"Cannot read properties of undefined (reading 'toLowerCase')". The
Python extractor already uses the correct short-circuit pattern; mirror
it in JS.

Additionally wrap the WASM extractor invocation in `wasmExtractSymbols`
in a try/catch that logs via `warn()` and returns `null`, mirroring the
existing parse-error handling directly above. Previously any extractor
runtime error would bubble up and kill the whole graph build; now the
build continues past the broken file.

Includes a regression test exercising a mock tree with an
empty-text identifier to verify the guard no longer throws.

Fixes #964

Impact: 2 functions changed, 16 affected

* fix(parser): free WASM tree on extractor error path (#972)

Addresses Greptile review feedback: when entry.extractor() throws, the
tree object allocated by parser.parse was never deleted. Since
web-tree-sitter trees are backed by WASM linear memory and not
garbage-collected, each extractor crash leaked one tree for the process
lifetime. Matches the finally/delete pattern already used in
backfillTypeMap and backfillTypeMapBatch.

Impact: 1 functions changed, 12 affected

Author: carlos-alm

src/domain/parser.ts

@@ -786,7 +786,16 @@ function wasmExtractSymbols(
   if (!entry) return null;
   const query = _queryCache.get(entry.id) ?? undefined;
   // Query (web-tree-sitter) is structurally compatible with TreeSitterQuery at runtime
-  const symbols = entry.extractor(tree as any, filePath, query as any);
+  let symbols: ExtractorOutput | null;
+  try {
+    symbols = entry.extractor(tree as any, filePath, query as any);
+  } catch (e: unknown) {
+    warn(`Extractor error in ${filePath}: ${(e as Error).message}`);
+    // Free WASM tree to prevent memory leak — web-tree-sitter trees are backed
+    // by WASM linear memory and are not garbage-collected automatically.
+    if (typeof (tree as any).delete === 'function') (tree as any).delete();
+    return null;
+  }
   return symbols ? { symbols, tree, langId: entry.id } : null;
 }
 

src/extractors/javascript.ts

@@ -1182,7 +1182,11 @@ function handleVarDeclaratorTypeMap(
       const obj = fn.childForFieldName('object');
       if (obj && obj.type === 'identifier') {
         const objName = obj.text;
-        if (objName[0]! !== objName[0]!.toLowerCase() && !BUILTIN_GLOBALS.has(objName)) {
+        if (
+          objName[0] &&
+          objName[0] !== objName[0].toLowerCase() &&
+          !BUILTIN_GLOBALS.has(objName)
+        ) {
           setTypeMapEntry(typeMap, nameN.text, objName, 0.7);
         }
       }

tests/parsers/javascript.test.ts

@@ -184,6 +184,79 @@ describe('JavaScript parser', () => {
       expect(symbols.typeMap.has('d')).toBe(false);
       expect(symbols.typeMap.has('p')).toBe(false);
     });
+
+    // Regression: GH #964 — tree-sitter can produce partial/corrupted trees in
+    // which an identifier node has empty `text`. Previously the factory path
+    // crashed with "Cannot read properties of undefined (reading 'toLowerCase')"
+    // because `objName[0]` is undefined for an empty string. The guard now
+    // mirrors the Python extractor's short-circuit check.
+    it('does not crash when factory call has an empty-text identifier', () => {
+      // Build a mock tree that mimics `const x = <empty-identifier>.create()`.
+      // The walk path calls handleVarDeclaratorTypeMap → factory branch, which
+      // reads `obj.text` ("") and would previously call "".toLowerCase() via
+      // `objName[0]!.toLowerCase()`. The fix's `objName[0] &&` guard short-circuits.
+      const pos = { row: 0, column: 0 };
+      const makeNode = (
+        type: string,
+        text = '',
+        fields: Record<string, any> = {},
+        children: any[] = [],
+      ) => {
+        const node: any = {
+          type,
+          text,
+          startPosition: pos,
+          endPosition: pos,
+          childCount: children.length,
+          child: (i: number) => children[i] ?? null,
+          childForFieldName: (name: string) => fields[name] ?? null,
+          parent: null,
+        };
+        for (const c of children) {
+          c.parent = node;
+        }
+        return node;
+      };
+
+      const emptyIdentifier = makeNode('identifier', '');
+      const createName = makeNode('property_identifier', 'create');
+      const memberExpr = makeNode(
+        'member_expression',
+        '.create',
+        {
+          object: emptyIdentifier,
+          property: createName,
+        },
+        [emptyIdentifier, createName],
+      );
+      const callExpr = makeNode(
+        'call_expression',
+        '.create()',
+        {
+          function: memberExpr,
+        },
+        [memberExpr],
+      );
+      const nameIdent = makeNode('identifier', 'x');
+      const declarator = makeNode(
+        'variable_declarator',
+        'x = .create()',
+        {
+          name: nameIdent,
+          value: callExpr,
+        },
+        [nameIdent, callExpr],
+      );
+      const lexDecl = makeNode('lexical_declaration', 'const x = .create();', {}, [declarator]);
+      const root = makeNode('program', '', {}, [lexDecl]);
+      const fakeTree: any = { rootNode: root };
+
+      // Before the fix this would throw TypeError. Now it should complete and
+      // simply leave `x` out of the typeMap (empty identifier is ignored).
+      expect(() => extractSymbols(fakeTree, 'test.js')).not.toThrow();
+      const symbols = extractSymbols(fakeTree, 'test.js');
+      expect(symbols.typeMap.has('x')).toBe(false);
+    });
   });
 
   it('does not set receiver for .call()/.apply()/.bind() unwrapped calls', () => {