triagent 0.1.0-alpha1

package/README.md

@@ -0,0 +1,51 @@
+# Triagent
+
+AI-powered Kubernetes debugging agent with terminal UI.
+
+## Installation
+
+```bash
+bun install triagent
+```
+
+## Usage
+
+```bash
+# Run interactive TUI
+triagent
+
+# Run webhook server only
+triagent --webhook-only
+```
+
+## Configuration
+
+Set the following environment variables:
+
+```bash
+ANTHROPIC_API_KEY=your-api-key
+# or
+OPENAI_API_KEY=your-api-key
+# or
+GOOGLE_GENERATIVE_AI_API_KEY=your-api-key
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Build
+bun run build
+
+# Type check
+bun run typecheck
+```
+
+## License
+
+MIT

package/bunfig.toml

@@ -0,0 +1 @@
+preload = ["@opentui/solid/preload"]

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "triagent",
+  "version": "0.1.0-alpha1",
+  "description": "AI-powered Kubernetes debugging agent with terminal UI",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "triagent": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "bunfig.toml"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "keywords": [
+    "kubernetes",
+    "k8s",
+    "debugging",
+    "ai",
+    "agent",
+    "cli",
+    "tui",
+    "devops",
+    "sre"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OWNER/triagent.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "webhook": "bun run src/index.ts --webhook-only",
+    "build": "bun run scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run typecheck"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1.2.0",
+    "@ai-sdk/google": "^1.2.0",
+    "@ai-sdk/openai": "^1.3.0",
+    "@bashlet/sdk": "^0.1.0-alpha1",
+    "@mastra/core": "^1.0.0-beta.21",
+    "@opentui/core": "^0.1.72",
+    "@opentui/solid": "^0.1.72",
+    "hono": "^4.6.0",
+    "solid-js": "^1.9.10",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
+    "bun-types": "^1.2.0"
+  }
+}

package/src/cli/config.ts

