Merge pull request #146 from subsy/feat/subagent-panel-improvements

feat: subagent panel improvements with TAB navigation and OpenCode support

Author: subsy

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-tui",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Ralph TUI - AI Agent Loop Orchestrator",
   "type": "module",
   "main": "./dist/index.js",

src/engine/index.test.ts

@@ -193,4 +193,43 @@ describe('ExecutionEngine', () => {
       expect(result3.success).toBe(true);
     });
   });
+
+  describe('getSubagentDetails', () => {
+    test('returns undefined for non-existent subagent', () => {
+      const engine = new ExecutionEngine(createMockConfig());
+      const result = engine.getSubagentDetails('non-existent-id');
+      expect(result).toBeUndefined();
+    });
+
+    test('returns undefined when no subagents have been tracked', () => {
+      const engine = new ExecutionEngine(createMockConfig());
+      // No subagents tracked yet
+      const result = engine.getSubagentDetails('any-id');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getSubagentOutput', () => {
+    test('returns undefined for non-existent subagent', () => {
+      const engine = new ExecutionEngine(createMockConfig());
+      const result = engine.getSubagentOutput('non-existent-id');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getActiveSubagentId', () => {
+    test('returns undefined when no subagents are active', () => {
+      const engine = new ExecutionEngine(createMockConfig());
+      const result = engine.getActiveSubagentId();
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getSubagentTree', () => {
+    test('returns empty array when no subagents', () => {
+      const engine = new ExecutionEngine(createMockConfig());
+      const result = engine.getSubagentTree();
+      expect(result).toEqual([]);
+    });
+  });
 });

src/engine/index.ts

@@ -33,8 +33,12 @@ import { getAgentRegistry } from '../plugins/agents/registry.js';
 import { getTrackerRegistry } from '../plugins/trackers/registry.js';
 import { SubagentTraceParser } from '../plugins/agents/tracing/parser.js';
 import type { SubagentEvent } from '../plugins/agents/tracing/types.js';
-import { ClaudeAgentPlugin } from '../plugins/agents/builtin/claude.js';
+import type { ClaudeJsonlMessage } from '../plugins/agents/builtin/claude.js';
 import { createDroidStreamingJsonlParser, isDroidJsonlMessage, toClaudeJsonlMessages } from '../plugins/agents/droid/outputParser.js';
+import {
+  isOpenCodeTaskTool,
+  openCodeTaskToClaudeMessages,
+} from '../plugins/agents/opencode/outputParser.js';
 import { updateSessionIteration, updateSessionStatus, updateSessionMaxIterations } from '../session/index.js';
 import { saveIterationLog, buildSubagentTrace, createProgressEntry, appendProgress, getRecentProgressSummary, getCodebasePatternsForPrompt } from '../logs/index.js';
 import type { AgentSwitchEntry } from '../logs/index.js';
@@ -807,15 +811,13 @@ export class ExecutionEngine {
       flags.push('--model', this.config.model);
     }
 
-    // Check if agent supports subagent tracing
+    // Check if agent declares subagent tracing support (used for agent-specific flags)
     const supportsTracing = this.agent!.meta.supportsSubagentTracing;
 
-    // Create streaming JSONL parser if tracing is enabled
-    const jsonlParser = supportsTracing
-      ? this.agent?.meta.id === 'droid'
-        ? createDroidStreamingJsonlParser()
-        : ClaudeAgentPlugin.createStreamingJsonlParser()
-      : null;
+    // For Droid agent, we need a JSONL parser since it uses a different output format.
+    // For Claude and OpenCode, we use the onJsonlMessage callback which gets pre-parsed messages.
+    const isDroidAgent = this.agent?.meta.id === 'droid';
+    const droidJsonlParser = isDroidAgent ? createDroidStreamingJsonlParser() : null;
 
     try {
       // Execute agent with subagent tracing if supported
@@ -824,6 +826,42 @@ export class ExecutionEngine {
         flags,
         sandbox: this.config.sandbox,
         subagentTracing: supportsTracing,
+        // Callback for pre-parsed JSONL messages (used by Claude and OpenCode plugins)
+        // This receives raw JSON objects directly from the agent's parsed JSONL output.
+        onJsonlMessage: (message: Record<string, unknown>) => {
+          // Check if this is OpenCode format (has 'part' with 'tool' property)
+          const part = message.part as Record<string, unknown> | undefined;
+          if (message.type === 'tool_use' && part?.tool) {
+            // OpenCode format - convert using OpenCode parser
+            const openCodeMessage = {
+              source: 'opencode' as const,
+              type: message.type as string,
+              timestamp: message.timestamp as number | undefined,
+              sessionID: message.sessionID as string | undefined,
+              part: part as import('../plugins/agents/opencode/outputParser.js').OpenCodePart,
+              raw: message,
+            };
+            // Check if it's a Task tool and convert to Claude format
+            if (isOpenCodeTaskTool(openCodeMessage)) {
+              for (const claudeMessage of openCodeTaskToClaudeMessages(openCodeMessage)) {
+                this.subagentParser.processMessage(claudeMessage);
+              }
+            }
+            return;
+          }
+
+          // Claude format - convert raw JSON to ClaudeJsonlMessage format for SubagentParser
+          const claudeMessage: ClaudeJsonlMessage = {
+            type: message.type as string | undefined,
+            message: message.message as string | undefined,
+            tool: message.tool as { name?: string; input?: Record<string, unknown> } | undefined,
+            result: message.result,
+            cost: message.cost as { inputTokens?: number; outputTokens?: number; totalUSD?: number } | undefined,
+            sessionId: message.sessionId as string | undefined,
+            raw: message,
+          };
+          this.subagentParser.processMessage(claudeMessage);
+        },
         onStdout: (data) => {
           this.state.currentOutput += data;
           this.emit({
@@ -834,9 +872,10 @@ export class ExecutionEngine {
             iteration,
           });
 
-          // Parse JSONL output for subagent events if tracing is enabled
-          if (jsonlParser) {
-            const results = jsonlParser.push(data);
+          // For Droid agent, parse JSONL output for subagent events
+          // (Claude uses onJsonlMessage callback instead)
+          if (droidJsonlParser && isDroidAgent) {
+            const results = droidJsonlParser.push(data);
             for (const result of results) {
               if (result.success) {
                 if (isDroidJsonlMessage(result.message)) {
@@ -849,6 +888,7 @@ export class ExecutionEngine {
               }
             }
           }
+
         },
         onStderr: (data) => {
           this.state.currentStderr += data;
@@ -868,9 +908,9 @@ export class ExecutionEngine {
       const agentResult = await handle.promise;
       this.currentExecution = null;
 
-      // Flush any remaining buffered JSONL data
-      if (jsonlParser) {
-        const remaining = jsonlParser.flush();
+      // Flush any remaining buffered JSONL data for Droid agent
+      if (droidJsonlParser && isDroidAgent) {
+        const remaining = droidJsonlParser.flush();
         for (const result of remaining) {
           if (result.success) {
             if (isDroidJsonlMessage(result.message)) {
@@ -1371,6 +1411,58 @@ export class ExecutionEngine {
     return depth;
   }
 
+  /**
+   * Get output/result for a specific subagent by ID.
+   * For completed subagents, returns their result content.
+   * For running subagents, returns undefined (use currentOutput for live streaming).
+   *
+   * @param id - Subagent ID to get output for
+   * @returns Subagent result content, or undefined if not found or still running
+   */
+  getSubagentOutput(id: string): string | undefined {
+    const state = this.subagentParser.getSubagent(id);
+    if (!state) return undefined;
+    // Return result only for completed/errored subagents
+    if (state.status === 'completed' || state.status === 'error') {
+      return state.result;
+    }
+    return undefined;
+  }
+
+  /**
+   * Get detailed information about a subagent for display.
+   * Returns the prompt, result, and timing information.
+   *
+   * @param id - Subagent ID to get details for
+   * @returns Subagent details or undefined if not found
+   */
+  getSubagentDetails(id: string): {
+    prompt?: string;
+    result?: string;
+    spawnedAt: string;
+    endedAt?: string;
+    childIds: string[];
+  } | undefined {
+    const state = this.subagentParser.getSubagent(id);
+    if (!state) return undefined;
+    return {
+      prompt: state.prompt,
+      result: state.result,
+      spawnedAt: state.spawnedAt,
+      endedAt: state.endedAt,
+      childIds: state.childIds,
+    };
+  }
+
+  /**
+   * Get the currently active subagent ID (deepest in the hierarchy).
+   * Returns undefined if no subagent is currently active.
+   */
+  getActiveSubagentId(): string | undefined {
+    const stack = this.subagentParser.getActiveStack();
+    return stack.length > 0 ? stack[0] : undefined;
+  }
+
   /**
    * Get the subagent tree for TUI rendering.
    * Returns an array of root-level subagent tree nodes with their children nested.

src/plugins/agents/builtin/claude.ts

@@ -444,9 +444,26 @@ export class ClaudeAgentPlugin extends BaseAgentPlugin {
             // This callback is set up but actual segments come from wrapping onStdout below
           }
         : options?.onStdoutSegments,
-      // Legacy string callback or wrapper that calls both callbacks
-      onStdout: isStreamingJson && (options?.onStdout || options?.onStdoutSegments)
+      // Legacy string callback or wrapper that calls both callbacks and JSONL message callback
+      onStdout: isStreamingJson && (options?.onStdout || options?.onStdoutSegments || options?.onJsonlMessage)
         ? (data: string) => {
+            // Parse each line for JSONL messages and display events
+            for (const line of data.split('\n')) {
+              const trimmed = line.trim();
+              if (!trimmed) continue;
+
+              // Try to parse as JSON and call the raw JSONL message callback
+              if (options?.onJsonlMessage) {
+                try {
+                  const rawJson = JSON.parse(trimmed) as Record<string, unknown>;
+                  options.onJsonlMessage(rawJson);
+                } catch {
+                  // Not valid JSON, skip for JSONL callback
+                }
+              }
+            }
+
+            // Also parse for display events
             const events = this.parseClaudeOutputToEvents(data);
             if (events.length > 0) {
               // Call TUI-native segments callback if provided

src/plugins/agents/builtin/opencode.ts

@@ -126,7 +126,7 @@ export class OpenCodeAgentPlugin extends BaseAgentPlugin {
     supportsStreaming: true,
     supportsInterrupt: true,
     supportsFileContext: true,
-    supportsSubagentTracing: false,
+    supportsSubagentTracing: true,
     skillsPaths: {
       personal: '~/.opencode/skill',
       repo: '.opencode/skill',
@@ -367,6 +367,7 @@ export class OpenCodeAgentPlugin extends BaseAgentPlugin {
   /**
    * Override execute to parse opencode JSON output.
    * Wraps the onStdout/onStdoutSegments callbacks to parse JSONL events and extract displayable content.
+   * Also forwards raw JSONL messages to onJsonlMessage for subagent tracing.
    */
   override execute(
     prompt: string,
@@ -376,8 +377,24 @@ export class OpenCodeAgentPlugin extends BaseAgentPlugin {
     // Wrap callbacks to parse JSON events
     const parsedOptions: AgentExecuteOptions = {
       ...options,
-      onStdout: (options?.onStdout || options?.onStdoutSegments)
+      onStdout: (options?.onStdout || options?.onStdoutSegments || options?.onJsonlMessage)
         ? (data: string) => {
+            // Parse raw JSONL lines and forward to onJsonlMessage for subagent tracing
+            if (options?.onJsonlMessage) {
+              for (const line of data.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && trimmed.startsWith('{')) {
+                  try {
+                    const parsed = JSON.parse(trimmed);
+                    options.onJsonlMessage(parsed);
+                  } catch {
+                    // Not valid JSON, skip
+                  }
+                }
+              }
+            }
+
+            // Process for display events
             const events = parseOpenCodeOutputToEvents(data);
             if (events.length > 0) {
               // Call TUI-native segments callback if provided

src/plugins/agents/droid/index.ts

@@ -30,7 +30,7 @@ export class DroidAgentPlugin extends BaseAgentPlugin {
     supportsStreaming: true,
     supportsInterrupt: true,
     supportsFileContext: false,
-    supportsSubagentTracing: true,
+    supportsSubagentTracing: false,
     structuredOutputFormat: 'jsonl',
     skillsPaths: {
       personal: '~/.factory/skills',
@@ -43,8 +43,8 @@ export class DroidAgentPlugin extends BaseAgentPlugin {
   // Default to true: droid exec cannot show interactive prompts without a TTY
   private skipPermissions = true;
   private enableTracing = true;
-  // Track effective subagent tracing support (can be disabled via config)
-  private effectiveSupportsSubagentTracing = true;
+  // Subagent tracing is not currently supported for Factory Droid
+  private effectiveSupportsSubagentTracing = false;
 
   /**
    * Returns meta with effectiveSupportsSubagentTracing applied.