@uxf/scripts 11.122.5 → 11.124.0

package/src/uxf-i18n-namespaces-gen/dependency-tree.js

@@ -0,0 +1,102 @@
+const { execFileSync } = require("child_process");
+const path = require("path");
+
+// 256 MB. `rev-dep`'s own `bin.js` wrapper shells out with `execSync` and no `maxBuffer`, so it
+// silently truncates at Node's 1 MB default and still exits 0 — we resolve the platform binary
+// ourselves to avoid that.
+const MAX_BUFFER = 256 * 1024 * 1024;
+
+function resolveRevDepBinary() {
+    const suffix = process.platform === "win32" ? ".exe" : "";
+    const request = `@rev-dep/${process.platform}-${process.arch}/bin/rev-dep${suffix}`;
+
+    try {
+        return require.resolve(request, { paths: [__dirname] });
+    } catch {
+        throw new Error(
+            `Could not locate the rev-dep binary for your platform (${request}). ` +
+                `It ships as an optionalDependency of rev-dep — reinstall without --omit=optional.`,
+        );
+    }
+}
+
+function runRevDep(cwd, tsConfig) {
+    const args = ["debug", "get-tree-for-cwd", "--cwd", cwd];
+
+    if (tsConfig) {
+        args.push("--tsconfig-json", tsConfig);
+    }
+
+    try {
+        return execFileSync(resolveRevDepBinary(), args, { encoding: "utf8", maxBuffer: MAX_BUFFER });
+    } catch (error) {
+        const details = error.stderr ? `\n${error.stderr}` : "";
+        throw new Error(`rev-dep failed to build the dependency tree for ${cwd}.${details}`);
+    }
+}
+
+/**
+ * Turns rev-dep's tree into the shape madge's `res.obj()` returned, so the callers' traversal
+ * keeps working unchanged:
+ *
+ *   { "<cwd-relative file>": ["<cwd-relative dep>" | "<bare specifier>", ...] }
+ *
+ * Imports that rev-dep could not resolve to a project file (node modules, unresolved requests)
+ * are kept as their raw specifier — callers resolve those themselves via `require.resolve`,
+ * which is how `node_modules/@uxf/**` gets picked up.
+ *
+ * @param {string} cwd
+ * @param {{ tsConfig?: string, fileExtensions?: string[], include?: string[] }} options
+ * @returns {Record<string, string[]>}
+ */
+function buildDependencyTree(cwd, options = {}) {
+    const { tsConfig, fileExtensions, include } = options;
+
+    const graph = JSON.parse(runRevDep(cwd, tsConfig));
+
+    const toRelative = (filePath) => (path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath);
+
+    const extensions = fileExtensions?.map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+
+    // `node_modules` is deliberately left to the callers' own resolution — rev-dep does not
+    // traverse into it, and it is the one place where the raw specifiers above are needed.
+    const isOutOfScope = (relativePath) =>
+        relativePath.startsWith("node_modules") || relativePath.startsWith("..") || path.isAbsolute(relativePath);
+
+    // `include` used to be madge's `excludeRegExp`: keep only files under the given prefixes.
+    const isIncluded = (relativePath) => !include?.length || include.some((prefix) => relativePath.startsWith(prefix));
+
+    const hasAllowedExtension = (relativePath) =>
+        !extensions || extensions.some((extension) => relativePath.endsWith(extension));
+
+    const isProjectFile = (relativePath) =>
+        !isOutOfScope(relativePath) && isIncluded(relativePath) && hasAllowedExtension(relativePath);
+
+    const tree = {};
+
+    for (const [file, dependencies] of Object.entries(graph)) {
+        const relativeFile = toRelative(file);
+
+        if (!isProjectFile(relativeFile)) {
+            continue;
+        }
+
+        tree[relativeFile] = (dependencies ?? [])
+            .map((dependency) => {
+                if (dependency.resolvedTypeLabel !== "UserModule" || !dependency.id) {
+                    // node module or unresolved — hand the specifier over untouched
+                    return dependency.request;
+                }
+
+                const relativeDependency = toRelative(dependency.id);
+
+                return isProjectFile(relativeDependency) ? relativeDependency : undefined;
+            })
+            .filter((dependency) => typeof dependency === "string" && dependency.length > 0);
+    }
+
+    return tree;
+}
+
+module.exports = buildDependencyTree;
+module.exports.resolveRevDepBinary = resolveRevDepBinary;

