Method getUnresolvedReferencesByFiles

src/db/queries.ts:2426–2459

* Get unresolved references scoped to specific file paths. * Uses the idx_unresolved_file_path index for efficient lookup.

(filePaths: string[])

   * Uses the idx_unresolved_file_path index for efficient lookup.
   */
  getUnresolvedReferencesByFiles(filePaths: string[]): UnresolvedReference[] {
    if (filePaths.length === 0) return [];

    // Chunk under SQLite's parameter limit: the first sync of a very large repo
    // passes every changed file here, which an unbounded `IN (...)` would bind
    // as one parameter each — exceeding MAX_VARIABLE_NUMBER and aborting with
    // "too many SQL variables". (#540)
    const rows: UnresolvedRefRow[] = [];
    for (let i = 0; i < filePaths.length; i += SQLITE_PARAM_CHUNK_SIZE) {
      const chunk = filePaths.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
      const placeholders = chunk.map(() => '?').join(',');
      const chunkRows = this.db
        .prepare(`SELECT * FROM unresolved_refs WHERE status = 'pending' AND file_path IN (${placeholders})`)
        .all(...chunk) as UnresolvedRefRow[];
      // Append with a loop, never a spread: the INPUT chunk is bounded, but
      // the RESULT rows per chunk are not — a dense recovery sync (e.g. the
      // #1541 self-heal re-indexing hundreds of files) returns more rows than
      // V8 allows as arguments, and `push(...chunkRows)` dies with "Maximum
      // call stack size exceeded", aborting resolution mid-sync (#1558).
      for (const row of chunkRows) rows.push(row);
    }

    return rows.map((row) => ({
      fromNodeId: row.from_node_id,
      referenceName: row.reference_name,
      referenceKind: row.reference_kind as EdgeKind,
      line: row.line,
      column: row.col,
      candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined,
      filePath: row.file_path,
      language: row.language as Language,
      rowId: row.id,
    }));
  }

  /**
   * Delete all unresolved references (after resolution)