triagent 0.1.0-alpha10 → 0.1.0-alpha13

package/README.md

@@ -57,9 +57,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-alpha10",
+  "version": "0.1.0-alpha13",
   "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,6 +50,8 @@
     "@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",
@@ -53,6 +59,7 @@
   },
   "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

@@ -3,23 +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");
@@ -40,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,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"),
   };
 

package/src/index.ts

@@ -88,9 +88,16 @@ CONFIG KEYS:
   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.
@@ -280,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");
     }

package/src/mastra/agents/debugger.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 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.
@@ -162,7 +163,15 @@ export const InvestigationResultSchema = z.object({
 
 export type InvestigationResult = z.infer<typeof InvestigationResultSchema>;
 
-export function createDebuggerAgent(config: Config) {
+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 = {
@@ -174,7 +183,7 @@ export function createDebuggerAgent(config: Config) {
   return new Agent({
     id: "kubernetes-debugger",
     name: "Kubernetes Debugger",
-    instructions: DEBUGGER_INSTRUCTIONS,
+    instructions,
     model: modelConfig as any, // Mastra handles model routing
     tools: {
       cli: cliTool,

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/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/tui/app.tsx

@@ -3,9 +3,22 @@ import { render } from "@opentui/solid";
 import { createSignal, For, Show, onMount } from "solid-js";
 import { createTextAttributes } from "@opentui/core";
 import "opentui-spinner/solid";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
 import { getDebuggerAgent, buildIncidentPrompt } from "../mastra/index.js";
 import type { IncidentInput } from "../mastra/agents/debugger.js";
 
+// Configure marked with terminal renderer
+marked.use(markedTerminal() as any);
+
+function renderMarkdown(content: string): string {
+  try {
+    return marked(content) as string;
+  } catch {
+    return content;
+  }
+}
+
 interface Message {
   id: string;
   role: "user" | "assistant" | "tool";
@@ -302,7 +315,7 @@ function App() {
                         Triagent:
                       </text>
                       <text fg="white" wrapMode="word">
-                        {msg.content}
+                        {renderMarkdown(msg.content)}
                       </text>
                     </box>
                   </Show>