package/src/uxf-i18n-namespaces-gen/dependency-tree.test.js

@@ -0,0 +1,46 @@
+/** @jest-environment node */
+const path = require("path");
+const buildDependencyTree = require("./dependency-tree");
+
+const FIXTURE_CWD = path.join(__dirname, "tests");
+
+describe("buildDependencyTree", () => {
+    const tree = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts", "tsx"] });
+
+    it("keys the tree by cwd-relative paths", () => {
+        expect(Object.keys(tree)).toEqual(expect.arrayContaining(["pages/page-a.tsx", "utils.tsx"]));
+    });
+
+    it("resolves relative imports to project files", () => {
+        expect(tree["pages/page-a.tsx"]).toEqual(
+            expect.arrayContaining(["components/no-index-file.tsx", "components/with-index-file/index.ts"]),
+        );
+    });
+
+    it("resolves a directory import to its index file", () => {
+        expect(tree["components/with-index-file/index.ts"]).toEqual(["components/with-index-file/with-index-file.tsx"]);
+    });
+
+    it("keeps unresolved node module imports as raw specifiers", () => {
+        // callers resolve these themselves — that is how node_modules/@uxf/** gets picked up
+        expect(tree["components/with-index-file/with-index-file.tsx"]).toEqual(
+            expect.arrayContaining(["@uxf/ui/chip", "@uxf/core/utils/noop"]),
+        );
+    });
+
+    it("does not emit node_modules files as tree keys", () => {
+        expect(Object.keys(tree).filter((file) => file.startsWith("node_modules"))).toEqual([]);
+    });
+
+    it("honours the include filter", () => {
+        const filtered = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts", "tsx"], include: ["pages"] });
+
+        expect(Object.keys(filtered).every((file) => file.startsWith("pages"))).toBe(true);
+    });
+
+    it("honours the fileExtensions filter", () => {
+        const filtered = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts"] });
+
+        expect(Object.keys(filtered).every((file) => file.endsWith(".ts"))).toBe(true);
+    });
+});

package/src/uxf-i18n-namespaces-gen/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const madge = require("madge");
+const buildDependencyTree = require("./dependency-tree");
 const path = require("path");
 const { readFileSync, readdirSync, writeFileSync, statSync, existsSync } = require("fs");
 const { findTFunctionNamespaces } = require("./utils/find-t-function-namespaces");
@@ -8,7 +8,8 @@ const join = require("node:path").join;
 
 const UXF_PACKAGES_PATH = "node_modules/@uxf";
 const FILE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "tsx", "d.ts", "mts", "cts", "d.mts", "d.cts"];
-const TEXT_FILE_EXTENSIONS = new Set(FILE_EXTENSIONS.map((e) => (e.startsWith(".") ? e : "." + e)));
+const DOTTED_FILE_EXTENSIONS = FILE_EXTENSIONS.map((e) => (e.startsWith(".") ? e : "." + e));
+const TEXT_FILE_EXTENSIONS = new Set(DOTTED_FILE_EXTENSIONS);
 const TS_CONFIG_PATH = path.resolve(process.cwd(), "tsconfig.json");
 const TS_CONFIG = existsSync(TS_CONFIG_PATH) ? TS_CONFIG_PATH : undefined;
 
@@ -44,6 +45,38 @@ function isAllowedFile(file) {
     return !file.includes("node_modules") || file.includes(UXF_PACKAGES_PATH);
 }
 
