ts-repo-utils 6.1.0 → 6.2.0

package/src/functions/exec-async.mts

@@ -9,9 +9,9 @@ type ExecOptionsCustom = Readonly<{
   silent?: boolean;
 }>;
 
-type ExecOptions = DeepReadonly<ExecOptions_ & ExecOptionsCustom>;
+export type ExecOptions = DeepReadonly<ExecOptions_ & ExecOptionsCustom>;
 
-type ExecResult<T extends string | Buffer> = Result<
+export type ExecResult<T extends string | Buffer> = Result<
   Readonly<{ stdout: T; stderr: T }>,
   ExecException
 >;

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

@@ -448,53 +448,83 @@ describe('exec-async', () => {
     });
 
     test('should demonstrate type equivalence with runtime comparison', async () => {
-      // Create a type that represents what exec callback receives
-      type ExecCallbackParams<T extends string | Buffer> = {
-        error: ExecException | null;
-        stdout: T;
-        stderr: T;
-      };
-
-      // Helper to capture exec callback types
-      const captureExecTypes = <T extends string | Buffer>(
-        _encoding?: BufferEncoding | 'buffer' | null,
-      ): ExecCallbackParams<T> => {
-        const emptyParams: ExecCallbackParams<T> = {
-          error: null,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          stdout: undefined as unknown as T,
-          // eslint-disable-next-line @typescript-eslint/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>(
-          '=',
-        );
-      }
-
-      // 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>('=');
-      }
-
-      // Error type comparison
-      if (Result.isErr($Default)) {
-        expectType<ExecException, typeof $Default.value>('=');
+      // Mock console functions to suppress output
+      const consoleLogSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      const consoleErrorSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      const stderrWriteSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(process.stderr, 'write')
+        .mockImplementation(() => true);
+
+      try {
+        await withSilentEcho(async () => {
+          // Create a type that represents what exec callback receives
+          type ExecCallbackParams<T extends string | Buffer> = {
+            error: ExecException | null;
+            stdout: T;
+            stderr: T;
+          };
+
+          // Helper to capture exec callback types
+          const captureExecTypes = <T extends string | Buffer>(
+            _encoding?: BufferEncoding | 'buffer' | null,
+          ): ExecCallbackParams<T> => {
+            const emptyParams: ExecCallbackParams<T> = {
+              error: null,
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+              stdout: undefined as unknown as T,
+              // eslint-disable-next-line @typescript-eslint/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
+            >('=');
+          }
+
+          // 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>(
+              '=',
+            );
+          }
+
+          // Error type comparison
+          if (Result.isErr($Default)) {
+            expectType<ExecException, typeof $Default.value>('=');
+          }
+        });
+      } finally {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        stderrWriteSpy.mockRestore();
       }
     });
   });

package/src/functions/format.mts

@@ -1,25 +1,30 @@
+import { type ExecException } from 'node:child_process';
 import * as prettier from 'prettier';
-import { Arr, Result } from 'ts-data-forge';
+import { Arr, isNotUndefined, Result } from 'ts-data-forge';
 import '../node-global.mjs';
