@mastra/github-signals 0.0.0-agent-learning-fetch-again-20260701152039

package/dist/index.js

@@ -0,0 +1,1371 @@
+import { randomUUID, createHash } from 'crypto';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { promisify } from 'util';
+import { SignalProvider } from '@mastra/core/signals';
+import { createTool } from '@mastra/core/tools';
+import z from 'zod';
+
+// src/index.ts
+var _execFileAsync;
+async function execFileAsync(file, args, options) {
+  if (!_execFileAsync) {
+    const cp = await import('child_process');
+    _execFileAsync = promisify(cp.execFile);
+  }
+  return _execFileAsync(file, args, options);
+}
+var GITHUB_SUBSCRIBE_PR_TAG = "github-subscribe-pr";
+var GITHUB_UNSUBSCRIBE_PR_TAG = "github-unsubscribe-pr";
+var GITHUB_SYNC_STATUS_TAG = "github-sync-status";
+var GITHUB_SIGNALS_METADATA_KEY = "githubSignals";
+var DEFAULT_AUTHORIZED_PERMISSIONS = ["admin", "maintain", "write"];
+var DEFAULT_AUTHORIZED_BOTS = ["coderabbitai[bot]", "devin-ai-integration[bot]"];
+var PERMISSION_CACHE_TTL_MS = 5 * 60 * 1e3;
+var AUTHOR_GATED_NOTIFICATION_KINDS = /* @__PURE__ */ new Set(["pull-request-activity", "pull-request-review-activity"]);
+var createGithubTool = createTool;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return void 0;
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (isPlainObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function snapshotHash(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function resolveHomePath(path) {
+  return path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
+}
+async function getGitcrawlDbPath() {
+  if (process.env.GITCRAWL_DB_PATH) return resolveHomePath(process.env.GITCRAWL_DB_PATH);
+  const configPath = process.env.GITCRAWL_CONFIG_PATH ?? join(homedir(), ".config", "gitcrawl", "config.toml");
+  try {
+    const config = await readFile(resolveHomePath(configPath), "utf8");
+    const match = /^\s*db_path\s*=\s*['\"]([^'\"]+)['\"]/m.exec(config);
+    if (match?.[1]) return resolveHomePath(match[1]);
+  } catch {
+  }
+  return join(homedir(), ".config", "gitcrawl", "gitcrawl.db");
+}
+async function queryGitcrawlDb(sql) {
+  const dbPath = await getGitcrawlDbPath();
+  const { stdout } = await execFileAsync("sqlite3", ["-json", dbPath, sql], { maxBuffer: 10 * 1024 * 1024 });
+  return JSON.parse(stdout || "[]");
+}
+function sqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function getSignalMetadata(message) {
+  if (message.role !== "signal") return void 0;
+  const signal = message.content.metadata?.signal;
+  return isPlainObject(signal) ? signal : void 0;
+}
+function getGithubMetadata(threadMetadata) {
+  const mastra = isPlainObject(threadMetadata?.mastra) ? threadMetadata.mastra : {};
+  const githubSignals = isPlainObject(mastra[GITHUB_SIGNALS_METADATA_KEY]) ? mastra[GITHUB_SIGNALS_METADATA_KEY] : {};
+  const rawSubscriptions = Array.isArray(githubSignals.subscriptions) ? githubSignals.subscriptions : [];
+  const subscriptions = [];
+  for (const rawSubscription of rawSubscriptions) {
+    if (!isPlainObject(rawSubscription)) continue;
+    const owner = readString(rawSubscription.owner);
+    const repo = readString(rawSubscription.repo);
+    const number = readNumber(rawSubscription.number);
+    const subscribedAt = readString(rawSubscription.subscribedAt);
+    const updatedAt = readString(rawSubscription.updatedAt);
+    const lastSubscribeSignalId = readString(rawSubscription.lastSubscribeSignalId);
+    if (!owner || !repo || !number || !subscribedAt || !updatedAt || !lastSubscribeSignalId) continue;
+    subscriptions.push({
+      owner,
+      repo,
+      number,
+      subscribedAt,
+      updatedAt,
+      lastSubscribeSignalId,
+      ...readString(rawSubscription.lastSyncAt) ? { lastSyncAt: readString(rawSubscription.lastSyncAt) } : {},
+      ...rawSubscription.lastSyncStatus === "success" || rawSubscription.lastSyncStatus === "error" || rawSubscription.lastSyncStatus === "skipped" ? { lastSyncStatus: rawSubscription.lastSyncStatus } : {},
+      ...readString(rawSubscription.lastSyncError) ? { lastSyncError: readString(rawSubscription.lastSyncError) } : {},
+      ...readString(rawSubscription.lastObservedGithubUpdatedAt) ? { lastObservedGithubUpdatedAt: readString(rawSubscription.lastObservedGithubUpdatedAt) } : {},
+      ...readString(rawSubscription.lastObservedContentHash) ? { lastObservedContentHash: readString(rawSubscription.lastObservedContentHash) } : {},
+      ...readString(rawSubscription.lastObservedThreadContentHash) ? { lastObservedThreadContentHash: readString(rawSubscription.lastObservedThreadContentHash) } : {},
+      ...readString(rawSubscription.lastObservedHeadSha) ? { lastObservedHeadSha: readString(rawSubscription.lastObservedHeadSha) } : {},
+      ...readString(rawSubscription.lastObservedState) ? { lastObservedState: readString(rawSubscription.lastObservedState) } : {},
+      ...readString(rawSubscription.lastObservedMergeableState) ? { lastObservedMergeableState: readString(rawSubscription.lastObservedMergeableState) } : {},
+      ...readString(rawSubscription.lastObservedCiState) ? { lastObservedCiState: readString(rawSubscription.lastObservedCiState) } : {},
+      ...readString(rawSubscription.lastObservedReviewStateHash) ? { lastObservedReviewStateHash: readString(rawSubscription.lastObservedReviewStateHash) } : {},
+      ...readString(rawSubscription.lastNotificationAt) ? { lastNotificationAt: readString(rawSubscription.lastNotificationAt) } : {},
+      ...readString(rawSubscription.lastNotificationKind) ? { lastNotificationKind: readString(rawSubscription.lastNotificationKind) } : {},
+      ...rawSubscription.lastNotificationPriority === "medium" || rawSubscription.lastNotificationPriority === "high" ? { lastNotificationPriority: rawSubscription.lastNotificationPriority } : {},
+      ...readString(rawSubscription.lastNotificationSummary) ? { lastNotificationSummary: readString(rawSubscription.lastNotificationSummary) } : {}
+    });
+  }
+  return {
+    subscriptions,
+    ...githubSignals.subscriptionHintShown === true ? { subscriptionHintShown: true } : {}
+  };
+}
+function setGithubMetadata(threadMetadata, githubSignals) {
+  const existing = threadMetadata ?? {};
+  const mastra = isPlainObject(existing.mastra) ? existing.mastra : {};
+  const existingGithubSignals = isPlainObject(mastra[GITHUB_SIGNALS_METADATA_KEY]) ? mastra[GITHUB_SIGNALS_METADATA_KEY] : {};
+  return {
+    ...existing,
+    mastra: {
+      ...mastra,
+      [GITHUB_SIGNALS_METADATA_KEY]: {
+        ...existingGithubSignals,
+        ...githubSignals
+      }
+    }
+  };
+}
+function getFailingChecks(snapshot) {
+  return (snapshot.checks ?? []).filter((check) => check.conclusion === "failure" || check.conclusion === "timed_out");
+}
+function getPendingChecks(snapshot) {
+  return (snapshot.checks ?? []).filter((check) => check.status && check.status !== "completed");
+}
+function getPrLabel(subscription, snapshot) {
+  const pr = `${subscription.owner}/${subscription.repo}#${subscription.number}`;
+  return snapshot?.title ? `${pr}: ${snapshot.title}` : pr;
+}
+function getMergedNotificationSummary(label) {
+  return `${label} was merged. This thread has been automatically unsubscribed from this PR. Resubscribe if you still need updates.`;
+}
+function stripBlocks(text, open, close) {
+  const haystack = text.toLowerCase();
+  const openLower = open.toLowerCase();
+  const closeLower = close.toLowerCase();
+  let result = "";
+  let cursor = 0;
+  for (; ; ) {
+    const start = haystack.indexOf(openLower, cursor);
+    if (start === -1) {
+      result += text.slice(cursor);
+      return result;
+    }
+    result += text.slice(cursor, start);
+    const end = haystack.indexOf(closeLower, start + openLower.length);
+    if (end === -1) return result;
+    cursor = end + closeLower.length;
+  }
+}
+var CODE_TOKEN_PREFIX = "\0CODE";
+var CODE_TOKEN_SUFFIX = "\0";
+function preserveMarkdownCode(text) {
+  const preserved = [];
+  const stash = (match) => {
+    const token = `${CODE_TOKEN_PREFIX}${preserved.length}${CODE_TOKEN_SUFFIX}`;
+    preserved.push(match);
+    return token;
+  };
+  const protectedText = text.replace(/```[\s\S]*?```/g, stash).replace(/(`{2,})(?!`)[\s\S]*?[^`]\1(?!`)/g, stash).replace(/`[^`\n]*`/g, stash);
+  return {
+    text: protectedText,
+    restore: (sanitized) => sanitized.replace(/\u0000CODE(\d+)\u0000/g, (_, index) => preserved[Number(index)] ?? "")
+  };
+}
+function sanitizeCommentText(body) {
+  const { text: protectedBody, restore } = preserveMarkdownCode(body);
+  let text = stripBlocks(protectedBody, "<!--", "-->");
+  text = stripBlocks(text, "<details", "</details>");
+  const stripped = text.replace(/<\/?[a-zA-Z][^<>]*>/g, "").replace(/<[!/a-zA-Z][\s\S]*$/g, "").replace(/</g, "").replace(/\n{3,}/g, "\n\n").trim();
+  return restore(stripped);
+}
+function sanitizeCommentBody(body) {
+  if (body === void 0) return void 0;
+  const sanitized = sanitizeCommentText(body);
+  return sanitized.length > 0 ? sanitized : void 0;
+}
+function getCommentExcerpt(body) {
+  const excerpt = sanitizeCommentText(body).replace(/\s+/g, " ").trim();
+  return excerpt.length > 240 ? `${excerpt.slice(0, 237)}...` : excerpt;
+}
+function getCommentNotificationSummary(pr, snapshot) {
+  if (!snapshot.latestCommentAuthor || !snapshot.latestCommentBody) return void 0;
+  return `${snapshot.latestCommentAuthor} commented on ${pr}: ${getCommentExcerpt(snapshot.latestCommentBody)}`;
+}
+var githubActivityNotificationPriority = {
+  high: 0,
+  medium: 1
+};
+function getGithubActivityNotificationRank(notification) {
+  return notification.kind === "pull-request-activity" ? 0 : 1;
+}
+function compareGithubActivityNotifications(a, b) {
+  if (!a && !b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+  const priorityComparison = githubActivityNotificationPriority[a.priority] - githubActivityNotificationPriority[b.priority];
+  if (priorityComparison !== 0) return priorityComparison;
+  return getGithubActivityNotificationRank(a) - getGithubActivityNotificationRank(b);
+}
+function classifyGithubCommentActivityNotification(input) {
+  if (isBotOnlyActivity(input.snapshot)) return void 0;
+  const pr = `${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}`;
+  const summary = getCommentNotificationSummary(pr, input.snapshot);
+  if (!summary) return void 0;
+  return { kind: "pull-request-activity", priority: "high", summary };
+}
+function getCheckUpdatedTime(check) {
+  const value = check.updatedAt ? Date.parse(check.updatedAt) : Number.NaN;
+  return Number.isFinite(value) ? value : 0;
+}
+function getCheckKey(check) {
+  return `${check.name || "check"}:${check.detailsUrl || check.workflowName || ""}`;
+}
+function normalizeGithubChecksForSnapshot(input) {
+  const latestCheckUpdatedAt = input.checkRows.reduce(
+    (latest, check) => Math.max(latest, getCheckUpdatedTime(check)),
+    0
+  );
+  const rows = [
+    ...input.checkRows,
+    ...input.workflowRows.filter(
+      (workflow) => input.checkRows.length === 0 || getCheckUpdatedTime(workflow) >= latestCheckUpdatedAt
+    )
+  ];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = getCheckKey(row);
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, row);
+      continue;
+    }
+    const rowTime = getCheckUpdatedTime(row);
+    const existingTime = getCheckUpdatedTime(existing);
+    if (rowTime > existingTime || rowTime === existingTime && existing.source === "workflow" && row.source === "check") {
+      byKey.set(key, row);
+    }
+  }
+  return [...byKey.values()].map(({ source: _source, ...check }) => check).sort((a, b) => `${a.name}:${a.detailsUrl ?? ""}`.localeCompare(`${b.name}:${b.detailsUrl ?? ""}`));
+}
+function isBotOnlyActivity(snapshot) {
+  return snapshot.latestCommentIsBot === true && (!snapshot.ciState || snapshot.ciState === "unknown");
+}
+function stringifyEvidence(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function detectPrWorkEvidence(input) {
+  const evidence = [
+    input.text ?? "",
+    ...(input.toolCalls ?? []).map((toolCall) => `${toolCall.toolName} ${stringifyEvidence(toolCall.args)}`)
+  ].join("\n");
+  if (!evidence.trim()) return void 0;
+  const url = /github\.com\/([^\s/#]+)\/([^\s/#]+)\/pull\/(\d+)/i.exec(evidence);
+  if (url?.[1] && url[2] && url[3]) return { owner: url[1], repo: url[2], number: Number(url[3]) };
+  const repoRef = /\b([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)\b/.exec(evidence);
+  if (repoRef?.[1] && repoRef[2] && repoRef[3])
+    return { owner: repoRef[1], repo: repoRef[2], number: Number(repoRef[3]) };
+  const ghCommand = /\bgh\s+(?:pr\s+(?:view|checks|status|comment|diff|checkout)|run\s+(?:rerun|view))\b/i.test(
+    evidence
+  );
+  if (!ghCommand) return void 0;
+  const numberMatch = /(?:^|\s)#?(\d{2,})(?:\s|$)/.exec(evidence);
+  return numberMatch?.[1] ? { number: Number(numberMatch[1]) } : void 0;
+}
+function classifyGithubActivityNotification(input) {
+  const pr = `${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}`;
+  const label = getPrLabel(input.subscription, input.snapshot);
+  if (input.snapshot.state && input.subscription.lastObservedState !== input.snapshot.state) {
+    if (input.snapshot.state === "merged")
+      return {
+        kind: "pull-request-merged",
+        priority: "high",
+        summary: getMergedNotificationSummary(label)
+      };
+    if (input.snapshot.state === "closed")
+      return { kind: "pull-request-closed", priority: "high", summary: `${label} was closed` };
+    if (input.subscription.lastObservedState && input.snapshot.state === "open")
+      return { kind: "pull-request-reopened", priority: "medium", summary: `${label} was reopened` };
+  }
+  const failingChecks = getFailingChecks(input.snapshot);
+  if (input.snapshot.ciState === "failure" && input.subscription.lastObservedCiState !== "failure") {
+    const names = failingChecks.slice(0, 3).map((check) => check.name).join(", ");
+    return {
+      kind: "pull-request-ci-failure",
+      priority: "high",
+      summary: `${pr} has failing CI${names ? `: ${names}` : ""}`
+    };
+  }
+  if (input.snapshot.mergeableState === "dirty" && input.subscription.lastObservedMergeableState !== "dirty") {
+    return {
+      kind: "pull-request-conflict",
+      priority: "high",
+      summary: `${pr} has merge conflicts${input.snapshot.title ? `: ${input.snapshot.title}` : ""}`
+    };
+  }
+  if (input.snapshot.mergeableState && input.subscription.lastObservedMergeableState === "dirty" && input.snapshot.mergeableState !== "dirty") {
+    return {
+      kind: "pull-request-conflict-resolved",
+      priority: "medium",
+      summary: `${pr} merge conflicts were resolved`
+    };
+  }
+  if (input.snapshot.mergeableState === "dirty") return void 0;
+  if (input.snapshot.ciState === "success" && input.subscription.lastObservedCiState && input.subscription.lastObservedCiState !== "success") {
+    return { kind: "pull-request-ci-recovered", priority: "medium", summary: `${pr} CI recovered` };
+  }
+  if (input.snapshot.reviewStateHash && input.subscription.lastObservedReviewStateHash && input.snapshot.reviewStateHash !== input.subscription.lastObservedReviewStateHash && (input.snapshot.unresolvedReviewThreads ?? 0) > 0) {
+    return {
+      kind: "pull-request-review-activity",
+      priority: "medium",
+      summary: `${pr} has ${input.snapshot.unresolvedReviewThreads} unresolved review thread${input.snapshot.unresolvedReviewThreads === 1 ? "" : "s"}`
+    };
+  }
+  const pendingChecks = getPendingChecks(input.snapshot);
+  if (input.snapshot.ciState === "pending" && input.subscription.lastObservedCiState !== "pending" && pendingChecks.length > 0) {
+    const names = pendingChecks.slice(0, 3).map((check) => check.name).join(", ");
+    return {
+      kind: "pull-request-ci-pending",
+      priority: "medium",
+      summary: `${pr} has CI still running${names ? `: ${names}` : ""}`
+    };
+  }
+  if (input.snapshot.ciState === "pending" && input.subscription.lastObservedCiState === "pending") return void 0;
+  if (isBotOnlyActivity(input.snapshot)) return void 0;
+  const commentSummary = getCommentNotificationSummary(pr, input.snapshot);
+  return {
+    kind: "pull-request-activity",
+    priority: commentSummary ? "high" : "medium",
+    summary: commentSummary ?? `${pr} has new activity${input.snapshot.title ? `: ${input.snapshot.title}` : ""}`
+  };
+}
+function classifyGithubBaselineNotification(input) {
+  const pr = `${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}`;
+  const failingChecks = getFailingChecks(input.snapshot);
+  const reviewCount = input.snapshot.unresolvedReviewThreads ?? 0;
+  const high = input.snapshot.ciState === "failure" || input.snapshot.mergeableState === "dirty";
+  const details = [
+    input.snapshot.state ? `state: ${input.snapshot.state}` : void 0,
+    input.snapshot.ciState && input.snapshot.ciState !== "unknown" ? `CI: ${input.snapshot.ciState}` : void 0,
+    input.snapshot.mergeableState ? `mergeability: ${input.snapshot.mergeableState}` : void 0,
+    reviewCount > 0 ? `${reviewCount} unresolved review thread${reviewCount === 1 ? "" : "s"}` : void 0,
+    failingChecks.length > 0 ? `failing: ${failingChecks.slice(0, 3).map((check) => check.name).join(", ")}` : void 0
+  ].filter(Boolean);
+  return {
+    kind: "pull-request-baseline",
+    priority: high ? "high" : "medium",
+    summary: `${pr} subscribed${input.snapshot.title ? `: ${input.snapshot.title}` : ""}${details.length ? ` (${details.join("; ")})` : ""}`
+  };
+}
+function applySnapshotCursor(subscription, snapshot) {
+  if (snapshot.githubUpdatedAt) subscription.lastObservedGithubUpdatedAt = snapshot.githubUpdatedAt;
+  if (snapshot.contentHash) subscription.lastObservedContentHash = snapshot.contentHash;
+  if (snapshot.threadContentHash) subscription.lastObservedThreadContentHash = snapshot.threadContentHash;
+  if (snapshot.headSha) subscription.lastObservedHeadSha = snapshot.headSha;
+  if (snapshot.state) subscription.lastObservedState = snapshot.state;
+  if (snapshot.mergeableState) subscription.lastObservedMergeableState = snapshot.mergeableState;
+  if (snapshot.ciState) subscription.lastObservedCiState = snapshot.ciState;
+  if (snapshot.reviewStateHash) subscription.lastObservedReviewStateHash = snapshot.reviewStateHash;
+}
+function parseGitHubRemoteUrl(remoteUrl) {
+  const trimmed = remoteUrl.trim().replace(/\.git$/, "");
+  const httpsMatch = /^https:\/\/github\.com\/([^/]+)\/([^/]+)$/.exec(trimmed);
+  if (httpsMatch?.[1] && httpsMatch[2]) return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  const sshMatch = /^git@github\.com:([^/]+)\/([^/]+)$/.exec(trimmed);
+  if (sshMatch?.[1] && sshMatch[2]) return { owner: sshMatch[1], repo: sshMatch[2] };
+  return void 0;
+}
+var GitRemoteRepositoryResolver = class {
+  async resolveRepository(input) {
+    try {
+      const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
+        cwd: input.cwd,
+        signal: input.abortSignal
+      });
+      return parseGitHubRemoteUrl(stdout);
+    } catch {
+      return void 0;
+    }
+  }
+};
+var GitcrawlSyncClient = class {
+  #command;
+  constructor(options = {}) {
+    this.#command = options.command ?? "gitcrawl";
+  }
+  async syncPullRequest(input) {
+    try {
+      const args = [
+        "sync",
+        `${input.owner}/${input.repo}`,
+        "--numbers",
+        String(input.number),
+        ...input.includeComments === false ? [] : ["--include-comments"],
+        "--with",
+        "pr-details",
+        "--json"
+      ];
+      const { stdout, stderr } = await execFileAsync(this.#command, args, {
+        cwd: input.cwd,
+        signal: input.abortSignal,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return { ok: true, stdout, stderr };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async getPullRequestSnapshot(input) {
+    try {
+      const { stdout } = await execFileAsync(
+        this.#command,
+        ["threads", `${input.owner}/${input.repo}`, "--numbers", String(input.number), "--json"],
+        {
+          cwd: input.cwd,
+          signal: input.abortSignal,
+          maxBuffer: 10 * 1024 * 1024
+        }
+      );
+      const parsed = JSON.parse(stdout);
+      const thread = parsed.threads?.find((item) => readNumber(item.number) === input.number);
+      if (!thread) return void 0;
+      const owner = sqlString(input.owner);
+      const repo = sqlString(input.repo);
+      const number = input.number;
+      const [threadDetails] = await queryGitcrawlDb(`select t.state, t.closed_at_gh, t.merged_at_gh
+          from threads t
+          join repositories r on r.id=t.repo_id
+         where r.owner=${owner} and r.name=${repo} and t.number=${number}
+         limit 1`);
+      const [details] = await queryGitcrawlDb(`select d.head_sha, d.head_ref, d.mergeable_state,
+                 json_extract(d.raw_json, '$.merged_at') as merged_at
+          from pull_request_details d
+          join threads t on t.id=d.thread_id
+          join repositories r on r.id=t.repo_id
+         where r.owner=${owner} and r.name=${repo} and t.number=${number}
+         limit 1`);
+      const headSha = readString(details?.head_sha);
+      const checkRows = await queryGitcrawlDb(`select c.name, c.status, c.conclusion, c.workflow_name, c.details_url,
+                 coalesce(c.completed_at, c.started_at, c.fetched_at) as updated_at
+            from pull_request_checks c
+            join threads t on t.id=c.thread_id
+            join repositories r on r.id=t.repo_id
+           where r.owner=${owner} and r.name=${repo} and t.number=${number}${headSha ? ` and json_extract(c.raw_json, '$.head_sha')=${sqlString(headSha)}` : ""}`);
+      const workflowRows = details?.head_sha ? await queryGitcrawlDb(`select workflow_name, status, conclusion, html_url, updated_at_gh
+                from github_workflow_runs w
+                join repositories r on r.id=w.repo_id
+               where r.owner=${owner} and r.name=${repo} and w.head_sha=${sqlString(details.head_sha)}`) : [];
+      const [reviewState] = await queryGitcrawlDb(`select count(*) as unresolved_count,
+                 max(coalesce(first_comment_updated_at, first_comment_created_at, fetched_at)) as latest_review_thread_at
+            from pull_request_review_threads rt
+            join threads t on t.id=rt.thread_id
+            join repositories r on r.id=t.repo_id
+           where r.owner=${owner} and r.name=${repo} and t.number=${number} and rt.is_resolved=0`);
+      const latestComments = await queryGitcrawlDb(`select c.author_login, c.author_type, c.is_bot, c.body, json_extract(c.raw_json, '$.html_url') as html_url,
+                 coalesce(c.updated_at_gh, c.created_at_gh) as updated_at
+            from comments c
+            join threads t on t.id=c.thread_id
+            join repositories r on r.id=t.repo_id
+           where r.owner=${owner} and r.name=${repo} and t.number=${number}
+           order by coalesce(c.updated_at_gh, c.created_at_gh) desc
+           limit 20`);
+      const latestComment = latestComments[0];
+      const checks = normalizeGithubChecksForSnapshot({
+        checkRows: checkRows.map((row) => ({
+          source: "check",
+          name: readString(row.name) ?? "check",
+          status: readString(row.status),
+          conclusion: readString(row.conclusion),
+          workflowName: readString(row.workflow_name),
+          detailsUrl: readString(row.details_url),
+          updatedAt: readString(row.updated_at)
+        })),
+        workflowRows: workflowRows.map((row) => ({
+          source: "workflow",
+          name: readString(row.workflow_name) ?? "workflow",
+          status: readString(row.status),
+          conclusion: readString(row.conclusion),
+          workflowName: readString(row.workflow_name),
+          detailsUrl: readString(row.html_url),
+          updatedAt: readString(row.updated_at_gh)
+        }))
+      });
+      const ciState = checks.some((check) => check.conclusion === "failure" || check.conclusion === "timed_out") ? "failure" : checks.some((check) => check.status && check.status !== "completed") ? "pending" : checks.length > 0 ? "success" : "unknown";
+      const threadContentHash = readString(thread.content_hash);
+      const unresolvedReviewThreads = Number(reviewState?.unresolved_count ?? 0);
+      const reviewStateHash = snapshotHash({
+        unresolvedReviewThreads,
+        latestReviewThreadAt: reviewState?.latest_review_thread_at
+      });
+      const contentHash = snapshotHash({
+        threadContentHash,
+        state: thread.state,
+        headSha: details?.head_sha,
+        mergeableState: details?.mergeable_state,
+        ciState,
+        reviewStateHash,
+        checks: checks.map((check) => ({
+          name: check.name,
+          status: check.status,
+          conclusion: check.conclusion,
+          detailsUrl: check.detailsUrl,
+          updatedAt: check.updatedAt
+        }))
+      });
+      return {
+        title: readString(thread.title),
+        state: readString(details?.merged_at) || readString(threadDetails?.merged_at_gh) ? "merged" : readString(threadDetails?.state) ?? readString(thread.state),
+        htmlUrl: readString(thread.html_url),
+        githubUpdatedAt: readString(thread.updated_at_gh),
+        closedAt: readString(threadDetails?.closed_at_gh),
+        mergedAt: readString(details?.merged_at) ?? readString(threadDetails?.merged_at_gh),
+        threadContentHash,
+        contentHash,
+        headSha: readString(details?.head_sha),
+        headRef: readString(details?.head_ref),
+        mergeableState: readString(details?.mergeable_state),
+        checks,
+        ciState,
+        unresolvedReviewThreads,
+        reviewStateHash,
+        latestReviewThreadAt: readString(reviewState?.latest_review_thread_at),
+        latestCommentAuthor: readString(latestComment?.author_login),
+        latestCommentAuthorType: readString(latestComment?.author_type),
+        latestCommentIsBot: latestComment?.is_bot === 1,
+        latestCommentBody: sanitizeCommentBody(readString(latestComment?.body)),
+        latestCommentUrl: readString(latestComment?.html_url),
+        latestCommentUpdatedAt: readString(latestComment?.updated_at),
+        latestComments: latestComments.map((comment) => ({
+          author: readString(comment.author_login),
+          authorType: readString(comment.author_type),
+          isBot: comment.is_bot === 1,
+          body: sanitizeCommentBody(readString(comment.body)),
+          url: readString(comment.html_url),
+          updatedAt: readString(comment.updated_at)
+        }))
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+var GithubSignals = class extends SignalProvider {
+  id = "github-signals";
+  name = "GitHub Signals";
+  #ghMastra;
+  static signals = {
+    subscribeToPR(input) {
+      const normalized = typeof input === "number" ? { number: input } : input;
+      return {
+        type: "reactive",
+        tagName: GITHUB_SUBSCRIBE_PR_TAG,
+        contents: `Subscribe to GitHub PR #${normalized.number}`,
+        attributes: {
+          ...normalized.owner ? { owner: normalized.owner } : {},
+          ...normalized.repo ? { repo: normalized.repo } : {},
+          number: normalized.number
+        },
+        metadata: {
+          github: {
+            action: "subscribeToPR",
+            ...normalized
+          }
+        }
+      };
+    },
+    unsubscribeFromPR(input) {
+      const normalized = typeof input === "number" ? { number: input } : input;
+      return {
+        type: "reactive",
+        tagName: GITHUB_UNSUBSCRIBE_PR_TAG,
+        contents: `Unsubscribe from GitHub PR #${normalized.number}`,
+        attributes: {
+          ...normalized.owner ? { owner: normalized.owner } : {},
+          ...normalized.repo ? { repo: normalized.repo } : {},
+          number: normalized.number
+        },
+        metadata: {
+          github: {
+            action: "unsubscribeFromPR",
+            ...normalized
+          }
+        }
+      };
+    }
+  };
+  #options;
+  #syncClient;
+  #repositoryResolver;
+  #polling = /* @__PURE__ */ new Map();
+  #permissionCache = /* @__PURE__ */ new Map();
+  #agent;
+  #agentOptions = {};
+  #subscriptionsChangedHandler;
+  #pollingChangedHandler;
+  constructor(options = {}) {
+    super();
+    this.#options = options;
+    this.#syncClient = options.syncClient ?? new GitcrawlSyncClient({ command: options.gitcrawlCommand });
+    this.#repositoryResolver = options.repositoryResolver ?? new GitRemoteRepositoryResolver();
+    if (options.getNotificationStreamOptions) {
+      this.#agentOptions = { getNotificationStreamOptions: options.getNotificationStreamOptions };
+    }
+  }
+  /**
+   * @deprecated Use `Agent({ signals: [githubSignals] })` instead.
+   * Kept for backward compatibility.
+   */
+  addAgent(agent, options = {}) {
+    this.#agent = agent;
+    this.#agentOptions = options;
+  }
+  /**
+   * Called by the Agent constructor when this provider is passed via `signals: [...]`.
+   * Sets the bidirectional link so the provider can send signals back to the agent.
+   */
+  connect(agent) {
+    super.connect(agent);
+    this.#agent = agent;
+  }
+  getInputProcessors() {
+    return [this];
+  }
+  getOutputProcessors() {
+    return [this];
+  }
+  onSubscriptionsChanged(handler) {
+    this.#subscriptionsChangedHandler = handler;
+  }
+  onPollingChanged(handler) {
+    this.#pollingChangedHandler = handler;
+  }
+  __registerMastra(mastra) {
+    super.__registerMastra(mastra);
+    this.#ghMastra = mastra;
+  }
+  async syncThreadNow(input) {
+    return this.#pollThread(input, { includeComments: true });
+  }
+  async subscribeThreadToPR(input) {
+    const pr = typeof input.pr === "number" ? { number: input.pr } : input.pr;
+    return this.#subscribe({
+      id: `github-command-subscribe-${randomUUID()}`,
+      ...pr,
+      threadId: input.threadId,
+      resourceId: input.resourceId
+    });
+  }
+  async unsubscribeThreadFromPR(input) {
+    const pr = typeof input.pr === "number" ? { number: input.pr } : input.pr;
+    return this.#unsubscribe({
+      id: `github-command-unsubscribe-${randomUUID()}`,
+      ...pr,
+      threadId: input.threadId,
+      resourceId: input.resourceId
+    });
+  }
+  async startPollingForThread(input, options = {}) {
+    const subscriptions = await this.#getThreadSubscriptions(input);
+    if (subscriptions.length === 0) {
+      this.stopPollingForThread(input);
+      return false;
+    }
+    const key = this.#pollingKey(input);
+    for (const [pollingKey, state] of this.#polling.entries()) {
+      if (pollingKey === key) continue;
+      clearInterval(state.timer);
+      this.#polling.delete(pollingKey);
+    }
+    if (this.#polling.has(key)) return true;
+    const runPoll = (pollOptions = {}) => {
+      void this.#pollThread(input, pollOptions).catch((error) => {
+        console.warn("GitHub PR polling failed:", error);
+      });
+    };
+    const timer = setInterval(() => {
+      runPoll({ includeComments: true });
+    }, this.#options.pollIntervalMs ?? 3e5);
+    if (options.pollImmediately) runPoll({ includeComments: true });
+    timer.unref?.();
+    this.#polling.set(key, { ...input, timer, running: false });
+    return true;
+  }
+  stopPollingForThread(input) {
+    const key = this.#pollingKey(input);
+    const state = this.#polling.get(key);
+    if (!state) return;
+    clearInterval(state.timer);
+    this.#polling.delete(key);
+  }
+  isPollingThread(input) {
+    return this.#polling.has(this.#pollingKey(input));
+  }
+  isPollingThreadRunning(input) {
+    return this.#polling.get(this.#pollingKey(input))?.running ?? false;
+  }
+  getPollIntervalMs() {
+    return this.#options.pollIntervalMs ?? 3e5;
+  }
+  stopAllPolling() {
+    for (const state of this.#polling.values()) clearInterval(state.timer);
+    this.#polling.clear();
+  }
+  async pollThreadNow(input) {
+    return this.#pollThread(input, { includeComments: true });
+  }
+  async processInputStep(args) {
+    const tools = this.#createTools(args);
+    if (args.stepNumber !== 0) return { tools };
+    const signal = this.#findLatestGithubSignal(args.messages);
+    if (!signal) return { tools };
+    const threadContext = this.#getThreadContext(args);
+    if (signal.tagName === GITHUB_UNSUBSCRIBE_PR_TAG) {
+      const result2 = await this.#unsubscribe({ ...signal, ...threadContext, abortSignal: args.abortSignal });
+      await this.#sendStatus(args, result2, {
+        status: result2.removed ? "unsubscribed" : "not_subscribed",
+        action: "unsubscribeFromPR",
+        message: result2.removed ? `Unsubscribed from ${result2.owner}/${result2.repo}#${result2.number}.` : `No GitHub subscription found for ${result2.owner}/${result2.repo}#${result2.number}.`
+      });
+      return { tools };
+    }
+    const result = await this.#subscribe({ ...signal, ...threadContext, abortSignal: args.abortSignal });
+    if (result.alreadyProcessed) return { tools };
+    await this.#sendStatus(args, result, {
+      status: result.syncResult?.ok === false ? "sync_error" : "subscribed",
+      action: "subscribeToPR",
+      message: result.syncResult?.ok === false ? `Subscribed to ${result.owner}/${result.repo}#${result.number}, but gitcrawl sync failed: ${result.syncResult.error}` : `Subscribed to ${result.owner}/${result.repo}#${result.number}.`
+    });
+    return { tools };
+  }
+  async processOutputStep(args) {
+    const evidence = detectPrWorkEvidence({ text: args.text, toolCalls: args.toolCalls });
+    if (!evidence) return;
+    const threadContext = this.#getThreadContext(args);
+    if (!threadContext.threadId || !threadContext.resourceId) return;
+    const { threadStore, loadedThread } = await this.#loadThread(threadContext);
+    const githubMetadata = getGithubMetadata(loadedThread.metadata);
+    if (githubMetadata.subscriptionHintShown || githubMetadata.subscriptions.length > 0) return;
+    let repository;
+    try {
+      repository = await this.#resolveRepository({
+        id: "github-subscription-hint",
+        owner: evidence.owner,
+        repo: evidence.repo,
+        number: evidence.number
+      });
+    } catch {
+      return;
+    }
+    await threadStore.saveThread({
+      thread: {
+        ...loadedThread,
+        id: threadContext.threadId,
+        resourceId: threadContext.resourceId,
+        createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        metadata: setGithubMetadata(loadedThread.metadata, { ...githubMetadata, subscriptionHintShown: true })
+      }
+    });
+    await args.sendSignal?.({
+      type: "reactive",
+      tagName: "system-reminder",
+      contents: `Looks like you're working with ${repository.owner}/${repository.repo}#${evidence.number}. Use /github subscribe ${evidence.number} or the github_subscribe_pr tool to follow updates.`,
+      attributes: { type: "github-subscription-hint" },
+      metadata: {
+        github: {
+          action: "subscriptionHint",
+          owner: repository.owner,
+          repo: repository.repo,
+          number: evidence.number
+        }
+      }
+    });
+  }
+  async #resolveThreadStore() {
+    if (this.#options.threadStore) return this.#options.threadStore;
+    const storage = this.#ghMastra?.getStorage?.();
+    const memoryStore = storage?.getStore ? await storage.getStore("memory") : void 0;
+    return memoryStore;
+  }
+  #getThreadContext(args) {
+    const memoryContext = args.requestContext?.get("MastraMemory");
+    return { threadId: memoryContext?.thread?.id, resourceId: memoryContext?.resourceId };
+  }
+  #createTools(args) {
+    const threadContext = this.#getThreadContext(args);
+    const getExecutionThreadContext = (context) => ({
+      threadId: context?.agent?.threadId ?? threadContext.threadId,
+      resourceId: context?.agent?.resourceId ?? threadContext.resourceId
+    });
+    return {
+      ...args.tools,
+      github_subscribe_pr: createGithubTool({
+        id: "github_subscribe_pr",
+        description: "Subscribe this thread to a GitHub pull request. Syncs only the requested PR with gitcrawl and stores the subscription on the thread.",
+        inputSchema: z.object({
+          number: z.number().int().positive(),
+          owner: z.string().optional(),
+          repo: z.string().optional()
+        }),
+        execute: async (input, context) => {
+          const executionThreadContext = getExecutionThreadContext(context);
+          const result = await this.#subscribe({
+            id: `github-tool-subscribe-${randomUUID()}`,
+            owner: input.owner,
+            repo: input.repo,
+            number: input.number,
+            threadId: executionThreadContext.threadId,
+            resourceId: executionThreadContext.resourceId
+          });
+          return {
+            subscribed: true,
+            owner: result.owner,
+            repo: result.repo,
+            number: result.number,
+            syncStatus: result.syncResult?.ok === false ? "error" : result.syncResult ? "success" : void 0,
+            message: result.syncResult?.ok === false ? `Subscribed to ${result.owner}/${result.repo}#${result.number}, but gitcrawl sync failed: ${result.syncResult.error}` : `Subscribed to ${result.owner}/${result.repo}#${result.number}.`
+          };
+        }
+      }),
+      github_unsubscribe_pr: createGithubTool({
+        id: "github_unsubscribe_pr",
+        description: "Unsubscribe this thread from a GitHub pull request.",
+        inputSchema: z.object({
+          number: z.number().int().positive(),
+          owner: z.string().optional(),
+          repo: z.string().optional()
+        }),
+        execute: async (input, context) => {
+          const executionThreadContext = getExecutionThreadContext(context);
+          const result = await this.#unsubscribe({
+            id: `github-tool-unsubscribe-${randomUUID()}`,
+            owner: input.owner,
+            repo: input.repo,
+            number: input.number,
+            threadId: executionThreadContext.threadId,
+            resourceId: executionThreadContext.resourceId
+          });
+          return {
+            unsubscribed: result.removed ?? false,
+            owner: result.owner,
+            repo: result.repo,
+            number: result.number,
+            remainingSubscriptions: result.remainingSubscriptions,
+            message: result.removed ? `Unsubscribed from ${result.owner}/${result.repo}#${result.number}.` : `No GitHub subscription found for ${result.owner}/${result.repo}#${result.number}.`
+          };
+        }
+      })
+    };
+  }
+  async #resolveRepository(input) {
+    const resolvedRepository = input.owner && input.repo ? { owner: input.owner, repo: input.repo } : this.#options.owner && this.#options.repo ? { owner: this.#options.owner, repo: this.#options.repo } : await this.#repositoryResolver.resolveRepository({
+      cwd: this.#options.cwd,
+      abortSignal: input.abortSignal
+    });
+    if (!resolvedRepository?.owner || !resolvedRepository.repo) {
+      throw new Error(
+        "GitHub PR subscription requires owner and repo. Run inside a GitHub repo or pass owner and repo."
+      );
+    }
+    return resolvedRepository;
+  }
+  async #loadThread(input) {
+    const threadStore = await this.#resolveThreadStore();
+    if (!threadStore) throw new Error("GitHub PR subscription requires memory-backed thread storage.");
+    if (!input.threadId || !input.resourceId)
+      throw new Error("GitHub PR subscription requires threadId and resourceId.");
+    const loadedThread = await threadStore.getThreadById({ threadId: input.threadId, resourceId: input.resourceId }) ?? void 0;
+    if (!loadedThread) throw new Error(`Could not load thread ${input.threadId}.`);
+    return { threadStore, loadedThread };
+  }
+  #pollingKey(input) {
+    return `${input.resourceId}:${input.threadId}`;
+  }
+  #getNotificationAgent(_input) {
+    if (this.#agent) return this.#agent;
+    const agentId = _input?.agentId ?? this.#options.agentId;
+    return agentId ? this.#ghMastra?.getAgentById?.(agentId) : void 0;
+  }
+  async #getThreadSubscriptions(input) {
+    const { loadedThread } = await this.#loadThread(input);
+    return getGithubMetadata(loadedThread.metadata).subscriptions;
+  }
+  #notifySubscriptionsChanged(input) {
+    this.#subscriptionsChangedHandler?.(input);
+  }
+  #notifyPollingChanged(input) {
+    this.#pollingChangedHandler?.(input);
+  }
+  async #pollThread(input, options = {}) {
+    const key = this.#pollingKey(input);
+    const state = this.#polling.get(key);
+    if (state?.running) {
+      return 0;
+    }
+    if (state) state.running = true;
+    this.#notifyPollingChanged({ threadId: input.threadId, resourceId: input.resourceId, running: true });
+    try {
+      const { threadStore, loadedThread } = await this.#loadThread(input);
+      const githubMetadata = getGithubMetadata(loadedThread.metadata);
+      if (githubMetadata.subscriptions.length === 0) {
+        this.stopPollingForThread(input);
+        return 0;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const subscriptions = [];
+      for (const subscription of githubMetadata.subscriptions) {
+        const syncInput = {
+          owner: subscription.owner,
+          repo: subscription.repo,
+          number: subscription.number,
+          cwd: this.#options.cwd,
+          includeComments: options.includeComments
+        };
+        const syncResult = await this.#syncClient.syncPullRequest(syncInput);
+        let snapshot = syncResult.ok ? await this.#syncClient.getPullRequestSnapshot?.(syncInput) : void 0;
+        if (snapshot)
+          snapshot = await this.#filterUnauthorizedLatestComment(subscription.owner, subscription.repo, snapshot);
+        const nextSubscription = {
+          ...subscription,
+          updatedAt: now,
+          lastSyncAt: now,
+          lastSyncStatus: syncResult.ok ? "success" : "error"
+        };
+        if (syncResult.error) nextSubscription.lastSyncError = syncResult.error;
+        else delete nextSubscription.lastSyncError;
+        const previousGithubUpdatedAt = subscription.lastObservedGithubUpdatedAt;
+        const previousContentHash = subscription.lastObservedContentHash;
+        const previousThreadContentHash = subscription.lastObservedThreadContentHash;
+        const previousHeadSha = subscription.lastObservedHeadSha;
+        const latestCommentChanged = !!previousGithubUpdatedAt && !!snapshot?.latestCommentUpdatedAt && Date.parse(snapshot.latestCommentUpdatedAt) > Date.parse(previousGithubUpdatedAt);
+        if (snapshot) applySnapshotCursor(nextSubscription, snapshot);
+        const isFirstObservation = syncResult.ok && snapshot && !previousGithubUpdatedAt && !previousContentHash;
+        const legacyAggregateChanged = previousContentHash && snapshot?.contentHash && previousContentHash !== snapshot.contentHash && !previousThreadContentHash && !previousHeadSha;
+        const changed = isFirstObservation || syncResult.ok && snapshot && (legacyAggregateChanged || latestCommentChanged || previousThreadContentHash && snapshot.threadContentHash && previousThreadContentHash !== snapshot.threadContentHash || previousHeadSha && snapshot.headSha && previousHeadSha !== snapshot.headSha || subscription.lastObservedState && snapshot.state && subscription.lastObservedState !== snapshot.state || subscription.lastObservedMergeableState && snapshot.mergeableState && subscription.lastObservedMergeableState !== snapshot.mergeableState || subscription.lastObservedCiState && snapshot.ciState && subscription.lastObservedCiState !== snapshot.ciState || subscription.lastObservedReviewStateHash && snapshot.reviewStateHash && subscription.lastObservedReviewStateHash !== snapshot.reviewStateHash);
+        let shouldKeepSubscription = true;
+        if (changed && snapshot) {
+          const notifications = await this.#sendActivityNotifications({
+            polling: input,
+            subscription,
+            snapshot,
+            previousGithubUpdatedAt,
+            previousContentHash,
+            latestCommentChanged
+          });
+          const primaryNotification = notifications[0];
+          if (primaryNotification) {
+            nextSubscription.lastNotificationAt = now;
+            nextSubscription.lastNotificationKind = primaryNotification.kind;
+            nextSubscription.lastNotificationPriority = primaryNotification.priority;
+            nextSubscription.lastNotificationSummary = primaryNotification.summary;
+            shouldKeepSubscription = notifications.every((notification) => notification.kind !== "pull-request-merged");
+          }
+        }
+        if (shouldKeepSubscription) subscriptions.push(nextSubscription);
+      }
+      await threadStore.saveThread({
+        thread: {
+          ...loadedThread,
+          id: input.threadId,
+          resourceId: input.resourceId,
+          createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
+        }
+      });
+      this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
+      if (subscriptions.length === 0) this.stopPollingForThread(input);
+      return subscriptions.length;
+    } catch (error) {
+      throw error;
+    } finally {
+      const latestState = this.#polling.get(key);
+      if (latestState) latestState.running = false;
+      this.#notifyPollingChanged({ threadId: input.threadId, resourceId: input.resourceId, running: false });
+    }
+  }
+  #createGithubNotificationInput(input) {
+    const failingChecks = getFailingChecks(input.snapshot);
+    const pendingChecks = getPendingChecks(input.snapshot);
+    const latestCommentExcerpt = input.snapshot.latestCommentBody ? getCommentExcerpt(input.snapshot.latestCommentBody) : void 0;
+    const latestCommentDedupeSuffix = input.notification.kind === "pull-request-activity" && input.snapshot.latestCommentUrl ? `comment:${input.snapshot.latestCommentUrl}:${input.snapshot.latestCommentUpdatedAt ?? ""}` : input.dedupeSuffix;
+    const notificationInput = {
+      source: "github",
+      kind: input.notification.kind,
+      priority: input.notification.priority,
+      summary: input.notification.summary,
+      dedupeKey: `github:${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}:${latestCommentDedupeSuffix}`,
+      coalesceKey: `github:${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}:${input.notification.kind}`,
+      attributes: {
+        owner: input.subscription.owner,
+        repo: input.subscription.repo,
+        number: input.subscription.number,
+        ...input.snapshot.title ? { title: input.snapshot.title } : {},
+        ...input.snapshot.state ? { state: input.snapshot.state } : {},
+        ...input.snapshot.htmlUrl ? { url: input.snapshot.htmlUrl } : {},
+        ...input.snapshot.githubUpdatedAt ? { githubUpdatedAt: input.snapshot.githubUpdatedAt } : {},
+        ...input.previousGithubUpdatedAt ? { previousGithubUpdatedAt: input.previousGithubUpdatedAt } : {},
+        ...input.snapshot.mergeableState ? { mergeableState: input.snapshot.mergeableState } : {},
+        ...input.snapshot.ciState ? { ciState: input.snapshot.ciState } : {},
+        ...input.snapshot.unresolvedReviewThreads !== void 0 ? { unresolvedReviewThreads: input.snapshot.unresolvedReviewThreads } : {},
+        ...input.snapshot.latestCommentAuthor ? { latestCommentAuthor: input.snapshot.latestCommentAuthor } : {},
+        ...latestCommentExcerpt ? { latestCommentExcerpt } : {},
+        ...input.snapshot.latestCommentUrl ? { latestCommentUrl: input.snapshot.latestCommentUrl } : {},
+        ...input.snapshot.latestCommentUpdatedAt ? { latestCommentUpdatedAt: input.snapshot.latestCommentUpdatedAt } : {},
+        ...failingChecks.length > 0 ? { failingChecks: failingChecks.map((check) => check.name).join(", ") } : {},
+        ...pendingChecks.length > 0 ? { pendingChecks: pendingChecks.map((check) => check.name).join(", ") } : {}
+      },
+      metadata: {
+        github: {
+          owner: input.subscription.owner,
+          repo: input.subscription.repo,
+          number: input.subscription.number,
+          title: input.snapshot.title,
+          state: input.snapshot.state,
+          htmlUrl: input.snapshot.htmlUrl,
+          githubUpdatedAt: input.snapshot.githubUpdatedAt,
+          previousGithubUpdatedAt: input.previousGithubUpdatedAt,
+          contentHash: input.snapshot.contentHash,
+          previousContentHash: input.previousContentHash,
+          threadContentHash: input.snapshot.threadContentHash,
+          headSha: input.snapshot.headSha,
+          headRef: input.snapshot.headRef,
+          mergeableState: input.snapshot.mergeableState,
+          ciState: input.snapshot.ciState,
+          closedAt: input.snapshot.closedAt,
+          mergedAt: input.snapshot.mergedAt,
+          unresolvedReviewThreads: input.snapshot.unresolvedReviewThreads,
+          reviewStateHash: input.snapshot.reviewStateHash,
+          latestReviewThreadAt: input.snapshot.latestReviewThreadAt,
+          latestCommentAuthor: input.snapshot.latestCommentAuthor,
+          latestCommentAuthorType: input.snapshot.latestCommentAuthorType,
+          latestCommentIsBot: input.snapshot.latestCommentIsBot,
+          // Intentionally omit the full latestCommentBody here: persisting it verbatim bloats
+          // notification payloads (a single CodeRabbit comment can exceed 100KB) and can overflow
+          // agent context windows when listed. The 240-char latestCommentExcerpt is stored instead.
+          latestCommentExcerpt,
+          latestCommentUrl: input.snapshot.latestCommentUrl,
+          latestCommentUpdatedAt: input.snapshot.latestCommentUpdatedAt,
+          failingChecks,
+          pendingChecks
+        }
+      }
+    };
+    return notificationInput;
+  }
+  async #sendGithubNotification(input) {
+    const notificationInput = this.#createGithubNotificationInput(input);
+    const streamOptions = await this.#agentOptions.getNotificationStreamOptions?.(input.target);
+    await input.agent?.sendNotificationSignal?.(
+      notificationInput,
+      streamOptions ? { ...input.target, ifIdle: { streamOptions } } : input.target
+    );
+  }
+  async #sendBaselineNotification(input) {
+    const agent = this.#getNotificationAgent({});
+    if (!agent?.sendNotificationSignal) return;
+    await this.#sendGithubNotification({
+      agent,
+      subscription: input.subscription,
+      snapshot: input.snapshot,
+      notification: classifyGithubBaselineNotification({ subscription: input.subscription, snapshot: input.snapshot }),
+      target: { resourceId: input.resourceId, threadId: input.threadId },
+      dedupeSuffix: `baseline:${input.subscription.lastSubscribeSignalId}`
+    });
+  }
+  async #isAuthorizedAuthor(owner, repo, user, metadata = {}) {
+    if (!user) return false;
+    const normalizedUser = user.toLowerCase();
+    const isBot = metadata.isBot === true || metadata.authorType?.toLowerCase() === "bot" || normalizedUser.endsWith("[bot]");
+    if (isBot) {
+      const ignoredBots = this.#options.ignoredBots ?? [];
+      if (ignoredBots.some((bot) => bot.toLowerCase() === normalizedUser)) return false;
+      const authorizedBots = this.#options.authorizedBots ?? DEFAULT_AUTHORIZED_BOTS;
+      return authorizedBots.some((bot) => bot.toLowerCase() === normalizedUser);
+    }
+    const permission = await this.#loadAuthorPermission(owner, repo, user);
+    const authorizedPermissions = this.#options.authorizedPermissions ?? DEFAULT_AUTHORIZED_PERMISSIONS;
+    return !!permission && authorizedPermissions.includes(permission);
+  }
+  async #filterUnauthorizedLatestComment(owner, repo, snapshot) {
+    const comments = snapshot.latestComments?.length ? snapshot.latestComments : [
+      {
+        author: snapshot.latestCommentAuthor,
+        authorType: snapshot.latestCommentAuthorType,
+        isBot: snapshot.latestCommentIsBot,
+        body: snapshot.latestCommentBody,
+        url: snapshot.latestCommentUrl,
+        updatedAt: snapshot.latestCommentUpdatedAt
+      }
+    ];
+    if (!comments.some((comment) => comment.author)) return snapshot;
+    if (!comments.some((comment) => comment.body || comment.url || comment.updatedAt)) return snapshot;
+    for (const comment of comments) {
+      if (!await this.#isAuthorizedAuthor(owner, repo, comment.author, {
+        authorType: comment.authorType,
+        isBot: comment.isBot
+      })) {
+        continue;
+      }
+      return {
+        ...snapshot,
+        latestCommentAuthor: comment.author,
+        latestCommentAuthorType: comment.authorType,
+        latestCommentIsBot: comment.isBot,
+        latestCommentBody: comment.body,
+        latestCommentUrl: comment.url,
+        latestCommentUpdatedAt: comment.updatedAt
+      };
+    }
+    return {
+      ...snapshot,
+      latestCommentAuthor: void 0,
+      latestCommentAuthorType: void 0,
+      latestCommentIsBot: void 0,
+      latestCommentBody: void 0,
+      latestCommentUrl: void 0,
+      latestCommentUpdatedAt: void 0
+    };
+  }
+  async #loadAuthorPermission(owner, repo, user) {
+    const cacheKey = `${owner}/${repo}:${user.toLowerCase()}`;
+    const cached = this.#permissionCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) return cached.permission;
+    if (cached) this.#permissionCache.delete(cacheKey);
+    try {
+      let permission;
+      if (this.#options.permissionResolver) {
+        permission = await this.#options.permissionResolver.getPermission(owner, repo, user);
+      } else {
+        const { stdout } = await execFileAsync("gh", [
+          "api",
+          `repos/${owner}/${repo}/collaborators/${user}/permission`,
+          "--jq",
+          ".permission"
+        ]);
+        const raw = stdout.trim();
+        permission = ["admin", "maintain", "write", "triage", "read", "none"].includes(
+          raw
+        ) ? raw : void 0;
+      }
+      if (permission) {
+        this.#permissionCache.set(cacheKey, { permission, expiresAt: Date.now() + PERMISSION_CACHE_TTL_MS });
+      }
+      return permission;
+    } catch {
+      this.#permissionCache.delete(cacheKey);
+      return void 0;
+    }
+  }
+  async #sendActivityNotifications(input) {
+    const agent = this.#getNotificationAgent(input.polling);
+    if (!agent?.sendNotificationSignal) return [];
+    const notifications = [
+      classifyGithubActivityNotification({
+        subscription: input.subscription,
+        snapshot: input.snapshot
+      })
+    ];
+    if (input.latestCommentChanged && notifications[0]?.kind !== "pull-request-activity") {
+      notifications.push(
+        classifyGithubCommentActivityNotification({
+          subscription: input.subscription,
+          snapshot: input.snapshot
+        })
+      );
+    }
+    const sent = [];
+    const notificationInputs = [];
+    for (const notification of notifications.sort(compareGithubActivityNotifications)) {
+      if (!notification) continue;
+      if (AUTHOR_GATED_NOTIFICATION_KINDS.has(notification.kind)) {
+        const authorized = await this.#isAuthorizedAuthor(
+          input.subscription.owner,
+          input.subscription.repo,
+          input.snapshot.latestCommentAuthor,
+          {
+            authorType: input.snapshot.latestCommentAuthorType,
+            isBot: input.snapshot.latestCommentIsBot
+          }
+        );
+        if (!authorized) continue;
+      }
+      notificationInputs.push(
+        this.#createGithubNotificationInput({
+          subscription: input.subscription,
+          snapshot: input.snapshot,
+          notification,
+          dedupeSuffix: input.snapshot.contentHash ?? input.snapshot.githubUpdatedAt ?? String(Date.now()),
+          previousGithubUpdatedAt: input.previousGithubUpdatedAt,
+          previousContentHash: input.previousContentHash
+        })
+      );
+      sent.push(notification);
+    }
+    if (notificationInputs.length > 0) {
+      const target = { resourceId: input.polling.resourceId, threadId: input.polling.threadId };
+      const streamOptions = await this.#agentOptions.getNotificationStreamOptions?.(target);
+      await agent.sendNotificationSignal(
+        notificationInputs,
+        streamOptions ? { ...target, ifIdle: { streamOptions } } : target
+      );
+    }
+    return sent;
+  }
+  async #subscribe(input) {
+    const { owner, repo } = await this.#resolveRepository(input);
+    const { threadStore, loadedThread } = await this.#loadThread(input);
+    const githubMetadata = getGithubMetadata(loadedThread.metadata);
+    const existingIndex = githubMetadata.subscriptions.findIndex(
+      (subscription2) => subscription2.owner === owner && subscription2.repo === repo && subscription2.number === input.number
+    );
+    const existing = existingIndex >= 0 ? githubMetadata.subscriptions[existingIndex] : void 0;
+    if (existing?.lastSubscribeSignalId === input.id) {
+      return { owner, repo, number: input.number, subscription: existing, alreadyProcessed: true };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const subscription = {
+      owner,
+      repo,
+      number: input.number,
+      subscribedAt: existing?.subscribedAt ?? now,
+      updatedAt: now,
+      lastSubscribeSignalId: input.id,
+      ...existing?.lastSyncAt ? { lastSyncAt: existing.lastSyncAt } : {},
+      ...existing?.lastSyncStatus ? { lastSyncStatus: existing.lastSyncStatus } : {},
+      ...existing?.lastSyncError ? { lastSyncError: existing.lastSyncError } : {},
+      ...existing?.lastObservedGithubUpdatedAt ? { lastObservedGithubUpdatedAt: existing.lastObservedGithubUpdatedAt } : {},
+      ...existing?.lastObservedContentHash ? { lastObservedContentHash: existing.lastObservedContentHash } : {},
+      ...existing?.lastObservedThreadContentHash ? { lastObservedThreadContentHash: existing.lastObservedThreadContentHash } : {},
+      ...existing?.lastObservedHeadSha ? { lastObservedHeadSha: existing.lastObservedHeadSha } : {},
+      ...existing?.lastObservedState ? { lastObservedState: existing.lastObservedState } : {},
+      ...existing?.lastObservedMergeableState ? { lastObservedMergeableState: existing.lastObservedMergeableState } : {},
+      ...existing?.lastObservedCiState ? { lastObservedCiState: existing.lastObservedCiState } : {},
+      ...existing?.lastObservedReviewStateHash ? { lastObservedReviewStateHash: existing.lastObservedReviewStateHash } : {}
+    };
+    let syncResult;
+    let baselineSnapshot;
+    if (this.#options.syncOnSubscribe !== false) {
+      const syncInput = {
+        owner,
+        repo,
+        number: input.number,
+        cwd: this.#options.cwd,
+        abortSignal: input.abortSignal
+      };
+      syncResult = await this.#syncClient.syncPullRequest(syncInput);
+      subscription.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+      subscription.lastSyncStatus = syncResult.ok ? "success" : "error";
+      if (syncResult.error) subscription.lastSyncError = syncResult.error;
+      else delete subscription.lastSyncError;
+      const snapshot = syncResult.ok ? await this.#syncClient.getPullRequestSnapshot?.(syncInput) : void 0;
+      baselineSnapshot = snapshot;
+      if (snapshot) applySnapshotCursor(subscription, snapshot);
+    } else {
+      subscription.lastSyncStatus = "skipped";
+    }
+    const subscriptions = [subscription];
+    await threadStore.saveThread({
+      thread: {
+        ...loadedThread,
+        id: input.threadId,
+        resourceId: input.resourceId,
+        createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
+      }
+    });
+    this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
+    if (baselineSnapshot) {
+      await this.#sendBaselineNotification({
+        threadId: input.threadId,
+        resourceId: input.resourceId,
+        subscription,
+        snapshot: baselineSnapshot
+      });
+    }
+    await this.startPollingForThread({ threadId: input.threadId, resourceId: input.resourceId });
+    return { owner, repo, number: input.number, subscription, syncResult };
+  }
+  async #unsubscribe(input) {
+    const { owner, repo } = await this.#resolveRepository(input);
+    const { threadStore, loadedThread } = await this.#loadThread(input);
+    const githubMetadata = getGithubMetadata(loadedThread.metadata);
+    const subscriptions = githubMetadata.subscriptions.filter(
+      (subscription) => !(subscription.owner === owner && subscription.repo === repo && subscription.number === input.number)
+    );
+    const removed = subscriptions.length !== githubMetadata.subscriptions.length;
+    if (removed) {
+      await threadStore.saveThread({
+        thread: {
+          ...loadedThread,
+          id: input.threadId,
+          resourceId: input.resourceId,
+          createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
+        }
+      });
+      this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
+      if (subscriptions.length === 0)
+        this.stopPollingForThread({ threadId: input.threadId, resourceId: input.resourceId });
+    }
+    return { owner, repo, number: input.number, removed, remainingSubscriptions: subscriptions.length };
+  }
+  #findLatestGithubSignal(messages) {
+    const message = messages.at(-1);
+    if (!message) return void 0;
+    const signal = getSignalMetadata(message);
+    if (!signal || signal.tagName !== GITHUB_SUBSCRIBE_PR_TAG && signal.tagName !== GITHUB_UNSUBSCRIBE_PR_TAG) {
+      return void 0;
+    }
+    const attributes = isPlainObject(signal.attributes) ? signal.attributes : {};
+    const metadata = isPlainObject(signal.metadata) ? signal.metadata : {};
+    const github = isPlainObject(metadata.github) ? metadata.github : {};
+    const number = readNumber(attributes.number) ?? readNumber(github.number);
+    if (!number) return void 0;
+    return {
+      tagName: String(signal.tagName),
+      id: readString(signal.id) ?? message.id,
+      owner: readString(attributes.owner) ?? readString(github.owner),
+      repo: readString(attributes.repo) ?? readString(github.repo),
+      number
+    };
+  }
+  async #sendStatus(args, signal, status) {
+    await args.sendSignal?.({
+      type: "reactive",
+      tagName: GITHUB_SYNC_STATUS_TAG,
+      contents: status.message,
+      attributes: {
+        status: status.status,
+        owner: signal.owner,
+        repo: signal.repo,
+        number: signal.number
+      },
+      metadata: {
+        github: {
+          action: status.action,
+          status: status.status,
+          owner: signal.owner,
+          repo: signal.repo,
+          number: signal.number
+        }
+      }
+    });
+  }
+};
+
+export { GITHUB_SIGNALS_METADATA_KEY, GITHUB_SUBSCRIBE_PR_TAG, GITHUB_SYNC_STATUS_TAG, GITHUB_UNSUBSCRIBE_PR_TAG, GitRemoteRepositoryResolver, GitcrawlSyncClient, GithubSignals, normalizeGithubChecksForSnapshot, sanitizeCommentText };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map