@adriandmitroca/relay 0.0.2

package/src/sources/jira.ts

@@ -0,0 +1,255 @@
+import type { NormalizedIssue, Severity, SourceAdapter } from "./types.ts";
+import type { JiraSourceConfig } from "../config.ts";
+import { logger } from "../utils/logger.ts";
+
+export class JiraAdapter implements SourceAdapter {
+  readonly name = "jira";
+  private configs: Map<string, JiraSourceConfig> = new Map();
+  private authHeaders: Map<string, Record<string, string>> = new Map();
+
+  constructor() {}
+
+  addProject(projectKey: string, config: JiraSourceConfig) {
+    this.configs.set(projectKey, config);
+    const encoded = btoa(`${config.email}:${config.apiToken}`);
+    this.authHeaders.set(projectKey, {
+      Authorization: `Basic ${encoded}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    });
+  }
+
+  async poll(projectKey: string): Promise<NormalizedIssue[]> {
+    const config = this.configs.get(projectKey);
+    if (!config) return [];
+
+    const jql = config.filterMode === "jql" && config.jql
+      ? config.jql
+      : buildJQL(config);
+
+    const url = `https://${config.host}/rest/api/3/search/jql?jql=${encodeURIComponent(jql)}&maxResults=50&fields=summary,description,status,priority,issuetype,labels,assignee,created,updated,comment`;
+    const resp = await this.request(projectKey, url);
+    if (!resp?.ok) {
+      logger.error("Jira poll failed", { status: resp?.status, project: projectKey });
+      return [];
+    }
+
+    const data = (await resp.json()) as JiraSearchResult;
+    return data.issues.map((i) => this.normalize(i, projectKey, config));
+  }
+
+  async getIssueContext(issue: NormalizedIssue): Promise<string> {
+    const config = this.configs.get(issue.projectKey);
+    if (!config) return issue.body;
+
+    const url = `https://${config.host}/rest/api/3/issue/${issue.sourceId}?expand=renderedFields&fields=summary,description,comment,status,priority,issuetype,labels,subtasks`;
+    const resp = await this.request(issue.projectKey, url);
+    if (!resp?.ok) return issue.body;
+
+    const data = (await resp.json()) as JiraIssueDetail;
+    const parts: string[] = [`# ${data.fields.summary}\n`];
+
+    if (data.renderedFields?.description) {
+      parts.push(data.renderedFields.description);
+    } else if (data.fields.description) {
+      parts.push(extractAdfText(data.fields.description));
+    }
+
+    const subtasks = data.fields.subtasks ?? [];
+    if (subtasks.length) {
+      parts.push("\n## Sub-tasks");
+      for (const st of subtasks) {
+        const status = st.fields.status?.name ?? "Unknown";
+        parts.push(`- [${st.key}] ${st.fields.summary} (${status})`);
+      }
+    }
+
+    const comments = data.fields.comment?.comments ?? [];
+    if (comments.length) {
+      parts.push("\n## Comments");
+      for (const c of comments.slice(-10)) {
+        const author = c.author?.displayName ?? "Unknown";
+        const body = c.renderedBody ?? extractAdfText(c.body);
+        parts.push(`\n**${author}** (${c.created}):\n${body}`);
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  async onFixAccepted(issue: NormalizedIssue, prUrl: string): Promise<void> {
+    const config = this.configs.get(issue.projectKey);
+    if (!config) return;
+
+    // Only write to Jira if explicitly configured
+    if (!config.onAcceptTransition) return;
+
+    // Transition issue
+    await this.transitionIssue(issue.projectKey, issue.sourceId, config);
+
+    // Add comment about the fix
+    const commentUrl = `https://${config.host}/rest/api/3/issue/${issue.sourceId}/comment`;
+    await this.request(issue.projectKey, commentUrl, {
+      method: "POST",
+      body: JSON.stringify({
+        body: { type: "doc", version: 1, content: [{ type: "paragraph", content: [{ type: "text", text: `Relay fix applied: ${prUrl}` }] }] },
+      }),
+    });
+  }
+
+  private async transitionIssue(projectKey: string, issueId: string, config: JiraSourceConfig) {
+    const transUrl = `https://${config.host}/rest/api/3/issue/${issueId}/transitions`;
+    const resp = await this.request(projectKey, transUrl);
+    if (!resp?.ok) return;
+
+    const data = (await resp.json()) as { transitions: Array<{ id: string; name: string }> };
+    const target = data.transitions.find((t) =>
+      t.name.toLowerCase() === config.onAcceptTransition!.toLowerCase(),
+    );
+
+    if (target) {
+      await this.request(projectKey, transUrl, {
+        method: "POST",
+        body: JSON.stringify({ transition: { id: target.id } }),
+      });
+    } else {
+      logger.warn("Jira transition not found", { transition: config.onAcceptTransition, available: data.transitions.map((t) => t.name) });
+    }
+  }
+
+  private normalize(raw: JiraIssue, projectKey: string, config: JiraSourceConfig): NormalizedIssue {
+    const description = raw.fields.description
+      ? extractAdfText(raw.fields.description)
+      : "";
+
+    return {
+      source: "jira",
+      sourceId: raw.key,
+      externalUrl: `https://${config.host}/browse/${raw.key}`,
+      projectKey,
+      title: `${raw.key}: ${raw.fields.summary}`,
+      body: description,
+      severity: mapJiraPriority(raw.fields.priority?.name),
+      metadata: {
+        status: raw.fields.status?.name,
+        priority: raw.fields.priority?.name,
+        issueType: raw.fields.issuetype?.name,
+        labels: raw.fields.labels ?? [],
+        assignee: raw.fields.assignee?.displayName,
+        createdAt: raw.fields.created,
+      },
+    };
+  }
+
+  private async request(projectKey: string, url: string, init?: RequestInit, retries = 0): Promise<Response | null> {
+    const headers = this.authHeaders.get(projectKey);
+    if (!headers) return null;
+
+    const resp = await fetch(url, {
+      ...init,
+      headers: { ...headers, ...init?.headers },
+    });
+
+    if (resp.status === 429 && retries < 3) {
+      const retryAfter = resp.headers.get("retry-after");
+      const wait = retryAfter ? parseInt(retryAfter, 10) * 1000 : 60_000;
+      logger.warn("Jira rate limited", { retryAfterMs: wait, attempt: retries + 1 });
+      await Bun.sleep(wait);
+      return this.request(projectKey, url, init, retries + 1);
+    }
+
+    return resp;
+  }
+}
+
+export function buildJQL(config: JiraSourceConfig): string {
+  const clauses: string[] = [`project = "${config.projectKey}"`];
+
+  if (config.statusFilter?.length) {
+    const statuses = config.statusFilter.map((s) => `"${s}"`).join(", ");
+    clauses.push(`status IN (${statuses})`);
+  }
+
+  if (config.assigneeFilter) {
+    if (config.assigneeFilter === "currentUser()") {
+      clauses.push("assignee = currentUser()");
+    } else {
+      clauses.push(`assignee = "${config.assigneeFilter}"`);
+    }
+  }
+
+  if (config.issueTypeFilter?.length) {
+    const types = config.issueTypeFilter.map((t) => `"${t}"`).join(", ");
+    clauses.push(`issuetype IN (${types})`);
+  }
+
+  if (config.priorityFilter?.length) {
+    const priorities = config.priorityFilter.map((p) => `"${p}"`).join(", ");
+    clauses.push(`priority IN (${priorities})`);
+  }
+
+  if (config.labelFilter?.length) {
+    const labels = config.labelFilter.map((l) => `"${l}"`).join(", ");
+    clauses.push(`labels IN (${labels})`);
+  }
+
+  return clauses.join(" AND ") + " ORDER BY updated DESC";
+}
+
+export function mapJiraPriority(name?: string): Severity {
+  if (!name) return "medium";
+  const lower = name.toLowerCase();
+  if (lower === "highest" || lower === "blocker") return "critical";
+  if (lower === "high") return "high";
+  if (lower === "medium") return "medium";
+  if (lower === "low" || lower === "lowest") return "low";
+  return "medium";
+}
+
+function extractAdfText(doc: unknown): string {
+  if (!doc || typeof doc !== "object") return "";
+  const node = doc as { type?: string; text?: string; content?: unknown[] };
+  if (node.text) return node.text;
+  if (!node.content) return "";
+  return node.content.map(extractAdfText).join("\n");
+}
+
+interface JiraSearchResult {
+  issues: JiraIssue[];
+  total: number;
+}
+
+interface JiraIssue {
+  id: string;
+  key: string;
+  fields: {
+    summary: string;
+    description?: unknown;
+    status?: { name: string };
+    priority?: { name: string };
+    issuetype?: { name: string };
+    labels?: string[];
+    assignee?: { displayName: string; accountId: string };
+    created: string;
+    updated: string;
+  };
+}
+
+interface JiraIssueDetail {
+  fields: {
+    summary: string;
+    description?: unknown;
+    comment?: {
+      comments: Array<{
+        author?: { displayName: string };
+        body: unknown;
+        renderedBody?: string;
+        created: string;
+      }>;
+    };
+    subtasks?: Array<{ key: string; fields: { summary: string; status?: { name: string } } }>;
+  };
+  renderedFields?: {
+    description?: string;
+  };
+}

package/src/sources/linear.ts

@@ -0,0 +1,233 @@
+import type { NormalizedIssue, Severity, SourceAdapter } from "./types.ts";
+import type { LinearSourceConfig } from "../config.ts";
+import { logger } from "../utils/logger.ts";
+
+export class LinearAdapter implements SourceAdapter {
+  readonly name = "linear";
+  private apiKey: string;
+  private configs: Map<string, LinearSourceConfig> = new Map();
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  addProject(projectKey: string, config: LinearSourceConfig) {
+    this.configs.set(projectKey, config);
+  }
+
+  async poll(projectKey: string): Promise<NormalizedIssue[]> {
+    const config = this.configs.get(projectKey);
+    if (!config) return [];
+
+    const filter = buildFilter(config);
+    const query = `
+      query($teamId: String!, $filter: IssueFilter) {
+        team(id: $teamId) {
+          issues(first: 50, filter: $filter, orderBy: updatedAt) {
+            nodes {
+              id
+              identifier
+              title
+              description
+              url
+              priority
+              state { name type }
+              labels { nodes { name } }
+              assignee { email displayName }
+              createdAt
+              updatedAt
+            }
+          }
+        }
+      }
+    `;
+
+    const resp = await this.graphql(query, { teamId: config.teamId, filter });
+    if (!resp) return [];
+
+    const issues = resp.data?.team?.issues?.nodes ?? [];
+    return issues
+      .filter((i: LinearIssue) => i.state?.type !== "completed" && i.state?.type !== "canceled")
+      .map((i: LinearIssue) => this.normalize(i, projectKey));
+  }
+
+  async getIssueContext(issue: NormalizedIssue): Promise<string> {
+    const config = this.configs.get(issue.projectKey);
+    if (!config) return issue.body;
+
+    const query = `
+      query($id: String!) {
+        issue(id: $id) {
+          title
+          description
+          comments(first: 20) {
+            nodes { body user { displayName } createdAt }
+          }
+        }
+      }
+    `;
+
+    const resp = await this.graphql(query, { id: issue.sourceId });
+    if (!resp) return issue.body;
+
+    const data = resp.data?.issue;
+    if (!data) return issue.body;
+
+    const parts: string[] = [`# ${data.title}\n`, data.description ?? ""];
+
+    if (data.comments?.nodes?.length) {
+      parts.push("\n## Comments");
+      for (const c of data.comments.nodes) {
+        parts.push(`\n**${c.user?.displayName ?? "Unknown"}** (${c.createdAt}):\n${c.body}`);
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  async onFixAccepted(issue: NormalizedIssue, prUrl: string): Promise<void> {
+    const config = this.configs.get(issue.projectKey);
+    if (!config) return;
+
+    // Only write to Linear if explicitly opted in
+    if (!config.onAcceptTransition) return;
+
+    // Transition to "Done" state
+    const stateQuery = `
+      query($teamId: String!) {
+        team(id: $teamId) {
+          states { nodes { id name type } }
+        }
+      }
+    `;
+
+    const stateResp = await this.graphql(stateQuery, { teamId: config.teamId });
+    const states = stateResp?.data?.team?.states?.nodes ?? [];
+    const doneState = states.find((s: { type: string }) => s.type === "completed");
+
+    if (doneState) {
+      const mutation = `
+        mutation($id: String!, $stateId: String!) {
+          issueUpdate(id: $id, input: { stateId: $stateId }) { success }
+        }
+      `;
+      await this.graphql(mutation, { id: issue.sourceId, stateId: doneState.id });
+    }
+
+    // Add comment with PR link
+    const commentMutation = `
+      mutation($issueId: String!, $body: String!) {
+        commentCreate(input: { issueId: $issueId, body: $body }) { success }
+      }
+    `;
+    await this.graphql(commentMutation, {
+      issueId: issue.sourceId,
+      body: `Relay fix applied: ${prUrl}`,
+    });
+  }
+
+  private normalize(raw: LinearIssue, projectKey: string): NormalizedIssue {
+    return {
+      source: "linear",
+      sourceId: raw.id,
+      externalUrl: raw.url,
+      projectKey,
+      title: `${raw.identifier}: ${raw.title}`,
+      body: raw.description ?? "",
+      severity: mapPriority(raw.priority),
+      metadata: {
+        priority: raw.priority,
+        state: raw.state?.name,
+        labels: raw.labels?.nodes?.map((l) => l.name) ?? [],
+        assignee: raw.assignee?.displayName,
+        createdAt: raw.createdAt,
+      },
+    };
+  }
+
+  private async graphql(query: string, variables: Record<string, unknown>, retries = 0): Promise<any> {
+    const resp = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: {
+        Authorization: this.apiKey,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ query, variables }),
+    });
+
+    if (resp.status === 429 && retries < 3) {
+      const retryAfter = resp.headers.get("retry-after");
+      const wait = retryAfter ? parseInt(retryAfter, 10) * 1000 : 60_000;
+      logger.warn("Linear rate limited", { retryAfterMs: wait, attempt: retries + 1 });
+      await Bun.sleep(wait);
+      return this.graphql(query, variables, retries + 1);
+    }
+
+    if (!resp.ok) {
+      logger.error("Linear GraphQL error", { status: resp.status });
+      return null;
+    }
+
+    const json = await resp.json();
+    if (json.errors?.length) {
+      logger.error("Linear GraphQL errors", { errors: json.errors });
+      return null;
+    }
+
+    return json;
+  }
+}
+
+export function buildFilter(config: LinearSourceConfig): Record<string, unknown> {
+  const filter: Record<string, unknown> = {};
+
+  if (config.projectId) {
+    filter.project = { id: { eq: config.projectId } };
+  }
+
+  if (config.statusFilter?.length) {
+    filter.state = { name: { in: config.statusFilter } };
+  }
+
+  if (config.assigneeFilter) {
+    if (config.assigneeFilter === "me") {
+      filter.assignee = { isMe: { eq: true } };
+    } else {
+      filter.assignee = { email: { eq: config.assigneeFilter } };
+    }
+  }
+
+  if (config.labelFilter?.length) {
+    filter.labels = { name: { in: config.labelFilter } };
+  }
+
+  if (config.priorityFilter?.length) {
+    filter.priority = { in: config.priorityFilter };
+  }
+
+  return filter;
+}
+
+export function mapPriority(priority: number): Severity {
+  switch (priority) {
+    case 1: return "critical";
+    case 2: return "high";
+    case 3: return "medium";
+    case 4: return "low";
+    default: return "medium";
+  }
+}
+
+interface LinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  description?: string;
+  url: string;
+  priority: number;
+  state?: { name: string; type: string };
+  labels?: { nodes: Array<{ name: string }> };
+  assignee?: { email: string; displayName: string };
+  createdAt: string;
+  updatedAt: string;
+}

package/src/sources/sentry.ts

@@ -0,0 +1,222 @@
+import type { NormalizedIssue, Severity, SourceAdapter } from "./types.ts";
+import type { SentrySourceConfig } from "../config.ts";
+import { logger } from "../utils/logger.ts";
+
+interface RateLimit {
+  remaining: number;
+  resetTime: number;
+}
+
+export class SentryAdapter implements SourceAdapter {
+  readonly name = "sentry";
+  private authToken: string;
+  private configs: Map<string, SentrySourceConfig> = new Map();
+  private rateLimit: RateLimit = { remaining: Infinity, resetTime: 0 };
+
+  constructor(authToken: string) {
+    this.authToken = authToken;
+  }
+
+  addProject(projectKey: string, config: SentrySourceConfig) {
+    this.configs.set(projectKey, config);
+  }
+
+  async poll(projectKey: string): Promise<NormalizedIssue[]> {
+    const config = this.configs.get(projectKey);
+    if (!config) return [];
+
+    await this.waitForRateLimit();
+
+    const url = `https://sentry.io/api/0/projects/${config.org}/${config.project}/issues/?query=is:unresolved+!logger:csp&limit=25`;
+    const resp = await this.request(url);
+    if (!resp.ok) {
+      logger.error("Sentry poll failed", { status: resp.status, project: projectKey });
+      return [];
+    }
+
+    const issues = (await resp.json()) as SentryIssue[];
+    return issues
+      .filter((i) => !isInfraNoiseIssue(i))
+      .map((i) => this.normalize(i, projectKey));
+  }
+
+  async getIssueContext(issue: NormalizedIssue): Promise<string> {
+    const config = this.configs.get(issue.projectKey);
+    if (!config) return issue.body;
+
+    await this.waitForRateLimit();
+
+    const url = `https://sentry.io/api/0/issues/${issue.sourceId}/events/latest/`;
+    const resp = await this.request(url);
+    if (!resp.ok) {
+      logger.warn("Failed to fetch Sentry event", { issueId: issue.sourceId });
+      return issue.body;
+    }
+
+    const event = (await resp.json()) as SentryEvent;
+    const parts: string[] = [`# ${issue.title}\n`, issue.body];
+
+    if (event.entries) {
+      for (const entry of event.entries) {
+        if (entry.type === "exception" && entry.data?.values) {
+          for (const exc of entry.data.values) {
+            parts.push(`\n## Exception: ${exc.type}: ${exc.value}`);
+            if (exc.stacktrace?.frames) {
+              parts.push("\nStacktrace (most recent last):");
+              const frames = exc.stacktrace.frames.slice(-15);
+              for (const f of frames) {
+                const loc = [f.filename, f.lineno, f.colno].filter(Boolean).join(":");
+                parts.push(`  ${f.function ?? "<anonymous>"} at ${loc}`);
+                if (f.context_line) {
+                  parts.push(`    > ${f.context_line.trim()}`);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (event.tags) {
+      const relevant = event.tags.filter((t) =>
+        ["environment", "release", "browser", "os", "runtime"].includes(t.key),
+      );
+      if (relevant.length) {
+        parts.push("\n## Tags");
+        for (const t of relevant) parts.push(`- ${t.key}: ${t.value}`);
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  async onFixAccepted(issue: NormalizedIssue): Promise<void> {
+    await this.waitForRateLimit();
+    const url = `https://sentry.io/api/0/issues/${issue.sourceId}/`;
+    const resp = await this.request(url, {
+      method: "PUT",
+      body: JSON.stringify({ status: "resolved" }),
+    });
+    if (!resp.ok) {
+      logger.warn("Failed to resolve Sentry issue", { issueId: issue.sourceId });
+    }
+  }
+
+  private normalize(raw: SentryIssue, projectKey: string): NormalizedIssue {
+    return {
+      source: "sentry",
+      sourceId: raw.id,
+      externalUrl: raw.permalink,
+      projectKey,
+      title: raw.title,
+      body: raw.metadata?.value || raw.culprit || raw.title,
+      severity: this.mapSeverity(raw.level),
+      metadata: {
+        level: raw.level,
+        culprit: raw.culprit,
+        count: raw.count,
+        firstSeen: raw.firstSeen,
+        lastSeen: raw.lastSeen,
+      },
+    };
+  }
+
+  private mapSeverity(level: string): Severity {
+    switch (level) {
+      case "fatal": return "critical";
+      case "error": return "high";
+      case "warning": return "medium";
+      default: return "low";
+    }
+  }
+
+  private async request(url: string, init?: RequestInit, retries = 0): Promise<Response> {
+    const resp = await fetch(url, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "Content-Type": "application/json",
+        ...init?.headers,
+      },
+    });
+
+    const remaining = resp.headers.get("x-sentry-rate-limit-remaining");
+    const reset = resp.headers.get("x-sentry-rate-limit-reset");
+    if (remaining) this.rateLimit.remaining = parseInt(remaining, 10);
+    if (reset) this.rateLimit.resetTime = parseFloat(reset) * 1000;
+
+    if (resp.status === 429 && retries < 3) {
+      const retryAfter = resp.headers.get("retry-after");
+      const wait = retryAfter ? parseInt(retryAfter, 10) * 1000 : 60_000;
+      logger.warn("Sentry rate limited", { retryAfterMs: wait, attempt: retries + 1 });
+      await Bun.sleep(wait);
+      return this.request(url, init, retries + 1);
+    }
+
+    return resp;
+  }
+
+  private async waitForRateLimit() {
+    if (this.rateLimit.remaining <= 1 && Date.now() < this.rateLimit.resetTime) {
+      const wait = this.rateLimit.resetTime - Date.now() + 100;
+      logger.debug("Waiting for Sentry rate limit reset", { waitMs: wait });
+      await Bun.sleep(wait);
+    }
+  }
+}
+
+const NOISE_PATTERNS = [
+  /^Blocked '(font|connect|image|script|style|media|frame)' from /i,
+  /^Error: Timeout$/i,
+  /^TimeoutError/i,
+  /^NetworkError/i,
+  /^Network request failed/i,
+  /^Load failed$/i,
+  /^Failed to fetch$/i,
+  /^AbortError/i,
+  /^ResizeObserver loop/i,
+  /^Script error\.?$/i,
+];
+
+function isInfraNoiseIssue(issue: SentryIssue): boolean {
+  const title = issue.title;
+  if (NOISE_PATTERNS.some((p) => p.test(title))) {
+    logger.debug("Filtered noise issue", { id: issue.id, title });
+    return true;
+  }
+  return false;
+}
+
+interface SentryIssue {
+  id: string;
+  title: string;
+  permalink: string;
+  level: string;
+  culprit: string;
+  count: string;
+  firstSeen: string;
+  lastSeen: string;
+  metadata: { value?: string; type?: string };
+}
+
+interface SentryEvent {
+  entries?: Array<{
+    type: string;
+    data?: {
+      values?: Array<{
+        type: string;
+        value: string;
+        stacktrace?: {
+          frames?: Array<{
+            filename?: string;
+            function?: string;
+            lineno?: number;
+            colno?: number;
+            context_line?: string;
+          }>;
+        };
+      }>;
+    };
+  }>;
+  tags?: Array<{ key: string; value: string }>;
+}