fix(resolution): bound name lookup memory during resolving

Author: jischeng

__tests__/foundation.test.ts

@@ -282,7 +282,7 @@ describe('Database Connection', () => {
 
     const version = db.getSchemaVersion();
     expect(version).not.toBeNull();
-    expect(version?.version).toBe(5);
+    expect(version?.version).toBe(6);
 
     db.close();
   });

__tests__/pr19-improvements.test.ts

@@ -299,7 +299,7 @@ describe('Best-Candidate Resolution', () => {
 describe('Schema v2 Migration', () => {
   it.skipIf(!HAS_SQLITE)('should have correct current schema version', async () => {
     const { CURRENT_SCHEMA_VERSION } = await import('../src/db/migrations');
-    expect(CURRENT_SCHEMA_VERSION).toBe(5);
+    expect(CURRENT_SCHEMA_VERSION).toBe(6);
   });
 
   it.skipIf(!HAS_SQLITE)('should have migration for version 2', async () => {

__tests__/resolution.test.ts

@@ -1307,6 +1307,79 @@ func main() {
       const result = matchReference(ref, baseContext([variable, decorator]));
       expect(result?.targetNodeId).toBe('func:di.ts:Inject:10');
     });
+
+    it('uses filtered name lookup for exact call refs instead of materializing all same-name nodes', () => {
+      const target: Node = {
+        id: 'func:src/app.ts:main:10', kind: 'function', name: 'main',
+        qualifiedName: 'src/app.ts::main', filePath: 'src/app.ts', language: 'typescript',
+        startLine: 10, endLine: 20, startColumn: 0, endColumn: 0, updatedAt: Date.now(),
+      };
+      const ref = {
+        fromNodeId: 'func:src/app.ts:bootstrap:1',
+        referenceName: 'main',
+        referenceKind: 'calls' as const,
+        line: 5, column: 0, filePath: 'src/app.ts', language: 'typescript' as const,
+      };
+      const context: ResolutionContext = {
+        getNodesInFile: () => [],
+        getNodesByName: () => { throw new Error('full name lookup should not be used'); },
+        getNodesByNameFiltered: (name, filters = {}) => {
+          expect(name).toBe('main');
+          expect(filters.kinds).toContain('function');
+          return [target];
+        },
+        getNodesByQualifiedName: () => [],
+        getNodesByKind: () => [],
+        fileExists: () => true,
+        readFile: () => null,
+        getProjectRoot: () => '/test',
+        getAllFiles: () => [],
+        getNodesByLowerName: () => [],
+        getImportMappings: () => [],
+      };
+
+      const result = matchReference(ref, context);
+      expect(result?.targetNodeId).toBe(target.id);
+    });
+
+    it('uses filtered lookup for method-call fallback instead of loading every same-name method', () => {
+      const target: Node = {
+        id: 'method:src/service.ts:PermissionEngine::check:10', kind: 'method', name: 'check',
+        qualifiedName: 'src/service.ts::PermissionEngine::check', filePath: 'src/service.ts',
+        language: 'typescript', startLine: 10, endLine: 20, startColumn: 0, endColumn: 0,
+        updatedAt: Date.now(),
+      };
+      const ref = {
+        fromNodeId: 'func:src/app.ts:run:1',
+        referenceName: 'permissionEngine.check',
+        referenceKind: 'calls' as const,
+        line: 5, column: 0, filePath: 'src/app.ts', language: 'typescript' as const,
+      };
+      const context: ResolutionContext = {
+        getNodesInFile: () => [],
+        getNodesByName: () => { throw new Error('full name lookup should not be used'); },
+        getNodesByNameFiltered: (name, filters = {}) => {
+          if (name === 'permissionEngine' || name === 'PermissionEngine') return [];
+          if (filters.qualifiedNameSuffix) return [];
+          expect(name).toBe('check');
+          expect(filters.kinds).toEqual(['method']);
+          expect(filters.language).toBe('typescript');
+          return [target];
+        },
+        getNodesByQualifiedName: () => [],
+        getNodesByKind: () => [],
+        fileExists: () => true,
+        readFile: () => null,
+        getProjectRoot: () => '/test',
+        getAllFiles: () => [],
+        getNodesByLowerName: () => [],
+        getImportMappings: () => [],
+      };
+
+      const result = matchReference(ref, context);
+      expect(result?.targetNodeId).toBe(target.id);
+      expect(result?.resolvedBy).toBe('instance-method');
+    });
   });
 
   describe('tsconfig path aliases', () => {

src/db/migrations.ts

@@ -9,7 +9,7 @@ import { SqliteDatabase } from './sqlite-adapter';
 /**
  * Current schema version
  */
-export const CURRENT_SCHEMA_VERSION = 5;
+export const CURRENT_SCHEMA_VERSION = 6;
 
 /**
  * Migration definition
@@ -75,6 +75,17 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    version: 6,
+    description:
+      'Add composite node lookup indexes for memory-bounded reference resolution',
+    up: (db) => {
+      db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_nodes_name_language_kind ON nodes(name, language, kind);
+        CREATE INDEX IF NOT EXISTS idx_nodes_name_language_file ON nodes(name, language, file_path);
+      `);
+    },
+  },
 ];
 
 /**

src/db/queries.ts

@@ -13,6 +13,7 @@ import {
   NodeKind,
   EdgeKind,
   Language,
+  NodeLookupFilters,
   GraphStats,
   SearchOptions,
   SearchResult,
@@ -49,6 +50,10 @@ function isLowValueFile(filePath: string): boolean {
 
 const SQLITE_PARAM_CHUNK_SIZE = 500;
 
+function escapeLikePattern(value: string): string {
+  return value.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+}
+
 /**
  * Database row types (snake_case from SQLite)
  */
@@ -210,9 +215,11 @@ export class QueryBuilder {
     deleteUnresolvedByNode?: SqliteStatement;
     getUnresolvedByName?: SqliteStatement;
     getNodesByName?: SqliteStatement;
+    getNodeNameCount?: SqliteStatement;
     hasNodeName?: SqliteStatement;
     getNodesByQualifiedNameExact?: SqliteStatement;
     getNodesByLowerName?: SqliteStatement;
+    getLowerNodeNameCount?: SqliteStatement;
     getUnresolvedCount?: SqliteStatement;
     getUnresolvedBatch?: SqliteStatement;
     getAllFilePaths?: SqliteStatement;
@@ -763,6 +770,109 @@ export class QueryBuilder {
     return rows.map(rowToNode);
   }
 
+  /**
+   * Count exact-name candidates without materializing them. Resolver-internal
+   * guardrails use this before legacy unfiltered name lookups.
+   */
+  getNodeNameCount(name: string): number {
+    if (!this.stmts.getNodeNameCount) {
+      this.stmts.getNodeNameCount = this.db.prepare('SELECT COUNT(*) AS count FROM nodes WHERE name = ?');
+    }
+    const row = this.stmts.getNodeNameCount.get(name) as { count: number };
+    return row.count;
+  }
+
+  /**
+   * Get nodes by exact name with resolver-side filters applied in SQL.
+   *
+   * This is intentionally separate from public `getNodesByName()`, which must
+   * keep returning the full set. Resolution often asks for common names like
+   * `main`, `default`, or `clone`; on large repos those names can have tens of
+   * thousands of rows, so filtering after `.all()` needlessly explodes the JS
+   * heap. Push the obvious language/kind/file/qualified-name predicates into
+   * SQLite and cap low-confidence global fallbacks.
+   */
+  getNodesByNameFiltered(name: string, filters: NodeLookupFilters = {}): Node[] {
+    const where: string[] = ['name = ?'];
+    const params: unknown[] = [name];
+
+    const languages = filters.languages?.length
+      ? [...new Set(filters.languages)]
+      : filters.language
+        ? [filters.language]
+        : [];
+    if (languages.length === 1) {
+      where.push('language = ?');
+      params.push(languages[0]);
+    } else if (languages.length > 1) {
+      where.push(`language IN (${languages.map(() => '?').join(',')})`);
+      params.push(...languages);
+    }
+
+    const kinds = filters.kinds?.length ? [...new Set(filters.kinds)] : [];
+    if (kinds.length === 1) {
+      where.push('kind = ?');
+      params.push(kinds[0]);
+    } else if (kinds.length > 1) {
+      where.push(`kind IN (${kinds.map(() => '?').join(',')})`);
+      params.push(...kinds);
+    }
+
+    if (filters.filePath) {
+      where.push('file_path = ?');
+      params.push(filters.filePath);
+    }
+    if (filters.filePathPrefix) {
+      where.push("file_path LIKE ? ESCAPE '\\'");
+      params.push(`${escapeLikePattern(filters.filePathPrefix)}%`);
+    }
+    if (filters.filePathSuffix) {
+      where.push("file_path LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLikePattern(filters.filePathSuffix)}`);
+    }
+    if (filters.qualifiedName) {
+      where.push('qualified_name = ?');
+      params.push(filters.qualifiedName);
+    }
+    if (filters.qualifiedNameSuffix) {
+      where.push("qualified_name LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLikePattern(filters.qualifiedNameSuffix)}`);
+    }
+    if (filters.hasReturnType) {
+      where.push("return_type IS NOT NULL AND return_type <> ''");
+    }
+    if (filters.excludeId) {
+      where.push('id <> ?');
+      params.push(filters.excludeId);
+    }
+
+    const orderBy: string[] = [];
+    if (filters.rankFilePath) {
+      orderBy.push('CASE WHEN file_path = ? THEN 0 ELSE 1 END');
+      params.push(filters.rankFilePath);
+    }
+    if (filters.rankFilePathPrefix) {
+      orderBy.push("CASE WHEN file_path LIKE ? ESCAPE '\\' THEN 0 ELSE 1 END");
+      params.push(`${escapeLikePattern(filters.rankFilePathPrefix)}%`);
+    }
+    orderBy.push('file_path', 'start_line', 'id');
+
+    let sql = `
+      SELECT * FROM nodes
+      WHERE ${where.join(' AND ')}
+      ORDER BY ${orderBy.join(', ')}
+    `;
+
+    if (filters.limit !== undefined) {
+      const limit = Math.max(1, Math.floor(filters.limit));
+      sql += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as NodeRow[];
+    return rows.map(rowToNode);
+  }
+
   /**
    * True when at least one node has this exact name. Uses idx_nodes_name and
    * returns a single row instead of materializing the distinct symbol-name set.
@@ -820,6 +930,95 @@ export class QueryBuilder {
     return rows.map(rowToNode);
   }
 
+  /**
+   * Count lowercase-name candidates without materializing them. Used as a
+   * safety check before legacy unfiltered fuzzy lookups.
+   */
+  getLowerNodeNameCount(lowerName: string): number {
+    if (!this.stmts.getLowerNodeNameCount) {
+      this.stmts.getLowerNodeNameCount = this.db.prepare(
+        'SELECT COUNT(*) AS count FROM nodes WHERE lower(name) = ?'
+      );
+    }
+    const row = this.stmts.getLowerNodeNameCount.get(lowerName) as { count: number };
+    return row.count;
+  }
+
+  /**
+   * Lowercase-name lookup with the same SQL-side filters as
+   * getNodesByNameFiltered(). Used by low-confidence fuzzy resolution, where a
+   * high-fanout lowercase match should never materialize the whole candidate
+   * set.
+   */
+  getNodesByLowerNameFiltered(lowerName: string, filters: NodeLookupFilters = {}): Node[] {
+    const where: string[] = ['lower(name) = ?'];
+    const params: unknown[] = [lowerName];
+
+    const languages = filters.languages?.length
+      ? [...new Set(filters.languages)]
+      : filters.language
+        ? [filters.language]
+        : [];
+    if (languages.length === 1) {
+      where.push('language = ?');
+      params.push(languages[0]);
+    } else if (languages.length > 1) {
+      where.push(`language IN (${languages.map(() => '?').join(',')})`);
+      params.push(...languages);
+    }
+
+    const kinds = filters.kinds?.length ? [...new Set(filters.kinds)] : [];
+    if (kinds.length === 1) {
+      where.push('kind = ?');
+      params.push(kinds[0]);
+    } else if (kinds.length > 1) {
+      where.push(`kind IN (${kinds.map(() => '?').join(',')})`);
+      params.push(...kinds);
+    }
+
+    if (filters.filePath) {
+      where.push('file_path = ?');
+      params.push(filters.filePath);
+    }
+    if (filters.filePathPrefix) {
+      where.push("file_path LIKE ? ESCAPE '\\'");
+      params.push(`${escapeLikePattern(filters.filePathPrefix)}%`);
+    }
+    if (filters.filePathSuffix) {
+      where.push("file_path LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLikePattern(filters.filePathSuffix)}`);
+    }
+    if (filters.excludeId) {
+      where.push('id <> ?');
+      params.push(filters.excludeId);
+    }
+
+    const orderBy: string[] = [];
+    if (filters.rankFilePath) {
+      orderBy.push('CASE WHEN file_path = ? THEN 0 ELSE 1 END');
+      params.push(filters.rankFilePath);
+    }
+    if (filters.rankFilePathPrefix) {
+      orderBy.push("CASE WHEN file_path LIKE ? ESCAPE '\\' THEN 0 ELSE 1 END");
+      params.push(`${escapeLikePattern(filters.rankFilePathPrefix)}%`);
+    }
+    orderBy.push('file_path', 'start_line', 'id');
+
+    let sql = `
+      SELECT * FROM nodes
+      WHERE ${where.join(' AND ')}
+      ORDER BY ${orderBy.join(', ')}
+    `;
+    if (filters.limit !== undefined) {
+      const limit = Math.max(1, Math.floor(filters.limit));
+      sql += ' LIMIT ?';
+      params.push(limit);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as NodeRow[];
+    return rows.map(rowToNode);
+  }
+
   /**
    * Search nodes by name using FTS with fallback to LIKE for better matching
    *

src/db/schema.sql

@@ -91,6 +91,8 @@ CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
 CREATE INDEX IF NOT EXISTS idx_nodes_qualified_name ON nodes(qualified_name);
 CREATE INDEX IF NOT EXISTS idx_nodes_file_path ON nodes(file_path);
 CREATE INDEX IF NOT EXISTS idx_nodes_language ON nodes(language);
+CREATE INDEX IF NOT EXISTS idx_nodes_name_language_kind ON nodes(name, language, kind);
+CREATE INDEX IF NOT EXISTS idx_nodes_name_language_file ON nodes(name, language, file_path);
 CREATE INDEX IF NOT EXISTS idx_nodes_file_line ON nodes(file_path, start_line);
 CREATE INDEX IF NOT EXISTS idx_nodes_lower_name ON nodes(lower(name));
 

src/resolution/frameworks/react.ts

@@ -9,7 +9,7 @@ import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from
 
 export const reactResolver: FrameworkResolver = {
   name: 'react',
-  languages: ['javascript', 'typescript'],
+  languages: ['javascript', 'typescript', 'jsx', 'tsx'],
 
   detect(context: ResolutionContext): boolean {
     // Check for React in package.json