ts-repo-utils 2.1.0 → 2.2.0

package/src/functions/diff.mts

@@ -5,7 +5,12 @@ import '../node-global.mjs';
 /**
  * Get files that have been changed (git status).
  */
-export const getUntrackedFiles = async (): Promise<
+export const getUntrackedFiles = async (
+  options?: Readonly<{
+    /** @default true */
+    excludeDeleted?: boolean;
+  }>,
+): Promise<
   Result<readonly string[], ExecException | Readonly<{ message: string }>>
 > => {
   // Get changed files from git status
@@ -29,7 +34,10 @@ export const getUntrackedFiles = async (): Promise<
     .filter(
       (file): file is string =>
         // Filter out deleted files (status starts with 'D')
-        file !== undefined && !stdout.includes(`D  ${file}`),
+        file !== undefined &&
+        ((options?.excludeDeleted ?? true)
+          ? !stdout.includes(`D  ${file}`)
+          : true),
     );
 
   return Result.ok(files);
@@ -40,11 +48,17 @@ export const getUntrackedFiles = async (): Promise<
  */
 export const getDiffFrom = async (
   base: string,
+  options?: Readonly<{
+    /** @default true */
+    excludeDeleted?: 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} --diff-filter=d`);
+  const result = await $(
+    `git diff --name-only ${base} ${(options?.excludeDeleted ?? true) ? '--diff-filter=d' : ''}`,
+  );
 
   if (Result.isErr(result)) {
     return result;

package/src/functions/format.mts

@@ -5,6 +5,64 @@ import { Result } from 'ts-data-forge';
 import '../node-global.mjs';
 import { getDiffFrom, 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 (
+  files: readonly string[],
+): Promise<'ok' | 'err'> => {
+  if (files.length === 0) {
+    echo('No files to format');
+    return 'ok';
+  }
+
+  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');
+
+        // Resolve prettier config for this file
+        const options = await prettier.resolveConfig(filePath);
+
+        // Check if file is ignored by prettier
+        const fileInfo = await prettier.getFileInfo(filePath, {
+          ignorePath: '.prettierignore',
+        });
+
+        if (fileInfo.ignored) {
+          echo(`Skipping ignored file: ${filePath}`);
+          return;
+        }
+
+        // Format the content
+        const formatted = await prettier.format(content, {
+          ...options,
+          filepath: filePath,
+        });
+
+        // Only write if content changed
+        if (formatted !== content) {
+          await writeFile(filePath, formatted, 'utf8');
+          echo(`Formatted: ${filePath}`);
+        }
+      } catch (error) {
+        console.error(`Error formatting ${filePath}:`, error);
+        throw error;
+      }
+    }),
+  );
+
+  // Check if any formatting failed
+  const hasErrors = results.some((result) => result.status === 'rejected');
+  return hasErrors ? 'err' : 'ok';
+};
+
 /**
  * Format files matching the given glob pattern using Prettier
  * @param pathGlob - Glob pattern to match files
@@ -24,49 +82,7 @@ export const formatFiles = async (pathGlob: string): Promise<'ok' | 'err'> => {
       return 'ok';
     }
 
-    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');
-
-          // Resolve prettier config for this file
-          const options = await prettier.resolveConfig(filePath);
-
-          // Check if file is ignored by prettier
-          const fileInfo = await prettier.getFileInfo(filePath, {
-            ignorePath: '.prettierignore',
-          });
-
-          if (fileInfo.ignored) {
-            echo(`Skipping ignored file: ${filePath}`);
-            return;
-          }
-
-          // Format the content
-          const formatted = await prettier.format(content, {
-            ...options,
-            filepath: filePath,
-          });
-
-          // Only write if content changed
-          if (formatted !== content) {
-            await writeFile(filePath, formatted, 'utf8');
-            echo(`Formatted: ${filePath}`);
-          }
-        } catch (error) {
-          console.error(`Error formatting ${filePath}:`, error);
-          throw error;
-        }
-      }),
-    );
-
-    // Check if any formatting failed
-    const hasErrors = results.some((result) => result.status === 'rejected');
-    return hasErrors ? 'err' : 'ok';
+    return await formatFilesList(files);
   } catch (error) {
     console.error('Error in formatFiles:', error);
     return 'err';
@@ -95,53 +111,29 @@ export const formatUntracked = async (): Promise<'ok' | 'err'> => {
 
     echo('Formatting changed files:', files);
 
-    // Format each changed file
-    const results = await Promise.allSettled(
+    // Filter out non-existent files before formatting
+    const fileExistenceChecks = await Promise.allSettled(
       files.map(async (filePath) => {
         try {
-          // Check if file exists and is not deleted
-          const content = await readFile(filePath, 'utf8').catch(() => null);
-          if (content === null) {
-            echo(`Skipping non-existent file: ${filePath}`);
-            return;
-          }
-
-          // Resolve prettier config for this file
-          const options = await prettier.resolveConfig(filePath);
-
-          // Check if file is ignored by prettier
-          const fileInfo = await prettier.getFileInfo(filePath, {
-            ignorePath: '.prettierignore',
-          });
-
-          if (fileInfo.ignored) {
-            echo(`Skipping ignored file: ${filePath}`);
-            return;
-          }
-
-          // Format the content
-          const formatted = await prettier.format(content, {
-            ...options,
-            filepath: filePath,
-          });
-
-          // Only write if content changed
-          if (formatted !== content) {
-            await writeFile(filePath, formatted, 'utf8');
-            echo(`Formatted: ${filePath}`);
-          }
-        } catch (error) {
-          console.error(`Error formatting ${filePath}:`, error);
-          throw error;
+          await readFile(filePath, 'utf8');
+          return filePath;
+        } catch {
+          echo(`Skipping non-existent file: ${filePath}`);
+          return undefined;
         }
       }),
     );
 
-    // Check if any formatting failed
-    const hasErrors = results.some((result) => result.status === 'rejected');
-    return hasErrors ? 'err' : 'ok';
+    const existingFiles = fileExistenceChecks
+      .filter(
+        (result): result is PromiseFulfilledResult<string> =>
+          result.status === 'fulfilled' && result.value !== undefined,
+      )
+      .map((result) => result.value);
+
+    return await formatFilesList(existingFiles);
   } catch (error) {
-    console.error('Error in formatChanged:', error);
+    console.error('Error in formatUntracked:', error);
     return 'err';
   }
 };
@@ -149,9 +141,14 @@ export const formatUntracked = async (): Promise<'ok' | 'err'> => {
 /**
  * Format only files that differ from the specified base branch or commit
  * @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)
  * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatDiffFrom = async (base: string): Promise<'ok' | 'err'> => {
+export const formatDiffFrom = async (
+  base: string,
+  options?: Readonly<{ includeUntracked?: boolean }>,
+): Promise<'ok' | 'err'> => {
   try {
     // Get files that differ from base branch/commit (excluding deleted files)
     const diffFromBaseResult = await getDiffFrom(base);
@@ -161,56 +158,41 @@ export const formatDiffFrom = async (base: string): Promise<'ok' | 'err'> => {
       return 'err';
     }
 
-    const files = diffFromBaseResult.value;
+    const diffFiles = diffFromBaseResult.value;
+    let allFiles = diffFiles;
+
+    // If includeUntracked is true, also get untracked files
+    if (options?.includeUntracked ?? true) {
+      const untrackedFilesResult = await getUntrackedFiles();
+
+      if (Result.isErr(untrackedFilesResult)) {
+        console.error(
+          'Error getting untracked files:',
+          untrackedFilesResult.value,
+        );
+        return 'err';
+      }
+
+      const untrackedFiles = untrackedFilesResult.value;
+
+      // Combine and deduplicate files
+      const uniqueFiles = new Set([...diffFiles, ...untrackedFiles]);
+      allFiles = Array.from(uniqueFiles);
+
+      echo(
+        `Formatting files that differ from ${base} and untracked files:`,
+        allFiles,
+      );
+    } else {
+      echo(`Formatting files that differ from ${base}:`, allFiles);
+    }
 
-    if (files.length === 0) {
-      echo(`No files differ from ${base}`);
+    if (allFiles.length === 0) {
+      echo(`No files to format`);
       return 'ok';
     }
 
-    echo(`Formatting files that differ from ${base}:`, files);
-
-    // Format each file
-    const results = await Promise.allSettled(
-      files.map(async (filePath) => {
-        try {
-          // Read file content
-          const content = await readFile(filePath, 'utf8');
-
-          // Resolve prettier config for this file
-          const options = await prettier.resolveConfig(filePath);
-
-          // Check if file is ignored by prettier
-          const fileInfo = await prettier.getFileInfo(filePath, {
-            ignorePath: '.prettierignore',
-          });
-
-          if (fileInfo.ignored) {
-            echo(`Skipping ignored file: ${filePath}`);
-            return;
-          }
-
-          // Format the content
-          const formatted = await prettier.format(content, {
-            ...options,
-            filepath: filePath,
-          });
-
-          // Only write if content changed
-          if (formatted !== content) {
-            await writeFile(filePath, formatted, 'utf8');
-            echo(`Formatted: ${filePath}`);
-          }
-        } catch (error) {
-          console.error(`Error formatting ${filePath}:`, error);
-          throw error;
-        }
-      }),
-    );
-
-    // Check if any formatting failed
-    const hasErrors = results.some((result) => result.status === 'rejected');
-    return hasErrors ? 'err' : 'ok';
+    return await formatFilesList(allFiles);
   } catch (error) {
     console.error('Error in formatDiffFrom:', error);
     return 'err';

package/src/functions/format.test.mts

@@ -1,30 +1,35 @@
 import dedent from 'dedent';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { formatFiles } from './format.mjs';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Result } from 'ts-data-forge';
+import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
+import { formatDiffFrom, formatFiles, formatFilesList } from './format.mjs';
+
+vi.mock('./diff.mjs', () => ({
+  getDiffFrom: vi.fn(),
+  getUntrackedFiles: vi.fn(),
+}));
 
 describe('formatFiles', () => {
-  const testDir = join(process.cwd(), 'test-format-files');
+  const testDir = path.join(process.cwd(), 'test-format-files');
 
   // Helper to create a test file with unformatted content
   const createTestFile = async (
     filename: string,
     content: string,
   ): Promise<string> => {
-    const filePath = join(testDir, filename);
-    await writeFile(filePath, content, 'utf8');
+    const filePath = path.join(testDir, filename);
+    await fs.writeFile(filePath, content, 'utf8');
     return filePath;
   };
 
   // Helper to read file content
-  const readTestFile = async (filePath: string): Promise<string> => {
-    const { readFile } = await import('node:fs/promises');
-    return readFile(filePath, 'utf8');
-  };
+  const readTestFile = async (filePath: string): Promise<string> =>
+    fs.readFile(filePath, 'utf8');
 
   test('should format files matching glob pattern', async () => {
     // Setup test directory
-    await mkdir(testDir, { recursive: true });
+    await fs.mkdir(testDir, { recursive: true });
 
     try {
       // Create test files with unformatted code
@@ -71,11 +76,11 @@ describe('formatFiles', () => {
       );
 
       // Check that non-matching file was not touched
-      const mdContent = await readTestFile(join(testDir, 'test.md'));
+      const mdContent = await readTestFile(path.join(testDir, 'test.md'));
       expect(mdContent).toBe('# Test\n\nSome    spaces');
     } finally {
       // Cleanup
-      await rm(testDir, { recursive: true, force: true });
+      await fs.rm(testDir, { recursive: true, force: true });
     }
   });
 
@@ -86,12 +91,12 @@ describe('formatFiles', () => {
 
   test('should handle nested directories with glob pattern', async () => {
     // Setup test directory with nested structure
-    await mkdir(join(testDir, 'src', 'utils'), { recursive: true });
+    await fs.mkdir(path.join(testDir, 'src', 'utils'), { recursive: true });
 
     try {
       // Create nested test file
       const nestedFile = await createTestFile(
-        join('src', 'utils', 'helper.ts'),
+        path.join('src', 'utils', 'helper.ts'),
         dedent`
           export const helper=(x:number)=>{return x*2}
         `,
@@ -112,7 +117,211 @@ describe('formatFiles', () => {
       );
     } finally {
       // Cleanup
-      await rm(testDir, { recursive: true, force: true });
+      await fs.rm(testDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('formatFilesList', () => {
+  const testDir = path.join(process.cwd(), 'test-format-files-list');
+
+  // Helper to create a test file with unformatted content
+  const createTestFile = async (
+    filename: string,
+    content: string,
+  ): Promise<string> => {
+    const filePath = path.join(testDir, filename);
+    await fs.writeFile(filePath, content, 'utf8');
+    return filePath;
+  };
+
+  // Helper to read file content
+  const readTestFile = async (filePath: string): Promise<string> =>
+    fs.readFile(filePath, 'utf8');
+
+  test('should format a list of files', async () => {
+    await fs.mkdir(testDir, { recursive: true });
+
+    try {
+      // Create test files
+      const file1 = await createTestFile(
+        'file1.ts',
+        dedent`
+          const x={a:1,b:2}
+        `,
+      );
+
+      const file2 = await createTestFile(
+        'file2.ts',
+        dedent`
+          function test(){return"hello"}
+        `,
+      );
+
+      // Format the files
+      const result = await formatFilesList([file1, file2]);
+      expect(result).toBe('ok');
+
+      // Check formatted content
+      const content1 = await readTestFile(file1);
+      expect(content1).toBe(
+        `${dedent`
+          const x = { a: 1, b: 2 };
+        `}\n`,
+      );
+
+      const content2 = await readTestFile(file2);
+      expect(content2).toBe(
+        `${dedent`
+          function test() {
+            return 'hello';
+          }
+        `}\n`,
+      );
+    } finally {
+      await fs.rm(testDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should return ok for empty file list', async () => {
+    const result = await formatFilesList([]);
+    expect(result).toBe('ok');
+  });
+});
+
+describe('formatDiffFrom', () => {
+  const testDir = path.join(process.cwd(), 'test-format-diff');
+
+  const createTestFile = async (
+    filename: string,
+    content: string,
+  ): Promise<string> => {
+    const filePath = path.join(testDir, filename);
+    await fs.writeFile(filePath, content, 'utf8');
+    return filePath;
+  };
+
+  const readTestFile = async (filePath: string): Promise<string> =>
+    fs.readFile(filePath, 'utf8');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('should format files from diff', async () => {
+    await fs.mkdir(testDir, { recursive: true });
+
+    try {
+      const file1 = await createTestFile(
+        'diff1.ts',
+        dedent`
+          const a=1;const b=2
+        `,
+      );
+
+      // Mock getDiffFrom to return our test file
+      vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([file1]));
+
+      vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([]));
+
+      const result = await formatDiffFrom('main');
+      expect(result).toBe('ok');
+
+      // Check file was formatted
+      const content = await readTestFile(file1);
+      expect(content).toBe(
+        `${dedent`
+          const a = 1;
+          const b = 2;
+        `}\n`,
+      );
+
+      expect(getDiffFrom).toHaveBeenCalledWith('main');
+    } finally {
+      await fs.rm(testDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should include untracked files when option is set', async () => {
+    await fs.mkdir(testDir, { recursive: true });
+
+    try {
+      const diffFile = await createTestFile(
+        'diff.ts',
+        dedent`
+          const diff=true
+        `,
+      );
+
+      const untrackedFile = await createTestFile(
+        'untracked.ts',
+        dedent`
+          const untracked=true
+        `,
+      );
+
+      // Mock both functions
+      vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([diffFile]));
+      vi.mocked(getUntrackedFiles).mockResolvedValue(
+        Result.ok([untrackedFile]),
+      );
+
+      const result = await formatDiffFrom('main', { includeUntracked: true });
+      expect(result).toBe('ok');
+
+      // Check both files were formatted
+      const diffContent = await readTestFile(diffFile);
+      expect(diffContent).toBe(
+        `${dedent`
+          const diff = true;
+        `}\n`,
+      );
+
+      const untrackedContent = await readTestFile(untrackedFile);
+      expect(untrackedContent).toBe(
+        `${dedent`
+          const untracked = true;
+        `}\n`,
+      );
+
+      expect(getDiffFrom).toHaveBeenCalledWith('main');
+      expect(getUntrackedFiles).toHaveBeenCalled();
+    } finally {
+      await fs.rm(testDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should deduplicate files when including untracked', async () => {
+    await fs.mkdir(testDir, { recursive: true });
+
+    try {
+      const sharedFile = await createTestFile(
+        'shared.ts',
+        dedent`
+          const shared={value:1}
+        `,
+      );
+
+      // Mock both functions to return the same file
+      vi.mocked(getDiffFrom).mockResolvedValue(Result.ok([sharedFile]));
+      vi.mocked(getUntrackedFiles).mockResolvedValue(Result.ok([sharedFile]));
+
+      const result = await formatDiffFrom('main', { includeUntracked: true });
+      expect(result).toBe('ok');
+
+      // Verify both functions were called
+      expect(getDiffFrom).toHaveBeenCalledWith('main');
+      expect(getUntrackedFiles).toHaveBeenCalled();
+
+      // Check that the file was formatted (content should change)
+      const finalContent = await readTestFile(sharedFile);
+      expect(finalContent).toBe(
+        `${dedent`
+          const shared = { value: 1 };
+        `}\n`,
+      );
+    } finally {
+      await fs.rm(testDir, { recursive: true, force: true });
     }
   });
 });

package/src/functions/index.mts

@@ -5,3 +5,4 @@ export * from './diff.mjs';
 export * from './exec-async.mjs';
 export * from './format.mjs';
 export * from './gen-index.mjs';
+export * from './should-run.mjs';

package/src/functions/should-run.mts

@@ -0,0 +1,33 @@
+import { pipe, Result } from 'ts-data-forge';
+import '../node-global.mjs';
+import { getDiffFrom } from './diff.mjs';
+
+export const checkShouldRunTypeChecks = async (): Promise<void> => {
+  // paths-ignore:
+  //   - '.cspell.json'
+  //   - '**.md'
+  //   - '**.txt'
+  //   - 'docs/**'
+
+  const GITHUB_OUTPUT = process.env['GITHUB_OUTPUT'];
+
+  const files = await getDiffFrom('origin/main');
+
+  if (Result.isErr(files)) {
+    console.error('Error getting diff:', files.value);
+    process.exit(1);
+  }
+
+  const shouldRunTsChecks: boolean = !files.value.every(
+    (file) =>
+      file === '.cspell.json' ||
+      file.startsWith('docs/') ||
+      pipe(path.basename(file)).map(
+        (filename) => filename.endsWith('.md') || filename.endsWith('.txt'),
+      ).value,
+  );
+
+  if (GITHUB_OUTPUT !== undefined) {
+    await fs.appendFile(GITHUB_OUTPUT, `should_run=${shouldRunTsChecks}\n`);
+  }
+};