@opndev/rzilla 0.0.1

package/lib/cmd/release.mjs

@@ -0,0 +1,285 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import { asArray} from "@opndev/util";
+
+import { bumpSemver } from "../util.mjs";
+import { createBuildDir } from "../builddir.mjs";
+import { populateBuildDir } from "../populate.mjs";
+import { readDistToml } from "../config.mjs";
+import { readVersion, writeVersion } from "../version.mjs";
+import { runPkg } from "./pkg.mjs";
+
+import {
+  readChanges,
+  writeChanges,
+  nextHasEntries,
+  finalizeNextToVersion,
+  ensureNextInserted,
+} from "../changes.mjs";
+
+const execFileAsync = promisify(execFile);
+
+async function sh(cmd, args, { inherit = false, cwd } = {}) {
+  if (inherit) {
+    await new Promise((resolve, reject) => {
+      const p = execFile(cmd, args, { stdio: "inherit", cwd }, (err) =>
+        err ? reject(err) : resolve()
+      );
+      p.on("error", reject);
+    });
+    return { stdout: "" };
+  }
+  const { stdout } = await execFileAsync(cmd, args, { encoding: "utf8", cwd });
+  return { stdout: stdout.trimEnd() };
+}
+
+
+async function requireHumanYes(prompt) {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    throw new Error("Refusing to publish: no TTY available (human confirmation required).");
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    const ans = (await rl.question(`${prompt} Type 'y' to continue: `)).trim().toLowerCase();
+    if (ans !== "y" && ans !== "yes") {
+      throw new Error("Aborted: publish not confirmed.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function gitDirtyPaths() {
+  const { stdout } = await sh("git", ["status", "--porcelain"]);
+  if (!stdout.trim()) return [];
+  return stdout
+    .split("\n")
+    .map((l) => l.slice(3).trim())
+    .filter(Boolean);
+}
+
+async function requireBranch(branch) {
+  const { stdout } = await sh("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const cur = stdout.trim();
+  if (cur !== branch) throw new Error(`Not on '${branch}' (currently on '${cur}').`);
+}
+
+async function readDefaultRemoteBranch(remote, { airplane }) {
+  // .git/refs/remotes/<remote>/HEAD contains: "ref: refs/remotes/<remote>/<branch>"
+  const headRefPath = `.git/refs/remotes/${remote}/HEAD`;
+
+  // Try local read first
+  try {
+    const txt = await fs.readFile(headRefPath, "utf8");
+    const m = txt.match(/refs\/remotes\/[^/]+\/(.+)\s*$/);
+    if (m) return m[1].trim();
+  } catch {
+    // ignore
+  }
+
+  if (airplane) {
+    throw new Error(`Cannot determine default branch for remote '${remote}' in airplane mode.`);
+  }
+
+  // Ask git to update the remote HEAD
+  await sh("git", ["remote", "set-head", remote, "--auto"], { inherit: true });
+
+  // Try again
+  try {
+    const txt = await fs.readFile(headRefPath, "utf8");
+    const m = txt.match(/refs\/remotes\/[^/]+\/(.+)\s*$/);
+    if (m) return m[1].trim();
+  } catch {
+    // ignore
+  }
+
+  // Last resort fetch (network)
+  await sh("git", ["fetch", remote], { inherit: true });
+
+  const txt2 = await fs.readFile(headRefPath, "utf8");
+  const m2 = txt2.match(/refs\/remotes\/[^/]+\/(.+)\s*$/);
+  if (m2) return m2[1].trim();
+
+  throw new Error(`Unable to determine default branch for remote '${remote}'.`);
+}
+
+async function writeBuildLicense({ buildDir, licenseCfg }) {
+  // dist.toml:
+  // [license]
+  // spdx = "MIT"
+  // file = "LICENSES/MIT.txt"
+  if (!licenseCfg?.file) return;
+
+  const srcPath = licenseCfg.file;
+  const text = await fs.readFile(srcPath, "utf8");
+  await fs.writeFile(path.join(buildDir, "LICENSE"), text, "utf8");
+}
+
+export async function runRelease(opts = {}) {
+  const { cfg } = await readDistToml("dist.toml");
+
+  const rel = cfg.release ?? {};
+  const pre = rel.preflight ?? {};
+  const after = rel.after ?? {};
+
+  const airplane = !!pre.airplane;
+
+  const changesPath = rel.changes ?? rel.changesFile ?? "Changes";
+  const version = await readVersion(cfg);
+  const tagPrefix = rel.tagPrefix ?? "v";
+  const tag = `${tagPrefix}${version}`;
+
+  // --------- requested structure ---------
+
+  await preflightChecks();
+  await testPackage();
+  await assertDirty();
+  await assertBranch();
+
+  const build = await createBuild();
+  await copyFilesAfterBuild(build);
+  await generateArtifacts(build);
+
+  await commitAndTagRelease();
+
+  await publishNpm(build);
+
+  await postRelease();
+
+  console.log(
+    `Released ${version} (${tag})${airplane ? " [airplane]" : ""}`
+  );
+  if (airplane) console.log("Airplane mode: no network actions were performed.");
+  console.log("Reminder: git push --follow-tags (if desired).");
+
+  // --------- steps ---------
+
+  async function preflightChecks() {
+    const changesBefore = await readChanges(changesPath);
+    if (!nextHasEntries(changesBefore)) {
+      throw new Error("{{ NEXT }} has no entries. Aborting release.");
+    }
+
+    // tag must not already exist
+    try {
+      await sh("git", ["rev-parse", "-q", "--verify", `refs/tags/${tag}`]);
+      throw new Error(`Tag '${tag}' already exists.`);
+    } catch {
+      // ok: rev-parse failed => tag doesn't exist
+    }
+  }
+
+  async function testPackage() {
+    await sh("npm", ["test"], { inherit: true });
+  }
+
+  async function assertDirty() {
+    const allowedDirty = asArray(pre.dirty ?? []);
+    const dirty = await gitDirtyPaths();
+    const disallowed = dirty.filter((p) => !allowedDirty.includes(p));
+    if (disallowed.length) {
+      throw new Error(`Git working tree is dirty (disallowed): ${disallowed.join(", ")}`);
+    }
+  }
+
+  async function assertBranch() {
+    let branch = rel.branch ?? null;
+    if (!branch) {
+      const remote = cfg.repository?.remote ?? "origin";
+      branch = await readDefaultRemoteBranch(remote, { airplane });
+    }
+    await requireBranch(branch);
+  }
+
+  async function createBuild() {
+    // .build/<random>/ + .build/current
+    const { buildDir, currentPath } = await createBuildDir({ buildRoot: ".build" });
+    return { buildDir, currentPath };
+  }
+
+  async function copyFilesAfterBuild({ buildDir }) {
+    // ONLY publishable files go into build dir.
+    const g = cfg.gather ?? {};
+    const binDirs = asArray(g.bin ?? []);
+    const files = asArray(g.files ?? "lib/**/*.{mjs,cjs,js}");
+    const include = asArray(g.include ?? []);
+
+    await populateBuildDir({ buildDir, files, include, binDirs });
+  }
+
+  async function generateArtifacts({ buildDir }) {
+    // package.json into build dir; emitFiles=false because build dir is already pruned
+    await runPkg({ outDir: buildDir, emitFiles: false });
+
+    // LICENSE into build dir from [license].file
+    await writeBuildLicense({ buildDir, licenseCfg: cfg.license });
+  }
+
+  async function commitAndTagRelease() {
+    // stamp NEXT -> version + UTC(Z) timestamp (repo)
+    const changesBefore = await readChanges(changesPath);
+    const releasedChanges = finalizeNextToVersion(changesBefore, version);
+    await writeChanges(changesPath, releasedChanges);
+
+    await sh("git", ["add", changesPath], { inherit: true });
+    await sh("git", ["commit", "-m", `Release ${version}`], { inherit: true });
+
+    await sh("git", ["tag", tag], { inherit: true });
+  }
+
+  async function publishNpm({ currentPath }) {
+    if (airplane) return;
+
+    const name = String(cfg.name ?? "");
+    const isScoped = name.startsWith("@") && name.includes("/");
+
+
+    // default: public for scoped, otherwise no flag needed
+    const access = rel.access ?? (isScoped ? "public" : null);
+
+    const args = ["publish"];
+    if (access) args.push("--access", access);
+
+    if (!opts.yes) {
+      await requireHumanYes(
+        `Publish ${cfg.name}@${version}${access ? ` (${access})` : ""} to npm?`
+      );
+    }
+
+    // publish from .build/current
+    await sh("npm", args, { inherit: true, cwd: currentPath });
+  }
+
+  async function postRelease() {
+    // restore NEXT in Changes (repo)
+    const afterRelease = await readChanges(changesPath);
+    await writeChanges(changesPath, ensureNextInserted(afterRelease));
+
+    // bump dist.toml and regen repo-root package.json (optional)
+    const bumpType = rel.bump ?? "patch";
+    const doBump = after.bump ?? true;
+    const commitFiles = asArray(after.commit ?? []);
+    // commit explicitly listed files
+    if (doBump) {
+      const nextVersion = bumpSemver(version, bumpType);
+      await writeVersion(cfg, nextVersion);
+      await runPkg({msg: false}); // repo convenience
+      commitFiles.push(cfg.version.from);
+    }
+
+    if (commitFiles.length) {
+      await sh("git", ["add", ...commitFiles], { inherit: true });
+      await sh("git", ["commit", "-m", "Prepare for next release"], { inherit: true });
+    }
+  }
+}

package/lib/config.mjs

@@ -0,0 +1,12 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import fs from "node:fs/promises";
+import TOML from "@iarna/toml";
+
+export async function readDistToml(path = "dist.toml") {
+  const text = await fs.readFile(path, "utf8");
+  const cfg = TOML.parse(text);
+  return { cfg, text };
+}

package/lib/plugins/autoprereqs.mjs

@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import fs from "node:fs/promises";
+import fg from "fast-glob";
+import { asArray } from "@opndev/util";
+
+const BUILTINS = new Set([
+  "assert","buffer","child_process","cluster","console","constants","crypto","dgram",
+  "dns","domain","events","fs","http","http2","https","inspector","module","net",
+  "os","path","perf_hooks","process","punycode","querystring","readline","repl",
+  "stream","string_decoder","sys","timers","tls","trace_events","tty","url","util",
+  "v8","vm","wasi","worker_threads","zlib",
+]);
+
+function isBuiltin(spec) {
+  if (spec.startsWith("node:")) return true;
+  return BUILTINS.has(spec);
+}
+function isRelative(spec) {
+  return spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/");
+}
+function pkgNameFromSpecifier(spec) {
+  if (spec.startsWith("@")) {
+    const parts = spec.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+  }
+  return spec.split("/")[0];
+}
+function extractSpecifiers(code) {
+  const out = new Set();
+  for (const m of code.matchAll(/\bimport\s+(?:[^'"]*?\s+from\s+)?["']([^"']+)["']/g)) out.add(m[1]);
+  for (const m of code.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) out.add(m[1]);
+  for (const m of code.matchAll(/\brequire\s*\(\s*["']([^"']+)["']\s*\)/g)) out.add(m[1]);
+  return out;
+}
+
+function isGlobish(s) {
+  return /[*?[{\]}!()]/.test(s);
+}
+
+function toScanGlobs(items, exts = "{mjs,cjs,js,ts,tsx,jsx}") {
+  const list = Array.isArray(items) ? items : (items == null ? [] : [items]);
+  return list
+    .map(String)
+    .map(s => s.trim())
+    .filter(Boolean)
+    .map(s => {
+      if (isGlobish(s)) return s;
+      if (/\.(mjs|cjs|js|ts|tsx|jsx)$/i.test(s)) return s;
+      return `${s}/**/*.${exts}`;
+    });
+}
+
+async function scanDirs(dirsOrGlobs, ignoreGlobs) {
+  const patterns = toScanGlobs(dirsOrGlobs);
+  if (!patterns.length) return [];
+  return fg(patterns, {
+    dot: true,
+    onlyFiles: true,
+    unique: true,
+    ignore: ignoreGlobs,
+  });
+}
+
+async function inferFromFiles(files, ignoreSet) {
+  const found = new Set();
+  for (const f of files) {
+    const code = await fs.readFile(f, "utf8");
+    for (const spec of extractSpecifiers(code)) {
+      if (!spec) continue;
+      if (ignoreSet.has(spec)) continue;
+      if (isRelative(spec)) continue;
+      if (isBuiltin(spec)) continue;
+
+      const name = pkgNameFromSpecifier(spec);
+      if (!ignoreSet.has(name)) found.add(name);
+    }
+  }
+  return found;
+}
+
+export async function applyAutoPrereqs(cfg, pkg) {
+  const ap = cfg.autoprereqs ?? {};
+  if (ap.enabled === false) return;
+
+  const ignoreSet = new Set(asArray(ap.ignore ?? []).map(String));
+
+  // defaults
+  const defaultTestDirs = ["t", "test", "tests", "__tests__"];
+
+  // runtime dirs default: derive from gather if not provided
+  let runtimeDirs = asArray(ap.runtime ?? []);
+  if (!runtimeDirs.length) {
+    const g = cfg.gather ?? {};
+    const binDirs = asArray(g.bin ?? []);
+    runtimeDirs = []
+      .concat(asArray(g.files ?? []))
+      .concat(asArray(g.bin ?? []).map(d => `${d}/**/*.{mjs,cjs,js}`));
+  }
+
+  const testDirs = asArray(ap.tests ?? defaultTestDirs);
+
+  const ignoreGlobs = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.build/**",
+    "**/.DS_Store",
+  ];
+
+  const runtimeFiles = await scanDirs(runtimeDirs, ignoreGlobs);
+  const testFiles = await scanDirs(testDirs, ignoreGlobs);
+
+  const runtimeDeps = await inferFromFiles(runtimeFiles, ignoreSet);
+  const testDeps = await inferFromFiles(testFiles, ignoreSet);
+
+  pkg.dependencies ??= {};
+  pkg.devDependencies ??= {};
+
+  // runtime wins: put these in dependencies
+  for (const name of runtimeDeps) {
+    if (pkg.dependencies[name] || pkg.devDependencies[name] || pkg.peerDependencies?.[name]) continue;
+    pkg.dependencies[name] = "latest";
+  }
+
+  // test-only deps go in devDependencies (unless already anywhere)
+  for (const name of testDeps) {
+    if (runtimeDeps.has(name)) continue; // already covered by dependencies
+    if (pkg.dependencies[name] || pkg.devDependencies[name] || pkg.peerDependencies?.[name]) continue;
+    pkg.devDependencies[name] = "latest";
+  }
+
+  if (!Object.keys(pkg.dependencies).length)
+      delete pkg["dependencies"];
+  if (!Object.keys(pkg.devDependencies).length)
+      delete pkg["devDependencies"];
+
+}
+

package/lib/plugins/exports.mjs

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import { prefixDotSlash } from "../util.mjs";
+
+export function buildExports(cfg) {
+  const exp = cfg.exports ?? null;
+  const deny = cfg.exports?.deny ?? null;
+
+  const out = {};
+
+  // main always defines "." (unless overridden by __DOT__)
+  const main = cfg.gather?.main;
+  if (main) out["."] = prefixDotSlash(main);
+
+  if (exp && typeof exp === "object") {
+    for (const [k, v] of Object.entries(exp)) {
+      if (k === "deny") continue;
+      if (k === "__DOT__") out["."] = prefixDotSlash(v);
+      else out[`./${k}`] = prefixDotSlash(v);
+    }
+  }
+
+  if (deny && typeof deny === "object") {
+    if (Object.prototype.hasOwnProperty.call(deny, "__DOT__")) {
+      throw new Error("exports.deny may not contain __DOT__");
+    }
+    for (const k of Object.keys(deny)) {
+      delete out[`./${k}`];
+    }
+  }
+
+  return Object.keys(out).length ? out : null;
+}
+

package/lib/plugins/gather.mjs

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import fg from "fast-glob";
+import { asArray, uniq } from "@opndev/util"
+
+export function gatherConfig(cfg) {
+  const g = cfg.gather ?? {};
+
+  const binGlob = g.bin ?? "bin/*.{mjs,cjs,js}";
+  const files = asArray(g.files ?? "lib/**/*.{mjs,cjs,js}");
+  const include = asArray(g.include ?? []);
+
+  return { main: g.main ?? null, binGlob, files, include };
+}
+
+export async function discoverBins(binGlob) {
+  const files = await fg(binGlob, { onlyFiles: true, dot: true });
+  const bin = {};
+  for (const f of files.sort()) {
+    const base = f.split("/").pop();
+    const name = base.replace(/\.(mjs|cjs|js)$/i, "");
+    bin[name] = `./${f}`;
+  }
+  return { bin, binFiles: files };
+}
+
+export function buildFilesList({ files, include, binGlob }) {
+  // package.json "files" supports globs; keep it clean and deterministic
+  return uniq([
+    ...asArray(files),
+    binGlob,
+    ...asArray(include),
+  ]);
+}

package/lib/plugins/prereqs.mjs

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import { normalizePrereqValue } from "../util.mjs";
+
+export function applyPrereqs(cfg, pkg) {
+  const prereqs = cfg.prereqs ?? {};
+  const dev = prereqs.dev ?? null;
+  const peer = prereqs.peer ?? null;
+
+  pkg.engines ??= {};
+
+  // Top-level prereqs table maps to dependencies, except node/npm → engines
+  for (const [name, val] of Object.entries(prereqs)) {
+    if (name === "dev" || name === "peer") continue;
+
+    const v = normalizePrereqValue(val);
+
+    if (name === "node") { pkg.engines.node = v; continue; }
+    if (name === "npm")  { pkg.engines.npm  = v; continue; }
+
+    pkg.dependencies ??= {};
+    pkg.dependencies[name] = v;
+  }
+
+  if (!Object.keys(pkg.engines).length)
+      delete pkg["engines"];
+
+  if (dev && typeof dev === "object") {
+    pkg.devDependencies ??= {};
+    for (const [name, val] of Object.entries(dev)) {
+      pkg.devDependencies[name] = normalizePrereqValue(val);
+    }
+  }
+  if (peer && typeof peer === "object") {
+    pkg.peerDependencies ??= {};
+    for (const [name, val] of Object.entries(peer)) {
+      pkg.peerDependencies[name] = normalizePrereqValue(val);
+    }
+    if (!Object.keys(pkg.peerDependencies).length)
+        delete pkg["peerDependencies"];
+  }
+}
+

package/lib/plugins/repository.mjs

@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesleys@opperschaap.net>
+//
+// SPDX-License-Identifier: MIT
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { requireString } from "../util.mjs";
+
+const execFileAsync = promisify(execFile);
+
+async function sh(cmd, args) {
+  const { stdout } = await execFileAsync(cmd, args, { encoding: "utf8" });
+  return stdout.trim();
+}
+
+async function listRemotes() {
+  const raw = await sh("git", ["remote"]);
+  return raw.split("\n").map(s => s.trim()).filter(Boolean);
+}
+
+export async function pickRemote(preferred) {
+  const remotes = await listRemotes();
+  if (preferred && remotes.includes(preferred)) return preferred;
+  if (remotes.includes("origin")) return "origin";
+  if (remotes.includes("upstream")) return "upstream";
+  return remotes[0] ?? null;
+}
+
+export async function getRemoteUrl(remote) {
+  if (!remote) return null;
+  return sh("git", ["remote", "get-url", remote]);
+}
+
+export function parseRemoteUrl(remoteUrl) {
+  if (!remoteUrl) return null;
+
+  // scp-like: git@host:org/repo.git
+  const scp = remoteUrl.match(/^([^@]+)@([^:]+):(.+)$/);
+  if (scp) {
+    return {
+      host: scp[2],
+      path: scp[3].replace(/^\/*/, "").replace(/\.git$/, ""),
+    };
+  }
+
+  try {
+    const normalized = remoteUrl.startsWith("git+") ? remoteUrl.slice(4) : remoteUrl;
+    const u = new URL(normalized);
+    return {
+      host: u.host,
+      path: u.pathname.replace(/^\/*/, "").replace(/\.git$/, ""),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function inferProviderFromHost(host) {
+  const h = String(host ?? "").toLowerCase();
+  if (h === "github.com") return "github";
+  if (h === "gitlab.com") return "gitlab";
+  if (h === "codeberg.org") return "codeberg";
+  if (h === "bitbucket.org") return "bitbucket";
+  return null;
+}
+
+const PROVIDERS = {
+  github:   { issuesSuffix: "/issues" },
+  codeberg: { issuesSuffix: "/issues" },
+  gitlab:   { issuesSuffix: "/-/issues" },
+  bitbucket:{ issuesSuffix: "/issues" },
+};
+
+export function deriveWebAndBugs({ host, path, provider }) {
+  if (!host || !path) return { web: null, bugs: null };
+  const web = `https://${host}/${path}`;
+  const prov = provider ? PROVIDERS[provider] : null;
+  const bugs = prov ? `${web}${prov.issuesSuffix}` : null;
+  return { web, bugs };
+}
+
+
+function toHttpsUrl(url) {
+  if (!url) return null;
+
+  // git@host:user/repo.git
+  const scp = url.match(/^git@([^:]+):(.+)$/);
+  if (scp) {
+    const [, host, path] = scp;
+    return `https://${host}/${path}`;
+  }
+
+  // ssh://git@host/user/repo.git
+  const ssh = url.match(/^ssh:\/\/git@([^/]+)\/(.+)$/);
+  if (ssh) {
+    const [, host, path] = ssh;
+    return `https://${host}/${path}`;
+  }
+
+  // already http/https
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+
+  return url; // fallback
+}
+
+export async function deriveRepoAndBugs({ repository, bugtracker }) {
+  // repository table presence enables the feature
+  const repo = repository ?? {};
+  const bt = bugtracker ?? {};
+
+  // strictness: remote must be one string (later you can enforce harder)
+  const preferredRemote = requireString(repo.remote, "[repository].remote");
+
+  const remote = await pickRemote(preferredRemote);
+  const gitUrl = repo.url ?? (await getRemoteUrl(remote));
+  const remoteUrl = toHttpsUrl(gitUrl);
+  const parsed = parseRemoteUrl(remoteUrl);
+
+  const host = parsed?.host ?? null;
+  const path = parsed?.path ?? null;
+
+  const provider = repo.provider ?? inferProviderFromHost(host);
+  const { web: derivedWeb, bugs: derivedBugs } = deriveWebAndBugs({ host, path, provider });
+
+  const web = repo.web ?? derivedWeb;
+  const bugsUrl = bt.web ?? derivedBugs;
+
+  return {
+    remote,
+    remoteUrl,
+    gitUrl,
+    provider,
+    host,
+    path,
+    web,
+    bugsUrl,
+  };
+}
+