watskeburt 1.0.1 → 2.0.1

package/README.md

@@ -7,8 +7,6 @@ Get changed files & their statuses since any git _revision_
 A micro-lib to retrieve an array of file names that were changed since a
 revision. Also sports a cli for use outside of JavaScript c.s.
 
-- :warning: Interface is stable, but can can change until 1.0.0 is published :warning:
-
 ## why?
 
 I needed something simple and robust to support some upcoming features in
@@ -103,6 +101,8 @@ Options:
 
 ## 🇳🇱 what does 'watskeburt' mean?
 
+Wazzup.
+
 _watskeburt_ is a fast pronunciation of the Dutch "wat is er gebeurd?"
 (_what has happened?_) or "wat er is gebeurd" (_what has happened_). It's
 also the title of a song by the Dutch band "De Jeugd van Tegenwoordig"

package/dist/cli.js

@@ -1,3 +1,73 @@
-#!/usr/bin/env node
-import { cli } from "./execute-cli.js";
-await cli();
+import { EOL } from "node:os";
+import { parseArgs } from "node:util";
+import { list } from "./main.js";
+import { VERSION } from "./version.js";
+const HELP_MESSAGE = `Usage: watskeburt [options] [old-revision] [new-revision]
+
+lists files & their statuses since [old-revision] or between [old-revision] and [new-revision].
+
+-> When you don't pass a revision at all old-revision defaults to the current one.
+
+Options:
+  -T, --outputType <type>  what format to emit (choices: "json", "regex", default: "regex")
+  --trackedOnly            only take tracked files into account (default: false)
+  -V, --version            output the version number
+  -h, --help               display help for command${EOL}`;
+export async function cli(
+  pArguments = process.argv.slice(2),
+  pOutStream = process.stdout,
+  pErrorStream = process.stderr,
+  pErrorExitCode = 1,
+) {
+  try {
+    const lArguments = getArguments(pArguments);
+    if (lArguments.values.help) {
+      pOutStream.write(HELP_MESSAGE);
+      return;
+    }
+    if (lArguments.values.version) {
+      pOutStream.write(`${VERSION}${EOL}`);
+      return;
+    }
+    if (!outputTypeIsValid(lArguments.values.outputType)) {
+      pErrorStream.write(
+        `error: option '-T, --outputType <type>' argument '${lArguments.values.outputType}' is invalid. Allowed choices are json, regex.${EOL}`,
+      );
+      process.exitCode = pErrorExitCode;
+      return;
+    }
+    const lResult = await list(
+      lArguments.positionals[0],
+      lArguments.positionals[1],
+      lArguments.values,
+    );
+    pOutStream.write(`${lResult}${EOL}`);
+  } catch (pError) {
+    pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
+    process.exitCode = pErrorExitCode;
+  }
+}
+function getArguments(pArguments) {
+  return parseArgs({
+    args: pArguments,
+    options: {
+      outputType: {
+        type: "string",
+        short: "T",
+        default: "regex",
+      },
+      trackedOnly: {
+        type: "boolean",
+        default: false,
+      },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "V", default: false },
+    },
+    strict: true,
+    allowPositionals: true,
+    tokens: false,
+  });
+}
+function outputTypeIsValid(pOutputType) {
+  return ["json", "regex"].includes(pOutputType);
+}

package/dist/formatters/format.js

@@ -2,9 +2,11 @@ import formatToRegex from "./regex.js";
 import formatToJSON from "./json.js";
 const identity = (pX) => pX;
 const OUTPUT_TYPE_TO_FUNCTION = new Map([
-    ["regex", formatToRegex],
-    ["json", formatToJSON],
+  ["regex", formatToRegex],
+  ["json", formatToJSON],
 ]);
 export default function format(pChanges, pOutputType) {
-    return (OUTPUT_TYPE_TO_FUNCTION.get(pOutputType ?? "unknown") || identity)(pChanges);
+  return (OUTPUT_TYPE_TO_FUNCTION.get(pOutputType ?? "unknown") || identity)(
+    pChanges,
+  );
 }

