Merge pull request #48 from Comfy-Org/sno-bugcop-dont-set-answered

refactor(gh-bugcop): remove ANSWERED_LABEL management and improve label handling

Author: snomiao

app/tasks/gh-bugcop/GithubBugcopTaskStatus.tsx

@@ -5,7 +5,7 @@ import prettyMilliseconds from "pretty-ms";
 import { useEffect, useState } from "react";
 import sflow from "sflow";
 import useAsyncEffect from "use-async-effect";
-import { ASKING_LABEL, GithubBugcopTask } from "./gh-bugcop";
+import { BUGCOP_ANSWERED, BUGCOP_ASKING_FOR_INFO, BUGCOP_RESPONSE_RECEIVED, GithubBugcopTask } from "./gh-bugcop";
 
 if (import.meta.main) render(<GithubBugcopTaskStatus />);
 
@@ -16,8 +16,9 @@ export default function GithubBugcopTaskStatus({}) {
 
   // Color mappers
   const getStatusColor = (labels?: string[]) => {
-    if (labels?.includes(ASKING_LABEL)) return "yellow";
-    // if (labels?.includes(ANSWERED_LABEL)) return "green";
+    if (labels?.includes(BUGCOP_ASKING_FOR_INFO)) return "yellow";
+    if (labels?.includes(BUGCOP_ANSWERED)) return "blue";
+    if (labels?.includes(BUGCOP_RESPONSE_RECEIVED)) return "green";
     return "red";
   };
 

app/tasks/gh-bugcop/gh-bugcop.tsx

@@ -1,3 +1,4 @@
+#!/usr/bin/env bun --watch
 /**
  * Github Bugcop Bot
  * 1. bot matches issues for label "bug-cop:ask-for-info"
@@ -10,13 +11,16 @@ import { TaskMetaCollection } from "@/src/db/TaskMeta";
 import { gh, type GH } from "@/src/gh";
 import { parseIssueUrl } from "@/src/parseIssueUrl";
 import { parseUrlRepoOwner } from "@/src/parseOwnerRepo";
+import KeyvSqlite from "@keyv/sqlite";
 import DIE from "@snomiao/die";
 import chalk from "chalk";
 import { compareBy } from "comparing";
 import fastDiff from "fast-diff";
+import { mkdir } from "fs/promises";
 import hotMemo from "hot-memo";
 import isCI from "is-ci";
-import { difference, union } from "rambda";
+import Keyv from "keyv";
+import { union } from "rambda";
 import sflow, { pageFlow } from "sflow";
 import z from "zod";
 import { createTimeLogger } from "../gh-design/createTimeLogger";
@@ -28,12 +32,23 @@ export const REPOLIST = [
   "https://github.com/Comfy-Org/ComfyUI_frontend",
   "https://github.com/Comfy-Org/desktop",
 ];
-export const ASKING_LABEL = "bug-cop:ask-for-info";
-// export const ANSWERED_LABEL = "bug-cop:answered"; // 2025-08-09 “answered” is never managed by bot
-export const RESPONSE_RECEIVED_LABEL = "bug-cop:response-received";
+await mkdir("./.cache", { recursive: true });
+const kv = new Keyv({ store: new KeyvSqlite("sqlite://.cache/bugcop-cache.sqlite") });
+function createKeyvCachedFn<FN extends (...args: any[]) => Promise<unknown>>(key: string, fn: FN): FN {
+  return (async (...args) => {
+    const mixedKey = key + "(" + JSON.stringify(args) + ")";
+    if (await kv.has(mixedKey)) return await kv.get(mixedKey);
+    const ret = await fn(...args);
+    await kv.set(mixedKey, ret);
+    return ret;
+  }) as FN;
+}
+export const BUGCOP_ASKING_FOR_INFO = "bug-cop:ask-for-info" as const; // asking user for more info
+export const BUGCOP_ANSWERED = "bug-cop:answered" as const; // an issue is answered by ComfyOrg Team member
+export const BUGCOP_RESPONSE_RECEIVED = "bug-cop:response-received" as const; // user has responded ask-for-info or answered label
 export const GithubBugcopTaskDefaultMeta = {
   repoUrls: REPOLIST,
-  matchLabel: [ASKING_LABEL],
+  matchLabel: [BUGCOP_ASKING_FOR_INFO],
 };
 
 export type GithubBugcopTask = {
@@ -79,70 +94,74 @@ if (import.meta.main) {
 
 export default async function runGithubBugcopTask() {
   tlog("Running Github Bugcop Task...");
+  const matchingLabels = [BUGCOP_ASKING_FOR_INFO, BUGCOP_ANSWERED];
   const openningIssues = await sflow(REPOLIST)
     // list issues for each repo
-    .map((repoUrl) => {
-      tlog(`Fetching issues for ${repoUrl}...`);
-      return pageFlow(1, async (page) => {
-        const { data: issues } = await hotMemo(gh.issues.listForRepo, [
-          {
-            ...parseUrlRepoOwner(repoUrl),
-            state: "open" as const,
-            page,
-            per_page: 100,
-            labels: ASKING_LABEL,
-          },
-        ]);
-        tlog(`Found ${issues.length} matched issues in ${repoUrl}`);
-        return { data: issues, next: issues.length >= 100 ? page + 1 : undefined };
-      }).flat();
-    })
+    .flatMap((repoUrl) =>
+      matchingLabels.map((label) =>
+        pageFlow(1, async (page) => {
+          const { data: issues } = await hotMemo(gh.issues.listForRepo, [
+            {
+              ...parseUrlRepoOwner(repoUrl),
+              state: "open" as const,
+              page,
+              per_page: 100,
+              labels: label,
+            },
+          ]);
+          tlog(`Found ${issues.length} ${label} issues in ${repoUrl}`);
+          return { data: issues, next: issues.length >= 100 ? page + 1 : undefined };
+        }).flat(),
+      ),
+    )
     .confluenceByParallel() // unpack pageFlow, order does not matter, so we can run in parallel
     .forEach(processIssue)
     .toArray();
 
-  tlog(`Processed ${openningIssues.length} open issues with label "${ASKING_LABEL}"`);
+  tlog(`Processed ${openningIssues.length} open issues`);
 
   // once openning issues are processed,
   // now we should process the issues in db that's not openning anymore
-  await sflow(
+  const existingTasks = await sflow(
     GithubBugcopTask.find({
       url: { $nin: openningIssues.map((e) => e.html_url) },
     }),
   )
     .map((task) => task.url)
-    .log()
     .map(async (issueUrl) => await hotMemo(gh.issues.get, [{ ...parseIssueUrl(issueUrl) }]).then((e) => e.data))
-    // .log()
     .forEach(processIssue)
-    .run();
+    .toArray();
 
-  tlog(chalk.green("Github Bugcop Task completed successfully!"));
+  tlog(chalk.green("Processed " + existingTasks.length + " existing tasks that are not openning/labeled anymore"));
+
+  tlog(chalk.green("All Github Bugcop Task completed successfully!"));
 }
 
 async function processIssue(issue: GH["issue"]) {
-  const url = issue.html_url; // ?? ("issue.html_url is required")    ;
-  const issueId = parseIssueUrl(issue.html_url); // = {owner, repo, issue_number}
+  const url = issue.html_url;
+  const issueId = parseIssueUrl(issue.html_url);
   let task = await GithubBugcopTask.findOne({ url });
   const saveTask = async (data: Partial<GithubBugcopTask>) =>
     (task =
-      (await GithubBugcopTask.findOneAndUpdate({ url }, { $set: data }, { returnDocument: "after", upsert: true })) ||
-      DIE("never"));
+      (await GithubBugcopTask.findOneAndUpdate(
+        { url },
+        { $set: { updatedAt: new Date(), ...data } },
+        { returnDocument: "after", upsert: true },
+      )) || DIE("never"));
+
+  const issueLabels = issue.labels.map((l) => (typeof l === "string" ? l : (l.name ?? ""))).filter(Boolean);
   task = await saveTask({
     taskStatus: "processing",
     user: issue.user?.login,
-    labels: issue.labels.map((l) => (typeof l === "string" ? l : (l.name ?? ""))).filter(Boolean),
+    labels: issueLabels,
     updatedAt: new Date(issue.updated_at),
   });
 
   if (issue.state === "closed") {
-    await saveTask({
-      status: "closed",
-      statusReason: "issue closed",
-      updatedAt: new Date(issue.updated_at),
-      lastChecked: new Date(),
-    });
-    return;
+    if (task.status !== "closed") {
+      tlog(chalk.bgRedBright("Issue is closed: " + issue.html_url));
+    }
+    return await saveTask({ status: "closed", lastChecked: new Date() });
   }
 
   // check if the issue body is updated since last successful scan
@@ -153,111 +172,78 @@ async function processIssue(issue: GH["issue"]) {
     issue.body !== task.body &&
     fastDiff(task.body ?? "", issue.body ?? "").filter(([op, val]) => op === fastDiff.INSERT).length > 0; // check if the issue body has added new content after the label added time
 
-  tlog(chalk.bgBlackBright("Issue: " + issue.html_url));
+  tlog(chalk.bgBlackBright("Processing Issue: " + issue.html_url));
+  tlog(chalk.bgBlue("Labels: " + JSON.stringify(issueLabels)));
 
-  const timeline = await pageFlow(1, async (page) => {
-    const { data: events } = await hotMemo(gh.issues.listEventsForTimeline, [
-      {
-        ...issueId,
-        page,
-        per_page: 100,
-      },
-    ]);
-    return { data: events, next: events.length >= 100 ? page + 1 : undefined };
-  })
-    // flat
-    .filter((e) => e.length)
-    .by((s) => s.pipeThrough(flats()))
-    .toArray();
+  const timeline = await fetchAllIssueTimeline(issueId);
 
   // list all label events
   const labelEvents = await sflow([...timeline])
-    .forEach((_e) => {
-      if (_e.event === "labeled") {
-        const e = _e as GH["labeled-issue-event"];
-        // tlog(`#${issue.number} ${new Date(e.created_at).toISOString()} @${e.actor.login} + label:${e.label.name}`);
-        return e;
-      }
-      if (_e.event === "unlabeled") {
-        const e = _e as GH["unlabeled-issue-event"];
-        // tlog(`#${issue.number} ${new Date(e.created_at).toISOString()} @${e.actor.login} - label:${e.label.name}`);
-        return e;
-      }
-      if (_e.event === "commented") {
-        const e = _e as GH["timeline-comment-event"];
-        // tlog(`#${issue.number} ${new Date(e.created_at).toISOString()} @${e.actor?.login} ${e.body?.slice(0, 20)}`);
-        return e;
-      }
-
-      tlog(`#${issue.number} ${new Date((_e as any).created_at ?? new Date()).toISOString()} ? ${_e.event}`);
-      // ignore other events
+    .map((_e) => {
+      return _e.event === "labeled" || _e.event === "unlabeled" || _e.event === "commented"
+        ? (_e as GH["labeled-issue-event"] | GH["unlabeled-issue-event"] | GH["timeline-comment-event"])
+        : null;
     })
+    .filter((e): e is NonNullable<typeof e> => e !== null)
     .toArray();
-  // tlog("Found " + labelEvents.length + " timeline events");
+  tlog("Found " + labelEvents.length + " unlabeled/labeled/commented events");
   await saveTask({ timeline: labelEvents as any });
 
-  const latestLabeledEvent =
-    labelEvents
-      .filter((e) => e.event === "labeled")
+  function lastLabeled(labelName: string) {
+    return labelEvents
+      .filter((e) => e?.event === "labeled")
       .map((e) => e as GH["labeled-issue-event"])
-      .filter((e) => e.label?.name === ASKING_LABEL)
+      .filter((e) => e.label?.name === labelName)
       .sort(compareBy((e) => e.created_at))
-      .reverse()[0] ||
-    DIE("No labeled event found, this should not happen since we are filtering issues by this label");
-  // last added time of this label
-  const labelLastAddedTime = new Date(latestLabeledEvent?.created_at);
-  tlog('Last added time of label "' + ASKING_LABEL + '" is ' + labelLastAddedTime.toISOString());
+      .reverse()[0];
+  }
+
+  const latestLabeledEvent = lastLabeled(BUGCOP_ASKING_FOR_INFO) || lastLabeled(BUGCOP_ANSWERED);
+  if (!latestLabeledEvent) {
+    lastLabeled(BUGCOP_RESPONSE_RECEIVED) ||
+      DIE(
+        new Error(
+          `No labeled event found, this should not happen since we are filtering issues by those label, ${JSON.stringify(task.labels)}`,
+        ),
+      );
+    return task;
+  }
 
-  // checkif it's answered
+  // check if it's answered since lastLabel
   const hasNewComment = await (async function () {
-    // 1. list issue comments that is updated/created later than this label last added
+    const labelLastAddedTime = new Date(latestLabeledEvent?.created_at);
     const newComments = await pageFlow(1, async (page) => {
-      const { data: comments } = await hotMemo(gh.issues.listComments.bind(gh.issues), [
-        { ...issueId, page, per_page: 100 },
-      ]);
+      const { data: comments } = await hotMemo(gh.issues.listComments, [{ ...issueId, page, per_page: 100 }]);
       return { data: comments, next: comments.length >= 100 ? page + 1 : undefined };
     })
-      .filter((page) => page.length)
       .flat()
       .filter((e) => e.user) // filter out comments without user
       .filter((e) => !e.user?.login.match(/\[bot\]$|-bot/)) // no bots
+      .filter((e) => +new Date(e.updated_at) > +new Date(labelLastAddedTime)) // only comments that is updated later than the label added time
       .filter((e) => !["COLLABORATOR", "CONTRIBUTOR", "MEMBER", "OWNER"].includes(e.author_association)) // not by collaborators, usually askForInfo for more info
       .filter((e) => e.user?.login !== latestLabeledEvent.actor.login) // ignore the user who added the label
-      .filter((e) => +new Date(e.updated_at) > +new Date(labelLastAddedTime)) // only comments that is updated later than the label added time
       .toArray();
-    newComments.length && tlog("Found " + newComments.length + " comments after last added time for " + issue.html_url);
-    // tlog("Found " + JSON.stringify(comments));
+    newComments.length &&
+      tlog(chalk.bgGreen("Found " + newComments.length + " comments after last added time for " + issue.html_url));
     return !!newComments.length;
   })();
 
-  // TODO: maybe search in notion db about this issue, if it's answered in notion, then mark as answered
-  // tlog('issue body not updated after last added time, checking comments...');
-
-  const responseReceived = hasNewComment || isBodyAddedContent; // check if user responsed info by new comment or body update
-  const status: "responseReceived" | "askForInfo" = responseReceived ? "responseReceived" : "askForInfo";
-  const workinglabels = [ASKING_LABEL, RESPONSE_RECEIVED_LABEL];
-  const labelSet = {
-    responseReceived: [RESPONSE_RECEIVED_LABEL],
-    askForInfo: [ASKING_LABEL],
-    closed: [], // clear bug-cop labels
-  }[status];
-
-  const currentLabels = issue.labels
-    .filter((l) => l != null)
-    .map((l) => (typeof l === "string" ? l : (l.name ?? "")))
-    .filter(Boolean);
-  const addLabels = difference(labelSet, currentLabels);
-  const removeLabels = difference(
-    currentLabels.filter((label) => workinglabels.includes(label)),
-    labelSet,
-  );
+  const isResponseReceived = hasNewComment || isBodyAddedContent; // check if user responsed info by new comment or body updated since last scanned
+  if (!isResponseReceived) {
+    return await saveTask({
+      taskStatus: "ok",
+      lastChecked: new Date(),
+    });
+  }
+  const addLabels = [BUGCOP_RESPONSE_RECEIVED];
+  const removeLabels = [latestLabeledEvent.label.name];
 
-  tlog(`Issue ${issue.html_url}`);
-  tlog(
-    `>> status: ${status}, labels: ${chalk.bgBlue([...addLabels.map((e) => "+ " + e), ...removeLabels.map((e) => "- " + e)].join(", "))}`,
-  );
+  if (isResponseReceived) {
+    console.log(chalk.bgBlue("Adding:"), addLabels);
+    console.log(chalk.bgBlue("Removing:"), removeLabels);
+  }
 
-  if (isDryRun) return;
+  if (isDryRun) return task;
 
   await sflow(addLabels)
     .forEach((label) => tlog(`Adding label ${label} to ${issue.html_url}`))
@@ -268,24 +254,23 @@ async function processIssue(issue: GH["issue"]) {
     .map((label) => gh.issues.removeLabel({ ...issueId, name: label }))
     .run();
 
-  // update task status
-  await saveTask({
-    status,
+  return await saveTask({
+    // status,
     statusReason: isBodyAddedContent ? "body updated" : hasNewComment ? "new comment" : "unknown",
     taskStatus: "ok",
-    taskAction: [...addLabels.map((e) => "+ " + e), ...removeLabels.map((e) => "- " + e)].join(", "),
     lastChecked: new Date(),
     labels: union(task.labels || [], addLabels).filter((e) => !removeLabels.includes(e)),
   });
 }
-function flats<T>(): TransformStream<T[], T> {
-  return new TransformStream<T[], T>({
-    transform: (e, controller) => {
-      e.forEach((event) => controller.enqueue(event));
-    },
-    flush: (controller) => {
-      // No finalization needed
-      // Stream will be closed automatically after flush
-    },
-  });
+
+async function fetchAllIssueTimeline(issueId: { owner: string; repo: string; issue_number: number }) {
+  return await pageFlow(1, async (page, size = 100) => {
+    const { data: events } = await createKeyvCachedFn("gh.issues.listEventsForTimeline", (...args) =>
+      gh.issues.listEventsForTimeline(...args),
+    )({ ...issueId, page, per_page: size });
+    console.log("Fetched " + JSON.stringify({ ...issueId, page, per_page: size, events: events.length }) + " events");
+    return { data: events, next: events.length >= size ? page + 1 : undefined };
+  })
+    .flat()
+    .toArray();
 }