triagent 0.1.0-alpha1 → 0.1.0-alpha12

package/README.md

@@ -5,7 +5,17 @@ AI-powered Kubernetes debugging agent with terminal UI.
 ## Installation
 
 ```bash
-bun install triagent
+# bun
+bun install -g triagent
+
+# npm
+npm install -g triagent
+
+# yarn
+yarn global add triagent
+
+# pnpm
+pnpm add -g triagent
 ```
 
 ## Usage
@@ -20,14 +30,99 @@ triagent --webhook-only
 
 ## Configuration
 
-Set the following environment variables:
+Configuration can be set via CLI commands or environment variables. CLI config takes precedence over environment variables.
+
+### CLI Config
+
+```bash
+# Set configuration values
+triagent config set <key> <value>
+
+# Get a configuration value
+triagent config get <key>
+
+# List all configuration values
+triagent config list
+
+# Show config file path
+triagent config path
+```
+
+### Config Keys
+
+| Key | Description | Default |
+|-----|-------------|---------|
+| `aiProvider` | AI provider (`openai`, `anthropic`, `google`) | `anthropic` |
+| `aiModel` | Model ID (e.g., `gpt-4o`, `claude-sonnet-4-20250514`) | Provider default |
+| `apiKey` | API key for the provider | - |
+| `baseUrl` | Custom API base URL (for proxies or local models) | - |
+| `webhookPort` | Webhook server port | `3000` |
+| `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 |
+|----------|-------------|
+| `AI_PROVIDER` | AI provider (`openai`, `anthropic`, `google`) |
+| `AI_MODEL` | Model ID |
+| `AI_BASE_URL` | Custom API base URL |
+| `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 |
+| `CODEBASE_PATH` | Path to codebase |
+| `KUBE_CONFIG_PATH` | Kubernetes config path |
+
+### Examples
 
 ```bash
-ANTHROPIC_API_KEY=your-api-key
-# or
-OPENAI_API_KEY=your-api-key
-# or
-GOOGLE_GENERATIVE_AI_API_KEY=your-api-key
+# Configure with Anthropic (default)
+triagent config set apiKey sk-ant-...
+
+# Configure with OpenAI
+triagent config set aiProvider openai
+triagent config set apiKey sk-proj-...
+
+# Use a custom API endpoint (e.g., proxy or local model)
+triagent config set baseUrl https://your-proxy.example.com/v1
 ```
 
 ## Development

package/bunfig.toml

@@ -1 +1,5 @@
 preload = ["@opentui/solid/preload"]
+
+[jsx]
+runtime = "automatic"
+importSource = "@opentui/solid"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triagent",
-  "version": "0.1.0-alpha1",
+  "version": "0.1.0-alpha12",
   "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": {
@@ -46,12 +50,15 @@
     "@opentui/core": "^0.1.72",
     "@opentui/solid": "^0.1.72",
     "hono": "^4.6.0",
-    "solid-js": "^1.9.10",
+    "opentui-spinner": "^0.0.6",
+    "solid-js": "1.9.9",
+    "triagent": "^0.1.0-alpha1",
     "zod": "^3.24.0"
   },
   "devDependencies": {
-    "typescript": "^5.7.0",
+    "@types/babel__core": "^7.20.5",
     "@types/node": "^22.0.0",
-    "bun-types": "^1.2.0"
+    "bun-types": "^1.2.0",
+    "typescript": "^5.7.0"
   }
 }

package/src/cli/config.ts

@@ -3,22 +3,43 @@ import { homedir } from "os";
 import { join } from "path";
 import type { AIProvider } from "../config.js";
 
