@uxf/scripts 11.122.5 → 11.124.0

package/README.md

@@ -19,7 +19,7 @@ Most binaries are already available in the UXF Docker images, so CI jobs can cal
 yarn add -D @uxf/scripts
 ```
 
-Requires **Node.js >= 24** (`engines.node`). No peer dependencies. Runtime dependencies (`axios`, `cheerio`, `dayjs`, `fast-glob`, `got`, `madge`, `robots-txt-parser`, `semver`, `yaml`, `yargs`) are bundled.
+Requires **Node.js >= 24** (`engines.node`). No peer dependencies. Runtime dependencies (`axios`, `cheerio`, `dayjs`, `fast-glob`, `got`, `rev-dep`, `robots-txt-parser`, `semver`, `yaml`, `yargs`) are bundled.
 
 ## Commands
 
@@ -31,10 +31,8 @@ Requires **Node.js >= 24** (`engines.node`). No peer dependencies. Runtime depen
 | `uxf-audit` | Print a JSON report of Node / Yarn / Next / React and installed `@uxf/*` versions. |
 | `uxf-claude-sync` | Download global guidelines from a URL into a `CLAUDE.md` file. |
 | `uxf-i18n-namespaces-gen` | Generate an `i18n-pages.json` mapping routes to the translation namespaces they use. |
-| `uxf-unused` | Find (and optionally delete) unused files in a Next.js project. |
 | `uxf-sitemap-check` | Crawl a sitemap and check all URLs for HTTP errors, duplicates, and missing pages. |
 | `uxf-sitemap-meta-export` | Crawl a sitemap and export page meta tags (title, description, OG) to `export.csv`. |
-| `uxf-lunch` | Post today's lunch menu to a Slack channel. |
 
 Every command accepts `-h` / `--help`.
 
@@ -221,24 +219,6 @@ Options:
 
 Namespaces found on `/_app` are merged into the global `*` entry.
 
-### uxf-unused
-
-Finds files in a Next.js project that are not reachable from the pages import graph, prints them, and (with `--removeFiles`) deletes them. Use `--debug` to dump intermediate JSON files (`uxf-unused-*.json`) into the working directory.
-
-```
-Usage:
-  uxf-unused [options]
-
-Options:
-  -p, --pagesDirectory    Glob of page entry points
-                          [default: "src/pages/**/*.(ts|tsx)"]
-  -f, --allFilesDirectory Glob of all candidate files
-                          [default: "src/**/*.(ts|tsx)"]
-  -r, --removeFiles       Delete the unused files          [boolean] [default: false]
-  -d, --debug             Write intermediate JSON files    [boolean] [default: false]
-  -h, --help              Show help
-```
-
 ### uxf-sitemap-check
 
 Crawls a sitemap and requests every URL, reporting HTTP errors, duplicate sitemap entries, and (optionally) indexable pages missing from the sitemap. Can also follow nested page links and images. Sends a summary to Google Chat when errors are found and exits with code 1.
@@ -286,28 +266,11 @@ Options:
   -h, --help           Show help                                       [boolean]
 ```
 
-### uxf-lunch
-
-Fetches the daily menu (Hotel Radnice) and posts it as a formatted message to a Slack channel.
-
-```
-Usage:
-  uxf-lunch [options]
-
-Environment variables:
-  SLACK_TOKEN - required
-
-Options:
-  --slack-channel  Slack channel (required)                            [string]
-  -h, --help       Show help
-```
-
 ## Gotchas
 
 - **CLI-only, no importable API.** `main` references a `index.js` that is not shipped; use the `bin` commands.
 - **CI-oriented defaults.** `uxf-release`, `uxf-push-notifier`, and `uxf-sitemap-meta-export` expect GitLab CI / environment variables and mostly make sense inside a pipeline.
 - **`uxf-sitemap-check --check-missing`** only works together with `--with-nested`; used alone it exits with code 1.
