fixes for CI

Author: kevinelliott

.golangci.yml

@@ -11,7 +11,6 @@ linters:
     - staticcheck
     - ineffassign
     - typecheck
-    - unused
     - gosimple
     - gosec
     - misspell
@@ -23,9 +22,6 @@ linters:
     - gocyclo
     - gocognit
 
-  disable:
-    - unused # False positives on some fields
-
 linters-settings:
   gofmt:
     simplify: true

pkg/agent/agent_test.go

@@ -0,0 +1,49 @@
+package agent
+
+import (
+	"testing"
+)
+
+func TestMessageType(t *testing.T) {
+	msg := Message{
+		AgentID:   "test-agent",
+		AgentName: "Test Agent",
+		Content:   "Test message",
+		Timestamp: 1234567890,
+		Role:      "agent",
+	}
+
+	if msg.AgentID != "test-agent" {
+		t.Errorf("Expected AgentID to be 'test-agent', got %s", msg.AgentID)
+	}
+
+	if msg.AgentName != "Test Agent" {
+		t.Errorf("Expected AgentName to be 'Test Agent', got %s", msg.AgentName)
+	}
+
+	if msg.Content != "Test message" {
+		t.Errorf("Expected Content to be 'Test message', got %s", msg.Content)
+	}
+
+	if msg.Role != "agent" {
+		t.Errorf("Expected Role to be 'agent', got %s", msg.Role)
+	}
+}
+
+func TestResponseMetrics(t *testing.T) {
+	metrics := &ResponseMetrics{
+		InputTokens:  100,
+		OutputTokens: 50,
+		TotalTokens:  150,
+		Model:        "test-model",
+		Cost:         0.001,
+	}
+
+	if metrics.TotalTokens != 150 {
+		t.Errorf("Expected TotalTokens to be 150, got %d", metrics.TotalTokens)
+	}
+
+	if metrics.Cost != 0.001 {
+		t.Errorf("Expected Cost to be 0.001, got %f", metrics.Cost)
+	}
+}

pkg/config/config_test.go

@@ -0,0 +1,105 @@
+package config
+
+import (
+	"strings"
+	"testing"
+	"time"
+	
+	"github.com/kevinelliott/agentpipe/pkg/agent"
+)
+
+func TestNewDefaultConfig(t *testing.T) {
+	cfg := NewDefaultConfig()
+
+	if cfg.Version != "1.0" {
+		t.Errorf("Expected Version to be '1.0', got %s", cfg.Version)
+	}
+
+	if cfg.Orchestrator.Mode != "round-robin" {
+		t.Errorf("Expected default mode to be 'round-robin', got %s", cfg.Orchestrator.Mode)
+	}
+
+	if cfg.Orchestrator.MaxTurns != 10 {
+		t.Errorf("Expected default MaxTurns to be 10, got %d", cfg.Orchestrator.MaxTurns)
+	}
+
+	if cfg.Orchestrator.TurnTimeout != 30*time.Second {
+		t.Errorf("Expected default TurnTimeout to be 30s, got %v", cfg.Orchestrator.TurnTimeout)
+	}
+
+	if !cfg.Logging.Enabled {
+		t.Error("Expected logging to be enabled by default")
+	}
+
+	if !strings.Contains(cfg.Logging.ChatLogDir, ".agentpipe/chats") {
+		t.Errorf("Expected ChatLogDir to contain '.agentpipe/chats', got %s", cfg.Logging.ChatLogDir)
+	}
+}
+
+func TestConfigValidate(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  *Config
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name: "empty agents",
+			config: &Config{
+				Agents: []agent.AgentConfig{},
+			},
+			wantErr: true,
+			errMsg:  "at least one agent must be configured",
+		},
+		{
+			name: "duplicate agent IDs",
+			config: &Config{
+				Agents: []agent.AgentConfig{
+					{ID: "agent1", Type: "claude", Name: "Agent 1"},
+					{ID: "agent1", Type: "gemini", Name: "Agent 2"},
+				},
+			},
+			wantErr: true,
+			errMsg:  "duplicate agent ID",
+		},
+		{
+			name: "invalid mode",
+			config: &Config{
+				Agents: []agent.AgentConfig{
+					{ID: "agent1", Type: "claude", Name: "Agent 1"},
+				},
+				Orchestrator: OrchestratorConfig{
+					Mode: "invalid-mode",
+				},
+			},
+			wantErr: true,
+			errMsg:  "invalid orchestrator mode",
+		},
+		{
+			name: "valid config",
+			config: &Config{
+				Agents: []agent.AgentConfig{
+					{ID: "agent1", Type: "claude", Name: "Agent 1"},
+					{ID: "agent2", Type: "gemini", Name: "Agent 2"},
+				},
+				Orchestrator: OrchestratorConfig{
+					Mode:     "round-robin",
+					MaxTurns: 10,
+				},
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.Validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && tt.errMsg != "" && !strings.Contains(err.Error(), tt.errMsg) {
+				t.Errorf("Validate() error message = %v, want to contain %v", err.Error(), tt.errMsg)
+			}
+		})
+	}
+}

