ts-repo-utils 7.8.1 → 7.9.0

package/src/functions/format.test.mts

@@ -1,4 +1,3 @@
-/* eslint-disable vitest/no-conditional-expect */
 import dedent from 'dedent';
 import { Result } from 'ts-data-forge';
 import '../node-global.mjs';
@@ -15,14 +14,14 @@ import {
   formatUncommittedFiles,
 } from './format.mjs';
 
-vi.mock('./diff.mjs', () => ({
+vi.mock(import('./diff.mjs'), () => ({
   getDiffFrom: vi.fn(),
   getModifiedFiles: vi.fn(),
   getStagedFiles: vi.fn(),
   getUntrackedFiles: vi.fn(),
 }));
 
-describe('formatFilesGlob', () => {
+describe(formatFilesGlob, () => {
   const testDir = path.join(
     process.cwd(),
     `test-format-files-${crypto.randomUUID()}`,
@@ -34,7 +33,9 @@ describe('formatFilesGlob', () => {
     content: string,
   ): Promise<string> => {
     const filePath = path.join(testDir, filename);
+
     await fs.writeFile(filePath, content, 'utf8');
+
     return filePath;
   };
 
@@ -44,6 +45,7 @@ describe('formatFilesGlob', () => {
 
   test('should format files matching glob pattern', async () => {
     vi.clearAllMocks();
+
     // Setup test directory
     await fs.mkdir(testDir, { recursive: true });
 
@@ -71,10 +73,12 @@ describe('formatFilesGlob', () => {
 
       // Format TypeScript files
       const result = await formatFilesGlob(`${testDir}/*.ts`, { silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check that files were formatted
       const content1 = await readTestFile(file1);
+
       expect(content1).toBe(
         `${dedent`
           const foo = 'bar';
@@ -83,6 +87,7 @@ describe('formatFilesGlob', () => {
       );
 
       const content2 = await readTestFile(file2);
+
       expect(content2).toBe(
         `${dedent`
           function test(x: number, y: string) {
@@ -93,6 +98,7 @@ describe('formatFilesGlob', () => {
 
       // Check that non-matching file was not touched
       const mdContent = await readTestFile(path.join(testDir, 'test.md'));
+
       expect(mdContent).toBe('# Test\n\nSome    spaces');
     } finally {
       // Cleanup
@@ -102,14 +108,17 @@ describe('formatFilesGlob', () => {
 
   test('should return ok when no files match pattern', async () => {
     vi.clearAllMocks();
+
     const result = await formatFilesGlob('/non-existent-path/*.ts', {
       silent: true,
     });
+
     expect(Result.isOk(result)).toBe(true);
   });
 
   test('should handle nested directories with glob pattern', async () => {
     vi.clearAllMocks();
+
     // Setup test directory with nested structure
     await fs.mkdir(path.join(testDir, 'src', 'utils'), { recursive: true });
 
@@ -126,10 +135,12 @@ describe('formatFilesGlob', () => {
       const result = await formatFilesGlob(`${testDir}/**/*.ts`, {
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check that nested file was formatted
       const content = await readTestFile(nestedFile);
+
       expect(content).toBe(
         `${dedent`
           export const helper = (x: number) => {
@@ -144,7 +155,7 @@ describe('formatFilesGlob', () => {
   });
 });
 
-describe('formatFiles', () => {
+describe(formatFiles, () => {
   const testDir = path.join(
     process.cwd(),
     `test-format-files-list-${crypto.randomUUID()}`,
@@ -156,7 +167,9 @@ describe('formatFiles', () => {
     content: string,
   ): Promise<string> => {
     const filePath = path.join(testDir, filename);
+
     await fs.writeFile(filePath, content, 'utf8');
+
     return filePath;
   };
 
@@ -166,6 +179,7 @@ describe('formatFiles', () => {
 
   test('should format a list of files', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -188,10 +202,12 @@ describe('formatFiles', () => {
       const result = await formatFiles([file1, file2], {
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check formatted content
       const content1 = await readTestFile(file1);
+
       expect(content1).toBe(
         `${dedent`
           const x = { a: 1, b: 2 };
@@ -199,6 +215,7 @@ describe('formatFiles', () => {
       );
 
       const content2 = await readTestFile(file2);
+
       expect(content2).toBe(
         `${dedent`
           function test() {
@@ -213,14 +230,16 @@ describe('formatFiles', () => {
 
   test('should return ok for empty file list', async () => {
     vi.clearAllMocks();
+
     const result = await formatFiles([], {
       silent: true,
     });
+
     expect(Result.isOk(result)).toBe(true);
   });
 });
 
-describe('formatUncommittedFiles', () => {
+describe(formatUncommittedFiles, () => {
   const testDir = path.join(
     process.cwd(),
     `test-format-uncommitted-${crypto.randomUUID()}`,
@@ -231,14 +250,19 @@ describe('formatUncommittedFiles', () => {
     content: string,
   ): Promise<string> => {
     const filePath = path.join(testDir, filename);
+
     const dir = path.dirname(filePath);
+
     await fs.mkdir(dir, { recursive: true });
+
     await fs.writeFile(filePath, content, 'utf8');
+
     return filePath;
   };
 
   const setupTest = async (): Promise<void> => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
   };
 
@@ -248,42 +272,54 @@ describe('formatUncommittedFiles', () => {
 
   test('should format all uncommitted files by default', async () => {
     await setupTest();
+
     try {
       const untrackedFiles = ['untracked1.ts', 'untracked2.ts'];
+
       const modifiedFiles = ['modified1.ts', 'modified2.ts'];
+
       const stagedFiles = ['staged1.ts', 'staged2.ts'];
 
       // Create test files
       const allFiles = [...untrackedFiles, ...modifiedFiles, ...stagedFiles];
+
       const filePromises = allFiles.map((file) =>
         createTestFile(file, 'const x=1'),
       );
+
       await Promise.all(filePromises);
 
       // Mock git functions
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok(untrackedFiles.map((f) => path.join(testDir, f))),
       );
+
       vi.mocked(getModifiedFiles).mockResolvedValue(
         Result.ok(modifiedFiles.map((f) => path.join(testDir, f))),
       );
+
       vi.mocked(getStagedFiles).mockResolvedValue(
         Result.ok(stagedFiles.map((f) => path.join(testDir, f))),
       );
 
       const result = await formatUncommittedFiles({ silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Verify all git functions were called
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getModifiedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
 
       // Verify files were formatted
       const verifyPromises = allFiles.map(async (file) => {
         const content = await fs.readFile(path.join(testDir, file), 'utf8');
+
         expect(content).toBe('const x = 1;\n');
       });
+
       await Promise.all(verifyPromises);
     } finally {
       await cleanupTest();
@@ -292,8 +328,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should format only untracked files when specified', async () => {
     await setupTest();
+
     try {
       const untrackedFiles = ['untracked.ts'] as const;
+
       await createTestFile(untrackedFiles[0], 'const x=1');
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(
@@ -306,10 +344,13 @@ describe('formatUncommittedFiles', () => {
         staged: false,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getModifiedFiles).not.toHaveBeenCalled();
+
       expect(getStagedFiles).not.toHaveBeenCalled();
     } finally {
       await cleanupTest();
@@ -318,8 +359,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should format only modified files when specified', async () => {
     await setupTest();
+
     try {
       const modifiedFiles = ['modified.ts'] as const;
+
       await createTestFile(modifiedFiles[0], 'const x=1');
 
       vi.mocked(getModifiedFiles).mockResolvedValue(
@@ -332,10 +375,13 @@ describe('formatUncommittedFiles', () => {
         staged: false,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       expect(getUntrackedFiles).not.toHaveBeenCalled();
+
       expect(getModifiedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getStagedFiles).not.toHaveBeenCalled();
     } finally {
       await cleanupTest();
@@ -344,8 +390,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should format only staged files when specified', async () => {
     await setupTest();
+
     try {
       const stagedFiles = ['staged.ts'] as const;
+
       await createTestFile(stagedFiles[0], 'const x=1');
 
       vi.mocked(getStagedFiles).mockResolvedValue(
@@ -358,10 +406,13 @@ describe('formatUncommittedFiles', () => {
         staged: true,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       expect(getUntrackedFiles).not.toHaveBeenCalled();
+
       expect(getModifiedFiles).not.toHaveBeenCalled();
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
     } finally {
       await cleanupTest();
@@ -370,19 +421,24 @@ describe('formatUncommittedFiles', () => {
 
   test('should handle combinations of file types', async () => {
     await setupTest();
+
     try {
       const untrackedFiles = ['untracked.ts'];
+
       const stagedFiles = ['staged.ts'];
 
       const allFiles = [...untrackedFiles, ...stagedFiles];
+
       const filePromises = allFiles.map((file) =>
         createTestFile(file, 'const x=1'),
       );
+
       await Promise.all(filePromises);
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok(untrackedFiles.map((f) => path.join(testDir, f))),
       );
+
       vi.mocked(getStagedFiles).mockResolvedValue(
         Result.ok(stagedFiles.map((f) => path.join(testDir, f))),
       );
@@ -393,10 +449,13 @@ describe('formatUncommittedFiles', () => {
         staged: true,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getModifiedFiles).not.toHaveBeenCalled();
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
     } finally {
       await cleanupTest();
@@ -405,22 +464,28 @@ describe('formatUncommittedFiles', () => {
 
   test('should deduplicate files that appear in multiple categories', async () => {
     await setupTest();
+
     try {
       const duplicateFile = path.join(testDir, 'duplicate.ts');
+
       await createTestFile('duplicate.ts', 'const x=1');
 
       // Mock the same file appearing in multiple categories
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok([duplicateFile]),
       );
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([duplicateFile]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([duplicateFile]));
 
       const result = await formatUncommittedFiles({ silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Verify file was formatted (only once despite appearing in all categories)
       const content = await fs.readFile(duplicateFile, 'utf8');
+
       expect(content).toBe('const x = 1;\n');
     } finally {
       await cleanupTest();
@@ -429,12 +494,16 @@ describe('formatUncommittedFiles', () => {
 
   test('should handle empty file lists', async () => {
     await setupTest();
+
     try {
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatUncommittedFiles({ silent: true });
+
       expect(Result.isOk(result)).toBe(true);
     } finally {
       await cleanupTest();
@@ -443,8 +512,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should return error when getUntrackedFiles fails', async () => {
     await setupTest();
+
     try {
       const error = { message: 'Git error' };
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.err(error));
 
       const result = await formatUncommittedFiles({
@@ -453,9 +524,11 @@ describe('formatUncommittedFiles', () => {
         staged: false,
         silent: true,
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
-        expect(result.value).toStrictEqual(error);
+        assert.deepStrictEqual(result.value, error);
       }
     } finally {
       await cleanupTest();
@@ -464,8 +537,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should return error when getModifiedFiles fails', async () => {
     await setupTest();
+
     try {
       const error = { message: 'Git error' };
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.err(error));
 
       const result = await formatUncommittedFiles({
@@ -474,9 +549,11 @@ describe('formatUncommittedFiles', () => {
         staged: false,
         silent: true,
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
-        expect(result.value).toStrictEqual(error);
+        assert.deepStrictEqual(result.value, error);
       }
     } finally {
       await cleanupTest();
@@ -485,8 +562,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should return error when getStagedFiles fails', async () => {
     await setupTest();
+
     try {
       const error = { message: 'Git error' };
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.err(error));
 
       const result = await formatUncommittedFiles({
@@ -495,9 +574,11 @@ describe('formatUncommittedFiles', () => {
         staged: true,
         silent: true,
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
-        expect(result.value).toStrictEqual(error);
+        assert.deepStrictEqual(result.value, error);
       }
     } finally {
       await cleanupTest();
@@ -506,23 +587,29 @@ describe('formatUncommittedFiles', () => {
 
   test('should respect silent option', async () => {
     await setupTest();
+
     try {
       // Using vi.stubGlobal to avoid direct assignment
       const consoleErrorStub = vi.fn();
+
       vi.stubGlobal('console', {
         ...console,
         error: consoleErrorStub,
       });
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result1 = await formatUncommittedFiles({ silent: false });
+
       expect(Result.isOk(result1)).toBe(true);
       // With silent: false, console output may occur
 
       const result2 = await formatUncommittedFiles({ silent: true });
+
       expect(Result.isOk(result2)).toBe(true);
       // With silent: true, console output should be suppressed
 
@@ -534,8 +621,10 @@ describe('formatUncommittedFiles', () => {
 
   test('should format TypeScript files correctly', async () => {
     await setupTest();
+
     try {
       const testFile = 'test.ts';
+
       await createTestFile(
         testFile,
         dedent`
@@ -547,13 +636,17 @@ describe('formatUncommittedFiles', () => {
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok([path.join(testDir, testFile)]),
       );
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatUncommittedFiles({ silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       const content = await fs.readFile(path.join(testDir, testFile), 'utf8');
+
       expect(content).toBe(
         `${dedent`
           function test() {
@@ -569,19 +662,25 @@ describe('formatUncommittedFiles', () => {
 
   test('should handle non-formattable files gracefully', async () => {
     await setupTest();
+
     try {
       const binaryFile = 'test.bin';
+
       const binaryPath = path.join(testDir, binaryFile);
+
       await createTestFile(
         binaryFile,
         Buffer.from([0x00, 0x01, 0x02]).toString(),
       );
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([binaryPath]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatUncommittedFiles({ silent: true });
+
       // Should handle error gracefully
       expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
     } finally {
@@ -590,7 +689,7 @@ describe('formatUncommittedFiles', () => {
   });
 });
 
-describe('formatDiffFrom', () => {
+describe(formatDiffFrom, () => {
   const testDir = path.join(
     process.cwd(),
     `test-format-diff-${crypto.randomUUID()}`,
@@ -601,7 +700,9 @@ describe('formatDiffFrom', () => {
     content: string,
   ): Promise<string> => {
     const filePath = path.join(testDir, filename);
+
     await fs.writeFile(filePath, content, 'utf8');
+
     return filePath;
   };
 
@@ -610,6 +711,7 @@ describe('formatDiffFrom', () => {
 
   test('should format files from diff', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -624,14 +726,18 @@ describe('formatDiffFrom', () => {
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([file1]));
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatDiffFrom('main', { silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check file was formatted
       const content = await readTestFile(file1);
+
       expect(content).toBe(
         `${dedent`
           const a = 1;
@@ -647,6 +753,7 @@ describe('formatDiffFrom', () => {
 
   test('should include untracked files when option is set', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -666,20 +773,25 @@ describe('formatDiffFrom', () => {
 
       // Mock both functions
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([diffFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok([untrackedFile]),
       );
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatDiffFrom('main', {
         includeUntracked: true,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check both files were formatted
       const diffContent = await readTestFile(diffFile);
+
       expect(diffContent).toBe(
         `${dedent`
           const diff = true;
@@ -687,6 +799,7 @@ describe('formatDiffFrom', () => {
       );
 
       const untrackedContent = await readTestFile(untrackedFile);
+
       expect(untrackedContent).toBe(
         `${dedent`
           const untracked = true;
@@ -694,6 +807,7 @@ describe('formatDiffFrom', () => {
       );
 
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });
@@ -702,6 +816,7 @@ describe('formatDiffFrom', () => {
 
   test('should deduplicate files when including untracked', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -714,22 +829,28 @@ describe('formatDiffFrom', () => {
 
       // Mock both functions to return the same file
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([sharedFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([sharedFile]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatDiffFrom('main', {
         includeUntracked: true,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Verify both functions were called
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
 
       // Check that the file was formatted (content should change)
       const finalContent = await readTestFile(sharedFile);
+
       expect(finalContent).toBe(
         `${dedent`
           const shared = { value: 1 };
@@ -742,6 +863,7 @@ describe('formatDiffFrom', () => {
 
   test('should include both staged and untracked files by default', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -768,18 +890,23 @@ describe('formatDiffFrom', () => {
 
       // Mock all functions
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([diffFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(
         Result.ok([untrackedFile]),
       );
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([stagedFile]));
 
       // Test default behavior (no options provided)
       const result = await formatDiffFrom('main', { silent: true });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check all files were formatted
       const diffContent = await readTestFile(diffFile);
+
       expect(diffContent).toBe(
         `${dedent`
           const diff = true;
@@ -787,6 +914,7 @@ describe('formatDiffFrom', () => {
       );
 
       const stagedContent = await readTestFile(stagedFile);
+
       expect(stagedContent).toBe(
         `${dedent`
           const staged = true;
@@ -794,6 +922,7 @@ describe('formatDiffFrom', () => {
       );
 
       const untrackedContent = await readTestFile(untrackedFile);
+
       expect(untrackedContent).toBe(
         `${dedent`
           const untracked = true;
@@ -802,7 +931,9 @@ describe('formatDiffFrom', () => {
 
       // Verify all functions were called by default
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });
@@ -811,6 +942,7 @@ describe('formatDiffFrom', () => {
 
   test('should include staged files when option is set', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -830,8 +962,11 @@ describe('formatDiffFrom', () => {
 
       // Mock all functions
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([diffFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([stagedFile]));
 
       const result = await formatDiffFrom('main', {
@@ -840,10 +975,12 @@ describe('formatDiffFrom', () => {
         includeModified: false,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check both files were formatted
       const diffContent = await readTestFile(diffFile);
+
       expect(diffContent).toBe(
         `${dedent`
           const diff = true;
@@ -851,6 +988,7 @@ describe('formatDiffFrom', () => {
       );
 
       const stagedContent = await readTestFile(stagedFile);
+
       expect(stagedContent).toBe(
         `${dedent`
           const staged = true;
@@ -858,7 +996,9 @@ describe('formatDiffFrom', () => {
       );
 
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getUntrackedFiles).not.toHaveBeenCalled();
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });
@@ -867,6 +1007,7 @@ describe('formatDiffFrom', () => {
 
   test('should deduplicate files when including both staged and untracked', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -879,8 +1020,11 @@ describe('formatDiffFrom', () => {
 
       // Mock all functions to return the same file
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([sharedFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([sharedFile]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([sharedFile]));
 
       const result = await formatDiffFrom('main', {
@@ -888,15 +1032,19 @@ describe('formatDiffFrom', () => {
         includeStaged: true,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Verify all functions were called
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
+
       expect(getStagedFiles).toHaveBeenCalledWith({ silent: true });
 
       // Check that the file was formatted (content should change)
       const finalContent = await readTestFile(sharedFile);
+
       expect(finalContent).toBe(
         `${dedent`
           const shared = { value: 1 };
@@ -909,6 +1057,7 @@ describe('formatDiffFrom', () => {
 
   test('should exclude staged files when option is set to false', async () => {
     vi.clearAllMocks();
+
     await fs.mkdir(testDir, { recursive: true });
 
     try {
@@ -921,8 +1070,11 @@ describe('formatDiffFrom', () => {
 
       // Mock functions - staged should not be called
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([diffFile]));
+
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getModifiedFiles).mockResolvedValue(Result.ok([]));
+
       vi.mocked(getStagedFiles).mockResolvedValue(Result.ok([]));
 
       const result = await formatDiffFrom('main', {
@@ -931,10 +1083,12 @@ describe('formatDiffFrom', () => {
         includeModified: false,
         silent: true,
       });
+
       expect(Result.isOk(result)).toBe(true);
 
       // Check only diff file was formatted
       const diffContent = await readTestFile(diffFile);
+
       expect(diffContent).toBe(
         `${dedent`
           const diff = true;
@@ -942,8 +1096,11 @@ describe('formatDiffFrom', () => {
       );
 
       expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+
       expect(getStagedFiles).not.toHaveBeenCalled();
+
       expect(getUntrackedFiles).not.toHaveBeenCalled();
+
       expect(getModifiedFiles).not.toHaveBeenCalled();
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });