orchestra/internal/herdr/activity_test.go

package herdr

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func writeJSONL(t *testing.T, lines []string) string {
	t.Helper()
	dir := t.TempDir()
	path := filepath.Join(dir, "transcript.jsonl")
	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
		t.Fatal(err)
	}
	return path
}

func claudeToolLine(t *testing.T, toolUseID, name string, input map[string]any) string {
	t.Helper()
	b, err := json.Marshal(map[string]any{
		"message": map[string]any{
			"content": []map[string]any{
				{"type": "tool_use", "id": toolUseID, "name": name, "input": input},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}

func claudeResultLine(t *testing.T, toolUseID string, isError bool) string {
	t.Helper()
	b, err := json.Marshal(map[string]any{
		"message": map[string]any{
			"content": []map[string]any{
				{"type": "tool_result", "tool_use_id": toolUseID, "is_error": isError},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}

func TestClaudeActivityPairsToolUseWithResult(t *testing.T) {
	path := writeJSONL(t, []string{
		claudeToolLine(t, "t1", "Bash", map[string]any{"command": "go test ./..."}),
		claudeResultLine(t, "t1", true),
		claudeToolLine(t, "t2", "Edit", map[string]any{"file_path": "main.go"}),
		claudeResultLine(t, "t2", false),
		// an unresolved tool_use (still mid-turn) must be dropped, not reported
		claudeToolLine(t, "t3", "Bash", map[string]any{"command": "echo hi"}),
	})
	calls, err := ClaudeActivity(path)
	if err != nil {
		t.Fatal(err)
	}
	if len(calls) != 2 {
		t.Fatalf("calls=%+v, want 2 (unresolved tool_use dropped)", calls)
	}
	if calls[0].Name != "Bash" || calls[0].Kind != "command" || calls[0].Key != "go test ./..." || calls[0].Success || !calls[0].IsTest {
		t.Fatalf("calls[0]=%+v", calls[0])
	}
	if calls[1].Name != "Edit" || calls[1].Kind != "file" || calls[1].Key != "main.go" || !calls[1].Success {
		t.Fatalf("calls[1]=%+v", calls[1])
	}
}

func TestDetectThrashConsecutiveTestFailures(t *testing.T) {
	calls := []ToolCall{
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
	}
	thrash, deadEnds := DetectThrash(calls, ThrashConfig{})
	if !thrash {
		t.Fatalf("want thrash on 3 consecutive test failures (default threshold)")
	}
	if len(deadEnds) != 1 || deadEnds[0].Tried != "go test ./..." {
		t.Fatalf("deadEnds=%+v", deadEnds)
	}
}

func TestDetectThrashStopsCountingAtASuccess(t *testing.T) {
	calls := []ToolCall{
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: true, IsTest: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: false, IsTest: true},
	}
	// Only one failure since the last success — must not thrash on the
	// default threshold of 3, even though 3 failures exist in the window.
	if thrash, _ := DetectThrash(calls, ThrashConfig{}); thrash {
		t.Fatalf("want no thrash: only 1 failure since the last passing run")
	}
}

func TestDetectThrashSameFileEditedTooManyTimes(t *testing.T) {
	var calls []ToolCall
	for i := 0; i < 5; i++ {
		calls = append(calls, ToolCall{Name: "Edit", Kind: "file", Key: "main.go", Success: true})
	}
	thrash, deadEnds := DetectThrash(calls, ThrashConfig{})
	if !thrash {
		t.Fatalf("want thrash on 5 edits to the same file (default threshold)")
	}
	found := false
	for _, d := range deadEnds {
		if strings.Contains(d.Tried, "main.go") {
			found = true
		}
	}
	if !found {
		t.Fatalf("deadEnds=%+v, want an entry naming main.go", deadEnds)
	}
}

func TestDetectThrashIgnoresReadsForFileEditCount(t *testing.T) {
	var calls []ToolCall
	for i := 0; i < 10; i++ {
		calls = append(calls, ToolCall{Name: "Read", Kind: "file", Key: "main.go", Success: true})
	}
	// Read is not an edit tool; repeated reads of the same file must never
	// trip the "edited too many times" rule.
	if thrash, _ := DetectThrash(calls, ThrashConfig{}); thrash {
		t.Fatalf("want no thrash: Read is not an edit tool")
	}
}

func TestDetectThrashIdenticalCallsRepeated(t *testing.T) {
	var calls []ToolCall
	for i := 0; i < 4; i++ {
		calls = append(calls, ToolCall{Name: "Bash", Kind: "command", Key: "npm install lodash", Success: false})
	}
	thrash, _ := DetectThrash(calls, ThrashConfig{})
	if !thrash {
		t.Fatalf("want thrash on the identical call repeated 4 times (default threshold)")
	}
}

func TestDetectThrashCustomThresholds(t *testing.T) {
	calls := []ToolCall{
		{Name: "Edit", Kind: "file", Key: "main.go", Success: true},
		{Name: "Edit", Kind: "file", Key: "main.go", Success: true},
	}
	if thrash, _ := DetectThrash(calls, ThrashConfig{}); thrash {
		t.Fatalf("2 edits must not thrash at the default threshold of 5")
	}
	if thrash, _ := DetectThrash(calls, ThrashConfig{MaxSameFileEdits: 2}); !thrash {
		t.Fatalf("2 edits must thrash once the threshold is lowered to 2")
	}
}

func TestDetectMilestoneOnSuccessfulCommit(t *testing.T) {
	calls := []ToolCall{
		{Name: "Bash", Kind: "command", Key: "go build ./...", Success: true},
		{Name: "Bash", Kind: "command", Key: "git commit -m fix", Success: true},
	}
	if !DetectMilestone(calls) {
		t.Fatalf("want milestone: last call is a successful git commit")
	}
}

func TestDetectMilestoneRequiresSuccess(t *testing.T) {
	calls := []ToolCall{
		{Name: "Bash", Kind: "command", Key: "git commit -m fix", Success: false},
	}
	if DetectMilestone(calls) {
		t.Fatalf("want no milestone: the commit failed")
	}
}

func TestDetectMilestoneRequiresLastCall(t *testing.T) {
	calls := []ToolCall{
		{Name: "Bash", Kind: "command", Key: "git commit -m fix", Success: true},
		{Name: "Bash", Kind: "command", Key: "go test ./...", Success: true},
	}
	if DetectMilestone(calls) {
		t.Fatalf("want no milestone: the commit isn't the most recent call")
	}
}

func TestOpenCodeActivityRefusesRatherThanGuess(t *testing.T) {
	if _, err := OpenCodeActivity("/nonexistent"); err == nil {
		t.Fatalf("want an error: opencode tool-call activity has no verified source")
	}
}