Fix the absolutely retarded single match crutch

build.sh

@@ -1,2 +1,2 @@
-GOOS=windows GOARCH=amd64 go build -o cln.exe .
+CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o cln.exe .
-GOOS=linux GOARCH=amd64 go build -o cln .
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o cln .

colors.go

@@ -83,6 +83,7 @@ const (
 // The acceptable range is [16, 231] but here we remove some very dark colors
 // That make text unreadable on a dark terminal
 // See https://www.hackitu.de/termcolor256/
+// Wait - why are we hardcoding this? lol do for loops not exist in our universe?
 var colors = []int{22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 57, 62, 63, 64, 65, 67, 68, 69, 70, 71, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 148, 149, 150, 151, 152, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 184, 185, 186, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 226, 227, 228, 229, 230}
 var colorsIndex int = -1
 var shuffled bool

home_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHomeDirectoryPatternExpansion(t *testing.T) {
+	testDir := getTestSubDir(t)
+
+	// Ensure we're working within the project directory
+	ensureInProjectDir(t, testDir)
+
+	// Change to test directory
+	originalDir, _ := os.Getwd()
+	defer os.Chdir(originalDir)
+	os.Chdir(testDir)
+
+	// Get the actual home directory
+	homeDir, err := os.UserHomeDir()
+	assert.NoError(t, err)
+
+	// Create a test directory in the home folder
+	testHomeDir := filepath.Join(homeDir, "synclib_test")
+	err = os.MkdirAll(testHomeDir, 0755)
+	assert.NoError(t, err)
+	defer os.RemoveAll(testHomeDir) // Cleanup
+
+	// Create a test file in the home directory
+	testFile := filepath.Join(testHomeDir, "testhome.csv")
+	err = os.WriteFile(testFile, []byte("test content"), 0644)
+	assert.NoError(t, err)
+
+	// Test the pattern with ~/ that should match the file
+	pattern := "~/synclib_test/testhome.csv"
+	links, err := ExpandPattern(pattern, testDir, "target.csv", false)
+
+	// This should work but currently fails due to the bug
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(links), "Pattern should match exactly 1 file")
+
+	if len(links) > 0 {
+		assert.Contains(t, links[0].Source, "testhome.csv")
+		assert.Equal(t, "target.csv", links[0].Target)
+	}
+}

instruction.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -16,6 +17,7 @@ type LinkInstruction struct {
 	Force  bool   `yaml:"force,omitempty"`
 	Hard   bool   `yaml:"hard,omitempty"`
 	Delete bool   `yaml:"delete,omitempty"`
+	Files  bool   `yaml:"files,omitempty"`
 }
 
 type YAMLConfig struct {
@@ -44,6 +46,9 @@ func (instruction *LinkInstruction) String() string {
 	if instruction.Delete {
 		flags = append(flags, "delete=true")
 	}
+	if instruction.Files {
+		flags = append(flags, "files=true")
+	}
 
 	flagsStr := ""
 	if len(flags) > 0 {
@@ -114,6 +119,8 @@ func ParseInstruction(line, workdir string) (LinkInstruction, error) {
 				if instruction.Delete {
 					instruction.Force = true // Delete implies Force
 				}
+			case 5: // Files flag (6th position)
+				instruction.Files = isTrue(flagPart)
 			}
 			continue
 		}
@@ -138,6 +145,8 @@ func ParseInstruction(line, workdir string) (LinkInstruction, error) {
 			if instruction.Delete {
 				instruction.Force = true // Delete implies Force
 			}
+		case "files":
+			instruction.Files = isTrue(flagValue)
 		}
 	}
 
@@ -168,6 +177,18 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 		return
 	}
 
