ts-repo-utils 7.8.2 → 7.9.1

package/src/functions/diff.test.mts

@@ -21,6 +21,7 @@ describe('diff', () => {
     ) => Promise<Result<{ stdout: string; stderr: string }, unknown>>;
   }> => {
     const tempDir = await fs.mkdtemp(path.join(tmpdir(), 'temp-repo-'));
+
     const repoPath = tempDir;
 
     // Initialize git repository
@@ -29,9 +30,12 @@ describe('diff', () => {
       options?: Readonly<{ silent?: boolean }>,
     ): Promise<ExecResult<string>> => {
       const originalCwd = process.cwd();
+
       process.chdir(repoPath);
+
       try {
         const result = await $(cmd, { silent: options?.silent ?? false });
+
         return result;
       } finally {
         process.chdir(originalCwd);
@@ -39,7 +43,9 @@ describe('diff', () => {
     };
 
     await execInRepo('git init', { silent: true });
+
     await execInRepo('git config user.name "Test User"', { silent: true });
+
     await execInRepo('git config user.email "test@example.com"', {
       silent: true,
     });
@@ -60,7 +66,9 @@ describe('diff', () => {
   const createRepoFunctions = (repoPath: string) => {
     const executeInRepo = async <T,>(fn: () => Promise<T>): Promise<T> => {
       const originalCwd = process.cwd();
+
       process.chdir(repoPath);
+
       try {
         return await fn();
       } finally {
@@ -85,6 +93,7 @@ describe('diff', () => {
   describe(getUntrackedFiles, () => {
     test('should return empty array when no files are changed', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -102,11 +111,13 @@ describe('diff', () => {
 
     test('should detect newly created files', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create a new file in the temp repository
         const testFileName = `test-new-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         await fs.writeFile(testFilePath, 'test content');
@@ -127,11 +138,13 @@ describe('diff', () => {
 
     test('should detect modified existing files', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create and track a file first
         const testFileName = `test-modify-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         await fs.writeFile(testFilePath, 'initial content');
@@ -158,14 +171,19 @@ describe('diff', () => {
 
     test('should detect multiple types of changes', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create multiple test files
         const uuid = crypto.randomUUID();
+
         const newFile = `test-new-file-${uuid}.tmp`;
+
         const modifyFile = `test-modify-file-${uuid}.tmp`;
+
         const newFilePath = path.join(repoPath, newFile);
+
         const modifyFilePath = path.join(repoPath, modifyFile);
 
         // Create new file
@@ -173,6 +191,7 @@ describe('diff', () => {
 
         // Create and track another file
         await fs.writeFile(modifyFilePath, 'initial content');
+
         await execInRepo(`git add ${modifyFile}`, { silent: true });
 
         // Modify the tracked file
@@ -186,6 +205,7 @@ describe('diff', () => {
           const files = result.value;
 
           expect(files).toContain(newFile);
+
           expect(files).not.toContain(modifyFile);
         }
       } finally {
@@ -195,6 +215,7 @@ describe('diff', () => {
 
     test('should exclude deleted files from results', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -204,6 +225,7 @@ describe('diff', () => {
 
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Verify no deleted files are included (status 'D')
           for (const file of files) {
             expectTypeOf(file).toBeString();
@@ -218,6 +240,7 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -232,6 +255,7 @@ describe('diff', () => {
 
     test('should parse git status output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -247,6 +271,7 @@ describe('diff', () => {
             expectTypeOf(file).toBeString();
 
             expect(file.trim()).toBe(file); // No leading/trailing whitespace
+
             expect(file.length).toBeGreaterThan(0);
           }
         }
@@ -257,6 +282,7 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -276,6 +302,7 @@ describe('diff', () => {
   describe(getStagedFiles, () => {
     test('should return empty array when no files are staged', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -293,13 +320,17 @@ describe('diff', () => {
 
     test('should detect staged files', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create a new file
         const testFileName = `test-staged-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
+
         await fs.writeFile(testFilePath, 'staged file content');
+
         // Stage the file
         await execInRepo(`git add ${testFileName}`, { silent: true });
 
@@ -319,18 +350,25 @@ describe('diff', () => {
 
     test('should detect multiple staged files', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create multiple test files
         const uuid = crypto.randomUUID();
+
         const file1 = `test-staged-file1-${uuid}.tmp`;
+
         const file2 = `test-staged-file2-${uuid}.tmp`;
+
         const filePath1 = path.join(repoPath, file1);
+
         const filePath2 = path.join(repoPath, file2);
 
         await fs.writeFile(filePath1, 'staged file 1 content');
+
         await fs.writeFile(filePath2, 'staged file 2 content');
+
         // Stage both files
         await execInRepo(`git add ${file1} ${file2}`, { silent: true });
 
@@ -342,6 +380,7 @@ describe('diff', () => {
           const files = result.value;
 
           expect(files).toContain(file1);
+
           expect(files).toContain(file2);
         }
       } finally {
@@ -351,15 +390,19 @@ describe('diff', () => {
 
     test('should exclude deleted files by default', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const testFileName = `test-deleted-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         // Create a file and commit it
         await fs.writeFile(testFilePath, 'file to be deleted');
+
         await execInRepo(`git add ${testFileName}`, { silent: true });
+
         await execInRepo(
           `git commit -m "Add test file for deletion" --no-verify`,
           {
@@ -369,6 +412,7 @@ describe('diff', () => {
 
         // Delete the file and stage the deletion
         await fs.rm(testFilePath, { force: true });
+
         await execInRepo(`git add ${testFileName}`, { silent: true });
 
         // Test with excludeDeleted = true (default)
@@ -389,6 +433,7 @@ describe('diff', () => {
         const gitStatusResult = await execInRepo(`git status --porcelain`, {
           silent: true,
         });
+
         const hasDeletion =
           Result.isOk(gitStatusResult) &&
           gitStatusResult.value.stdout.includes(`D  ${testFileName}`);
@@ -419,6 +464,7 @@ describe('diff', () => {
 
     test('should parse staged files output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -428,6 +474,7 @@ describe('diff', () => {
 
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Each file should be a non-empty string
           for (const file of files) {
             expectTypeOf(file).toBeString();
@@ -442,6 +489,7 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -459,6 +507,7 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -475,6 +524,7 @@ describe('diff', () => {
   describe(getModifiedFiles, () => {
     test('should return empty array when no files are modified', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -492,15 +542,19 @@ describe('diff', () => {
 
     test('should detect modified files', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create a new file and commit it first
         const testFileName = `test-modified-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         await fs.writeFile(testFilePath, 'initial content');
+
         await execInRepo(`git add ${testFileName}`, { silent: true });
+
         await execInRepo(
           `git commit -m "Add file for modification test" --no-verify`,
           { silent: true },
@@ -525,19 +579,27 @@ describe('diff', () => {
 
     test('should detect multiple modified files', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const uuid = crypto.randomUUID();
+
         const file1 = `test-modified-file1-${uuid}.tmp`;
+
         const file2 = `test-modified-file2-${uuid}.tmp`;
+
         const filePath1 = path.join(repoPath, file1);
+
         const filePath2 = path.join(repoPath, file2);
 
         // Create and commit both files
         await fs.writeFile(filePath1, 'initial content 1');
+
         await fs.writeFile(filePath2, 'initial content 2');
+
         await execInRepo(`git add ${file1} ${file2}`, { silent: true });
+
         await execInRepo(
           `git commit -m "Add files for modification test" --no-verify`,
           { silent: true },
@@ -545,6 +607,7 @@ describe('diff', () => {
 
         // Modify both files
         await fs.writeFile(filePath1, 'modified content 1');
+
         await fs.writeFile(filePath2, 'modified content 2');
 
         const result = await repoFunctions.getModifiedFiles({ silent: true });
@@ -555,6 +618,7 @@ describe('diff', () => {
           const files = result.value;
 
           expect(files).toContain(file1);
+
           expect(files).toContain(file2);
         }
       } finally {
@@ -564,15 +628,19 @@ describe('diff', () => {
 
     test('should exclude deleted files by default', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const testFileName = `test-deleted-modified-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         // Create a file and commit it
         await fs.writeFile(testFilePath, 'file to be deleted');
+
         await execInRepo(`git add ${testFileName}`, { silent: true });
+
         await execInRepo(
           `git commit -m "Add test file for deletion" --no-verify`,
           { silent: true },
@@ -614,6 +682,7 @@ describe('diff', () => {
 
     test('should parse modified files output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -623,6 +692,7 @@ describe('diff', () => {
 
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Each file should be a non-empty string
           for (const file of files) {
             expectTypeOf(file).toBeString();
@@ -637,6 +707,7 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -654,6 +725,7 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -670,15 +742,19 @@ describe('diff', () => {
   describe(getDiffFrom, () => {
     test('should work with silent option', async () => {
       const { repoPath, cleanup, execInRepo } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         // Create an initial commit to have something to diff against
         const testFileName = `test-initial-file-${crypto.randomUUID()}.tmp`;
+
         const testFilePath = path.join(repoPath, testFileName);
 
         await fs.writeFile(testFilePath, 'initial content');
+
         await execInRepo(`git add ${testFileName}`, { silent: true });
+
         await execInRepo(`git commit -m "Initial commit" --no-verify`, {
           silent: true,
         });

package/src/functions/exec-async.mts

@@ -62,6 +62,7 @@ export function $(
   options?: ExecOptionsWithStringEncoding | ExecOptionsWithBufferEncoding,
 ): Promise<ExecResult<string | Buffer>> {
   const { silent = false, ...restOptions } = options ?? {};
+
   const normalizedOptions: NormalizedExecOptions = restOptions;
 
   if (!silent) {
@@ -79,6 +80,7 @@ export function $(
         if (!isEmpty(stdout)) {
           echo(stdout);
         }
+
         if (!isEmpty(stderr)) {
           console.error(stderr);
         }
@@ -86,6 +88,7 @@ export function $(
 
       if (error !== null) {
         resolve(Result.err(error));
+
         return;
       }
 
@@ -106,6 +109,7 @@ export function $(
           handleResult(error, stdout, stderr);
         },
       );
+
       return;
     }
 

package/src/functions/exec-async.test.mts

@@ -10,10 +10,12 @@ describe('exec-async', () => {
   const withSilentEcho = async <T,>(fn: () => Promise<T>): Promise<T> => {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
     const originalEcho = (globalThis as any).echo;
+
     // eslint-disable-next-line functional/immutable-data, @typescript-eslint/no-unsafe-member-access
     (globalThis as any).echo = () => {
       // Silent implementation - no output
     };
+
     try {
       return await fn();
     } finally {
@@ -30,6 +32,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         expect(result.value.stdout.trim()).toBe('hello world');
+
         expect(result.value.stderr).toBe('');
       }
     });
@@ -41,6 +44,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         expect(result.value.stdout.trim()).toBe('line1\nline2\nline3');
+
         expect(result.value.stderr).toBe('');
       }
     });
@@ -52,6 +56,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         expect(result.value.stdout).toBe('');
+
         expect(result.value.stderr).toBe('');
       }
     });
@@ -65,6 +70,7 @@ describe('exec-async', () => {
 
       if (Result.isErr(result)) {
         expect(result.value).toBeDefined();
+
         expect(result.value.code).toBeDefined();
       }
     });
@@ -76,6 +82,7 @@ describe('exec-async', () => {
 
       if (Result.isErr(result)) {
         expect(result.value).toBeDefined();
+
         expect(result.value.code).toBe(1);
       }
     });
@@ -138,6 +145,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         expect(Buffer.isBuffer(result.value.stdout)).toBe(true);
+
         expect(Buffer.isBuffer(result.value.stderr)).toBe(true);
       }
     });
@@ -149,6 +157,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         expect(Buffer.isBuffer(result.value.stdout)).toBe(true);
+
         expect(Buffer.isBuffer(result.value.stderr)).toBe(true);
       }
     });
@@ -223,6 +232,7 @@ describe('exec-async', () => {
       if (Result.isOk(result)) {
         // These assignments will fail at compile time if types don't match
         assertType<string>(result.value.stdout);
+
         assertType<string>(result.value.stderr);
       }
     });
@@ -249,6 +259,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         assertType<Buffer>(result.value.stdout);
+
         assertType<Buffer>(result.value.stderr);
       }
     });
@@ -263,6 +274,7 @@ describe('exec-async', () => {
 
       if (Result.isOk(result)) {
         assertType<Buffer>(result.value.stdout);
+
         assertType<Buffer>(result.value.stderr);
       }
     });
@@ -272,10 +284,12 @@ describe('exec-async', () => {
         encoding: 'utf8',
         silent: true,
       });
+
       const _resultAscii = await $('echo "test"', {
         encoding: 'ascii',
         silent: true,
       });
+
       const _resultBase64 = await $('echo "test"', {
         encoding: 'base64',
         silent: true,
@@ -299,17 +313,21 @@ describe('exec-async', () => {
 
     test('should maintain type safety with const encoding values', async () => {
       const bufferEncoding = 'buffer';
+
       const nullEncoding = null;
+
       const utf8Encoding = 'utf8';
 
       const _resultBuffer = await $('echo "test"', {
         encoding: bufferEncoding,
         silent: true,
       });
+
       const _resultNull = await $('echo "test"', {
         encoding: nullEncoding,
         silent: true,
       });
+
       const _resultUtf8 = await $('echo "test"', {
         encoding: utf8Encoding,
         silent: true,
@@ -365,12 +383,15 @@ describe('exec-async', () => {
       // Type check for native exec with default options
       exec('echo "test"', (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
+
         expectType<string, typeof stdout>('=');
+
         expectType<string, typeof stderr>('=');
       });
 
       // The $ function should produce the same types wrapped in Result (suppressed for clean output)
       const _resultPromise = withSilentEcho(async () => $('echo "test"'));
+
       expectType<
         typeof _resultPromise,
         Promise<
@@ -383,7 +404,9 @@ describe('exec-async', () => {
       // Type check for native exec with buffer encoding
       exec('echo "test"', { encoding: 'buffer' }, (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
+
         expectType<Buffer, typeof stdout>('>=');
+
         expectType<Buffer, typeof stderr>('>=');
       });
 
@@ -391,6 +414,7 @@ describe('exec-async', () => {
       const _resultPromise = withSilentEcho(async () =>
         $('echo "test"', { encoding: 'buffer' }),
       );
+
       expectType<
         typeof _resultPromise,
         Promise<
@@ -403,7 +427,9 @@ describe('exec-async', () => {
       // Type check for native exec with null encoding
       exec('echo "test"', { encoding: null }, (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
+
         expectType<Buffer, typeof stdout>('>=');
+
         expectType<Buffer, typeof stderr>('>=');
       });
 
@@ -411,6 +437,7 @@ describe('exec-async', () => {
       const _resultPromise = withSilentEcho(async () =>
         $('echo "test"', { encoding: null }),
       );
+
       expectType<
         typeof _resultPromise,
         Promise<
@@ -423,7 +450,9 @@ describe('exec-async', () => {
       // Type check for native exec with utf8 encoding
       exec('echo "test"', { encoding: 'utf8' }, (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
+
         expectType<string, typeof stdout>('=');
+
         expectType<string, typeof stderr>('=');
       });
 
@@ -431,6 +460,7 @@ describe('exec-async', () => {
       const _resultPromise = withSilentEcho(async () =>
         $('echo "test"', { encoding: 'utf8' }),
       );
+
       expectType<
         typeof _resultPromise,
         Promise<
@@ -446,7 +476,9 @@ describe('exec-async', () => {
         { encoding: 'utf8', timeout: 5000 },
         (error, stdout, stderr) => {
           expectType<ExecException | null, typeof error>('=');
+
           expectType<string, typeof stdout>('=');
+
           expectType<string, typeof stderr>('=');
         },
       );
@@ -456,6 +488,7 @@ describe('exec-async', () => {
         encoding: 'utf8',
         silent: true,
       });
+
       expectType<
         typeof _resultPromise,
         Promise<
@@ -503,17 +536,21 @@ describe('exec-async', () => {
               // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               stderr: undefined as unknown as T,
             };
+
             return emptyParams;
           };
 
           // Default encoding comparison
           const _execDefault = captureExecTypes<string>();
+
           const $Default = await $('echo "test"', { silent: true });
+
           if (Result.isOk($Default)) {
             expectType<
               typeof _execDefault.stdout,
               typeof $Default.value.stdout
             >('=');
+
             expectType<
               typeof _execDefault.stderr,
               typeof $Default.value.stderr
@@ -522,14 +559,17 @@ describe('exec-async', () => {
 
           // Buffer encoding comparison
           const _execBuffer = captureExecTypes<Buffer>('buffer');
+
           const $Buffer = await $('echo "test"', {
             encoding: 'buffer',
             silent: true,
           });
+
           if (Result.isOk($Buffer)) {
             expectType<typeof _execBuffer.stdout, typeof $Buffer.value.stdout>(
               '=',
             );
+
             expectType<typeof _execBuffer.stderr, typeof $Buffer.value.stderr>(
               '=',
             );
@@ -542,7 +582,9 @@ describe('exec-async', () => {
         });
       } finally {
         consoleLogSpy.mockRestore();
+
         consoleErrorSpy.mockRestore();
+
         stderrWriteSpy.mockRestore();
       }
     });