feat: emit all logs as JSON events in --json mode (v0.5.4)

Complete JSON-only output mode - ALL logs (messages, events, diagnostics)
now emitted as JSON to stdout when using --json flag.

Key Features:
- Pure JSONL stream - every line is a valid JSON object
- Two event types: conversation events + log.entry events
- Diagnostic logs (zerolog INF/WRN/ERR/DBG) emitted as log.entry with role="diagnostic"
- Chat messages emitted as log.entry with role="agent"/"system"/"user"
- Includes all metadata: tokens, cost, duration, agent info
- Perfect for log aggregators, monitoring, CI/CD, automation

Technical Implementation:
- New event type: log.entry in internal/bridge/events.go
- New module: internal/bridge/zerolog_json_writer.go (custom zerolog writer)
- Updated: internal/bridge/stdout_emitter.go (EmitLogEntry method)
- Updated: pkg/logger/logger.go (JSON emitter integration)
- Updated: cmd/run.go (logger reinitialization for JSON mode)

All quality checks passing:
✅ go test -v -race ./... (all tests pass)
✅ go build -o agentpipe .
✅ Manual testing with --json flag

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kevinelliott

CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.4] - 2025-01-26
+
+### Added
+- **Complete JSON-only output mode**
+  - ALL output (logs, messages, events) now emitted as JSON to stdout when using `--json` flag
+  - Includes agent messages, system messages, diagnostic logs, and metadata
+  - Pure JSONL stream - every line is a valid JSON object
+  - Two event types:
+    - Conversation events: `bridge.connected`, `conversation.started`, `message.created`, `conversation.completed`
+    - Log events: `log.entry` for all messages and diagnostic logs
+  - Enables complete conversation replay and analysis from JSON stream alone
+  - Perfect for log aggregators, monitoring tools, CI/CD pipelines, and automation
+
+### Enhanced
+- **Diagnostic logs as JSON events**
+  - All zerolog diagnostic logs (INF, WRN, ERR, DBG) emitted as `log.entry` events with `role: "diagnostic"`
+  - Includes metadata from log fields (agent_id, duration, tokens, etc.)
+  - Clean separation: `role: "diagnostic"` for system logs vs `role: "agent"/"system"/"user"` for chat messages
+
+### Technical Details
+- **New Event Type**: `log.entry` in `internal/bridge/events.go`
+  - `LogEntryData` struct with level, agent info, content, role, metadata, and metrics
+  - `LogEntryMetrics` struct for duration, tokens, cost
+  - Supports both chat messages and diagnostic logs in unified format
+- **New Module**: `internal/bridge/zerolog_json_writer.go`
+  - Custom zerolog writer that parses zerolog JSON output
+  - Emits diagnostic logs as `log.entry` events to stdout
+  - Extracts level, message, and metadata from zerolog fields
+- **Updated**: `internal/bridge/stdout_emitter.go`
+  - Added `EmitLogEntry()` method for log event emission
+- **Updated**: `pkg/logger/logger.go`
+  - Added `jsonEmitter` field to `ChatLogger`
+  - Added `SetJSONEmitter()` method
+  - Modified `LogMessage()`, `LogError()`, and `LogSystem()` to emit JSON events when JSON emitter is set
+  - Falls back to console/file output when JSON emitter is not set
+- **Updated**: `cmd/run.go`
+  - Set JSON emitter on logger when `--json` flag is used
+  - Reinitialize zerolog with `ZerologJSONWriter` for diagnostic log conversion
+  - Ensures all output becomes JSON events
+
 ## [0.5.3] - 2025-01-26
 
 ### Added

cmd/run.go

