fix(lint): resolve all ESLint errors across codebase

Remove unused variable, fix async/await patterns, use nullish coalescing,
and eliminate unsafe non-null assertions.

Changes:
- Remove unused `processedTextsCount` variable in translation service
- Replace `||` with `??` for safer nullish coalescing in tests
- Convert jest callback tests to async/await pattern
- Fix optional chain non-null assertion by using proper type guards
- Remove unnecessary async keyword from non-awaiting mock function

All tests passing (1461 tests). Zero lint errors remaining.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sjsyrek

src/services/translation.ts

@@ -210,7 +210,6 @@ export class TranslationService {
     // Use a Map to correctly track which text maps to which result
     const textToResultMap = new Map<string, TranslationResult>();
     let lastError: Error | null = null;
-    let processedTextsCount = 0; // Track position in textsToTranslate array
 
     for (const batch of batches) {
       try {
@@ -224,13 +223,10 @@ export class TranslationService {
             textToResultMap.set(text, result);
           }
         }
-
-        processedTextsCount += batch.length;
       } catch (error) {
         lastError = error as Error;
         Logger.error(`Batch translation failed: ${error instanceof Error ? error.message : String(error)}`);
         // Mark all texts in this batch as processed (but failed)
-        processedTextsCount += batch.length;
         // Continue with other batches rather than failing completely
       }
     }

tests/integration/batch-translation.integration.test.ts