package/dist/formatters/json.js

@@ -1,4 +1,4 @@
 const INDENT = 2;
 export default function formatToJSON(pChanges) {
-    return JSON.stringify(pChanges, null, INDENT);
+  return JSON.stringify(pChanges, null, INDENT);
 }

package/dist/formatters/regex.js

@@ -1,36 +1,40 @@
 import { extname } from "node:path";
 const DEFAULT_EXTENSIONS = new Set([
-    ".cjs",
-    ".cjsx",
-    ".coffee",
-    ".csx",
-    ".cts",
-    ".js",
-    ".json",
-    ".jsx",
-    ".litcoffee",
-    ".ls",
-    ".mjs",
-    ".mts",
-    ".svelte",
-    ".ts",
-    ".tsx",
-    ".vue",
-    ".vuex",
+  ".cjs",
+  ".cjsx",
+  ".coffee",
+  ".csx",
+  ".cts",
+  ".js",
+  ".json",
+  ".jsx",
+  ".litcoffee",
+  ".ls",
+  ".mjs",
+  ".mts",
+  ".svelte",
+  ".ts",
+  ".tsx",
+  ".vue",
+  ".vuex",
 ]);
 const DEFAULT_CHANGE_TYPES = new Set([
-    "modified",
-    "added",
-    "renamed",
-    "copied",
-    "untracked",
+  "modified",
+  "added",
+  "renamed",
+  "copied",
+  "untracked",
 ]);