pkg/utils/tokens_test.go

@@ -0,0 +1,115 @@
+package utils
+
+import (
+	"testing"
+)
+
+func TestEstimateTokens(t *testing.T) {
+	tests := []struct {
+		name     string
+		text     string
+		expected int
+		delta    int // allowed difference
+	}{
+		{
+			name:     "empty string",
+			text:     "",
+			expected: 0,
+			delta:    0,
+		},
+		{
+			name:     "single word",
+			text:     "hello",
+			expected: 1,
+			delta:    1,
+		},
+		{
+			name:     "short sentence",
+			text:     "The quick brown fox jumps over the lazy dog",
+			expected: 9,
+			delta:    3,
+		},
+		{
+			name:     "with punctuation",
+			text:     "Hello, world! How are you today?",
+			expected: 8,
+			delta:    2,
+		},
+		{
+			name:     "with numbers",
+			text:     "The year 2024 has 365 days",
+			expected: 8,
+			delta:    2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := EstimateTokens(tt.text)
+			diff := got - tt.expected
+			if diff < 0 {
+				diff = -diff
+			}
+			if diff > tt.delta {
+				t.Errorf("EstimateTokens() = %v, want %v ± %v", got, tt.expected, tt.delta)
+			}
+		})
+	}
+}
+
+func TestEstimateCost(t *testing.T) {
+	tests := []struct {
+		name         string
+		model        string
+		inputTokens  int
+		outputTokens int
+		wantCost     float64
+		delta        float64
+	}{
+		{
+			name:         "claude-3-opus",
+			model:        "claude-3-opus",
+			inputTokens:  1000,
+			outputTokens: 500,
+			wantCost:     0.0525, // Current implementation returns this
+			delta:        0.0001,
+		},
+		{
+			name:         "gpt-4",
+			model:        "gpt-4",
+			inputTokens:  1000,
+			outputTokens: 500,
+			wantCost:     0.06, // Current implementation returns this
+			delta:        0.0001,
+		},
+		{
+			name:         "unknown model",
+			model:        "unknown",
+			inputTokens:  1000,
+			outputTokens: 500,
+			wantCost:     0, // unknown model returns 0
+			delta:        0.0000001,
+		},
+		{
+			name:         "zero tokens",
+			model:        "claude-3-opus",
+			inputTokens:  0,
+			outputTokens: 0,
+			wantCost:     0,
+			delta:        0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := EstimateCost(tt.model, tt.inputTokens, tt.outputTokens)
+			diff := got - tt.wantCost
+			if diff < 0 {
+				diff = -diff
+			}
+			if diff > tt.delta {
+				t.Errorf("EstimateCost() = %v, want %v ± %v", got, tt.wantCost, tt.delta)
+			}
+		})
+	}
+}