+/**
+ * Resolve an extension-less path the way TypeScript would: as a file with one of the known
+ * extensions appended, or as a directory holding an index file.
+ * @param {string} basePath
+ * @returns {string | undefined}
+ */
+function resolveFileCandidate(basePath) {
+    for (const extension of DOTTED_FILE_EXTENSIONS) {
+        const candidate = basePath + extension;
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+
+    if (existsSync(basePath)) {
+        if (statSync(basePath).isFile()) {
+            return basePath;
+        }
+
+        for (const extension of DOTTED_FILE_EXTENSIONS) {
+            const candidate = path.join(basePath, "index" + extension);
+
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+
+    return undefined;
+}
+
 /**
  * Resolve a module specifier (bare, relative, or absolute) to a real filesystem path if possible.
  * Falls back to the original specifier when not resolvable.
@@ -71,13 +104,9 @@ function resolveModuleSpecifier(spec) {
                         for (const target of targets) {
                             const mapped = target.includes("*") ? target.replace("*", middle) : target;
 
-                            const candidates = [
-                                path.resolve(ts.baseUrl, mapped),
-                                ...FILE_EXTENSIONS.map((e) => path.resolve(ts.baseUrl, mapped + e)),
-                                ...FILE_EXTENSIONS.map((e) => path.join(ts.baseUrl, mapped, "index" + e)),
-                            ].find(existsSync);
+                            const candidate = resolveFileCandidate(path.resolve(ts.baseUrl, mapped));
 
-                            if (candidates) return candidates;
+                            if (candidate) return candidate;
                         }
                     }
                 } else if (spec === pattern) {
@@ -87,8 +116,19 @@ function resolveModuleSpecifier(spec) {
             }
         }
 
-        const resolved = require.resolve(spec, { paths: [process.cwd()] });
-        return isAllowedFile(resolved) ? resolved : spec;
+        try {
+            const resolved = require.resolve(spec, { paths: [process.cwd()] });
+            if (isAllowedFile(resolved)) return resolved;
+        } catch {
+            // not resolvable by Node — fall through to the TypeScript probe below
+        }
+
+        // Node's resolver only knows .js, so packages published (or symlinked by a workspace) as
+        // TypeScript source are invisible to it. Probe node_modules directly for those.
+        const candidate = resolveFileCandidate(path.resolve(process.cwd(), "node_modules", spec));
+        if (candidate && isAllowedFile(candidate)) return candidate;
+
+        return spec;
     } catch {
         return spec;
     }
@@ -107,20 +147,9 @@ function resolveImportFrom(spec, fromFile) {
         // Relative path from the file's directory
         if (spec.startsWith(".")) {
             const baseDir = path.dirname(fromFile);
-            let candidate = path.resolve(baseDir, spec);
 
-            // Try as file
-            for (const e of FILE_EXTENSIONS) {
-                const c = candidate + e;
-                if (existsSync(c)) return c;
-            }
-            // Try as directory index
-            if (existsSync(candidate) && statSync(candidate).isDirectory()) {
-                for (const e of FILE_EXTENSIONS) {
-                    const idx = path.join(candidate, "index" + e);
-                    if (existsSync(idx)) return idx;
-                }
-            }
+            const candidate = resolveFileCandidate(path.resolve(baseDir, spec));
+            if (candidate) return candidate;
 
             // Fallback to Node resolver with file dir as base
             const resolved = require.resolve(spec, { paths: [baseDir] });
@@ -191,26 +220,14 @@ const filePathToRoute = (filePath) => {
     return removeTrailingSlash(route);
 };
 
-async function getMadgeTree(entries, include) {
-    // Build madge options; allow traversing UXF packages in node_modules.
-    const options = {
+function getDependencyTree(cwd, include) {
+    // Only project files come from here — imports of node_modules/@uxf are handed over as raw
+    // specifiers and resolved by getFiles() below.
+    return buildDependencyTree(cwd, {
         tsConfig: TS_CONFIG,
         fileExtensions: FILE_EXTENSIONS,
-        includeNpm: true,
-        dependencyFilter: (dependency) => {
-            return !dependency.includes("node_modules") || dependency.includes(UXF_PACKAGES_PATH);
-        },
-    };
-
-    // If include is provided, limit traversal to those prefixes AND node_modules/@uxf.
-    if (Array.isArray(include) && include.length > 0) {
-        const allowedPrefixes = [...include, UXF_PACKAGES_PATH];
-        const searchDirs = new RegExp(`^(?!(${allowedPrefixes.join("|")}))`, "i");
-        options.excludeRegExp = [searchDirs];
-    }
-
-    const res = await madge(entries, options);
-    return res.obj();
+        include,
+    });
 }
 
 async function getFiles(entryPoint, tree) {
@@ -243,7 +260,7 @@ async function getFiles(entryPoint, tree) {
     const queue = [];
     const visited = new Set();
 
-    // Seed queue with initial files from madge tree
+    // Seed queue with initial files from the dependency tree
     for (const file of flattenFilesOnPath) {
         if (file && typeof file === "string") {
             const fsPath = resolveModuleSpecifier(file);
@@ -302,8 +319,8 @@ async function main(include, output, defaultNamespaces, pagesDirectory) {
 
     const pages = walk(pagesDirectory).flat(Number.POSITIVE_INFINITY);
 
-    // Build a global dependency tree rooted at project to leverage madge resolution across aliases/packages
-    const tree = await getMadgeTree(process.cwd(), include);
+    // Build a global dependency tree rooted at project to leverage rev-dep resolution across aliases/packages
+    const tree = getDependencyTree(process.cwd(), include);
 
     for (const entryPoint of pages) {
         let namespaces = [];
@@ -346,6 +363,7 @@ async function main(include, output, defaultNamespaces, pagesDirectory) {
 
 module.exports = main;
 module.exports.isAllowedFile = isAllowedFile;
+module.exports.resolveFileCandidate = resolveFileCandidate;
 module.exports.removeTrailingSlash = removeTrailingSlash;
 module.exports.filePathToRoute = filePathToRoute;
 module.exports.findNamespaces = findNamespaces;

package/src/uxf-i18n-namespaces-gen/index.test.js

@@ -1,5 +1,36 @@
 /** @jest-environment node */
-const { isAllowedFile, removeTrailingSlash, filePathToRoute, findNamespaces } = require("./index");
+const path = require("path");
+const {
+    isAllowedFile,
+    removeTrailingSlash,
+    filePathToRoute,
+    findNamespaces,
+    resolveFileCandidate,
+} = require("./index");
+
+const FIXTURES = path.join(__dirname, "tests");
+
+describe("resolveFileCandidate", () => {
+    it("appends the extension to an extension-less path", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "utils"))).toBe(path.join(FIXTURES, "utils.tsx"));
+    });
+
+    it("resolves a directory to its index file", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "components/with-index-file"))).toBe(
+            path.join(FIXTURES, "components/with-index-file/index.ts"),
+        );
+    });
+
+    it("returns a path that already points at a file unchanged", () => {
+        const file = path.join(FIXTURES, "utils.tsx");
+
+        expect(resolveFileCandidate(file)).toBe(file);
+    });
+
+    it("returns undefined when nothing matches", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "does-not-exist"))).toBeUndefined();
+    });
+});
 
 describe("isAllowedFile", () => {
     it("allows .ts files outside node_modules", () => {

package/src/uxf-merge-requests-notifier/cli.js

@@ -1,27 +1,24 @@
 const { argv, env } = require("process");
+const { hasFlag } = require("../cli-args");
 
 const AVAILABLE_VARIANTS = ["CR", "STALE"];
 
-module.exports = async () => {
-    const cli = require("yargs")()
-        .command("$0", "UXF merge requests notifier", (yargs) => {
-            yargs.demandCommand(0, 0).usage(`Usage:
+const USAGE = `Usage:
   uxf-merge-requests-notifier [options]
 
+Options:
+  -h, --help         zobrazí tuto nápovědu
+
 Environment variables:
   VARIANT            - optional - CR (default), STALE
   GITLAB_TOKEN       - required
   GOOGLE_WEBHOOK_URL - required
-  CI_SERVER_URL      - required - setting by GitLab CI`);
-        })
-        .option("h", { alias: "help", group: "Options" })
-        .strict(false)
-        .exitProcess(false);
+  CI_SERVER_URL      - required - setting by GitLab CI`;
 
+module.exports = async () => {
     try {
-        const { help, ...options } = cli.parse(argv.slice(2));
-
-        if (Boolean(help)) {
+        if (hasFlag(argv.slice(2), ["-h", "--help"])) {
+            console.log(USAGE);
             return 0;
         }
 

package/src/uxf-merge-requests-notifier/index.js

@@ -1,13 +1,42 @@
-const GitLab = require("../GitLab");
-const GoogleChat = require("../GoogleChat");
-const relativeTime = require("dayjs/plugin/relativeTime");
-const dayjs = require("dayjs");
-require("dayjs/locale/cs");
-dayjs.locale("cs");
-dayjs.extend(relativeTime);
+const GitLab = require("../gitlab");
+const GoogleChat = require("../google-chat");
 
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+
+// `numeric: "always"` drží číselný tvar ("před 2 dny") tak, jak ho dělal dayjs.
+// S "auto" by Intl střídalo slovní tvary ("předevčírem") jen pro některé hodnoty.
+const RELATIVE_TIME = new Intl.RelativeTimeFormat("cs", { numeric: "always" });
+
+/** @type {Array<[Intl.RelativeTimeFormatUnit, number]>} */
+const RELATIVE_TIME_UNITS = [
+    ["year", 365 * 86400],
+    ["month", 30 * 86400],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1],
+];
+
+/** Náhrada `dayjs(date).fromNow()` s českou lokalizací. */
+function fromNow(date) {
+    const diffInSeconds = (new Date(date).getTime() - Date.now()) / 1000;
+    const absolute = Math.abs(diffInSeconds);
+
+    for (const [unit, seconds] of RELATIVE_TIME_UNITS) {
+        if (absolute >= seconds || unit === "second") {
+            return RELATIVE_TIME.format(Math.round(diffInSeconds / seconds), unit);
+        }
+    }
+}
+
+/** Náhrada `dayjs().diff(date, "days")` — ořezává k nule stejně jako dayjs. */
+function daysSince(date) {
+    return Math.trunc((Date.now() - new Date(date).getTime()) / DAY_IN_MS);
+}
+
+/** Česká shoda čísla se jménem: 1 → word1, 2–4 → word2, jinak (včetně 0) → word3. */
 function inflect(value, word1, word2, word3) {
-    return `${value} ${value === 1 ? word1 : value <= 4 ? word2 : word3}`;
+    return `${value} ${value === 1 ? word1 : value > 1 && value <= 4 ? word2 : word3}`;
 }
 
 function mapMergeRequests(mrs, projects) {
@@ -52,7 +81,7 @@ module.exports = async function run(variant) {
             result = result.filter((mr) => mr.reviewers.length === 0);
             break;
         case "STALE":
-            result = result.filter((mr) => dayjs().diff(mr.updatedAt, "days") > 30);
+            result = result.filter((mr) => daysSince(mr.updatedAt) > 30);
             break;
     }
 
@@ -75,7 +104,7 @@ module.exports = async function run(variant) {
                 card: {
                     header: {
                         title: `${mr.project.name} | ${mr.title}`,
-                        subtitle: `${mr.author.name} | ${dayjs(mr.updatedAt).fromNow()} | ${inflect(
+                        subtitle: `${mr.author.name} | ${fromNow(mr.updatedAt)} | ${inflect(
                             changesCount,
                             "soubor",
                             "soubory",
@@ -98,3 +127,8 @@ module.exports = async function run(variant) {
         ]);
     }
 };
+
+// Vystaveno kvůli testům — stejný vzorec jako v uxf-release/index.js.
+module.exports.fromNow = fromNow;
+module.exports.daysSince = daysSince;
+module.exports.inflect = inflect;

package/src/uxf-merge-requests-notifier/index.test.js

@@ -0,0 +1,103 @@
+const { fromNow, daysSince, inflect } = require("./index");
+
+const NOW = new Date("2026-06-15T12:00:00.000Z").getTime();
+
+function ago(milliseconds) {
+    return new Date(NOW - milliseconds).toISOString();
+}
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+beforeEach(() => {
+    jest.spyOn(Date, "now").mockReturnValue(NOW);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+// `fromNow` a `daysSince` nahradily dayjs (`.fromNow()` a `.diff(x, "days")`),
+// proto na ně testy — jsou to jediná místa, kde se formátování času mohlo rozejít.
+describe("fromNow", () => {
+    it("formats seconds in Czech", () => {
+        expect(fromNow(ago(30 * SECOND))).toBe("před 30 sekundami");
+    });
+
+    it("formats minutes", () => {
+        expect(fromNow(ago(5 * MINUTE))).toBe("před 5 minutami");
+    });
+
+    it("formats hours", () => {
+        expect(fromNow(ago(3 * HOUR))).toBe("před 3 hodinami");
+    });
+
+    it("formats days numerically rather than as a word", () => {
+        // Se `numeric: "auto"` by Intl vrátilo "předevčírem", což dayjs nedělal.
+        expect(fromNow(ago(2 * DAY))).toBe("před 2 dny");
+    });
+
+    it("formats months", () => {
+        expect(fromNow(ago(40 * DAY))).toBe("před 1 měsícem");
+    });
+
+    it("formats years", () => {
+        expect(fromNow(ago(400 * DAY))).toBe("před 1 rokem");
+    });
+
+    it("picks the largest fitting unit", () => {
+        expect(fromNow(ago(23 * HOUR))).toBe("před 23 hodinami");
+        expect(fromNow(ago(25 * HOUR))).toBe("před 1 dnem");
+    });
+
+    it("handles a future timestamp", () => {
+        expect(fromNow(new Date(NOW + 2 * DAY).toISOString())).toBe("za 2 dny");
+    });
+});
+
+describe("daysSince", () => {
+    it("counts whole days", () => {
+        expect(daysSince(ago(3 * DAY))).toBe(3);
+    });
+
+    it("truncates a partial day, the way dayjs diff did", () => {
+        expect(daysSince(ago(3 * DAY + 23 * HOUR))).toBe(3);
+    });
+
+    it("returns 0 for something that happened moments ago", () => {
+        expect(daysSince(ago(MINUTE))).toBe(0);
+    });
+
+    it("crosses the 30 day threshold used by the STALE variant", () => {
+        expect(daysSince(ago(30 * DAY))).toBe(30);
+        expect(daysSince(ago(31 * DAY))).toBe(31);
+    });
+});
+
+describe("inflect", () => {
+    it("uses the singular for one", () => {
+        expect(inflect(1, "soubor", "soubory", "souborů")).toBe("1 soubor");
+    });
+
+    it("uses the 2-4 form", () => {
+        expect(inflect(2, "soubor", "soubory", "souborů")).toBe("2 soubory");
+        expect(inflect(4, "soubor", "soubory", "souborů")).toBe("4 soubory");
+    });
+
+    it("uses the plural genitive from five up", () => {
+        expect(inflect(5, "soubor", "soubory", "souborů")).toBe("5 souborů");
+        expect(inflect(12, "soubor", "soubory", "souborů")).toBe("12 souborů");
+    });
+
+    // Regrese: původní podmínka `value <= 4` posílala nulu do tvaru pro 2–4
+    // ("0 soubory"). Čeština má pro nulu genitiv plurálu.
+    it("uses the plural genitive for zero", () => {
+        expect(inflect(0, "soubor", "soubory", "souborů")).toBe("0 souborů");
+    });
+
+    it("uses the plural genitive for a value that is not a number", () => {
+        expect(inflect(NaN, "soubor", "soubory", "souborů")).toBe("NaN souborů");
+    });
+});

package/src/uxf-push-notifier/cli.js

@@ -1,27 +1,28 @@
-const { argv, env } = require("process");
+const { argv } = require("process");
+const { hasFlag, readOption } = require("../cli-args");
 
-module.exports = async () => {
-    const cli = require("yargs")()
-        .command("$0", "UXF push notifier", (yargs) => {
-            yargs.demandCommand(0, 0).usage(`Usage:
+const USAGE = `Usage:
   uxf-push-notifier [options]
 
+Options:
+  -g, --google-chat-webhook-url   URL Google Chat webhooku
+  -h, --help                      zobrazí tuto nápovědu
+
 Environment variables:
   GITLAB_TOKEN - required
-`);
-        })
-        .option("g", { alias: "google-chat-webhook-url", group: "Options" })
-        .option("h", { alias: "help", group: "Options" })
-        .strict(false)
-        .exitProcess(false);
+`;
 
+module.exports = async () => {
     try {
-        const { help, g: googleChatWebhookUrl } = cli.parse(argv.slice(2));
+        const args = argv.slice(2);
 
-        if (Boolean(help)) {
+        if (hasFlag(args, ["-h", "--help"])) {
+            console.log(USAGE);
             return 0;
         }
 
+        const googleChatWebhookUrl = readOption(args, ["-g", "--google-chat-webhook-url"]);
+
         await require("./index")(googleChatWebhookUrl);
     } catch (e) {
         console.error(e);