@@ -19,14 +19,14 @@ jest.mock('p-limit', () => ({
 // Mock fast-glob with implementation inline
 jest.mock('fast-glob', () => ({
   __esModule: true,
-  default: async (pattern: string | string[], options: any) => {
+  default: (pattern: string | string[], options: any) => {
     // Simple mock implementation that scans directories
-    const globPattern = (Array.isArray(pattern) ? pattern[0] : pattern) || '';
+    const globPattern = (Array.isArray(pattern) ? pattern[0] : pattern) ?? '';
 
     // Extract base directory from pattern by removing glob parts
     let baseDir = globPattern;
     if (baseDir.includes('**')) {
-      baseDir = baseDir.split('**')[0] || '';
+      baseDir = baseDir.split('**')[0] ?? '';
     }
     baseDir = baseDir.replace(/[/*]+$/, '');
 
@@ -36,7 +36,7 @@ jest.mock('fast-glob', () => ({
 
     // Recursively scan directory
     const scanDir = (dir: string, currentDepth: number = 0): string[] => {
-      if (!fs.existsSync(dir)) return [];
+      if (!fs.existsSync(dir)) {return [];}
 
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       const files: string[] = [];

tests/integration/cli-translate-workflow.integration.test.ts

@@ -38,7 +38,7 @@ describe('Translation Workflow Integration', () => {
         proxy: {},
       }),
       getValue: (key: string) => {
-        if (key === 'cache.enabled') return true;
+        if (key === 'cache.enabled') {return true;}
         return undefined;
       },
     } as unknown as ConfigService;
@@ -275,7 +275,7 @@ describe('Translation Workflow Integration', () => {
       mockConfig = {
         get: () => ({ defaults: {} }),
         getValue: (key: string) => {
-          if (key === 'cache.enabled') return false;
+          if (key === 'cache.enabled') {return false;}
           return undefined;
         },
       } as ConfigService;
@@ -653,11 +653,18 @@ describe('Translation Workflow Integration', () => {
       expect(results[0]?.outputPath).toBe(path.join(outputDir, 'input.es.txt'));
       expect(results[1]?.outputPath).toBe(path.join(outputDir, 'input.fr.txt'));
 
-      expect(fs.existsSync(results[0]?.outputPath!)).toBe(true);
-      expect(fs.existsSync(results[1]?.outputPath!)).toBe(true);
+      const outputPath0 = results[0]?.outputPath;
+      const outputPath1 = results[1]?.outputPath;
+      expect(outputPath0).toBeDefined();
+      expect(outputPath1).toBeDefined();
 
-      expect(fs.readFileSync(results[0]?.outputPath!, 'utf-8')).toBe('Hola');
-      expect(fs.readFileSync(results[1]?.outputPath!, 'utf-8')).toBe('Bonjour');
+      if (outputPath0 && outputPath1) {
+        expect(fs.existsSync(outputPath0)).toBe(true);
+        expect(fs.existsSync(outputPath1)).toBe(true);
+
+        expect(fs.readFileSync(outputPath0, 'utf-8')).toBe('Hola');
+        expect(fs.readFileSync(outputPath1, 'utf-8')).toBe('Bonjour');
+      }
     });
 
     it('should throw error for non-existent input file', async () => {

tests/integration/cli-watch.integration.test.ts

@@ -170,44 +170,52 @@ describe('Watch Service Integration', () => {
   });
 
   describe('handleFileChange() - Callbacks', () => {
-    it('should call onChange callback when file changes', (done) => {
+    it('should call onChange callback when file changes', async () => {
       const testFile = path.join(tmpDir, 'test.txt');
       fs.writeFileSync(testFile, 'Hello');
 
-      const onChangeMock = jest.fn((filePath: string) => {
-        expect(filePath).toBe(testFile);
-        done();
-      });
+      const callbackPromise = new Promise<void>((resolve) => {
+        const onChangeMock = jest.fn((filePath: string) => {
+          expect(filePath).toBe(testFile);
+          resolve();
+        });
 
-      watchService.watch(testFile, {
-        targetLangs: ['es'],
-        outputDir: tmpDir,
-        onChange: onChangeMock,
+        watchService.watch(testFile, {
+          targetLangs: ['es'],
+          outputDir: tmpDir,
+          onChange: onChangeMock,
+        });
+
+        watchService.handleFileChange(testFile);
       });
 
-      watchService.handleFileChange(testFile);
+      await callbackPromise;
     });
 
-    it('should call onError callback when translation fails', (done) => {
+    it('should call onError callback when translation fails', async () => {
       const testFile = path.join(tmpDir, 'test.txt');
       fs.writeFileSync(testFile, 'Hello');
 
       // Mock translation service to throw error
       jest.spyOn(fileTranslationService, 'translateFile').mockRejectedValue(new Error('API error'));
 
-      const onErrorMock = jest.fn((filePath: string, error: Error) => {
-        expect(filePath).toBe(testFile);
-        expect(error.message).toContain('API error');
-        done();
-      });
+      const callbackPromise = new Promise<void>((resolve) => {
+        const onErrorMock = jest.fn((filePath: string, error: Error) => {
+          expect(filePath).toBe(testFile);
+          expect(error.message).toContain('API error');
+          resolve();
+        });
 
-      watchService.watch(testFile, {
-        targetLangs: ['es'],
-        outputDir: tmpDir,
-        onError: onErrorMock,
+        watchService.watch(testFile, {
+          targetLangs: ['es'],
+          outputDir: tmpDir,
+          onError: onErrorMock,
+        });
+
+        watchService.handleFileChange(testFile);
       });
 
-      watchService.handleFileChange(testFile);
+      await callbackPromise;
     });
   });
 
@@ -234,23 +242,27 @@ describe('Watch Service Integration', () => {
       expect(stats.isWatching).toBe(true);
     });
 
-    it('should increment error count on translation failure', (done) => {
+    it('should increment error count on translation failure', async () => {
       const testFile = path.join(tmpDir, 'test.txt');
       fs.writeFileSync(testFile, 'Hello');
 
       jest.spyOn(fileTranslationService, 'translateFile').mockRejectedValue(new Error('Fail'));
 
-      watchService.watch(testFile, {
-        targetLangs: ['es'],
-        outputDir: tmpDir,
-        onError: () => {
-          const stats = watchService.getStats();
-          expect(stats.errorsCount).toBeGreaterThan(0);
-          done();
-        },
+      const callbackPromise = new Promise<void>((resolve) => {
+        watchService.watch(testFile, {
+          targetLangs: ['es'],
+          outputDir: tmpDir,
+          onError: () => {
+            const stats = watchService.getStats();
+            expect(stats.errorsCount).toBeGreaterThan(0);
+            resolve();
+          },
+        });
+
+        watchService.handleFileChange(testFile);
       });
 
-      watchService.handleFileChange(testFile);
+      await callbackPromise;
     });
   });
 
@@ -355,7 +367,7 @@ describe('Watch Service Integration', () => {
   });
 
   describe('Debouncing', () => {
-    it('should debounce rapid file changes', (done) => {
+    it('should debounce rapid file changes', async () => {
       const testFile = path.join(tmpDir, 'test.txt');
       fs.writeFileSync(testFile, 'Hello');
 
@@ -376,10 +388,8 @@ describe('Watch Service Integration', () => {
       watchService.handleFileChange(testFile);
 
       // onChange should be called 3 times (once per trigger)
-      setTimeout(() => {
-        expect(changeCount).toBe(3);
-        done();
-      }, 100);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(changeCount).toBe(3);
     });
   });
 });

tests/unit/translation-service.test.ts

@@ -646,7 +646,7 @@ describe('TranslationService', () => {
       });
 
       // Should preserve all three {name} instances
-      const nameCount = (result.text.match(/\{name\}/g) || []).length;
+      const nameCount = (result.text.match(/\{name\}/g) ?? []).length;
       expect(nameCount).toBe(3);
     });
 
@@ -664,7 +664,7 @@ describe('TranslationService', () => {
 
       // Check that the text sent to API has three DIFFERENT placeholders
       // (even though the original had three identical variables)
-      const placeholders = receivedText.match(/__VAR_\w+__/g) || [];
+      const placeholders = receivedText.match(/__VAR_\w+__/g) ?? [];
       expect(placeholders.length).toBe(3);
 
       // All placeholders should be unique (no collisions)