+export interface CodebaseEntry {
+  name: string;
+  path: string;
+}
+
 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;
 }
 
 const CONFIG_DIR = join(homedir(), ".config", "triagent");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const TRIAGENT_MD_FILE = join(CONFIG_DIR, "TRIAGENT.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 loadStoredConfig(): Promise<StoredConfig> {
   try {
     const content = await readFile(CONFIG_FILE, "utf-8");
@@ -39,7 +60,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,21 +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("~")) {
@@ -38,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();
 
@@ -47,8 +68,9 @@ export async function loadConfig(): Promise<Config> {
     aiProvider: provider,
     aiModel: process.env.AI_MODEL || stored.aiModel || getDefaultModel(provider),
     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"),
   };
 

package/src/index.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env bun
+// Load solid JSX plugin before any TSX imports
+import "@opentui/solid/preload";
+
 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,
@@ -84,10 +86,18 @@ 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
+  baseUrl        - Custom API base URL (for proxies or local models)
   webhookPort    - Webhook server port (default: 3000)
-  codebasePath   - Path to codebase (default: ./)
+  codebasePath   - Path to codebase (default: ./) - for single codebase
   kubeConfigPath - Kubernetes config path (default: ~/.kube)
 
+  For multiple codebases, edit ~/.config/triagent/config.json directly:
+    "codebasePaths": [
+      { "name": "frontend", "path": "/path/to/frontend" },
+      { "name": "backend", "path": "/path/to/backend" }
+    ]
+  Each codebase will be mounted at /workspace/<name> in the sandbox.
+
 MODES:
   Interactive (default):
     Run with no arguments to start the interactive TUI.
@@ -109,6 +119,7 @@ MODES:
 ENVIRONMENT VARIABLES:
   AI_PROVIDER              - AI provider (openai, anthropic, google)
   AI_MODEL                 - Model ID (e.g., gpt-4o, claude-3-5-sonnet)
+  AI_BASE_URL              - Custom API base URL (for proxies or local models)
   OPENAI_API_KEY          - OpenAI API key
   ANTHROPIC_API_KEY       - Anthropic API key
   GOOGLE_GENERATIVE_AI_API_KEY - Google AI API key
@@ -152,7 +163,12 @@ async function runDirectIncident(description: string): Promise<void> {
         if (toolCalls && toolCalls.length > 0) {
           const toolCall = toolCalls[0];
           const toolName = "toolName" in toolCall ? toolCall.toolName : "tool";
-          console.log(`\n[Tool: ${toolName}]\n`);
+          const args = "args" in toolCall ? toolCall.args : {};
+          console.log(`\n[Tool: ${toolName}]`);
+          if (args && typeof args === "object" && "command" in args) {
+            console.log(`$ ${args.command}`);
+          }
+          console.log();
         }
       },
     });
