package agentcontextconfig_test

import (

"os"

"path/filepath"

"strings"

"testing"

"github.com/stretchr/testify/require"

"github.com/coder/coder/v2/agent/agentcontextconfig"

"github.com/coder/coder/v2/codersdk"

)

// filterParts returns only the parts matching the given type.

func filterParts(parts []codersdk.ChatMessagePart, t codersdk.ChatMessagePartType) []codersdk.ChatMessagePart {

var out []codersdk.ChatMessagePart

for _, p := range parts {

if p.Type == t {

out = append(out, p)

}

}

return out

}

func writeSkillMetaFileInRoot(t *testing.T, skillsRoot, name, description string) string {

t.Helper()

skillDir := filepath.Join(skillsRoot, name)

require.NoError(t, os.MkdirAll(skillDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(skillDir, "SKILL.md"),

[]byte("---\nname: "+name+"\ndescription: "+description+"\n---\nSkill body"),

0o600,

))

return skillDir

}

func writeSkillMetaFile(t *testing.T, dir, name, description string) string {

t.Helper()

return writeSkillMetaFileInRoot(t, filepath.Join(dir, ".agents", "skills"), name, description)

}

//nolint:paralleltest,tparallel // Uses t.Setenv to isolate HOME.

func TestContextPartsFromDir(t *testing.T) {

// Prevent ~/.coder/skills on the host from leaking into results.

t.Setenv("HOME", t.TempDir())

t.Setenv("USERPROFILE", t.TempDir())

t.Run("ReturnsInstructionFilePart", func(t *testing.T) {

t.Parallel()

dir := t.TempDir()

instructionPath := filepath.Join(dir, "AGENTS.md")

require.NoError(t, os.WriteFile(instructionPath, []byte("project instructions"), 0o600))

parts := agentcontextconfig.ContextPartsFromDir(dir)

contextParts := filterParts(parts, codersdk.ChatMessagePartTypeContextFile)

skillParts := filterParts(parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, parts, 1)

require.Len(t, contextParts, 1)

require.Empty(t, skillParts)

require.Equal(t, instructionPath, contextParts[0].ContextFilePath)

require.Equal(t, "project instructions", contextParts[0].ContextFileContent)

require.False(t, contextParts[0].ContextFileTruncated)

})

t.Run("ReturnsSkillParts", func(t *testing.T) {

t.Parallel()

dir := t.TempDir()

skillDir := writeSkillMetaFile(t, dir, "my-skill", "A test skill")

parts := agentcontextconfig.ContextPartsFromDir(dir)

contextParts := filterParts(parts, codersdk.ChatMessagePartTypeContextFile)

skillParts := filterParts(parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, parts, 1)

require.Empty(t, contextParts)

require.Len(t, skillParts, 1)

require.Equal(t, "my-skill", skillParts[0].SkillName)

require.Equal(t, "A test skill", skillParts[0].SkillDescription)

require.Equal(t, skillDir, skillParts[0].SkillDir)

require.Equal(t, "SKILL.md", skillParts[0].ContextFileSkillMetaFile)

})

t.Run("ReturnsSkillPartsFromSkillsDir", func(t *testing.T) {

t.Parallel()

dir := t.TempDir()

skillDir := writeSkillMetaFileInRoot(

t,

filepath.Join(dir, "skills"),

"my-skill",

"A test skill",

)

parts := agentcontextconfig.ContextPartsFromDir(dir)

contextParts := filterParts(parts, codersdk.ChatMessagePartTypeContextFile)

skillParts := filterParts(parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, parts, 1)

require.Empty(t, contextParts)

require.Len(t, skillParts, 1)

require.Equal(t, "my-skill", skillParts[0].SkillName)

require.Equal(t, "A test skill", skillParts[0].SkillDescription)

require.Equal(t, skillDir, skillParts[0].SkillDir)

require.Equal(t, "SKILL.md", skillParts[0].ContextFileSkillMetaFile)

})

t.Run("ReturnsEmptyForEmptyDir", func(t *testing.T) {

t.Parallel()

parts := agentcontextconfig.ContextPartsFromDir(t.TempDir())

require.NotNil(t, parts)

require.Empty(t, parts)

})

t.Run("ReturnsCombinedResults", func(t *testing.T) {

t.Parallel()

dir := t.TempDir()

instructionPath := filepath.Join(dir, "AGENTS.md")

require.NoError(t, os.WriteFile(instructionPath, []byte("combined instructions"), 0o600))

skillDir := writeSkillMetaFile(t, dir, "combined-skill", "Combined test skill")

parts := agentcontextconfig.ContextPartsFromDir(dir)

contextParts := filterParts(parts, codersdk.ChatMessagePartTypeContextFile)

skillParts := filterParts(parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, parts, 2)

require.Len(t, contextParts, 1)

require.Len(t, skillParts, 1)

require.Equal(t, instructionPath, contextParts[0].ContextFilePath)

require.Equal(t, "combined instructions", contextParts[0].ContextFileContent)

require.Equal(t, "combined-skill", skillParts[0].SkillName)

require.Equal(t, skillDir, skillParts[0].SkillDir)

})

}