+	if instruction.Files {
+		info, err := os.Stat(instruction.Source)
+		if err != nil {
+			status <- fmt.Errorf("could not stat source %s; err: %v", FormatSourcePath(instruction.Source), err)
+			return
+		}
+		if info.IsDir() {
+			status <- fmt.Errorf("source %s is a directory but files=true", FormatSourcePath(instruction.Source))
+			return
+		}
+	}
+
 	if !instruction.Force && AreSame(instruction.Source, instruction.Target) {
 		//status <- fmt.Errorf("source %s and target %s are the same, nothing to do...",
 		//	FormatSourcePath(instruction.Source),
@@ -179,6 +200,12 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 	}
 
 	if FileExists(instruction.Target) {
+		if instruction.Files {
+			if info, err := os.Stat(instruction.Target); err == nil && info.IsDir() {
+				status <- fmt.Errorf("target %s is a directory but files=true", FormatTargetPath(instruction.Target))
+				return
+			}
+		}
 		if instruction.Force {
 			isSymlink, err := IsSymlink(instruction.Target)
 			if err != nil {
@@ -316,6 +343,14 @@ func preprocessInstructions(instructions []LinkInstruction, filename, workdir st
 			// This is a from reference - load the referenced file
 			fromInstructions, err := loadFromReference(instr.Source, filename, workdir, visited)
 			if err != nil {
+				var absRefErr *absoluteReferenceError
+				if errors.As(err, &absRefErr) {
+					LogError("Referenced file not found: %s (from %s), skipping", instr.Source, filename)
+					continue
+				}
+				if errors.Is(err, os.ErrNotExist) {
+					LogError("Referenced file not found: %s (from %s), stopping", instr.Source, filename)
+				}
 				return nil, fmt.Errorf("error loading from reference %s: %w", instr.Source, err)
 			}
 			result = append(result, fromInstructions...)
@@ -333,9 +368,29 @@ func preprocessInstructions(instructions []LinkInstruction, filename, workdir st
 }
 
 // loadFromReference loads instructions from a referenced file
+type absoluteReferenceError struct {
+	path string
+	err  error
+}
+
+func (e *absoluteReferenceError) Error() string {
+	return e.err.Error()
+}
+
+func (e *absoluteReferenceError) Unwrap() error {
+	return e.err
+}
+
 func loadFromReference(fromFile, currentFile, workdir string, visited map[string]bool) ([]LinkInstruction, error) {
+	// First convert home directory if it starts with ~
+	fromPath, err := ConvertHome(fromFile)
+	if err != nil {
+		return nil, fmt.Errorf("error converting home directory: %w", err)
+	}
+
+	refIsAbsolute := filepath.IsAbs(fromPath)
+
 	// Convert relative paths to absolute paths based on the current file's directory
-	fromPath := fromFile
 	if !filepath.IsAbs(fromPath) {
 		currentDir := filepath.Dir(currentFile)
 		fromPath = filepath.Join(currentDir, fromPath)
@@ -346,13 +401,26 @@ func loadFromReference(fromFile, currentFile, workdir string, visited map[string
 
 	// Recursively parse the referenced file with cycle detection
 	fromWorkdir := filepath.Dir(fromPath)
-	return parseYAMLFileRecursive(fromPath, fromWorkdir, visited)
+	links, err := parseYAMLFileRecursive(fromPath, fromWorkdir, visited)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) && refIsAbsolute {
+			return nil, &absoluteReferenceError{path: fromPath, err: err}
+		}
+		return nil, err
+	}
+	return links, nil
 }
 
 // expandGlobs expands glob patterns in a single instruction
 func expandGlobs(instr LinkInstruction, filename, workdir string) ([]LinkInstruction, error) {
-	LogSource("Expanding pattern source %s in YAML file %s", instr.Source, filename)
+	// Convert home directory (~) before expanding pattern
-	newlinks, err := ExpandPattern(instr.Source, workdir, instr.Target)
+	convertedSource, err := ConvertHome(instr.Source)
+	if err != nil {
+		return nil, fmt.Errorf("error converting home directory in source %s: %w", instr.Source, err)
+	}
+
+	LogSource("Expanding pattern source %s in YAML file %s", convertedSource, filename)
+	newlinks, err := ExpandPattern(convertedSource, workdir, instr.Target, instr.Files)
 	if err != nil {
 		return nil, err
 	}
@@ -362,6 +430,7 @@ func expandGlobs(instr LinkInstruction, filename, workdir string) ([]LinkInstruc
 		newlinks[i].Delete = instr.Delete
 		newlinks[i].Hard = instr.Hard
 		newlinks[i].Force = instr.Force
+		newlinks[i].Files = instr.Files
 	}
 
 	LogInfo("Expanded pattern %s in YAML file %s to %d links",
@@ -428,8 +497,43 @@ func parseYAMLFileRecursive(filename, workdir string, visited map[string]bool) (
 	return processedInstructions, nil
 }
 
-func ExpandPattern(source, workdir, target string) (links []LinkInstruction, err error) {
+func ExpandPattern(source, workdir, target string, filesOnly bool) (links []LinkInstruction, err error) {
+	if strings.TrimSpace(source) == "" {
+		return nil, nil
+	}
+	// Convert home directory (~) before splitting pattern
+	source, err = ConvertHome(source)
+	if err != nil {
+		return nil, fmt.Errorf("error converting home directory in source %s: %w", source, err)
+	}
+	// Normalize path to convert backslashes to forward slashes before pattern processing
+	source = NormalizePath(source, workdir)
+
+	if !strings.ContainsAny(source, "*?[{") {
+		info, statErr := os.Stat(source)
+		if statErr != nil {
+			if os.IsNotExist(statErr) {
+				LogInfo("Literal source %s does not exist, skipping", FormatSourcePath(source))
+				return nil, nil
+			}
+			return nil, fmt.Errorf("failed to stat literal source %s: %w", source, statErr)
+		}
+
+		if filesOnly && info.IsDir() {
+			LogInfo("Files-only mode: skipping directory %s", FormatSourcePath(source))
+			return nil, nil
+		}
+
+		return []LinkInstruction{
+			{
+				Source: source,
+				Target: target,
+			},
+		}, nil
+	}
+
 	static, pattern := doublestar.SplitPattern(source)
+
 	if static == "" || static == "." {
 		static = workdir
 	}
@@ -441,43 +545,31 @@ func ExpandPattern(source, workdir, target string) (links []LinkInstruction, err
 		return nil, fmt.Errorf("error expanding pattern: %w", err)
 	}
 
-	targetIsFile := false
-	if info, err := os.Stat(target); err == nil && !info.IsDir() {
-		targetIsFile = true
-	}
-
 	for _, file := range files {
-		if len(files) == 1 {
+		fullPath := filepath.Join(static, file)
-			// Special case: if there is only one file
+
-			// This should only ever happen if our source is a path (and not a glob!)
+		info, err := os.Stat(fullPath)
-			// And our target is a path
+		if err != nil {
-			// ...but it will also happen if the source IS a glob and it happens to match ONE file
+			LogError("Failed to stat %s: %v", FormatSourcePath(fullPath), err)
-			// I think that should happen rarely enough to not be an issue...
-			links = append(links, LinkInstruction{
-				Source: filepath.Join(static, file),
-				Target: target,
-			})
 			continue
 		}
-		if info, err := os.Stat(file); err == nil && info.IsDir() {
+
+		if filesOnly && info.IsDir() {
+			LogInfo("Files-only mode: skipping directory %s", FormatSourcePath(fullPath))
+			continue
+		}
+
+		if info.IsDir() {
 			// We don't care about matched directories
 			// We want files within them
 			LogInfo("Skipping directory %s", file)
 			continue
 		}
 
-		var targetPath string
+		targetPath := filepath.Join(target, file)
-		if targetIsFile && len(files) == 1 {
-			// Special case: target is a file, and glob matches exactly one file.
-			// Use target directly (don't append filename).
-			targetPath = target
-		} else {
-			// Default: append filename to target dir.
-			targetPath = filepath.Join(target, file)
-		}
 
 		links = append(links, LinkInstruction{
-			Source: filepath.Join(static, file),
+			Source: fullPath,
 			Target: targetPath,
 		})
 	}

instruction_test.go

@@ -110,7 +110,6 @@ func ensureInProjectDir(t *testing.T, testDir string) {
 	}
 }
 
-
 func TestParseInstruction(t *testing.T) {
 	testDir := getTestSubDir(t)
 
@@ -133,7 +132,7 @@ func TestParseInstruction(t *testing.T) {
 		input       string
 		expectError bool
 		errorMsg    string
-		assertions func(*testing.T, LinkInstruction)
+		assertions  func(*testing.T, LinkInstruction)
 	}{
 		{
 			name:        "Basic instruction",
@@ -182,6 +181,14 @@ func TestParseInstruction(t *testing.T) {
 				assert.True(t, instruction.Delete)
 			},
 		},
+		{
+			name:        "Instruction with files flag",
+			input:       "src.txt,dst.txt,files=true",
+			expectError: false,
+			assertions: func(t *testing.T, instruction LinkInstruction) {
+				assert.True(t, instruction.Files)
+			},
+		},
 		{
 			name:        "Comment line",
 			input:       "# This is a comment",
@@ -217,7 +224,7 @@ func TestParseInstruction(t *testing.T) {
 
 func TestLinkInstruction_RunAsync(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -346,12 +353,52 @@ func TestLinkInstruction_RunAsync(t *testing.T) {
 		err := <-status
 		assert.NoError(t, err) // Should succeed but do nothing
 	})
+
+	t.Run("Files flag rejects directory source", func(t *testing.T) {
+		dirSource := filepath.Join(testDir, "dirsource")
+		err := os.MkdirAll(dirSource, 0755)
+		assert.NoError(t, err)
+
+		instruction := LinkInstruction{
+			Source: dirSource,
+			Target: filepath.Join(testDir, "dirlink"),
+			Files:  true,
+		}
+
+		status := make(chan error)
+		go instruction.RunAsync(status)
+
+		err = <-status
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "files=true")
+	})
+
+	t.Run("Files flag prevents deleting target directories", func(t *testing.T) {
+		targetDir := filepath.Join(testDir, "targetdir")
+		err := os.MkdirAll(targetDir, 0755)
+		assert.NoError(t, err)
+
+		instruction := LinkInstruction{
+			Source: srcFile,
+			Target: targetDir,
+			Force:  true,
+			Delete: true,
+			Files:  true,
+		}
+
+		status := make(chan error)
+		go instruction.RunAsync(status)
+
+		err = <-status
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "files=true")
+		assert.True(t, FileExists(targetDir))
+	})
 }
 
 func TestLinkInstruction_Undo(t *testing.T) {
 	testDir := getTestSubDir(t)
 
-	
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -409,7 +456,7 @@ func TestLinkInstruction_Undo(t *testing.T) {
 
 func TestGlobPatterns(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -478,11 +525,11 @@ func TestGlobPatterns(t *testing.T) {
 
 		// Verify the full source and target paths using path endings
 		expectedMappings := map[string]string{
-			"src/file1.txt":                 "dst/file1.txt",
+			"src/file1.txt":                "dst/file1.txt",
-			"src/file2.txt":                 "dst/file2.txt",
+			"src/file2.txt":                "dst/file2.txt",
-			"src/foobar/foobar.txt":         "dst/foobar/foobar.txt",
+			"src/foobar/foobar.txt":        "dst/foobar/foobar.txt",
-			"src/foobar/nested/foobar.txt":  "dst/foobar/nested/foobar.txt",
+			"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
-			"src/nested/nested.txt":         "dst/nested/nested.txt",
+			"src/nested/nested.txt":        "dst/nested/nested.txt",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -519,8 +566,8 @@ func TestGlobPatterns(t *testing.T) {
 
 		// Verify the full source and target paths using path endings
 		expectedMappings := map[string]string{
-			"src/nested/nested.txt":           "dst/nested/nested.txt",
+			"src/nested/nested.txt":        "dst/nested/nested.txt",
-			"src/foobar/nested/foobar.txt":   "dst/foobar/nested/foobar.txt",
+			"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -557,13 +604,13 @@ func TestGlobPatterns(t *testing.T) {
 
 		// Verify the full source and target paths using path endings
 		expectedMappings := map[string]string{
-			"src/file1.txt":                 "dst/file1.txt",
+			"src/file1.txt":                "dst/file1.txt",
-			"src/file2.txt":                 "dst/file2.txt",
+			"src/file2.txt":                "dst/file2.txt",
-			"src/file3.log":                 "dst/file3.log",
+			"src/file3.log":                "dst/file3.log",
-			"src/readme.md":                 "dst/readme.md",
+			"src/readme.md":                "dst/readme.md",
-			"src/foobar/foobar.txt":         "dst/foobar/foobar.txt",
+			"src/foobar/foobar.txt":        "dst/foobar/foobar.txt",
-			"src/foobar/nested/foobar.txt":  "dst/foobar/nested/foobar.txt",
+			"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
-			"src/nested/nested.txt":         "dst/nested/nested.txt",
+			"src/nested/nested.txt":        "dst/nested/nested.txt",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -711,8 +758,8 @@ func TestGlobPatterns(t *testing.T) {
 		expectedMappings := map[string]string{
 			"src/file1.txt": "dst/txt/file1.txt",
 			"src/file2.txt": "dst/txt/file2.txt",
-			"src/file3.log": "dst/logs", // Single file - target is directory directly
+			"src/file3.log": "dst/logs/file3.log",
-			"src/readme.md": "dst/docs", // Single file - target is directory directly
+			"src/readme.md": "dst/docs/readme.md",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -751,11 +798,11 @@ func TestGlobPatterns(t *testing.T) {
 
 		// Verify the full source and target paths and flags using path endings
 		expectedMappings := map[string]string{
-			"src/file1.txt":                 "dst/file1.txt",
+			"src/file1.txt":                "dst/file1.txt",
-			"src/file2.txt":                 "dst/file2.txt",
+			"src/file2.txt":                "dst/file2.txt",
-			"src/foobar/foobar.txt":         "dst/foobar/foobar.txt",
+			"src/foobar/foobar.txt":        "dst/foobar/foobar.txt",
-			"src/foobar/nested/foobar.txt":  "dst/foobar/nested/foobar.txt",
+			"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
-			"src/nested/nested.txt":         "dst/nested/nested.txt",
+			"src/nested/nested.txt":        "dst/nested/nested.txt",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -820,7 +867,7 @@ func createGlobTestStructure(t *testing.T, testDir string) {
 
 func TestParseYAMLFile(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -845,6 +892,10 @@ func TestParseYAMLFile(t *testing.T) {
 	err = os.WriteFile(file3, []byte("log content"), 0644)
 	assert.NoError(t, err)
 
+	dirOnly := filepath.Join(srcDir, "dironly")
+	err = os.MkdirAll(dirOnly, 0755)
+	assert.NoError(t, err)
+
 	t.Run("YAML with glob pattern", func(t *testing.T) {
 		yamlContent := `- source: src/*.txt
   target: dst
@@ -910,6 +961,24 @@ func TestParseYAMLFile(t *testing.T) {
 		assert.True(t, instructions[0].Force)
 	})
 
+	t.Run("YAML with files flag", func(t *testing.T) {
+		yamlContent := `- source: src/*.txt
+  target: dst
+  files: true`
+
+		yamlFile := filepath.Join(testDir, "files-flag.yaml")
+		err := os.WriteFile(yamlFile, []byte(yamlContent), 0644)
+		assert.NoError(t, err)
+
+		instructions, err := ParseYAMLFile(yamlFile, testDir)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(instructions))
+
+		for _, inst := range instructions {
+			assert.True(t, inst.Files)
+		}
+	})
+
 	t.Run("Invalid YAML", func(t *testing.T) {
 		yamlFile := filepath.Join(testDir, "invalid.yaml")
 		err := os.WriteFile(yamlFile, []byte("invalid: yaml: content: [["), 0644)
@@ -927,7 +996,7 @@ func TestParseYAMLFile(t *testing.T) {
 
 func TestExpandPattern(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -953,7 +1022,7 @@ func TestExpandPattern(t *testing.T) {
 	assert.NoError(t, err)
 
 	t.Run("Glob pattern", func(t *testing.T) {
-		links, err := ExpandPattern("src/*.txt", testDir, "dst")
+		links, err := ExpandPattern("src/*.txt", testDir, "dst", false)
 		assert.NoError(t, err)
 		assert.Equal(t, 2, len(links))
 
@@ -983,7 +1052,7 @@ func TestExpandPattern(t *testing.T) {
 	})
 
 	t.Run("Single file pattern", func(t *testing.T) {
-		links, err := ExpandPattern("src/file1.txt", testDir, "dst/single.txt")
+		links, err := ExpandPattern("src/file1.txt", testDir, "dst/single.txt", false)
 		assert.NoError(t, err)
 		assert.Equal(t, 1, len(links))
 
@@ -992,15 +1061,31 @@ func TestExpandPattern(t *testing.T) {
 	})
 
 	t.Run("Non-existent pattern", func(t *testing.T) {
-		links, err := ExpandPattern("src/nonexistent.txt", testDir, "dst")
+		links, err := ExpandPattern("src/nonexistent.txt", testDir, "dst", false)
 		assert.NoError(t, err)
 		assert.Equal(t, 0, len(links))
 	})
+
+	t.Run("Files only keeps file matches", func(t *testing.T) {
+		links, err := ExpandPattern("src/*.txt", testDir, "dst", true)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(links))
+		for _, link := range links {
+			assert.True(t, strings.HasSuffix(link.Source, ".txt"))
+		}
+	})
+
+	t.Run("Files only skips single directory match", func(t *testing.T) {
+		links, err := ExpandPattern("src/dironly/**", testDir, "dst", true)
+		assert.NoError(t, err)
+		assert.Equal(t, 0, len(links))
+	})
+
 }
 
 func TestGetSyncFilesRecursively(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1063,7 +1148,7 @@ func TestGetSyncFilesRecursively(t *testing.T) {
 
 func TestReadFromFile(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1151,7 +1236,7 @@ func TestReadFromFile(t *testing.T) {
 // Test main.go functions that are completely missing coverage
 func TestMainFunctions(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1250,7 +1335,7 @@ func TestMainFunctions(t *testing.T) {
 // Test 1:1 destination mapping for glob patterns
 func TestDestinationPathMapping(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1308,10 +1393,10 @@ func TestDestinationPathMapping(t *testing.T) {
 
 		// Verify 1:1 mapping: static part (src/) is removed, pattern part is preserved using path endings
 		expectedMappings := map[string]string{
-			"src/root.txt":              "foobar/root.txt",
+			"src/root.txt":               "foobar/root.txt",
-			"src/foo/foo.txt":           "foobar/foo/foo.txt",
+			"src/foo/foo.txt":            "foobar/foo/foo.txt",
-			"src/foo/bar/bar.txt":       "foobar/foo/bar/bar.txt",
+			"src/foo/bar/bar.txt":        "foobar/foo/bar/bar.txt",
-			"src/foo/bar/baz/baz.txt":   "foobar/foo/bar/baz/baz.txt",
+			"src/foo/bar/baz/baz.txt":    "foobar/foo/bar/baz/baz.txt",
 			"src/foo/bar/baz/nested.txt": "foobar/foo/bar/baz/nested.txt",
 		}
 
@@ -1349,10 +1434,10 @@ func TestDestinationPathMapping(t *testing.T) {
 
 		// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part is preserved using path endings
 		expectedMappings := map[string]string{
-			"src/foo/foo.txt":             "foobar/foo.txt",
+			"src/foo/foo.txt":            "foobar/foo.txt",
-			"src/foo/bar/bar.txt":         "foobar/bar/bar.txt",
+			"src/foo/bar/bar.txt":        "foobar/bar/bar.txt",
-			"src/foo/bar/baz/baz.txt":     "foobar/bar/baz/baz.txt",
+			"src/foo/bar/baz/baz.txt":    "foobar/bar/baz/baz.txt",
-			"src/foo/bar/baz/nested.txt":  "foobar/bar/baz/nested.txt",
+			"src/foo/bar/baz/nested.txt": "foobar/bar/baz/nested.txt",
 		}
 
 		for sourceEnd, expectedTargetEnd := range expectedMappings {
@@ -1384,7 +1469,7 @@ func TestDestinationPathMapping(t *testing.T) {
 		instruction := instructions[0]
 		// Verify using path endings
 		assert.True(t, strings.HasSuffix(instruction.Source, "src/root.txt"))
-		assert.True(t, strings.HasSuffix(instruction.Target, "dst")) // Single file - target is directory directly
+		assert.True(t, strings.HasSuffix(instruction.Target, "dst/root.txt"))
 	})
 
 	t.Run("src/foo/*.txt -> dst should map src/foo/foo.txt to dst/foo.txt", func(t *testing.T) {
@@ -1401,7 +1486,7 @@ func TestDestinationPathMapping(t *testing.T) {
 		instruction := instructions[0]
 		// Verify using path endings
 		assert.True(t, strings.HasSuffix(instruction.Source, "src/foo/foo.txt"))
-		assert.True(t, strings.HasSuffix(instruction.Target, "dst")) // Single file - target is directory directly
+		assert.True(t, strings.HasSuffix(instruction.Target, "dst/foo.txt"))
 	})
 
 	t.Run("Complex nested pattern src/foo/**/bar/*.txt -> dst should preserve structure", func(t *testing.T) {
@@ -1432,7 +1517,7 @@ func TestDestinationPathMapping(t *testing.T) {
 
 		// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part (bar/baz.txt, bar/baz/bar/deep.txt) is preserved using path endings
 		expectedMappings := map[string]string{
-			"src/foo/bar/bar.txt":       "dst/bar/bar.txt",
+			"src/foo/bar/bar.txt":          "dst/bar/bar.txt",
 			"src/foo/bar/baz/bar/deep.txt": "dst/bar/baz/bar/deep.txt",
 		}
 
@@ -1456,7 +1541,6 @@ func TestDestinationPathMapping(t *testing.T) {
 func TestInstructionEdgeCases(t *testing.T) {
 	testDir := getTestSubDir(t)
 
-	
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1733,7 +1817,7 @@ func TestInstructionEdgeCases(t *testing.T) {
 // Test missing util.go paths
 func TestUtilEdgeCases(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -1942,7 +2026,7 @@ func TestPathFormattingFunctions(t *testing.T) {
 // Test missing instruction.go YAML parsing paths
 func TestYAMLEdgeCases(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -2012,7 +2096,7 @@ func TestYAMLEdgeCases(t *testing.T) {
 		assert.NoError(t, err)
 
 		// Pattern that matches directory
-		links, err := ExpandPattern("src/**/*", testDir, "dst")
+		links, err := ExpandPattern("src/**/*", testDir, "dst", false)
 		assert.NoError(t, err)
 
 		// Should skip directories and only include files
@@ -2037,7 +2121,7 @@ func TestYAMLEdgeCases(t *testing.T) {
 		// Target is a file (not directory)
 		targetFile := filepath.Join(testDir, "target.txt")
 
-		links, err := ExpandPattern("src.txt", testDir, targetFile)
+		links, err := ExpandPattern("src.txt", testDir, targetFile, false)
 		assert.NoError(t, err)
 		assert.Equal(t, 1, len(links))
 		assert.Equal(t, targetFile, links[0].Target)
@@ -2055,7 +2139,7 @@ func TestYAMLEdgeCases(t *testing.T) {
 		// Target is a file (not directory)
 		targetFile := filepath.Join(testDir, "target.txt")
 
-		links, err := ExpandPattern("src*.txt", testDir, targetFile)
+		links, err := ExpandPattern("src*.txt", testDir, targetFile, false)
 		assert.NoError(t, err)
 		assert.GreaterOrEqual(t, len(links), 2)
 
@@ -2077,7 +2161,7 @@ func TestYAMLEdgeCases(t *testing.T) {
 // Test the untested error paths in ReadFromFile and ReadFromStdin
 func TestErrorPaths(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -2363,17 +2447,17 @@ func TestErrorPaths(t *testing.T) {
 		// Test ExpandPattern with error cases
 
 		// Non-existent pattern
-		links, err := ExpandPattern("nonexistent/*.txt", testDir, "target.txt")
+		links, err := ExpandPattern("nonexistent/*.txt", testDir, "target.txt", false)
 		assert.NoError(t, err)
 		assert.Empty(t, links)
 
 		// Empty pattern
-		links, err = ExpandPattern("", testDir, "target.txt")
+		links, err = ExpandPattern("", testDir, "target.txt", false)
 		assert.NoError(t, err)
 		assert.Empty(t, links)
 
 		// Invalid pattern - this actually returns an error
-		_, err = ExpandPattern("invalid[", testDir, "target.txt")
+		_, err = ExpandPattern("invalid[", testDir, "target.txt", false)
 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "syntax error in pattern")
 	})
@@ -2426,7 +2510,7 @@ func TestErrorPaths(t *testing.T) {
 // Test main.go functions that are currently at 0% coverage
 func TestMainFunctionsCoverage(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -2712,7 +2796,7 @@ func TestUnicodeFilenames(t *testing.T) {
 	testDir := getTestSubDir(t)
 
 	// Clean up any files from previous tests to prevent interference
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -2905,7 +2989,7 @@ func TestLongPaths(t *testing.T) {
 	testDir := getTestSubDir(t)
 
 	// Clean up any files from previous tests to prevent interference
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -3273,8 +3357,8 @@ func TestSpecialCharacters(t *testing.T) {
 
 		// Test instruction parsing with special character directories
 		testCases := []struct {
-			source      string
+			source string
-			target      string
+			target string
 		}{
 			{"dir-with-dashes/file.txt", "target1.txt"},
 			{"dir_with_underscores/file.txt", "target2.txt"},
@@ -3353,13 +3437,13 @@ func TestSpecialCharacters(t *testing.T) {
 			filename    string
 			shouldError bool
 		}{
-			{"file.txt", false},                     // Normal case
+			{"file.txt", false},       // Normal case
-			{"file-.txt", false},                    // Trailing dash
+			{"file-.txt", false},      // Trailing dash
-			{"file_.txt", false},                    // Trailing underscore
+			{"file_.txt", false},      // Trailing underscore
-			{"file..txt", false},                    // Multiple dots
+			{"file..txt", false},      // Multiple dots
-			{"file-_.txt", false},                   // Mixed special chars
+			{"file-_.txt", false},     // Mixed special chars
-			{"file--test.txt", false},               // Double dashes
+			{"file--test.txt", false}, // Double dashes
-			{"file__test.txt", false},               // Double underscores
+			{"file__test.txt", false}, // Double underscores
 		}
 
 		for _, tc := range edgeCases {
@@ -3411,7 +3495,7 @@ func TestMixedSourceTypes(t *testing.T) {
 	testDir := getTestSubDir(t)
 
 	// Clean up any files from previous tests to prevent interference
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -3485,7 +3569,7 @@ func TestMixedSourceTypes(t *testing.T) {
 			file := filepath.Join(pattern2Dir, fmt.Sprintf("doc%d.md", i))
 			err = os.WriteFile(file, []byte(fmt.Sprintf("pattern2 content %d", i)), 0644)
 			assert.NoError(t, err)
-			}
+		}
 
 		// Create first YAML file
 		yamlFile1 := filepath.Join(testDir, "pattern1.yaml")
@@ -3705,7 +3789,7 @@ func TestRollbackScenarios(t *testing.T) {
 	testDir := getTestSubDir(t)
 
 	// Clean up any files from previous tests to prevent interference
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -4042,7 +4126,7 @@ func TestRollbackScenarios(t *testing.T) {
 // Test YAMLConfig "From" functionality
 func TestYAMLConfigFrom(t *testing.T) {
 	testDir := getTestSubDir(t)
-	
+
 	// Ensure we're working within the project directory
 	ensureInProjectDir(t, testDir)
 
@@ -4303,3 +4387,146 @@ func TestYAMLConfigFrom(t *testing.T) {
 		assert.Contains(t, err.Error(), "circular reference detected")
 	})
 }
+
+func TestPathResolutionBug(t *testing.T) {
+	testDir := t.TempDir()
+
+	t.Run("ConvertHome_then_NormalizePath_absolute_path", func(t *testing.T) {
+		// This is the exact bug scenario from the error message
+		// ~/Seafile/activitywatch/sync.yml should NOT be prepended with workdir
+
+		// First convert home directory
+		homePath, err := ConvertHome("~/Seafile/activitywatch/sync.yml")
+		assert.NoError(t, err)
+		assert.True(t, filepath.IsAbs(homePath), "ConvertHome should produce absolute path")
+
+		// Then normalize - this should NOT prepend workdir since it's already absolute
+		result := NormalizePath(homePath, testDir)
+
+		// The result should be the same as the homePath, not prepended with testDir
+		// NormalizePath converts to forward slashes, so compare normalized versions
+		expected := filepath.ToSlash(homePath)
+		actual := filepath.ToSlash(result)
+		assert.Equal(t, expected, actual, "Absolute paths should not be prepended with workdir")
+		assert.NotContains(t, result, testDir, "Absolute path should not contain workdir")
+	})
+
+	t.Run("ConvertHome_then_NormalizePath_relative_path", func(t *testing.T) {
+		// Test that relative paths still get workdir prepended
+		relativePath := "config/sync.yml"
+
+		// ConvertHome should not change relative paths
+		convertedPath, err := ConvertHome(relativePath)
+		assert.NoError(t, err)
+		assert.Equal(t, relativePath, convertedPath)
+
+		// NormalizePath should prepend workdir for relative paths
+		result := NormalizePath(convertedPath, testDir)
+		// NormalizePath converts to forward slashes, so compare normalized versions
+		normalizedTestDir := filepath.ToSlash(testDir)
+		normalizedResult := filepath.ToSlash(result)
+		assert.Contains(t, normalizedResult, normalizedTestDir, "Relative paths should be prepended with workdir")
+		assert.Contains(t, result, "config/sync.yml")
+	})
+
+	t.Run("Direct_absolute_path_normalization", func(t *testing.T) {
+		// Test direct absolute path (no tilde)
+		absPath := filepath.Join(testDir, "absolute", "sync.yml")
+		result := NormalizePath(absPath, testDir)
+
+		// Should not be prepended with workdir
+		// NormalizePath converts to forward slashes, so compare normalized versions
+		expected := filepath.ToSlash(absPath)
+		actual := filepath.ToSlash(result)
+		assert.Equal(t, expected, actual, "Direct absolute paths should not be prepended with workdir")
+		assert.NotContains(t, result, filepath.Join(testDir, testDir), "Should not double-prepend workdir")
+	})
+
+	t.Run("Direct_relative_path_normalization", func(t *testing.T) {
+		// Test direct relative path
+		relativePath := "relative/sync.yml"
+		result := NormalizePath(relativePath, testDir)
+
+		// Should be prepended with workdir
+		// NormalizePath converts to forward slashes, so compare normalized versions
+		normalizedTestDir := filepath.ToSlash(testDir)
+		normalizedResult := filepath.ToSlash(result)
+		assert.Contains(t, normalizedResult, normalizedTestDir, "Relative paths should be prepended with workdir")
+		assert.Contains(t, result, "relative/sync.yml")
+	})
+
+	t.Run("Tilde_path_edge_cases", func(t *testing.T) {
+		// Test various tilde scenarios
+		testCases := []struct {
+			input    string
+			expected string
+		}{
+			{"~/file.txt", "~/file.txt"}, // Should convert to absolute
+			{"~file.txt", "~file.txt"},   // Should NOT convert (no slash after ~)
+			{"~", "~"},                   // Should NOT convert (just tilde)
+		}
+
+		for _, tc := range testCases {
+			t.Run(fmt.Sprintf("input_%s", tc.input), func(t *testing.T) {
+				converted, err := ConvertHome(tc.input)
+				assert.NoError(t, err)
+
+				if strings.HasPrefix(tc.input, "~/") {
+					// Should be converted to absolute path
+					assert.True(t, filepath.IsAbs(converted), "Tilde paths should become absolute")
+					assert.NotContains(t, converted, "~", "Should not contain tilde after conversion")
+				} else {
+					// Should remain unchanged
+					assert.Equal(t, tc.input, converted, "Non-tilde paths should remain unchanged")
+				}
+			})
+		}
+	})
+
+	t.Run("YAML_instruction_path_resolution", func(t *testing.T) {
+		// Test the actual YAML instruction parsing with tilde paths
+		yamlContent := `
+- source: ~/Seafile/activitywatch/sync.yml
+  target: ""
+`
+
+		yamlFile := filepath.Join(testDir, "test.yaml")
+		err := os.WriteFile(yamlFile, []byte(yamlContent), 0644)
+		assert.NoError(t, err)
+
+		// Parse the YAML file
+		instructions, err := ParseYAMLFileRecursive(yamlFile, testDir)
+		assert.NoError(t, err)
+		if len(instructions) == 0 {
+			assert.Len(t, instructions, 0, "Should not create instructions for from references")
+		} else {
+			t.Log("Activitywatch sync file exists locally; skipping zero-length assertion")
+		}
+
+		// Test with actual link instruction
+		yamlContent2 := `
+- source: ~/Seafile/source/file.txt
+  target: ~/Seafile/target/file.txt
+`
+
+		yamlFile2 := filepath.Join(testDir, "test2.yaml")
+		err = os.WriteFile(yamlFile2, []byte(yamlContent2), 0644)
+		assert.NoError(t, err)
+
+		instructions2, err := ParseYAMLFileRecursive(yamlFile2, testDir)
+		if err != nil {
+			// If there's an error, it might be because the tilde path wasn't converted properly
+			// This is the bug we're trying to catch
+			t.Logf("Expected error due to path resolution bug: %v", err)
+			return
+		}
+
+		if len(instructions2) > 0 {
+			// The paths should be absolute and not prepended with workdir
+			assert.True(t, filepath.IsAbs(instructions2[0].Source), "Source should be absolute")
+			assert.True(t, filepath.IsAbs(instructions2[0].Target), "Target should be absolute")
+			assert.NotContains(t, instructions2[0].Source, testDir, "Source should not contain workdir")
+			assert.NotContains(t, instructions2[0].Target, testDir, "Target should not contain workdir")
+		}
+	})
+}