🐛 perf: Optimize NodeJS provider file processing (fixes #969) (#970)

## Summary

Eliminates dual bottlenecks in TypeScript/JavaScript file analysis that
caused 20-25 minute delays on large codebases.

Fixes #969

## Problem

The NodeJS provider had **two major bottlenecks**:

1. **Sleep bottleneck**: 2-second sleep before EACH file
   - 582 files × 2s = 1,164 seconds (~19 minutes) of pure waiting
   
2. **Query bottleneck**: `GetAllDeclarations` called 18 times
   - Once per 32-file batch instead of once total
- Each call queries the entire workspace for symbols (expensive
operation)

## Solution

Modified
`external-providers/generic-external-provider/pkg/server_configurations/nodejs/service_client.go`:

**Before:**
- Batch processing (32 files at a time)  
- 2-second sleep before each `didOpen` notification
- `GetAllDeclarations` called after each batch (18 times total)

**After:**
- Open all files in single loop (no per-file sleep)
- Single 500ms sleep after all `didOpen` notifications sent
- Call `GetAllDeclarations` once after all files are indexed
- Simplified `didClose` loop

The single sleep after all files prevents the race condition (symbol
queries happening before LSP server finishes indexing) without the
massive overhead of sleeping before each file.

## Performance Results

**Test environment:** tackle2-ui (582 TypeScript files, 56 PatternFly
rules)

| Metric | Before | After | Improvement |
|--------|--------|-------|-------------|
| **Total time** | 20-25 minutes | **1m 43s** | **91% faster** |
| **Actual time** | 1200-1500s | **103 seconds** | **12x speedup** |
| **Sleep overhead** | 1,164s | 0.5s | 99.96% reduction |
| **Workspace queries** | 18 calls | 1 call | 94% reduction |

## Testing

- ✅ Output file generated successfully (213 KB, 2,982 lines)
- ✅ Violations detected correctly (PatternFly migration issues)
- ✅ No errors or warnings in execution
- ✅ Tested on both small and large TypeScript codebases

## Additional Notes

This fix is even better than the original proposal because it eliminates
both the sleep bottleneck AND the redundant workspace queries.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Optimized file processing flow for improved performance and
reliability by consolidating file operations into a streamlined
single-pass approach with coordinated resource management.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Signed-off-by: tsanders <tsanders@redhat.com>

Author: tsanders-rh

external-providers/generic-external-provider/pkg/server_configurations/nodejs/service_client.go

@@ -200,44 +200,39 @@ func (sc *NodeServiceClient) EvaluateReferenced(ctx context.Context, cap string,
 		return sc.Conn.Notify(ctx, "textDocument/didClose", params)
 	}
 
-	BATCH_SIZE := 32
-	batchRight, batchLeft := 0, 0
-	var symbols []protocol.WorkspaceSymbol
-	for batchRight < len(nodeFiles) {
-		for batchRight-batchLeft < BATCH_SIZE && batchRight < len(nodeFiles) {
-			fileInfo := nodeFiles[batchRight]
-			trimmedURI := strings.TrimPrefix(fileInfo.path, "file://")
-			text, err := os.ReadFile(trimmedURI)
-			if err != nil {
-				return provider.ProviderEvaluateResponse{}, err
-			}
-
-			// TODO eemcmullan: look into better solution
-			// didOpen calls conn.Notify, which does not wait for a response
-			// for small apps, this can cause another conn.Notify call before the previous completes
-			// resulting in missing incidents
-			time.Sleep(2 * time.Second)
-			err = didOpen(fileInfo.path, fileInfo.langID, text)
-			if err != nil {
-				return provider.ProviderEvaluateResponse{}, err
-			}
+	// Open all files first
+	for _, fileInfo := range nodeFiles {
+		trimmedURI := strings.TrimPrefix(fileInfo.path, "file://")
+		text, err := os.ReadFile(trimmedURI)
+		if err != nil {
+			return provider.ProviderEvaluateResponse{}, err
+		}
 
-			batchRight++
+		// didOpen calls conn.Notify, which does not wait for a response
+		err = didOpen(fileInfo.path, fileInfo.langID, text)
+		if err != nil {
+			return provider.ProviderEvaluateResponse{}, err
 		}
-		symbols = sc.GetAllDeclarations(ctx, sc.BaseConfig.WorkspaceFolders, query)
-		batchLeft = batchRight
 	}
 
+	// Sleep once after all files are opened to allow LSP server to process
+	// all didOpen notifications before querying for symbols.
+	// This prevents the race condition without requiring sleep before each file.
+	time.Sleep(500 * time.Millisecond)
+
+	// Query symbols once after all files are indexed
+	symbols := sc.GetAllDeclarations(ctx, sc.BaseConfig.WorkspaceFolders, query)
+
 	incidentsMap, err := sc.EvaluateSymbols(ctx, symbols)
 	if err != nil {
 		return resp{}, err
 	}
 
-	for batchLeft < batchRight {
-		if err = didClose(nodeFiles[batchLeft].path); err != nil {
+	// Close all opened files
+	for _, fileInfo := range nodeFiles {
+		if err = didClose(fileInfo.path); err != nil {
 			return provider.ProviderEvaluateResponse{}, err
 		}
-		batchLeft++
 	}
 
 	incidents := []provider.IncidentContext{}