ts-repo-utils 6.0.0 → 6.0.1

package/README.md

@@ -25,19 +25,19 @@ Generates index.ts files recursively in target directories with automatic barrel
 
 ```bash
 # Basic usage with required options
-npx gen-index-ts ./src --target-ext .mts --index-ext .mts --export-ext .mjs
+npm exec -- gen-index-ts ./src --target-ext .mts --index-ext .mts --export-ext .mjs
 
 # With formatting command
-npx gen-index-ts ./src --target-ext .mts --index-ext .mts --export-ext .mjs --fmt 'npm run fmt'
+npm exec -- gen-index-ts ./src --target-ext .mts --index-ext .mts --export-ext .mjs --fmt 'npm run fmt'
 
 # Multiple target extensions
-npx gen-index-ts ./src --target-ext .mts --target-ext .tsx --index-ext .mts --export-ext .mjs
+npm exec -- gen-index-ts ./src --target-ext .mts --target-ext .tsx --index-ext .mts --export-ext .mjs
 
 # With exclude patterns
-npx gen-index-ts ./src --target-ext .ts --index-ext .ts --export-ext .js --exclude '*.test.ts' --exclude '*.spec.ts'
+npm exec -- gen-index-ts ./src --target-ext .ts --index-ext .ts --export-ext .js --exclude '*.test.ts' --exclude '*.spec.ts'
 
 # Example in npm scripts
-"gi": "gen-index-ts ./src/functions --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'"
+"gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'"
 ```
 
 **Options:**
@@ -56,16 +56,16 @@ Checks if repository is clean and exits with code 1 if it has uncommitted change
 
 ```bash
 # Basic usage
-npx assert-repo-is-clean
+npm exec -- assert-repo-is-clean
 
 # Silent mode
-npx assert-repo-is-clean --silent
+npm exec -- assert-repo-is-clean --silent
 ```
 
 ```yaml
 # Example in GitHub Actions
 - name: Check if there is no file diff
-  run: npx tsx ./src/cmd/assert-repo-is-clean.mts
+  run: npm exec -- assert-repo-is-clean
 ```
 
 **Options:**
@@ -78,10 +78,10 @@ Formats only untracked/modified files using Prettier.
 
 ```bash
 # Basic usage
-npx format-untracked
+npm exec -- format-untracked
 
 # Silent mode
-npx format-untracked --silent
+npm exec -- format-untracked --silent
 ```
 
 **Options:**
@@ -94,16 +94,16 @@ Formats only files that differ from the specified base branch or commit.
 
 ```bash
 # Format files different from main branch
-npx format-diff-from main
+npm exec -- format-diff-from main
 
 # Format files different from origin/main
-npx format-diff-from origin/main
+npm exec -- format-diff-from origin/main
 
 # Exclude untracked files
-npx format-diff-from main --exclude-untracked
+npm exec -- format-diff-from main --exclude-untracked
 
 # Silent mode
-npx format-diff-from main --silent
+npm exec -- format-diff-from main --silent
 
 # Example in npm scripts
 "fmt": "format-diff-from origin/main"
@@ -116,6 +116,49 @@ npx format-diff-from main --silent
 - `--exclude-untracked` - Exclude untracked files, only format diff files (optional)
 - `--silent` - Suppress output messages (optional)
 
+### `check-should-run-type-checks`
+
+Checks if TypeScript type checks should run based on the diff from a base branch. Optimizes CI/CD pipelines by skipping type checks when only non-TypeScript files are changed.
+
+```bash
+# Basic usage (compares against origin/main)
+npm exec -- check-should-run-type-checks
+
+# Custom base branch
+npm exec -- check-should-run-type-checks --base-branch origin/develop
+
+# Custom ignore patterns
+npm exec -- check-should-run-type-checks \
+  --paths-ignore '.github/' \
+  --paths-ignore 'docs/' \
+  --paths-ignore '**.md' \
+  --paths-ignore '**.yml'
+```
+
+```yaml
+# Example in GitHub Actions
+- name: Check if type checks should run
+  id: check_diff
+  run: npm exec -- check-should-run-type-checks
+
+- name: Run type checks
+  if: steps.check_diff.outputs.should_run == 'true'
+  run: npm run type-check
+```
+
+**Options:**
+
+- `--paths-ignore` - Patterns to ignore when checking if type checks should run (optional, can be specified multiple times)
+    - Supports exact file matches: `.cspell.json`
+    - Directory prefixes: `docs/` (matches any file in docs directory)
+    - File extensions: `**.md` (matches any markdown file)
+    - Default: `['LICENSE', '.editorconfig', '.gitignore', '.cspell.json', '.markdownlint-cli2.mjs', '.npmignore', '.prettierignore', '.prettierrc', 'docs/', '**.md', '**.txt']`
+- `--base-branch` - Base branch to compare against for determining changed files (default: `origin/main`)
+
+**GitHub Actions Integration:**
+
+When running in GitHub Actions, the command sets the `GITHUB_OUTPUT` environment variable with `should_run=true` or `should_run=false`, which can be used in subsequent steps.
+
 ### Usage in npm scripts
 
 The CLI commands are commonly used in npm scripts for automation:
@@ -124,7 +167,7 @@ The CLI commands are commonly used in npm scripts for automation:
 {
     "scripts": {
         "fmt": "format-diff-from origin/main",
-        "gi": "gen-index-ts ./src/functions --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'",
+        "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'",
         "check:clean": "assert-repo-is-clean"
     }
 }
@@ -139,13 +182,13 @@ These commands are particularly useful in CI/CD pipelines:
 - name: Format check
   run: |
       npm run fmt
-      npx assert-repo-is-clean
+      npm exec -- assert-repo-is-clean
 
 # Check for uncommitted changes after build
 - name: Build
   run: npm run build
 - name: Check if there is no file diff
-  run: npx tsx ./src/cmd/assert-repo-is-clean.mts
+  run: npm exec -- assert-repo-is-clean
 ```
 
 ## API Reference

