ts-repo-utils 2.2.2 → 2.3.1

package/src/functions/assert-repo-is-dirty.mts

@@ -6,8 +6,10 @@ import '../node-global.mjs';
  * @returns True if the repo is dirty, false otherwise.
  * @throws Error if git command fails.
  */
-export const repoIsDirty = async (): Promise<boolean> => {
-  const status = await getGitStatus();
+export const repoIsDirty = async (
+  options?: Readonly<{ silent?: boolean }>,
+): Promise<boolean> => {
+  const status = await getGitStatus({ silent: options?.silent ?? false });
   return status.isDirty;
 };
 
@@ -15,9 +17,11 @@ export const repoIsDirty = async (): Promise<boolean> => {
  * Checks if the repository is dirty and exits with code 1 if it is.
  * Shows git status and diff output before exiting.
  */
-export const assertRepoIsDirty = async (): Promise<void> => {
+export const assertRepoIsClean = async (
+  options?: Readonly<{ silent?: boolean }>,
+): Promise<void> => {
   try {
-    const status = await getGitStatus();
+    const status = await getGitStatus({ silent: options?.silent ?? false });
 
     if (!status.isDirty) {
       echo('Repo is clean\n');
@@ -29,12 +33,16 @@ export const assertRepoIsDirty = async (): Promise<void> => {
     echo(status.stdout);
 
     // Show files not tracked by git and unstaged changes
-    const addResult = await $('git add -N .');
+    const addResult = await $('git add -N .', {
+      silent: options?.silent ?? false,
+    });
     if (Result.isErr(addResult)) {
       echo('Warning: Failed to add untracked files for diff\n');
     }
 
-    const diffResult = await $('git diff');
+    const diffResult = await $('git diff', {
+      silent: options?.silent ?? false,
+    });
     if (Result.isErr(diffResult)) {
       echo('Warning: Failed to show diff\n');
     }
@@ -50,11 +58,15 @@ export const assertRepoIsDirty = async (): Promise<void> => {
  * Gets the git status of the repository.
  * @returns An object containing status information.
  */
-const getGitStatus = async (): Promise<{
+const getGitStatus = async (
+  options?: Readonly<{ silent?: boolean }>,
+): Promise<{
   isDirty: boolean;
   stdout: string;
 }> => {
-  const res = await $('git status --porcelain');
+  const res = await $('git status --porcelain', {
+    silent: options?.silent ?? false,
+  });
 
   if (Result.isErr(res)) {
     throw new Error(`Failed to get git status: ${res.value.message}`);

package/src/functions/diff.mts

@@ -9,12 +9,23 @@ export const getUntrackedFiles = async (
   options?: Readonly<{
     /** @default true */
     excludeDeleted?: boolean;
+    /** @default false */
+    silent?: boolean;
   }>,
 ): Promise<
   Result<readonly string[], ExecException | Readonly<{ message: string }>>
 > => {
   // Get changed files from git status
-  const result = await $('git status --porcelain');
+  const result = await $(
+    [
+      `git ls-files --others --exclude-standard`,
+      // Append '--deleted' to include deleted files only if excludeDeleted is explicitly false
+      (options?.excludeDeleted ?? true) ? '' : '--deleted',
+    ]
+      .filter((s) => s !== '')
+      .join(' '),
+    { silent: options?.silent ?? false },
+  );
 
   if (Result.isErr(result)) {
     return result;
@@ -25,20 +36,8 @@ export const getUntrackedFiles = async (
   // Parse git status output
   const files = stdout
     .split('\n')
-    .filter((line) => line.trim() !== '')
-    .map((line) => {
-      // Status format: "XY filename" where X and Y are status codes
-      const match = /^..\s+(.+)$/u.exec(line);
-      return match?.[1];
-    })
-    .filter(
-      (file): file is string =>
-        // Filter out deleted files (status starts with 'D')
-        file !== undefined &&
-        ((options?.excludeDeleted ?? true)
-          ? !stdout.includes(`D  ${file}`)
-          : true),
-    );
+    .map((s) => s.trim())
+    .filter((s) => s !== '');
 
   return Result.ok(files);
 };
@@ -51,13 +50,22 @@ export const getDiffFrom = async (
   options?: Readonly<{
     /** @default true */
     excludeDeleted?: boolean;
+    /** @default false */
+    silent?: boolean;
   }>,
 ): Promise<
   Result<readonly string[], ExecException | Readonly<{ message: string }>>
 > => {
   // Get files that differ from base branch/commit (excluding deleted files)
   const result = await $(
-    `git diff --name-only ${base} ${(options?.excludeDeleted ?? true) ? '--diff-filter=d' : ''}`,
+    [
+      `git diff --name-only`,
+      base,
+      (options?.excludeDeleted ?? true) ? '--diff-filter=d' : '',
+    ]
+      .filter((s) => s !== '')
+      .join(' '),
+    { silent: options?.silent ?? false },
   );
 
   if (Result.isErr(result)) {

package/src/functions/diff.test.mts

@@ -1,8 +1,6 @@
-import { rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
 import { Result } from 'ts-data-forge';
 import '../node-global.mjs';
-import { getUntrackedFiles } from './diff.mjs';
+import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
 
 describe('diff', () => {
   // Use project root for test files to ensure git tracking
@@ -13,7 +11,7 @@ describe('diff', () => {
     for (const file of testFiles) {
       try {
         // eslint-disable-next-line no-await-in-loop
-        await rm(file, { force: true });
+        await fs.rm(file, { force: true });
       } catch {
         // Ignore cleanup errors
       }
@@ -23,7 +21,7 @@ describe('diff', () => {
 
   describe('getUntrackedFiles', () => {
     test('should return empty array when no files are changed', async () => {
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
@@ -34,84 +32,82 @@ describe('diff', () => {
     test('should detect newly created files', async () => {
       // Create a new file in project root
       const testFileName = 'test-new-file.tmp';
-      const testFilePath = join(process.cwd(), testFileName);
+      const testFilePath = path.join(process.cwd(), testFileName);
       testFiles.push(testFilePath);
 
-      await writeFile(testFilePath, 'test content');
+      await fs.writeFile(testFilePath, 'test content');
 
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
         const files = result.value;
-        expect(files.some((file) => file.includes(testFileName))).toBe(true);
+        expect(files.some((file) => file === testFileName)).toBe(true);
       }
     });
 
     test('should detect modified existing files', async () => {
       // Use an existing file in the project that we can modify safely
       const testFileName = 'test-modify-file.tmp';
-      const testFilePath = join(process.cwd(), testFileName);
+      const testFilePath = path.join(process.cwd(), testFileName);
       testFiles.push(testFilePath);
 
       // Create and commit the file first
-      await writeFile(testFilePath, 'initial content');
+      await fs.writeFile(testFilePath, 'initial content');
 
       // Add to git to track it
-      await $(`git add ${testFileName}`);
+      await $(`git add ${testFileName}`, { silent: true });
 
       // Modify the file
-      await writeFile(testFilePath, 'modified content');
+      await fs.writeFile(testFilePath, 'modified content');
 
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
         const files = result.value;
-        expect(files.some((file) => file.includes(testFileName))).toBe(true);
+        expect(files.some((file) => file === testFileName)).toBe(false);
       }
 
       // Reset git state
-      await $(`git reset HEAD ${testFileName}`);
+      await $(`git reset HEAD ${testFileName}`, { silent: true });
     });
 
     test('should detect multiple types of changes', async () => {
       // Create multiple test files
-      const newFile = join(process.cwd(), 'test-new-file.tmp');
-      const modifyFile = join(process.cwd(), 'test-modify-file.tmp');
+      const newFile = path.join(process.cwd(), 'test-new-file.tmp');
+      const modifyFile = path.join(process.cwd(), 'test-modify-file.tmp');
       testFiles.push(newFile, modifyFile);
 
       // Create new file
-      await writeFile(newFile, 'new file content');
+      await fs.writeFile(newFile, 'new file content');
 
       // Create and track another file
-      await writeFile(modifyFile, 'initial content');
-      await $(`git add test-modify-file.tmp`);
+      await fs.writeFile(modifyFile, 'initial content');
+      await $(`git add test-modify-file.tmp`, { silent: true });
 
       // Modify the tracked file
-      await writeFile(modifyFile, 'modified content');
+      await fs.writeFile(modifyFile, 'modified content');
 
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
         const files = result.value;
-        expect(files.some((file) => file.includes('test-new-file.tmp'))).toBe(
-          true,
+        expect(files.some((file) => file === 'test-new-file.tmp')).toBe(true);
+        expect(files.some((file) => file === 'test-modify-file.tmp')).toBe(
+          false,
         );
-        expect(
-          files.some((file) => file.includes('test-modify-file.tmp')),
-        ).toBe(true);
       }
 
       // Reset git state
-      await $(`git reset HEAD test-modify-file.tmp`);
+      await $(`git reset HEAD test-modify-file.tmp`, { silent: true });
     });
 
     test('should exclude deleted files from results', async () => {
       // This test is more complex as it requires simulating git state
       // For now, we'll test that the function executes successfully
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
@@ -127,14 +123,14 @@ describe('diff', () => {
     test('should handle git command errors gracefully', async () => {
       // This test would require mocking git command failure
       // For now, we'll ensure the function returns a Result type
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       // Should always return a Result, either Ok or Err
       expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
     });
 
     test('should parse git status output correctly', async () => {
-      const result = await getUntrackedFiles();
+      const result = await getUntrackedFiles({ silent: true });
 
       expect(Result.isOk(result)).toBe(true);
       if (Result.isOk(result)) {
@@ -148,5 +144,22 @@ describe('diff', () => {
         });
       }
     });
+
+    test('should work with silent option', async () => {
+      const result = await getUntrackedFiles({ silent: true });
+
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(Array.isArray(result.value)).toBe(true);
+      }
+    });
+  });
+
+  describe('getDiffFrom', () => {
+    test('should work with silent option', async () => {
+      const result = await getDiffFrom('HEAD~1', { silent: true });
+
+      expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
+    });
   });
 });

package/src/functions/exec-async.mts

@@ -16,7 +16,7 @@ export const $ = (
   const { silent = false, timeout = 30000 } = options;
 
   if (!silent) {
-    console.log(`$ ${cmd}`);
+    echo(`$ ${cmd}`);
   }
 
   return new Promise((resolve) => {
@@ -25,7 +25,7 @@ export const $ = (
     exec(cmd, execOptions, (error, stdout, stderr) => {
       if (!silent) {
         if (stdout !== '') {
-          console.log(stdout);
+          echo(stdout);
         }
         if (stderr !== '') {
           console.error(stderr);

package/src/functions/format.mts

@@ -1,7 +1,5 @@
-import glob from 'fast-glob';
-import { readFile, writeFile } from 'node:fs/promises';
 import * as prettier from 'prettier';
-import { Result } from 'ts-data-forge';
+import { Arr, Result } from 'ts-data-forge';
 import '../node-global.mjs';
 import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
 
@@ -12,23 +10,30 @@ import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
  */
 export const formatFilesList = async (
   files: readonly string[],
+  options?: Readonly<{ silent?: boolean }>,
 ): Promise<'ok' | 'err'> => {
+  const silent = options?.silent ?? false;
+
   if (files.length === 0) {
-    echo('No files to format');
+    if (!silent) {
+      echo('No files to format');
+    }
     return 'ok';
   }
 
-  echo(`Formatting ${files.length} files...`);
+  if (!silent) {
+    echo(`Formatting ${files.length} files...`);
+  }
 
   // Format each file
   const results = await Promise.allSettled(
     files.map(async (filePath) => {
       try {
         // Read file content
-        const content = await readFile(filePath, 'utf8');
+        const content = await fs.readFile(filePath, 'utf8');
 
         // Resolve prettier config for this file
-        const options = await prettier.resolveConfig(filePath);
+        const prettierOptions = await prettier.resolveConfig(filePath);
 
         // Check if file is ignored by prettier
         const fileInfo = await prettier.getFileInfo(filePath, {
@@ -36,20 +41,24 @@ export const formatFilesList = async (
         });
 
         if (fileInfo.ignored) {
-          echo(`Skipping ignored file: ${filePath}`);
+          if (!silent) {
+            echo(`Skipping ignored file: ${filePath}`);
+          }
           return;
         }
 
         // Format the content
         const formatted = await prettier.format(content, {
-          ...options,
+          ...prettierOptions,
           filepath: filePath,
         });
 
         // Only write if content changed
         if (formatted !== content) {
-          await writeFile(filePath, formatted, 'utf8');
-          echo(`Formatted: ${filePath}`);
+          await fs.writeFile(filePath, formatted, 'utf8');
+          if (!silent) {
+            echo(`Formatted: ${filePath}`);
+          }
         }
       } catch (error) {
         console.error(`Error formatting ${filePath}:`, error);
@@ -68,7 +77,12 @@ export const formatFilesList = async (
  * @param pathGlob - Glob pattern to match files
  * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatFiles = async (pathGlob: string): Promise<'ok' | 'err'> => {
+export const formatFiles = async (
+  pathGlob: string,
+  options?: Readonly<{ silent?: boolean }>,
+): Promise<'ok' | 'err'> => {
+  const silent = options?.silent ?? false;
+
   try {
     // Find all files matching the glob
     const files = await glob(pathGlob, {
@@ -78,11 +92,13 @@ export const formatFiles = async (pathGlob: string): Promise<'ok' | 'err'> => {
     });
 
     if (files.length === 0) {
-      echo('No files found matching pattern:', pathGlob);
+      if (!silent) {
+        echo('No files found matching pattern:', pathGlob);
+      }
       return 'ok';
     }
 
-    return await formatFilesList(files);
+    return await formatFilesList(files, { silent });
   } catch (error) {
     console.error('Error in formatFiles:', error);
     return 'err';
@@ -91,11 +107,18 @@ export const formatFiles = async (pathGlob: string): Promise<'ok' | 'err'> => {
 
 /**
  * Format only files that have been changed (git status)
+ * @param options - Options for formatting
  * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatUntracked = async (): Promise<'ok' | 'err'> => {
+export const formatUntracked = async (
+  options?: Readonly<{ silent?: boolean }>,
+): Promise<'ok' | 'err'> => {
+  const silent = options?.silent ?? false;
+
   try {
-    const untrackedFilesResult = await getUntrackedFiles();
+    const untrackedFilesResult = await getUntrackedFiles({
+      silent,
+    });
 
     if (Result.isErr(untrackedFilesResult)) {
       console.error('Error getting changed files:', untrackedFilesResult.value);
@@ -105,20 +128,26 @@ export const formatUntracked = async (): Promise<'ok' | 'err'> => {
     const files = untrackedFilesResult.value;
 
     if (files.length === 0) {
-      echo('No changed files to format');
+      if (!silent) {
+        echo('No changed files to format');
+      }
       return 'ok';
     }
 
-    echo('Formatting changed files:', files);
+    if (!silent) {
+      echo('Formatting changed files:', files);
+    }
 
     // Filter out non-existent files before formatting
     const fileExistenceChecks = await Promise.allSettled(
       files.map(async (filePath) => {
         try {
-          await readFile(filePath, 'utf8');
+          await fs.readFile(filePath, 'utf8');
           return filePath;
         } catch {
-          echo(`Skipping non-existent file: ${filePath}`);
+          if (!silent) {
+            echo(`Skipping non-existent file: ${filePath}`);
+          }
           return undefined;
         }
       }),
@@ -131,7 +160,7 @@ export const formatUntracked = async (): Promise<'ok' | 'err'> => {
       )
       .map((result) => result.value);
 
-    return await formatFilesList(existingFiles);
+    return await formatFilesList(existingFiles, { silent });
   } catch (error) {
     console.error('Error in formatUntracked:', error);
     return 'err';
@@ -143,15 +172,20 @@ export const formatUntracked = async (): Promise<'ok' | 'err'> => {
  * @param base - Base branch name or commit hash to compare against (defaults to 'main')
  * @param options - Options for formatting
  * @param options.includeUntracked - Include untracked files in addition to diff files (default is true)
+ * @param options.silent - Silent mode to suppress command output (default is false)
  * @returns 'ok' if successful, 'err' if any errors occurred
  */
 export const formatDiffFrom = async (
   base: string,
-  options?: Readonly<{ includeUntracked?: boolean }>,
+  options?: Readonly<{ includeUntracked?: boolean; silent?: boolean }>,
 ): Promise<'ok' | 'err'> => {
+  const silent = options?.silent ?? false;
+
   try {
     // Get files that differ from base branch/commit (excluding deleted files)
-    const diffFromBaseResult = await getDiffFrom(base);
+    const diffFromBaseResult = await getDiffFrom(base, {
+      silent,
+    });
 
     if (Result.isErr(diffFromBaseResult)) {
       console.error('Error getting changed files:', diffFromBaseResult.value);
@@ -159,11 +193,13 @@ export const formatDiffFrom = async (
     }
 
     const diffFiles = diffFromBaseResult.value;
-    let allFiles = diffFiles;
+    let mut_allFiles = diffFiles;
 
     // If includeUntracked is true, also get untracked files
     if (options?.includeUntracked ?? true) {
-      const untrackedFilesResult = await getUntrackedFiles();
+      const untrackedFilesResult = await getUntrackedFiles({
+        silent,
+      });
 
       if (Result.isErr(untrackedFilesResult)) {
         console.error(
@@ -176,23 +212,28 @@ export const formatDiffFrom = async (
       const untrackedFiles = untrackedFilesResult.value;
 
       // Combine and deduplicate files
-      const uniqueFiles = new Set([...diffFiles, ...untrackedFiles]);
-      allFiles = Array.from(uniqueFiles);
+      mut_allFiles = Arr.uniq([...diffFiles, ...untrackedFiles]);
 
-      echo(
-        `Formatting files that differ from ${base} and untracked files:`,
-        allFiles,
-      );
+      if (!silent) {
+        echo(
+          `Formatting files that differ from ${base} and untracked files:`,
+          mut_allFiles,
+        );
+      }
     } else {
-      echo(`Formatting files that differ from ${base}:`, allFiles);
+      if (!silent) {
+        echo(`Formatting files that differ from ${base}:`, mut_allFiles);
+      }
     }
 
-    if (allFiles.length === 0) {
-      echo(`No files to format`);
+    if (mut_allFiles.length === 0) {
+      if (!silent) {
+        echo(`No files to format`);
+      }
       return 'ok';
     }
 
-    return await formatFilesList(allFiles);
+    return await formatFilesList(mut_allFiles, { silent });
   } catch (error) {
     console.error('Error in formatDiffFrom:', error);
     return 'err';

package/src/functions/format.test.mts

@@ -1,7 +1,6 @@
 import dedent from 'dedent';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import { Result } from 'ts-data-forge';
+import '../node-global.mjs';
 import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
 import { formatDiffFrom, formatFiles, formatFilesList } from './format.mjs';
 
@@ -54,7 +53,7 @@ describe('formatFiles', () => {
       await createTestFile('test.md', '# Test\n\nSome    spaces');
 
       // Format TypeScript files
-      const result = await formatFiles(`${testDir}/*.ts`);
+      const result = await formatFiles(`${testDir}/*.ts`, { silent: true });
       expect(result).toBe('ok');
 
       // Check that files were formatted
@@ -85,7 +84,9 @@ describe('formatFiles', () => {
   });
 
   test('should return ok when no files match pattern', async () => {
-    const result = await formatFiles('/non-existent-path/*.ts');
+    const result = await formatFiles('/non-existent-path/*.ts', {
+      silent: true,
+    });
     expect(result).toBe('ok');
   });
 
@@ -103,7 +104,9 @@ describe('formatFiles', () => {
       );
 
       // Format with recursive glob
-      const result = await formatFiles(`${testDir}/**/*.ts`);
+      const result = await formatFiles(`${testDir}/**/*.ts`, {
+        silent: true,
+      });
       expect(result).toBe('ok');
 
       // Check that nested file was formatted
@@ -159,7 +162,9 @@ describe('formatFilesList', () => {
       );
 
       // Format the files
-      const result = await formatFilesList([file1, file2]);
+      const result = await formatFilesList([file1, file2], {
+        silent: true,
+      });
       expect(result).toBe('ok');
 
       // Check formatted content
@@ -184,7 +189,9 @@ describe('formatFilesList', () => {
   });
 
   test('should return ok for empty file list', async () => {
-    const result = await formatFilesList([]);
+    const result = await formatFilesList([], {
+      silent: true,
+    });
     expect(result).toBe('ok');
   });
 });
@@ -224,7 +231,7 @@ describe('formatDiffFrom', () => {
 
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
 
-      const result = await formatDiffFrom('main');
+      const result = await formatDiffFrom('main', { silent: true });
       expect(result).toBe('ok');
 
       // Check file was formatted
@@ -236,7 +243,7 @@ describe('formatDiffFrom', () => {
         `}\n`,
       );
 
-      expect(getDiffFrom).toHaveBeenCalledWith('main');
+      expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });
     }
@@ -266,7 +273,10 @@ describe('formatDiffFrom', () => {
         Result.ok([untrackedFile]),
       );
 
-      const result = await formatDiffFrom('main', { includeUntracked: true });
+      const result = await formatDiffFrom('main', {
+        includeUntracked: true,
+        silent: true,
+      });
       expect(result).toBe('ok');
 
       // Check both files were formatted
@@ -284,8 +294,8 @@ describe('formatDiffFrom', () => {
         `}\n`,
       );
 
-      expect(getDiffFrom).toHaveBeenCalledWith('main');
-      expect(getUntrackedFiles).toHaveBeenCalled();
+      expect(getDiffFrom).toHaveBeenCalledWith('main', { silent: true });
+      expect(getUntrackedFiles).toHaveBeenCalledWith({ silent: true });
     } finally {
       await fs.rm(testDir, { recursive: true, force: true });
     }
@@ -306,12 +316,15 @@ describe('formatDiffFrom', () => {
       vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([sharedFile]));
       vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([sharedFile]));
 
-      const result = await formatDiffFrom('main', { includeUntracked: true });
+      const result = await formatDiffFrom('main', {
+        includeUntracked: true,
+        silent: true,
+      });
       expect(result).toBe('ok');
 
       // Verify both functions were called
-      expect(getDiffFrom).toHaveBeenCalledWith('main');
-      expect(getUntrackedFiles).toHaveBeenCalled();
+      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);