comfy-pr 0.2.26 → 1.0.1

package/src/checkPRsFailures.ts

@@ -1,18 +1,23 @@
 import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
-import { csvFormatBody } from "d3";
 import sflow from "sflow";
 import { CNRepos } from "./CNRepos";
+import { yaml } from "./utils/yaml";
 
 if (import.meta.main) {
   const pipeline = $pipeline(CNRepos)
     .match({ "createdPulls.state": "error" })
     .set({ error: "$createdPulls.error" })
-    .project({ _id: 0, repository: 1, error: 1 })
-    .as<{ repository: string; error: string }>()
+    .set({ mtime: "$createdPulls.mtime" })
+    .project({ _id: 0, repository: 1, error: 1, mtime: 1 })
+    .as<{ repository: string; error: string; mtime: Date }>()
     .aggregate();
-  const csv = await sflow(pipeline)
-    .map((e, i) => ((!i && "repository,error\n") || "") + csvFormatBody([e]) + "\n")
-    .log()
-    .text();
-  await Bun.write(".cache/pr-errors.csv", csv);
+  // const csv = await sflow(pipeline)
+  //   .map((e, i) => ((!i && "repository,error\n") || "") + csvFormatBody([e]) + "\n")
+  //   .log()
+  //   .text();
+  // await Bun.write(".cache/pr-errors.csv", csv);
+  // await Bun.$`code .cache/pr-errors.csv`
+  const yml = yaml.stringify(await sflow(pipeline).toArray());
+  await Bun.write(".cache/pr-errors.yml", yml);
+  await Bun.$`code .cache/pr-errors.yml`;
 }

package/src/cli.test.ts

@@ -0,0 +1,2 @@
+// TODO: Add CLI tests
+export {};

package/src/cli.ts

@@ -1,4 +1,4 @@
-#!bun
+#!/usr/bin/env bun
 import DIE from "@snomiao/die";
 import { readFile } from "fs/promises";
 import { argv, $ as zx } from "zx";

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const UNCLAIMED_ADMIN_PUBLISHER_ID = "admin-11338bd3-f081-43cf-b3f9-295c829826f7"; // copy from https://github.com/Comfy-Org/comfy-api/blob/main/db/publisher.go#L13
+export const VERBOSE = process.env.VERBOSE;

package/src/createComfyRegistryPRsFromCandidates.ts