-- **`uxf-unused --removeFiles` deletes files** on disk — run without it (or with `--debug`) first to review the list.
 - **`uxf-merge-requests-notifier`** exists in the source tree but is **not** exposed as a `bin` command; it is run internally via the package's `run:mr-notifier` npm script and is not installed for consumers.
 
 ## Links

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.122.5",
+    "version": "11.124.0",
     "description": "",
     "main": "index.js",
     "bin": {
@@ -8,18 +8,15 @@
         "uxf-claude-sync": "bin/uxf-claude-sync.js",
         "uxf-dependencies-check": "bin/uxf-dependencies-check.js",
         "uxf-i18n-namespaces-gen": "bin/uxf-i18n-namespaces-gen.js",
-        "uxf-lunch": "bin/uxf-lunch.js",
         "uxf-push-notifier": "bin/uxf-push-notifier.js",
         "uxf-release": "bin/uxf-release.js",
         "uxf-sitemap-check": "bin/uxf-sitemap-check.js",
-        "uxf-sitemap-meta-export": "bin/uxf-sitemap-meta-export.js",
-        "uxf-unused": "bin/uxf-unused.js"
+        "uxf-sitemap-meta-export": "bin/uxf-sitemap-meta-export.js"
     },
     "scripts": {
         "build": "tsc -P tsconfig.build.json && chmod +x ./bin/*",
         "run:mr-notifier": "GOOGLE_WEBHOOK_URL=<<TODO>> GITLAB_TOKEN=<<TODO>> CI_SERVER_URL=https://gitlab.uxf.cz node ./bin/uxf-merge-requests-notifier.js",
-        "test": "./node_modules/.bin/eslint ./bin",
-        "typecheck": "tsc --noEmit -p tsconfig.json"
+        "typecheck": "tsc --noEmit"
     },
     "publishConfig": {
         "access": "public"
@@ -33,23 +30,22 @@
         "node": ">=24"
     },
     "dependencies": {
-        "axios": "^1.13.4",
         "cheerio": "1.2.0",
-        "dayjs": "^1.11.19",
+        "dayjs": "^1.11.21",
         "fast-glob": "3.3.3",
-        "got": "14.6.6",
-        "madge": "8.0.0",
+        "got": "15.1.0",
+        "rev-dep": "3.0.0",
         "robots-txt-parser": "2.0.3",
-        "semver": "^7.7.3",
-        "yaml": "2.8.2",
-        "yargs": "18.0.0"
+        "semver": "^7.8.5",
+        "yaml": "2.9.0",
+        "yargs": "18.1.0"
     },
     "devDependencies": {
         "@types/node": "24",
-        "@types/react": "18.3.27",
+        "@types/react": "18.3.31",
         "@types/react-dom": "18.3.7",
         "@types/semver": "^7.7.1",
-        "@uxf/core": "11.114.0",
-        "@uxf/ui": "11.122.5"
+        "@uxf/core": "11.124.0",
+        "@uxf/ui": "11.124.0"
     }
 }

package/src/cli-args.js

@@ -0,0 +1,43 @@
+/**
+ * Drobná náhrada yargsu pro notifiery, které musí běžet v CI bez `npm install`
+ * — viz `docs/decisions/package-manager.md`. Ostatní skripty v balíčku yargs
+ * používají dál; tenhle helper řeší jen `--help` a jednu hodnotovou option.
+ */
+
+/**
+ * @param {string[]} args
+ * @param {string[]} names např. `["-h", "--help"]`
+ */
+function hasFlag(args, names) {
+    return args.some((arg) => names.includes(arg));
+}
+
+/**
+ * Přečte hodnotu option ve tvaru `--name value`, `--name=value`, `-n value` i `-n=value`.
+ *
+ * @param {string[]} args
+ * @param {string[]} names např. `["-g", "--google-chat-webhook-url"]`
+ * @returns {string | undefined}
+ */
+function readOption(args, names) {
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+
+        if (names.includes(arg)) {
+            return args[index + 1];
+        }
+
+        const matched = names.find((name) => arg.startsWith(`${name}=`));
+
+        if (matched) {
+            return arg.slice(matched.length + 1);
+        }
+    }
+
+    return undefined;
+}
+
+module.exports = {
+    hasFlag,
+    readOption,
+};

package/src/cli-args.test.js

