triagent 0.1.0-alpha8 → 0.1.0-beta2

package/README.md

@@ -26,6 +26,69 @@ triagent
 
 # Run webhook server only
 triagent --webhook-only
+
+# Direct incident investigation
+triagent --incident "API gateway returning 503 errors"
+```
+
+## Execution Modes
+
+Triagent supports three execution modes for running commands:
+
+### Sandbox Mode (Default)
+
+Commands run inside a Docker container via [Bashlet](https://github.com/anthropics/bashlet). This provides isolation and safety - the agent cannot accidentally modify your host system.
+
+```bash
+triagent
+```
+
+Codebases are mounted at `/workspace/<name>` and kubeconfig at `/root/.kube`.
+
+### Host Mode
+
+Commands run directly on your local machine. Use this when you need access to tools not available in the sandbox.
+
+```bash
+triagent --host
+```
+
+### Remote Mode
+
+Commands run on a remote server via SSH. This is useful for connecting to a Docker container or VM with pre-installed debugging tools.
+
+```bash
+triagent --remote user@host
+triagent -r root@debug-container.local
+```
+
+On startup, triagent creates a session workspace on the remote:
+```
+🌐 Running in remote mode: root@debug-container.local
+   Workspace: /tmp/triagent-a3b4c5d6 (session: a3b4c5d6)
+```
+
+**Requirements:**
+- SSH key-based authentication (no password prompts)
+- The remote must have the necessary CLI tools (kubectl, etc.)
+
+**Example: Debug container setup**
+
+```bash
+# Run a container with SSH and debugging tools
+docker run -d --name debug-tools \
+  -p 2222:22 \
+  -v ~/.kube:/root/.kube:ro \
+  your-debug-image:latest
+
+# Add to ~/.ssh/config for easy access
+# Host debug-tools
+#   HostName localhost
+#   Port 2222
+#   User root
+
+# Connect triagent to it
+triagent --remote debug-tools
 ```
 
 ## Configuration
@@ -57,9 +120,46 @@ triagent config path
 | `apiKey` | API key for the provider | - |
 | `baseUrl` | Custom API base URL (for proxies or local models) | - |
 | `webhookPort` | Webhook server port | `3000` |
-| `codebasePath` | Path to codebase | `./` |
+| `codebasePath` | Path to single codebase (legacy) | `./` |
 | `kubeConfigPath` | Kubernetes config path | `~/.kube` |
 
+### Multiple Codebases
+
+For applications spanning multiple repositories, configure `codebasePaths` in `~/.config/triagent/config.json`:
+
+```json
+{
+  "codebasePaths": [
+    { "name": "frontend", "path": "/path/to/frontend-repo" },
+    { "name": "backend", "path": "/path/to/backend-repo" },
+    { "name": "infra", "path": "/path/to/infrastructure" }
+  ]
+}
+```
+
+Each codebase is mounted at `/workspace/<name>` in the sandbox. The model can access any codebase as needed during investigation.
+
+### Custom Instructions (TRIAGENT.md)
+
+Create `~/.config/triagent/TRIAGENT.md` to provide custom instructions to the model. These instructions are prepended to the default system prompt.
+
+Example `TRIAGENT.md`:
+
+```markdown
+## Project Context
+
+This is a microservices e-commerce platform with the following services:
+- frontend: Next.js app in /workspace/frontend
+- api: Go backend in /workspace/backend
+- infra: Terraform configs in /workspace/infra
+
+## Investigation Priorities
+
+1. Always check the api service logs first for 5xx errors
+2. The frontend service talks to api via internal DNS: api.default.svc.cluster.local
+3. Common issues: Redis connection timeouts, PostgreSQL connection pool exhaustion
+```
+
 ### Environment Variables
 
 | Variable | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triagent",
-  "version": "0.1.0-alpha8",
+  "version": "0.1.0-beta2",
   "description": "AI-powered Kubernetes debugging agent with terminal UI",
   "type": "module",
   "main": "src/index.ts",
@@ -27,7 +27,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/OWNER/triagent.git"
+    "url": "git+https://github.com/ServiceWeave/triagent.git"
+  },
+  "homepage": "https://github.com/ServiceWeave/triagent#readme",
+  "bugs": {
+    "url": "https://github.com/ServiceWeave/triagent/issues"
   },
   "license": "MIT",
   "scripts": {
@@ -41,8 +45,10 @@
     "@ai-sdk/anthropic": "^1.2.0",
     "@ai-sdk/google": "^1.2.0",
     "@ai-sdk/openai": "^1.3.0",
-    "@bashlet/sdk": "^0.1.0-alpha1",
+    "@bashlet/sdk": "1.3.2",
     "@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",

package/src/cli/config.ts

@@ -3,23 +3,139 @@ import { homedir } from "os";
 import { join } from "path";
 import type { AIProvider } from "../config.js";
 
+export interface CodebaseEntry {
+  name: string;
+  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;
   apiKey?: string;
   baseUrl?: string;
   webhookPort?: number;
-  codebasePath?: string;
+  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;
 }
 
+export async function getTriagentMdPath(): Promise<string> {
+  return TRIAGENT_MD_FILE;
+}
+
+export async function loadTriagentMd(): Promise<string | null> {
+  try {
+    const content = await readFile(TRIAGENT_MD_FILE, "utf-8");
+    return content.trim();
+  } catch {
+    return 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");
@@ -40,7 +156,7 @@ export async function setConfigValue(key: keyof StoredConfig, value: string | nu
   await saveStoredConfig(config);
 }
 
-export async function getConfigValue(key: keyof StoredConfig): Promise<string | number | undefined> {
+export async function getConfigValue(key: keyof StoredConfig): Promise<StoredConfig[keyof StoredConfig]> {
   const config = await loadStoredConfig();
   return config[key];
 }

package/src/config.ts

@@ -1,22 +1,28 @@
 import { z } from "zod";
 import { resolve } from "path";
 import { homedir } from "os";
-import { loadStoredConfig, type StoredConfig } from "./cli/config.js";
+import { loadStoredConfig, type StoredConfig, type CodebaseEntry } from "./cli/config.js";
 
 const AIProviderSchema = z.enum(["openai", "anthropic", "google"]);
 export type AIProvider = z.infer<typeof AIProviderSchema>;
 
+const CodebaseEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+});
+
 const ConfigSchema = z.object({
   aiProvider: AIProviderSchema,
   aiModel: z.string().min(1),
   apiKey: z.string().min(1),
   baseUrl: z.string().url().optional(),
   webhookPort: z.number().int().positive().default(3000),
-  codebasePath: z.string().min(1).default("./"),
+  codebasePaths: z.array(CodebaseEntrySchema).min(1),
   kubeConfigPath: z.string().min(1).default("~/.kube"),
 });
 
 export type Config = z.infer<typeof ConfigSchema>;
+export type { CodebaseEntry };
 
 function expandPath(path: string): string {
   if (path.startsWith("~")) {
@@ -39,6 +45,20 @@ function getApiKey(provider: AIProvider, stored: StoredConfig): string {
   }
 }
 
+function resolveCodebasePaths(stored: StoredConfig): CodebaseEntry[] {
+  // Priority: codebasePaths array > legacy codebasePath > default
+  if (stored.codebasePaths && stored.codebasePaths.length > 0) {
+    return stored.codebasePaths.map((entry) => ({
+      name: entry.name,
+      path: expandPath(entry.path),
+    }));
+  }
+
+  // Backward compatibility: convert single codebasePath to array
+  const legacyPath = process.env.CODEBASE_PATH || stored.codebasePath || "./";
+  return [{ name: "workspace", path: expandPath(legacyPath) }];
+}
+
 export async function loadConfig(): Promise<Config> {
   const stored = await loadStoredConfig();
 
@@ -50,7 +70,7 @@ export async function loadConfig(): Promise<Config> {
     apiKey: getApiKey(provider, stored),
     baseUrl: process.env.AI_BASE_URL || stored.baseUrl || undefined,
     webhookPort: parseInt(process.env.WEBHOOK_PORT || String(stored.webhookPort || 3000), 10),
-    codebasePath: expandPath(process.env.CODEBASE_PATH || stored.codebasePath || "./"),
+    codebasePaths: resolveCodebasePaths(stored),
     kubeConfigPath: expandPath(process.env.KUBE_CONFIG_PATH || stored.kubeConfigPath || "~/.kube"),
   };