spec-up-t 1.0.89 → 1.0.91

package/assets/js/show-commit-hashes.js

@@ -83,9 +83,9 @@ function fetchCommitHashes() {
       };
    }
 
-   // B: Debounced “GitHub rate limit exceeded” error message
+   // B: Debounced “GitHub API rate limit exceeded” error message
    const debouncedError = debounce(() => {
-      notyf.error('GitHub rate limit exceeded. See <a target="_blank" rel="noopener" href="https://trustoverip.github.io/spec-up-t-website/docs/github-token/">documentation</a> for more info.');
+      notyf.error('GitHub API rate limit exceeded. See <a target="_blank" rel="noopener" href="https://trustoverip.github.io/spec-up-t-website/docs/github-token/">documentation</a> for more info.');
    }, 3000); // Delay in milliseconds
 
    // Fetch the content of a term-file from GitHub

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spec-up-t",
-  "version": "1.0.89",
+  "version": "1.0.91",
   "description": "Technical specification drafting tool that generates rich specification documents from markdown. Forked from https://github.com/decentralized-identity/spec-up by Daniel Buchner (https://github.com/csuwildcat)",
   "main": "./index",
   "repository": {

package/src/get-xtrefs-data/searchGitHubCode.6.js

@@ -0,0 +1,101 @@
+async function searchGitHubCode(GITHUB_API_TOKEN, searchString, owner, repo, subdirectory) {
+    const { Octokit } = await import("octokit");
+    const { throttling } = await import("@octokit/plugin-throttling");
+
+    // Create a throttled Octokit instance
+    const ThrottledOctokit = Octokit.plugin(throttling);
+    const octokit = new ThrottledOctokit({
+        auth: GITHUB_API_TOKEN,
+        throttle: {
+            onRateLimit: (retryAfter, options) => {
+                console.warn(`Request quota exhausted for request ${options.method} ${options.url}`);
+                if (!process.env.GITHUB_API_TOKEN) {
+                    console.warn('GitHub API rate limit exceeded. See <a target="_blank" rel="noopener" href="https://trustoverip.github.io/spec-up-t-website/docs/github-token/">documentation</a> for more info.');
+                    process.exit(1);
+                }
+                if (options.request.retryCount <= 1) {
+                    console.log(`Retrying after ${retryAfter} seconds...`);
+                    return true;
+                }
+            },
+            onAbuseLimit: (retryAfter, options) => {
+                console.warn(`Abuse detected for request ${options.method} ${options.url}`);
+            },
+            onSecondaryRateLimit: (retryAfter, options) => {
+                console.warn(`Secondary rate limit hit for request ${options.method} ${options.url}`);
+                if (options.request.retryCount <= 1) {
+                    console.log(`Retrying after ${retryAfter} seconds...`);
+                    return true;
+                }
+            },
+        },
+    });
+
+    try {
+        // Perform the search using Octokit with exact match
+        const searchResponse = await octokit.rest.search.code({
+            q: `"${searchString}" repo:${owner}/${repo} path:${subdirectory}`, // Exact match in subdirectory
+            headers: {
+                Accept: "application/vnd.github.v3.text-match+json", // Include text-match media type
+            },
+        });
+
+        // Log the search results
+        console.log("Total results:", searchResponse.data.total_count);
+
+        // Fetch the content of each file
+        for (const item of searchResponse.data.items) {
+            // Check if text_matches exists and is not empty
+            if (!item.text_matches || item.text_matches.length === 0) {
+                console.log(`Skipping ${item.path}: No text matches found.`);
+                continue;
+            }
+
+            // Check if the match is in the first line using text_matches
+            const isFirstLineMatch = item.text_matches.some(match => {
+                if (!match.fragment) {
+                    console.log(`Skipping ${item.path}: No fragment found in text match.`);
+                    return false;
+                }
+
+                const firstLine = match.fragment.split("\n")[0];
+                return firstLine.includes(searchString);
+            });
+
+            if (!isFirstLineMatch) {
+                console.log(`Skipping ${item.path}: Match not in the first line.`);
+                continue; // Skip this file
+            }
+
+            // Fetch file content
+            let content = "";
+            try {
+                const fileContentResponse = await octokit.rest.repos.getContent({
+                    owner: item.repository.owner.login, // Repository owner
+                    repo: item.repository.name, // Repository name
+                    path: item.path, // File path
+                });
+
+                // Decode the file content (it's base64-encoded)
+                if (fileContentResponse.data.content) {
+                    content = Buffer.from(fileContentResponse.data.content, "base64").toString("utf-8");
+                } else {
+                    // If the file is larger than 1 MB, GitHub's API will return a download URL instead of the content.
+                    console.log("File is too large. Download URL:", fileContentResponse.data.download_url);
+                }
+            } catch (error) {
+                console.error(`Error fetching content for ${item.path}:`, error);
+                content = ""; // Set content to an empty string if there's an error
+            }
+
+            // Attach the content to the item
+            item.content = content;
+        }
+
+        return searchResponse;
+    } catch (error) {
+        console.error("Error searching GitHub or fetching file content:", error);
+    }
+}
+
+exports.searchGitHubCode = searchGitHubCode;

package/src/get-xtrefs-data.js

@@ -10,209 +10,270 @@
  * @since 2024-06-09
  */
 
-const fs = require('fs-extra');
-const path = require('path');
-const readlineSync = require('readline-sync');
-const { searchGitHubCode } = require('./get-xtrefs-data/searchGitHubCode.js');
-const { matchTerm } = require('./get-xtrefs-data/matchTerm');
-const config = fs.readJsonSync('specs.json');
-const { doesUrlExist } = require('./utils/doesUrlExist.js');
-const { addPath, getPath, getAllPaths } = require('./config/paths');
-
-const externalSpecsRepos = config.specs[0].external_specs;
-
-// Check if the URLs for the external specs repositories are valid, and prompt the user to abort if they are not.
-externalSpecsRepos.forEach(repo => {
-    // Construct the URL for the terms directory of the repository
-    const termsDirUrl = `${repo.url}/blob/main/${repo.terms_dir}`;
-
-    doesUrlExist(termsDirUrl).then(exists => {
-        if (!exists) {
-            const userInput = readlineSync.question(`\n   SPEC-UP-T: This external reference is not a valid URL:\n   ${termsDirUrl}\n   Do you want to stop? (yes/no): `);
-            if (userInput.toLowerCase() === 'yes' || userInput.toLowerCase() === 'y') {
-                console.log('Stopping...');
-                process.exit(1);
-            }
-        }
-    }).catch(error => {
-        console.error('\n   SPEC-UP-T:Error checking URL existence:', error);
-    });
-});
-
-// Collect all directories that contain files with a term and definition
-// This maps over the specs in the config file and constructs paths to directories
-// where the term definition files are located.
-const specTermsDirectories = config.specs.map(spec => spec.spec_directory + '/' + spec.spec_terms_directory);
-
-// Ensure that the 'output' directory exists, creating it if necessary.
-if (!fs.existsSync('output')) {
-    fs.mkdirSync('output');
-}
 
-// Ensure that the 'output/xtrefs-history' directory exists, creating it if necessary.
-if (!fs.existsSync('output/xtrefs-history')) {
-    fs.mkdirSync('output/xtrefs-history');
-}
+function updateXTrefs(GITHUB_API_TOKEN, skipExisting) {
+    const fs = require('fs-extra');
+    const readlineSync = require('readline-sync');
+    const config = fs.readJsonSync('specs.json');
+    const externalSpecsRepos = config.specs[0].external_specs;
 
-// Define paths for various output files, including JSON and JS files.
-const outputPathJSON = 'output/xtrefs-data.json';
-const outputPathJS = 'output/xtrefs-data.js';
-const outputPathJSTimeStamped = 'output/xtrefs-history/xtrefs-data-' + Date.now() + '.js';
+    const explanationPAT =
+`\n   SPEC-UP-T: No GitHub Personal Access Token (PAT) was found.
 
-function updateXTrefs(GITHUB_API_TOKEN, skipExisting) {
-    // Function to extend xtref objects with additional information, such as repository URL and directory information.
-    function extendXTrefs(config, xtrefs) {
-        if (config.specs[0].external_specs_repos) {
-            console.log("\n   SPEC-UP-T: PLEASE NOTE: Your specs.json file is outdated (not your fault, we changed something). Use this one: https://github.com/trustoverip/spec-up-t-starter-pack/blob/main/spec-up-t-boilerplate/specs.json or e-mail kor@dwarshuis.com for help. \n");
+GitHub requires you to set up a PAT to retrieve external references.
+
+There is no point in continuing without a PAT, so we stop here.
+
+Find instructions on how to get a PAT at https://trustoverip.github.io/spec-up-t-website/docs/getting-started/github-token
+
+ `;
+
+    const explanationNoExternalReferences =
+`\n   SPEC-UP-T: No external references were found in the specs.json file.
+
+There is no point in continuing without external references, so we stop here.
+
+Please add external references to the specs.json file that you will find at the root of your project.
+
+`;
+    
+    
+    // First do some checks
+
+    // Do not run the script if the GitHub API token is not set
+    if (!GITHUB_API_TOKEN) {
+        console.log(explanationPAT);
+        const userInput = readlineSync.question('Press any key');
+
+        // React to user pressing any key
+        if (userInput.trim() !== '') {
+            console.log('Stopping...');
             return;
         }
+    }
 
-        xtrefs.forEach(xtref => {
-            config.specs.forEach(spec => {
-                // Loop through "external_specs" to find the repository URL for each xtref
-                xtref.repoUrl = null;
-                xtref.terms_dir = null;
-                xtref.owner = null;
-                xtref.repo = null;
-
-                spec.external_specs.forEach(repo => {
-                    if (repo.external_spec === xtref.externalSpec) {
-                        xtref.repoUrl = repo.url;
-                        xtref.terms_dir = repo.terms_dir;
-                        const urlParts = new URL(xtref.repoUrl).pathname.split('/');
-                        xtref.owner = urlParts[1];
-                        xtref.repo = urlParts[2];
+    else if (externalSpecsRepos.length === 0) {
+        // Check if the URLs for the external specs repositories are valid, and prompt the user to abort if they are not.
+        console.log(explanationNoExternalReferences);
+        const userInput = readlineSync.question('Press any key');
+
+        // React to user pressing any key
+        if (userInput.trim() !== '') {
+            console.log('Stopping...');
+            return;
+        }
+    } else {
+        main();
+    }
+
+    function main() {
+        const path = require('path');
+        const { searchGitHubCode } = require('./get-xtrefs-data/searchGitHubCode.js');
+        const { matchTerm } = require('./get-xtrefs-data/matchTerm');
+        const { doesUrlExist } = require('./utils/doesUrlExist.js');
+        const { addPath, getPath, getAllPaths } = require('./config/paths');
+
+        // Check if the URLs for the external specs repositories are valid, and prompt the user to abort if they are not.
+        externalSpecsRepos.forEach(repo => {
+            doesUrlExist(repo.url, repo.terms_dir).then(exists => {
+                if (!exists) {
+                    const userInput = readlineSync.question(
+`   SPEC-UP-T: This external reference is not a valid URL:
+   Repository: ${repo.url},
+   
+   Terms directory: ${repo.terms_dir}
+
+   Please fix the external references to the specs.json file that you will find at the root of your project.
+
+   Do you want to stop? (yes/no): `);
+                    if (userInput.toLowerCase() === 'yes' || userInput.toLowerCase() === 'y') {
+                        console.log('Stopping...');
+                        process.exit(1);
                     }
-                });
+                }
+            }).catch(error => {
+                console.error('\n   SPEC-UP-T:Error checking URL existence:', error);
+            });
+        });
+
+        // Collect all directories that contain files with a term and definition
+        // This maps over the specs in the config file and constructs paths to directories
+        // where the term definition files are located.
+        const specTermsDirectories = config.specs.map(spec => spec.spec_directory + '/' + spec.spec_terms_directory);
+
+        // Ensure that the 'output' directory exists, creating it if necessary.
+        if (!fs.existsSync('output')) {
+            fs.mkdirSync('output');
+        }
+
+        // Ensure that the 'output/xtrefs-history' directory exists, creating it if necessary.
+        if (!fs.existsSync('output/xtrefs-history')) {
+            fs.mkdirSync('output/xtrefs-history');
+        }
+
+        // Define paths for various output files, including JSON and JS files.
+        const outputPathJSON = 'output/xtrefs-data.json';
+        const outputPathJS = 'output/xtrefs-data.js';
+        const outputPathJSTimeStamped = 'output/xtrefs-history/xtrefs-data-' + Date.now() + '.js';
+        // Function to extend xtref objects with additional information, such as repository URL and directory information.
+        function extendXTrefs(config, xtrefs) {
+            if (config.specs[0].external_specs_repos) {
+                console.log("\n   SPEC-UP-T: PLEASE NOTE: Your specs.json file is outdated (not your fault, we changed something). Use this one: https://github.com/trustoverip/spec-up-t-starter-pack/blob/main/spec-up-t-boilerplate/specs.json or e-mail kor@dwarshuis.com for help. \n");
+                return;
+            }
 
-                // Loop through "external_specs" to find the site URL for each xtref
+            xtrefs.forEach(xtref => {
+                config.specs.forEach(spec => {
+                    // Loop through "external_specs" to find the repository URL for each xtref
+                    xtref.repoUrl = null;
+                    xtref.terms_dir = null;
+                    xtref.owner = null;
+                    xtref.repo = null;
 
-                xtref.site = null;
-                if (spec.external_specs) {
-                    spec.external_specs.forEach(externalSpec => {
-                        const key = Object.keys(externalSpec)[0];
-                        if (key === xtref.externalSpec) {
-                            xtref.site = externalSpec[key];
+                    spec.external_specs.forEach(repo => {
+                        if (repo.external_spec === xtref.externalSpec) {
+                            xtref.repoUrl = repo.url;
+                            xtref.terms_dir = repo.terms_dir;
+                            const urlParts = new URL(xtref.repoUrl).pathname.split('/');
+                            xtref.owner = urlParts[1];
+                            xtref.repo = urlParts[2];
                         }
                     });
+
+                    // Loop through "external_specs" to find the site URL for each xtref
+
+                    xtref.site = null;
+                    if (spec.external_specs) {
+                        spec.external_specs.forEach(externalSpec => {
+                            const key = Object.keys(externalSpec)[0];
+                            if (key === xtref.externalSpec) {
+                                xtref.site = externalSpec[key];
+                            }
+                        });
+                    }
+                });
+            });
+        }
+
+        // Function to check if an xtref is in the markdown content
+        function isXTrefInMarkdown(xtref, markdownContent) {
+            // const regex = new RegExp(`\\[\\[xref:${xref.term}\\]\\]`, 'g');
+            const regex = new RegExp(`\\[\\[(?:x|t)ref:${xtref.term}\\]\\]`, 'g');
+            const result = regex.test(markdownContent);
+            return result;
+        }
+
+        // Function to process and clean up xref / tref strings found in the markdown file, returning an object with `externalSpec` and `term` properties.
+        function processXTref(xtref) {
+            let [externalSpec, term] = xtref.replace(/\[\[(?:xref|tref):/, '').replace(/\]\]/, '').trim().split(/,/, 2);
+            return {
+                externalSpec: externalSpec.trim(),
+                term: term.trim()
+            };
+        }
+
+        // Initialize an object to store all xtrefs.
+        let allXTrefs = { xtrefs: [] };
+
+        // If the output JSON file exists, load its data.
+        if (fs.existsSync(outputPathJSON)) {
+            const existingXTrefs = fs.readJsonSync(outputPathJSON);
+            allXTrefs = existingXTrefs && existingXTrefs.xtrefs ? existingXTrefs : { xtrefs: [] };
+        }
+
+        // Collect all markdown content
+        let allMarkdownContent = '';
+
+        // Read all main repo Markdown files from a list of directories and concatenate their content into a single string.
+        specTermsDirectories.forEach(specDirectory => {
+            fs.readdirSync(specDirectory).forEach(file => {
+                if (file.endsWith('.md')) {
+                    const markdown = fs.readFileSync(`${specDirectory}/${file}`, 'utf8');
+                    allMarkdownContent += markdown;
                 }
             });
         });
-    }
 
-    // Function to check if an xtref is in the markdown content
-    function isXTrefInMarkdown(xtref, markdownContent) {
-        // const regex = new RegExp(`\\[\\[xref:${xref.term}\\]\\]`, 'g');
-        const regex = new RegExp(`\\[\\[(?:x|t)ref:${xtref.term}\\]\\]`, 'g');
-        const result = regex.test(markdownContent);
-        return result;
-    }
+        // Remove existing entries if not in the combined markdown content
+        allXTrefs.xtrefs = allXTrefs.xtrefs.filter(existingXTref => {
+            return isXTrefInMarkdown(existingXTref, allMarkdownContent);
+        });
 
-    // Function to process and clean up xref / tref strings found in the markdown file, returning an object with `externalSpec` and `term` properties.
-    function processXTref(xtref) {
-        let [externalSpec, term] = xtref.replace(/\[\[(?:xref|tref):/, '').replace(/\]\]/, '').trim().split(/,/, 2);
-        return {
-            externalSpec: externalSpec.trim(),
-            term: term.trim()
+        // Add new entries if they are in the markdown
+        const regex = /\[\[(?:xref|tref):.*?\]\]/g;
+
+        // `regex` is the regular expression object, and `allMarkdownContent` is the string being tested. The test method returns a boolean value: true if the pattern is found within the string, and false otherwise.
+        if (regex.test(allMarkdownContent)) {
+            const xtrefs = allMarkdownContent.match(regex);
+            xtrefs.forEach(xtref => {
+                const newXTrefObj = processXTref(xtref);
+                // Ensure that newXTrefObj is only added to the xtrefs array if there isn't already an object with the same term and externalSpec properties. This helps maintain the uniqueness of entries in the array based on these two properties.
+                if (!allXTrefs.xtrefs.some(existingXTref =>
+                    existingXTref.term === newXTrefObj.term && existingXTref.externalSpec === newXTrefObj.externalSpec)) {
+                    allXTrefs.xtrefs.push(newXTrefObj);
+                }
+            });
         };
-    }
 
-    // Initialize an object to store all xtrefs.
-    let allXTrefs = { xtrefs: [] };
+        // Example at this point:
+        // allXTrefs.xtrefs: [
+        //     { externalSpec: 'kmg-1', term: 'authentic-chained-data-container' },
+        // ]
 
-    // If the output JSON file exists, load its data.
-    if (fs.existsSync(outputPathJSON)) {
-        const existingXTrefs = fs.readJsonSync(outputPathJSON);
-        allXTrefs = existingXTrefs && existingXTrefs.xtrefs ? existingXTrefs : { xtrefs: [] };
-    }
+        // Extend each xref with additional data and fetch commit information from GitHub.
+        extendXTrefs(config, allXTrefs.xtrefs);
 
-    // Collect all markdown content
-    let allMarkdownContent = '';
+        // Example at this point:
+        // allXTrefs.xtrefs: [
+        //     {
+        //         externalSpec: 'kmg-1',
+        //         term: 'authentic-chained-data-container',
+        //         repoUrl: 'https://github.com/henkvancann/keri-main-glossary',
+        //         terms_dir: 'spec/terms-definitions',
+        //         owner: 'henkvancann',
+        //         repo: 'keri-main-glossary',
+        //         site: null
+        //     }
+        // ]
 
-    // Read all main repo Markdown files from a list of directories and concatenate their content into a single string.
-    specTermsDirectories.forEach(specDirectory => {
-        fs.readdirSync(specDirectory).forEach(file => {
-            if (file.endsWith('.md')) {
-                const markdown = fs.readFileSync(`${specDirectory}/${file}`, 'utf8');
-                allMarkdownContent += markdown;
-            }
-        });
-    });
-
-    // Remove existing entries if not in the combined markdown content
-    allXTrefs.xtrefs = allXTrefs.xtrefs.filter(existingXTref => {
-        return isXTrefInMarkdown(existingXTref, allMarkdownContent);
-    });
-
-    // Add new entries if they are in the markdown
-    const regex = /\[\[(?:xref|tref):.*?\]\]/g;
-
-    // `regex` is the regular expression object, and `allMarkdownContent` is the string being tested. The test method returns a boolean value: true if the pattern is found within the string, and false otherwise.
-    if (regex.test(allMarkdownContent)) {
-        const xtrefs = allMarkdownContent.match(regex);
-        xtrefs.forEach(xtref => {
-            const newXTrefObj = processXTref(xtref);
-            // Ensure that newXTrefObj is only added to the xtrefs array if there isn't already an object with the same term and externalSpec properties. This helps maintain the uniqueness of entries in the array based on these two properties.
-            if (!allXTrefs.xtrefs.some(existingXTref =>
-                existingXTref.term === newXTrefObj.term && existingXTref.externalSpec === newXTrefObj.externalSpec)) {
-                allXTrefs.xtrefs.push(newXTrefObj);
-            }
-        });
-    };
-
-    // Example at this point:
-    // allXTrefs.xtrefs: [
-    //     { externalSpec: 'kmg-1', term: 'authentic-chained-data-container' },
-    // ]
-
-    // Extend each xref with additional data and fetch commit information from GitHub.
-    extendXTrefs(config, allXTrefs.xtrefs);
-
-    // Example at this point:
-    // allXTrefs.xtrefs: [
-    //     {
-    //         externalSpec: 'kmg-1',
-    //         term: 'authentic-chained-data-container',
-    //         repoUrl: 'https://github.com/henkvancann/keri-main-glossary',
-    //         terms_dir: 'spec/terms-definitions',
-    //         owner: 'henkvancann',
-    //         repo: 'keri-main-glossary',
-    //         site: null
-    //     }
-    // ]
-
-    (async () => {
-        try {
-            for (let xtref of allXTrefs.xtrefs) {
-                const fetchedData = await searchGitHubCode(GITHUB_API_TOKEN, xtref.term, xtref.owner, xtref.repo, xtref.terms_dir);
-
-                fetchedData.data.items.forEach(item => {
-                    // If the term is found according to the matchTerm function (in the first line, line should start with “[[def:), etc) add the commit hash and content to the xtref object
-                    if (matchTerm(item.content, xtref.term)) {
-                        // console.log('KORKOR item: ', item);
-                        xtref.commitHash = item.sha;
-                        xtref.content = item.content;
-                        console.log(`\n   SPEC-UP-T: Match found for term: ${xtref.term} in ${xtref.externalSpec};`);
-                    } else {
+        (async () => {
+            try {
+                for (let xtref of allXTrefs.xtrefs) {
+                    const fetchedData = await searchGitHubCode(GITHUB_API_TOKEN, xtref.term, xtref.owner, xtref.repo, xtref.terms_dir);
+                    if (fetchedData.data.items.length === 0) {
                         xtref.commitHash = "not found";
                         xtref.content = "This term was not found in the external repository.";
-                        console.log(`\n   SPEC-UP-T: No match found for term: ${xtref.term} in ${xtref.externalSpec};`);
+                    } else {
+                        fetchedData.data.items.forEach(item => {
+                            // If the term is found according to the matchTerm function (in the first line, line should start with “[[def:), etc) add the commit hash and content to the xtref object
+                            if (matchTerm(item.content, xtref.term)) {
+                                xtref.commitHash = item.sha;
+                                xtref.content = item.content;
+                                console.log(`\n   SPEC-UP-T: Match found for term: ${xtref.term} in ${xtref.externalSpec};`);
+                            } else {
+                                xtref.commitHash = "not found";
+                                xtref.content = "This term was not found in the external repository.";
+                                console.log(`\n   SPEC-UP-T: No match found for term: ${xtref.term} in ${xtref.externalSpec};`);
+                            }
+                        });
                     }
-                });
+                }
+
+                const allXTrefsStr = JSON.stringify(allXTrefs, null, 2);
+                fs.writeFileSync(outputPathJSON, allXTrefsStr, 'utf8');
+                const stringReadyForFileWrite = `const allXTrefs = ${allXTrefsStr};`;
+                fs.writeFileSync(outputPathJS, stringReadyForFileWrite, 'utf8');
+                fs.writeFileSync(outputPathJSTimeStamped, stringReadyForFileWrite, 'utf8');
+
+                // Run the render function to update the HTML file
+                require('../index.js')({ nowatch: true });
+            } catch (error) {
+                console.error('An error occurred:', error);
             }
+        })();
+    }
 
-            const allXTrefsStr = JSON.stringify(allXTrefs, null, 2);
-            fs.writeFileSync(outputPathJSON, allXTrefsStr, 'utf8');
-            const stringReadyForFileWrite = `const allXTrefs = ${allXTrefsStr};`;
-            fs.writeFileSync(outputPathJS, stringReadyForFileWrite, 'utf8');
-            fs.writeFileSync(outputPathJSTimeStamped, stringReadyForFileWrite, 'utf8');
 
-            // Run the render function to update the HTML file
-            require('../index.js')({ nowatch: true });
-        } catch (error) {
-            console.error('An error occurred:', error);
-        }
-    })();
 }
 
 module.exports = {

package/src/utils/doesUrlExist.js

@@ -1,4 +1,5 @@
-async function doesUrlExist(url) {
+async function doesUrlExist(repo, termsDir) {
+    const url = `${repo}/blob/main/${termsDir}`;
     try {
         const response = await fetch(url, { method: 'HEAD' });
         if (response.ok) {