@@ -0,0 +1,61 @@
+const { hasFlag, readOption } = require("./cli-args");
+
+describe("hasFlag", () => {
+    it("finds the long form", () => {
+        expect(hasFlag(["--help"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("finds the short form", () => {
+        expect(hasFlag(["-h"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("finds the flag among other arguments", () => {
+        expect(hasFlag(["-g", "https://x", "--help"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("returns false when absent", () => {
+        expect(hasFlag(["-g", "https://x"], ["-h", "--help"])).toBe(false);
+        expect(hasFlag([], ["-h", "--help"])).toBe(false);
+    });
+
+    it("does not match a flag that is only a prefix", () => {
+        expect(hasFlag(["--help-me"], ["-h", "--help"])).toBe(false);
+    });
+});
+
+describe("readOption", () => {
+    const NAMES = ["-g", "--google-chat-webhook-url"];
+
+    it("reads `--name value`", () => {
+        expect(readOption(["--google-chat-webhook-url", "https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `--name=value` — the form used in .gitlab-ci.yml", () => {
+        expect(readOption(["--google-chat-webhook-url=https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `-n value`", () => {
+        expect(readOption(["-g", "https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `-n=value`", () => {
+        expect(readOption(["-g=https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("keeps `=` inside the value", () => {
+        expect(readOption(["--google-chat-webhook-url=https://x?key=abc"], NAMES)).toBe("https://x?key=abc");
+    });
+
+    it("finds the option among other arguments", () => {
+        expect(readOption(["--verbose", "-g", "https://x", "--other"], NAMES)).toBe("https://x");
+    });
+
+    it("returns undefined when the option is missing", () => {
+        expect(readOption(["--verbose"], NAMES)).toBeUndefined();
+        expect(readOption([], NAMES)).toBeUndefined();
+    });
+
+    it("returns undefined when the option is last and has no value", () => {
+        expect(readOption(["-g"], NAMES)).toBeUndefined();
+    });
+});

package/src/{GitLab.js → gitlab.js}

@@ -1,24 +1,41 @@
 const { env } = require("process");
-const { create } = require("axios");
-const dayjs = require("dayjs");
+const { request } = require("./http");
 
-const axios = create({
-    baseURL: `${env.CI_SERVER_URL}/api/v4`,
-    headers: {
-        Authorization: `Bearer ${env.GITLAB_TOKEN}`,
-    },
-});
+/**
+ * @param {string} url
+ * @param {{method?: string, headers?: Record<string, string>, params?: Record<string, any>, body?: any}} options
+ */
+function gitlabRequest(url, options = {}) {
+    return request(url, {
+        ...options,
+        baseUrl: `${env.CI_SERVER_URL}/api/v4`,
+        headers: { Authorization: `Bearer ${env.GITLAB_TOKEN}`, ...options.headers },
+    });
+}
+
+/** Lokální čas, stejně jako `dayjs().format(...)`, které tohle nahradilo. */
+function formatTagTimestamp(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, "0");
+
+    return [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate()),
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+    ].join("-");
+}
 
 /**
  *
  * @param {string} url
- * @param {axios.AxiosRequestConfig<any>} config
+ * @param {{params?: Record<string, any>}} config
  */
 async function getAll(url, config) {
     let nextPage = "1";
     const data = [];
     do {
-        const response = await axios.get(url, {
+        const response = await gitlabRequest(url, {
             ...config,
             params: {
                 ...config.params,
@@ -26,7 +43,7 @@ async function getAll(url, config) {
                 page: nextPage,
             },
         });
-        nextPage = response.headers["x-next-page"];
+        nextPage = response.headers.get("x-next-page");
         data.push(...response.data);
     } while (nextPage);
 
@@ -38,15 +55,15 @@ async function loadCommits(from, ref_name = "master") {
 
     let nextPage = "1";
     do {
-        const response = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
+        const response = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
             params: {
                 ref_name,
-                since: from ? dayjs(from).toISOString() : undefined,
+                since: from ? new Date(from).toISOString() : undefined,
                 per_page: "100",
                 page: nextPage,
             },
         });
-        nextPage = response.headers["x-next-page"];
+        nextPage = response.headers.get("x-next-page");
         commits.push(...response.data);
     } while (nextPage);
 
@@ -61,7 +78,7 @@ async function findMigrationFiles(commits) {
     await Promise.all(
         commits.map(async (commit) => {
             try {
-                const { data: diffs } = await axios.get(
+                const { data: diffs } = await gitlabRequest(
                     `/projects/${env.CI_PROJECT_ID}/repository/commits/${commit.id}/diff`,
                 );
                 diffs.forEach(({ new_path }) => {
@@ -81,7 +98,7 @@ async function findMigrationFiles(commits) {
 }
 
 async function getLastTag(tagPrefix = "release-", ref_name = "master") {
-    const { data: commits } = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
+    const { data: commits } = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
         params: {
             ref_name,
             per_page: "100",
@@ -90,9 +107,11 @@ async function getLastTag(tagPrefix = "release-", ref_name = "master") {
 
     const commitIds = commits.map((commit) => commit.id);
 
-    const { data: tags } = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/tags`, {
+    // Pozor: `per_page` tu záměrně chybí. V axios verzi bylo omylem mimo `params`,
+    // takže se na GitLab nikdy neposlalo a platí default (20 tagů). Doplnit ho by
+    // změnilo, který tag se najde, což je zásah do release flow — řešit zvlášť.
+    const { data: tags } = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/tags`, {
         params: { search: `^${tagPrefix}` },
-        per_page: "100",
     });
 
     const tag = tags.find((tag) => commitIds.includes(tag.commit.id)) ?? null;
@@ -107,20 +126,23 @@ async function getLastTag(tagPrefix = "release-", ref_name = "master") {
 }
 
 async function createRelease(description, tagPrefix = "release-", dryRun = false) {
-    const tag = tagPrefix + dayjs().format("YYYY-MM-DD-HH-mm");
+    const tag = tagPrefix + formatTagTimestamp();
 
     if (dryRun) {
         console.log(`\n🎉🎉🎉 Release "${tag}" published (skipped in dry run)\n\n${description}`);
         return;
     }
 
-    await axios.post(`/projects/${env.CI_PROJECT_ID}/releases`, { description, tag_name: tag, ref: "master" });
+    await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/releases`, {
+        method: "POST",
+        body: { description, tag_name: tag, ref: "master" },
+    });
 
     console.log(`\n🎉🎉🎉 Release "${tag}" published\n\n${description}`);
 }
 
 function getSingleMergeRequestChanges(projectId, mr_iid) {
-    return axios.get(`/projects/${projectId}/merge_requests/${mr_iid}/changes`).then((r) => r.data);
+    return gitlabRequest(`/projects/${projectId}/merge_requests/${mr_iid}/changes`).then((r) => r.data);
 }
 
 /**

package/src/gitlab.test.js

@@ -0,0 +1,207 @@
+const GitLab = require("./gitlab");
+
+const originalFetch = globalThis.fetch;
+const { CI_SERVER_URL, GITLAB_TOKEN, CI_PROJECT_ID } = process.env;
+
+/**
+ * @param {Array<{body: any, nextPage?: string, status?: number}>} pages
+ * odpovědi v pořadí, v jakém je fetch vrátí
+ */
+function stubFetch(pages) {
+    const calls = [];
+    let index = 0;
+
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        const page = pages[Math.min(index++, pages.length - 1)];
+        const status = page.status ?? 200;
+
+        return {
+            ok: status >= 200 && status < 300,
+            status,
+            headers: {
+                get: (name) => {
+                    if (name === "x-next-page") {
+                        return page.nextPage ?? "";
+                    }
+                    return name.toLowerCase() === "content-type" ? "application/json" : null;
+                },
+            },
+            text: async () => JSON.stringify(page.body),
+        };
+    };
+
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.CI_SERVER_URL = "https://git.test";
+    process.env.GITLAB_TOKEN = "test-token";
+    process.env.CI_PROJECT_ID = "42";
+    jest.spyOn(console, "log").mockImplementation(() => {});
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.CI_SERVER_URL = CI_SERVER_URL;
+    process.env.GITLAB_TOKEN = GITLAB_TOKEN;
+    process.env.CI_PROJECT_ID = CI_PROJECT_ID;
+    jest.restoreAllMocks();
+});
+
+describe("authentication and base url", () => {
+    it("prefixes the API path and sends the bearer token", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls[0].url).toContain("https://git.test/api/v4/projects");
+        expect(calls[0].init.headers.Authorization).toBe("Bearer test-token");
+    });
+});
+
+describe("getAll pagination", () => {
+    it("follows x-next-page until it is empty and concatenates the pages", async () => {
+        const calls = stubFetch([
+            { body: [{ id: 1 }], nextPage: "2" },
+            { body: [{ id: 2 }], nextPage: "3" },
+            { body: [{ id: 3 }], nextPage: "" },
+        ]);
+
+        const projects = await GitLab.getAllProjects();
+
+        expect(projects).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+        expect(calls).toHaveLength(3);
+        expect(calls[0].url).toContain("page=1");
+        expect(calls[1].url).toContain("page=2");
+        expect(calls[2].url).toContain("page=3");
+    });
+
+    it("stops after a single page when there is no next page", async () => {
+        const calls = stubFetch([{ body: [{ id: 1 }] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls).toHaveLength(1);
+    });
+
+    it("always asks for 100 items per page", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls[0].url).toContain("per_page=100");
+    });
+});
+
+describe("getAllMergeRequests", () => {
+    it("excludes work in progress by default", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllMergeRequests(false);
+
+        expect(calls[0].url).toContain("wip=no");
+    });
+
+    it("omits the wip filter when work in progress is included", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllMergeRequests(true);
+
+        expect(calls[0].url).not.toContain("wip=");
+    });
+});
+
+describe("loadCommits", () => {
+    it("converts the `from` timestamp to ISO for the `since` parameter", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits("2026-01-02T03:04:05.000Z");
+
+        expect(decodeURIComponent(calls[0].url)).toContain("since=2026-01-02T03:04:05.000Z");
+    });
+
+    it("omits `since` when there is no starting point", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits(null);
+
+        expect(calls[0].url).not.toContain("since=");
+    });
+
+    it("drops the boundary commit so the last release is not counted twice", async () => {
+        const from = "2026-01-02T03:04:05.000Z";
+        stubFetch([
+            {
+                body: [
+                    { id: "a", created_at: from },
+                    { id: "b", created_at: "2026-01-03T00:00:00.000Z" },
+                ],
+            },
+        ]);
+
+        const commits = await GitLab.loadCommits(from);
+
+        expect(commits.map((c) => c.id)).toEqual(["b"]);
+    });
+
+    it("uses the requested ref", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits(null, "develop");
+
+        expect(calls[0].url).toContain("ref_name=develop");
+    });
+});
+
+describe("getSingleMergeRequestChanges", () => {
+    it("returns the response body", async () => {
+        stubFetch([{ body: { changes_count: "7" } }]);
+
+        await expect(GitLab.getSingleMergeRequestChanges(1, 2)).resolves.toEqual({ changes_count: "7" });
+    });
+});
+
+describe("createRelease", () => {
+    it("builds a tag from the prefix and a local timestamp", async () => {
+        const calls = stubFetch([{ body: {} }]);
+
+        await GitLab.createRelease("poznámky", "release-");
+
+        expect(calls[0].init.method).toBe("POST");
+        expect(JSON.parse(calls[0].init.body)).toEqual({
+            description: "poznámky",
+            tag_name: expect.stringMatching(/^release-\d{4}-\d{2}-\d{2}-\d{2}-\d{2}$/),
+            ref: "master",
+        });
+    });
+
+    it("sends nothing in dry run mode", async () => {
+        const calls = stubFetch([{ body: {} }]);
+
+        await GitLab.createRelease("poznámky", "release-", true);
+
+        expect(calls).toHaveLength(0);
+    });
+});
+
+describe("findMigrationFiles", () => {
+    it("collects api migration files and ignores everything else", async () => {
+        stubFetch([
+            {
+                body: [{ new_path: "api/migrations/Version20260101120000.php" }, { new_path: "web/src/app.tsx" }],
+            },
+        ]);
+
+        await expect(GitLab.findMigrationFiles([{ id: "abc" }])).resolves.toEqual([
+            "api/migrations/Version20260101120000.php",
+        ]);
+    });
+
+    it("survives a failing commit diff instead of rejecting the whole run", async () => {
+        jest.spyOn(console, "error").mockImplementation(() => {});
+        stubFetch([{ body: { message: "nope" }, status: 500 }]);
+
+        await expect(GitLab.findMigrationFiles([{ id: "abc" }])).resolves.toEqual([]);
+    });
+});

package/src/{GoogleChat.js → google-chat.js}

@@ -1,7 +1,5 @@
 const { env } = require("process");
-const { create } = require("axios");
-
-const axios = create({});
+const { request } = require("./http");
 
 /**
  * @see https://developers.google.com/chat/api/reference/rest/v1/cards-v1
@@ -16,7 +14,7 @@ async function chatPostMessage(data, config = {}) {
 
     if (webhookUrl && !config.dryRun) {
         try {
-            await axios.post(webhookUrl, { ...data });
+            await request(webhookUrl, { method: "POST", body: { ...data } });
         } catch (error) {
             process.stderr.write("GOOGLE CHAT: chat.postMessage - error");
             console.error(error);
@@ -30,16 +28,16 @@ async function chatPostMessage(data, config = {}) {
  *
  * @param cardsV2
  * @param {{webhookUrl?: string}} config
- * @returns {Promise<axios.AxiosResponse<any>>}
+ * @returns {Promise<any>}
  */
 async function messageCardsV2(cardsV2, config = {}) {
-    return axios
-        .post(
-            config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL,
-            { cardsV2 },
-            { headers: { "Content-Type": "application/json; charset=UTF-8" } },
-        )
-        .then((r) => r.data);
+    const response = await request(config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json; charset=UTF-8" },
+        body: { cardsV2 },
+    });
+
+    return response.data;
 }
 
 module.exports = {