Add Kiro CLI and Kiro IDE agent support

cmd/entire/cli/agent/agent.go

@@ -189,6 +189,30 @@ type HookResponseWriter interface {
 	WriteHookResponse(message string) error
 }
 
+// TerminalAgent is implemented by agents that run inside a terminal emulator
+// (e.g., Kiro in tmux). These agents have hasTTY()=true even when the agent
+// itself is committing, so git hooks cannot distinguish user-initiated commits
+// from agent-initiated commits using TTY detection alone.
+type TerminalAgent interface {
+	Agent
+
+	// UsesTerminal reports whether this agent runs in a terminal emulator.
+	UsesTerminal() bool
+}
+
+// IsTerminalAgent checks whether the given agent type corresponds to an agent
+// that runs inside a terminal emulator. It looks up the agent in the registry
+// and checks for the TerminalAgent interface.
+func IsTerminalAgent(agentType types.AgentType) bool {
+	ag, err := GetByAgentType(agentType)
+	if err != nil {
+		return false
+	}
+	ta, ok := ag.(TerminalAgent)
+
+	return ok && ta.UsesTerminal()
+}
+
 // TestOnly is implemented by agents that exist solely for testing (e.g., the Vogon canary agent).
 // These agents are excluded from the user-facing agent selection in `entire enable`.
 type TestOnly interface {

cmd/entire/cli/agent/event.go

@@ -1,6 +1,7 @@
 package agent
 
 import (
+	"bufio"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -128,16 +129,58 @@ type Event struct {
 	Metadata map[string]string
 }
 
+// ErrEmptyHookInput is returned by ReadAndParseHookInput when stdin is empty.
+// Agents that support empty stdin (e.g., Kiro IDE mode) can check for this
+// with errors.Is and handle it gracefully.
+var ErrEmptyHookInput = errors.New("empty hook input")
+
+// stdinReadTimeout is how long ReadAndParseHookInput waits for stdin data
+// before treating the input as empty. IDEs like Kiro keep stdin pipes open
+// without sending EOF, so io.ReadAll blocks forever. Piped data is available
+// immediately, so 500ms is generous.
+const stdinReadTimeout = 500 * time.Millisecond
+
 // ReadAndParseHookInput reads all bytes from stdin and unmarshals JSON into the given type.
 // This is a shared helper for agent ParseHookEvent implementations.
+//
+// Uses a two-phase approach to handle agents that keep stdin open without EOF (e.g., Kiro):
+//   - Phase 1: Peek(1) with a timeout to detect whether any data is available.
+//   - Phase 2: Once data is confirmed, io.ReadAll without timeout to read the full payload.
+//
+// Note: on timeout, the Peek goroutine is abandoned (it blocks forever on
+// the open stdin pipe). This is an intentional trade-off — hook processes are
+// short-lived, so the leaked goroutine is cleaned up when the process exits.
 func ReadAndParseHookInput[T any](stdin io.Reader) (*T, error) {
-	data, err := io.ReadAll(stdin)
+	br := bufio.NewReader(stdin)
+
+	// Phase 1: detect whether any data is available (with timeout for open-pipe cases).
+	peekCh := make(chan error, 1)
+	go func() {
+		_, err := br.Peek(1)
+		peekCh <- err
+	}()
+
+	select {
+	case err := <-peekCh:
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return nil, ErrEmptyHookInput
+			}
+			return nil, fmt.Errorf("failed to read hook input: %w", err)
+		}
+	case <-time.After(stdinReadTimeout):
+		return nil, ErrEmptyHookInput
+	}
+
+	// Phase 2: data available — read the full payload (no timeout, wait for EOF).
+	data, err := io.ReadAll(br)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read hook input: %w", err)
 	}
 	if len(data) == 0 {
-		return nil, errors.New("empty hook input")
+		return nil, ErrEmptyHookInput
 	}
+
 	var result T
 	if err := json.Unmarshal(data, &result); err != nil {
 		return nil, fmt.Errorf("failed to parse hook input: %w", err)