-export default function formatToRegex(pChanges, pExtensions = DEFAULT_EXTENSIONS, pChangeTypes = DEFAULT_CHANGE_TYPES) {
-    const lChanges = pChanges
-        .filter((pChange) => pChangeTypes.has(pChange.changeType))
-        .map(({ name }) => name)
-        .filter((pName) => pExtensions.has(extname(pName)))
-        .map((pName) => pName.replace(/\\/g, "\\\\").replace(/\./g, "\\."))
-        .join("|");
-    return `^(${lChanges})$`;
+export default function formatToRegex(
+  pChanges,
+  pExtensions = DEFAULT_EXTENSIONS,
+  pChangeTypes = DEFAULT_CHANGE_TYPES,
+) {
+  const lChanges = pChanges
+    .filter((pChange) => pChangeTypes.has(pChange.changeType))
+    .map(({ name }) => name)
+    .filter((pName) => pExtensions.has(extname(pName)))
+    .map((pName) => pName.replace(/\\/g, "\\\\").replace(/\./g, "\\."))
+    .join("|");
+  return `^(${lChanges})$`;
 }

package/dist/git-primitives.js

@@ -1,67 +1,88 @@
 import { spawn } from "node:child_process";
 export async function getStatusShort(pSpawnFunction = spawn) {
-    const lErrorMap = new Map([
-        [129, `'${process.cwd()}' does not seem to be a git repository`],
-    ]);
-    const lResult = await getGitResult(["status", "--porcelain"], lErrorMap, pSpawnFunction);
-    return lResult;
+  const lErrorMap = new Map([
+    [129, `'${process.cwd()}' does not seem to be a git repository`],
+  ]);
+  const lResult = await getGitResult(
+    ["status", "--porcelain"],
+    lErrorMap,
+    pSpawnFunction,
+  );
+  return lResult;
 }
-export async function getDiffLines(pOldRevision, pNewRevision, pSpawnFunction = spawn) {
-    const lErrorMap = new Map([
-        [
-            128,
-            `revision '${pOldRevision}' ${pNewRevision ? `(or '${pNewRevision}') ` : ""}unknown`,
-        ],
-        [129, `'${process.cwd()}' does not seem to be a git repository`],
-    ]);
-    const lResult = await getGitResult(pNewRevision
-        ? ["diff", pOldRevision, pNewRevision, "--name-status"]
-        : ["diff", pOldRevision, "--name-status"], lErrorMap, pSpawnFunction);
-    return lResult;
+export async function getDiffLines(
+  pOldRevision,
+  pNewRevision,
+  pSpawnFunction = spawn,
+) {
+  const lErrorMap = new Map([
+    [
+      128,
+      `revision '${pOldRevision}' ${
+        pNewRevision ? `(or '${pNewRevision}') ` : ""
+      }unknown`,
+    ],
+    [129, `'${process.cwd()}' does not seem to be a git repository`],
+  ]);
+  const lResult = await getGitResult(
+    pNewRevision
+      ? ["diff", pOldRevision, pNewRevision, "--name-status"]
+      : ["diff", pOldRevision, "--name-status"],
+    lErrorMap,
+    pSpawnFunction,
+  );
+  return lResult;
 }
 export async function getSHA(pSpawnFunction = spawn) {
-    const lSha1Length = 40;
-    const lResult = await getGitResult(["rev-parse", "HEAD"], new Map(), pSpawnFunction);
-    return lResult.slice(0, lSha1Length);
+  const lSha1Length = 40;
+  const lResult = await getGitResult(
+    ["rev-parse", "HEAD"],
+    new Map(),
+    pSpawnFunction,
+  );
+  return lResult.slice(0, lSha1Length);
 }
 function getGitResult(pArguments, pErrorMap, pSpawnFunction) {
-    const lGit = pSpawnFunction("git", pArguments, {
-        cwd: process.cwd(),
-        env: process.env,
+  const lGit = pSpawnFunction("git", pArguments, {
+    cwd: process.cwd(),
+    env: process.env,
+  });
+  let lStdOutData = "";
+  let lStdErrorData = "";
+  return new Promise((pResolve, pReject) => {
+    lGit.stdout?.on("data", (pData) => {
+      lStdOutData = lStdOutData.concat(pData);
     });
-    let lStdOutData = "";
-    let lStdErrorData = "";
-    return new Promise((pResolve, pReject) => {
-        lGit.stdout?.on("data", (pData) => {
-            lStdOutData = lStdOutData.concat(pData);
-        });
-        lGit.stderr?.on("data", (pData) => {
-            lStdErrorData = lStdErrorData.concat(pData);
-        });
-        lGit.on("close", (pCode) => {
-            if (pCode === 0) {
-                pResolve(stringifyOutStream(lStdOutData));
-            }
-            else {
-                pReject(new Error(pErrorMap.get(pCode ?? 0) ||
-                    `internal git error: ${pCode} (${stringifyOutStream(lStdErrorData)})`));
-            }
-        });
-        lGit.on("error", (pError) => {
-            if (pError?.code === "ENOENT") {
-                pReject(new Error("git executable not found"));
-            }
-            else {
-                pReject(new Error(`internal spawn error: ${pError}`));
-            }
-        });
+    lGit.stderr?.on("data", (pData) => {
+      lStdErrorData = lStdErrorData.concat(pData);
     });
+    lGit.on("close", (pCode) => {
+      if (pCode === 0) {
+        pResolve(stringifyOutStream(lStdOutData));
+      } else {
+        pReject(
+          new Error(
+            pErrorMap.get(pCode ?? 0) ||
+              `internal git error: ${pCode} (${stringifyOutStream(
+                lStdErrorData,
+              )})`,
+          ),
+        );
+      }
+    });
+    lGit.on("error", (pError) => {
+      if (pError?.code === "ENOENT") {
+        pReject(new Error("git executable not found"));
+      } else {
+        pReject(new Error(`internal spawn error: ${pError}`));
+      }
+    });
+  });
 }
 function stringifyOutStream(pBufferOrString) {
-    if (pBufferOrString instanceof Buffer) {
-        return pBufferOrString.toString("utf8");
-    }
-    else {
-        return pBufferOrString;
-    }
+  if (pBufferOrString instanceof Buffer) {
+    return pBufferOrString.toString("utf8");
+  } else {
+    return pBufferOrString;
+  }
 }

package/dist/main.js

@@ -3,18 +3,22 @@ import { parseStatusLines } from "./parse-status-lines.js";
 import * as primitives from "./git-primitives.js";
 import format from "./formatters/format.js";
 export async function list(pOldRevision, pNewRevision, pOptions) {
-    const lOldRevision = pOldRevision || (await primitives.getSHA());
-    const lOptions = pOptions || {};
-    const [lDiffLines, lStatusLines] = await Promise.all([
-        primitives.getDiffLines(lOldRevision, pNewRevision),
-        !lOptions.trackedOnly ? primitives.getStatusShort() : "",
-    ]);
-    let lChanges = parseDiffLines(lDiffLines);
-    if (!lOptions.trackedOnly) {
-        lChanges = lChanges.concat(parseStatusLines(lStatusLines).filter(({ changeType }) => changeType === "untracked"));
-    }
-    return format(lChanges, lOptions.outputType);
+  const lOldRevision = pOldRevision || (await primitives.getSHA());
+  const lOptions = pOptions || {};
+  const [lDiffLines, lStatusLines] = await Promise.all([
+    primitives.getDiffLines(lOldRevision, pNewRevision),
+    !lOptions.trackedOnly ? primitives.getStatusShort() : "",
+  ]);
+  let lChanges = parseDiffLines(lDiffLines);
+  if (!lOptions.trackedOnly) {
+    lChanges = lChanges.concat(
+      parseStatusLines(lStatusLines).filter(
+        ({ changeType }) => changeType === "untracked",
+      ),
+    );
+  }
+  return format(lChanges, lOptions.outputType);
 }
 export function getSHA() {
-    return primitives.getSHA();
+  return primitives.getSHA();
 }

package/dist/map-change-type.js

@@ -1,16 +1,16 @@
 const CHANGE_CHAR_2_CHANGE_TYPE = new Map([
-    ["A", "added"],
-    ["C", "copied"],
-    ["D", "deleted"],
-    ["M", "modified"],
-    ["R", "renamed"],
-    ["T", "type changed"],
-    ["U", "unmerged"],
-    ["B", "pairing broken"],
-    [" ", "unmodified"],
-    ["?", "untracked"],
-    ["!", "ignored"],
+  ["A", "added"],
+  ["C", "copied"],
+  ["D", "deleted"],
+  ["M", "modified"],
+  ["R", "renamed"],
+  ["T", "type changed"],
+  ["U", "unmerged"],
+  ["B", "pairing broken"],
+  [" ", "unmodified"],
+  ["?", "untracked"],
+  ["!", "ignored"],
 ]);
 export function changeChar2ChangeType(pChar) {
-    return CHANGE_CHAR_2_CHANGE_TYPE.get(pChar) ?? "unknown";
+  return CHANGE_CHAR_2_CHANGE_TYPE.get(pChar) ?? "unknown";
 }

package/dist/parse-diff-lines.js

@@ -1,25 +1,27 @@
 import { EOL } from "node:os";
 import { changeChar2ChangeType } from "./map-change-type.js";
-const DIFF_NAME_STATUS_LINE_PATTERN = /^(?<changeType>[ACDMRTUXB])(?<similarity>[0-9]{3})?[ \t]+(?<name>[^ \t]+)[ \t]*(?<newName>[^ \t]+)?$/;
+const DIFF_NAME_STATUS_LINE_PATTERN =
+  /^(?<changeType>[ACDMRTUXB])(?<similarity>[0-9]{3})?[ \t]+(?<name>[^ \t]+)[ \t]*(?<newName>[^ \t]+)?$/;
 export function parseDiffLines(pString) {
-    return pString
-        .split(EOL)
-        .filter(Boolean)
-        .map(parseDiffLine)
-        .filter(({ name, changeType }) => Boolean(name) && Boolean(changeType));
+  return pString
+    .split(EOL)
+    .filter(Boolean)
+    .map(parseDiffLine)
+    .filter(({ name, changeType }) => Boolean(name) && Boolean(changeType));
 }
 export function parseDiffLine(pString) {
-    const lMatchResult = pString.match(DIFF_NAME_STATUS_LINE_PATTERN);
-    const lReturnValue = {};
-    if (lMatchResult?.groups) {
-        lReturnValue.changeType = changeChar2ChangeType(lMatchResult.groups.changeType);
-        if (lMatchResult.groups.newName) {
-            lReturnValue.name = lMatchResult.groups.newName;
-            lReturnValue.oldName = lMatchResult.groups.name;
-        }
-        else {
-            lReturnValue.name = lMatchResult.groups.name;
-        }
+  const lMatchResult = pString.match(DIFF_NAME_STATUS_LINE_PATTERN);
+  const lReturnValue = {};
+  if (lMatchResult?.groups) {
+    lReturnValue.changeType = changeChar2ChangeType(
+      lMatchResult.groups.changeType,
+    );
+    if (lMatchResult.groups.newName) {
+      lReturnValue.name = lMatchResult.groups.newName;
+      lReturnValue.oldName = lMatchResult.groups.name;
+    } else {
+      lReturnValue.name = lMatchResult.groups.name;
     }
-    return lReturnValue;
+  }
+  return lReturnValue;
 }

package/dist/parse-status-lines.js

@@ -1,30 +1,34 @@
 import { EOL } from "node:os";
 import { changeChar2ChangeType } from "./map-change-type.js";
-const DIFF_SHORT_STATUS_LINE_PATTERN = /^(?<stagedChangeType>[ ACDMRTUXB?!])(?<unStagedChangeType>[ ACDMRTUXB?!])[ \t]+(?<name>[^ \t]+)(( -> )(?<newName>[^ \t]+))?$/;
+const DIFF_SHORT_STATUS_LINE_PATTERN =
+  /^(?<stagedChangeType>[ ACDMRTUXB?!])(?<unStagedChangeType>[ ACDMRTUXB?!])[ \t]+(?<name>[^ \t]+)(( -> )(?<newName>[^ \t]+))?$/;
 export function parseStatusLines(pString) {
-    return pString
-        .split(EOL)
-        .filter(Boolean)
-        .map(parseStatusLine)
-        .filter(({ name, changeType }) => Boolean(name) && Boolean(changeType));
+  return pString
+    .split(EOL)
+    .filter(Boolean)
+    .map(parseStatusLine)
+    .filter(({ name, changeType }) => Boolean(name) && Boolean(changeType));
 }
 export function parseStatusLine(pString) {
-    const lMatchResult = pString.match(DIFF_SHORT_STATUS_LINE_PATTERN);
-    const lReturnValue = {};
-    if (lMatchResult?.groups) {
-        const lStagedChangeType = changeChar2ChangeType(lMatchResult.groups.stagedChangeType);
-        const lUnStagedChangeType = changeChar2ChangeType(lMatchResult.groups.unStagedChangeType);
-        lReturnValue.changeType =
-            lStagedChangeType === "unmodified"
-                ? lUnStagedChangeType
-                : lStagedChangeType;
-        if (lMatchResult.groups.newName) {
-            lReturnValue.name = lMatchResult.groups.newName;
-            lReturnValue.oldName = lMatchResult.groups.name;
-        }
-        else {
-            lReturnValue.name = lMatchResult.groups.name;
-        }
+  const lMatchResult = pString.match(DIFF_SHORT_STATUS_LINE_PATTERN);
+  const lReturnValue = {};
+  if (lMatchResult?.groups) {
+    const lStagedChangeType = changeChar2ChangeType(
+      lMatchResult.groups.stagedChangeType,
+    );
+    const lUnStagedChangeType = changeChar2ChangeType(
+      lMatchResult.groups.unStagedChangeType,
+    );
+    lReturnValue.changeType =
+      lStagedChangeType === "unmodified"
+        ? lUnStagedChangeType
+        : lStagedChangeType;
+    if (lMatchResult.groups.newName) {
+      lReturnValue.name = lMatchResult.groups.newName;
+      lReturnValue.oldName = lMatchResult.groups.name;
+    } else {
+      lReturnValue.name = lMatchResult.groups.name;
     }
-    return lReturnValue;
+  }
+  return lReturnValue;
 }

package/dist/run-cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { cli } from "./cli.js";
+await cli();

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.0.1";
+export const VERSION = "2.0.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watskeburt",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "List files changed since a git revision",
   "keywords": [
     "git",
@@ -19,7 +19,7 @@
     "url": "https://sverweij.github.io"
   },
   "license": "MIT",
-  "bin": "dist/cli.js",
+  "bin": "dist/run-cli.js",
   "main": "dist/main.js",
   "module": "dist/main.js",
   "type": "module",
@@ -42,44 +42,45 @@
     "README.md"
   ],
   "devDependencies": {
-    "@types/node": "20.5.1",
-    "@typescript-eslint/eslint-plugin": "6.4.1",
+    "@types/node": "20.8.7",
+    "@typescript-eslint/eslint-plugin": "6.9.0",
     "c8": "8.0.1",
-    "dependency-cruiser": "13.1.4",
-    "eslint": "8.47.0",
+    "dependency-cruiser": "15.0.0",
+    "eslint": "8.52.0",
     "eslint-config-moving-meadow": "4.0.2",
     "eslint-config-prettier": "9.0.0",
     "eslint-plugin-budapestian": "5.0.1",
     "eslint-plugin-eslint-comments": "3.2.0",
-    "eslint-plugin-import": "2.28.1",
-    "eslint-plugin-mocha": "10.1.0",
+    "eslint-plugin-import": "2.29.0",
+    "eslint-plugin-mocha": "10.2.0",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-security": "1.7.1",
     "eslint-plugin-unicorn": "48.0.1",
     "npm-run-all": "4.1.5",
-    "prettier": "3.0.2",
-    "ts-node": "10.9.1",
-    "typescript": "5.1.6",
-    "upem": "8.0.0"
+    "prettier": "3.0.3",
+    "tsx": "3.14.0",
+    "typescript": "5.2.2",
+    "upem": "9.0.2"
   },
   "engines": {
-    "node": "^16.14||>=18"
+    "node": "^18||>=20"
   },
   "scripts": {
-    "build": "npm-run-all --sequential build:clean build:version build:dist",
-    "build:version": "node --no-warnings --loader ts-node/esm tools/get-version.ts > src/version.ts",
+    "build": "npm-run-all --sequential build:clean build:version build:dist build:format",
+    "build:version": "tsx tools/get-version.ts > src/version.ts",
     "build:clean": "rm -rf dist/*",
     "build:dist": "tsc",
+    "build:format": "prettier --log-level warn --write dist/",
     "check": "npm-run-all --parallel --aggregate-output lint depcruise test:cover",
     "clean": "rm -rf dist",
-    "test": "node --no-warnings --loader 'ts-node/esm' --test-reporter ./tools/dot-with-summary.reporter.js --test src/*.spec.ts src/**/*.spec.ts",
+    "test": "tsx --test-reporter ./tools/dot-with-summary.reporter.js --test src/*.spec.ts src/**/*.spec.ts",
     "test:cover": "c8 npm test",
     "depcruise": "depcruise dist src types",
     "depcruise:graph": "depcruise src types --include-only '^(dist|src|types)' --output-type dot | dot -T svg | tee docs/dependency-graph.svg | depcruise-wrap-stream-in-html > docs/dependency-graph.html",
     "depcruise:graph:archi": "depcruise src --include-only '^(dist|src|types)' --output-type archi | dot -T svg | depcruise-wrap-stream-in-html > docs/high-level-dependency-graph.html",
     "depcruise:graph:dev": "depcruise dist src types --include-only '^(dist|src|types)' --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser",
-    "depcruise:graph:diff:dev": "depcruise dist src types --include-only '^(dist|src|types)' --highlight \"$(node dist/cli.js main -T regex)\" --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser",
-    "depcruise:graph:diff:mermaid": "depcruise dist src types --include-only '^(dist|src|types)' --output-type mermaid --output-to - --highlight \"$(node dist/cli.js $SHA -T regex)\"",
+    "depcruise:graph:diff:dev": "depcruise dist src types --include-only '^(dist|src|types)' --highlight \"$(node dist/run-cli.js main -T regex)\" --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser",
+    "depcruise:graph:diff:mermaid": "depcruise dist src types --include-only '^(dist|src|types)' --output-type mermaid --output-to - --highlight \"$(node dist/run-cli.js $SHA -T regex)\"",
     "depcruise:html": "depcruise src types --progress --output-type err-html --output-to dependency-violation-report.html",
     "depcruise:text": "depcruise src types --progress --output-type text",
     "depcruise:focus": "depcruise src types --progress --output-type text --focus",

package/dist/execute-cli.js

@@ -1,63 +0,0 @@
-import { EOL } from "node:os";
-import { parseArgs } from "node:util";
-import { list } from "./main.js";
-import { VERSION } from "./version.js";
-const HELP_MESSAGE = `Usage: watskeburt [options] [old-revision] [new-revision]
-
-lists files & their statuses since [old-revision] or between [old-revision] and [new-revision].
-
--> When you don't pass a revision at all old-revision defaults to the current one.
-
-Options:
-  -T, --outputType <type>  what format to emit (choices: "json", "regex", default: "regex")
-  --trackedOnly            only take tracked files into account (default: false)
-  -V, --version            output the version number
-  -h, --help               display help for command${EOL}`;
-export async function cli(pArguments = process.argv.slice(2), pOutStream = process.stdout, pErrorStream = process.stderr, pErrorExitCode = 1) {
-    try {
-        const lArguments = getArguments(pArguments);
-        if (lArguments.values.help) {
-            pOutStream.write(HELP_MESSAGE);
-            return;
-        }
-        if (lArguments.values.version) {
-            pOutStream.write(`${VERSION}${EOL}`);
-            return;
-        }
-        if (!outputTypeIsValid(lArguments.values.outputType)) {
-            pErrorStream.write(`error: option '-T, --outputType <type>' argument '${lArguments.values.outputType}' is invalid. Allowed choices are json, regex.${EOL}`);
-            process.exitCode = pErrorExitCode;
-            return;
-        }
-        const lResult = await list(lArguments.positionals[0], lArguments.positionals[1], lArguments.values);
-        pOutStream.write(`${lResult}${EOL}`);
-    }
-    catch (pError) {
-        pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
-        process.exitCode = pErrorExitCode;
-    }
-}
-function getArguments(pArguments) {
-    return parseArgs({
-        args: pArguments,
-        options: {
-            outputType: {
-                type: "string",
-                short: "T",
-                default: "regex",
-            },
-            trackedOnly: {
-                type: "boolean",
-                default: false,
-            },
-            help: { type: "boolean", short: "h", default: false },
-            version: { type: "boolean", short: "V", default: false },
-        },
-        strict: true,
-        allowPositionals: true,
-        tokens: false,
-    });
-}
-function outputTypeIsValid(pOutputType) {
-    return ["json", "regex"].includes(pOutputType);
-}