triagent 0.1.0-alpha13 → 0.1.0-alpha18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triagent",
-  "version": "0.1.0-alpha13",
+  "version": "0.1.0-alpha18",
   "description": "AI-powered Kubernetes debugging agent with terminal UI",
   "type": "module",
   "main": "src/index.ts",
@@ -47,11 +47,11 @@
     "@ai-sdk/openai": "^1.3.0",
     "@bashlet/sdk": "^0.1.0-alpha1",
     "@mastra/core": "^1.0.0-beta.21",
+    "@opentui-ui/dialog": "^0.1.2",
+    "@opentui-ui/toast": "^0.0.5",
     "@opentui/core": "^0.1.72",
     "@opentui/solid": "^0.1.72",
     "hono": "^4.6.0",
-    "marked": "^17.0.1",
-    "marked-terminal": "^7.3.0",
     "opentui-spinner": "^0.0.6",
     "solid-js": "1.9.9",
     "triagent": "^0.1.0-alpha1",
@@ -59,7 +59,6 @@
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
-    "@types/marked-terminal": "^6.1.1",
     "@types/node": "^22.0.0",
     "bun-types": "^1.2.0",
     "typescript": "^5.7.0"

package/src/cli/config.ts

@@ -8,6 +8,65 @@ export interface CodebaseEntry {
   path: string;
 }
 