@@ -0,0 +1,60 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import type { AIProvider } from "../config.js";
+
+export interface StoredConfig {
+  aiProvider?: AIProvider;
+  aiModel?: string;
+  apiKey?: string;
+  webhookPort?: number;
+  codebasePath?: string;
+  kubeConfigPath?: string;
+}
+
+const CONFIG_DIR = join(homedir(), ".config", "triagent");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export async function getConfigPath(): Promise<string> {
+  return CONFIG_FILE;
+}
+
+export async function loadStoredConfig(): Promise<StoredConfig> {
+  try {
+    const content = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+export async function saveStoredConfig(config: StoredConfig): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export async function setConfigValue(key: keyof StoredConfig, value: string | number): Promise<void> {
+  const config = await loadStoredConfig();
+  (config as Record<string, string | number>)[key] = value;
+  await saveStoredConfig(config);
+}
+
+export async function getConfigValue(key: keyof StoredConfig): Promise<string | number | undefined> {
+  const config = await loadStoredConfig();
+  return config[key];
+}
+
+export async function deleteConfigValue(key: keyof StoredConfig): Promise<void> {
+  const config = await loadStoredConfig();
+  delete config[key];
+  await saveStoredConfig(config);
+}
+
+export async function listConfig(): Promise<StoredConfig> {
+  return loadStoredConfig();
+}
+
+export function maskApiKey(key: string): string {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}

package/src/config.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { resolve } from "path";
+import { homedir } from "os";
+import { loadStoredConfig, type StoredConfig } from "./cli/config.js";
+
+const AIProviderSchema = z.enum(["openai", "anthropic", "google"]);
+export type AIProvider = z.infer<typeof AIProviderSchema>;
+
+const ConfigSchema = z.object({
+  aiProvider: AIProviderSchema,
+  aiModel: z.string().min(1),
+  apiKey: z.string().min(1),
+  webhookPort: z.number().int().positive().default(3000),
+  codebasePath: z.string().min(1).default("./"),
+  kubeConfigPath: z.string().min(1).default("~/.kube"),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+function expandPath(path: string): string {
+  if (path.startsWith("~")) {
+    return resolve(homedir(), path.slice(2));
+  }
+  return resolve(path);
+}
+
+function getApiKey(provider: AIProvider, stored: StoredConfig): string {
+  // Check stored config first, then env vars
+  if (stored.apiKey) return stored.apiKey;
+
+  switch (provider) {
+    case "openai":
+      return process.env.OPENAI_API_KEY || "";
+    case "anthropic":
+      return process.env.ANTHROPIC_API_KEY || "";
+    case "google":
+      return process.env.GOOGLE_GENERATIVE_AI_API_KEY || "";
+  }
+}
+
+export async function loadConfig(): Promise<Config> {
+  const stored = await loadStoredConfig();
+
+  const provider = (process.env.AI_PROVIDER || stored.aiProvider || "anthropic") as AIProvider;
+
+  const rawConfig = {
+    aiProvider: provider,
+    aiModel: process.env.AI_MODEL || stored.aiModel || getDefaultModel(provider),
+    apiKey: getApiKey(provider, stored),
+    webhookPort: parseInt(process.env.WEBHOOK_PORT || String(stored.webhookPort || 3000), 10),
+    codebasePath: expandPath(process.env.CODEBASE_PATH || stored.codebasePath || "./"),
+    kubeConfigPath: expandPath(process.env.KUBE_CONFIG_PATH || stored.kubeConfigPath || "~/.kube"),
+  };
+
+  const result = ConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errors = result.error.errors
+      .map((e) => `  - ${e.path.join(".")}: ${e.message}`)
+      .join("\n");
+    throw new Error(`Invalid configuration:\n${errors}`);
+  }
+
+  return result.data;
+}
+
+function getDefaultModel(provider: AIProvider): string {
+  switch (provider) {
+    case "openai":
+      return "gpt-4o";
+    case "anthropic":
+      return "claude-3-5-sonnet-20241022";
+    case "google":
+      return "gemini-1.5-pro";
+  }
+}
+
+export function getModelConfig(config: Config) {
+  const { aiProvider, aiModel } = config;
+
+  switch (aiProvider) {
+    case "openai":
+      return {
+        provider: "openai" as const,
+        model: aiModel,
+      };
+    case "anthropic":
+      return {
+        provider: "anthropic" as const,
+        model: aiModel,
+      };
+    case "google":
+      return {
+        provider: "google" as const,
+        model: aiModel,
+      };
+  }
+}

package/src/index.ts

@@ -0,0 +1,310 @@
+#!/usr/bin/env bun
+import { loadConfig } from "./config.js";
+import { initSandboxFromConfig } from "./sandbox/bashlet.js";
+import { createMastraInstance, buildIncidentPrompt, getDebuggerAgent } from "./mastra/index.js";
+import { runTUI } from "./tui/app.jsx";
+import { startWebhookServer } from "./server/webhook.js";
+import {
+  loadStoredConfig,
+  saveStoredConfig,
+  getConfigPath,
+  maskApiKey,
+  type StoredConfig,
+} from "./cli/config.js";
+import type { AIProvider } from "./config.js";
+
+interface CliArgs {
+  command: "run" | "config";
+  configAction?: "set" | "get" | "list" | "path";
+  configKey?: string;
+  configValue?: string;
+  webhookOnly: boolean;
+  incident: string | null;
+  help: boolean;
+  host: boolean;
+}
+
+function parseArgs(): CliArgs {
+  const args = process.argv.slice(2);
+  const result: CliArgs = {
+    command: "run",
+    webhookOnly: false,
+    incident: null,
+    help: false,
+    host: false,
+  };
+
+  // Check for config subcommand
+  if (args[0] === "config") {
+    result.command = "config";
+    result.configAction = args[1] as "set" | "get" | "list" | "path";
+    result.configKey = args[2];
+    result.configValue = args[3];
+    return result;
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "--webhook-only" || arg === "-w") {
+      result.webhookOnly = true;
+    } else if (arg === "--incident" || arg === "-i") {
+      result.incident = args[++i] || null;
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--host") {
+      result.host = true;
+    }
+  }
+
+  return result;
+}
+
+function printHelp(): void {
+  console.log(`
+🚨 TRIAGENT - AI Kubernetes Debugging Agent
+
+USAGE:
+  triagent [OPTIONS]
+  triagent config <action> [key] [value]
+
+OPTIONS:
+  -h, --help          Show this help message
+  -w, --webhook-only  Run only the webhook server (no TUI)
+  -i, --incident      Direct incident input (runs once and exits)
+      --host          Run commands on host machine (no sandbox)
+
+CONFIG COMMANDS:
+  triagent config set <key> <value>  Set a configuration value
+  triagent config get <key>          Get a configuration value
+  triagent config list               List all configuration values
+  triagent config path               Show config file path
+
+CONFIG KEYS:
+  aiProvider     - AI provider (openai, anthropic, google)
+  aiModel        - Model ID (e.g., gpt-4o, claude-sonnet-4-20250514)
+  apiKey         - API key for the provider
+  webhookPort    - Webhook server port (default: 3000)
+  codebasePath   - Path to codebase (default: ./)
+  kubeConfigPath - Kubernetes config path (default: ~/.kube)
+
+MODES:
+  Interactive (default):
+    Run with no arguments to start the interactive TUI.
+    Enter incident descriptions and see real-time debugging output.
+
+  Webhook Server:
+    Use --webhook-only to start an HTTP server that accepts
+    incident webhooks from alerting systems.
+
+    Endpoints:
+      POST /webhook/incident  - Submit an incident
+      GET  /investigations/:id - Get investigation results
+      GET  /health            - Health check
+
+  Direct Input:
+    Use --incident "description" for one-shot debugging.
+    Example: triagent --incident "checkout pods crashing"
+
+ENVIRONMENT VARIABLES:
+  AI_PROVIDER              - AI provider (openai, anthropic, google)
+  AI_MODEL                 - Model ID (e.g., gpt-4o, claude-3-5-sonnet)
+  OPENAI_API_KEY          - OpenAI API key
+  ANTHROPIC_API_KEY       - Anthropic API key
+  GOOGLE_GENERATIVE_AI_API_KEY - Google AI API key
+  WEBHOOK_PORT            - Webhook server port (default: 3000)
+  CODEBASE_PATH           - Path to codebase (default: ./)
+  KUBE_CONFIG_PATH        - Kubernetes config path (default: ~/.kube)
+
+EXAMPLES:
+  # Interactive TUI mode
+  triagent
+
+  # Webhook server mode
+  triagent --webhook-only
+
+  # Direct incident investigation
+  triagent -i "API gateway returning 503 errors"
+
+  # Submit via curl (webhook mode)
+  curl -X POST http://localhost:3000/webhook/incident \\
+    -H "Content-Type: application/json" \\
+    -d '{"title": "API Error", "description": "checkout not working", "severity": "critical"}'
+`);
+}
+
+async function runDirectIncident(description: string): Promise<void> {
+  console.log("🚨 TRIAGENT - Direct Investigation Mode\n");
+  console.log(`Incident: ${description}\n`);
+  console.log("Starting investigation...\n");
+  console.log("─".repeat(60) + "\n");
+
+  const agent = getDebuggerAgent();
+  const prompt = buildIncidentPrompt({
+    title: "Direct Investigation",
+    description,
+  });
+
+  try {
+    const stream = await agent.stream(prompt, {
+      maxSteps: 20,
+      onStepFinish: ({ toolCalls }) => {
+        if (toolCalls && toolCalls.length > 0) {
+          const toolCall = toolCalls[0];
+          const toolName = "toolName" in toolCall ? toolCall.toolName : "tool";
+          console.log(`\n[Tool: ${toolName}]\n`);
+        }
+      },
+    });
+
+    for await (const chunk of stream.textStream) {
+      process.stdout.write(chunk);
+    }
+
+    console.log("\n\n" + "─".repeat(60));
+    console.log("✅ Investigation complete");
+  } catch (error) {
+    console.error("\n❌ Investigation failed:", error);
+    process.exit(1);
+  }
+}
+
+async function handleConfigCommand(args: CliArgs): Promise<void> {
+  const validKeys: (keyof StoredConfig)[] = [
+    "aiProvider",
+    "aiModel",
+    "apiKey",
+    "webhookPort",
+    "codebasePath",
+    "kubeConfigPath",
+  ];
+
+  switch (args.configAction) {
+    case "set": {
+      if (!args.configKey || args.configValue === undefined) {
+        console.error("Usage: triagent config set <key> <value>");
+        process.exit(1);
+      }
+      if (!validKeys.includes(args.configKey as keyof StoredConfig)) {
+        console.error(`Invalid key: ${args.configKey}`);
+        console.error(`Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+      }
+      const config = await loadStoredConfig();
+      let value: string | number = args.configValue;
+      if (args.configKey === "webhookPort") {
+        value = parseInt(args.configValue, 10);
+      }
+      (config as Record<string, string | number>)[args.configKey] = value;
+      await saveStoredConfig(config);
+      console.log(`✅ Set ${args.configKey}`);
+      break;
+    }
+    case "get": {
+      if (!args.configKey) {
+        console.error("Usage: triagent config get <key>");
+        process.exit(1);
+      }
+      const config = await loadStoredConfig();
+      const value = config[args.configKey as keyof StoredConfig];
+      if (value === undefined) {
+        console.log(`${args.configKey}: (not set)`);
+      } else if (args.configKey === "apiKey") {
+        console.log(`${args.configKey}: ${maskApiKey(String(value))}`);
+      } else {
+        console.log(`${args.configKey}: ${value}`);
+      }
+      break;
+    }
+    case "list": {
+      const config = await loadStoredConfig();
+      console.log("Current configuration:\n");
+      for (const key of validKeys) {
+        const value = config[key];
+        if (value === undefined) {
+          console.log(`  ${key}: (not set)`);
+        } else if (key === "apiKey") {
+          console.log(`  ${key}: ${maskApiKey(String(value))}`);
+        } else {
+          console.log(`  ${key}: ${value}`);
+        }
+      }
+      break;
+    }
+    case "path": {
+      const path = await getConfigPath();
+      console.log(path);
+      break;
+    }
+    default:
+      console.error("Usage: triagent config <set|get|list|path> [key] [value]");
+      process.exit(1);
+  }
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs();
+
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Handle config command
+  if (args.command === "config") {
+    await handleConfigCommand(args);
+    process.exit(0);
+  }
+
+  // Load configuration
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (error) {
+    console.error("❌ Configuration error:", error);
+    console.error("\nRun 'triagent config set apiKey <your-key>' to configure.");
+    console.error("Or set environment variables (see --help for details).");
+    process.exit(1);
+  }
+
+  // Initialize sandbox and Mastra
+  try {
+    initSandboxFromConfig(config, args.host);
+    createMastraInstance(config);
+    if (args.host) {
+      console.log("⚠️  Running in host mode (no sandbox)\n");
+    }
+  } catch (error) {
+    console.error("❌ Initialization error:", error);
+    process.exit(1);
+  }
+
+  // Run in appropriate mode
+  if (args.webhookOnly) {
+    // Webhook server mode
+    await startWebhookServer(config.webhookPort);
+  } else if (args.incident) {
+    // Direct incident mode
+    await runDirectIncident(args.incident);
+  } else {
+    // Interactive TUI mode
+    console.log("Starting Triagent TUI...\n");
+    const tui = await runTUI();
+
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+      tui.shutdown();
+      process.exit(0);
+    });
+
+    process.on("SIGTERM", () => {
+      tui.shutdown();
+      process.exit(0);
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});