fix(mcp): skip ToolProvider mapping when the request carries no tool payload

.github/scripts/stale.js

@@ -0,0 +1,167 @@
+module.exports = async ({ github, context, core }) => {
+  const DAYS_UNTIL_STALE = 60;
+  const DAYS_UNTIL_CLOSE = 7;
+  const STALE_LABEL      = 'stale';
+  const EXEMPT_LABELS    = new Set([
+    'Hacktoberfest',
+    'RFC',
+    '⭐ EU-FOSSA Hackathon',
+  ]);
+  const EXEMPT_TYPES     = new Set(['Bug', 'Feature']);
+  const STALE_COMMENT    = [
+    'This issue has been automatically marked as stale because it has not had',
+    'recent activity. It will be closed if no further activity occurs. Thank you',
+    'for your contributions.',
+  ].join(' ');
+  const BOT_LOGINS       = new Set(['github-actions[bot]', 'github-actions']);
+
+  const DRY_RUN            = /^(1|true|yes)$/i.test(process.env.DRY_RUN || '');
+  const MAX_ACTIONS_PER_RUN = Number.parseInt(process.env.MAX_ACTIONS_PER_RUN || '25', 10);
+
+  const { owner, repo } = context.repo;
+  const now             = Date.now();
+  const staleCutoff     = new Date(now - DAYS_UNTIL_STALE * 86400000);
+  const closeCutoff     = new Date(now - DAYS_UNTIL_CLOSE * 86400000);
+
+  let actionsTaken = 0;
+  const budgetExhausted = () => actionsTaken >= MAX_ACTIONS_PER_RUN;
+
+  async function* iterateOpenIssues() {
+    let cursor = null;
+    while (true) {
+      const data = await github.graphql(`
+        query($owner: String!, $name: String!, $cursor: String) {
+          repository(owner: $owner, name: $name) {
+            issues(first: 100, after: $cursor, states: OPEN, orderBy: {field: UPDATED_AT, direction: ASC}) {
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                number
+                updatedAt
+                issueType { name }
+                labels(first: 50) { nodes { name } }
+                timelineItems(last: 100, itemTypes: [LABELED_EVENT]) {
+                  nodes {
+                    ... on LabeledEvent {
+                      createdAt
+                      label { name }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }`, { owner, name: repo, cursor });
+
+      const page = data.repository.issues;
+      for (const node of page.nodes) yield node;
+      if (!page.pageInfo.hasNextPage) break;
+      cursor = page.pageInfo.endCursor;
+    }
+  }
+
+  async function hasNonBotActivitySince(issue_number, since) {
+    const events = await github.paginate(
+      github.rest.issues.listEventsForTimeline,
+      { owner, repo, issue_number, per_page: 100 },
+    );
+    return events.some(e => {
+      const ts = e.created_at || e.submitted_at;
+      if (!ts) return false;
+      if (new Date(ts) <= since) return false;
+      const actor = e.actor?.login || e.user?.login;
+      if (actor && BOT_LOGINS.has(actor)) return false;
+      return true;
+    });
+  }
+
+  function mostRecentStaleAt(issue) {
+    let latest = null;
+    for (const e of issue.timelineItems.nodes) {
+      if (e?.label?.name !== STALE_LABEL) continue;
+      const at = new Date(e.createdAt);
+      if (!latest || at > latest) latest = at;
+    }
+    return latest;
+  }
+
+  async function addStale(issue_number) {
+    if (DRY_RUN) {
+      core.info(`DRY_RUN would stale #${issue_number}`);
+      return;
+    }
+    await github.rest.issues.addLabels({ owner, repo, issue_number, labels: [STALE_LABEL] });
+    await github.rest.issues.createComment({ owner, repo, issue_number, body: STALE_COMMENT });
+  }
+
+  async function close(issue_number) {
+    if (DRY_RUN) {
+      core.info(`DRY_RUN would close #${issue_number}`);
+      return;
+    }
+    await github.rest.issues.update({
+      owner, repo, issue_number, state: 'closed', state_reason: 'not_planned',
+    });
+  }
+
+  async function unstale(issue_number) {
+    if (DRY_RUN) {
+      core.info(`DRY_RUN would unstale #${issue_number}`);
+      return;
+    }
+    await github.rest.issues.removeLabel({
+      owner, repo, issue_number, name: STALE_LABEL,
+    }).catch(err => {
+      if (err.status !== 404) throw err;
+    });
+  }
+
+  const summary = { staled: 0, closed: 0, unstaled: 0, exempt: 0, scanned: 0, skipped: 0 };
+
+  for await (const issue of iterateOpenIssues()) {
+    summary.scanned++;
+    const labels   = new Set(issue.labels.nodes.map(l => l.name));
+    const typeName = issue.issueType?.name;
+    const exempt   = (typeName && EXEMPT_TYPES.has(typeName))
+                  || [...labels].some(l => EXEMPT_LABELS.has(l));
+    const hasStale = labels.has(STALE_LABEL);
+
+    if (hasStale) {
+      const staleAt = mostRecentStaleAt(issue);
+      if (!staleAt) continue;
+
+      const interacted = await hasNonBotActivitySince(issue.number, staleAt);
+      if (interacted) {
+        if (budgetExhausted()) { summary.skipped++; continue; }
+        await unstale(issue.number);
+        summary.unstaled++;
+        actionsTaken++;
+      } else if (staleAt <= closeCutoff) {
+        if (budgetExhausted()) { summary.skipped++; continue; }
+        await close(issue.number);
+        summary.closed++;
+        actionsTaken++;
+      }
+      continue;
+    }
+
+    if (exempt) {
+      summary.exempt++;
+      continue;
+    }
+
+    if (new Date(issue.updatedAt) <= staleCutoff) {
+      if (budgetExhausted()) { summary.skipped++; continue; }
+      await addStale(issue.number);
+      summary.staled++;
+      actionsTaken++;
+    }
+  }
+
+  const prefix = DRY_RUN ? 'DRY_RUN ' : '';
+  core.info(
+    `${prefix}scanned=${summary.scanned} staled=${summary.staled} ` +
+    `closed=${summary.closed} unstaled=${summary.unstaled} ` +
+    `exempt=${summary.exempt} skipped=${summary.skipped} ` +
+    `budget=${MAX_ACTIONS_PER_RUN}`,
+  );
+};