command_test.go

package cli

import (
	"os"
	"slices"
	"strings"
	"testing"

	"github.com/ethpandaops/claude-agent-sdk-go/internal/config"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// TestBuildArgs_WithSystemPromptFile tests that --system-prompt-file flag is
// present and --system-prompt is absent when SystemPromptFile is set.
func TestBuildArgs_WithSystemPromptFile(t *testing.T) {
	t.Parallel()

	options := &config.Options{
		SystemPromptFile: "/path/to/prompt.md",
	}

	args := BuildArgs("test", options, false)

	idx := slices.Index(args, "--system-prompt-file")
	require.NotEqual(t, -1, idx, "Expected --system-prompt-file flag to be present")
	require.Less(t, idx+1, len(args), "Expected value after --system-prompt-file flag")
	require.Equal(t, "/path/to/prompt.md", args[idx+1])

	// --system-prompt should NOT be present when --system-prompt-file is used
	require.NotContains(t, args, "--system-prompt")
}

// TestBuildArgs_SystemPromptFilePrecedence tests that Preset > File > String.
func TestBuildArgs_SystemPromptFilePrecedence(t *testing.T) {
	t.Parallel()

	t.Run("preset takes precedence over file", func(t *testing.T) {
		t.Parallel()

		appendText := "extra context"
		options := &config.Options{
			SystemPromptPreset: &config.SystemPromptPreset{
				Type:   "preset",
				Preset: "claude_code",
				Append: &appendText,
			},
			SystemPromptFile: "/path/to/prompt.md",
			SystemPrompt:     "plain string prompt",
		}

		args := BuildArgs("test", options, false)

		// Preset should win: --append-system-prompt present
		require.Contains(t, args, "--append-system-prompt")
		// File and string should not appear
		require.NotContains(t, args, "--system-prompt-file")
		require.NotContains(t, args, "--system-prompt")
	})

	t.Run("file takes precedence over string", func(t *testing.T) {
		t.Parallel()

		options := &config.Options{
			SystemPromptFile: "/path/to/prompt.md",
			SystemPrompt:     "plain string prompt",
		}

		args := BuildArgs("test", options, false)

		idx := slices.Index(args, "--system-prompt-file")
		require.NotEqual(t, -1, idx, "Expected --system-prompt-file flag")
		require.Equal(t, "/path/to/prompt.md", args[idx+1])
		require.NotContains(t, args, "--system-prompt")
	})

	t.Run("string used when no preset or file", func(t *testing.T) {
		t.Parallel()

		options := &config.Options{
			SystemPrompt: "plain string prompt",
		}

		args := BuildArgs("test", options, false)

		idx := slices.Index(args, "--system-prompt")
		require.NotEqual(t, -1, idx, "Expected --system-prompt flag")
		require.Equal(t, "plain string prompt", args[idx+1])
		require.NotContains(t, args, "--system-prompt-file")
	})
}

// TestBuildArgs_WithTaskBudget tests that --task-budget flag is present.
func TestBuildArgs_WithTaskBudget(t *testing.T) {
	t.Parallel()

	budget := 50000
	options := &config.Options{
		TaskBudget: &budget,
	}

	args := BuildArgs("test", options, false)

	idx := slices.Index(args, "--task-budget")
	require.NotEqual(t, -1, idx, "Expected --task-budget flag to be present")
	require.Less(t, idx+1, len(args), "Expected value after --task-budget flag")
	require.Equal(t, "50000", args[idx+1])
}

// TestBuildEnvironment_FiltersCLAUDECODE tests that the CLAUDECODE env var is filtered.
func TestBuildEnvironment_FiltersCLAUDECODE(t *testing.T) {
	t.Setenv("CLAUDECODE", "test-value")

	options := &config.Options{}
	env := BuildEnvironment(options)

	for _, e := range env {
		key, _, ok := strings.Cut(e, "=")
		if ok && key == "CLAUDECODE" {
			t.Fatal("Expected CLAUDECODE to be filtered from environment")
		}
	}
}

// TestBuildEnvironment_UserEnvOverridesEntrypoint tests that user-provided env
// vars override SDK defaults via last-wins semantics.
func TestBuildEnvironment_UserEnvOverridesEntrypoint(t *testing.T) {
	options := &config.Options{
		Env: map[string]string{
			"CLAUDE_CODE_ENTRYPOINT": "custom-entrypoint",
		},
	}

	env := BuildEnvironment(options)

	// Find all CLAUDE_CODE_ENTRYPOINT entries; last one should be the user's
	var lastValue string

	for _, e := range env {
		if key, val, ok := strings.Cut(e, "="); ok && key == "CLAUDE_CODE_ENTRYPOINT" {
			lastValue = val
		}
	}

	require.Equal(t, "custom-entrypoint", lastValue,
		"User-provided CLAUDE_CODE_ENTRYPOINT should be last (wins in exec.Cmd.Env)")
}

func TestBuildEnvironment_WithUnattendedRetry(t *testing.T) {
	enabled := true
	env := BuildEnvironment(&config.Options{UnattendedRetry: &enabled})

	require.Contains(t, env, "CLAUDE_CODE_UNATTENDED_RETRY=1")
}

func TestBuildEnvironment_WithRuntimeOverrides(t *testing.T) {
	maxToolConcurrency := 7
	autoCompactPct := 82
	blockingLimit := 4096
	disableCompact := true
	disableAutoCompact := true

	env := BuildEnvironment(&config.Options{
		MaxToolUseConcurrency:         &maxToolConcurrency,
		AutoCompactPercentageOverride: &autoCompactPct,
		BlockingLimitOverride:         &blockingLimit,
		DisableCompact:                &disableCompact,
		DisableAutoCompact:            &disableAutoCompact,
	})

	require.Contains(t, env, "CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY=7")
	require.Contains(t, env, "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=82")
	require.Contains(t, env, "CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE=4096")
	require.Contains(t, env, "DISABLE_COMPACT=1")
	require.Contains(t, env, "DISABLE_AUTO_COMPACT=1")
}

func TestBuildArgs_OneShotDoesNotIncludePrompt(t *testing.T) {
	t.Parallel()

	prompt := "This is a large prompt that should not appear in CLI args"
	args := BuildArgs(prompt, &config.Options{}, false)

	// Should contain --print but not the prompt text or "--"
	assert.True(t, slices.Contains(args, "--print"),
		"one-shot mode should include --print flag")

	for _, arg := range args {
		assert.False(t, strings.Contains(arg, prompt),
			"prompt should not appear in CLI args (avoids ARG_MAX)")
	}

	assert.False(t, slices.Contains(args, "--"),
		"one-shot mode should not include -- separator")
}

func TestBuildArgs_StreamingModeUnchanged(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test prompt", &config.Options{}, true)

	assert.True(t, slices.Contains(args, "--input-format"),
		"streaming mode should include --input-format flag")
	assert.False(t, slices.Contains(args, "--print"),
		"streaming mode should not include --print flag")
}

func TestBuildArgs_LargePromptNotInArgs(t *testing.T) {
	t.Parallel()

	// Simulate a large prompt (>128KB)
	largePrompt := strings.Repeat("x", 200*1024)
	args := BuildArgs(largePrompt, &config.Options{}, false)

	// Calculate total args size
	totalSize := 0
	for _, arg := range args {
		totalSize += len(arg)
	}

	require.Less(t, totalSize, 100*1024,
		"total args size should be small (prompt sent via stdin, not args)")
}

func TestBuildArgs_StreamingAllowsDangerouslySkipPermissions(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{
		PermissionMode: "default",
	}, true)

	require.Contains(t, args, "--allow-dangerously-skip-permissions")
}

