Simplify root directory

.github/scripts/autoclose-labeled-issues.js

@@ -0,0 +1,258 @@
+/**
+ * scripts/autoclose-labeled-issues.js
+ *
+ * Auto-closes issues that have a bot "possible duplicate" comment older than
+ * 3 days, unless:
+ * - A human has commented after the bot's duplicate comment
+ * - The author reacted with thumbs-down on the duplicate comment
+ *
+ * Required environment variables:
+ *   GITHUB_TOKEN  - GitHub Actions token
+ *   REPO_OWNER    - Repository owner
+ *   REPO_NAME     - Repository name
+ *
+ * Optional:
+ *   DRY_RUN       - If "true", report but do not close (default: false)
+ */
+
+'use strict';
+
+const https = require('https');
+
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+const REPO_OWNER   = process.env.REPO_OWNER;
+const REPO_NAME    = process.env.REPO_NAME;
+const DRY_RUN      = process.env.DRY_RUN === 'true';
+
+const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+
+function githubRequest(method, path, body = null, retried = false) {
+  return new Promise((resolve, reject) => {
+    const payload = body ? JSON.stringify(body) : null;
+    const options = {
+      hostname: 'api.github.com',
+      path,
+      method,
+      headers: {
+        'Authorization': `Bearer ${GITHUB_TOKEN}`,
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'PageIndex-Autoclose/1.0',
+        'X-GitHub-Api-Version': '2022-11-28',
+        ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } : {}),
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => (data += chunk));
+      res.on('end', async () => {
+        // 429: 始终重试（rate limit）
+        if (res.statusCode === 429 && !retried) {
+          const retryAfter = parseInt(res.headers['retry-after'] || '60', 10);
+          console.log(`  Rate limited on ${method} ${path}, retrying after ${retryAfter}s...`);
+          await sleep(retryAfter * 1000);
+          try { resolve(await githubRequest(method, path, body, true)); }
+          catch (err) { reject(err); }
+          return;
+        }
+        // 403: 只在 rate limit 相关时重试
+        if (res.statusCode === 403 && !retried) {
+          const rateLimitRemaining = res.headers['x-ratelimit-remaining'];
+          const hasRetryAfter = res.headers['retry-after'];
+          if (rateLimitRemaining === '0' || hasRetryAfter) {
+            const retryAfter = parseInt(hasRetryAfter || '60', 10);
+            console.log(`  Rate limited (403) on ${method} ${path}, retrying after ${retryAfter}s...`);
+            await sleep(retryAfter * 1000);
+            try { resolve(await githubRequest(method, path, body, true)); }
+            catch (err) { reject(err); }
+            return;
+          }
+        }
+        if (res.statusCode >= 400) {
+          reject(new Error(`GitHub API ${method} ${path} -> ${res.statusCode}: ${data}`));
+          return;
+        }
+        try { resolve(data ? JSON.parse(data) : {}); }
+        catch { resolve({}); }
+      });
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+/**
+ * Fetches open issues with the "duplicate" label, paginating as needed.
+ * Only returns issues created more than 3 days ago.
+ */
+async function fetchDuplicateIssues() {
+  const issues = [];
+  let page = 1;
+  while (true) {
+    const data = await githubRequest(
+      'GET',
+      `/repos/${REPO_OWNER}/${REPO_NAME}/issues?state=open&labels=duplicate&per_page=100&page=${page}`
+    );
+    if (!Array.isArray(data) || data.length === 0) break;
+    issues.push(...data.filter(i => !i.pull_request));
+    if (data.length < 100) break;
+    page++;
+  }
+
+  const cutoff = new Date(Date.now() - THREE_DAYS_MS);
+  return issues.filter(i => new Date(i.created_at) < cutoff);
+}
+
+function isBot(user) {
+  return user.type === 'Bot' || user.login.endsWith('[bot]') || user.login === 'github-actions';
+}
+
+/**
+ * Finds the bot's duplicate comment on an issue (contains "possible duplicate").
+ */
+function findDuplicateComment(comments) {
+  return comments.find(c =>
+    isBot(c.user) && c.body.includes('possible duplicate')
+  );
+}
+
+/**
+ * Checks if there are human comments after the duplicate comment.
+ */
+function hasHumanCommentAfter(comments, afterDate) {
+  return comments.some(c => {
+    if (isBot(c.user)) return false;
+    return new Date(c.created_at) > afterDate;
+  });
+}
+
+/**
+ * Fetches all comments for an issue, handling pagination.
+ * Requests per_page=100 and loops until we get fewer than 100 or an empty array.
+ */
+async function fetchAllComments(issueNumber) {
+  const allComments = [];
+  let page = 1;
+  while (true) {
+    const comments = await githubRequest(
+      'GET',
+      `/repos/${REPO_OWNER}/${REPO_NAME}/issues/${issueNumber}/comments?per_page=100&page=${page}`
+    );
+    if (!Array.isArray(comments) || comments.length === 0) break;
+    allComments.push(...comments);
+    if (comments.length < 100) break;
+    page++;
+  }
+  return allComments;
+}
+
+/**
+ * Checks if the duplicate comment has a thumbs-down reaction.
+ */
+async function hasThumbsDownReaction(commentId) {
+  const reactions = await githubRequest(
+    'GET',
+    `/repos/${REPO_OWNER}/${REPO_NAME}/issues/comments/${commentId}/reactions`
+  );
+  return Array.isArray(reactions) && reactions.some(r => r.content === '-1');
+}
+
+/**
+ * Closes an issue as duplicate with a comment.
+ */
+async function closeAsDuplicate(issueNumber) {
+  const body =
+    'This issue has been automatically closed as a duplicate. ' +
+    'No human activity or objection was received within the 3-day grace period.\n\n' +
+    'If you believe this was closed in error, please reopen the issue and leave a comment.';
+
+  await githubRequest(
+    'POST',
+    `/repos/${REPO_OWNER}/${REPO_NAME}/issues/${issueNumber}/comments`,
+    { body }
+  );
+
+  await githubRequest(
+    'PATCH',
+    `/repos/${REPO_OWNER}/${REPO_NAME}/issues/${issueNumber}`,
+    { state: 'closed', state_reason: 'completed' }
+  );
+}
+
+async function processIssue(issue) {
+  const num = issue.number;
+  console.log(`\nChecking issue #${num}: ${issue.title}`);
+
+  const comments = await fetchAllComments(num);
+
+  if (!Array.isArray(comments) || comments.length === 0) {
+    console.log(`  -> Could not fetch comments, skipping.`);
+    return false;
+  }
+
+  const dupeComment = findDuplicateComment(comments);
+  if (!dupeComment) {
+    console.log(`  -> No duplicate comment found, skipping.`);
+    return false;
+  }
+
+  const commentDate = new Date(dupeComment.created_at);
+  const ageMs = Date.now() - commentDate.getTime();
+
+  if (ageMs < THREE_DAYS_MS) {
+    const daysLeft = Math.ceil((THREE_DAYS_MS - ageMs) / (24 * 60 * 60 * 1000));
+    console.log(`  -> Duplicate comment is less than 3 days old (${daysLeft}d remaining), skipping.`);
+    return false;
+  }
+
+  if (hasHumanCommentAfter(comments, commentDate)) {
+    console.log(`  -> Human commented after duplicate comment, skipping.`);
+    return false;
+  }
+
+  if (await hasThumbsDownReaction(dupeComment.id)) {
+    console.log(`  -> Author reacted with thumbs-down, skipping.`);
+    return false;
+  }
+
+  if (DRY_RUN) {
+    console.log(`  [DRY RUN] Would close issue #${num}`);
+    return true;
+  }
+
+  await closeAsDuplicate(num);
+  console.log(`  -> Closed issue #${num} as duplicate`);
+  return true;
+}
+
+async function main() {
+  const missing = ['GITHUB_TOKEN', 'REPO_OWNER', 'REPO_NAME'].filter(k => !process.env[k]);
+  if (missing.length) {
+    console.error(`Missing required environment variables: ${missing.join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log('Auto-close duplicate issues');
+  console.log(`  Repository: ${REPO_OWNER}/${REPO_NAME}`);
+  console.log(`  Dry run:    ${DRY_RUN}`);
+
+  const issues = await fetchDuplicateIssues();
+  console.log(`\nFound ${issues.length} duplicate-labeled issue(s) older than 3 days.`);
+
+  let closedCount = 0;
+  for (const issue of issues) {
+    const closed = await processIssue(issue);
+    if (closed) closedCount++;
+    await sleep(1000);
+  }
+
+  console.log(`\nSummary: ${closedCount} issue(s) closed.`);
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

.github/scripts/comment-on-duplicates.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+#
+# comment-on-duplicates.sh - Posts a duplicate issue comment with auto-close warning.
+#
+# Usage:
+#   ./.github/scripts/comment-on-duplicates.sh --base-issue 123 --potential-duplicates 456 789
+#
+set -euo pipefail
+
+REPO="${GITHUB_REPOSITORY:-}"
+if [ -z "$REPO" ]; then
+  echo "Error: GITHUB_REPOSITORY is not set" >&2
+  exit 1
+fi
+
+BASE_ISSUE=""
+DUPLICATES=()
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --base-issue)
+      BASE_ISSUE="$2"
+      shift 2
+      ;;
+    --potential-duplicates)
+      shift
+      while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do
+        DUPLICATES+=("$1")
+        shift
+      done
+      ;;
+    *)
+      echo "Error: Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate inputs
+if [ -z "$BASE_ISSUE" ]; then
+  echo "Error: --base-issue is required" >&2
+  exit 1
+fi
+
+if ! [[ "$BASE_ISSUE" =~ ^[0-9]+$ ]]; then
+  echo "Error: --base-issue must be a number, got: $BASE_ISSUE" >&2
+  exit 1
+fi
+
+if [ ${#DUPLICATES[@]} -eq 0 ]; then
+  echo "Error: --potential-duplicates requires at least one issue number" >&2
+  exit 1
+fi
+
+for dup in "${DUPLICATES[@]}"; do
+  if ! [[ "$dup" =~ ^[0-9]+$ ]]; then
+    echo "Error: duplicate issue must be a number, got: $dup" >&2
+    exit 1
+  fi
+done
+
+# Limit to 3 duplicates max
+if [ ${#DUPLICATES[@]} -gt 3 ]; then
+  echo "Warning: Limiting to first 3 duplicates" >&2
+  DUPLICATES=("${DUPLICATES[@]:0:3}")
+fi
+
+# Build the duplicate links list
+COUNT=0
+LINKS=""
+for dup in "${DUPLICATES[@]}"; do
+  COUNT=$((COUNT + 1))
+  LINKS="${LINKS}${COUNT}. https://github.com/${REPO}/issues/${dup}
+"
+done
+
+# Build and post the comment — if the issue is closed or doesn't exist, gh will error out
+COMMENT="Found ${COUNT} possible duplicate issue(s):
+
+${LINKS}
+This issue will be automatically closed as a duplicate in 3 days.
+- To prevent auto-closure, add a comment or react with :thumbsdown: on this comment."
+
+gh issue comment "$BASE_ISSUE" --repo "$REPO" --body "$COMMENT"
+gh issue edit "$BASE_ISSUE" --repo "$REPO" --add-label "duplicate"
+
+echo "Posted duplicate comment on issue #$BASE_ISSUE with $COUNT potential duplicate(s)"