@@ -11,6 +11,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
@@ -373,6 +374,19 @@ func startConversation(cmd *cobra.Command, cfg *config.Config) error {
 	if jsonOutput {
 		stdoutEmitter := bridge.NewStdoutEmitter(version.GetShortVersion())
 		orch.SetBridgeEmitter(stdoutEmitter)
+
+		// Set JSON emitter on logger to emit log.entry events
+		if chatLogger != nil {
+			chatLogger.SetJSONEmitter(stdoutEmitter)
+		}
+
+		// Reinitialize zerolog to use JSON writer for diagnostic logs
+		jsonWriter := bridge.NewZerologJSONWriter(stdoutEmitter)
+		level := zerolog.InfoLevel
+		if verbose {
+			level = zerolog.DebugLevel
+		}
+		log.InitLogger(jsonWriter, level, false) // false = don't use pretty console output
 	} else {
 		// Set up streaming bridge if enabled (only when not in JSON mode)
 		shouldStream := determineShouldStream(streamEnabled, noStream)

internal/bridge/events.go

@@ -21,6 +21,8 @@ const (
 	EventConversationError EventType = "conversation.error"
 	// EventBridgeTest is emitted when testing the bridge connection
 	EventBridgeTest EventType = "bridge.test"
+	// EventLogEntry is emitted for log messages (messages, errors, system messages)
+	EventLogEntry EventType = "log.entry"
 )
 
 // UTCTime wraps time.Time to ensure JSON marshaling always uses UTC with Z suffix
@@ -145,3 +147,23 @@ type BridgeConnectedData struct {
 	SystemInfo  SystemInfo `json:"system_info"`
 	ConnectedAt string     `json:"connected_at"`
 }
+
+// LogEntryData contains data for log.entry events
+type LogEntryData struct {
+	ConversationID string                 `json:"conversation_id"`
+	Level          string                 `json:"level"`           // "message", "error", "system"
+	AgentID        string                 `json:"agent_id,omitempty"`
+	AgentName      string                 `json:"agent_name,omitempty"`
+	AgentType      string                 `json:"agent_type,omitempty"`
+	Content        string                 `json:"content"`
+	Role           string                 `json:"role,omitempty"`  // "assistant", "system", "user"
+	Metrics        *LogEntryMetrics       `json:"metrics,omitempty"`
+	Metadata       map[string]interface{} `json:"metadata,omitempty"` // Additional context
+}
+
+// LogEntryMetrics contains metrics for log entries (if applicable)
+type LogEntryMetrics struct {
+	DurationSeconds float64 `json:"duration_seconds,omitempty"`
+	TotalTokens     int     `json:"total_tokens,omitempty"`
+	Cost            float64 `json:"cost,omitempty"`
+}

internal/bridge/stdout_emitter.go

@@ -193,3 +193,35 @@ func (e *StdoutEmitter) EmitConversationError(errorMessage string, errorType str
 
 	_ = e.emitEvent(event)
 }
+
+// EmitLogEntry emits a log.entry event for log messages
+func (e *StdoutEmitter) EmitLogEntry(
+	level string,
+	agentID string,
+	agentName string,
+	agentType string,
+	content string,
+	role string,
+	metrics *LogEntryMetrics,
+	metadata map[string]interface{},
+) {
+	data := LogEntryData{
+		ConversationID: e.conversationID,
+		Level:          level,
+		AgentID:        agentID,
+		AgentName:      agentName,
+		AgentType:      agentType,
+		Content:        content,
+		Role:           role,
+		Metrics:        metrics,
+		Metadata:       metadata,
+	}
+
+	event := Event{
+		Type:      EventLogEntry,
+		Timestamp: UTCTime{Time: time.Now()},
+		Data:      data,
+	}
+
+	_ = e.emitEvent(event)
+}

internal/bridge/zerolog_json_writer.go

@@ -0,0 +1,65 @@
+package bridge
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"sync"
+)
+
+// ZerologJSONWriter is a zerolog writer that emits log entries as log.entry JSON events
+type ZerologJSONWriter struct {
+	emitter        *StdoutEmitter
+	mu             sync.Mutex
+}
+
+// NewZerologJSONWriter creates a new zerolog writer that emits JSON events
+func NewZerologJSONWriter(emitter *StdoutEmitter) *ZerologJSONWriter {
+	return &ZerologJSONWriter{
+		emitter: emitter,
+	}
+}
+
+// Write implements io.Writer for zerolog
+func (w *ZerologJSONWriter) Write(p []byte) (n int, err error) {
+	// Parse the zerolog JSON output
+	var logEntry map[string]interface{}
+	if err := json.Unmarshal(p, &logEntry); err != nil {
+		// If we can't parse it, just write raw to stderr as fallback
+		fmt.Fprint(os.Stderr, string(p))
+		return len(p), nil
+	}
+
+	// Extract standard zerolog fields
+	level, _ := logEntry["level"].(string)
+	message, _ := logEntry["message"].(string)
+
+	// Build metadata from remaining fields
+	metadata := make(map[string]interface{})
+	for k, v := range logEntry {
+		// Skip standard fields that we handle separately
+		if k != "level" && k != "message" && k != "time" && k != "timestamp" {
+			metadata[k] = v
+		}
+	}
+
+	// Emit as log.entry event
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	w.emitter.EmitLogEntry(
+		level,           // level (debug, info, warn, error, etc.)
+		"",              // agent_id (not applicable for system logs)
+		"",              // agent_name (not applicable for system logs)
+		"",              // agent_type (not applicable for system logs)
+		message,         // content
+		"diagnostic",    // role (use "diagnostic" to distinguish from agent messages)
+		nil,             // metrics
+		metadata,        // metadata (all other fields from zerolog)
+	)
+
+	return len(p), nil
+}
+
+var _ io.Writer = (*ZerologJSONWriter)(nil)

pkg/logger/logger.go

@@ -11,17 +11,19 @@ import (
 
 	"github.com/charmbracelet/lipgloss"
 
+	"github.com/kevinelliott/agentpipe/internal/bridge"
 	"github.com/kevinelliott/agentpipe/pkg/agent"
 )
 
 type ChatLogger struct {
-	logFile     *os.File
-	logFormat   string
-	console     io.Writer
-	agentColors map[string]lipgloss.Style
-	colorIndex  int
-	termWidth   int
-	showMetrics bool
+	logFile      *os.File
+	logFormat    string
+	console      io.Writer
+	agentColors  map[string]lipgloss.Style
+	colorIndex   int
+	termWidth    int
+	showMetrics  bool
+	jsonEmitter  *bridge.StdoutEmitter // For JSON mode output
 }
 
 var colors = []lipgloss.Color{
@@ -123,6 +125,11 @@ func NewChatLogger(logDir string, logFormat string, console io.Writer, showMetri
 	return logger, nil
 }
 
+// SetJSONEmitter sets the JSON emitter for JSON-only output mode
+func (l *ChatLogger) SetJSONEmitter(emitter *bridge.StdoutEmitter) {
+	l.jsonEmitter = emitter
+}
+
 func (l *ChatLogger) getAgentColor(agentName string) lipgloss.Style {
 	if style, exists := l.agentColors[agentName]; exists {
 		return style
@@ -162,6 +169,30 @@ func (l *ChatLogger) getAgentBadgeStyle(agentName string) lipgloss.Style {
 func (l *ChatLogger) LogMessage(msg agent.Message) {
 	timestamp := time.Unix(msg.Timestamp, 0).Format("15:04:05")
 
+	// If JSON emitter is set, emit as JSON event
+	if l.jsonEmitter != nil {
+		var metrics *bridge.LogEntryMetrics
+		if msg.Metrics != nil {
+			metrics = &bridge.LogEntryMetrics{
+				DurationSeconds: msg.Metrics.Duration.Seconds(),
+				TotalTokens:     msg.Metrics.TotalTokens,
+				Cost:            msg.Metrics.Cost,
+			}
+		}
+
+		l.jsonEmitter.EmitLogEntry(
+			"message",
+			msg.AgentID,
+			msg.AgentName,
+			msg.AgentType,
+			msg.Content,
+			msg.Role,
+			metrics,
+			nil, // metadata
+		)
+		return
+	}
+
 	// Write to file
 	if l.logFile != nil {
 		if l.logFormat == "json" {
@@ -262,6 +293,21 @@ func (l *ChatLogger) LogMessage(msg agent.Message) {
 func (l *ChatLogger) LogError(agentName string, err error) {
 	timestamp := time.Now().Format("15:04:05")
 
+	// If JSON emitter is set, emit as JSON event
+	if l.jsonEmitter != nil {
+		l.jsonEmitter.EmitLogEntry(
+			"error",
+			"",
+			agentName,
+			"",
+			err.Error(),
+			"",
+			nil,
+			nil,
+		)
+		return
+	}
+
 	// Write to file
 	if l.logFile != nil {
 		l.writeToFile(fmt.Sprintf("[%s] ERROR - %s: %v\n", timestamp, agentName, err))