func TestBuildArgs_OneShotDoesNotAddDangerouslySkipPermissionsAllowFlag(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{
		PermissionMode: "default",
	}, false)

	require.NotContains(t, args, "--allow-dangerously-skip-permissions")
}

const settingsFlag = "--settings"

func TestBuildArgs_WithFastModeMergedIntoSettingsJSON(t *testing.T) {
	enabled := true
	options := &config.Options{
		Settings: `{"test":"value"}`,
		FastMode: &enabled,
	}

	args := BuildArgs("test", options, false)
	require.Contains(t, args, settingsFlag)

	for i, arg := range args {
		if arg == settingsFlag && i+1 < len(args) {
			require.Contains(t, args[i+1], `"fastMode":true`)
			require.Contains(t, args[i+1], `"test":"value"`)

			return
		}
	}

	t.Fatal("expected merged --settings payload")
}

func TestBuildArgs_WithFastModeMergedIntoSettingsFile(t *testing.T) {
	tmpDir := t.TempDir()
	settingsPath := tmpDir + "/settings.json"
	require.NoError(t, os.WriteFile(settingsPath, []byte(`{"theme":"dark"}`), 0o600))

	enabled := true
	options := &config.Options{
		Settings: settingsPath,
		FastMode: &enabled,
	}

	args := BuildArgs("test", options, false)
	require.Contains(t, args, settingsFlag)

	for i, arg := range args {
		if arg == settingsFlag && i+1 < len(args) {
			require.Contains(t, args[i+1], `"fastMode":true`)
			require.Contains(t, args[i+1], `"theme":"dark"`)

			return
		}
	}

	t.Fatal("expected merged --settings payload")
}

