@uxf/scripts 11.58.0 → 11.61.0

package/bin/uxf-claude-sync.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+require("../src/uxf-claude-sync/cli")()
+    .then(exitCode => {
+        process.exitCode = exitCode;
+    })
+    .catch(() => {
+        process.exitCode = 1;
+    });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.58.0",
+    "version": "11.61.0",
     "description": "",
     "main": "index.js",
     "bin": {

package/src/GoogleChat.js

@@ -5,12 +5,18 @@ const axios = create({});
 
 /**
  * @see https://developers.google.com/chat/api/reference/rest/v1/cards-v1
+ *
+ * @param data
+ * @param {{dryRun?: boolean|undefined, webhookUrl?: string|undefined}} config
+ *
  * @returns {Promise<void>}
  */
-async function chatPostMessage(data, dryRun) {
-    if (env.GOOGLE_WEBHOOK_URL && !dryRun) {
+async function chatPostMessage(data, config = {}) {
+    const webhookUrl = config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL;
+
+    if (webhookUrl && !config.dryRun) {
         try {
-            await axios.post(env.GOOGLE_WEBHOOK_URL, { ...data });
+            await axios.post(webhookUrl, { ...data });
         } catch (error) {
             process.stderr.write("GOOGLE CHAT: chat.postMessage - error");
             console.error(error);
@@ -20,9 +26,19 @@ async function chatPostMessage(data, dryRun) {
     }
 }
 
-async function messageCardsV2(cardsV2) {
+/**
+ *
+ * @param cardsV2
+ * @param {{webhookUrl?: string}} config
+ * @returns {Promise<axios.AxiosResponse<any>>}
+ */
+async function messageCardsV2(cardsV2, config = {}) {
     return axios
-        .post(env.GOOGLE_WEBHOOK_URL, { cardsV2 }, { headers: { "Content-Type": "application/json; charset=UTF-8" } })
+        .post(
+            config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL,
+            { cardsV2 },
+            { headers: { "Content-Type": "application/json; charset=UTF-8" } },
+        )
         .then((r) => r.data);
 }
 

package/src/uxf-claude-sync/cli.js

@@ -0,0 +1,35 @@
+const { argv } = require("process");
+
+module.exports = async () => {
+    const cli = require("yargs")
+        .command("$0", "UXF Claude code sync", (yargs) => {
+            yargs.demandCommand(0, 0).usage(`UXF Claude code sync
+Usage:
+  uxf-claude-sync [options]
+  
+  `);
+        })
+        .option("url", {
+            describe: "Global guidelines URL",
+            type: "string",
+            group: "Options",
+        })
+        .option("h", { alias: "help", group: "Options" })
+        .strict(false)
+        .exitProcess(false);
+
+    try {
+        const { help, url, ...options } = cli.parse(argv.slice(2));
+
+        if (Boolean(help)) {
+            return 0;
+        }
+
+        await require("./index")(
+            url,
+        );
+    } catch (e) {
+        console.error(e);
+        return 1;
+    }
+};

package/src/uxf-claude-sync/index.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+
+const fileName = 'CLAUDE.md';
+const header = '# Global guidelines';
+
+// Funkce pro stažení obsahu z URL
+function downloadContent(url) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : http;
+
+        protocol.get(url, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new Error(`Chyba při stahování: HTTP status ${response.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            response.on('end', () => {
+                resolve(data);
+            });
+        }).on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+
+// Funkce pro úpravu souboru
+function processFile(content) {
+    try {
+        // Kontrola, zda soubor existuje
+        let fileContent = '';
+        try {
+            fileContent = fs.readFileSync(fileName, 'utf8');
+        } catch (error) {
+            // Soubor neexistuje, vytvoříme nový
+            console.log(`Soubor ${fileName} neexistuje, vytvářím nový...`);
+            fs.writeFileSync(fileName, `${header}\n\n${content}\n`);
+            console.log(`Hotovo! Obsah byl uložen do nově vytvořeného souboru ${fileName}.`);
+            return;
+        }
+
+        // Kontrola, zda soubor obsahuje nadpis
+        if (fileContent.includes(header)) {
+            console.log(`Nadpis '${header}' nalezen v souboru, nahrazuji obsah pod ním...`);
+
+            const parts = fileContent.split(header);
+            let newContent = parts[0] + header + '\n\n' + content;
+
+            fs.writeFileSync(fileName, newContent);
+            console.log(`Hotovo! Obsah pod nadpisem '${header}' byl nahrazen.`);
+        } else {
+            console.log(`Nadpis '${header}' nenalezen v souboru, přidávám na konec...`);
+            fs.writeFileSync(fileName, `${fileContent.trim()}\n\n${header}\n\n${content}\n`);
+            console.log(`Hotovo! Nadpis '${header}' a obsah byly přidány na konec souboru ${fileName}.`);
+        }
+    } catch (error) {
+        console.error(`Chyba při zpracování souboru: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports =  async function(url) {
+    console.log(`Stahuji obsah z ${url}...`);
+
+    try {
+        const content = await downloadContent(url);
+        processFile(content);
+    } catch (error) {
+        console.error(`Chyba: ${error.message}`);
+        process.exit(1);
+    }
+}

package/src/uxf-release/index.js

@@ -88,7 +88,7 @@ module.exports = async (dryRun, channel, messageTitle) => {
 
     await Slack.chatPostMessage(channel, { text: generateSlackMessage(commits, messageTitle) }, dryRun);
 
-    await GoogleChat.chatPostMessage(generateGoogleMessage(commits, messageTitle), dryRun);
+    await GoogleChat.chatPostMessage(generateGoogleMessage(commits, messageTitle), { dryRun });
 
     await GitLab.createRelease(commits.map(generateReleaseCommitMessage).join("\n"), dryRun);
 };

package/src/uxf-sitemap-check/cli.js

@@ -43,6 +43,11 @@ Environment variables:
             type: "boolean",
             group: "Options",
         })
+        .option("google-chat-webhook-url", {
+            describe: "Webhook URL of Google Chat where to send the results.",
+            type: "string",
+            group: "Options",
+        })
         .option("h", { alias: "help", group: "Options" })
         .strict(false)
         .exitProcess(false);
@@ -60,7 +65,13 @@ Environment variables:
             env.HTTP_PASSWORD = options["http-password"];
         }
 
-        await require("./index")(url, skip, options["with-nested"], options["with-images"]);
+        await require("./index")(
+            url,
+            skip,
+            options["with-nested"],
+            options["with-images"],
+            options["google-chat-webhook-url"],
+        );
     } catch (e) {
         console.error(e);
         return 1;

package/src/uxf-sitemap-check/index.js

@@ -406,12 +406,16 @@ function logStatistics(okResults, time) {
 
 /**
  * @param resultErrors {string}
+ * @param webhookUrl {string|undefined}
  * @return {Promise<void>}
  */
-async function sendGoogleChatMessage(resultErrors) {
-    await GoogleChat.chatPostMessage({
-        text: resultErrors,
-    });
+async function sendGoogleChatMessage(resultErrors, webhookUrl) {
+    await GoogleChat.chatPostMessage(
+        {
+            text: resultErrors,
+        },
+        { webhookUrl },
+    );
 }
 
 /**
@@ -419,9 +423,10 @@ async function sendGoogleChatMessage(resultErrors) {
  * @param skip {number}
  * @param withNested {boolean}
  * @param withImages {boolean}
+ * @param googleWebhookUrl {string|undefined}
  * @return {Promise<*>}
  */
-module.exports = async function run(sitemapUrl, skip, withNested, withImages) {
+module.exports = async function run(sitemapUrl, skip, withNested, withImages, googleWebhookUrl) {
     if (!sitemapUrl) {
         stdout.write("⛔ Required parameter --url is empty.\n");
         return process.exit(1);
@@ -450,7 +455,7 @@ module.exports = async function run(sitemapUrl, skip, withNested, withImages) {
     if (errors.length > 0) {
         const errorText = createErrorResult(errors);
         logErrors(errorText, "\n\n\nErrors:\n");
-        await sendGoogleChatMessage(errorText);
+        await sendGoogleChatMessage(errorText, googleWebhookUrl);
     }
 
     if (skippedUrls.length > 0) {