@adriandmitroca/relay 0.0.2

package/src/notifications/telegram.ts

@@ -0,0 +1,334 @@
+import { logger } from "../utils/logger.ts";
+import { esc, sanitizeTopicName, decodeHtmlEntities } from "../utils/html.ts";
+import { FAILURE_HINTS, type CallbackAction, type CallbackData } from "../constants.ts";
+import type { IssueRow } from "../db.ts";
+import type { TriageResult } from "../worker/triage.ts";
+
+export type { CallbackAction, CallbackData } from "../constants.ts";
+
+const MAX_MESSAGE_LENGTH = 4096;
+
+const SEVERITY_COLORS: Record<string, number> = {
+  critical: 0xFB6F5F, // red
+  high: 0xFFD67E, // orange
+  medium: 0x6FB9F0, // blue
+  low: 0x8EEE98, // green
+};
+
+const SEVERITY_ICONS: Record<string, string> = {
+  critical: "🔴",
+  high: "🟠",
+  medium: "🔵",
+  low: "🟢",
+};
+
+export class TelegramBot {
+  private botToken: string;
+  private chatId: string;
+  private baseUrl: string;
+  private offset = 0;
+  private polling = false;
+  private pollAbort: AbortController | null = null;
+  private onCallback: ((data: CallbackData) => Promise<void>) | null = null;
+
+  constructor(botToken: string, chatId: string) {
+    this.botToken = botToken;
+    this.chatId = chatId;
+    this.baseUrl = `https://api.telegram.org/bot${botToken}`;
+  }
+
+  setCallbackHandler(handler: (data: CallbackData) => Promise<void>) {
+    this.onCallback = handler;
+  }
+
+  async createIssueTopic(issue: IssueRow): Promise<number | null> {
+    const name = `[${issue.source}] ${sanitizeTopicName(issue.title)}`.slice(0, 128);
+    const iconColor = SEVERITY_COLORS[issue.severity] ?? SEVERITY_COLORS.medium;
+
+    const result = await this.api("createForumTopic", {
+      chat_id: this.chatId,
+      name,
+      icon_color: iconColor,
+    });
+
+    if (!result?.message_thread_id) return null;
+    const threadId = result.message_thread_id as number;
+
+    const sevIcon = SEVERITY_ICONS[issue.severity] ?? "🔵";
+    let text = `<b>${esc(decodeHtmlEntities(issue.title))}</b>\n\n`;
+    text += `${sevIcon} <b>${esc(issue.severity)}</b>  ·  <code>${esc(issue.source)}:${esc(issue.sourceId)}</code>\n`;
+    text += `📁 ${esc(issue.projectKey)}  ·  🏢 ${esc(issue.workspaceKey)}`;
+    if (issue.externalUrl) {
+      text += `\n\n<a href="${esc(issue.externalUrl)}">View in ${esc(issue.source)} ↗</a>`;
+    }
+    await this.sendMessage(truncate(text), undefined, threadId);
+
+    return threadId;
+  }
+
+  async sendThreadMessage(
+    threadId: number,
+    text: string,
+    keyboard?: Array<Array<{ text: string; callback_data: string }>>,
+  ): Promise<number | null> {
+    return this.sendMessage(truncate(text), keyboard, threadId);
+  }
+
+  async reopenThread(threadId: number) {
+    await this.api("reopenForumTopic", {
+      chat_id: this.chatId,
+      message_thread_id: threadId,
+    });
+  }
+
+  async closeThread(threadId: number, text: string): Promise<number | null> {
+    const msgId = await this.sendThreadMessage(threadId, text);
+    await this.api("closeForumTopic", {
+      chat_id: this.chatId,
+      message_thread_id: threadId,
+    });
+    return msgId;
+  }
+
+  async sendTriageResult(issue: IssueRow, triage: TriageResult, threadId?: number): Promise<number | null> {
+    const icon = triage.fixable ? "🔧" : "⏭";
+    const verdict = triage.fixable ? "ACTIONABLE" : "NOT ACTIONABLE";
+    const confidence = Math.round(triage.confidence * 100);
+
+    let text = `${icon} <b>${esc(verdict)}</b> — ${confidence}% confident\n\n`;
+    text += `<i>${esc(triage.reason)}</i>`;
+
+    if (triage.plan) {
+      text += `\n\n<b>Plan:</b>\n${esc(triage.plan)}`;
+    }
+
+    text += `\n\n<code>⏱ ${formatDuration(triage.durationMs)} · 🪙 ${formatTokens(triage.inputTokens, triage.outputTokens)}${triage.costUsd != null ? ` · 💰 $${triage.costUsd.toFixed(3)}` : ""}</code>`;
+
+    const keyboard = triage.fixable
+      ? [[
+          { text: "✅ Start", callback_data: `fix:${issue.source}:${issue.sourceId}` },
+          { text: "⏭ Skip", callback_data: `skip:${issue.source}:${issue.sourceId}` },
+        ]]
+      : [[
+          { text: "🔄 Retry", callback_data: `retry:${issue.source}:${issue.sourceId}` },
+          { text: "⏭ Skip", callback_data: `skip:${issue.source}:${issue.sourceId}` },
+        ]];
+
+    return this.sendMessage(truncate(text), keyboard, threadId);
+  }
+
+  async sendApproval(
+    issue: IssueRow,
+    summary: string,
+    threadId?: number,
+    fixStats?: { durationMs: number; inputTokens: number; outputTokens: number; costUsd?: number },
+  ): Promise<number | null> {
+    let text = `✅ <b>WORK COMPLETE</b>\n\n`;
+    if (summary) text += `<i>${mdToHtml(summary)}</i>\n\n`;
+    if (fixStats) {
+      text += `<code>⏱ ${formatDuration(fixStats.durationMs)} · 🪙 ${formatTokens(fixStats.inputTokens, fixStats.outputTokens)}${fixStats.costUsd != null ? ` · 💰 $${fixStats.costUsd.toFixed(3)}` : ""}</code>`;
+    }
+
+    const keyboard = [
+      [
+        { text: "✅ Accept", callback_data: `accept:${issue.source}:${issue.sourceId}` },
+        { text: "❌ Discard", callback_data: `discard:${issue.source}:${issue.sourceId}` },
+      ],
+    ];
+
+    return this.sendMessage(truncate(text), keyboard, threadId);
+  }
+
+  async sendFixReady(issue: IssueRow, threadId?: number): Promise<number | null> {
+    const keyboard = [
+      [
+        { text: "✅ Start", callback_data: `fix:${issue.source}:${issue.sourceId}` },
+        { text: "⏭ Skip", callback_data: `skip:${issue.source}:${issue.sourceId}` },
+      ],
+    ];
+    return this.sendMessage("🔧 <b>READY TO START</b>", keyboard, threadId);
+  }
+
+  async sendFailedMessage(source: string, sourceId: string, error: string, threadId?: number, failureReason?: string): Promise<number | null> {
+    let text = `❌ <b>FAILED</b>`;
+    if (failureReason) text += ` · <code>${esc(failureReason)}</code>`;
+    const hint = failureReason ? FAILURE_HINTS[failureReason] : undefined;
+    if (hint) text += `\n\n${esc(hint)}`;
+    text += `\n\n<code>${esc(error.slice(0, 300))}</code>`;
+    const keyboard = [[{ text: "🔄 Retry", callback_data: `retry:${source}:${sourceId}` }]];
+    return this.sendMessage(truncate(text), keyboard, threadId);
+  }
+
+  async sendStatus(text: string): Promise<number | null> {
+    return this.sendMessage(truncate(`ℹ️ ${esc(text)}`));
+  }
+
+  async editMessage(messageId: number, text: string) {
+    await this.api("editMessageText", {
+      chat_id: this.chatId,
+      message_id: messageId,
+      text: truncate(text),
+      parse_mode: "HTML",
+    });
+  }
+
+  async editMessageRemoveKeyboard(messageId: number, text: string) {
+    await this.api("editMessageText", {
+      chat_id: this.chatId,
+      message_id: messageId,
+      text: truncate(text),
+      parse_mode: "HTML",
+      reply_markup: JSON.stringify({ inline_keyboard: [] }),
+    });
+  }
+
+  startPolling() {
+    if (this.polling) return;
+    this.polling = true;
+    this.pollLoop();
+  }
+
+  stopPolling() {
+    this.polling = false;
+    this.pollAbort?.abort();
+    this.pollAbort = null;
+  }
+
+  private async pollLoop() {
+    while (this.polling) {
+      try {
+        this.pollAbort = new AbortController();
+        const timeoutId = setTimeout(() => this.pollAbort?.abort(), 35_000);
+        const resp = await fetch(`${this.baseUrl}/getUpdates?offset=${this.offset}&timeout=30&allowed_updates=["callback_query"]`, {
+          signal: this.pollAbort.signal,
+        });
+        clearTimeout(timeoutId);
+
+        if (!resp.ok) {
+          logger.error("Telegram poll error", { status: resp.status });
+          await Bun.sleep(5_000);
+          continue;
+        }
+
+        const body = (await resp.json()) as { ok: boolean; result: TelegramUpdate[] };
+        if (!body.ok || !body.result.length) continue;
+
+        for (const update of body.result) {
+          this.offset = update.update_id + 1;
+
+          if (update.callback_query) {
+            await this.handleCallback(update.callback_query);
+          }
+        }
+      } catch (err) {
+        if (this.polling) {
+          logger.warn("Telegram poll error, retrying in 5s", { error: String(err) });
+          await Bun.sleep(5_000);
+        }
+      }
+    }
+  }
+
+  private async handleCallback(query: TelegramCallbackQuery) {
+    // Acknowledge immediately
+    await this.api("answerCallbackQuery", { callback_query_id: query.id });
+
+    if (!query.data || !this.onCallback) return;
+
+    const parts = query.data.split(":");
+    if (parts.length < 3) return;
+
+    const [action, source, ...rest] = parts;
+    const sourceId = rest.join(":");
+
+    if (!["accept", "discard", "skip", "fix", "retry"].includes(action)) return;
+
+    try {
+      await this.onCallback({
+        action: action as CallbackAction,
+        source,
+        sourceId,
+      });
+    } catch (err) {
+      logger.error("Callback handler error", { error: String(err) });
+    }
+  }
+
+  private async sendMessage(
+    text: string,
+    keyboard?: Array<Array<{ text: string; callback_data: string }>>,
+    messageThreadId?: number,
+  ): Promise<number | null> {
+    const body: Record<string, unknown> = {
+      chat_id: this.chatId,
+      text,
+      parse_mode: "HTML",
+      disable_web_page_preview: true,
+    };
+
+    if (keyboard) {
+      body.reply_markup = JSON.stringify({ inline_keyboard: keyboard });
+    }
+
+    if (messageThreadId) {
+      body.message_thread_id = messageThreadId;
+    }
+
+    const result = await this.api("sendMessage", body);
+    return result?.message_id ?? null;
+  }
+
+  private async api(method: string, body: Record<string, unknown>): Promise<Record<string, unknown> | null> {
+    try {
+      const resp = await fetch(`${this.baseUrl}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+
+      if (!resp.ok) {
+        const text = await resp.text();
+        logger.error("Telegram API error", { method, status: resp.status, body: text.slice(0, 200) });
+        return null;
+      }
+
+      const data = (await resp.json()) as { ok: boolean; result?: Record<string, unknown> };
+      return data.result ?? null;
+    } catch (err) {
+      logger.error("Telegram API call failed", { method, error: String(err) });
+      return null;
+    }
+  }
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 60_000) return `${Math.round(ms / 1000)}s`;
+  return `${Math.floor(ms / 60_000)}m ${Math.round((ms % 60_000) / 1000)}s`;
+}
+
+function formatTokens(input: number, output: number): string {
+  const fmt = (n: number) => n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
+  return `${fmt(input)} in / ${fmt(output)} out`;
+}
+
+function mdToHtml(md: string): string {
+  return esc(md)
+    .replace(/\*\*(.+?)\*\*/g, "<b>$1</b>")
+    .replace(/`([^`]+)`/g, "<code>$1</code>");
+}
+
+function truncate(s: string): string {
+  if (s.length <= MAX_MESSAGE_LENGTH) return s;
+  return s.slice(0, MAX_MESSAGE_LENGTH - 20) + "\n\n(truncated)";
+}
+
+interface TelegramUpdate {
+  update_id: number;
+  callback_query?: TelegramCallbackQuery;
+}
+
+interface TelegramCallbackQuery {
+  id: string;
+  data?: string;
+  message?: { message_id: number; chat: { id: number } };
+}

package/src/queue.ts

@@ -0,0 +1,98 @@
+import type { Severity } from "./sources/types.ts";
+import { logger } from "./utils/logger.ts";
+
+const PRIORITY: Record<Severity, number> = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+};
+
+interface QueueItem<T> {
+  id: string;
+  data: T;
+  priority: number;
+}
+
+export class PriorityQueue<T> {
+  private items: QueueItem<T>[] = [];
+  private active = new Set<string>();
+  private maxConcurrency: number;
+  private running = 0;
+  private paused = false;
+  private processor: (data: T) => Promise<void>;
+  private drainResolve: (() => void) | null = null;
+
+  constructor(maxConcurrency: number, processor: (data: T) => Promise<void>) {
+    this.maxConcurrency = maxConcurrency;
+    this.processor = processor;
+  }
+
+  enqueue(id: string, data: T, severity: Severity): boolean {
+    if (this.active.has(id) || this.items.some((i) => i.id === id)) {
+      return false; // dedup
+    }
+
+    const priority = PRIORITY[severity] ?? 2;
+    this.items.push({ id, data, priority });
+    this.items.sort((a, b) => a.priority - b.priority);
+    this.tryProcess();
+    return true;
+  }
+
+  pause() {
+    this.paused = true;
+  }
+
+  resume() {
+    this.paused = false;
+    this.tryProcess();
+  }
+
+  async drain(timeoutMs = 300_000): Promise<void> {
+    this.paused = true; // stop accepting new work
+    this.items = []; // clear pending
+
+    if (this.running === 0) return;
+
+    return new Promise<void>((resolve) => {
+      let resolved = false;
+      const done = () => {
+        if (resolved) return;
+        resolved = true;
+        this.drainResolve = null;
+        resolve();
+      };
+      this.drainResolve = done;
+      setTimeout(done, timeoutMs);
+    });
+  }
+
+  get size(): number {
+    return this.items.length;
+  }
+
+  get activeCount(): number {
+    return this.running;
+  }
+
+  private tryProcess() {
+    while (!this.paused && this.running < this.maxConcurrency && this.items.length > 0) {
+      const item = this.items.shift()!;
+      this.active.add(item.id);
+      this.running++;
+
+      this.processor(item.data)
+        .catch((err) => logger.error("Queue processor error", { id: item.id, error: String(err) }))
+        .finally(() => {
+          this.active.delete(item.id);
+          this.running--;
+          if (this.running === 0 && this.drainResolve) {
+            this.drainResolve();
+            this.drainResolve = null;
+          }
+          this.tryProcess();
+        });
+    }
+  }
+}

package/src/sources/asana.ts

@@ -0,0 +1,161 @@
+import type { NormalizedIssue, Severity, SourceAdapter } from "./types.ts";
+import type { AsanaSourceConfig } from "../config.ts";
+import { logger } from "../utils/logger.ts";
+
+export class AsanaAdapter implements SourceAdapter {
+  readonly name = "asana";
+  private accessToken: string;
+  private configs: Map<string, AsanaSourceConfig> = new Map();
+
+  constructor(accessToken: string) {
+    this.accessToken = accessToken;
+  }
+
+  addProject(projectKey: string, config: AsanaSourceConfig) {
+    this.configs.set(projectKey, config);
+  }
+
+  async poll(projectKey: string): Promise<NormalizedIssue[]> {
+    const config = this.configs.get(projectKey);
+    if (!config) return [];
+
+    const fields = "gid,name,notes,completed,created_at,permalink_url,tags,custom_fields";
+    const url = `https://app.asana.com/api/1.0/projects/${config.projectGid}/tasks?completed_since=now&opt_fields=${fields}&limit=50`;
+
+    const tasks = await this.fetchPaginated(url, 3);
+    return tasks
+      .filter((t) => !t.completed)
+      .map((t) => this.normalize(t, projectKey, config));
+  }
+
+  async getIssueContext(issue: NormalizedIssue): Promise<string> {
+    const parts: string[] = [`# ${issue.title}\n`, issue.body];
+
+    const storiesUrl = `https://app.asana.com/api/1.0/tasks/${issue.sourceId}/stories?opt_fields=text,type,created_by.name,created_at`;
+    const resp = await this.request(storiesUrl);
+    if (resp.ok) {
+      const data = (await resp.json()) as { data: AsanaStory[] };
+      const comments = data.data.filter((s) => s.type === "comment" && s.text);
+      if (comments.length) {
+        parts.push("\n## Comments");
+        for (const c of comments.slice(-10)) {
+          parts.push(`\n**${c.created_by?.name ?? "Unknown"}** (${c.created_at}):\n${c.text}`);
+        }
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  async onFixAccepted(issue: NormalizedIssue, prUrl: string): Promise<void> {
+    const url = `https://app.asana.com/api/1.0/tasks/${issue.sourceId}/stories`;
+    const resp = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({ data: { text: `Relay fix applied: ${prUrl}` } }),
+    });
+    if (!resp.ok) {
+      logger.warn("Failed to comment on Asana task", { taskGid: issue.sourceId });
+    }
+  }
+
+  private normalize(raw: AsanaTask, projectKey: string, config: AsanaSourceConfig): NormalizedIssue {
+    return {
+      source: "asana",
+      sourceId: raw.gid,
+      externalUrl: raw.permalink_url ?? `https://app.asana.com/0/0/${raw.gid}`,
+      projectKey,
+      title: raw.name,
+      body: raw.notes ?? "",
+      severity: this.extractSeverity(raw, config),
+      metadata: {
+        createdAt: raw.created_at,
+        tags: raw.tags?.map((t) => t.name) ?? [],
+      },
+    };
+  }
+
+  private extractSeverity(task: AsanaTask, config: AsanaSourceConfig): Severity {
+    if (config.severityFieldGid && task.custom_fields) {
+      const field = task.custom_fields.find((f) => f.gid === config.severityFieldGid);
+      if (field?.enum_value?.name) {
+        const name = field.enum_value.name.toLowerCase();
+        if (name.includes("critical")) return "critical";
+        if (name.includes("high")) return "high";
+        if (name.includes("low")) return "low";
+      }
+    }
+
+    if (task.tags) {
+      for (const tag of task.tags) {
+        const n = tag.name.toLowerCase();
+        if (n.includes("critical") || n.includes("p0")) return "critical";
+        if (n.includes("high") || n.includes("p1")) return "high";
+        if (n.includes("low") || n.includes("p3")) return "low";
+      }
+    }
+
+    return "medium";
+  }
+
+  private async fetchPaginated(url: string, maxPages: number): Promise<AsanaTask[]> {
+    const all: AsanaTask[] = [];
+    let nextUrl: string | null = url;
+    let page = 0;
+
+    while (nextUrl && page < maxPages) {
+      const resp = await this.request(nextUrl);
+      if (!resp.ok) {
+        logger.error("Asana API error", { status: resp.status });
+        break;
+      }
+      const body = (await resp.json()) as { data: AsanaTask[]; next_page?: { uri: string } | null };
+      all.push(...body.data);
+      nextUrl = body.next_page?.uri ?? null;
+      page++;
+    }
+
+    return all;
+  }
+
+  private async request(url: string, init?: RequestInit, retries = 0): Promise<Response> {
+    const resp = await fetch(url, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+        ...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("Asana rate limited", { retryAfterMs: wait, attempt: retries + 1 });
+      await Bun.sleep(wait);
+      return this.request(url, init, retries + 1);
+    }
+
+    return resp;
+  }
+}
+
+interface AsanaTask {
+  gid: string;
+  name: string;
+  notes?: string;
+  completed: boolean;
+  created_at: string;
+  permalink_url?: string;
+  tags?: Array<{ gid: string; name: string }>;
+  custom_fields?: Array<{
+    gid: string;
+    enum_value?: { name: string } | null;
+  }>;
+}
+
+interface AsanaStory {
+  type: string;
+  text?: string;
+  created_by?: { name: string };
+  created_at: string;
+}