func TestBuildArgs_WithSessionID(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{SessionID: "sess-abc-123"}, false)

	idx := slices.Index(args, "--session-id")
	require.NotEqual(t, -1, idx, "Expected --session-id flag")
	require.Equal(t, "sess-abc-123", args[idx+1])
}

func TestBuildArgs_SessionIDOmittedWhenEmpty(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{}, false)
	require.NotContains(t, args, "--session-id")
}

func TestBuildArgs_SettingSourcesOmittedWhenEmpty(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{}, false)
	require.NotContains(t, args, "--setting-sources")
}

func TestBuildArgs_SettingSourcesIncludedWhenSet(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{
		SettingSources: []config.SettingSource{config.SettingSourceUser, config.SettingSourceProject},
	}, false)

	idx := slices.Index(args, "--setting-sources")
	require.NotEqual(t, -1, idx, "Expected --setting-sources flag")
	require.Equal(t, "user,project", args[idx+1])
}

func TestBuildArgs_ThinkingConfig(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		thinking  config.ThinkingConfig
		wantFlag  string
		wantValue string
	}{
		{
			name:      "adaptive uses --thinking adaptive",
			thinking:  config.ThinkingConfigAdaptive{},
			wantFlag:  "--thinking",
			wantValue: "adaptive",
		},
		{
			name:      "enabled uses --max-thinking-tokens with budget",
			thinking:  config.ThinkingConfigEnabled{BudgetTokens: 16000},
			wantFlag:  "--max-thinking-tokens",
			wantValue: "16000",
		},
		{
			name:      "disabled uses --thinking disabled",
			thinking:  config.ThinkingConfigDisabled{},
			wantFlag:  "--thinking",
			wantValue: "disabled",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			args := BuildArgs("test", &config.Options{Thinking: tt.thinking}, false)
			idx := slices.Index(args, tt.wantFlag)
			require.NotEqual(t, -1, idx, "Expected %s flag", tt.wantFlag)
			require.Equal(t, tt.wantValue, args[idx+1])
		})
	}
}

func TestBuildArgs_ThinkingAdaptiveDoesNotUseMaxThinkingTokens(t *testing.T) {
	t.Parallel()

	args := BuildArgs("test", &config.Options{Thinking: config.ThinkingConfigAdaptive{}}, false)
	require.NotContains(t, args, "--max-thinking-tokens")
}