@@ -4,18 +4,18 @@ import { match } from "ts-pattern";
 import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
 import { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
-import { $filaten, $stale } from "./db";
-import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
-import { notifySlackLinks } from "./slack/notifySlackLinks";
+import { $flatten, $stale } from "./db";
+import { parseGithubRepoUrl, stringifyOwnerRepo } from "./parseOwnerRepo";
+import { notifySlackLinks } from "@/lib/slack/notifySlackLinks";
 import { tLog } from "./utils/tLog";
 if (import.meta.main) {
   await tLog("createComfyRegistryPRsFromCandidates", createComfyRegistryPRsFromCandidates);
   console.log("all done");
 }
 export async function createComfyRegistryPRsFromCandidates() {
-  await CNRepos.createIndex($filaten({ candidate: { data: 1 } }));
+  await CNRepos.createIndex($flatten({ candidate: { data: 1 } }));
   await CNRepos.createIndex(
-    $filaten({
+    $flatten({
       candidate: { data: 1 },
       createdPulls: { state: 1, mtime: 1 },
     }),
@@ -23,7 +23,7 @@ export async function createComfyRegistryPRsFromCandidates() {
   return await pMap(
     $pipeline(CNRepos)
       .match(
-        $filaten({
+        $flatten({
           candidate: { data: { $eq: true } },
           createdPulls: { state: { $ne: "ok" }, mtime: $stale("5m") },
         }),
@@ -32,19 +32,27 @@ export async function createComfyRegistryPRsFromCandidates() {
     async (repo) => {
       const { repository } = repo;
       console.log("Making PRs for " + repository);
-      const createdPulls = await createComfyRegistryPullRequests(repository).then(TaskOK).catch(TaskError);
+      const createdPulls = await createComfyRegistryPullRequests(repository)
+        .then(TaskOK)
+        .catch(TaskError);
       match(createdPulls).with($OK, async ({ data }) => {
         const links = data.map((e) => ({
           href: e.html_url,
-          name: stringifyOwnerRepo(parseUrlRepoOwner(e.html_url.replace(/\/pull\/.*$/, ""))) + " #" + e.title,
+          name:
+            stringifyOwnerRepo(parseGithubRepoUrl(e.html_url.replace(/\/pull\/.*$/, ""))) +
+            " #" +
+            e.title,
         }));
-        await notifySlackLinks("PR just Created, @HaoHao check plz", links);
+        await notifySlackLinks("PR Created", links);
         await pMap(data, async (pull) => {
           const { html_url } = pull;
           // also update to crPulls
-          await CNRepos.updateOne($filaten({ repository, crPulls: { data: { pull: { html_url } } } }), {
-            $set: { "crPulls.data.$.pull": pull },
-          });
+          await CNRepos.updateOne(
+            $flatten({ repository, crPulls: { data: { pull: { html_url } } } }),
+            {
+              $set: { "crPulls.data.$.pull": pull },
+            },
+          );
         });
       });
 

package/src/createComfyRegistryPullRequests.ts

@@ -1,26 +1,51 @@
+import minimist from "minimist";
 import pMap from "p-map";
-// import { chalk } from "zx";
-import { clone_modify_push_Branches } from "./clone_modify_push_Branches";
-import { createGithubForkForRepo } from "./createGithubForkForRepo";
+import { createGithubForkForRepoEx } from "./createGithubForkForRepo";
 import { createGithubPullRequest } from "./createGithubPullRequest";
-import type { GithubPull } from "./gh/GithubPull";
-import { makeUpdateTomlLicenseBranch } from "./makeUpdateTomlLicenseBranch";
+import type { GithubPull } from "@/lib/github/GithubPull";
+import { makeGpl3LicenseBranch } from "./makeGpl3LicenseBranch";
+import { makePublishcrBranch } from "./makePublishBranch";
+import { makePyprojectBranch } from "./makeTomlBranch";
 import { parsePulls } from "./parsePullsState";
+if (import.meta.main) {
+  // test repo
+  // const default_test_repo = "https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler";
+  const default_test_repo = "https://github.com/snomiao/ComfyNode-Registry-test";
+  const test_repo = minimist(process.argv.slice(2)).argv || default_test_repo;
+  console.info(await createComfyRegistryPullRequests(test_repo));
+}
 
 export async function createComfyRegistryPullRequests(upstreamRepoUrl: string) {
-  const forkedRepo = await createGithubForkForRepo(upstreamRepoUrl);
+  console.log("forking " + upstreamRepoUrl);
+  const forkedRepo = await createGithubForkForRepoEx(upstreamRepoUrl);
 
+  console.log("modifing " + forkedRepo.html_url);
   const PR_REQUESTS = await clone_modify_push_Branches(upstreamRepoUrl, forkedRepo.html_url);
-  const prs = await pMap(PR_REQUESTS, async ({ type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }));
+  const prs = await pMap(
+    PR_REQUESTS,
+    async ({ type: _type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }),
+  );
 
   console.log("Registry PRs DONE");
 
   return ([...prs] as GithubPull[]).map((e) => parsePulls([e])[0]);
 }
 
-export async function clone_modify_push_Branches_for_updateTomlLicense(upstreamUrl: string, forkUrl: string) {
-  return (await Promise.all([makeUpdateTomlLicenseBranch(upstreamUrl, forkUrl)]))
-    .flatMap((e) => (e ? [e] : []))
+/**
+ * this function will:
+ *
+ * for each branch (pyproject, publishcr)
+ * 1. clone forked srepo
+ * 2. modify on forked repo (add pyproject.toml, add .github/workflow/publish.yml)
+ * 3. commit changes, push to forked repo
+ * 4. check if all branch is ready, create PR to upstream repo
+ */
+export async function clone_modify_push_Branches(upstreamUrl: string, forkUrl: string) {
+  const pyprojectBranchInfo = makePyprojectBranch(upstreamUrl, forkUrl);
+  const publishcrBranchInfo = makePublishcrBranch(upstreamUrl, forkUrl);
+  const gpl3LicenseBranchInfo = makeGpl3LicenseBranch(upstreamUrl, forkUrl);
+  return (await Promise.all([pyprojectBranchInfo, publishcrBranchInfo, gpl3LicenseBranchInfo]))
+    .filter((info): info is NonNullable<typeof info> => info !== null)
     .map(({ body, branch, title, type }) => ({
       body,
       branch,

package/src/createGithubForkForRepo.ts

@@ -1,14 +1,22 @@
 import DIE from "@snomiao/die";
 import md5 from "md5";
 import minimist from "minimist";
+import { db } from "./db";
 import { FORK_OWNER } from "./FORK_OWNER";
 import { FORK_PREFIX } from "./FORK_PREFIX";
-import { createGithubFork } from "./gh/createGithubFork";
+import { createGithubFork } from "@/lib/github/createGithubFork";
 import { ghUser } from "./ghUser";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { parseGithubRepoUrl } from "./parseOwnerRepo";
+
+/** for cache */
+const ForkedRepo = db.collection<{ repo: string; forkedRepo: string; updatedAt: Date }>(
+  "ForkedRepo",
+);
 
 if (import.meta.main) {
-  console.log(await createGithubForkForRepo("https://github.com/comfyanonymous/ComfyUI_TensorRT"));
+  console.log(
+    await createGithubForkForRepoEx("https://github.com/comfyanonymous/ComfyUI_TensorRT"),
+  );
 }
 
 /**
@@ -22,10 +30,19 @@ if (import.meta.main) {
  * @param upstreamRepoUrl
  * @returns forked repo info
  */
-export async function createGithubForkForRepo(
-  upstreamRepoUrl: string,
-  { forkUrl = createGithubForkUrlForRepo(upstreamRepoUrl) } = {},
-) {
+export async function createGithubForkForRepoEx(upstreamRepoUrl: string, { forkUrl = "" } = {}) {
+  forkUrl ||= await createGithubForkUrlForRepo(upstreamRepoUrl);
+  const alreadyForked = await ForkedRepo.findOne({ repo: upstreamRepoUrl, forkedRepo: forkUrl });
+  if (alreadyForked) {
+    console.debug(
+      `
+Forked ${upstreamRepoUrl}
+  into ${forkUrl}
+`.trim(),
+    );
+    return { html_url: forkUrl };
+  }
+
   console.debug(
     `
 Forking ${upstreamRepoUrl}
@@ -39,15 +56,23 @@ Forking ${upstreamRepoUrl}
         "forked url not expected, it's likely you already forked this repo in your account before, and now trying to fork it again with different salt. To recovery you could delete that repo forked before by manual. (the repo forked before is listed in FORK OK: .....)",
       ),
     );
+  await ForkedRepo.updateOne(
+    { repo: upstreamRepoUrl, forkedRepo: forkUrl },
+    { $set: { updatedAt: new Date() } },
+    { upsert: true },
+  );
   return forked;
 }
-export function createGithubForkUrlForRepo(upstreamRepoUrl: string) {
+export async function createGithubForkUrlForRepo(upstreamRepoUrl: string) {
   // console.log(`* Change env.SALT=${salt} will fork into a different repo`);
-  const upstream = parseUrlRepoOwner(upstreamRepoUrl);
+  const upstream = parseGithubRepoUrl(upstreamRepoUrl);
   const argv = minimist(process.argv.slice(2));
   const salt = argv.salt || process.env.SALT || "m3KMgZ2AeZGWYh7W";
-  const repo_hash = md5(`${salt}-${ghUser.name}-${upstream.owner}/${upstream.repo}`).slice(0, 8);
-  const forkRepoName = (FORK_PREFIX && `${FORK_PREFIX}${upstream.repo}-${repo_hash}`) || upstream.repo;
+  const repo_hash = md5(
+    `${salt}-${(await ghUser()).name}-${upstream.owner}/${upstream.repo}`,
+  ).slice(0, 8);
+  const forkRepoName =
+    (FORK_PREFIX && `${FORK_PREFIX}${upstream.repo}-${repo_hash}`) || upstream.repo;
   const forkDst = `${FORK_OWNER}/${forkRepoName}`;
   const forkUrl = `https://github.com/${forkDst}`;
   return forkUrl;

package/src/createGithubPullRequest.ts

@@ -1,18 +1,19 @@
 import DIE, { catchArgs } from "@snomiao/die";
 import "git-diff";
-import { Octokit } from "octokit";
 import { pickAll } from "rambda";
 import sflow from "sflow";
 import { isRepoBypassed } from "./bypassRepos";
-import { gh } from "./gh";
-import type { GithubPull } from "./gh/GithubPull";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { createOctokit } from "@/lib/github/createOctokit";
+import { gh } from "@/lib/github";
+import type { GithubPull } from "@/lib/github/GithubPull";
+import { parseGithubRepoUrl } from "./parseOwnerRepo";
+import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
 if (import.meta.main) {
   const srcUrl = "https://github.com/ComfyNodePRs/PR-ComfyUI-DareMerge-7bcbf6a9";
   const dstUrl = "https://github.com/54rt1n/ComfyUI-DareMerge";
-  const src = parseUrlRepoOwner(srcUrl);
-  const dst = parseUrlRepoOwner(dstUrl);
-  const branch = "licence-update";
+  const src = parseGithubRepoUrl(srcUrl);
+  const dst = parseGithubRepoUrl(dstUrl);
+  const _branch = "licence-update";
   const repo = (await gh.repos.get({ ...dst })).data;
   const head_repo = `${src.owner}/${src.repo}`;
   // const head = `${src.owner}:${branch}`;
@@ -45,6 +46,21 @@ if (import.meta.main) {
     .toLog();
   console.log("all done");
 }
+export async function createPR({
+  src: srcUrl,
+  dst: dstUrl,
+  branch,
+  msg,
+}: {
+  src: string;
+  dst: string;
+  branch: string;
+  msg: string;
+}) {
+  const { title, body } = parseTitleBodyOfMarkdown(msg);
+  return (await createGithubPullRequest({ srcUrl, dstUrl, branch, title, body })).html_url;
+}
+
 export async function createGithubPullRequest({
   title,
   body,
@@ -60,42 +76,49 @@ export async function createGithubPullRequest({
   dstUrl: string; // upstream
   updateIfNotMatched?: boolean;
 }) {
+  // 2025-05-06 this function may create duplicated PR  if calling too fast with same args
+  // TODO: try grab a lock with reop+branch
   if (isRepoBypassed(dstUrl)) DIE("dst repo is requested to be bypassed");
 
-  const dst = parseUrlRepoOwner(dstUrl);
-  const src = parseUrlRepoOwner(srcUrl);
+  const dst = parseGithubRepoUrl(dstUrl);
+  const src = parseGithubRepoUrl(srcUrl);
   const repo = (await gh.repos.get({ ...dst })).data;
 
-  // TODO: seems has bugs on head_repo
-  const existedList = (
+  // 2025-03-13 prevent duplicated PR, if there are PR is closed with same content.
+  // reported here
+  // https://github.com/Chaoses-Ib/ComfyUI_Ib_CustomNodes/pulls?q=is%3Apr
+  //
+  const sameContentPRList = (
     await gh.pulls.list({
       // source repo
-      state: "all",
-      head_repo: `${src.owner}/${src.repo}`,
-      head: `${src.owner}:${branch}`,
+      // state: "open",
+      head: encodeURIComponent(`${src.owner}:${branch}`),
       // pr will merge into
       owner: dst.owner,
       repo: dst.repo,
       base: repo.default_branch,
     })
-  ).data;
-  if (existedList.length > 1)
+  ).data.filter((e) => e.title === title && e.body === body);
+
+  sameContentPRList.length <= 1 ||
     DIE(
-      new Error(`expect only 1 pr, but got ${existedList.length}`, {
-        cause: { existed: existedList.map((e) => ({ url: e.html_url, title: e.title })) },
+      new Error(`expect <= 1 same content pr, but got ${sameContentPRList.length}`, {
+        cause: {
+          sameContentPRList: sameContentPRList.map((e) => ({ url: e.html_url, title: e.title })),
+        },
       }),
     );
 
   const pr_result =
-    existedList[0] ??
-    (await ghPR()
+    // existedList[0] ??
+    await ghPR()
       .pulls.create({
         // pr info
         title,
         body,
         // source repo
-        head_repo: src.owner + "/" + src.repo,
-        head: src.owner + ":" + branch,
+        head_repo: `${src.owner}/${src.repo}`,
+        head: `${src.owner}:${branch}`,
         // pr will merge into
         owner: dst.owner,
         repo: dst.repo,
@@ -114,8 +137,8 @@ export async function createGithubPullRequest({
           await gh.pulls.list({
             // source repo
             state: "open",
-            head_repo: `${src.owner}/${src.repo}`,
-            head: `${src.owner}:${branch}`,
+            // head_repo: `${src.owner}/${src.repo}`,
+            head: encodeURIComponent(`${src.owner}:${branch}`),
             // pr will merge into
             owner: dst.owner,
             repo: dst.repo,
@@ -123,15 +146,27 @@ export async function createGithubPullRequest({
           })
         ).data; // .filter(existed => existed.title === title);
 
-        if (existedList.length !== 1)
+        if (existedList.length !== 1) {
           DIE(
             new Error("expect only 1 pr, but got " + existedList.length, {
-              cause: { existed: existedList.map((e) => ({ url: e.html_url, title: e.title })) },
+              cause: {
+                existed: existedList.map((e) => ({
+                  url: e.html_url,
+                  title: e.title,
+                })),
+                error: e,
+                state: "open",
+                head: `${src.owner}:${branch}`,
+                owner: dst.owner,
+                repo: dst.repo,
+                base: repo.default_branch,
+              },
             }),
           );
+        }
 
         return existedList[0];
-      }));
+      });
 
   console.log("PR OK", pr_result.html_url);
   const mismatch = pr_result.title !== title || pr_result.body !== body;
@@ -139,19 +174,34 @@ export async function createGithubPullRequest({
     if (!updateIfNotMatched)
       DIE(
         new Error("pr content mismatch", {
-          cause: { mismatch, expected: { title, body }, actual: pickAll(["title", "body"], pr_result) },
+          cause: {
+            mismatch,
+            expected: { title, body },
+            actual: pickAll(["title", "body"], pr_result),
+          },
         }),
       );
-    const { owner, repo } = parseUrlRepoOwner(dstUrl); // upstream repo
-    const updated = (await catchArgs(ghPR().pulls.update)({ pull_number: pr_result.number, body, title, owner, repo }))
-      .data!;
+    const { owner, repo } = parseGithubRepoUrl(dstUrl); // upstream repo
+    const updated = (
+      await catchArgs(ghPR().pulls.update)({
+        pull_number: pr_result.number,
+        body,
+        title,
+        owner,
+        repo,
+      })
+    ).data!;
     const updatedPRStillMismatch = updated.title !== title || updated.body !== body;
     if (updatedPRStillMismatch) DIE(new Error("updatedPRStillMismatch", { cause: arguments }));
-    console.warn(`PR content updated ${owner}/${repo} / \n<< ${pr_result.title}\n>> ${updated.title}`);
+    console.warn(
+      `PR content updated ${owner}/${repo} / \n<< ${pr_result.title}\n>> ${updated.title}`,
+    );
   }
   return pr_result as GithubPull;
 }
 
 function ghPR() {
-  return new Octokit({ auth: process.env.GH_TOKEN_COMFY_PR || DIE(new Error("Missing env.GH_TOKEN_COMFY_PR")) }).rest;
+  return createOctokit({
+    auth: process.env.GH_TOKEN_COMFY_PR || DIE(new Error("Missing env.GH_TOKEN_COMFY_PR")),
+  }).rest;
 }

package/src/createIssueComment.ts

@@ -1,17 +1,17 @@
 import DIE from "@snomiao/die";
-import { gh } from "./gh";
+import { gh } from "@/lib/github";
 import { ghUser } from "./ghUser";
 import { parseIssueUrl } from "./parseIssueUrl";
 
 if (import.meta.main) {
   // const url = "https://github.com/snomiao/ComfyNode-Registry-test/pull/1";
   // const body = "Hello World @snomiao";
-  // const result = await createIssueComment(url, body, ghUser.login);
+  // const result = await createIssueComment(url, body, (await ghUser()).login);
   // console.log(result.comment.html_url);
   // console.log(result.comments.map((e) => e.html_url));
   const url = "https://github.com/snomiao/ComfyNode-Registry-test/pull/28";
   const body = "Hello World @robinjhuang";
-  const result = await createIssueComment(url, body, ghUser.login);
+  const result = await createIssueComment(url, body, (await ghUser()).login);
   console.log(result.comment.html_url);
   console.log(result.comments.map((e) => e.html_url));
 }
@@ -25,7 +25,7 @@ export async function createIssueComment(issueUrl: string, body: string, by: str
   const result = await (async function () {
     const commentExisted = comments.find((e) => e.body === body);
     if (commentExisted) return { comment: commentExisted, comments };
-    if (by !== ghUser.login) DIE("Fails to creating issue: user not match");
+    if (by !== (await ghUser()).login) DIE("Fails to creating issue: user not match");
     const comment = (await gh.issues.createComment({ ...parseIssueUrl(issueUrl), body })).data;
     console.log("+ IssueComment " + comment.html_url);
     return { comment, comments: [...comments, comment] };

package/src/fetchComfyRegistryNodes.ts

@@ -1,11 +1,41 @@
-import type { mockPublishedNodes } from "../mocks/mockPublishedNodes";
 import DIE from "@snomiao/die";
+import type { mockPublishedNodes } from "../mocks/mockPublishedNodes";
 import { fetchJson } from "./utils/fetchJson";
 
-export async function fetchCRNodes() {
+export async function fetchCRNodes(): Promise<
+  {
+    author: string;
+    description: string;
+    icon: string;
+    id: string;
+    latest_version: {
+      changelog: string;
+      createdAt: string;
+      dependencies: never[];
+      deprecated: boolean;
+      id: string;
+      version: string;
+    };
+    license: string;
+    name: string;
+    publisher: {
+      createdAt: string;
+      description: string;
+      id: string;
+      logo: string;
+      members: never[];
+      name: string;
+      source_code_repo: string;
+      support: string;
+      website: string;
+    };
+    repository: string;
+    tags: never[];
+  }[]
+> {
   const r = (await fetchJson<typeof mockPublishedNodes>(
-    "https://api.comfy.org/nodes?page=1&limit=99999999"
+    "https://api.comfy.org/nodes?page=1&limit=99999999",
   )) as typeof mockPublishedNodes;
-  r.totalPages === 1 || DIE("FAIL TO FETCH ALL NODES");
+  if (r.totalPages !== 1) DIE("FAIL TO FETCH ALL NODES");
   return r.nodes;
 }

package/src/fetchCurrentGeoInfo.ts

@@ -1,6 +1,8 @@
 import { fetchJson } from "./utils/fetchJson";
 export async function fetchCurrentGeoInfo() {
-  const { query, city, iat, lon, countryCode, region, regionName } = (await fetchJson("http://ip-api.com/json")) as any;
+  const { query, city, iat, lon, countryCode, region, regionName } = (await fetchJson(
+    "http://ip-api.com/json",
+  )) as Record<string, unknown>;
   const geo = { ip: query, city, iat, lon, countryCode, region, regionName };
   return geo;
 }

package/src/fetchRelatedPullWithComments.ts

@@ -1,5 +1,5 @@
 import pMap from "p-map";
-import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { fetchIssueComments } from "@/lib/github/fetchIssueComments";
 import { matchRelatedPulls } from "./matchRelatedPulls";
 import type { GithubPullParsed } from "./parsePullsState";
 import { summaryLastPullComment } from "./summaryLastPullComment";

package/src/fetchRepoDescriptionMap.ts

@@ -1,12 +1,9 @@
 import { fromPairs } from "rambda";
 import { fetchCMNodes } from "./fetchCMNodes";
 
-
 export async function fetchRepoDescriptionMap() {
   const nodeList = await fetchCMNodes();
-  const repoDescriptionMap = fromPairs(
-    nodeList.map((e) => [e.reference, e.description])
-  );
+  const repoDescriptionMap = fromPairs(nodeList.map((e) => [e.reference, e.description]));
   repoDescriptionMap["https://github.com/snomiao/ComfyNode-Registry-test"] =
     "ComfyNode-Registry-test-description";
 

package/src/followRuleSchema.ts

@@ -2,7 +2,9 @@ import { $before, $fresh, $stale } from "@/packages/mongodb-pipeline-ts/$fresh";
 import { tryCatch } from "rambda";
 import { z } from "zod";
 
-const znot_include = z.object({ "not-include": z.string() }).transform((x) => ({ $nin: x["not-include"] }));
+const znot_include = z
+  .object({ "not-include": z.string() })
+  .transform((x) => ({ $nin: x["not-include"] }));
 const mString = z.string().transform((x) =>
   tryCatch<string, string | RegExp>(
     (x) => new RegExp(x) as RegExp,
@@ -12,8 +14,12 @@ const mString = z.string().transform((x) =>
 const zbefore = z
   .object({ $before: z.coerce.date().or(z.string()).or(z.number()) })
   .transform((x) => $before(x.$before));
-const zfresh = z.object({ $fresh: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $fresh(x.$fresh));
-const mstale = z.object({ $stale: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $stale(x.$stale));
+const zfresh = z
+  .object({ $fresh: z.coerce.date().or(z.string()).or(z.number()) })
+  .transform((x) => $fresh(x.$fresh));
+const mstale = z
+  .object({ $stale: z.coerce.date().or(z.string()).or(z.number()) })
+  .transform((x) => $stale(x.$stale));
 const mDate = z.date().or(zbefore).or(zfresh).or(mstale);
 const mAny = z.number().or(znot_include).or(mString).or(zbefore).or(zfresh);
 const mNumber = z
@@ -70,7 +76,7 @@ const zFollowUpRule = z.object({
           tags: mAny,
         })
         .strict(),
-      // close: z.any(),
+      // close: z.unknown(),
     })
     .strict()
     .partial(),

package/src/getBranchWorkingDir.ts

@@ -1,13 +1,9 @@
 import { rm } from "fs/promises";
 import { getRepoWorkingDir } from "./getRepoWorkingDir";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { parseGithubRepoUrl } from "./parseOwnerRepo";
 
-export async function getBranchWorkingDir(
-  upstreamUrl: string,
-  forkUrl: string,
-  branch: string
-) {
-  const src = parseUrlRepoOwner(upstreamUrl);
+export async function getBranchWorkingDir(upstreamUrl: string, forkUrl: string, branch: string) {
+  const src = parseGithubRepoUrl(upstreamUrl);
   const dir = getRepoWorkingDir(forkUrl);
   const packageName = src.repo;
   const cwd = `${dir}/${branch}/${packageName}`;

package/src/getRepoWorkingDir.ts

@@ -1,6 +1,5 @@
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { parseGithubRepoUrl } from "./parseOwnerRepo";
 
 export function getRepoWorkingDir(forkUrl: string) {
-  return `prs/${parseUrlRepoOwner(forkUrl).repo}`;
+  return `prs/${parseGithubRepoUrl(forkUrl).repo}`;
 }
-