triagent 0.1.0-alpha8 → 0.1.0-beta2

package/src/integrations/prometheus/client.ts

@@ -0,0 +1,163 @@
+import type { PrometheusConfig } from "../../cli/config.js";
+
+export interface PrometheusQueryResult {
+  status: "success" | "error";
+  data?: {
+    resultType: "vector" | "matrix" | "scalar" | "string";
+    result: Array<{
+      metric: Record<string, string>;
+      value?: [number, string];
+      values?: Array<[number, string]>;
+    }>;
+  };
+  error?: string;
+  errorType?: string;
+}
+
+export interface PrometheusAlert {
+  labels: Record<string, string>;
+  annotations: Record<string, string>;
+  state: "firing" | "pending" | "inactive";
+  activeAt: string;
+  value: string;
+}
+
+export interface PrometheusTarget {
+  labels: Record<string, string>;
+  scrapePool: string;
+  scrapeUrl: string;
+  health: "up" | "down" | "unknown";
+  lastScrape: string;
+  lastError: string;
+}
+
+export class PrometheusClient {
+  private baseUrl: string;
+  private authToken?: string;
+
+  constructor(config: PrometheusConfig) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.authToken = config.auth?.token;
+  }
+
+  private async request<T>(endpoint: string, params?: Record<string, string>): Promise<T> {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Accept": "application/json",
+    };
+
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+
+    const response = await fetch(url.toString(), { headers });
+    if (!response.ok) {
+      throw new Error(`Prometheus API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async query(query: string, time?: string): Promise<PrometheusQueryResult> {
+    const params: Record<string, string> = { query };
+    if (time) {
+      params.time = time;
+    }
+    return this.request<PrometheusQueryResult>("/api/v1/query", params);
+  }
+
+  async queryRange(
+    query: string,
+    start: string,
+    end: string,
+    step: string
+  ): Promise<PrometheusQueryResult> {
+    return this.request<PrometheusQueryResult>("/api/v1/query_range", {
+      query,
+      start,
+      end,
+      step,
+    });
+  }
+
+  async getAlerts(): Promise<{ alerts: PrometheusAlert[] }> {
+    const response = await this.request<{
+      status: string;
+      data: { alerts: PrometheusAlert[] };
+    }>("/api/v1/alerts");
+    return response.data;
+  }
+
+  async getTargets(): Promise<{ activeTargets: PrometheusTarget[] }> {
+    const response = await this.request<{
+      status: string;
+      data: { activeTargets: PrometheusTarget[] };
+    }>("/api/v1/targets");
+    return response.data;
+  }
+
+  async getRules(): Promise<{ groups: Array<{ name: string; rules: unknown[] }> }> {
+    const response = await this.request<{
+      status: string;
+      data: { groups: Array<{ name: string; rules: unknown[] }> };
+    }>("/api/v1/rules");
+    return response.data;
+  }
+
+  async getMetadata(metric?: string): Promise<Record<string, unknown[]>> {
+    const params: Record<string, string> = {};
+    if (metric) {
+      params.metric = metric;
+    }
+    const response = await this.request<{
+      status: string;
+      data: Record<string, unknown[]>;
+    }>("/api/v1/metadata", params);
+    return response.data;
+  }
+
+  formatQueryResult(result: PrometheusQueryResult): string {
+    if (result.status !== "success" || !result.data) {
+      return `Error: ${result.error || "Unknown error"}`;
+    }
+
+    const lines: string[] = [];
+    for (const item of result.data.result) {
+      const labels = Object.entries(item.metric)
+        .map(([k, v]) => `${k}="${v}"`)
+        .join(", ");
+
+      if (item.value) {
+        const [timestamp, value] = item.value;
+        lines.push(`{${labels}} => ${value} @${new Date(timestamp * 1000).toISOString()}`);
+      } else if (item.values) {
+        lines.push(`{${labels}}:`);
+        for (const [timestamp, value] of item.values.slice(-5)) {
+          lines.push(`  ${new Date(timestamp * 1000).toISOString()}: ${value}`);
+        }
+      }
+    }
+
+    return lines.join("\n") || "No data";
+  }
+}
+
+// Singleton instance
+let prometheusClient: PrometheusClient | null = null;
+
+export function getPrometheusClient(): PrometheusClient | null {
+  return prometheusClient;
+}
+
+export function initPrometheusClient(config?: PrometheusConfig): PrometheusClient | null {
+  if (config) {
+    prometheusClient = new PrometheusClient(config);
+  }
+  return prometheusClient;
+}

package/src/integrations/slack/client.ts

@@ -0,0 +1,265 @@
+import type { SlackConfig } from "../../cli/config.js";
+
+export interface SlackMessage {
+  channel?: string;
+  text: string;
+  blocks?: SlackBlock[];
+  attachments?: SlackAttachment[];
+  thread_ts?: string;
+}
+
+export interface SlackBlock {
+  type: "section" | "divider" | "header" | "context" | "actions";
+  text?: { type: "mrkdwn" | "plain_text"; text: string };
+  fields?: Array<{ type: "mrkdwn" | "plain_text"; text: string }>;
+  elements?: SlackBlockElement[];
+  accessory?: SlackBlockElement;
+}
+
+export interface SlackBlockElement {
+  type: "button" | "static_select" | "image" | "mrkdwn" | "plain_text";
+  text?: { type: "plain_text" | "mrkdwn"; text: string; emoji?: boolean };
+  action_id?: string;
+  url?: string;
+  value?: string;
+  style?: "primary" | "danger";
+  image_url?: string;
+  alt_text?: string;
+}
+
+export interface SlackAttachment {
+  color?: string;
+  fallback?: string;
+  title?: string;
+  text?: string;
+  fields?: Array<{ title: string; value: string; short?: boolean }>;
+  footer?: string;
+  ts?: number;
+}
+
+export interface SlackResponse {
+  ok: boolean;
+  error?: string;
+  ts?: string;
+  channel?: string;
+}
+
+export class SlackClient {
+  private webhookUrl: string;
+  private botToken?: string;
+  private defaultChannel?: string;
+
+  constructor(config: SlackConfig) {
+    this.webhookUrl = config.webhookUrl;
+    this.botToken = config.botToken;
+    this.defaultChannel = config.defaultChannel;
+  }
+
+  async sendWebhook(message: SlackMessage): Promise<boolean> {
+    try {
+      const response = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(message),
+      });
+
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async sendMessage(message: SlackMessage): Promise<SlackResponse> {
+    if (!this.botToken) {
+      // Fall back to webhook
+      const success = await this.sendWebhook(message);
+      return { ok: success };
+    }
+
+    const channel = message.channel || this.defaultChannel;
+    if (!channel) {
+      return { ok: false, error: "No channel specified" };
+    }
+
+    try {
+      const response = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.botToken}`,
+        },
+        body: JSON.stringify({
+          ...message,
+          channel,
+        }),
+      });
+
+      return await response.json() as SlackResponse;
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
+  async updateMessage(channel: string, ts: string, message: SlackMessage): Promise<SlackResponse> {
+    if (!this.botToken) {
+      return { ok: false, error: "Bot token required for message updates" };
+    }
+
+    try {
+      const response = await fetch("https://slack.com/api/chat.update", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.botToken}`,
+        },
+        body: JSON.stringify({
+          ...message,
+          channel,
+          ts,
+        }),
+      });
+
+      return await response.json() as SlackResponse;
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
+  buildInvestigationMessage(investigation: {
+    id: string;
+    title: string;
+    status: string;
+    summary?: string;
+    severity?: string;
+    rootCause?: string;
+    recommendations?: string[];
+    url?: string;
+  }): SlackMessage {
+    const statusEmoji = {
+      pending: "⏳",
+      running: "🔄",
+      completed: "✅",
+      failed: "❌",
+    }[investigation.status] || "❓";
+
+    const severityColor = {
+      critical: "#dc3545",
+      warning: "#ffc107",
+      info: "#17a2b8",
+    }[investigation.severity || "info"] || "#6c757d";
+
+    const blocks: SlackBlock[] = [
+      {
+        type: "header",
+        text: { type: "plain_text", text: `${statusEmoji} Investigation: ${investigation.title}` },
+      },
+      {
+        type: "section",
+        fields: [
+          { type: "mrkdwn", text: `*Status:*\n${investigation.status}` },
+          { type: "mrkdwn", text: `*ID:*\n\`${investigation.id}\`` },
+        ],
+      },
+    ];
+
+    if (investigation.summary) {
+      blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: `*Summary:*\n${investigation.summary}` },
+      });
+    }
+
+    if (investigation.rootCause) {
+      blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: `*Root Cause:*\n${investigation.rootCause}` },
+      });
+    }
+
+    if (investigation.recommendations && investigation.recommendations.length > 0) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Recommendations:*\n${investigation.recommendations.map((r, i) => `${i + 1}. ${r}`).join("\n")}`,
+        },
+      });
+    }
+
+    if (investigation.url) {
+      blocks.push({
+        type: "actions",
+        elements: [
+          {
+            type: "button",
+            text: { type: "plain_text", text: "View Details", emoji: true },
+            url: investigation.url,
+          },
+        ],
+      });
+    }
+
+    return {
+      text: `Investigation ${investigation.status}: ${investigation.title}`,
+      blocks,
+      attachments: [
+        {
+          color: severityColor,
+          fallback: investigation.summary || investigation.title,
+        },
+      ],
+    };
+  }
+
+  buildAlertMessage(alert: {
+    name: string;
+    severity: string;
+    message: string;
+    source?: string;
+    timestamp?: Date;
+  }): SlackMessage {
+    const severityEmoji = {
+      critical: "🔴",
+      warning: "🟡",
+      info: "🔵",
+    }[alert.severity] || "⚪";
+
+    const severityColor = {
+      critical: "#dc3545",
+      warning: "#ffc107",
+      info: "#17a2b8",
+    }[alert.severity] || "#6c757d";
+
+    return {
+      text: `${severityEmoji} Alert: ${alert.name}`,
+      attachments: [
+        {
+          color: severityColor,
+          fallback: alert.message,
+          title: `${severityEmoji} ${alert.name}`,
+          text: alert.message,
+          fields: [
+            { title: "Severity", value: alert.severity.toUpperCase(), short: true },
+            { title: "Source", value: alert.source || "Unknown", short: true },
+          ],
+          footer: "Triagent",
+          ts: Math.floor((alert.timestamp || new Date()).getTime() / 1000),
+        },
+      ],
+    };
+  }
+}
+
+// Singleton instance
+let slackClient: SlackClient | null = null;
+
+export function getSlackClient(): SlackClient | null {
+  return slackClient;
+}
+
+export function initSlackClient(config?: SlackConfig): SlackClient | null {
+  if (config) {
+    slackClient = new SlackClient(config);
+  }
+  return slackClient;
+}

package/src/integrations/teams/client.ts

@@ -0,0 +1,199 @@
+import type { TeamsConfig } from "../../cli/config.js";
+
+export interface TeamsMessage {
+  "@type": "MessageCard";
+  "@context": "http://schema.org/extensions";
+  themeColor?: string;
+  summary: string;
+  sections?: TeamsSection[];
+  potentialAction?: TeamsAction[];
+}
+
+export interface TeamsSection {
+  activityTitle?: string;
+  activitySubtitle?: string;
+  activityImage?: string;
+  facts?: Array<{ name: string; value: string }>;
+  markdown?: boolean;
+  text?: string;
+}
+
+export interface TeamsAction {
+  "@type": "OpenUri" | "ActionCard" | "HttpPOST";
+  name: string;
+  targets?: Array<{ os: string; uri: string }>;
+  inputs?: TeamsInput[];
+  actions?: TeamsAction[];
+  target?: string;
+  body?: string;
+}
+
+export interface TeamsInput {
+  "@type": "TextInput" | "MultichoiceInput";
+  id: string;
+  title: string;
+  isMultiline?: boolean;
+  isRequired?: boolean;
+  choices?: Array<{ display: string; value: string }>;
+}
+
+export class TeamsClient {
+  private webhookUrl: string;
+
+  constructor(config: TeamsConfig) {
+    this.webhookUrl = config.webhookUrl;
+  }
+
+  async sendMessage(message: TeamsMessage): Promise<boolean> {
+    try {
+      const response = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(message),
+      });
+
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  buildInvestigationMessage(investigation: {
+    id: string;
+    title: string;
+    status: string;
+    summary?: string;
+    severity?: string;
+    rootCause?: string;
+    recommendations?: string[];
+    url?: string;
+  }): TeamsMessage {
+    const statusEmoji = {
+      pending: "⏳",
+      running: "🔄",
+      completed: "✅",
+      failed: "❌",
+    }[investigation.status] || "❓";
+
+    const themeColor = {
+      critical: "dc3545",
+      warning: "ffc107",
+      info: "17a2b8",
+      completed: "28a745",
+      failed: "dc3545",
+    }[investigation.severity || investigation.status] || "6c757d";
+
+    const facts: Array<{ name: string; value: string }> = [
+      { name: "Status", value: `${statusEmoji} ${investigation.status}` },
+      { name: "ID", value: investigation.id },
+    ];
+
+    if (investigation.severity) {
+      facts.push({ name: "Severity", value: investigation.severity.toUpperCase() });
+    }
+
+    const sections: TeamsSection[] = [
+      {
+        activityTitle: `Investigation: ${investigation.title}`,
+        activitySubtitle: `Status: ${investigation.status}`,
+        facts,
+        markdown: true,
+      },
+    ];
+
+    if (investigation.summary) {
+      sections.push({
+        text: `**Summary:** ${investigation.summary}`,
+        markdown: true,
+      });
+    }
+
+    if (investigation.rootCause) {
+      sections.push({
+        text: `**Root Cause:** ${investigation.rootCause}`,
+        markdown: true,
+      });
+    }
+
+    if (investigation.recommendations && investigation.recommendations.length > 0) {
+      const recText = investigation.recommendations
+        .map((r, i) => `${i + 1}. ${r}`)
+        .join("\n\n");
+      sections.push({
+        text: `**Recommendations:**\n\n${recText}`,
+        markdown: true,
+      });
+    }
+
+    const actions: TeamsAction[] = [];
+    if (investigation.url) {
+      actions.push({
+        "@type": "OpenUri",
+        name: "View Details",
+        targets: [{ os: "default", uri: investigation.url }],
+      });
+    }
+
+    return {
+      "@type": "MessageCard",
+      "@context": "http://schema.org/extensions",
+      themeColor,
+      summary: `Investigation ${investigation.status}: ${investigation.title}`,
+      sections,
+      potentialAction: actions.length > 0 ? actions : undefined,
+    };
+  }
+
+  buildAlertMessage(alert: {
+    name: string;
+    severity: string;
+    message: string;
+    source?: string;
+    timestamp?: Date;
+  }): TeamsMessage {
+    const severityEmoji = {
+      critical: "🔴",
+      warning: "🟡",
+      info: "🔵",
+    }[alert.severity] || "⚪";
+
+    const themeColor = {
+      critical: "dc3545",
+      warning: "ffc107",
+      info: "17a2b8",
+    }[alert.severity] || "6c757d";
+
+    return {
+      "@type": "MessageCard",
+      "@context": "http://schema.org/extensions",
+      themeColor,
+      summary: `${severityEmoji} Alert: ${alert.name}`,
+      sections: [
+        {
+          activityTitle: `${severityEmoji} ${alert.name}`,
+          activitySubtitle: alert.source || "Triagent",
+          facts: [
+            { name: "Severity", value: alert.severity.toUpperCase() },
+            { name: "Time", value: (alert.timestamp || new Date()).toISOString() },
+          ],
+          text: alert.message,
+          markdown: true,
+        },
+      ],
+    };
+  }
+}
+
+// Singleton instance
+let teamsClient: TeamsClient | null = null;
+
+export function getTeamsClient(): TeamsClient | null {
+  return teamsClient;
+}
+
+export function initTeamsClient(config?: TeamsConfig): TeamsClient | null {
+  if (config) {
+    teamsClient = new TeamsClient(config);
+  }
+  return teamsClient;
+}