binary-collections 2.0.12 → 2.0.14

package/lib/chunk-OA2RKEY3.mjs

@@ -0,0 +1,162 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-PAZH45HS.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/get-latest-workflow-status.mjs
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+import axios from "axios";
+import { spawn } from "cross-spawn";
+if (!import_config.GITHUB_ACCESS_TOKEN) {
+  console.error("Missing env var: ACCESS_TOKEN or GITHUB_TOKEN");
+  process.exit(1);
+}
+var BASE = "https://api.github.com";
+var headers = {
+  Authorization: `Bearer ${import_config.GITHUB_ACCESS_TOKEN}`,
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28"
+};
+async function request(url) {
+  try {
+    const res = await axios.get(url, { headers });
+    return res.data;
+  } catch (err) {
+    if (err == null ? void 0 : err.response) {
+      const statusText = err.response.statusText || "Request failed";
+      const responseText = typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data);
+      throw new Error(`${err.response.status} ${statusText}
+${responseText}`);
+    }
+    throw err;
+  }
+}
+function runGit(args) {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const child = spawn("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+        return;
+      }
+      reject(new Error(stderr.trim() || `git ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+function getOwnerFromRemoteUrl(remoteUrl) {
+  var _a;
+  const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+  const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+  return ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.owner) || null;
+}
+function getRepoFromRemoteUrl(remoteUrl) {
+  var _a;
+  const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+  const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+  return ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.repo) || null;
+}
+async function getCurrentOwner() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const owner = getOwnerFromRemoteUrl(remoteUrl);
+      if (owner) {
+        return owner;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository owner from git remote.origin.url");
+}
+async function getCurrentRepo() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const repo = getRepoFromRemoteUrl(remoteUrl);
+      if (repo) {
+        return repo;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository name from git remote.origin.url");
+}
+async function getLatestRun(owner, repo, workflowId) {
+  var _a;
+  let url = `${BASE}/repos/${owner}/${repo}/actions/runs?per_page=1`;
+  if (workflowId) {
+    url += `&workflow_id=${encodeURIComponent(workflowId)}`;
+  }
+  const data = await request(url);
+  return (_a = data.workflow_runs) == null ? void 0 : _a[0];
+}
+async function getJobs(owner, repo, runId) {
+  const url = `${BASE}/repos/${owner}/${repo}/actions/runs/${runId}/jobs`;
+  const data = await request(url);
+  return data.jobs || [];
+}
+function printReport(run, jobs) {
+  var _a;
+  console.log("\n==============================");
+  console.log("\u{1F680} Latest Workflow Run");
+  console.log("==============================");
+  console.log(`Name      : ${run.name}`);
+  console.log(`Status    : ${run.status}`);
+  console.log(`Conclusion: ${run.conclusion}`);
+  console.log(`Branch    : ${run.head_branch}`);
+  console.log(`Run ID    : ${run.id}`);
+  console.log(`URL       : ${run.html_url}`);
+  console.log("\n==============================");
+  console.log("\u{1F9E9} Jobs & Steps");
+  console.log("==============================\n");
+  for (const job of jobs) {
+    console.log(`\u{1F9F1} Job: ${job.name}`);
+    console.log(`   Status: ${job.status} | Conclusion: ${job.conclusion}`);
+    if (!((_a = job.steps) == null ? void 0 : _a.length)) {
+      console.log("   (no steps found)\n");
+      continue;
+    }
+    for (const step of job.steps) {
+      const icon = step.conclusion === "success" ? "\u2705" : step.conclusion === "failure" ? "\u274C" : step.conclusion === "skipped" ? "\u23ED\uFE0F" : "\u26AA";
+      console.log(`   ${icon} ${step.name} -> ${step.conclusion} (${step.status})`);
+    }
+    console.log("");
+  }
+}
+
+export {
+  request,
+  getOwnerFromRemoteUrl,
+  getRepoFromRemoteUrl,
+  getCurrentOwner,
+  getCurrentRepo,
+  getLatestRun,
+  getJobs,
+  printReport
+};

package/lib/{chunk-C6D2TTYU.mjs → chunk-OBXLTXFJ.mjs}

@@ -1,14 +1,16 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  init_isWindows,
   isWindows
-} from "./chunk-XPJGCDOD.mjs";
+} from "./chunk-QII2EKCS.mjs";
 import {
   init_esm_shims
 } from "./chunk-QQ4A6DLD.mjs";
 
 // src/cross-env/command.ts
 init_esm_shims();
-import path from "path";
+init_isWindows();
+import path from "upath";
 function commandConvert(command, env, normalize = false) {
   if (!isWindows()) {
     return command;

package/lib/{chunk-G5UUEWUO.mjs → chunk-PAZH45HS.mjs}

@@ -12,9 +12,14 @@ import {
 var require_config = __commonJS({
   "src/binary-collections/config.cjs"(exports, module) {
     init_esm_shims();
-    var path = __require("path");
+    var path = __require("upath");
+    var minimistLib = __require("minimist");
     var { findEnvWithToken } = require_findEnvFiles();
     __require("dotenv").config({ path: findEnvWithToken(), quiet: true, overwrite: true });
+    var cliArgv = minimistLib(process.argv.slice(2), {
+      string: ["token"]
+    });
+    var GITHUB_ACCESS_TOKEN = cliArgv.token || process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
     function getTempDir() {
       return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
     }
@@ -25,7 +30,8 @@ var require_config = __commonJS({
     module.exports = {
       getTempDir,
       getTempPath,
-      TEMP_BASE_DIR
+      TEMP_BASE_DIR,
+      GITHUB_ACCESS_TOKEN
     };
   }
 });

package/lib/chunk-QD4T255Z.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/cache.js
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+import crypto from "crypto";
+function md5(str) {
+  return crypto.createHash("md5").update(str).digest("hex");
+}
+function getCacheFile({ patterns, ignore, cwd }) {
+  const root = cwd || process.env.INIT_CWD || process.cwd();
+  const key = md5(
+    JSON.stringify({
+      patterns: [...patterns].sort(),
+      ignore: [...ignore].sort()
+    })
+  );
+  return path.join(root, "tmp", ".checksum", `${key}.json`);
+}
+function loadCache(file) {
+  try {
+    return fs.readJsonSync(file);
+  } catch {
+    return null;
+  }
+}
+function saveCache(file, data) {
+  fs.ensureDirSync(path.dirname(file));
+  fs.writeJsonSync(file, data, { spaces: 2 });
+}
+
+export {
+  getCacheFile,
+  loadCache,
+  saveCache
+};

package/lib/{chunk-XPJGCDOD.mjs → chunk-QII2EKCS.mjs}

@@ -1,14 +1,26 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  __esm,
+  __export,
   init_esm_shims
 } from "./chunk-QQ4A6DLD.mjs";
 
 // src/utils/isWindows.js
-init_esm_shims();
+var isWindows_exports = {};
+__export(isWindows_exports, {
+  isWindows: () => isWindows
+});
 function isWindows() {
   return process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE || "");
 }
+var init_isWindows = __esm({
+  "src/utils/isWindows.js"() {
+    init_esm_shims();
+  }
+});
 
 export {
-  isWindows
+  isWindows,
+  isWindows_exports,
+  init_isWindows
 };

package/lib/chunk-QZMGBDSA.mjs

@@ -0,0 +1,32 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/utils/check-api.ts
+init_esm_shims();
+import axios from "axios";
+import { writefile } from "sbg-utility";
+async function checkOpenCodeApi(prompt, apiKey, model = "deepseek-v4-flash-free") {
+  const res = await axios.post(
+    "https://opencode.ai/zen/v1/chat/completions",
+    {
+      model,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 512
+    },
+    {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    }
+  );
+  const filePath = `tmp/logs/opencode-api-check-${Date.now()}.json`;
+  writefile(filePath, JSON.stringify(res.data, null, 2));
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  const notEmptyOutput = output && output.trim().length > 0;
+  return notEmptyOutput;
+}
+
+export {
+  checkOpenCodeApi
+};

package/lib/chunk-RDGDLSPD.mjs

@@ -0,0 +1,76 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/rmpath.mjs
+init_esm_shims();
+import dotenv from "dotenv";
+import fs from "fs-extra";
+import * as glob from "glob";
+import path from "upath";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var dotenvPath = path.resolve(process.cwd(), ".env");
+if (fs.existsSync(dotenvPath)) {
+  dotenv.config({ path: dotenvPath, override: true, quiet: true });
+}
+var deletePatterns = [];
+function resolveDeletePatterns(targetPath) {
+  if (fs.existsSync(targetPath) && fs.lstatSync(targetPath).isFile()) {
+    deletePatterns.push(targetPath);
+    return;
+  }
+  const vowels = ["a", "i", "u", "e", "o", "A", "I", "U", "E", "O"];
+  const letters = [];
+  for (let i = 97; i <= 122; i++) letters.push(String.fromCharCode(i));
+  for (let i = 65; i <= 90; i++) letters.push(String.fromCharCode(i));
+  for (const letter of letters) {
+    for (const vowel of vowels) {
+      deletePatterns.push(
+        `.${letter}*`,
+        `@${letter}*`,
+        `${letter}*`,
+        `@${letter}${vowel}*`,
+        `.${letter}${vowel}*`,
+        `${letter}${vowel}*`
+      );
+    }
+  }
+}
+async function deleteMatchingFiles(baseDir) {
+  for (const pattern of deletePatterns) {
+    if (fs.existsSync(pattern)) {
+      fs.rmSync(pattern, { recursive: true, force: true });
+      continue;
+    }
+    const matches = glob.sync(path.join(baseDir, pattern), { dot: true, nocase: true });
+    for (const fpath of matches) {
+      try {
+        console.log(`deleting ${fpath}`);
+        fs.rmSync(fpath, { recursive: true, force: true });
+      } catch (_e) {
+        console.error(`cannot delete ${fpath}`);
+      }
+    }
+  }
+}
+async function deleteMainScript(targetPath) {
+  if (!fs.existsSync(targetPath)) {
+    targetPath = path.resolve(process.cwd(), targetPath);
+  }
+  resolveDeletePatterns(targetPath);
+  await deleteMatchingFiles(targetPath);
+  console.log(`cleaning ${targetPath}`);
+  try {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  } catch (_e) {
+  }
+}
+
+export {
+  resolveDeletePatterns,
+  deleteMatchingFiles,
+  deleteMainScript
+};

package/lib/chunk-RJKTSUAX.mjs

@@ -0,0 +1,123 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-package-packer/build-readme.mjs
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+import * as crossSpawn from "cross-spawn";
+import { gitCommandHelper as gch } from "git-command-helper";
+async function buildReadme(dirname, packagejson, releaseDir, argv, isCI) {
+  if (!fs.existsSync(path.join(dirname, ".git"))) {
+    console.log("Not a git repository, skipping readme creation");
+    return;
+  }
+  const spawnAsync = crossSpawn && typeof crossSpawn.async === "function" ? crossSpawn.async : crossSpawn;
+  if (isCI) {
+    await spawnAsync("git", ["config", "--global", "user.name", "dimaslanjaka"], {
+      cwd: dirname,
+      stdio: "inherit"
+    });
+    await spawnAsync("git", ["config", "--global", "user.email", "dimaslanjaka@gmail.com"], {
+      cwd: dirname,
+      stdio: "inherit"
+    });
+  }
+  const git = new gch(dirname);
+  const branch = (await git.getbranch()).filter((o) => o.active)[0].branch;
+  const gitlatest = await git.latestCommit();
+  const tarballs = fs.readdirSync(releaseDir).filter((str) => str.endsWith("tgz")).map((str) => {
+    return {
+      absolute: path.resolve(releaseDir, str),
+      relative: path.resolve(releaseDir, str).replace(path.toUnix(dirname), "")
+    };
+  }).filter((o) => fs.statSync(o.absolute).isFile());
+  let md = `# Release \`${packagejson.name}\` tarball
+`;
+  md += "## Releases\n";
+  md += "| version | tarball url |\n";
+  md += "| :--- | :--- |\n";
+  for (let i = 0; i < tarballs.length; i++) {
+    const tarball = tarballs[i];
+    const relativeTarball = tarball.relative.replace(/^\/+/, "");
+    if (!fs.existsSync(tarball.absolute)) {
+      console.log(tarball.relative, "not found");
+      continue;
+    }
+    await spawnAsync("git", ["update-index", "--untracked-cache"]);
+    if (argv["commit"]) {
+      const checkIgnore = await git.isIgnored(relativeTarball, { cwd: dirname });
+      if (checkIgnore) {
+        console.log(relativeTarball, "ignored by .gitignore");
+        continue;
+      } else {
+        await git.add(relativeTarball);
+        const args = ["status", "-uno", "--porcelain", "--", relativeTarball, "|", "wc", "-l"];
+        const isChanged = parseInt(
+          (await spawnAsync("git", args, {
+            cwd: dirname,
+            shell: true
+          })).output.trim()
+        ) > 0;
+        if (isChanged) {
+          await git.commit("chore(tarball): update " + gitlatest, "-m", { stdio: "pipe" });
+        }
+      }
+    }
+    const hash = await git.latestCommit(tarball.relative.replace(/^\/+/, ""));
+    const raw = await git.getGithubRepoUrl(tarball.relative.replace(/^\/+/, ""));
+    let tarballUrl;
+    const dev = raw.rawURL;
+    const prod = raw.rawURL.replace("/raw/" + branch, "/raw/" + hash);
+    let ver = path.basename(tarball.relative, ".tgz").replace(`${packagejson.name}-`, "");
+    if (typeof hash === "string") {
+      if (isNaN(parseFloat(ver))) {
+        ver = "latest";
+        tarballUrl = dev;
+        md += `| ${ver} | ${prod} |
+`;
+      } else {
+        tarballUrl = prod;
+      }
+      md += `| ${ver} | ${tarballUrl} |
+`;
+    }
+  }
+  md += `
+use this tarball with \`resolutions\`:
+`;
+  md += '```json\n{\n  "resolutions": {\n    "' + packagejson.name + '": "<url of tarball>"\n  }\n}\n```\n\n## Releases\n\n    ';
+  fs.writeFileSync(
+    path.join(releaseDir, "readme.md"),
+    (md + `
+
+## Get URL of \`${packagejson.name}\` Release Tarball
+- select tarball file
+![gambar](https://user-images.githubusercontent.com/12471057/203216375-8af4b5d9-00c2-40fb-8d3d-d220beaabd46.png)
+- copy raw url
+![gambar](https://user-images.githubusercontent.com/12471057/203216508-7590cbb9-a1ce-47d6-96ca-8d82149f0762.png)
+- or copy download url
+![gambar](https://user-images.githubusercontent.com/12471057/203216541-3807d2c3-5213-49f3-b93d-c626dbae3b2e.png)
+- then run installation from command line
+
+\`\`\`bash
+npm i https://....url-tgz
+\`\`\`
+for example
+\`\`\`bash
+npm i https://github.com/dimaslanjaka/nodejs-package-types/raw/main/release/nodejs-package-types.tgz
+\`\`\`
+
+## URL Parts Explanations
+> https://github.com/github-username/github-repo-name/raw/github-branch-name/path-to-file-with-extension
+  `).trim() + "\n"
+  );
+}
+var build_readme_default = buildReadme;
+
+export {
+  buildReadme,
+  build_readme_default
+};

package/lib/chunk-RKPIBGKE.mjs

@@ -0,0 +1,61 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  checkOpenCodeApi
+} from "./chunk-QZMGBDSA.mjs";
+import {
+  getOpenCodeAuth,
+  readJson,
+  saveOpenCodeAuth
+} from "./chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/cli/auth-rotate.ts
+init_esm_shims();
+import path from "upath";
+async function handleAuthRotate() {
+  let keysFile = path.join(process.cwd(), ".opencode.keys.jsonc");
+  let keys = await readJson(keysFile);
+  if (!keys) {
+    keysFile = path.join(process.cwd(), ".opencode.keys.json");
+    keys = await readJson(keysFile);
+  }
+  if (!keys || !Array.isArray(keys) || keys.length === 0) {
+    console.error("No valid .opencode.keys.json or .opencode.keys.jsonc found in current directory");
+    process.exit(1);
+  }
+  const auth = await getOpenCodeAuth();
+  if (!auth) {
+    console.error("No auth file found. Run configure first.");
+    process.exit(1);
+  }
+  const currentKey = auth.opencode.key;
+  const candidates = keys.filter((k) => k.key !== currentKey);
+  if (candidates.length === 0) {
+    console.error("No other keys available to rotate to");
+    process.exit(1);
+  }
+  let chosen = null;
+  for (const candidate of candidates) {
+    try {
+      const ok = await checkOpenCodeApi("Hello", candidate.key);
+      if (ok) {
+        chosen = candidate;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!chosen) {
+    console.error("No working key found among available keys");
+    process.exit(1);
+  }
+  auth.opencode.key = chosen.key;
+  await saveOpenCodeAuth(auth);
+  console.log(`Rotated OpenCode API key to: ${chosen.name}`);
+}
+
+export {
+  handleAuthRotate
+};

package/lib/chunk-SARIXFHP.mjs

@@ -0,0 +1,44 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_findEnvFiles
+} from "./chunk-J4M5EL5P.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections/config.cjs
+var require_config = __commonJS({
+  "src/binary-collections/config.cjs"(exports, module) {
+    init_esm_shims();
+    var path = __require("upath");
+    var minimistLib = __require("minimist");
+    var { findEnvWithToken } = require_findEnvFiles();
+    var dotenv = __require("dotenv");
+    var loadDotenv = (tokenKey = /ACCESS_TOKEN|GITHUB_TOKEN/) => dotenv.config({ path: findEnvWithToken(void 0, tokenKey), quiet: true, overwrite: true });
+    loadDotenv();
+    var cliArgv = minimistLib(process.argv.slice(2), {
+      string: ["token"]
+    });
+    var GITHUB_ACCESS_TOKEN = cliArgv.token || process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    function getTempDir() {
+      return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
+    }
+    function getTempPath(...segments) {
+      return path.join(getTempDir(), ...segments);
+    }
+    var TEMP_BASE_DIR = getTempDir();
+    module.exports = {
+      getTempDir,
+      getTempPath,
+      TEMP_BASE_DIR,
+      GITHUB_ACCESS_TOKEN,
+      loadDotenv
+    };
+  }
+});
+
+export {
+  require_config
+};

package/lib/chunk-SJYP66BO.mjs

@@ -0,0 +1,62 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SWUAEY4H.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/submodule-remove.cjs
+var require_submodule_remove = __commonJS({
+  "src/submodule-remove.cjs"(exports, module) {
+    init_esm_shims();
+    var { spawnAsync } = __require("cross-spawn");
+    var path = __require("upath");
+    var fs = __require("fs-extra");
+    var { loadDotenv } = require_config();
+    loadDotenv();
+    async function removeSubmodule(submodulePath) {
+      try {
+        await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not deinitialize submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      try {
+        await spawnAsync("git", ["config", "--remove-section", `submodule.${submodulePath}`], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not remove git config section for submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      const gitModulesPath = path.resolve(".git", "modules", submodulePath);
+      if (fs.existsSync(gitModulesPath)) {
+        fs.rmSync(gitModulesPath, { recursive: true, force: true });
+        console.log(`Removed .git/modules entry for submodule "${submodulePath}".`);
+      } else {
+        console.warn(`Warning: The path "${gitModulesPath}" does not exist. Skipping removal of .git/modules entry.`);
+      }
+      const gitmodulesPath = path.resolve(".gitmodules");
+      if (fs.existsSync(gitmodulesPath)) {
+        let gitmodulesContent = fs.readFileSync(gitmodulesPath, "utf-8");
+        const submoduleSectionRegex = new RegExp(
+          `\\[submodule "${submodulePath.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}"]([\\s\\S]*?)(?=\\[|$)`,
+          "g"
+        );
+        gitmodulesContent = gitmodulesContent.replace(submoduleSectionRegex, "").trim();
+        fs.writeFileSync(gitmodulesPath, gitmodulesContent);
+        console.log(`Removed submodule "${submodulePath}" from .gitmodules.`);
+      } else {
+        console.warn(`Warning: The .gitmodules file does not exist. Skipping removal of submodule "${submodulePath}".`);
+      }
+      fs.rmSync(path.resolve(submodulePath), { recursive: true, force: true });
+      console.log(`Submodule "${submodulePath}" has been removed.`);
+    }
+    module.exports = removeSubmodule;
+  }
+});
+
+export {
+  require_submodule_remove
+};