@mastra/github-signals 0.0.0

package/dist/index.cjs

@@ -0,0 +1,1135 @@
+'use strict';
+
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
+var util = require('util');
+var signals = require('@mastra/core/signals');
+var tools = require('@mastra/core/tools');
+var z = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var z__default = /*#__PURE__*/_interopDefault(z);
+
+// src/index.ts
+var _execFileAsync;
+async function execFileAsync(file, args, options) {
+  if (!_execFileAsync) {
+    const cp = await import('child_process');
+    _execFileAsync = util.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 createGithubTool = tools.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 crypto.createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function resolveHomePath(path$1) {
+  return path$1.startsWith("~/") ? path.join(os.homedir(), path$1.slice(2)) : path$1;
+}
+async function getGitcrawlDbPath() {
+  if (process.env.GITCRAWL_DB_PATH) return resolveHomePath(process.env.GITCRAWL_DB_PATH);
+  const configPath = process.env.GITCRAWL_CONFIG_PATH ?? path.join(os.homedir(), ".config", "gitcrawl", "config.toml");
+  try {
+    const config = await promises.readFile(resolveHomePath(configPath), "utf8");
+    const match = /^\s*db_path\s*=\s*['\"]([^'\"]+)['\"]/m.exec(config);
+    if (match?.[1]) return resolveHomePath(match[1]);
+  } catch {
+  }
+  return path.join(os.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 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;
+  return {
+    kind: "pull-request-activity",
+    priority: "medium",
+    summary: `${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 [latestComment] = await queryGitcrawlDb(`select c.author_login, c.author_type, c.is_bot
+            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 1`);
+      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
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+var GithubSignals = class extends signals.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();
+  #agent;
+  #agentOptions = {};
+  #subscriptionsChangedHandler;
+  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;
+  }
+  __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-${crypto.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-${crypto.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;
+    let scheduledPollCount = options.pollImmediately ? 1 : 0;
+    const runPoll = (pollOptions = {}) => {
+      void this.#pollThread(input, pollOptions).catch((error) => {
+        console.warn("GitHub PR polling failed:", error);
+      });
+    };
+    const timer = setInterval(() => {
+      scheduledPollCount += 1;
+      runPoll({ includeComments: scheduledPollCount % 2 === 1 });
+    }, 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));
+  }
+  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 args.messages;
+    const threadContext = this.#getThreadContext(args);
+    if (!threadContext.threadId || !threadContext.resourceId) return args.messages;
+    const { threadStore, loadedThread } = await this.#loadThread(threadContext);
+    const githubMetadata = getGithubMetadata(loadedThread.metadata);
+    if (githubMetadata.subscriptionHintShown || githubMetadata.subscriptions.length > 0) return args.messages;
+    let repository;
+    try {
+      repository = await this.#resolveRepository({
+        id: "github-subscription-hint",
+        owner: evidence.owner,
+        repo: evidence.repo,
+        number: evidence.number
+      });
+    } catch {
+      return args.messages;
+    }
+    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
+        }
+      }
+    });
+    return args.messages;
+  }
+  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);
+    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__default.default.object({
+          number: z__default.default.number().int().positive(),
+          owner: z__default.default.string().optional(),
+          repo: z__default.default.string().optional()
+        }),
+        execute: async (input) => {
+          const result = await this.#subscribe({
+            id: `github-tool-subscribe-${crypto.randomUUID()}`,
+            owner: input.owner,
+            repo: input.repo,
+            number: input.number,
+            threadId: threadContext.threadId,
+            resourceId: threadContext.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__default.default.object({
+          number: z__default.default.number().int().positive(),
+          owner: z__default.default.string().optional(),
+          repo: z__default.default.string().optional()
+        }),
+        execute: async (input) => {
+          const result = await this.#unsubscribe({
+            id: `github-tool-unsubscribe-${crypto.randomUUID()}`,
+            owner: input.owner,
+            repo: input.repo,
+            number: input.number,
+            threadId: threadContext.threadId,
+            resourceId: threadContext.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);
+  }
+  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;
+    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);
+        const snapshot = syncResult.ok ? await this.#syncClient.getPullRequestSnapshot?.(syncInput) : void 0;
+        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;
+        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 || 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) {
+          const notification = await this.#sendActivityNotification({
+            polling: input,
+            subscription,
+            snapshot,
+            previousGithubUpdatedAt,
+            previousContentHash
+          });
+          if (notification) {
+            nextSubscription.lastNotificationAt = now;
+            nextSubscription.lastNotificationKind = notification.kind;
+            nextSubscription.lastNotificationPriority = notification.priority;
+            nextSubscription.lastNotificationSummary = notification.summary;
+            shouldKeepSubscription = 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;
+    }
+  }
+  async #sendGithubNotification(input) {
+    const failingChecks = getFailingChecks(input.snapshot);
+    const pendingChecks = getPendingChecks(input.snapshot);
+    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}:${input.dedupeSuffix}`,
+      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 } : {},
+        ...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,
+          failingChecks,
+          pendingChecks
+        }
+      }
+    };
+    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 #sendActivityNotification(input) {
+    const agent = this.#getNotificationAgent(input.polling);
+    if (!agent?.sendNotificationSignal) return void 0;
+    const notification = classifyGithubActivityNotification({
+      subscription: input.subscription,
+      snapshot: input.snapshot
+    });
+    if (!notification) return void 0;
+    await this.#sendGithubNotification({
+      agent,
+      subscription: input.subscription,
+      snapshot: input.snapshot,
+      notification,
+      target: { resourceId: input.polling.resourceId, threadId: input.polling.threadId },
+      dedupeSuffix: input.snapshot.contentHash ?? input.snapshot.githubUpdatedAt ?? String(Date.now()),
+      previousGithubUpdatedAt: input.previousGithubUpdatedAt,
+      previousContentHash: input.previousContentHash
+    });
+    return notification;
+  }
+  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
+        }
+      }
+    });
+  }
+};
+
+exports.GITHUB_SIGNALS_METADATA_KEY = GITHUB_SIGNALS_METADATA_KEY;
+exports.GITHUB_SUBSCRIBE_PR_TAG = GITHUB_SUBSCRIBE_PR_TAG;
+exports.GITHUB_SYNC_STATUS_TAG = GITHUB_SYNC_STATUS_TAG;
+exports.GITHUB_UNSUBSCRIBE_PR_TAG = GITHUB_UNSUBSCRIBE_PR_TAG;
+exports.GitRemoteRepositoryResolver = GitRemoteRepositoryResolver;
+exports.GitcrawlSyncClient = GitcrawlSyncClient;
+exports.GithubSignals = GithubSignals;
+exports.normalizeGithubChecksForSnapshot = normalizeGithubChecksForSnapshot;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map