@@ -174,6 +190,7 @@ async function handleConfigCommand(args: CliArgs): Promise<void> {
     "aiProvider",
     "aiModel",
     "apiKey",
+    "baseUrl",
     "webhookPort",
     "codebasePath",
     "kubeConfigPath",
@@ -270,7 +287,7 @@ async function main(): Promise<void> {
   // Initialize sandbox and Mastra
   try {
     initSandboxFromConfig(config, args.host);
-    createMastraInstance(config);
+    await createMastraInstance(config);
     if (args.host) {
       console.log("⚠️  Running in host mode (no sandbox)\n");
     }
@@ -289,6 +306,8 @@ async function main(): Promise<void> {
   } else {
     // Interactive TUI mode
     console.log("Starting Triagent TUI...\n");
+    // Dynamic import to ensure solid plugin is loaded first
+    const { runTUI } = await import("./tui/app.jsx");
     const tui = await runTUI();
 
     // Handle graceful shutdown

package/src/mastra/agents/debugger.ts

@@ -1,20 +1,23 @@
 import { Agent } from "@mastra/core/agent";
 import { z } from "zod";
-import { kubectlTool } from "../tools/kubectl.js";
+import { cliTool } from "../tools/cli.js";
 import { gitTool } from "../tools/git.js";
 import { filesystemTool } from "../tools/filesystem.js";
+import { loadTriagentMd } from "../../cli/config.js";
 import type { Config } from "../../config.js";
 
 const DEBUGGER_INSTRUCTIONS = `You are an expert Kubernetes debugging agent named Triagent. Your role is to investigate and diagnose issues in Kubernetes clusters by analyzing resources, logs, code, and git history.
 
 ## Your Capabilities
 
-1. **Kubernetes Inspection** (kubectl tool):
-   - Get resource status (pods, deployments, services, configmaps)
-   - Describe resources for detailed information
-   - Fetch container logs
-   - Check resource usage (top)
-   - Review cluster events
+1. **CLI Access** (cli tool):
+   - Run any shell command including kubectl, grep, awk, jq, curl, etc.
+   - Pipe commands together for powerful filtering and processing
+   - Examples:
+     - \`kubectl get pods -A | grep inventory\`
+     - \`kubectl logs deploy/myapp --tail 100 | grep -i error\`
+     - \`kubectl get pods -o json | jq '.items[].metadata.name'\`
+     - \`kubectl describe pod mypod | grep -A10 Events\`
 
 2. **Code Analysis** (filesystem tool):
    - Read source code files
@@ -27,6 +30,39 @@ const DEBUGGER_INSTRUCTIONS = `You are an expert Kubernetes debugging agent name
    - Show specific commit details
    - Blame files to find who changed what
 
+## Resource Discovery Strategy
+
+When asked to find resources for a service (e.g., "inventory service"), DO NOT simply try one label like \`app=inventory\` and give up if not found. Instead, use a systematic discovery approach:
+
+1. **Search by partial name match using grep**:
+   - \`kubectl get pods -A | grep -i inventory\`
+   - \`kubectl get deploy,svc -A | grep -i inventory\`
+   - This finds resources with "inventory" anywhere in the name (e.g., \`inventory-api\`, \`svc-inventory\`)
+
+2. **If grep returns no results, list all resources to browse**:
+   - \`kubectl get pods,deploy,svc -A\` to see everything
+   - \`kubectl get pods -n <namespace>\` if namespace is known
+
+3. **Try common label patterns**:
+   - \`kubectl get pods -A -l app=inventory\`
+   - \`kubectl get pods -A -l app.kubernetes.io/name=inventory\`
+   - \`kubectl get pods -A -l component=inventory\`
+
+4. **Follow the resource chain**:
+   - Found a Service? \`kubectl describe svc <name> | grep Selector\` then find pods with that selector
+   - Found a Deployment? \`kubectl get pods -l app=<deployment-name>\`
+   - Use \`kubectl get endpoints <svc-name>\` to see which pods back a service
+
+5. **Check events for context**:
+   - \`kubectl get events -A --sort-by='.lastTimestamp' | grep -i inventory\`
+   - \`kubectl get events -A --sort-by='.lastTimestamp' | head -20\` for recent cluster activity
+
+6. **When you find a potential match**:
+   - \`kubectl describe <resource> <name>\` to confirm it's the right one
+   - Check related resources (pods for a deployment, endpoints for a service)
+
+Always report what you searched for and what you found, even if it's not an exact match. The user can confirm if you found the right resource.
+
 ## Investigation Process
 
 When given an incident, follow this systematic approach:
@@ -36,26 +72,32 @@ When given an incident, follow this systematic approach:
    - What symptoms are being observed
    - When the issue started (if known)
 
-2. **Check Cluster State**:
-   - Get pod status for affected services
-   - Check for recent events
+2. **Discover Relevant Resources**:
+   - Use the Resource Discovery Strategy above to find the affected resources
+   - Don't assume exact names or labels - search broadly first
+   - Follow the resource chain (Service → Deployment → Pods → Containers)
+
+3. **Check Cluster State**:
+   - Get pod status for discovered resources
+   - Check for recent events related to those resources
    - Look at resource usage
 
-3. **Analyze Logs**:
-   - Fetch logs from affected pods
+4. **Analyze Logs**:
+   - Fetch logs from affected pods (use \`--tail 100\` to get recent logs)
    - Look for errors, exceptions, or unusual patterns
+   - If multiple containers, check each one
 
-4. **Investigate Recent Changes**:
+5. **Investigate Recent Changes**:
    - Check git log for recent commits
    - Review diffs of suspicious changes
    - Correlate timing with when issues started
 
-5. **Examine Code**:
+6. **Examine Code**:
    - Read relevant configuration files
    - Check application code if needed
    - Look for misconfigurations
 
-6. **Synthesize Findings**:
+7. **Synthesize Findings**:
    - Identify the root cause
    - List affected resources
    - Provide actionable recommendations
@@ -121,17 +163,30 @@ export const InvestigationResultSchema = z.object({
 
 export type InvestigationResult = z.infer<typeof InvestigationResultSchema>;
 
-export function createDebuggerAgent(config: Config) {
-  // Construct model string based on provider
-  const modelString = `${config.aiProvider}/${config.aiModel}`;
+export async function createDebuggerAgent(config: Config) {
+  // Load user instructions from ~/.config/triagent/TRIAGENT.md if present
+  const userInstructions = await loadTriagentMd();
+
+  // Combine user instructions with default instructions
+  const instructions = userInstructions
+    ? `## User-Provided Instructions\n\n${userInstructions}\n\n---\n\n${DEBUGGER_INSTRUCTIONS}`
+    : DEBUGGER_INSTRUCTIONS;
+
+  // Construct model config with API key and optional base URL
+  const modelId = `${config.aiProvider}/${config.aiModel}` as const;
+  const modelConfig = {
+    id: modelId,
+    apiKey: config.apiKey,
+    ...(config.baseUrl && { url: config.baseUrl }),
+  };
 
   return new Agent({
     id: "kubernetes-debugger",
     name: "Kubernetes Debugger",
-    instructions: DEBUGGER_INSTRUCTIONS,
-    model: modelString as any, // Mastra handles model routing
+    instructions,
+    model: modelConfig as any, // Mastra handles model routing
     tools: {
-      kubectl: kubectlTool,
+      cli: cliTool,
       git: gitTool,
       filesystem: filesystemTool,
     },

package/src/mastra/index.ts

@@ -4,12 +4,12 @@ import type { Config } from "../config.js";
 
 let mastraInstance: Mastra | null = null;
 
-export function createMastraInstance(config: Config): Mastra {
+export async function createMastraInstance(config: Config): Promise<Mastra> {
   if (mastraInstance) {
     return mastraInstance;
   }
 
-  const debuggerAgent = createDebuggerAgent(config);
+  const debuggerAgent = await createDebuggerAgent(config);
 
   mastraInstance = new Mastra({
     agents: {

package/src/mastra/tools/cli.ts

@@ -0,0 +1,65 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { execCommand } from "../../sandbox/bashlet.js";
+
+interface CliOutput {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+function filterSensitiveData(output: string): string {
+  // Redact potential secrets, tokens, and passwords
+  return output
+    .replace(
+      /(password|secret|token|key|credential)[\s:=]+["']?[^\s"'\n]+["']?/gi,
+      "$1: [REDACTED]"
+    )
+    .replace(/Bearer\s+[^\s]+/gi, "Bearer [REDACTED]")
+    .replace(/-----BEGIN[^-]+-----[\s\S]*?-----END[^-]+-----/g, "[REDACTED CERTIFICATE/KEY]");
+}
+
+export const cliTool = createTool({
+  id: "cli",
+  description: `Execute shell commands in the sandbox environment.
+Use this to run any CLI commands including kubectl, grep, awk, jq, curl, etc.
+Supports pipes and command chaining.
+
+Examples:
+- List all pods: kubectl get pods -A
+- Find pods by name: kubectl get pods -A | grep inventory
+- Get logs with filtering: kubectl logs deployment/myapp -n prod --tail 100 | grep -i error
+- Check resource usage: kubectl top pods -n default
+- Describe and search: kubectl describe pod mypod | grep -A5 "Events"
+- JSON processing: kubectl get pods -o json | jq '.items[].metadata.name'`,
+
+  inputSchema: z.object({
+    command: z.string().describe("The shell command to execute"),
+  }),
+
+  execute: async ({ command }): Promise<CliOutput> => {
+    try {
+      const result = await execCommand(command);
+
+      if (result.exitCode !== 0) {
+        return {
+          success: false,
+          output: result.stdout ? filterSensitiveData(result.stdout) : "",
+          error: result.stderr || `Command failed with exit code ${result.exitCode}`,
+        };
+      }
+
+      return {
+        success: true,
+        output: filterSensitiveData(result.stdout),
+        error: result.stderr ? filterSensitiveData(result.stderr) : undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+});

package/src/sandbox/bashlet.ts

@@ -1,7 +1,7 @@
 import { Bashlet } from "@bashlet/sdk";
 import { $ } from "bun";
 import { readFile as fsReadFile, readdir } from "fs/promises";
-import type { Config } from "../config.js";
+import type { Config, CodebaseEntry } from "../config.js";
 
 export interface CommandResult {
   stdout: string;
@@ -10,7 +10,7 @@ export interface CommandResult {
 }
 
 export interface SandboxOptions {
-  codebasePath: string;
+  codebasePaths: CodebaseEntry[];
   kubeConfigPath: string;
   timeout?: number;
   useHost?: boolean;
@@ -22,7 +22,8 @@ let hostWorkdir = "./";
 
 export function createSandbox(options: SandboxOptions): void {
   hostMode = options.useHost ?? false;
-  hostWorkdir = options.codebasePath;
+  // Use first codebase as default working directory
+  hostWorkdir = options.codebasePaths[0]?.path || "./";
 
   if (hostMode) {
     return;
@@ -32,9 +33,15 @@ export function createSandbox(options: SandboxOptions): void {
     return;
   }
 
+  // Mount each codebase at /workspace/<name>
+  const codebaseMounts = options.codebasePaths.map((entry) => ({
+    hostPath: entry.path,
+    guestPath: `/workspace/${entry.name}`,
+  }));
+
   bashletInstance = new Bashlet({
     mounts: [
-      { hostPath: options.codebasePath, guestPath: "/workspace" },
+      ...codebaseMounts,
       { hostPath: options.kubeConfigPath, guestPath: "/root/.kube" },
     ],
     workdir: "/workspace",
@@ -143,7 +150,7 @@ export async function listDir(path: string): Promise<string[]> {
 
 export function initSandboxFromConfig(config: Config, useHost: boolean = false): void {
   createSandbox({
-    codebasePath: config.codebasePath,
+    codebasePaths: config.codebasePaths,
     kubeConfigPath: config.kubeConfigPath,
     timeout: 120,
     useHost,

package/src/server/webhook.ts

@@ -149,7 +149,11 @@ async function runInvestigation(id: string): Promise<void> {
         if (toolCalls && toolCalls.length > 0) {
           const toolCall = toolCalls[0];
           const toolName = "toolName" in toolCall ? toolCall.toolName : "tool";
+          const args = "args" in toolCall ? toolCall.args : {};
           console.log(`[Investigation ${id}] Tool: ${toolName}`);
+          if (args && typeof args === "object" && "command" in args) {
+            console.log(`[Investigation ${id}] $ ${args.command}`);
+          }
         }
       },
     });

package/src/tui/app.tsx

@@ -1,6 +1,8 @@
+/* @jsxImportSource @opentui/solid */
 import { render } from "@opentui/solid";
 import { createSignal, For, Show, onMount } from "solid-js";
 import { createTextAttributes } from "@opentui/core";
+import "opentui-spinner/solid";
 import { getDebuggerAgent, buildIncidentPrompt } from "../mastra/index.js";
 import type { IncidentInput } from "../mastra/agents/debugger.js";
 
@@ -10,6 +12,25 @@ interface Message {
   content: string;
   timestamp: Date;
   toolName?: string;
+  command?: string;
+}
+
+// Conversation history for multi-turn debugging
+interface ConversationMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+function formatHistoryAsPrompt(history: ConversationMessage[], newMessage: string): string {
+  if (history.length === 0) {
+    return newMessage;
+  }
+
+  const historyText = history
+    .map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`)
+    .join("\n\n");
+
+  return `Previous conversation:\n${historyText}\n\nUser: ${newMessage}`;
 }
 
 type AppStatus = "idle" | "investigating" | "complete" | "error";
@@ -17,8 +38,55 @@ type AppStatus = "idle" | "investigating" | "complete" | "error";
 const ATTR_DIM = createTextAttributes({ dim: true });
 const ATTR_BOLD = createTextAttributes({ bold: true });
 
+function buildDisplayCommand(toolName: string, args: unknown): string | undefined {
+  if (!args || typeof args !== "object") return undefined;
+
+  const a = args as Record<string, unknown>;
+
+  switch (toolName) {
+    case "cli":
+      // CLI tool has direct command
+      return "command" in a ? String(a.command) : undefined;
+
+    case "git": {
+      // Build git command: git <command> [args...] [path]
+      if (!("command" in a)) return undefined;
+      const parts = ["git", String(a.command)];
+      if ("args" in a && Array.isArray(a.args)) {
+        parts.push(...a.args.map(String));
+      }
+      if ("path" in a && a.path) {
+        parts.push(String(a.path));
+      }
+      return parts.join(" ");
+    }
+
+    case "filesystem": {
+      // Build filesystem display: <operation> <path> [pattern]
+      if (!("operation" in a)) return undefined;
+      const op = String(a.operation);
+      const path = "path" in a ? String(a.path) : "";
+      if (op === "search" && "pattern" in a) {
+        return `grep "${a.pattern}" ${path}`;
+      }
+      if (op === "read") {
+        return `cat ${path}`;
+      }
+      if (op === "list") {
+        return `ls ${path}`;
+      }
+      return `${op} ${path}`;
+    }
+
+    default:
+      // Fallback: try to use command if it exists
+      return "command" in a ? String(a.command) : undefined;
+  }
+}
+
 function App() {
   const [messages, setMessages] = createSignal<Message[]>([]);
+  const [conversationHistory, setConversationHistory] = createSignal<ConversationMessage[]>([]);
   const [status, setStatus] = createSignal<AppStatus>("idle");
   const [currentTool, setCurrentTool] = createSignal<string | null>(null);
   const [inputValue, setInputValue] = createSignal("");
@@ -40,29 +108,50 @@ function App() {
     setError(null);
     setCurrentTool(null);
 
+    // Add user message to UI
     addMessage({
       role: "user",
       content: incident.description,
     });
 
+    // Build prompt: use full incident prompt for first message, include history for follow-ups
+    const isFirstMessage = conversationHistory().length === 0;
+    const userContent = isFirstMessage
+      ? buildIncidentPrompt(incident)
+      : incident.description;
+
+    // Format prompt with conversation history
+    const prompt = formatHistoryAsPrompt(conversationHistory(), userContent);
+
+    // Add user message to conversation history
+    setConversationHistory((prev) => [
+      ...prev,
+      { role: "user", content: userContent },
+    ]);
+
     try {
       const agent = getDebuggerAgent();
-      const prompt = buildIncidentPrompt(incident);
 
       let assistantContent = "";
 
+      // Send the formatted prompt to the agent
       const stream = await agent.stream(prompt, {
         maxSteps: 20,
         onStepFinish: ({ toolCalls }) => {
           if (toolCalls && toolCalls.length > 0) {
-            const toolCall = toolCalls[0];
-            const toolName =
-              "toolName" in toolCall ? String(toolCall.toolName) : "tool";
+            const toolCall = toolCalls[0] as { toolName?: string; args?: unknown };
+            const toolName = toolCall.toolName ?? "tool";
+            const args = toolCall.args ?? {};
+
+            // Build display command based on tool type
+            const command = buildDisplayCommand(toolName, args);
+
             setCurrentTool(toolName);
             addMessage({
               role: "tool",
-              content: `Executing ${toolName}...`,
+              content: command ? `$ ${command}` : `Executing ${toolName}...`,
               toolName,
+              command,
             });
           }
         },
@@ -72,11 +161,18 @@ function App() {
         assistantContent += chunk;
       }
 
+      // Add assistant response to UI
       addMessage({
         role: "assistant",
         content: assistantContent,
       });
 
+      // Add assistant response to conversation history
+      setConversationHistory((prev) => [
+        ...prev,
+        { role: "assistant", content: assistantContent },
+      ]);
+
       setStatus("complete");
       setCurrentTool(null);
     } catch (err) {
@@ -185,7 +281,13 @@ function App() {
                     </box>
                   </Show>
                   <Show when={msg.role === "tool"}>
-                    <box flexDirection="row" gap={1}>
+                    <box flexDirection="row" gap={1} alignItems="center">
+                      <Show
+                        when={status() === "investigating" && msg.id === messages().filter(m => m.role === "tool").at(-1)?.id}
+                        fallback={<text fg="green">✓</text>}
+                      >
+                        <spinner name="dots" color="blue" />
+                      </Show>
                       <text fg="blue" attributes={ATTR_DIM}>
                         [{msg.toolName}]
                       </text>

package/src/mastra/tools/kubectl.ts

@@ -1,107 +0,0 @@
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-import { execCommand } from "../../sandbox/bashlet.js";
-
-const ALLOWED_COMMANDS = ["get", "describe", "logs", "top", "events"] as const;
-
-const KubectlInputSchema = z.object({
-  command: z.enum(ALLOWED_COMMANDS).describe("The kubectl command to run"),
-  resource: z
-    .string()
-    .optional()
-    .describe(
-      "Resource type (e.g., pods, deployments, services, configmaps, secrets)"
-    ),
-  name: z.string().optional().describe("Specific resource name"),
-  namespace: z
-    .string()
-    .optional()
-    .describe("Kubernetes namespace (defaults to current context namespace)"),
-  flags: z
-    .array(z.string())
-    .optional()
-    .describe(
-      "Additional flags (e.g., ['-o', 'yaml'], ['--tail', '100'], ['-l', 'app=myapp'])"
-    ),
-});
-
-// Output type (no schema validation to allow error returns)
-interface KubectlOutput {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-function filterSensitiveData(output: string): string {
-  // Redact potential secrets, tokens, and passwords
-  return output
-    .replace(
-      /(password|secret|token|key|credential)[\s:=]+["']?[^\s"'\n]+["']?/gi,
-      "$1: [REDACTED]"
-    )
-    .replace(/Bearer\s+[^\s]+/gi, "Bearer [REDACTED]")
-    .replace(/-----BEGIN[^-]+-----[\s\S]*?-----END[^-]+-----/g, "[REDACTED CERTIFICATE/KEY]");
-}
-
-export const kubectlTool = createTool({
-  id: "kubectl",
-  description: `Execute kubectl commands to inspect Kubernetes resources.
-Available commands: ${ALLOWED_COMMANDS.join(", ")}.
-Use this to get information about pods, deployments, services, logs, and cluster events.
-Examples:
-- Get all pods: { command: "get", resource: "pods", flags: ["-A"] }
-- Get pod logs: { command: "logs", name: "my-pod", namespace: "default", flags: ["--tail", "100"] }
-- Describe deployment: { command: "describe", resource: "deployment", name: "my-app" }
-- Get events: { command: "events", namespace: "production", flags: ["--sort-by", ".lastTimestamp"] }`,
-
-  inputSchema: KubectlInputSchema,
-
-  execute: async (inputData): Promise<KubectlOutput> => {
-    const { command, resource, name, namespace, flags } = inputData;
-
-    // Build kubectl command
-    const parts = ["kubectl", command];
-
-    if (resource) {
-      parts.push(resource);
-    }
-
-    if (name) {
-      parts.push(name);
-    }
-
-    if (namespace) {
-      parts.push("-n", namespace);
-    }
-
-    if (flags && flags.length > 0) {
-      parts.push(...flags);
-    }
-
-    const fullCommand = parts.join(" ");
-
-    try {
-      const result = await execCommand(fullCommand);
-
-      if (result.exitCode !== 0) {
-        return {
-          success: false,
-          output: "",
-          error: result.stderr || `Command failed with exit code ${result.exitCode}`,
-        };
-      }
-
-      return {
-        success: true,
-        output: filterSensitiveData(result.stdout),
-        error: result.stderr ? filterSensitiveData(result.stderr) : undefined,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: "",
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  },
-});