-import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
+import {
+  getDiffFrom,
+  getModifiedFiles,
+  getStagedFiles,
+  getUntrackedFiles,
+} from './diff.mjs';
 
 /**
  * Format a list of files using Prettier
  *
  * @param files - Array of file paths to format
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatFilesList = async (
+export const formatFiles = async (
   files: readonly string[],
   options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
+): Promise<Result<undefined, readonly unknown[]>> => {
   const silent = options?.silent ?? false;
 
   if (files.length === 0) {
     if (!silent) {
       echo('No files to format');
     }
-    return 'ok';
+    return Result.ok(undefined);
   }
 
   if (!silent) {
@@ -27,62 +32,97 @@ export const formatFilesList = async (
   }
 
   // Format each file
-  const results = await Promise.allSettled(
-    files.map(async (filePath) => {
-      try {
-        // Read file content
-        const content = await fs.readFile(filePath, 'utf8');
+  const results: readonly PromiseSettledResult<Result<undefined, unknown>>[] =
+    // NOTE: Using Promise.allSettled to ensure all files are processed even if some fail
+    await Promise.allSettled(
+      files.map(async (filePath) => {
+        try {
+          // Check if file exists first
+          try {
+            await fs.access(filePath);
+          } catch {
+            // File doesn't exist, skip it
+            if (!silent) {
+              echo(`Skipping non-existent file: ${filePath}`);
+            }
+            return Result.ok(undefined);
+          }
 
-        // Resolve prettier config for this file
-        const prettierOptions = await prettier.resolveConfig(filePath);
+          // Read file content
+          const content = await fs.readFile(filePath, 'utf8');
 
-        // Check if file is ignored by prettier
-        const fileInfo = await prettier.getFileInfo(filePath, {
-          ignorePath: '.prettierignore',
-        });
+          // Resolve prettier config for this file
+          const prettierOptions = await prettier.resolveConfig(filePath);
 
-        if (fileInfo.ignored) {
-          if (!silent) {
-            echo(`Skipping ignored file: ${filePath}`);
+          // Check if file is ignored by prettier
+          const fileInfo = await prettier.getFileInfo(filePath, {
+            ignorePath: '.prettierignore',
+          });
+
+          if (fileInfo.ignored) {
+            if (!silent) {
+              echo(`Skipping ignored file: ${filePath}`);
+            }
+            return Result.ok(undefined);
           }
-          return;
-        }
 
-        // Format the content
-        const formatted = await prettier.format(content, {
-          ...prettierOptions,
-          filepath: filePath,
-        });
+          // Format the content
+          const formatted = await prettier.format(content, {
+            ...prettierOptions,
+            filepath: filePath,
+          });
+
+          // Only write if content changed
+          if (formatted === content) {
+            if (!silent) {
+              echo(`Unchanged: ${filePath}`);
+            }
+          } else {
+            await fs.writeFile(filePath, formatted, 'utf8');
+            if (!silent) {
+              echo(`Formatted: ${filePath}`);
+            }
+          }
 
-        // Only write if content changed
-        if (formatted !== content) {
-          await fs.writeFile(filePath, formatted, 'utf8');
+          return Result.ok(undefined);
+        } catch (error) {
           if (!silent) {
-            echo(`Formatted: ${filePath}`);
+            console.error(`Error formatting ${filePath}:`, error);
           }
+          return Result.err(error);
         }
-      } catch (error) {
-        console.error(`Error formatting ${filePath}:`, error);
-        throw error;
-      }
-    }),
-  );
+      }),
+    );
+
+  if (results.every((r) => r.status === 'fulfilled')) {
+    const fulfilled = results.map((r) => r.value);
+    if (fulfilled.every(Result.isOk)) {
+      return Result.ok(undefined);
+    } else {
+      const errors: readonly unknown[] = fulfilled
+        .filter(Result.isErr)
+        .map((r) => r.value);
+
+      return Result.err(errors);
+    }
+  } else {
+    const errors: readonly unknown[] = results
+      .filter((r) => r.status === 'rejected')
+      .map((r) => r.reason as unknown);
 
-  // Check if any formatting failed
-  const hasErrors = results.some((result) => result.status === 'rejected');
-  return hasErrors ? 'err' : 'ok';
+    return Result.err(errors);
+  }
 };
 
 /**
  * Format files matching the given glob pattern using Prettier
  *
  * @param pathGlob - Glob pattern to match files
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatFiles = async (
+export const formatFilesGlob = async (
   pathGlob: string,
   options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
+): Promise<Result<undefined, unknown>> => {
   const silent = options?.silent ?? false;
 
   try {
@@ -97,13 +137,15 @@ export const formatFiles = async (
       if (!silent) {
         echo('No files found matching pattern:', pathGlob);
       }
-      return 'ok';
+      return Result.ok(undefined);
     }
 
-    return await formatFilesList(files, { silent });
+    return await formatFiles(files, { silent });
   } catch (error) {
-    console.error('Error in formatFiles:', error);
-    return 'err';
+    if (!silent) {
+      console.error('Error in formatFiles:', error);
+    }
+    return Result.err(error);
   }
 };
 
@@ -111,63 +153,72 @@ export const formatFiles = async (
  * 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 (
-  options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
-  const silent = options?.silent ?? false;
-
-  try {
-    const untrackedFilesResult = await getUntrackedFiles({
-      silent,
-    });
+export const formatUncommittedFiles = async (
+  options?: Readonly<{
+    untracked?: boolean;
+    modified?: boolean;
+    staged?: boolean;
+    silent?: boolean;
+  }>,
+): Promise<
+  Result<
+    undefined,
+    ExecException | Readonly<{ message: string }> | readonly unknown[]
+  >
+> => {
+  const {
+    untracked = true,
+    modified = true,
+    staged = true,
+    silent = false,
+  } = options ?? {};
+
+  const mut_files: string[] = [];
+
+  if (untracked) {
+    const untrackedFilesResult = await getUntrackedFiles({ silent });
 
     if (Result.isErr(untrackedFilesResult)) {
-      console.error('Error getting changed files:', untrackedFilesResult.value);
-      return 'err';
+      if (!silent) {
+        console.error(
+          'Error getting changed files:',
+          untrackedFilesResult.value,
+        );
+      }
+      return untrackedFilesResult;
     }
 
-    const files = untrackedFilesResult.value;
+    mut_files.push(...untrackedFilesResult.value);
+  }
+
+  if (modified) {
+    const diffFilesResult = await getModifiedFiles({ silent });
 
-    if (files.length === 0) {
+    if (Result.isErr(diffFilesResult)) {
       if (!silent) {
-        echo('No changed files to format');
+        console.error('Error getting changed files:', diffFilesResult.value);
       }
-      return 'ok';
+      return diffFilesResult;
     }
 
-    if (!silent) {
-      echo('Formatting changed files:', files);
-    }
+    mut_files.push(...diffFilesResult.value);
+  }
 
-    // Filter out non-existent files before formatting
-    const fileExistenceChecks = await Promise.allSettled(
-      files.map(async (filePath) => {
-        try {
-          await fs.readFile(filePath, 'utf8');
-          return filePath;
-        } catch {
-          if (!silent) {
-            echo(`Skipping non-existent file: ${filePath}`);
-          }
-          return undefined;
-        }
-      }),
-    );
+  if (staged) {
+    const stagedFilesResult = await getStagedFiles({ silent });
 
-    const existingFiles = fileExistenceChecks
-      .filter(
-        (result): result is PromiseFulfilledResult<string> =>
-          result.status === 'fulfilled' && result.value !== undefined,
-      )
-      .map((result) => result.value);
+    if (Result.isErr(stagedFilesResult)) {
+      if (!silent) {
+        console.error('Error getting changed files:', stagedFilesResult.value);
+      }
+      return stagedFilesResult;
+    }
 
-    return await formatFilesList(existingFiles, { silent });
-  } catch (error) {
-    console.error('Error in formatUntracked:', error);
-    return 'err';
+    mut_files.push(...stagedFilesResult.value);
   }
+
+  return formatFiles(Arr.uniq(mut_files), { silent });
 };
 
 /**
@@ -178,71 +229,103 @@ export const formatUntracked = async (
  * @param options - Options for formatting
  * @param options.includeUntracked - Include untracked files in addition to diff
  *   files (default is true)
+ * @param options.includeStaged - Include staged 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; 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, {
-      silent,
-    });
-
-    if (Result.isErr(diffFromBaseResult)) {
+  options?: Readonly<{
+    includeUntracked?: boolean;
+    includeModified?: boolean;
+    includeStaged?: boolean;
+    silent?: boolean;
+  }>,
+): Promise<
+  Result<
+    undefined,
+    | ExecException
+    | Readonly<{
+        message: string;
+      }>
+    | readonly unknown[]
+  >
+> => {
+  // const silent = options?.silent ?? false;
+  const {
+    silent = false,
+    includeUntracked = true,
+    includeModified = true,
+    includeStaged = true,
+  } = options ?? {};
+
+  // Get files that differ from base branch/commit (excluding deleted files)
+  const diffFromBaseResult = await getDiffFrom(base, {
+    silent,
+  });
+
+  if (Result.isErr(diffFromBaseResult)) {
+    if (!silent) {
       console.error('Error getting changed files:', diffFromBaseResult.value);
-      return 'err';
     }
+    return diffFromBaseResult;
+  }
 
-    const diffFiles = diffFromBaseResult.value;
-    let mut_allFiles = diffFiles;
-
-    // If includeUntracked is true, also get untracked files
-    if (options?.includeUntracked ?? true) {
-      const untrackedFilesResult = await getUntrackedFiles({
-        silent,
-      });
-
-      if (Result.isErr(untrackedFilesResult)) {
-        console.error(
-          'Error getting untracked files:',
-          untrackedFilesResult.value,
-        );
-        return 'err';
+  const diffFiles = diffFromBaseResult.value;
+  const mut_allFiles: string[] = diffFiles.slice();
+
+  // If includeUntracked is true, also get untracked files
+  for (const { type, flag, fn } of [
+    { type: 'untracked', flag: includeUntracked, fn: getUntrackedFiles },
+    { type: 'modified', flag: includeModified, fn: getModifiedFiles },
+    { type: 'staged', flag: includeStaged, fn: getStagedFiles },
+  ]) {
+    if (flag) {
+      // eslint-disable-next-line no-await-in-loop
+      const filesResult = await fn({ silent });
+
+      if (Result.isErr(filesResult)) {
+        if (!silent) {
+          console.error(`Error getting ${type} files:`, filesResult.value);
+        }
+        return filesResult;
       }
 
-      const untrackedFiles = untrackedFilesResult.value;
+      const files = filesResult.value;
 
       // Combine and deduplicate files
-      mut_allFiles = Arr.uniq([...diffFiles, ...untrackedFiles]);
-
-      if (!silent) {
-        echo(
-          `Formatting files that differ from ${base} and untracked files:`,
-          mut_allFiles,
-        );
-      }
-    } else {
-      if (!silent) {
-        echo(`Formatting files that differ from ${base}:`, mut_allFiles);
-      }
+      mut_allFiles.push(...files);
     }
+  }
 
-    if (mut_allFiles.length === 0) {
-      if (!silent) {
-        echo(`No files to format`);
-      }
-      return 'ok';
-    }
+  const allFiles = Arr.uniq(mut_allFiles);
 
-    return await formatFilesList(mut_allFiles, { silent });
-  } catch (error) {
-    console.error('Error in formatDiffFrom:', error);
-    return 'err';
+  if (!silent) {
+    const includedFileTypes = [
+      includeUntracked ? 'untracked files' : undefined,
+      includeModified ? 'modified files' : undefined,
+      includeStaged ? 'staged files' : undefined,
+    ].filter(isNotUndefined);
+
+    const message = [
+      `Formatting files that differ from ${base}`,
+      includedFileTypes
+        .map((s, i) =>
+          i !== includedFileTypes.length - 1 ? `, ${s}` : ` and ${s}`,
+        )
+        .join(''),
+    ].join('');
+
+    echo(`${message}:`, allFiles);
   }
+
+  if (allFiles.length === 0) {
+    if (!silent) {
+      echo('No files to format');
+    }
+    return Result.ok(undefined);
+  }
+
+  return formatFiles(allFiles, { silent });
 };