package/dist/cmd/assert-repo-is-clean.mjs

@@ -1,32 +1,32 @@
 #!/usr/bin/env -S npx tsx
+import 'child_process';
 import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
-import { assertRepoIsClean } from '../functions/assert-repo-is-clean.mjs';
+import 'micromatch';
 import 'node:child_process';
 import 'prettier';
-import 'micromatch';
-import 'child_process';
+import 'ts-data-forge';
+import { assertRepoIsClean } from '../functions/assert-repo-is-clean.mjs';
+import '../node-global.mjs';
 
 const cmdDef = cmd.command({
-    name: 'assert-repo-is-clean-cli',
-    version: '6.0.0',
-    args: {
-        silent: cmd.flag({
-            long: 'silent',
-            type: cmd.optional(cmd.boolean),
-            description: 'If true, suppresses output messages (default: false)',
-        }),
-    },
-    handler: (args) => {
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
+  name: 'assert-repo-is-clean-cli',
+  version: '6.0.1',
+  args: {
+    silent: cmd.flag({
+      long: 'silent',
+      type: cmd.optional(cmd.boolean),
+      description: 'If true, suppresses output messages (default: false)',
+    }),
+  },
+  handler: (args) => {
+    main(args).catch((error) => {
+      console.error('An error occurred:', error);
+      process.exit(1);
+    });
+  },
 });
 const main = async (args) => {
-    await assertRepoIsClean({ silent: args.silent });
+  await assertRepoIsClean({ silent: args.silent });
 };
 await cmd.run(cmdDef, process.argv.slice(2));
 //# sourceMappingURL=assert-repo-is-clean.mjs.map

package/dist/cmd/check-should-run-type-checks.mjs

@@ -1,40 +1,42 @@
 #!/usr/bin/env -S npx tsx
+import 'child_process';
 import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
+import 'micromatch';
 import 'node:child_process';
 import 'prettier';
-import 'micromatch';
+import 'ts-data-forge';
 import { checkShouldRunTypeChecks } from '../functions/should-run.mjs';
-import 'child_process';
+import '../node-global.mjs';
 
 const cmdDef = cmd.command({
-    name: 'check-should-run-type-checks-cli',
-    version: '6.0.0',
-    args: {
-        pathsIgnore: cmd.multioption({
-            long: 'paths-ignore',
-            type: cmd.optional(cmd.array(cmd.string)),
-            description: 'Patterns to ignore when checking if type checks should run. Supports exact file matches, directory prefixes (ending with "/"), and file extensions (starting with "**.")',
-        }),
-        baseBranch: cmd.option({
-            long: 'base-branch',
-            type: cmd.optional(cmd.string),
-            description: 'Base branch to compare against for determining changed files. Defaults to "origin/main"',
-        }),
-    },
-    handler: (args) => {
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
+  name: 'check-should-run-type-checks-cli',
+  version: '6.0.1',
+  args: {
+    pathsIgnore: cmd.multioption({
+      long: 'paths-ignore',
+      type: cmd.optional(cmd.array(cmd.string)),
+      description:
+        'Patterns to ignore when checking if type checks should run. Supports exact file matches, directory prefixes (ending with "/"), and file extensions (starting with "**.")',
+    }),
+    baseBranch: cmd.option({
+      long: 'base-branch',
+      type: cmd.optional(cmd.string),
+      description:
+        'Base branch to compare against for determining changed files. Defaults to "origin/main"',
+    }),
+  },
+  handler: (args) => {
+    main(args).catch((error) => {
+      console.error('An error occurred:', error);
+      process.exit(1);
+    });
+  },
 });
 const main = async (args) => {
-    await checkShouldRunTypeChecks({
-        pathsIgnore: args.pathsIgnore,
-        baseBranch: args.baseBranch,
-    });
+  await checkShouldRunTypeChecks({
+    pathsIgnore: args.pathsIgnore,
+    baseBranch: args.baseBranch,
+  });
 };
 await cmd.run(cmdDef, process.argv.slice(2));
 //# sourceMappingURL=check-should-run-type-checks.mjs.map

package/dist/cmd/format-diff-from.mjs

@@ -1,44 +1,45 @@
 #!/usr/bin/env -S npx tsx
+import 'child_process';
 import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
+import 'micromatch';
 import 'node:child_process';
+import 'ts-data-forge';
 import { formatDiffFrom } from '../functions/format.mjs';
-import 'micromatch';
-import 'child_process';
+import '../node-global.mjs';
 
 const cmdDef = cmd.command({
-    name: 'format-diff-from-cli',
-    version: '6.0.0',
-    args: {
-        base: cmd.positional({
-            type: cmd.string,
-            displayName: 'base',
-            description: 'Base branch name or commit hash to compare against',
-        }),
-        includeUntracked: cmd.flag({
-            long: 'include-untracked',
-            type: cmd.optional(cmd.boolean),
-            description: 'Include untracked files in addition to diff files (default: true)',
-        }),
-        silent: cmd.flag({
-            long: 'silent',
-            type: cmd.optional(cmd.boolean),
-            description: 'If true, suppresses output messages (default: false)',
-        }),
-    },
-    handler: (args) => {
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
+  name: 'format-diff-from-cli',
+  version: '6.0.1',
+  args: {
+    base: cmd.positional({
+      type: cmd.string,
+      displayName: 'base',
+      description: 'Base branch name or commit hash to compare against',
+    }),
+    includeUntracked: cmd.flag({
+      long: 'include-untracked',
+      type: cmd.optional(cmd.boolean),
+      description:
+        'Include untracked files in addition to diff files (default: true)',
+    }),
+    silent: cmd.flag({
+      long: 'silent',
+      type: cmd.optional(cmd.boolean),
+      description: 'If true, suppresses output messages (default: false)',
+    }),
+  },
+  handler: (args) => {
+    main(args).catch((error) => {
+      console.error('An error occurred:', error);
+      process.exit(1);
+    });
+  },
 });
 const main = async (args) => {
-    const result = await formatDiffFrom(args.base, args);
-    if (result === 'err') {
-        process.exit(1);
-    }
+  const result = await formatDiffFrom(args.base, args);
+  if (result === 'err') {
+    process.exit(1);
+  }
 };
 await cmd.run(cmdDef, process.argv.slice(2));
 //# sourceMappingURL=format-diff-from.mjs.map

package/dist/cmd/format-untracked.mjs

@@ -1,34 +1,34 @@
 #!/usr/bin/env -S npx tsx
+import 'child_process';
 import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
+import 'micromatch';
 import 'node:child_process';
+import 'ts-data-forge';
 import { formatUntracked } from '../functions/format.mjs';
-import 'micromatch';
-import 'child_process';
+import '../node-global.mjs';
 
 const cmdDef = cmd.command({
-    name: 'format-untracked-cli',
-    version: '6.0.0',
-    args: {
-        silent: cmd.flag({
-            long: 'silent',
-            type: cmd.optional(cmd.boolean),
-            description: 'If true, suppresses output messages (default: false)',
-        }),
-    },
-    handler: (args) => {
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
+  name: 'format-untracked-cli',
+  version: '6.0.1',
+  args: {
+    silent: cmd.flag({
+      long: 'silent',
+      type: cmd.optional(cmd.boolean),
+      description: 'If true, suppresses output messages (default: false)',
+    }),
+  },
+  handler: (args) => {
+    main(args).catch((error) => {
+      console.error('An error occurred:', error);
+      process.exit(1);
+    });
+  },
 });
 const main = async (args) => {
-    const result = await formatUntracked({ silent: args.silent });
-    if (result === 'err') {
-        process.exit(1);
-    }
+  const result = await formatUntracked({ silent: args.silent });
+  if (result === 'err') {
+    process.exit(1);
+  }
 };
 await cmd.run(cmdDef, process.argv.slice(2));
 //# sourceMappingURL=format-untracked.mjs.map

package/dist/cmd/gen-index-ts.mjs

@@ -1,103 +1,119 @@
 #!/usr/bin/env -S npx tsx
+import 'child_process';
 import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
 import 'node:child_process';
 import 'prettier';
+import 'ts-data-forge';
 import { genIndex } from '../functions/gen-index.mjs';
-import 'child_process';
+import '../node-global.mjs';
 
 const extensionType = cmd.extendType(cmd.string, {
-    from: (s) => {
-        if (!s.startsWith('.')) {
-            throw new Error(`ext should start with '.'`);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        return Promise.resolve(s);
-    },
+  from: (s) => {
+    if (!s.startsWith('.')) {
+      throw new Error(`ext should start with '.'`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Promise.resolve(s);
+  },
 });
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const nonEmptyArray = (t, commandName) => cmd.extendType(cmd.array(t), {
+const nonEmptyArray = (t, commandName) =>
+  cmd.extendType(cmd.array(t), {
     from: (arr) => {
-        if (arr.length === 0) {
-            throw new Error(`No value provided for --${commandName}. At least one value is required.`);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        return Promise.resolve(arr);
+      if (arr.length === 0) {
+        throw new Error(
+          `No value provided for --${commandName}. At least one value is required.`,
+        );
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      return Promise.resolve(arr);
     },
-});
+  });
 const cmdDef = cmd.command({
-    name: 'gen-index-ts-cli',
-    version: '6.0.0',
-    args: {
-        // required args
-        targetDirectory: cmd.positional({
-            type: cmd.string,
-            displayName: 'target-directory',
-            description: 'Directory where the index file will be generated  (Comma-separated list can be used)',
-        }),
-        targetExtensions: cmd.multioption({
-            long: 'target-ext',
-            type: nonEmptyArray(extensionType, 'target-ext'),
-            description: 'File extensions to include in the index file',
+  name: 'gen-index-ts-cli',
+  version: '6.0.1',
+  args: {
+    // required args
+    targetDirectory: cmd.positional({
+      type: cmd.string,
+      displayName: 'target-directory',
+      description:
+        'Directory where the index file will be generated  (Comma-separated list can be used)',
+    }),
+    targetExtensions: cmd.multioption({
+      long: 'target-ext',
+      type: nonEmptyArray(extensionType, 'target-ext'),
+      description: 'File extensions to include in the index file',
+    }),
+    indexFileExtension: cmd.option({
+      long: 'index-ext',
+      type: extensionType,
+      description: 'Extension of the index file to be generated',
+    }),
+    exportStatementExtension: cmd.option({
+      long: 'export-ext',
+      type: cmd.union([
+        extensionType,
+        cmd.extendType(cmd.string, {
+          from: (s) => {
+            if (s !== 'none') {
+              throw new Error(
+                `export-ext should be 'none' or a valid extension`,
+              );
+            }
+            return Promise.resolve('none');
+          },
         }),
-        indexFileExtension: cmd.option({
-            long: 'index-ext',
-            type: extensionType,
-            description: 'Extension of the index file to be generated',
-        }),
-        exportStatementExtension: cmd.option({
-            long: 'export-ext',
-            type: cmd.union([
-                extensionType,
-                cmd.extendType(cmd.string, {
-                    from: (s) => {
-                        if (s !== 'none') {
-                            throw new Error(`export-ext should be 'none' or a valid extension`);
-                        }
-                        return Promise.resolve('none');
-                    },
-                }),
-            ]),
-            description: 'Extension of the export statements in the index file',
-        }),
-        // optional args
-        exclude: cmd.multioption({
-            long: 'exclude',
-            type: cmd.optional(cmd.array(cmd.string)),
-            description: 'Glob patterns of files to exclude from the index file (e.g., "*.d.mts", "*.test.mts")',
-        }),
-        formatCommand: cmd.option({
-            long: 'fmt',
-            type: cmd.optional(cmd.string),
-            description: 'Command to format after generating the index file (e.g., "npm run fmt")',
-        }),
-        silent: cmd.flag({
-            long: 'silent',
-            type: cmd.optional(cmd.boolean),
-            description: 'If true, suppresses output messages (default: false)',
-        }),
-    },
-    handler: (args) => {
-        console.log(args);
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
-});
-const main = async ({ targetDirectory, targetExtensions, exportStatementExtension, indexFileExtension, exclude, formatCommand, silent, }) => {
-    await genIndex({
-        targetDirectory: targetDirectory.includes(',')
-            ? targetDirectory.split(',').map((dir) => dir.trim())
-            : targetDirectory,
-        exportStatementExtension,
-        targetExtensions,
-        exclude,
-        indexFileExtension,
-        formatCommand,
-        silent,
+      ]),
+      description: 'Extension of the export statements in the index file',
+    }),
+    // optional args
+    exclude: cmd.multioption({
+      long: 'exclude',
+      type: cmd.optional(cmd.array(cmd.string)),
+      description:
+        'Glob patterns of files to exclude from the index file (e.g., "*.d.mts", "*.test.mts")',
+    }),
+    formatCommand: cmd.option({
+      long: 'fmt',
+      type: cmd.optional(cmd.string),
+      description:
+        'Command to format after generating the index file (e.g., "npm run fmt")',
+    }),
+    silent: cmd.flag({
+      long: 'silent',
+      type: cmd.optional(cmd.boolean),
+      description: 'If true, suppresses output messages (default: false)',
+    }),
+  },
+  handler: (args) => {
+    console.log(args);
+    main(args).catch((error) => {
+      console.error('An error occurred:', error);
+      process.exit(1);
     });
+  },
+});
+const main = async ({
+  targetDirectory,
+  targetExtensions,
+  exportStatementExtension,
+  indexFileExtension,
+  exclude,
+  formatCommand,
+  silent,
+}) => {
+  await genIndex({
+    targetDirectory: targetDirectory.includes(',')
+      ? targetDirectory.split(',').map((dir) => dir.trim())
+      : targetDirectory,
+    exportStatementExtension,
+    targetExtensions,
+    exclude,
+    indexFileExtension,
+    formatCommand,
+    silent,
+  });
 };
 await cmd.run(cmdDef, process.argv.slice(2));
 //# sourceMappingURL=gen-index-ts.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-repo-utils",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "private": false,
   "keywords": [
     "typescript"
@@ -16,13 +16,13 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/type.d.mts",
+        "types": "./dist/types.d.mts",
         "default": "./dist/index.mjs"
       }
     }
   },
   "module": "./dist/index.mjs",
-  "types": "./dist/type.d.mts",
+  "types": "./dist/types.d.mts",
   "bin": {
     "assert-repo-is-clean": "./src/cmd/assert-repo-is-clean.mts",
     "check-should-run-type-checks": "./src/cmd/check-should-run-type-checks.mts",
@@ -82,13 +82,13 @@
     "@semantic-release/github": "^11.0.3",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^24.1.0",
+    "@types/node": "^24.2.1",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "cspell": "^9.2.0",
     "dedent": "^1.6.0",
-    "eslint": "^9.32.0",
+    "eslint": "^9.33.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-array-func": "5.0.2",
     "eslint-plugin-functional": "9.0.2",
@@ -107,10 +107,10 @@
     "semantic-release": "^24.2.7",
     "ts-type-forge": "^2.1.1",
     "tslib": "^2.8.1",
-    "typedoc": "^0.28.7",
+    "typedoc": "^0.28.9",
     "typedoc-plugin-markdown": "^4.8.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.38.0",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.0",
     "vitest": "^3.2.4"
   },
   "engines": {

package/src/cmd/assert-repo-is-clean.mts

@@ -5,7 +5,7 @@ import { assertRepoIsClean } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'assert-repo-is-clean-cli',
-  version: '6.0.0',
+  version: '6.0.1',
   args: {
     silent: cmd.flag({
       long: 'silent',

package/src/cmd/check-should-run-type-checks.mts

@@ -5,7 +5,7 @@ import { checkShouldRunTypeChecks } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'check-should-run-type-checks-cli',
-  version: '6.0.0',
+  version: '6.0.1',
   args: {
     pathsIgnore: cmd.multioption({
       long: 'paths-ignore',

package/src/cmd/format-diff-from.mts

@@ -5,7 +5,7 @@ import { formatDiffFrom } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'format-diff-from-cli',
-  version: '6.0.0',
+  version: '6.0.1',
   args: {
     base: cmd.positional({
       type: cmd.string,

package/src/cmd/format-untracked.mts

@@ -5,7 +5,7 @@ import { formatUntracked } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'format-untracked-cli',
-  version: '6.0.0',
+  version: '6.0.1',
   args: {
     silent: cmd.flag({
       long: 'silent',

package/src/cmd/gen-index-ts.mts

@@ -38,7 +38,7 @@ const nonEmptyArray = <T extends cmd.Type<any, any>>(
 
 const cmdDef = cmd.command({
   name: 'gen-index-ts-cli',
-  version: '6.0.0',
+  version: '6.0.1',
   args: {
     // required args
     targetDirectory: cmd.positional({