+export interface ClusterConfig {
+  name: string;
+  context: string;
+  kubeConfigPath?: string;
+  environment?: "development" | "staging" | "production";
+}
+
+export interface PrometheusConfig {
+  url: string;
+  auth?: { token: string };
+}
+
+export interface GrafanaConfig {
+  url: string;
+  apiKey: string;
+}
+
+export interface ElasticsearchConfig {
+  url: string;
+  index: string;
+  auth?: { apiKey: string };
+}
+
+export interface LokiConfig {
+  url: string;
+}
+
+export interface CloudWatchConfig {
+  region: string;
+  logGroupPrefix?: string;
+}
+
+export interface SlackConfig {
+  webhookUrl: string;
+  botToken?: string;
+  defaultChannel?: string;
+}
+
+export interface TeamsConfig {
+  webhookUrl: string;
+}
+
+export interface RunbookConfig {
+  paths: string[];
+  gitRepos?: string[];
+}
+
+export interface CostAnalysisConfig {
+  provider?: "aws" | "gcp" | "azure";
+  hourlyRates?: {
+    cpu: number;
+    memory: number;
+    storage: number;
+  };
+  businessImpact?: {
+    revenuePerMinute?: number;
+  };
+}
+
 export interface StoredConfig {
   aiProvider?: AIProvider;
   aiModel?: string;
@@ -17,11 +76,35 @@ export interface StoredConfig {
   codebasePath?: string; // Deprecated: use codebasePaths instead
   codebasePaths?: CodebaseEntry[];
   kubeConfigPath?: string;
+
+  // Phase 1: Foundation
+  historyRetentionDays?: number;
+  clusters?: ClusterConfig[];
+  activeCluster?: string;
+
+  // Phase 2: Observability
+  prometheus?: PrometheusConfig;
+  grafana?: GrafanaConfig;
+  logProvider?: "elasticsearch" | "loki" | "cloudwatch";
+  elasticsearch?: ElasticsearchConfig;
+  loki?: LokiConfig;
+  cloudwatch?: CloudWatchConfig;
+
+  // Phase 3: Operations
+  runbooks?: RunbookConfig;
+
+  // Phase 4: Communication & Cost
+  notifications?: {
+    slack?: SlackConfig;
+    teams?: TeamsConfig;
+  };
+  costAnalysis?: CostAnalysisConfig;
 }
 
 const CONFIG_DIR = join(homedir(), ".config", "triagent");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
 const TRIAGENT_MD_FILE = join(CONFIG_DIR, "TRIAGENT.md");
+const RUNBOOK_MD_FILE = join(CONFIG_DIR, "RUNBOOK.md");
 
 export async function getConfigPath(): Promise<string> {
   return CONFIG_FILE;
@@ -40,6 +123,19 @@ export async function loadTriagentMd(): Promise<string | null> {
   }
 }
 
+export async function loadRunbookMd(): Promise<string | null> {
+  try {
+    const content = await readFile(RUNBOOK_MD_FILE, "utf-8");
+    return content.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function getRunbookMdPath(): Promise<string> {
+  return RUNBOOK_MD_FILE;
+}
+
 export async function loadStoredConfig(): Promise<StoredConfig> {
   try {
     const content = await readFile(CONFIG_FILE, "utf-8");

package/src/index.ts

@@ -16,10 +16,15 @@ import {
 import type { AIProvider } from "./config.js";
 
 interface CliArgs {
-  command: "run" | "config";
+  command: "run" | "config" | "cluster";
   configAction?: "set" | "get" | "list" | "path";
   configKey?: string;
   configValue?: string;
+  clusterAction?: "add" | "remove" | "list" | "use" | "status";
+  clusterName?: string;
+  clusterContext?: string;
+  clusterKubeConfig?: string;
+  clusterEnvironment?: string;
   webhookOnly: boolean;
   incident: string | null;
   help: boolean;
@@ -45,6 +50,30 @@ function parseArgs(): CliArgs {
     return result;
   }
 
+  // Check for cluster subcommand
+  if (args[0] === "cluster") {
+    result.command = "cluster";
+    result.clusterAction = args[1] as "add" | "remove" | "list" | "use" | "status";
+
+    // Parse cluster sub-command arguments
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--name" || arg === "-n") {
+        result.clusterName = args[++i];
+      } else if (arg === "--context" || arg === "-c") {
+        result.clusterContext = args[++i];
+      } else if (arg === "--kubeconfig" || arg === "-k") {
+        result.clusterKubeConfig = args[++i];
+      } else if (arg === "--environment" || arg === "-e") {
+        result.clusterEnvironment = args[++i];
+      } else if (!arg.startsWith("-")) {
+        // Positional argument - cluster name
+        result.clusterName = arg;
+      }
+    }
+    return result;
+  }
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
 
@@ -69,6 +98,7 @@ function printHelp(): void {
 USAGE:
   triagent [OPTIONS]
   triagent config <action> [key] [value]
+  triagent cluster <action> [options]
 
 OPTIONS:
   -h, --help          Show this help message
@@ -98,6 +128,19 @@ CONFIG KEYS:
     ]
   Each codebase will be mounted at /workspace/<name> in the sandbox.
 
+CLUSTER COMMANDS:
+  triagent cluster add <name> --context <ctx>  Add a cluster
+  triagent cluster remove <name>               Remove a cluster
+  triagent cluster list                        List all clusters
+  triagent cluster use <name>                  Set active cluster
+  triagent cluster status [name]               Check cluster status
+
+CLUSTER OPTIONS:
+  -n, --name         Cluster name
+  -c, --context      Kubernetes context name
+  -k, --kubeconfig   Path to kubeconfig file
+  -e, --environment  Environment (development, staging, production)
+
 MODES:
   Interactive (default):
     Run with no arguments to start the interactive TUI.
@@ -108,9 +151,12 @@ MODES:
     incident webhooks from alerting systems.
 
     Endpoints:
-      POST /webhook/incident  - Submit an incident
+      POST /webhook/incident   - Submit an incident
       GET  /investigations/:id - Get investigation results
-      GET  /health            - Health check
+      GET  /history            - List investigation history
+      GET  /history/:id        - Get investigation details
+      GET  /history/stats      - Get investigation statistics
+      GET  /health             - Health check
 
   Direct Input:
     Use --incident "description" for one-shot debugging.
@@ -137,6 +183,11 @@ EXAMPLES:
   # Direct incident investigation
   triagent -i "API gateway returning 503 errors"
 
+  # Multi-cluster management
+  triagent cluster add prod --context prod-cluster -e production
+  triagent cluster use prod
+  triagent cluster status
+
   # Submit via curl (webhook mode)
   curl -X POST http://localhost:3000/webhook/incident \\
     -H "Content-Type: application/json" \\
@@ -185,6 +236,147 @@ async function runDirectIncident(description: string): Promise<void> {
   }
 }
 
+import { initClusterManager, getClusterManager } from "./integrations/kubernetes/multi-cluster.js";
+import type { ClusterConfig } from "./cli/config.js";
+
+async function handleClusterCommand(args: CliArgs): Promise<void> {
+  const config = await loadStoredConfig();
+  const clusterManager = initClusterManager(config.clusters, config.activeCluster);
+
+  switch (args.clusterAction) {
+    case "add": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster add <name> --context <context>");
+        process.exit(1);
+      }
+      const context = args.clusterContext || args.clusterName;
+      const newCluster: ClusterConfig = {
+        name: args.clusterName,
+        context,
+        kubeConfigPath: args.clusterKubeConfig,
+        environment: args.clusterEnvironment as ClusterConfig["environment"],
+      };
+
+      await clusterManager.addCluster(newCluster);
+
+      // Save to config
+      config.clusters = config.clusters || [];
+      config.clusters.push(newCluster);
+      await saveStoredConfig(config);
+
+      console.log(`✅ Added cluster: ${args.clusterName} (context: ${context})`);
+      break;
+    }
+    case "remove": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster remove <name>");
+        process.exit(1);
+      }
+
+      const removed = await clusterManager.removeCluster(args.clusterName);
+      if (!removed) {
+        console.error(`Cluster not found: ${args.clusterName}`);
+        process.exit(1);
+      }
+
+      // Remove from config
+      config.clusters = config.clusters?.filter((c) => c.name !== args.clusterName);
+      if (config.activeCluster === args.clusterName) {
+        config.activeCluster = undefined;
+      }
+      await saveStoredConfig(config);
+
+      console.log(`✅ Removed cluster: ${args.clusterName}`);
+      break;
+    }
+    case "list": {
+      const clusters = clusterManager.listClusters();
+      if (clusters.length === 0) {
+        console.log("No clusters configured.");
+        console.log("\nDiscover available contexts:");
+        const discovered = await clusterManager.discoverClusters();
+        if (discovered.length > 0) {
+          console.log("\nAvailable Kubernetes contexts:");
+          for (const c of discovered) {
+            console.log(`  - ${c.context} (${c.server})`);
+          }
+          console.log("\nAdd a cluster with: triagent cluster add <name> --context <context>");
+        } else {
+          console.log("No Kubernetes contexts found.");
+        }
+      } else {
+        console.log("Configured clusters:\n");
+        for (const c of clusters) {
+          const active = c.isActive ? " (active)" : "";
+          const env = c.environment ? ` [${c.environment}]` : "";
+          console.log(`  ${c.name}${active}${env}`);
+          console.log(`    context: ${c.context}`);
+          if (c.kubeConfigPath) {
+            console.log(`    kubeconfig: ${c.kubeConfigPath}`);
+          }
+        }
+      }
+      break;
+    }
+    case "use": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster use <name>");
+        process.exit(1);
+      }
+
+      const success = await clusterManager.setActiveCluster(args.clusterName);
+      if (!success) {
+        console.error(`Cluster not found: ${args.clusterName}`);
+        process.exit(1);
+      }
+
+      // Save to config
+      config.activeCluster = args.clusterName;
+      await saveStoredConfig(config);
+
+      console.log(`✅ Active cluster set to: ${args.clusterName}`);
+      break;
+    }
+    case "status": {
+      const clusterName = args.clusterName;
+      if (clusterName) {
+        const status = await clusterManager.checkClusterStatus(clusterName);
+        console.log(`Cluster: ${status.name}`);
+        console.log(`  Connected: ${status.connected ? "✅ Yes" : "❌ No"}`);
+        if (status.connected) {
+          console.log(`  Version: ${status.version}`);
+          console.log(`  Nodes: ${status.nodeCount}`);
+        }
+        if (status.error) {
+          console.log(`  Error: ${status.error}`);
+        }
+      } else {
+        const clusters = clusterManager.listClusters();
+        if (clusters.length === 0) {
+          console.log("No clusters configured.");
+        } else {
+          console.log("Cluster status:\n");
+          for (const c of clusters) {
+            const status = await clusterManager.checkClusterStatus(c.name);
+            const active = c.isActive ? " (active)" : "";
+            const connected = status.connected ? "✅" : "❌";
+            console.log(`  ${connected} ${c.name}${active}`);
+            if (status.connected) {
+              console.log(`      v${status.version}, ${status.nodeCount} nodes`);
+            } else if (status.error) {
+              console.log(`      Error: ${status.error}`);
+            }
+          }
+        }
+      }
+      break;
+    }
+    default:
+      console.error("Usage: triagent cluster <add|remove|list|use|status> [options]");
+      process.exit(1);
+  }
+}
+
 async function handleConfigCommand(args: CliArgs): Promise<void> {
   const validKeys: (keyof StoredConfig)[] = [
     "aiProvider",
@@ -273,6 +465,12 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
+  // Handle cluster command
+  if (args.command === "cluster") {
+    await handleClusterCommand(args);
+    process.exit(0);
+  }
+
   // Load configuration
   let config;
   try {

package/src/integrations/elasticsearch/client.ts

@@ -0,0 +1,210 @@
+import type { ElasticsearchConfig } from "../../cli/config.js";
+
+export interface ESSearchResult {
+  hits: {
+    total: { value: number; relation: string };
+    hits: Array<{
+      _index: string;
+      _id: string;
+      _source: Record<string, unknown>;
+      sort?: unknown[];
+    }>;
+  };
+  aggregations?: Record<string, unknown>;
+}
+
+export interface ESLogEntry {
+  timestamp: string;
+  message: string;
+  level?: string;
+  pod?: string;
+  namespace?: string;
+  container?: string;
+  [key: string]: unknown;
+}
+
+export class ElasticsearchClient {
+  private baseUrl: string;
+  private index: string;
+  private apiKey?: string;
+
+  constructor(config: ElasticsearchConfig) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.index = config.index;
+    this.apiKey = config.auth?.apiKey;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options?: Omit<RequestInit, 'body'> & { body?: unknown }
+  ): Promise<T> {
+    const headers: Record<string, string> = {
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+    };
+
+    if (this.apiKey) {
+      headers["Authorization"] = `ApiKey ${this.apiKey}`;
+    }
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: { ...headers, ...options?.headers },
+      body: options?.body ? JSON.stringify(options.body) : undefined,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Elasticsearch API error: ${response.status} ${text}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async search(options: {
+    query: string;
+    timeRange?: { start: string; end?: string };
+    limit?: number;
+    sort?: "asc" | "desc";
+  }): Promise<ESLogEntry[]> {
+    const { query, timeRange, limit = 100, sort = "desc" } = options;
+
+    const must: unknown[] = [
+      {
+        query_string: {
+          query,
+          default_field: "message",
+        },
+      },
+    ];
+
+    if (timeRange) {
+      const range: Record<string, string> = { gte: timeRange.start };
+      if (timeRange.end) {
+        range.lte = timeRange.end;
+      }
+      must.push({
+        range: {
+          "@timestamp": range,
+        },
+      });
+    }
+
+    const body = {
+      query: {
+        bool: { must },
+      },
+      size: limit,
+      sort: [{ "@timestamp": { order: sort } }],
+    };
+
+    const result = await this.request<ESSearchResult>(`/${this.index}/_search`, {
+      method: "POST",
+      body,
+    });
+
+    return result.hits.hits.map((hit) => {
+      const source = hit._source as Record<string, unknown>;
+      const k8s = source.kubernetes as Record<string, unknown> | undefined;
+      const k8sPod = k8s?.pod as Record<string, unknown> | undefined;
+      const k8sContainer = k8s?.container as Record<string, unknown> | undefined;
+      return {
+        timestamp: (source["@timestamp"] as string) || new Date().toISOString(),
+        message: (source.message as string) || JSON.stringify(source),
+        level: source.level as string | undefined,
+        pod: (k8sPod?.name || source.pod) as string | undefined,
+        namespace: (k8s?.namespace || source.namespace) as string | undefined,
+        container: (k8sContainer?.name || source.container) as string | undefined,
+        ...source,
+      };
+    });
+  }
+
+  async aggregate(options: {
+    query: string;
+    field: string;
+    timeRange?: { start: string; end?: string };
+    interval?: string;
+  }): Promise<Array<{ key: string; count: number }>> {
+    const { query, field, timeRange, interval = "1m" } = options;
+
+    const must: unknown[] = [
+      {
+        query_string: {
+          query,
+          default_field: "message",
+        },
+      },
+    ];
+
+    if (timeRange) {
+      const range: Record<string, string> = { gte: timeRange.start };
+      if (timeRange.end) {
+        range.lte = timeRange.end;
+      }
+      must.push({
+        range: {
+          "@timestamp": range,
+        },
+      });
+    }
+
+    const body = {
+      query: {
+        bool: { must },
+      },
+      size: 0,
+      aggs: {
+        by_field: {
+          terms: { field, size: 50 },
+        },
+        over_time: {
+          date_histogram: {
+            field: "@timestamp",
+            fixed_interval: interval,
+          },
+        },
+      },
+    };
+
+    const result = await this.request<{
+      aggregations: {
+        by_field: { buckets: Array<{ key: string; doc_count: number }> };
+        over_time: { buckets: Array<{ key_as_string: string; doc_count: number }> };
+      };
+    }>(`/${this.index}/_search`, {
+      method: "POST",
+      body,
+    });
+
+    return result.aggregations.by_field.buckets.map((bucket) => ({
+      key: bucket.key,
+      count: bucket.doc_count,
+    }));
+  }
+
+  formatLogs(logs: ESLogEntry[]): string {
+    const lines: string[] = [];
+    for (const log of logs) {
+      const level = log.level ? `[${log.level.toUpperCase()}]` : "";
+      const source = log.pod ? `${log.namespace}/${log.pod}` : "";
+      const prefix = [log.timestamp, level, source].filter(Boolean).join(" ");
+      lines.push(`${prefix}: ${log.message}`);
+    }
+    return lines.join("\n");
+  }
+}
+
+// Singleton instance
+let esClient: ElasticsearchClient | null = null;
+
+export function getElasticsearchClient(): ElasticsearchClient | null {
+  return esClient;
+}
+
+export function initElasticsearchClient(config?: ElasticsearchConfig): ElasticsearchClient | null {
+  if (config) {
+    esClient = new ElasticsearchClient(config);
+  }
+  return esClient;
+}