fix: remove deleted files from records file with --stage-record-file (#34)

* fix: remove deleted files from records file (#31)

When using --stage-record-file, deleted files are now automatically
removed from the records instead of throwing an error. This enables
pre-commit hooks to include deleted files (diff-filter=ACMRD) so the
tracker can clean up records for removed files.

- Add partitionByExistence() to separate existing/deleted files
- Update --stage-record-file to compile only existing files while
  passing all files to records for cleanup
- Add log messages for deleted files being removed
- Fix grammar in log messages ("1 file" vs "1 files")
- Update README with new behavior and diff-filter guidance

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

* refactor: extract pluralize helper into utils module

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

* fix: only check existing files for error increases in stage mode

Pass existingFilePaths instead of allFilePaths to exitIfErrorsIncreased
since only existing files are compiled. Deleted files are handled
separately and don't need error checking.

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

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: frankieyan

README.md

@@ -74,7 +74,7 @@ npx @doist/react-compiler-tracker --overwrite
 
 ### `--stage-record-file <file1> <file2> ...`
 
-Checks the provided files and updates the records. Exits with code 1 if errors increase (preventing the commit), otherwise updates the records file for the checked files.
+Checks the provided files and updates the records. Exits with code 1 if errors increase (preventing the commit), otherwise updates the records file for the checked files. Deleted files are automatically removed from the records.
 
 ```bash
 npx @doist/react-compiler-tracker --stage-record-file src/components/Button.tsx src/hooks/useData.ts
@@ -84,7 +84,7 @@ If no files are provided, exits cleanly with a success message.
 
 ### `--check-files <file1> <file2> ...`
 
-Checks specific files without updating records. Exits with code 1 if checked files show increased error counts (or new errors). Primarily for CI to ensure PRs don't introduce new compiler errors.
+Checks specific files without updating records. Exits with code 1 if checked files show increased error counts (or new errors), or if any provided file does not exist. Primarily for CI to ensure PRs don't introduce new compiler errors.
 
 ```bash
 npx @doist/react-compiler-tracker --check-files src/components/Button.tsx src/hooks/useData.ts
@@ -130,8 +130,8 @@ With lint-staged, the matched files are automatically passed as arguments to the
 
 ```bash
 #!/bin/sh
-# Get staged files and pass them to the tracker
-FILES=$(git diff --diff-filter=ACMR --cached --name-only -- '*.tsx' '*.ts' '*.jsx' '*.js' | tr '\n' ' ')
+# Get staged files (including deleted) and pass them to the tracker
+FILES=$(git diff --diff-filter=ACMRD --cached --name-only -- '*.tsx' '*.ts' '*.jsx' '*.js' | tr '\n' ' ')
 if [ -n "$FILES" ]; then
   npx @doist/react-compiler-tracker --stage-record-file $FILES
 fi

src/index.integration.test.mts

@@ -64,7 +64,7 @@ describe('CLI', () => {
         // Simulate what CI tools do when passing filenames with $ through shell variables
         const output = runCLI(['--check-files', 'src/route.\\$param.tsx'])
 
-        expect(output).toContain('🔍 Checking 1 files for React Compiler errors…')
+        expect(output).toContain('🔍 Checking 1 file for React Compiler errors…')
         expect(output).not.toContain('File not found')
     })
 
@@ -131,6 +131,56 @@ describe('CLI', () => {
             // but the important thing is that error checking passed
             expect(output).not.toContain('React Compiler errors have increased')
         })
+
+        it('removes deleted files from records', () => {
+            // First create records
+            runCLI(['--overwrite'])
+
+            // Manually add a fake entry to records simulating a previously tracked file
+            let records = JSON.parse(readFileSync(recordsPath, 'utf8'))
+            records.files['src/deleted-file.tsx'] = { CompileError: 2 }
+            writeFileSync(recordsPath, JSON.stringify(records, null, 2))
+
+            // Verify the fake entry is in records
+            records = JSON.parse(readFileSync(recordsPath, 'utf8'))
+            expect(records.files['src/deleted-file.tsx']).toEqual({ CompileError: 2 })
+
+            // Now run --stage-record-file with the deleted file path
+            // The file src/deleted-file.tsx doesn't exist, simulating deletion
+            const output = runCLI([
+                '--stage-record-file',
+                'src/good-component.tsx',
+                'src/deleted-file.tsx',
+            ])
+
+            // Should log the deleted file being removed
+            expect(output).toContain('🗑️  Removing 1 deleted file from records:')
+            expect(output).toContain('• src/deleted-file.tsx')
+            // Should check only existing files (1 file, not 2)
+            expect(output).toContain('🔍 Checking 1 file for React Compiler errors')
+            // Should not error on the deleted file
+            expect(output).not.toContain('File not found')
+
+            // Verify the deleted file was removed from records
+            records = JSON.parse(readFileSync(recordsPath, 'utf8'))
+            expect(records.files['src/deleted-file.tsx']).toBeUndefined()
+        })
+
+        it('exits cleanly when only deleted files provided', () => {
+            // First create records
+            runCLI(['--overwrite'])
+
+            // Run with only deleted files
+            const output = runCLI(['--stage-record-file', 'src/deleted1.tsx', 'src/deleted2.tsx'])
+
+            // Should log the deleted files being removed
+            expect(output).toContain('🗑️  Removing 2 deleted files from records:')
+            expect(output).toContain('• src/deleted1.tsx')
+            expect(output).toContain('• src/deleted2.tsx')
+            // Should show clear message when no existing files
+            expect(output).toContain('📁 No existing files to check.')
+            expect(output).not.toContain('File not found')
+        })
     })
 
     describe('config file', () => {

src/index.mts

@@ -7,6 +7,7 @@ import { loadConfig } from './config.mjs'
 import type { FileErrors } from './records-file.mjs'
 import * as recordsFile from './records-file.mjs'
 import * as sourceFiles from './source-files.mjs'
+import { pluralize } from './utils.mjs'
 
 const OVERWRITE_FLAG = '--overwrite'
 const STAGE_RECORD_FILE_FLAG = '--stage-record-file'
@@ -47,10 +48,12 @@ async function main() {
                     filePaths: sourceFiles.normalizeFilePaths(filePathParams),
                     globPattern: config.sourceGlob,
                 })
-                sourceFiles.validateFilesExist(filePaths)
+                const { existing, deleted } = sourceFiles.partitionByExistence(filePaths)
 
                 return await runStageRecords({
-                    filePaths,
+                    existingFilePaths: existing,
+                    allFilePaths: filePaths,
+                    deletedFilePaths: deleted,
                     recordsFilePath: config.recordsFile,
                 })
             }
@@ -144,40 +147,58 @@ async function runOverwriteRecords({
  * Handles the `--stage-record-file` flag by checking provided files and updating the records file.
  *
  * If errors have increased, the process will exit with code 1 and the records file will not be updated.
+ * Deleted files are automatically removed from the records.
  */
 async function runStageRecords({
-    filePaths,
+    existingFilePaths,
+    allFilePaths,
+    deletedFilePaths,
     recordsFilePath,
 }: {
-    filePaths: string[]
+    existingFilePaths: string[]
+    allFilePaths: string[]
+    deletedFilePaths: string[]
     recordsFilePath: string
 }) {
-    if (!filePaths.length) {
+    if (!allFilePaths.length) {
         console.log('✅ No files to check')
         return
     }
 
-    console.log(
-        `🔍 Checking ${filePaths.length} files for React Compiler errors and updating records…`,
-    )
+    if (deletedFilePaths.length > 0) {
+        const deletedFileWord = pluralize(deletedFilePaths.length, 'file', 'files')
+        const fileList = deletedFilePaths.map((f) => `  • ${f}`).join('\n')
+        console.log(
+            `🗑️  Removing ${deletedFilePaths.length} deleted ${deletedFileWord} from records:\n${fileList}`,
+        )
+    }
+
+    if (!existingFilePaths.length) {
+        console.log('📁 No existing files to check.')
+    } else {
+        const fileWord = pluralize(existingFilePaths.length, 'file', 'files')
+        console.log(
+            `🔍 Checking ${existingFilePaths.length} ${fileWord} for React Compiler errors and updating records…`,
+        )
+    }
 
     //
-    // Compile files and update `compilerErrors` with `customReactCompilerLogger`
+    // Compile only existing files and update `compilerErrors` with `customReactCompilerLogger`
     //
 
     await babel.compileFiles({
-        filePaths,
+        filePaths: existingFilePaths,
         customReactCompilerLogger: customReactCompilerLogger,
     })
 
-    const records = exitIfErrorsIncreased({ filePaths, recordsFilePath })
+    const records = exitIfErrorsIncreased({ filePaths: existingFilePaths, recordsFilePath })
 
     //
-    // Update and stage records file
+    // Update and stage records file (includes deleted files so they get removed from records)
     //
 
     recordsFile.save({
-        filePaths,
+        filePaths: allFilePaths,
         recordsPath: recordsFilePath,
         compilerErrors: Object.fromEntries(compilerErrors.entries()),
         records: records?.files ?? null,
@@ -211,7 +232,8 @@ async function runCheckFiles({
         return
     }
 
-    console.log(`🔍 Checking ${filePaths.length} files for React Compiler errors…`)
+    const fileWord = pluralize(filePaths.length, 'file', 'files')
+    console.log(`🔍 Checking ${filePaths.length} ${fileWord} for React Compiler errors…`)
 
     //
     // Compile files and update `compilerErrors` with `customReactCompilerLogger`

src/source-files.mts

@@ -104,4 +104,22 @@ function validateFilesExist(filePaths: string[]) {
     }
 }
 
-export { getAll, normalizeFilePaths, filterByGlob, validateFilesExist }
+/**
+ * Partitions file paths into existing and deleted sets based on filesystem existence.
+ */
+function partitionByExistence(filePaths: string[]): { existing: string[]; deleted: string[] } {
+    const existing: string[] = []
+    const deleted: string[] = []
+
+    for (const filePath of filePaths) {
+        if (existsSync(filePath)) {
+            existing.push(filePath)
+        } else {
+            deleted.push(filePath)
+        }
+    }
+
+    return { existing, deleted }
+}
+
+export { getAll, normalizeFilePaths, filterByGlob, validateFilesExist, partitionByExistence }

src/source-files.test.mts

@@ -2,7 +2,13 @@ import { execSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { glob } from 'glob'
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { filterByGlob, getAll, normalizeFilePaths, validateFilesExist } from './source-files.mjs'
+import {
+    filterByGlob,
+    getAll,
+    normalizeFilePaths,
+    partitionByExistence,
+    validateFilesExist,
+} from './source-files.mjs'
 
 vi.mock('node:child_process', () => ({
     execSync: vi.fn(),
@@ -264,3 +270,46 @@ describe('validateFilesExist', () => {
         )
     })
 })
+
+describe('partitionByExistence', () => {
+    it('partitions files into existing and deleted sets', () => {
+        vi.mocked(existsSync).mockImplementation(
+            (path) => path === 'exists1.tsx' || path === 'exists2.tsx',
+        )
+
+        const result = partitionByExistence([
+            'exists1.tsx',
+            'deleted.tsx',
+            'exists2.tsx',
+            'also-deleted.tsx',
+        ])
+
+        expect(result.existing).toEqual(['exists1.tsx', 'exists2.tsx'])
+        expect(result.deleted).toEqual(['deleted.tsx', 'also-deleted.tsx'])
+    })
+
+    it('returns all files as existing when all exist', () => {
+        vi.mocked(existsSync).mockReturnValue(true)
+
+        const result = partitionByExistence(['file1.tsx', 'file2.tsx'])
+
+        expect(result.existing).toEqual(['file1.tsx', 'file2.tsx'])
+        expect(result.deleted).toEqual([])
+    })
+
+    it('returns all files as deleted when none exist', () => {
+        vi.mocked(existsSync).mockReturnValue(false)
+
+        const result = partitionByExistence(['file1.tsx', 'file2.tsx'])
+
+        expect(result.existing).toEqual([])
+        expect(result.deleted).toEqual(['file1.tsx', 'file2.tsx'])
+    })
+
+    it('handles empty file list', () => {
+        const result = partitionByExistence([])
+
+        expect(result.existing).toEqual([])
+        expect(result.deleted).toEqual([])
+    })
+})

src/utils.mts

@@ -0,0 +1,3 @@
+export function pluralize(count: number, singular: string, plural: string): string {
+    return count === 1 ? singular : plural
+}