ts-repo-utils 7.8.1 → 7.9.0

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 {
@@ -82,15 +90,17 @@ describe('diff', () => {
     };
   };
 
-  describe('getUntrackedFiles', () => {
+  describe(getUntrackedFiles, () => {
     test('should return empty array when no files are changed', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -101,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');
@@ -113,8 +125,10 @@ describe('diff', () => {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(testFileName);
         }
       } finally {
@@ -124,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');
@@ -142,8 +158,10 @@ describe('diff', () => {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).not.toContain(testFileName);
         }
       } finally {
@@ -153,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
@@ -168,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
@@ -176,9 +200,12 @@ describe('diff', () => {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(newFile);
+
           expect(files).not.toContain(modifyFile);
         }
       } finally {
@@ -188,17 +215,21 @@ describe('diff', () => {
 
     test('should exclude deleted files from results', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Verify no deleted files are included (status 'D')
           for (const file of files) {
-            expect(typeof file).toBe('string');
+            expectTypeOf(file).toBeString();
+
             expect(file.length).toBeGreaterThan(0);
           }
         }
@@ -209,6 +240,7 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
@@ -223,19 +255,23 @@ describe('diff', () => {
 
     test('should parse git status output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
 
           // Each file should be a non-empty string
           for (const file of files) {
-            expect(typeof file).toBe('string');
+            expectTypeOf(file).toBeString();
+
             expect(file.trim()).toBe(file); // No leading/trailing whitespace
+
             expect(file.length).toBeGreaterThan(0);
           }
         }
@@ -246,12 +282,14 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getUntrackedFiles({ silent: true });
 
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -261,14 +299,17 @@ describe('diff', () => {
     });
   });
 
-  describe('getStagedFiles', () => {
+  describe(getStagedFiles, () => {
     test('should return empty array when no files are staged', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -279,20 +320,27 @@ 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 });
 
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(testFileName);
         }
       } finally {
@@ -302,26 +350,37 @@ 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 });
 
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(file1);
+
           expect(files).toContain(file2);
         }
       } finally {
@@ -331,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`,
           {
@@ -349,15 +412,19 @@ 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)
         const resultExclude = await repoFunctions.getStagedFiles({
           silent: true,
         });
+
         expect(Result.isOk(resultExclude)).toBe(true);
+
         if (Result.isOk(resultExclude)) {
           const files = resultExclude.value;
+
           expect(files).not.toContain(testFileName);
         }
 
@@ -366,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}`);
@@ -375,9 +443,12 @@ describe('diff', () => {
             excludeDeleted: false,
             silent: true,
           });
+
           expect(Result.isOk(resultInclude)).toBe(true);
+
           if (Result.isOk(resultInclude)) {
             const files = resultInclude.value;
+
             expect(files).toContain(testFileName);
           }
         } else {
@@ -393,16 +464,21 @@ describe('diff', () => {
 
     test('should parse staged files output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Each file should be a non-empty string
           for (const file of files) {
-            expect(typeof file).toBe('string');
+            expectTypeOf(file).toBeString();
+
             expect(file.trim()).toBe(file); // No leading/trailing whitespace
           }
         }
@@ -413,11 +489,14 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -428,10 +507,12 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getStagedFiles({ silent: true });
+
         // Should always return a Result, either Ok or Err
         expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
       } finally {
@@ -440,14 +521,17 @@ describe('diff', () => {
     });
   });
 
-  describe('getModifiedFiles', () => {
+  describe(getModifiedFiles, () => {
     test('should return empty array when no files are modified', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getModifiedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -458,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 },
@@ -476,9 +564,12 @@ describe('diff', () => {
         await fs.writeFile(testFilePath, 'modified content');
 
         const result = await repoFunctions.getModifiedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(testFileName);
         }
       } finally {
@@ -488,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 },
@@ -508,13 +607,18 @@ 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 });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           expect(files).toContain(file1);
+
           expect(files).toContain(file2);
         }
       } finally {
@@ -524,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 },
@@ -545,9 +653,12 @@ describe('diff', () => {
         const resultExclude = await repoFunctions.getModifiedFiles({
           silent: true,
         });
+
         expect(Result.isOk(resultExclude)).toBe(true);
+
         if (Result.isOk(resultExclude)) {
           const files = resultExclude.value;
+
           expect(files).not.toContain(testFileName);
         }
 
@@ -556,9 +667,12 @@ describe('diff', () => {
           excludeDeleted: false,
           silent: true,
         });
+
         expect(Result.isOk(resultInclude)).toBe(true);
+
         if (Result.isOk(resultInclude)) {
           const files = resultInclude.value;
+
           expect(files).toContain(testFileName);
         }
       } finally {
@@ -568,16 +682,21 @@ describe('diff', () => {
 
     test('should parse modified files output correctly', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getModifiedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           const files = result.value;
+
           // Each file should be a non-empty string
           for (const file of files) {
-            expect(typeof file).toBe('string');
+            expectTypeOf(file).toBeString();
+
             expect(file.trim()).toBe(file); // No leading/trailing whitespace
           }
         }
@@ -588,11 +707,14 @@ describe('diff', () => {
 
     test('should work with silent option', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getModifiedFiles({ silent: true });
+
         expect(Result.isOk(result)).toBe(true);
+
         if (Result.isOk(result)) {
           expect(Array.isArray(result.value)).toBe(true);
         }
@@ -603,10 +725,12 @@ describe('diff', () => {
 
     test('should handle git command errors gracefully', async () => {
       const { repoPath, cleanup } = await createTempRepo();
+
       const repoFunctions = createRepoFunctions(repoPath);
 
       try {
         const result = await repoFunctions.getModifiedFiles({ silent: true });
+
         // Should always return a Result, either Ok or Err
         expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
       } finally {
@@ -615,18 +739,22 @@ describe('diff', () => {
     });
   });
 
-  describe('getDiffFrom', () => {
+  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;
     }