func setupConfigTestEnv(t *testing.T, overrides map[string]string) string {

t.Helper()

fakeHome := t.TempDir()

t.Setenv("HOME", fakeHome)

t.Setenv("USERPROFILE", fakeHome)

t.Setenv(agentcontextconfig.EnvInstructionsDirs, "")

t.Setenv(agentcontextconfig.EnvInstructionsFile, "")

t.Setenv(agentcontextconfig.EnvSkillsDirs, "")

t.Setenv(agentcontextconfig.EnvSkillMetaFile, "")

t.Setenv(agentcontextconfig.EnvMCPConfigFiles, "")

for key, value := range overrides {

t.Setenv(key, value)

}

return fakeHome

}

func TestResolve(t *testing.T) {

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("Defaults", func(t *testing.T) {

setupConfigTestEnv(t, nil)

workDir := platformAbsPath("work")

cfg, mcpFiles := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

// Parts is always non-nil.

require.NotNil(t, cfg.Parts)

// Default MCP config file is ".mcp.json" (relative),

// resolved against the working directory.

require.Equal(t, []string{filepath.Join(workDir, ".mcp.json")}, mcpFiles)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("CustomEnvVars", func(t *testing.T) {

optInstructions := t.TempDir()

optSkills := t.TempDir()

optMCP := platformAbsPath("opt", "mcp.json")

setupConfigTestEnv(t, map[string]string{

agentcontextconfig.EnvInstructionsDirs: optInstructions,

agentcontextconfig.EnvInstructionsFile: "CUSTOM.md",

agentcontextconfig.EnvSkillsDirs: optSkills,

agentcontextconfig.EnvSkillMetaFile: "META.yaml",

agentcontextconfig.EnvMCPConfigFiles: optMCP,

})

// Create files matching the custom names so we can

// verify the env vars actually change lookup behavior.

require.NoError(t, os.WriteFile(filepath.Join(optInstructions, "CUSTOM.md"), []byte("custom instructions"), 0o600))

skillDir := filepath.Join(optSkills, "my-skill")

require.NoError(t, os.MkdirAll(skillDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(skillDir, "META.yaml"),

[]byte("---\nname: my-skill\ndescription: custom meta\n---\n"),

0o600,

))

workDir := platformAbsPath("work")

cfg, mcpFiles := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

require.Equal(t, []string{optMCP}, mcpFiles)

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 1)

require.Equal(t, "custom instructions", ctxFiles[0].ContextFileContent)

skillParts := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, skillParts, 1)

require.Equal(t, "my-skill", skillParts[0].SkillName)

require.Equal(t, "META.yaml", skillParts[0].ContextFileSkillMetaFile)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("WhitespaceInFileNames", func(t *testing.T) {

fakeHome := setupConfigTestEnv(t, map[string]string{

agentcontextconfig.EnvInstructionsFile: " CLAUDE.md ",

})

t.Setenv(agentcontextconfig.EnvInstructionsDirs, fakeHome)

workDir := t.TempDir()

// Create a file matching the trimmed name.

require.NoError(t, os.WriteFile(filepath.Join(fakeHome, "CLAUDE.md"), []byte("hello"), 0o600))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 1)

require.Equal(t, "hello", ctxFiles[0].ContextFileContent)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("CommaSeparatedDirs", func(t *testing.T) {

a := t.TempDir()

b := t.TempDir()

setupConfigTestEnv(t, map[string]string{

agentcontextconfig.EnvInstructionsDirs: a + "," + b,

})

// Put instruction files in both dirs.

require.NoError(t, os.WriteFile(filepath.Join(a, "AGENTS.md"), []byte("from a"), 0o600))

require.NoError(t, os.WriteFile(filepath.Join(b, "AGENTS.md"), []byte("from b"), 0o600))

workDir := t.TempDir()

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 2)

require.Equal(t, "from a", ctxFiles[0].ContextFileContent)

require.Equal(t, "from b", ctxFiles[1].ContextFileContent)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("ReadsInstructionFiles", func(t *testing.T) {

workDir := t.TempDir()

fakeHome := setupConfigTestEnv(t, nil)

// Create ~/.coder/AGENTS.md

coderDir := filepath.Join(fakeHome, ".coder")

require.NoError(t, os.MkdirAll(coderDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(coderDir, "AGENTS.md"),

[]byte("home instructions"),

0o600,

))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.NotNil(t, cfg.Parts)

require.Len(t, ctxFiles, 1)

require.Equal(t, "home instructions", ctxFiles[0].ContextFileContent)

require.Equal(t, filepath.Join(coderDir, "AGENTS.md"), ctxFiles[0].ContextFilePath)

require.False(t, ctxFiles[0].ContextFileTruncated)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("ReadsWorkingDirInstructionFile", func(t *testing.T) {

setupConfigTestEnv(t, nil)

workDir := t.TempDir()

// Create AGENTS.md in the working directory.

require.NoError(t, os.WriteFile(

filepath.Join(workDir, "AGENTS.md"),

[]byte("project instructions"),

0o600,

))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

// Should find the working dir file (not in instruction dirs).

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.NotNil(t, cfg.Parts)

require.Len(t, ctxFiles, 1)

require.Equal(t, "project instructions", ctxFiles[0].ContextFileContent)

require.Equal(t, filepath.Join(workDir, "AGENTS.md"), ctxFiles[0].ContextFilePath)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("TruncatesLargeInstructionFile", func(t *testing.T) {

setupConfigTestEnv(t, nil)

workDir := t.TempDir()

largeContent := strings.Repeat("a", 64*1024+100)

require.NoError(t, os.WriteFile(filepath.Join(workDir, "AGENTS.md"), []byte(largeContent), 0o600))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 1)

require.True(t, ctxFiles[0].ContextFileTruncated)

require.Len(t, ctxFiles[0].ContextFileContent, 64*1024)

})

sanitizationTests := []struct {

name string

input string

expected string

}{

{

name: "SanitizesHTMLComments",

input: "visible\n<!-- hidden -->content",

expected: "visible\ncontent",

},

{

name: "SanitizesInvisibleUnicode",

input: "before\u200bafter",

expected: "beforeafter",

},

{

name: "NormalizesCRLF",

input: "line1\r\nline2\rline3",

expected: "line1\nline2\nline3",

},

}

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

for _, tt := range sanitizationTests {

t.Run(tt.name, func(t *testing.T) {

setupConfigTestEnv(t, nil)

workDir := t.TempDir()

require.NoError(t, os.WriteFile(

filepath.Join(workDir, "AGENTS.md"),

[]byte(tt.input),

0o600,

))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

ctxFiles := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 1)

require.Equal(t, tt.expected, ctxFiles[0].ContextFileContent)

})

}

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("DiscoversSkills", func(t *testing.T) {

fakeHome := t.TempDir()

t.Setenv("HOME", fakeHome)

t.Setenv("USERPROFILE", fakeHome)

t.Setenv(agentcontextconfig.EnvInstructionsDirs, fakeHome)

t.Setenv(agentcontextconfig.EnvInstructionsFile, "")

t.Setenv(agentcontextconfig.EnvSkillMetaFile, "")

t.Setenv(agentcontextconfig.EnvMCPConfigFiles, "")

workDir := t.TempDir()

skillsDir := filepath.Join(workDir, ".agents", "skills")

t.Setenv(agentcontextconfig.EnvSkillsDirs, skillsDir)

// Create a valid skill.

skillDir := filepath.Join(skillsDir, "my-skill")

require.NoError(t, os.MkdirAll(skillDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(skillDir, "SKILL.md"),

[]byte("---\nname: my-skill\ndescription: A test skill\n---\nSkill body"),

0o600,

))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

skillParts := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, skillParts, 1)

require.Equal(t, "my-skill", skillParts[0].SkillName)

require.Equal(t, "A test skill", skillParts[0].SkillDescription)

require.Equal(t, skillDir, skillParts[0].SkillDir)

require.Equal(t, "SKILL.md", skillParts[0].ContextFileSkillMetaFile)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("SkipsMissingDirs", func(t *testing.T) {

nonExistent := filepath.Join(t.TempDir(), "does-not-exist")

setupConfigTestEnv(t, map[string]string{

agentcontextconfig.EnvInstructionsDirs: nonExistent,

agentcontextconfig.EnvSkillsDirs: nonExistent,

})

workDir := t.TempDir()

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

// Non-nil empty slice (signals agent supports new format).

require.NotNil(t, cfg.Parts)

require.Empty(t, cfg.Parts)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("MCPConfigFilesResolvedSeparately", func(t *testing.T) {

optMCP := platformAbsPath("opt", "custom.json")

fakeHome := setupConfigTestEnv(t, map[string]string{

agentcontextconfig.EnvMCPConfigFiles: optMCP,

})

t.Setenv(agentcontextconfig.EnvInstructionsDirs, fakeHome)

workDir := t.TempDir()

_, mcpFiles := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

require.Equal(t, []string{optMCP}, mcpFiles)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("SkillNameMustMatchDir", func(t *testing.T) {

fakeHome := setupConfigTestEnv(t, nil)

t.Setenv(agentcontextconfig.EnvInstructionsDirs, fakeHome)

workDir := t.TempDir()

skillsDir := filepath.Join(workDir, "skills")

t.Setenv(agentcontextconfig.EnvSkillsDirs, skillsDir)

// Skill name in frontmatter doesn't match directory name.

skillDir := filepath.Join(skillsDir, "wrong-dir-name")

require.NoError(t, os.MkdirAll(skillDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(skillDir, "SKILL.md"),

[]byte("---\nname: actual-name\ndescription: mismatch\n---\n"),

0o600,

))

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

skillParts := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeSkill)

require.Empty(t, skillParts)

})

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

t.Run("DuplicateSkillsFirstWins", func(t *testing.T) {

fakeHome := setupConfigTestEnv(t, nil)

t.Setenv(agentcontextconfig.EnvInstructionsDirs, fakeHome)

workDir := t.TempDir()

skillsDir1 := filepath.Join(workDir, "skills1")

skillsDir2 := filepath.Join(workDir, "skills2")

t.Setenv(agentcontextconfig.EnvSkillsDirs, skillsDir1+","+skillsDir2)

// Same skill name in both directories.

for _, dir := range []string{skillsDir1, skillsDir2} {

skillDir := filepath.Join(dir, "dup-skill")

require.NoError(t, os.MkdirAll(skillDir, 0o755))

require.NoError(t, os.WriteFile(

filepath.Join(skillDir, "SKILL.md"),

[]byte("---\nname: dup-skill\ndescription: from "+filepath.Base(dir)+"\n---\n"),

0o600,

))

}

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.ReadEnvConfig())

skillParts := filterParts(cfg.Parts, codersdk.ChatMessagePartTypeSkill)

require.Len(t, skillParts, 1)

require.Equal(t, "from skills1", skillParts[0].SkillDescription)

})

//nolint:paralleltest // Uses t.Setenv to mutate HOME.

t.Run("DefaultDiscoversHomeAndProjectSkillsHomeWins", func(t *testing.T) {

fakeHome := t.TempDir()

t.Setenv("HOME", fakeHome)

t.Setenv("USERPROFILE", fakeHome)

workDir := t.TempDir()

homeSkills := filepath.Join(fakeHome, ".coder", "skills")

writeSkillMetaFileInRoot(t, homeSkills, "home-only", "home only")

writeSkillMetaFileInRoot(t, homeSkills, "shared", "from home")

writeSkillMetaFile(t, workDir, "project-only", "project only")

writeSkillMetaFile(t, workDir, "shared", "from project")

// Construct the Config directly with the package defaults

// to verify the default skills list (and only the defaults).

cfg, _ := agentcontextconfig.Resolve(workDir, agentcontextconfig.Config{

SkillsDirs: agentcontextconfig.DefaultSkillsDir,

SkillMetaFile: agentcontextconfig.DefaultSkillMetaFile,

})

got := map[string]string{}

for _, p := range filterParts(cfg.Parts, codersdk.ChatMessagePartTypeSkill) {

got[p.SkillName] = p.SkillDescription

}

require.Equal(t, map[string]string{

"home-only": "home only",

"project-only": "project only",

"shared": "from home",

}, got)

})

}

func TestNewAPI_LazyDirectory(t *testing.T) {

t.Setenv(agentcontextconfig.EnvInstructionsDirs, "")

t.Setenv(agentcontextconfig.EnvInstructionsFile, "")

t.Setenv(agentcontextconfig.EnvSkillsDirs, "")

t.Setenv(agentcontextconfig.EnvSkillMetaFile, "")

t.Setenv(agentcontextconfig.EnvMCPConfigFiles, "")

dir := ""

api := agentcontextconfig.NewAPI(func() string { return dir }, agentcontextconfig.ReadEnvConfig())

// Before directory is set, MCP paths resolve to nothing.

mcpFiles := api.MCPConfigFiles()

require.Empty(t, mcpFiles)

// After setting the directory, MCPConfigFiles() picks it up.

dir = platformAbsPath("work")

mcpFiles = api.MCPConfigFiles()

require.NotEmpty(t, mcpFiles)

require.Equal(t, []string{filepath.Join(dir, ".mcp.json")}, mcpFiles)

}

// TestClearEnvVars verifies that ClearEnvVars removes every

// CODER_AGENT_EXP_* env var from the process.

//

//nolint:paralleltest // Mutates process-wide environment.

func TestClearEnvVars(t *testing.T) {

// Set every context config env var.

for _, key := range []string{

agentcontextconfig.EnvInstructionsDirs,

agentcontextconfig.EnvInstructionsFile,

agentcontextconfig.EnvSkillsDirs,

agentcontextconfig.EnvSkillMetaFile,

agentcontextconfig.EnvMCPConfigFiles,

} {

t.Setenv(key, "some-value")

}

agentcontextconfig.ClearEnvVars()

// Every env var should be absent.

for _, key := range []string{

agentcontextconfig.EnvInstructionsDirs,

agentcontextconfig.EnvInstructionsFile,

agentcontextconfig.EnvSkillsDirs,

agentcontextconfig.EnvSkillMetaFile,

agentcontextconfig.EnvMCPConfigFiles,

} {

_, ok := os.LookupEnv(key)

require.False(t, ok, "env var %s should be cleared", key)

}

}

// TestResolve_ConfigOverridesEnv verifies that Resolve uses

// the Config struct, not environment variables.

//

//nolint:paralleltest // Uses t.Setenv to mutate process-wide environment.

func TestResolve_ConfigOverridesEnv(t *testing.T) {

// Set env vars to one value.

envDir := t.TempDir()

t.Setenv(agentcontextconfig.EnvInstructionsDirs, envDir)

// Build a Config with a different value.

cfgDir := t.TempDir()

require.NoError(t, os.WriteFile(

filepath.Join(cfgDir, "AGENTS.md"),

[]byte("from config"),

0o600,

))

cfg := agentcontextconfig.ReadEnvConfig()

cfg.InstructionsDirs = cfgDir

workDir := t.TempDir()

result, _ := agentcontextconfig.Resolve(workDir, cfg)

ctxFiles := filterParts(result.Parts, codersdk.ChatMessagePartTypeContextFile)

require.Len(t, ctxFiles, 1)

require.Equal(t, "from config", ctxFiles[0].ContextFileContent)

}