comfy-pr 0.2.26 → 1.0.1

package/src/CNRepos.ts

@@ -4,15 +4,14 @@ bun index.ts
 */
 import type { ObjectId, WithId } from "mongodb";
 import "react-hook-form";
-import { nil } from "sflow";
 import { type Task } from "../packages/mongodb-pipeline-ts/Task";
 import { type CMNode } from "./CMNodes";
 import { type CRNode } from "./CRNodes";
 import { db } from "./db";
-import { gh } from "./gh";
+import { gh } from "@/lib/github";
 import { type RelatedPull } from "./matchRelatedPulls";
 import type { GithubPullParsed } from "./parsePullsState";
-import { type SlackMsg } from "./slack/SlackMsgs";
+import { type SlackMsg } from "@/lib/slack/SlackMsgs";
 
 type Email = {
   from?: string;
@@ -21,7 +20,7 @@ type Email = {
   to: string;
 };
 
-type Sent = {
+type _Sent = {
   slack?: SlackMsg;
   emails?: Email[];
 };
@@ -39,7 +38,9 @@ export type CRPull = RelatedPull & {
 };
 // TODO: refactor into interface to improve performance
 export type CustomNodeRepo = {
+  // github url
   repository: string;
+
   info?: Task<Pick<GithubRepo, "html_url" | "archived" | "default_branch" | "private">>;
 
   // author?: Author;
@@ -48,7 +49,9 @@ export type CustomNodeRepo = {
   cr?: Pick<WithId<CRNode>, "_id" | "id" | "name">;
 
   cr_ids?: ObjectId[];
-  on_registry?: Task<boolean>; // check if cr_ids is not empty
+
+  on_registry?: Task<boolean>; // check if cr_ids is not empty, exclude publisher.id === ADMIN
+  on_registry_all?: Task<boolean>; // check if cr_ids is not empty, including  publisher.id === ADMIN
 
   /** @deprecated use cm_ids */
   cm?: Pick<WithId<CMNode>, "_id" | "id" | "title">;
@@ -66,13 +69,33 @@ export type CustomNodeRepo = {
   // createFork?: Task<GithubRepo>;
   // createBranches?: Task<{ type: CRType; assigned: Worker } & PushedBranch>[];
 
-  /** @deprecated use CRPulls.pull */
+  /** TODO: @deprecated use CRPulls.pull */
   createdPulls?: Task<GithubPullParsed[]>;
 };
 export type CNRepo = CustomNodeRepo;
 export const CNRepos = db.collection<CNRepo>("CNRepos");
 
-CNRepos.createIndex({ repository: 1 }, { unique: true }).catch(nil);
+CNRepos.createIndex({ repository: 1 }, { unique: true }).catch(() => {});
+
+// Performance optimization: compound index for complex state + mtime queries
+// This index improves queries filtering by multiple state and mtime fields
+// Target query: aggregate with $match on crPulls.state, info.state, and various mtime fields
+CNRepos.createIndex(
+  {
+    "crPulls.state": 1,
+    "info.state": 1,
+    "crPulls.mtime": 1,
+    "info.mtime": 1,
+    "candidate.mtime": 1,
+  },
+  {
+    name: "idx_states_mtimes",
+    background: true,
+  },
+).catch(() => {});
+
+// Note: pulls.mtime index is created by setup-performance-indexes.ts script
+// Run: bun run db:setup-indexes
 
 // fix cr null, it should be not exists
 // await CNRepos.updateMany({ cr: null as unknown as WithId<CRNode> }, { $unset: { cr: 1 } });

package/src/CRNodes.ts

@@ -1,11 +1,11 @@
 import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
 import type { ObjectId } from "mongodb";
-import pMap from "p-map";
 import { peekYaml } from "peek-log";
+import { sf } from "sflow";
 import { CNRepos } from "./CNRepos";
 import { db } from "./db";
 import { fetchCRNodes } from "./fetchComfyRegistryNodes";
-import { type SlackMsg } from "./slack/SlackMsgs";
+import { type SlackMsg } from "@/lib/slack/SlackMsgs";
 
 export type CRNode = Awaited<ReturnType<typeof fetchCRNodes>>[number] & {
   sent?: { slack?: SlackMsg };
@@ -16,12 +16,14 @@ await CRNodes.createIndex({ id: 1 }, { unique: true });
 await CRNodes.createIndex({ repository: 1 }, { unique: false }); // WARN: duplicate is allowed
 
 if (import.meta.main) {
-  const r = await pMap(
-    $pipeline(CNRepos)
-      .match({ cr: { $exists: true } })
-      .replaceRoot({ newRoot: "$cr" })
-      .aggregate(),
-    (e) => e,
-  );
+  // peek cr nodes
+  const r = await sf
+    .sflow(
+      $pipeline(CNRepos)
+        .match({ cr: { $exists: true } })
+        .replaceRoot({ newRoot: "$cr" })
+        .aggregate(),
+    )
+    .toArray();
   peekYaml({ r, len: r.length });
 }

package/src/CRPulls.ts

@@ -1,4 +1,7 @@
 import type { CRPull } from "./CNRepos";
 import { db } from "./db";
 
+/**
+ * @deprecated todo: utillize this collection @sno
+ */
 export const CRPulls = db.collection<CRPull>("CRPulls");

package/src/EmailTasks.ts

@@ -1,7 +1,7 @@
 import DIE from "@snomiao/die";
 import markdownIt from "markdown-it";
 import type { WithId } from "mongodb";
-import { sf } from "snoflow";
+import { sf } from "sflow";
 import type { z } from "zod";
 import { $stale, db } from "./db";
 import type { zSendEmailAction } from "./followRuleSchema";
@@ -25,10 +25,10 @@ export const EmailTasks = db.collection<EmailTask>("EmailTasks");
 await EmailTasks.createIndex({ from: 1, to: 1, subject: 1 });
 
 if (import.meta.main) {
-  sf(EmailTasks.find({}))
+  sf.sflow(EmailTasks.find({}))
     .map((e) => e.state)
     .toLog();
-  // sf(EmailTasks.watch([], { fullDocument: "whenAvailable" }))
+  // sf.sflow(EmailTasks.watch([], { fullDocument: "whenAvailable" }))
   //   // .filter((c) => c.operationType === "modify")
   //   .toLog()
   //   .then(() => console.log("all done"));
@@ -54,7 +54,7 @@ if (import.meta.main) {
  * deduplicated by [from, to, subject].join(' ')
  */
 export async function enqueueEmailTask(task: z.infer<typeof zSendEmailAction>) {
-  const { name, from, to, subject, body, provider } = task;
+  const { name: _name, from, to, subject, body: _body, provider: _provider } = task;
   return (
     (await EmailTasks.findOneAndUpdate(
       { from, to, subject },
@@ -64,8 +64,9 @@ export async function enqueueEmailTask(task: z.infer<typeof zSendEmailAction>) {
   );
 }
 export async function updateEmailTasks() {
-  const count = await sf(EmailTasks.find({ state: "waiting" }))
-    .join(sf(EmailTasks.find({ state: "sending", mtime: $stale("1m") })))
+  const count = await sf
+    .sflow(EmailTasks.find({ state: "waiting" }))
+    .merge(sf.sflow(EmailTasks.find({ state: "sending", mtime: $stale("1m") })))
     .map(async (e) => {
       const { _id, state } = e;
       if (state === "waiting") {
@@ -73,21 +74,38 @@ export async function updateEmailTasks() {
         return await sendEmailTask(e)
           .then(() => EmailTasks.updateOne({ _id }, { $set: { mtime: new Date(), state: "sent" } }))
           .catch((err) =>
-            EmailTasks.updateOne({ _id }, { $set: { mtime: new Date(), state: "error", error: String(err) } }),
+            EmailTasks.updateOne(
+              { _id },
+              { $set: { mtime: new Date(), state: "error", error: String(err) } },
+            ),
           );
       }
     })
     .toCount();
   console.log(count, "email tasks processed");
 }
-export async function sendEmailTask({ _id, state, name, from, to, subject, body, provider }: WithId<EmailTask>) {
+export async function sendEmailTask({
+  _id,
+  state: _state,
+  name,
+  from,
+  to,
+  subject,
+  body,
+  provider,
+}: WithId<EmailTask>) {
   // prerequisites
   if (provider !== "google") DIE("providers other than google is implemented yet");
   const auth = await getGCloudOAuth2Client({
     email: from,
     scope: ["https://www.googleapis.com/auth/gmail.compose"],
     authorize: async (url) =>
-      DIE("ERROR: Trying send email from " + from + " but it's not authorized, plz grant permission in " + url),
+      DIE(
+        "ERROR: Trying send email from " +
+          from +
+          " but it's not authorized, plz grant permission in " +
+          url,
+      ),
   });
   // do send
   return sendGmail({

package/src/FORK_OWNER.ts

@@ -2,4 +2,6 @@ import DIE from "@snomiao/die";
 import { ghUser } from "./ghUser";
 
 export const FORK_OWNER =
-  process.env.FORK_OWNER?.replace(/"/g, "")?.trim() || ghUser.login || DIE("Missing env.FORK_OWNER");
+  process.env.FORK_OWNER?.replace(/"/g, "")?.trim() ||
+  (await ghUser()).login ||
+  DIE("Missing env.FORK_OWNER");

package/src/FollowRules.ts

@@ -15,11 +15,11 @@ export type FollowRuleSet = {
   matched?: Task<PullsStatus>;
   action_results?: {
     name: string;
-    action: any;
-    result: Task<any>;
+    action: unknown;
+    result: Task<unknown>;
   }[];
   enabled?: boolean;
   yamlWhenEnabled?: string;
 };
 export const FollowRuleSets = db.collection<FollowRuleSet>("FollowRuleSets");
-await FollowRuleSets.createIndex("name", { unique: true });
+FollowRuleSets.createIndex("name", { unique: true }).catch(() => null);

package/src/GithubIssueComments.ts

@@ -1,3 +1,3 @@
-import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { fetchIssueComments } from "@/lib/github/fetchIssueComments";
 
 export type GithubIssueComment = Awaited<ReturnType<typeof fetchIssueComments>>[number];

package/src/Totals.ts

@@ -1,6 +1,6 @@
 import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
 import { flatten } from "flat";
-import { sf } from "snoflow";
+import { sf } from "sflow";
 import { type Task } from "../packages/mongodb-pipeline-ts/Task";
 import { analyzeTotals } from "./analyzeTotals";
 import { db } from "./db";
@@ -12,13 +12,14 @@ export const Totals = db.collection<{
   totals?: Task<Totals>;
 }>("Totals");
 if (import.meta.main) {
-  sf(
-    $pipeline(Totals)
-      .match({ "totals.data": { $exists: true } })
-      .set({ "totals.data.date": "$totals.mtime" })
-      .replaceRoot({ newRoot: "$totals.data" })
-      .aggregate(),
-  )
+  await sf
+    .sflow(
+      $pipeline(Totals)
+        .match({ "totals.data": { $exists: true } })
+        .set({ "totals.data.date": "$totals.mtime" })
+        .replaceRoot({ newRoot: "$totals.data" })
+        .aggregate(),
+    )
     .map((e) => flatten(e) as { date: string } & Record<string, number>)
     .toLog();
 }

package/src/WorkerInstances.ts

@@ -2,9 +2,12 @@ import { getMAC } from "@ctrl/mac-address";
 import { defer } from "lodash-es";
 import md5 from "md5";
 import type { WithId } from "mongodb";
-import { db } from "./db";
+import sflow from "sflow";
+import { $fresh, db } from "./db";
 import { fetchCurrentGeoInfo } from "./fetchCurrentGeoInfo";
 import { createInstanceId } from "./utils/createInstanceId";
+import { yaml } from "./utils/yaml";
+
 export type GeoInfo = Awaited<ReturnType<typeof fetchCurrentGeoInfo>>;
 export type WorkerInstance = {
   /** id: rand */
@@ -14,26 +17,43 @@ export type WorkerInstance = {
   geo: GeoInfo;
   workerId: string;
   task?: string;
+  tasks?: string[];
 };
 
 const k = "COMFY_PR_WorkerInstanceKey";
-type g = typeof globalThis & { [k]: any };
+const g = globalThis as typeof globalThis & { [k]: string };
 function getWorkerInstanceId() {
   // ensure only one instance
-  if (!(global as any as g)[k])
+  if (!g[k])
     defer(async function () {
       await Promise.all([postWorkerHeartBeatLoop(), watchWorkerInstancesLoop()]);
     });
-  const instanceId = ((global as any as g)[k] ??= createInstanceId());
+  const instanceId = (g[k] ??= createInstanceId());
   return instanceId;
 }
 export const WorkerInstances = db.collection<WorkerInstance>("WorkerInstances");
-await WorkerInstances.createIndex({ id: 1 }, { unique: true });
-await WorkerInstances.createIndex({ ip: 1 });
-export const _geoPromise = fetchCurrentGeoInfo(); // in background
+let _geoPromise: Promise<GeoInfo> | undefined;
+function getGeoPromise() {
+  if (!_geoPromise) {
+    _geoPromise = fetchCurrentGeoInfo();
+  }
+  return _geoPromise;
+}
 
 if (import.meta.main) {
+  await WorkerInstances.createIndex({ id: 1 }, { unique: true });
+  await WorkerInstances.createIndex({ ip: 1 });
   console.log(await getWorkerInstance());
+  console.log(
+    await sflow(
+      WorkerInstances.watch([{ $match: { up: $fresh("5min") } }], {
+        fullDocument: "whenAvailable",
+      }),
+    )
+      .map((e) => yaml.stringify(e))
+      .log()
+      .run(),
+  );
 }
 
 async function postWorkerHeartBeatLoop() {
@@ -75,9 +95,12 @@ export async function getWorkerInstance(task?: string) {
         id,
         active: new Date(),
         workerId: getWorkerId(),
-        geo: await _geoPromise,
+        geo: await getGeoPromise(),
         ...(task && { task }),
       },
+      $addToSet: {
+        ...(task && { tasks: task }),
+      },
       $setOnInsert: { up: new Date() },
     },
     { upsert: true, returnDocument: "after" },

package/src/addCommentAction.ts

@@ -8,11 +8,11 @@ import type { z } from "zod";
 import type { PullStatusShown } from "./analyzePullsStatus";
 import { CNRepos, type CRPull } from "./CNRepos";
 import { createIssueComment } from "./createIssueComment";
-import { $filaten } from "./db";
+import { $flatten } from "./db";
 import type { zAddCommentAction } from "./followRuleSchema";
 import { ghUser } from "./ghUser";
 import type { GithubIssueComment } from "./GithubIssueComments";
-import { notifySlackLinks } from "./slack/notifySlackLinks";
+import { notifySlackLinks } from "@/lib/slack/notifySlackLinks";
 
 export async function addCommentAction({
   matched,
@@ -32,14 +32,15 @@ export async function addCommentAction({
         action: "add-comment",
         url: payload.url,
         by: action.by,
-        body: action.body.replace(
-          /{{\$([_A-Za-z0-9]+)}}/g,
-          (_, key: string) =>
-            (payload as any)[key] || DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
+        body: action.body.replace(/{{\$([_A-Za-z0-9]+)}}/g, (_, key: string) =>
+          String(
+            (payload as Record<string, unknown>)[key] ??
+              DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
+          ),
         ),
       };
 
-      if (runAction && loadedAction.by === ghUser.login) {
+      if (runAction && loadedAction.by === (await ghUser()).login) {
         const existedCommentsTask =
           (await $pipeline(CNRepos)
             .unwind("$crPulls.data")
@@ -48,7 +49,8 @@ export async function addCommentAction({
             .replaceRoot({ newRoot: "$crPulls.data.comments" })
             .as<Task<GithubIssueComment[]>>()
             .aggregate()
-            .next()) ?? DIE("comments is not fetched before, plz check " + loadedAction.url + " in CNRepos");
+            .next()) ??
+          DIE("comments is not fetched before, plz check " + loadedAction.url + " in CNRepos");
 
         const existedComments =
           TaskDataOrNull(existedCommentsTask) ??
@@ -56,13 +58,19 @@ export async function addCommentAction({
         const existedComment = existedComments.find((e) => e.body === loadedAction.body);
 
         if (!existedComment) {
-          const { comments, comment } = await createIssueComment(loadedAction.url, loadedAction.body, loadedAction.by);
+          const { comments, comment } = await createIssueComment(
+            loadedAction.url,
+            loadedAction.body,
+            loadedAction.by,
+          );
           const updateResult = await CNRepos.updateOne(
-            $filaten({ crPulls: { data: $elemMatch({ pull: { html_url: loadedAction.url } }) } }),
+            $flatten({ crPulls: { data: $elemMatch({ pull: { html_url: loadedAction.url } }) } }),
             { $set: { "crPulls.data.$.comments": comments } },
           );
           if (!updateResult.matchedCount) DIE("created issue not matched");
-          await notifySlackLinks("A New issue comment are created from rule " + rule.name, [comment.html_url]);
+          await notifySlackLinks("A New issue comment are created from rule " + rule.name, [
+            comment.html_url,
+          ]);
         }
       }
 

package/src/analyzePullsStatus.ts

@@ -1,7 +1,7 @@
 import { $pipeline, type Pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
 import type { ObjectId } from "mongodb";
 import prettyMs from "pretty-ms";
-import { snoflow } from "snoflow";
+import { sflow } from "sflow";
 import type { z } from "zod";
 import type { Task } from "../packages/mongodb-pipeline-ts/Task";
 import type { Author } from "./Authors";
@@ -14,7 +14,7 @@ import type { zPullStatus } from "./zod/zPullsStatus";
 // import { $pipeline } from "./db/$pipeline";
 // in case of dump production in local environment:
 // bun --env-file .env.production.local src/dump.ts > dump.csv
-export const DashboardDetails = db.collection<any>("DashboardDetails");
+export const DashboardDetails = db.collection<Record<string, unknown>>("DashboardDetails");
 if (import.meta.main) {
   // const r = peekYaml(await analyzePullsStatus());
 
@@ -26,7 +26,7 @@ if (import.meta.main) {
   // await writeFile("src/zPullsStatus.ts", jsonToZod(await analyzePullsStatus({ limit: 1 }), "zPullsStatus", true));
 
   // analyzePullsStatusPipeline
-  await snoflow(analyzePullsStatusPipeline().aggregate())
+  await sflow(analyzePullsStatusPipeline().aggregate())
     .filter((e) => e.email)
     .limit(2)
     .map((e) => yaml.stringify({ e }))
@@ -40,23 +40,37 @@ export type PullStatus = z.infer<typeof zPullStatus>;
 export type PullsStatus = PullStatus[];
 export type PullStatusShown = Awaited<ReturnType<typeof analyzePullsStatus>>[number];
 
-export async function analyzePullsStatus({ skip = 0, limit = 0, pipeline = analyzePullsStatusPipeline() } = {}) {
+export async function analyzePullsStatus({
+  skip = 0,
+  limit = 0,
+  pipeline = analyzePullsStatusPipeline(),
+} = {}) {
   "use server";
   return await pipeline
     .skip(skip)
     .limit(limit || 2 ** 31 - 1)
     .aggregate()
-    .map(({ updated_at, created_at, actived_at, on_registry_at, ...pull }) => {
-      const pull_updated = prettyMs(+new Date() - +new Date(updated_at), { compact: true }) + " ago";
-      const repo_updated = prettyMs(+new Date() - +new Date(actived_at), { compact: true }) + " ago";
-      return {
-        updated: pull_updated, // @deprecated
-        pull_updated,
-        repo_updated,
-        ...pull,
-        lastcomment: pull.lastcomment?.replace(/\s+/g, " ").replace(/\*\*\*.*/g, "..."),
-      };
-    })
+    .map(
+      ({
+        updated_at,
+        created_at: _created_at,
+        actived_at,
+        on_registry_at: _on_registry_at,
+        ...pull
+      }) => {
+        const pull_updated =
+          prettyMs(+new Date() - +new Date(updated_at), { compact: true }) + " ago";
+        const repo_updated =
+          prettyMs(+new Date() - +new Date(actived_at), { compact: true }) + " ago";
+        return {
+          updated: pull_updated, // @deprecated
+          pull_updated,
+          repo_updated,
+          ...pull,
+          lastcomment: pull.lastcomment?.replace(/\s+/g, " ").replace(/\*\*\*.*/g, "..."),
+        };
+      },
+    )
     .toArray();
 }
 export function baseCRPullStatusPipeline(): Pipeline<
@@ -71,7 +85,11 @@ export function baseCRPullStatusPipeline(): Pipeline<
   return (
     $pipeline(CNRepos)
       // get latest pr comments time
-      .set({ "crPulls.data.pull.latest_comment_at": { $max: { $max: "$crPulls.data.comments.data.updated_at" } } })
+      .set({
+        "crPulls.data.pull.latest_comment_at": {
+          $max: { $max: "$crPulls.data.comments.data.updated_at" },
+        },
+      })
       // unwind
       .stage({ $unwind: "$crPulls.data" })
       .match({ "crPulls.data.comments.data": { $exists: true } })
@@ -145,7 +163,11 @@ export function analyzePullsStatusPipeline(): Pipeline<{
       .project({ authors: 0 })
 
       .set({ lastcomment: { $arrayElemAt: ["$comments", -1] } })
-      .set({ lastcomment: { $ifNull: [{ $concat: ["$lastcomment.user.login", ": ", "$lastcomment.body"] }, ""] } })
+      .set({
+        lastcomment: {
+          $ifNull: [{ $concat: ["$lastcomment.user.login", ": ", "$lastcomment.body"] }, ""],
+        },
+      })
 
       // calculate update_at max( )
       // date format convert

package/src/analyzeTotals.ts

@@ -4,8 +4,9 @@ import promiseAllProperties from "promise-all-properties";
 import YAML from "yaml";
 import { CMNodes } from "./CMNodes";
 import { CNRepos } from "./CNRepos";
+import { UNCLAIMED_ADMIN_PUBLISHER_ID } from "./constants";
 import { CRNodes } from "./CRNodes";
-import { $filaten } from "./db";
+import { $flatten } from "./db";
 import { tLog } from "./utils/tLog";
 
 if (import.meta.main) {
@@ -24,23 +25,30 @@ export async function analyzeTotals() {
     "Total Nodes": promiseAllProperties({
       "on ComfyUI Manager": CMNodes.estimatedDocumentCount(),
       "on Registry": CRNodes.estimatedDocumentCount(),
+      "on Registry (exclude unclaimed)": CRNodes.countDocuments({
+        "publisher.id": { $ne: UNCLAIMED_ADMIN_PUBLISHER_ID },
+      } as Record<string, unknown>),
     }),
     "Total Repos": $pipeline(CNRepos)
       .group({
         _id: null,
-        "on Comfy Manager List": { $sum: { $cond: [{ $eq: [{ $type: "$cm" }, "missing"] }, 0, 1] } },
+        "on Comfy Manager List": {
+          $sum: { $cond: [{ $eq: [{ $type: "$cm" }, "missing"] }, 0, 1] },
+        },
         "on Registry": { $sum: { $cond: [{ $eq: [{ $type: "$cr" }, "missing"] }, 0, 1] } },
         Archived: { $sum: { $cond: ["$info.data.archived", 1, 0] } },
         All: { $sum: 1 },
         // Candidates: { $sum: { $cond: ["$candidate.data", 1, 0] } },
-        "Got ERROR on creating PR": { $sum: { $cond: [{ $eq: ["$createdPulls.state", "error"] }, 1, 0] } },
+        "Got ERROR on creating PR": {
+          $sum: { $cond: [{ $eq: ["$createdPulls.state", "error"] }, 1, 0] },
+        },
       })
       .project({ _id: 0 })
       .aggregate()
-      // .map((e: any) => e.pairs)
+      // .map((e: unknown) => e.pairs)
       .next(),
     "Total Authors": $pipeline(CNRepos)
-      .match($filaten({ info: { data: { owner: { login: { $exists: true } } } } }))
+      .match($flatten({ info: { data: { owner: { login: { $exists: true } } } } }))
       .group({
         _id: "$info.data.owner.login",
         // author: "$info.data.owner.login",
@@ -57,7 +65,7 @@ export async function analyzeTotals() {
       })
       .project({ _id: 0 })
       .aggregate()
-      // .map((e: any) => e.pairs)
+      // .map((e: unknown) => e.pairs)
       .next(),
     "Total PRs Made": $pipeline(CNRepos)
       .unwind("$crPulls.data")
@@ -66,7 +74,7 @@ export async function analyzeTotals() {
       .set({ id_total: [["$_id", "$total"]] })
       .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
       .aggregate()
-      .map((e: any) => e.pairs)
+      .map((e: unknown) => (e as { pairs?: unknown }).pairs)
       .next(),
     "Total Open": $pipeline(CNRepos)
       .unwind("$crPulls.data")
@@ -76,7 +84,7 @@ export async function analyzeTotals() {
       .set({ id_total: [["$_id", "$total"]] })
       .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
       .aggregate()
-      .map((e: any) => e.pairs)
+      .map((e: unknown) => (e as { pairs?: unknown }).pairs)
       .next(),
     "Total Merged (on Registry)": $pipeline(CNRepos)
       .unwind("$crPulls.data")
@@ -86,7 +94,7 @@ export async function analyzeTotals() {
       .set({ id_total: [["$_id", "$total"]] })
       .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
       .aggregate()
-      .map((e: any) => e.pairs)
+      .map((e: unknown) => (e as { pairs?: unknown }).pairs)
       .next(),
     "Total Merged (not on Registry)": $pipeline(CNRepos)
       .unwind("$crPulls.data")
@@ -96,7 +104,7 @@ export async function analyzeTotals() {
       .set({ id_total: [["$_id", "$total"]] })
       .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
       .aggregate()
-      .map((e: any) => e.pairs)
+      .map((e: unknown) => (e as { pairs?: unknown }).pairs)
       .next(),
     "Total Closed": $pipeline(CNRepos)
       .unwind("$crPulls.data")
@@ -106,7 +114,7 @@ export async function analyzeTotals() {
       .set({ id_total: [["$_id", "$total"]] })
       .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
       .aggregate()
-      .map((e: any) => e.pairs)
+      .map((e: unknown) => (e as { pairs?: unknown }).pairs)
       .next(),
 
     // // Follow Rules

package/src/bypassRepos.ts

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { yaml } from "./utils/yaml";
 
-export const bypassRepos = z
-  .string()
-  .array()
-  .parse(yaml.parse(await Bun.file("./bypass.yaml").text()).bypass_repos);
-export const isRepoBypassed = (repo: string) => bypassRepos.some((reg) => repo.match(reg));
+export const { ignore_repos } = z
+  .object({
+    ignore_repos: z.string().array(),
+  })
+  .parse(yaml.parse(await Bun.file("./comfypr-ignore.yaml").text()));
+export const isRepoBypassed = (repo: string) => ignore_repos.some((reg) => repo.match(reg));