Implement undoing

To fix issue where folders were being linked as files

.gitignore

@@ -1,2 +1,4 @@
-
+*.exe
-main.exe
+*.exe
+cln
+cln.log

README.md

@@ -0,0 +1,89 @@
+# synclib
+
+A small Go tool for creating symbolic links
+
+Created out of infuriating difficulty of creating symbolic links on windows
+
+## Instruction Formats
+
+The tool supports two formats for defining symbolic links:
+
+### 1. CSV Format (Legacy)
+
+Simple comma-separated values with the format: `<source>,<destination>[,force][,hard][,delete]`
+
+For example:
+```
+source_path,target_path
+source_path,target_path,true
+source_path,target_path,true,true
+source_path,target_path,true,true,true
+```
+
+Or with named flags:
+```
+source_path,target_path,force=true,hard=true,delete=true
+source_path,target_path,f=true,h=true,d=true
+```
+
+### 2. YAML Format (Recommended)
+
+A more readable format using YAML:
+
+```yaml
+links:
+  - source: ~/Documents/config.ini
+    target: ~/.config/app/config.ini
+    force: true
+  
+  - source: ~/Pictures
+    target: ~/Documents/Pictures
+    hard: true
+    force: true
+  
+  - source: ~/Scripts/script.sh
+    target: ~/bin/script.sh
+    delete: true
+```
+
+Alternatively, you can use an array directly:
+
+```yaml
+- source: ~/Documents/config.ini
+  target: ~/.config/app/config.ini
+  force: true
+
+- source: ~/Pictures
+  target: ~/Documents/Pictures
+  hard: true
+```
+
+## Input Methods
+
+The tool supports input of these instructions through:
+
+- Stdin
+  - `echo "this,that" | sync`
+- Run arguments
+  - `sync this,that foo,bar "foo 2","C:/bar"`
+- Files
+  - `sync -f <file>` (CSV format)
+  - `sync -f <file.yaml>` or `sync -f <file.yml>` (YAML format)
+  - Where the file contains instructions, one per line for CSV or structured YAML
+- Directories
+  - `sync -r <directory>`
+  - This mode will look for "sync", "sync.yaml", or "sync.yml" files recursively in directories and run their instructions
+
+## Options
+
+- `force: true` - Overwrite an existing symbolic link at the target location
+- `hard: true` - Create a hard link instead of a symbolic link
+- `delete: true` - Delete a non-symlink file at the target location (implies `force: true`)
+
+## Use case
+
+I have a lot of folders (documents, projects, configurations) backed up via Seafile and to have the software using those folders find them at their usual location I'm creating soft symbolic links from the seafile drive to their original location
+
+It would be problematic to have to redo all (or some part) of these symlinks when reinstalling the OS or having something somewhere explode (say software uninstalled) so I have all the instructions in sync files in individual folders in the seafile drive
+
+Which means I can easily back up my configuration and `sync -r ~/Seafile` to symlink it where it belongs

colors.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"fmt"
+	"math/rand/v2"
+)
+
+const (
+	// Reset
+	Reset = "\033[0m" // Text Reset
+
+	// Regular Colors
+	Black  = "\033[0;30m" // Black
+	Red    = "\033[0;31m" // Red
+	Green  = "\033[0;32m" // Green
+	Yellow = "\033[0;33m" // Yellow
+	Blue   = "\033[0;34m" // Blue
+	Purple = "\033[0;35m" // Purple
+	Cyan   = "\033[0;36m" // Cyan
+	White  = "\033[0;37m" // White
+
+	// Bold
+	BBlack  = "\033[1;30m" // Black
+	BRed    = "\033[1;31m" // Red
+	BGreen  = "\033[1;32m" // Green
+	BYellow = "\033[1;33m" // Yellow
+	BBlue   = "\033[1;34m" // Blue
+	BPurple = "\033[1;35m" // Purple
+	BCyan   = "\033[1;36m" // Cyan
+	BWhite  = "\033[1;37m" // White
+
+	// Underline
+	UBlack  = "\033[4;30m" // Black
+	URed    = "\033[4;31m" // Red
+	UGreen  = "\033[4;32m" // Green
+	UYellow = "\033[4;33m" // Yellow
+	UBlue   = "\033[4;34m" // Blue
+	UPurple = "\033[4;35m" // Purple
+	UCyan   = "\033[4;36m" // Cyan
+	UWhite  = "\033[4;37m" // White
+
+	// Background
+	On_Black  = "\033[40m" // Black
+	On_Red    = "\033[41m" // Red
+	On_Green  = "\033[42m" // Green
+	On_Yellow = "\033[43m" // Yellow
+	On_Blue   = "\033[44m" // Blue
+	On_Purple = "\033[45m" // Purple
+	On_Cyan   = "\033[46m" // Cyan
+	On_White  = "\033[47m" // White
+
+	// High Intensty
+	IBlack  = "\033[0;90m" // Black
+	IRed    = "\033[0;91m" // Red
+	IGreen  = "\033[0;92m" // Green
+	IYellow = "\033[0;93m" // Yellow
+	IBlue   = "\033[0;94m" // Blue
+	IPurple = "\033[0;95m" // Purple
+	ICyan   = "\033[0;96m" // Cyan
+	IWhite  = "\033[0;97m" // White
+
+	// Bold High Intensty
+	BIBlack  = "\033[1;90m" // Black
+	BIRed    = "\033[1;91m" // Red
+	BIGreen  = "\033[1;92m" // Green
+	BIYellow = "\033[1;93m" // Yellow
+	BIBlue   = "\033[1;94m" // Blue
+	BIPurple = "\033[1;95m" // Purple
+	BICyan   = "\033[1;96m" // Cyan
+	BIWhite  = "\033[1;97m" // White
+
+	// High Intensty backgrounds
+	On_IBlack  = "\033[0;100m" // Black
+	On_IRed    = "\033[0;101m" // Red
+	On_IGreen  = "\033[0;102m" // Green
+	On_IYellow = "\033[0;103m" // Yellow
+	On_IBlue   = "\033[0;104m" // Blue
+	On_IPurple = "\033[10;95m" // Purple
+	On_ICyan   = "\033[0;106m" // Cyan
+	On_IWhite  = "\033[0;107m" // White
+)
+
+// 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/
+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
+
+func GenerateRandomAnsiColor() string {
+	if !shuffled {
+		rand.Shuffle(len(colors), func(i int, j int) {
+			colors[i], colors[j] = colors[j], colors[i]
+		})
+		shuffled = true
+	}
+	colorsIndex++
+	return fmt.Sprintf("\033[1;4;38;5;%dm", colors[colorsIndex%len(colors)])
+}

deploy.sh

@@ -1 +1,2 @@
-go build main && cp main.exe "/c/Program Files/Git/usr/bin/cln.exe"
+GOOS=windows GOARCH=amd64 go build -o main.exe main && cp main.exe "/c/Program Files/Git/usr/bin/cln.exe"
+GOOS=linux GOARCH=amd64 go build -o main_linux main

go.mod

@@ -1,3 +1,5 @@
-module main
+module cln
 
 go 1.21.7
+
+require gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -0,0 +1,4 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

instruction.go

@@ -1,132 +1,341 @@
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-	"log"
+	"os"
-	"os"
+	"path/filepath"
-	"regexp"
+	"slices"
-	"strconv"
+	"strings"
-	"strings"
+
-)
+	"gopkg.in/yaml.v3"
-
+)
-type LinkInstruction struct {
+
-	Source string
+type LinkInstruction struct {
-	Target string
+	Source string `yaml:"source"`
-	Force  bool
+	Target string `yaml:"target"`
-}
+	Force  bool   `yaml:"force,omitempty"`
-
+	Hard   bool   `yaml:"hard,omitempty"`
-func (instruction *LinkInstruction) String() string {
+	Delete bool   `yaml:"delete,omitempty"`
-	return fmt.Sprintf("%s%s%s%s%s%s%s%s%s", SourceColor, instruction.Source, DefaultColor, deliminer, TargetColor, instruction.Target, DefaultColor, deliminer, strconv.FormatBool(instruction.Force))
+}
-}
+
-
+type YAMLConfig struct {
-func ParseInstruction(line string) (LinkInstruction, error) {
+	Links []LinkInstruction `yaml:"links"`
-	parts := strings.Split(line, deliminer)
+}
-	instruction := LinkInstruction{}
+
-
+func (instruction *LinkInstruction) Tidy() {
-	if len(parts) < 2 {
+	instruction.Source = strings.ReplaceAll(instruction.Source, "\"", "")
-		return instruction, fmt.Errorf("invalid format - not enough parameters (must have at least source and target)")
+	instruction.Source = strings.ReplaceAll(instruction.Source, "\\", "/")
-	}
+	instruction.Source = strings.TrimSpace(instruction.Source)
-
+
-	instruction.Source = parts[0]
+	instruction.Target = strings.ReplaceAll(instruction.Target, "\"", "")
-	instruction.Target = parts[1]
+	instruction.Target = strings.ReplaceAll(instruction.Target, "\\", "/")
-	instruction.Force = false
+	instruction.Target = strings.TrimSpace(instruction.Target)
-	if len(parts) > 2 {
+}
-		res, _ := regexp.MatchString("^(?i)T|TRUE$", parts[2])
+
-		instruction.Force = res
+func (instruction *LinkInstruction) String() string {
-	}
+	var flags []string
-
+	if instruction.Force {
-	instruction.Source, _ = ConvertHome(instruction.Source)
+		flags = append(flags, "force=true")
-	instruction.Target, _ = ConvertHome(instruction.Target)
+	}
-
+	if instruction.Hard {
-	instruction.Source = NormalizePath(instruction.Source)
+		flags = append(flags, "hard=true")
-	instruction.Target = NormalizePath(instruction.Target)
+	}
-
+	if instruction.Delete {
-	return instruction, nil
+		flags = append(flags, "delete=true")
-}
+	}
-
+
-func (instruction *LinkInstruction) RunSync() error {
+	flagsStr := ""
-	if !FileExists(instruction.Source) {
+	if len(flags) > 0 {
-		return fmt.Errorf("instruction source %s%s%s does not exist", SourceColor, instruction.Source, DefaultColor)
+		flagsStr = " [" + strings.Join(flags, ", ") + "]"
-	}
+	}
-
+
-	if AreSame(instruction.Source, instruction.Target) {
+	return fmt.Sprintf("%s → %s%s",
-		log.Printf("Source %s%s%s and target %s%s%s are the same, %snothing to do...%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, PathColor, DefaultColor)
+		FormatSourcePath(instruction.Source),
-		return nil
+		FormatTargetPath(instruction.Target),
-	}
+		flagsStr)
-
+}
-	if FileExists(instruction.Target) {
+
-		if instruction.Force {
+func (instruction *LinkInstruction) Undo() {
-			isSymlink, err := IsSymlink(instruction.Target)
+	if !FileExists(instruction.Target) {
-			if err != nil {
+		return
-				return fmt.Errorf("could not determine whether %s%s%s is a sym link or not, stopping; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+	}
-			}
+
-
+	isSymlink, err := IsSymlink(instruction.Target)
-			if isSymlink {
+	if err != nil {
-				log.Printf("Removing symlink at %s%s%s", TargetColor, instruction.Target, DefaultColor)
+		LogError("could not determine whether %s is a sym link or not, stopping; err: %v",
-				err = os.Remove(instruction.Target)
+			FormatTargetPath(instruction.Target), err)
-				if err != nil {
+		return
-					return fmt.Errorf("failed deleting %s%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+	}
-				}
+
-			} else {
+	if isSymlink {
-				return fmt.Errorf("refusing to delte actual (non symlink) file %s%s%s", TargetColor, instruction.Target, DefaultColor)
+		LogInfo("Removing symlink at %s", FormatTargetPath(instruction.Target))
-			}
+		err = os.Remove(instruction.Target)
-		} else {
+		if err != nil {
-			return fmt.Errorf("target %s%s%s exists - handle manually or set the 'forced' flag (3rd field)", TargetColor, instruction.Target, DefaultColor)
+			LogError("could not remove symlink at %s; err: %v",
-		}
+				FormatTargetPath(instruction.Target), err)
-	}
+		}
-
+	} else {
-	err := os.Symlink(instruction.Source, instruction.Target)
+		LogInfo("%s is not a symlink, skipping", FormatTargetPath(instruction.Target))
-	if err != nil {
+	}
-		return fmt.Errorf("failed creating symlink between %s%s%s and %s%s%s with error %s%+v%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+}
-	}
+
-	log.Printf("Created symlink between %s%s%s and %s%s%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor)
+func ParseInstruction(line, workdir string) (LinkInstruction, error) {
-
+	line = strings.TrimSpace(line)
-	return nil
+	if strings.HasPrefix(line, "#") {
-}
+		return LinkInstruction{}, fmt.Errorf("comment line")
-
+	}
-func (instruction *LinkInstruction) RunAsync(status chan (error)) {
+
-	defer close(status)
+	parts := strings.Split(line, deliminer)
-	if !FileExists(instruction.Source) {
+	instruction := LinkInstruction{}
-		status <- fmt.Errorf("instruction source %s%s%s does not exist", SourceColor, instruction.Source, DefaultColor)
+
-		return
+	if len(parts) < 2 {
-	}
+		return instruction, fmt.Errorf("invalid format - not enough parameters (must have at least source and target)")
-
+	}
-	if AreSame(instruction.Source, instruction.Target) {
+
-		status <- fmt.Errorf("source %s%s%s and target %s%s%s are the same, %snothing to do...%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, PathColor, DefaultColor)
+	instruction.Source = strings.TrimSpace(parts[0])
-		return
+	instruction.Target = strings.TrimSpace(parts[1])
-	}
+
-
+	for i := 2; i < len(parts); i++ {
-	if FileExists(instruction.Target) {
+		flagPart := strings.TrimSpace(parts[i])
-		if instruction.Force {
+
-			isSymlink, err := IsSymlink(instruction.Target)
+		// Support for legacy format (backward compatibility)
-			if err != nil {
+		if !strings.Contains(flagPart, "=") {
-				status <- fmt.Errorf("could not determine whether %s%s%s is a sym link or not, stopping; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+			// Legacy format: positional boolean flags
-				return
+			switch i {
-			}
+			case 2: // Force flag (3rd position)
-
+				instruction.Force = isTrue(flagPart)
-			if isSymlink {
+			case 3: // Hard flag (4th position)
-				log.Printf("Removing symlink at %s%s%s", TargetColor, instruction.Target, DefaultColor)
+				instruction.Hard = isTrue(flagPart)
-				err = os.Remove(instruction.Target)
+			case 4: // Delete flag (5th position)
-				if err != nil {
+				instruction.Delete = isTrue(flagPart)
-					status <- fmt.Errorf("failed deleting %s%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+				if instruction.Delete {
-					return
+					instruction.Force = true // Delete implies Force
-				}
+				}
-			} else {
+			}
-				status <- fmt.Errorf("refusing to delte actual (non symlink) file %s%s%s", TargetColor, instruction.Target, DefaultColor)
+			continue
-				return
+		}
-			}
+
-		} else {
+		// New format: named flags (name=value)
-			status <- fmt.Errorf("target %s%s%s exists - handle manually or set the 'forced' flag (3rd field)", TargetColor, instruction.Target, DefaultColor)
+		nameValue := strings.SplitN(flagPart, "=", 2)
-			return
+		if len(nameValue) != 2 {
-		}
+			// Skip malformed flags
-	}
+			continue
-
+		}
-	err := os.Symlink(instruction.Source, instruction.Target)
+
-	if err != nil {
+		flagName := strings.ToLower(strings.TrimSpace(nameValue[0]))
-		status <- fmt.Errorf("failed creating symlink between %s%s%s and %s%s%s with error %s%+v%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+		flagValue := strings.TrimSpace(nameValue[1])
-		return
+
-	}
+		switch flagName {
-	log.Printf("Created symlink between %s%s%s and %s%s%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor)
+		case "force", "f":
-
+			instruction.Force = isTrue(flagValue)
-	status <- nil
+		case "hard", "h":
-}
+			instruction.Hard = isTrue(flagValue)
+		case "delete", "d":
+			instruction.Delete = isTrue(flagValue)
+			if instruction.Delete {
+				instruction.Force = true // Delete implies Force
+			}
+		}
+	}
+
+	instruction.Tidy()
+	instruction.Source, _ = ConvertHome(instruction.Source)
+	instruction.Target, _ = ConvertHome(instruction.Target)
+
+	instruction.Source = NormalizePath(instruction.Source, workdir)
+	instruction.Target = NormalizePath(instruction.Target, workdir)
+
+	return instruction, nil
+}
+
+func isTrue(value string) bool {
+	value = strings.ToLower(strings.TrimSpace(value))
+	return value == "true" || value == "t" || value == "yes" || value == "y" || value == "1"
+}
+
+func (instruction *LinkInstruction) RunAsync(status chan (error)) {
+	defer close(status)
+	if undo {
+		instruction.Undo()
+		return
+	}
+
+	if !FileExists(instruction.Source) {
+		status <- fmt.Errorf("instruction source %s does not exist", 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),
+			FormatTargetPath(instruction.Target))
+		return
+	}
+
+	if FileExists(instruction.Target) {
+		if instruction.Force {
+			isSymlink, err := IsSymlink(instruction.Target)
+			if err != nil {
+				status <- fmt.Errorf("could not determine whether %s is a sym link or not, stopping; err: %v",
+					FormatTargetPath(instruction.Target), err)
+				return
+			}
+
+			if instruction.Hard {
+				info, err := os.Stat(instruction.Target)
+				if err != nil {
+					status <- fmt.Errorf("could not stat %s, stopping; err: %v",
+						FormatTargetPath(instruction.Target), err)
+					return
+				}
+				if info.Mode().IsRegular() && info.Name() == filepath.Base(instruction.Source) {
+					LogTarget("Overwriting existing file %s", instruction.Target)
+					err := os.Remove(instruction.Target)
+					if err != nil {
+						status <- fmt.Errorf("could not remove existing file %s; err: %v",
+							FormatTargetPath(instruction.Target), err)
+						return
+					}
+				}
+			}
+
+			if isSymlink {
+				LogTarget("Removing symlink at %s", instruction.Target)
+				err = os.Remove(instruction.Target)
+				if err != nil {
+					status <- fmt.Errorf("failed deleting %s due to %v",
+						FormatTargetPath(instruction.Target), err)
+					return
+				}
+			} else {
+				if !instruction.Delete {
+					status <- fmt.Errorf("refusing to delte actual (non symlink) file %s",
+						FormatTargetPath(instruction.Target))
+					return
+				}
+				LogImportant("Deleting (!!!) %s", instruction.Target)
+				err = os.RemoveAll(instruction.Target)
+				if err != nil {
+					status <- fmt.Errorf("failed deleting %s due to %v",
+						FormatTargetPath(instruction.Target), err)
+					return
+				}
+			}
+		} else {
+			status <- fmt.Errorf("target %s exists - handle manually or set the 'forced' flag (3rd field)",
+				FormatTargetPath(instruction.Target))
+			return
+		}
+	}
+
+	targetDir := filepath.Dir(instruction.Target)
+	if _, err := os.Stat(targetDir); os.IsNotExist(err) {
+		err = os.MkdirAll(targetDir, 0755)
+		if err != nil {
+			status <- fmt.Errorf("failed creating directory %s due to %v",
+				FormatTargetPath(targetDir), err)
+			return
+		}
+	}
+
+	var err error
+	if instruction.Hard {
+		err = os.Link(instruction.Source, instruction.Target)
+	} else {
+		err = os.Symlink(instruction.Source, instruction.Target)
+	}
+	if err != nil {
+		status <- fmt.Errorf("failed creating symlink between %s and %s with error %v",
+			FormatSourcePath(instruction.Source),
+			FormatTargetPath(instruction.Target),
+			err)
+		return
+	}
+	LogInfo("Created symlink between %s and %s",
+		FormatSourcePath(instruction.Source),
+		FormatTargetPath(instruction.Target))
+
+	status <- nil
+}
+
+func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, fmt.Errorf("error reading YAML file: %w", err)
+	}
+
+	// First try to parse as a list of link instructions
+	var config YAMLConfig
+	err = yaml.Unmarshal(data, &config)
+	if err != nil || len(config.Links) == 0 {
+		// If that fails, try parsing as a direct list of instructions
+		var instructions []LinkInstruction
+		err = yaml.Unmarshal(data, &instructions)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing YAML: %w", err)
+		}
+		config.Links = instructions
+	}
+
+	toRemove := []int{}
+	for i, link := range config.Links {
+		if strings.Contains(link.Source, "*") {
+			LogSource("Expanding wildcard source %s in YAML file %s", link.Source, filename)
+			newlinks, err := ExpandWildcard(link.Source, workdir, link.Target)
+			if err != nil {
+				return nil, fmt.Errorf("error expanding wildcard: %w", err)
+			}
+			LogInfo("Expanded wildcard source %s in YAML file %s to %d links",
+				FormatSourcePath(link.Source), FormatSourcePath(filename), len(newlinks))
+			config.Links = append(config.Links, newlinks...)
+			toRemove = append(toRemove, i)
+		}
+	}
+
+	for i := len(toRemove) - 1; i >= 0; i-- {
+		config.Links = slices.Delete(config.Links, toRemove[i], 1)
+	}
+
+	for i := range config.Links {
+		link := &config.Links[i]
+
+		link.Tidy()
+		link.Source, _ = ConvertHome(link.Source)
+		link.Target, _ = ConvertHome(link.Target)
+		link.Source = NormalizePath(link.Source, workdir)
+		link.Target = NormalizePath(link.Target, workdir)
+
+		// If Delete is true, Force must also be true
+		if config.Links[i].Delete {
+			config.Links[i].Force = true
+		}
+	}
+
+	return config.Links, nil
+}
+
+func ExpandWildcard(source, workdir, target string) (links []LinkInstruction, err error) {
+	dir := filepath.Dir(source)
+	pattern := filepath.Base(source)
+
+	files, err := filepath.Glob(filepath.Join(workdir, dir, pattern))
+	if err != nil {
+		return nil, fmt.Errorf("error expanding wildcard: %w", err)
+	}
+
+	for _, file := range files {
+		link := LinkInstruction{
+			Source: file,
+			Target: filepath.Join(target, filepath.Base(file)),
+		}
+		links = append(links, link)
+	}
+
+	LogInfo("Expanded wildcard source %s to %d links", FormatSourcePath(source), len(links))
+	return
+}
+
+func IsYAMLFile(filename string) bool {
+	ext := strings.ToLower(filepath.Ext(filename))
+	return ext == ".yaml" || ext == ".yml"
+}

logger.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"fmt"
+	"log"
+)
+
+// Message type prefixes
+const (
+	InfoPrefix      = "INFO"
+	ErrorPrefix     = "ERROR"
+	WarningPrefix   = "WARN"
+	SourcePrefix    = "SOURCE"
+	TargetPrefix    = "TARGET"
+	PathPrefix      = "PATH"
+	ImportantPrefix = "IMPORTANT"
+)
+
+// LogInfo logs an informational message
+func LogInfo(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s", BGreen, InfoPrefix, Reset, message)
+}
+
+// LogSource logs a message about a source file/path with proper coloring
+func LogSource(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s%s%s", BPurple, SourcePrefix, Reset, SourceColor, message, Reset)
+}
+
+// LogTarget logs a message about a target file/path with proper coloring
+func LogTarget(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s%s%s", BYellow, TargetPrefix, Reset, TargetColor, message, Reset)
+}
+
+// LogPath logs a message about a path with proper coloring
+func LogPath(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s%s%s", BGreen, PathPrefix, Reset, PathColor, message, Reset)
+}
+
+// LogImportant logs a message that needs attention with proper coloring
+func LogImportant(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s%s%s", BRed, ImportantPrefix, Reset, ImportantColor, message, Reset)
+}
+
+// LogError logs an error message with proper coloring that won't be cut off
+func LogError(format string, args ...interface{}) {
+	// Format the message first with normal text (no red coloring)
+	message := fmt.Sprintf(format, args...)
+
+	// The Error prefix itself is bold red on a light background for maximum visibility
+	prefix := fmt.Sprintf("%s%s[%s]%s ", BRed, On_White, ErrorPrefix, Reset)
+
+	// The message is in default color (no red), only the [ERROR] prefix is colored
+	log.Printf("%s%s", prefix, message)
+}
+
+// FormatSourcePath returns a source path with proper coloring
+func FormatSourcePath(path string) string {
+	return fmt.Sprintf("%s%s%s", SourceColor, path, Reset)
+}
+
+// FormatTargetPath returns a target path with proper coloring
+func FormatTargetPath(path string) string {
+	return fmt.Sprintf("%s%s%s", TargetColor, path, Reset)
+}
+
+// FormatPathValue returns a path with proper coloring
+func FormatPathValue(path string) string {
+	return fmt.Sprintf("%s%s%s", PathColor, path, Reset)
+}
+
+// FormatErrorValue returns an error value without any additional formatting
+// Since error messages are no longer red, we don't need special formatting
+func FormatErrorValue(err error) string {
+	if err == nil {
+		return ""
+	}
+	// Just return the error string with no color formatting
+	return fmt.Sprintf("%v", err)
+}
+
+// FormatErrorMessage formats an error message with no additional color formatting,
+// while preserving the special formatting of embedded source/target/path elements.
+func FormatErrorMessage(format string, args ...interface{}) string {
+	// This just formats the message with no additional color formatting
+	// The path formatting will still be preserved
+	return fmt.Sprintf(format, args...)
+}

main.go

@@ -1,238 +1,267 @@
-package main
+package main
-
+
-import (
+import (
-	"bufio"
+	"bufio"
-	"flag"
+	"flag"
-	"io"
+	"io"
-	"log"
+	"log"
-	"os"
+	"os"
-	"regexp"
+	"path/filepath"
-	"sync"
+	"regexp"
-	"sync/atomic"
+	"sync"
-)
+	"sync/atomic"
-
+)
-const deliminer = ","
+
-const (
+const deliminer = ","
-	Black   = "\033[30m"
+const SourceColor = Purple
-	Red     = "\033[31m"
+const TargetColor = Yellow
-	Green   = "\033[32m"
+const ErrorColor = Red
-	Yellow  = "\033[33m"
+const ImportantColor = BRed
-	Blue    = "\033[34m"
+const DefaultColor = Reset
-	Magenta = "\033[35m"
+const PathColor = Green
-	Cyan    = "\033[36m"
+
-	White   = "\033[37m"
+var FileRegex, _ = regexp.Compile(`sync\.ya?ml$`)
-)
+var programName = os.Args[0]
-const SourceColor = Magenta
+var undo = false
-const TargetColor = Yellow
+
-const ErrorColor = Red
+func main() {
-const DefaultColor = White
+	recurse := flag.String("r", "", "recurse into directories")
-const PathColor = Green
+	file := flag.String("f", "", "file to read instructions from")
-
+	debug := flag.Bool("d", false, "debug")
-var DirRegex, _ = regexp.Compile(`^(.+?)[/\\]sync$`)
+	undoF := flag.Bool("u", false, "undo")
-var FileRegex, _ = regexp.Compile(`^sync$`)
+	flag.Parse()
-var programName = os.Args[0]
+	undo = *undoF
-
+
-func main() {
+	if *debug {
-	recurse := flag.String("r", "", "recurse into directories")
+		log.SetFlags(log.Lmicroseconds | log.Lshortfile)
-	file := flag.String("f", "", "file to read instructions from")
+		logFile, err := os.Create(programName + ".log")
-	debug := flag.Bool("d", false, "debug")
+		if err != nil {
-	flag.Parse()
+			LogError("Error creating log file: %v", err)
-
+			os.Exit(1)
-	if *debug {
+		}
-		log.SetFlags(log.Lmicroseconds | log.Lshortfile)
+		logger := io.MultiWriter(os.Stdout, logFile)
-		logFile, err := os.Create("main.log")
+		log.SetOutput(logger)
-		if err != nil {
+	} else {
-			log.Printf("Error creating log file: %v", err)
+		log.SetFlags(log.Lmicroseconds)
-			os.Exit(1)
+	}
-		}
+
-		logger := io.MultiWriter(os.Stdout, logFile)
+	instructions := make(chan *LinkInstruction, 1000)
-		log.SetOutput(logger)
+	status := make(chan error)
-	} else {
+
-		log.SetFlags(log.Lmicroseconds)
+	// Check input sources in priority order
-	}
+	switch {
-
+	case *recurse != "":
-	log.Printf("Recurse: %s", *recurse)
+		LogInfo("Recurse: %s", *recurse)
-	log.Printf("File: %s", *file)
+		go ReadFromFilesRecursively(*recurse, instructions, status)
-
+
-	instructions := make(chan LinkInstruction, 1000)
+	case *file != "":
-	status := make(chan error)
+		LogInfo("File: %s", *file)
-	if *recurse != "" {
+		go ReadFromFile(*file, instructions, status, true)
-		go ReadFromFilesRecursively(*recurse, instructions, status)
+
-	} else if *file != "" {
+	case len(flag.Args()) > 0:
-		go ReadFromFile(*file, instructions, status, true)
+		LogInfo("Reading from command line arguments")
-	} else if len(os.Args) > 1 {
+		go ReadFromArgs(instructions, status)
-		go ReadFromArgs(instructions, status)
+
-	} else {
+	case IsPipeInput():
-		go ReadFromStdin(instructions, status)
+		LogInfo("Reading from stdin pipe")
-	}
+		go ReadFromStdin(instructions, status)
-
+
-	go func() {
+	default:
-		for {
+		if _, err := os.Stat("sync.yaml"); err == nil {
-			err, ok := <-status
+			LogInfo("Using default sync.yaml file")
-			if !ok {
+			go ReadFromFile("sync.yaml", instructions, status, true)
-				break
+		} else if _, err := os.Stat("sync.yml"); err == nil {
-			}
+			LogInfo("Using default sync.yml file")
-			if err != nil {
+			go ReadFromFile("sync.yml", instructions, status, true)
-				log.Println(err)
+		} else {
-			}
+			LogInfo("No input provided")
-		}
+			LogInfo("Provide input as: ")
-	}()
+			LogInfo("Arguments - %s <source>,<target>,<force?>", programName)
-
+			LogInfo("File - %s -f <file>", programName)
-	var instructionsDone int32
+			LogInfo("YAML File - %s -f <file.yaml>", programName)
-	var wg sync.WaitGroup
+			LogInfo("Folder (finding sync files in folder recursively) - %s -r <folder>", programName)
-	for {
+			LogInfo("stdin - (cat <file> | %s)", programName)
-		instruction, ok := <-instructions
+			os.Exit(1)
-		if !ok {
+		}
-			log.Printf("No more instructions to process")
+	}
-			break
+
-		}
+	go func() {
-		log.Printf("Processing: %s", instruction.String())
+		for {
-		status := make(chan error)
+			err, ok := <-status
-		go instruction.RunAsync(status)
+			if !ok {
-		wg.Add(1)
+				break
-		err := <-status
+			}
-		if err != nil {
+			if err != nil {
-			log.Printf("Failed parsing instruction %s%s%s due to %s%+v%s", SourceColor, instruction.String(), DefaultColor, ErrorColor, err, DefaultColor)
+				LogError("%v", err)
-		}
+			}
-		atomic.AddInt32(&instructionsDone, 1)
+		}
-		wg.Done()
+	}()
-	}
+
-	wg.Wait()
+	var instructionsDone int32 = 0
-	log.Println("All done")
+	var wg sync.WaitGroup
-	if instructionsDone == 0 {
+	for {
-		log.Printf("No input provided")
+		instruction, ok := <-instructions
-		log.Printf("Provide input as: ")
+		if !ok {
-		log.Printf("Arguments - %s <source>,<target>,<force?>", programName)
+			LogInfo("No more instructions to process")
-		log.Printf("File - %s -f <file>", programName)
+			break
-		log.Printf("Folder (finding sync files in folder recursively) - %s -r <folder>", programName)
+		}
-		log.Printf("stdin - (cat <file> | %s)", programName)
+		LogInfo("Processing: %s", instruction.String())
-		os.Exit(1)
+		status := make(chan error)
-	}
+		go instruction.RunAsync(status)
-}
+		wg.Add(1)
-
+		err := <-status
-func ReadFromFilesRecursively(input string, output chan LinkInstruction, status chan error) {
+		if err != nil {
-	defer close(output)
+			LogError("Failed processing instruction: %v", err)
-	defer close(status)
+		}
-
+		atomic.AddInt32(&instructionsDone, 1)
-	input = NormalizePath(input)
+		wg.Done()
-	log.Printf("Reading input from files recursively starting in %s%s%s", PathColor, input, DefaultColor)
+	}
-
+	wg.Wait()
-	files := make(chan string, 128)
+	if instructionsDone == 0 {
-	recurseStatus := make(chan error)
+		LogInfo("No instructions were processed")
-	go GetSyncFilesRecursively(input, files, recurseStatus)
+		os.Exit(1)
-	go func() {
+	}
-		for {
+	LogInfo("All done")
-			err, ok := <-recurseStatus
+}
-			if !ok {
+
-				break
+func IsPipeInput() bool {
-			}
+	info, err := os.Stdin.Stat()
-			if err != nil {
+	if err != nil {
-				log.Printf("Failed to get sync files recursively: %s%+v%s", ErrorColor, err, DefaultColor)
+		return false
-				status <- err
+	}
-			}
+	return info.Mode()&os.ModeNamedPipe != 0
-		}
+}
-	}()
+
-
+func ReadFromFilesRecursively(input string, output chan *LinkInstruction, status chan error) {
-	var wg sync.WaitGroup
+	defer close(output)
-	for {
+	defer close(status)
-		file, ok := <-files
+
-		if !ok {
+	workdir, _ := os.Getwd()
-			log.Printf("No more files to process")
+	input = NormalizePath(input, workdir)
-			break
+	LogInfo("Reading input from files recursively starting in %s", FormatPathValue(input))
-		}
+
-		wg.Add(1)
+	files := make(chan string, 128)
-		go func() {
+	fileStatus := make(chan error)
-			defer wg.Done()
+	var wg sync.WaitGroup
-			log.Println(file)
+	go GetSyncFilesRecursively(input, files, fileStatus)
-			file = NormalizePath(file)
+	go func() {
-			log.Printf("Processing file: %s%s%s", PathColor, file, DefaultColor)
+		wg.Wait()
-
+		close(files)
-			// This "has" to be done because instructions are resolved in relation to cwd
+	}()
-			fileDir := DirRegex.FindStringSubmatch(file)
+
-			if fileDir == nil {
+	go func() {
-				log.Printf("Failed to extract directory from %s%s%s", SourceColor, file, DefaultColor)
+		for {
-				return
+			err, ok := <-fileStatus
-			}
+			if !ok {
-			log.Printf("Changing directory to %s%s%s (for %s%s%s)", PathColor, fileDir[1], DefaultColor, PathColor, file, DefaultColor)
+				break
-			err := os.Chdir(fileDir[1])
+			}
-			if err != nil {
+			if err != nil {
-				log.Printf("Failed to change directory to %s%s%s: %s%+v%s", SourceColor, fileDir[1], DefaultColor, ErrorColor, err, DefaultColor)
+				LogError("Failed to get sync files recursively: %v", err)
-				return
+				status <- err
-			}
+			}
-
+		}
-			ReadFromFile(file, output, status, false)
+	}()
-		}()
+
-	}
+	for {
-	wg.Wait()
+		file, ok := <-files
-}
+		if !ok {
-func ReadFromFile(input string, output chan LinkInstruction, status chan error, doclose bool) {
+			LogInfo("No more files to process")
-	if doclose {
+			break
-		defer close(output)
+		}
-		defer close(status)
+		wg.Add(1)
-	}
+		go func() {
-
+			defer wg.Done()
-	input = NormalizePath(input)
+			LogInfo(file)
-	log.Printf("Reading input from file: %s%s%s", PathColor, input, DefaultColor)
+			file = NormalizePath(file, workdir)
-	file, err := os.Open(input)
+			LogInfo("Processing file: %s", FormatPathValue(file))
-	if err != nil {
+
-		log.Fatalf("Failed to open file %s%s%s: %s%+v%s", SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor)
+			// This "has" to be done because instructions are resolved in relation to cwd
-		return
+			fileDir := FileRegex.FindStringSubmatch(file)
-	}
+			if fileDir == nil {
-	defer file.Close()
+				LogError("Failed to extract directory from %s", FormatSourcePath(file))
-
+				return
-	scanner := bufio.NewScanner(file)
+			}
-	for scanner.Scan() {
+			LogInfo("Changing directory to %s (for %s)",
-		line := scanner.Text()
+				FormatPathValue(fileDir[1]),
-		instruction, err := ParseInstruction(line)
+				FormatPathValue(file))
-		if err != nil {
+			err := os.Chdir(fileDir[1])
-			log.Printf("Error parsing line: %s'%s'%s, error: %s%+v%s", SourceColor, line, DefaultColor, ErrorColor, err, DefaultColor)
+			if err != nil {
-			continue
+				LogError("Failed to change directory to %s: %v",
-		}
+					FormatSourcePath(fileDir[1]), err)
-		log.Printf("Read instruction: %s", instruction.String())
+				return
-		output <- instruction
+			}
-	}
+			ReadFromFile(file, output, status, false)
-}
+			// Don't return directory, stay where we are
-func ReadFromArgs(output chan LinkInstruction, status chan error) {
+			os.Chdir(workdir)
-	defer close(output)
+		}()
-	defer close(status)
+	}
-
+}
-	log.Printf("Reading input from args")
+
-	for _, arg := range os.Args[1:] {
+func ReadFromFile(input string, output chan *LinkInstruction, status chan error, doclose bool) {
-		instruction, err := ParseInstruction(arg)
+	if doclose {
-		if err != nil {
+		defer close(output)
-			log.Printf("Error parsing arg: %s'%s'%s, error: %s%+v%s", SourceColor, arg, DefaultColor, ErrorColor, err, DefaultColor)
+		defer close(status)
-			continue
+	}
-		}
+
-		output <- instruction
+	input = NormalizePath(input, filepath.Dir(input))
-	}
+	LogInfo("Reading input from file: %s", FormatPathValue(input))
-}
+
-func ReadFromStdin(output chan LinkInstruction, status chan error) {
+	// Check if this is a YAML file
-	defer close(output)
+	if IsYAMLFile(input) {
-	defer close(status)
+		LogInfo("Parsing as YAML file")
-
+		instructions, err := ParseYAMLFile(input, filepath.Dir(input))
-	log.Printf("Reading input from stdin")
+		if err != nil {
-
+			LogError("Failed to parse YAML file %s: %v",
-	info, err := os.Stdin.Stat()
+				FormatSourcePath(input), err)
-	if err != nil {
+			status <- err
-		log.Fatalf("Failed to stat stdin: %s%+v%s", ErrorColor, err, DefaultColor)
+			return
-		status <- err
+		}
-		return
+
-	}
+		for _, instruction := range instructions {
-	if info.Mode()&os.ModeNamedPipe != 0 {
+			instr := instruction // Create a copy to avoid reference issues
-		scanner := bufio.NewScanner(os.Stdin)
+			LogInfo("Read YAML instruction: %s", instr.String())
-		for scanner.Scan() {
+			output <- &instr
-			line := scanner.Text()
+		}
-			instruction, err := ParseInstruction(line)
+		return
-			if err != nil {
+	}
-				log.Printf("Error parsing line: %s'%s'%s, error: %s%+v%s", SourceColor, line, DefaultColor, ErrorColor, err, DefaultColor)
+}
-				continue
+
-			}
+func ReadFromArgs(output chan *LinkInstruction, status chan error) {
-			output <- instruction
+	defer close(output)
-		}
+	defer close(status)
-		if err := scanner.Err(); err != nil {
+
-			log.Fatalf("Error reading from stdin: %s%+v%s", ErrorColor, err, DefaultColor)
+	workdir, _ := os.Getwd()
-			status <- err
+	LogInfo("Reading input from args")
-			return
+	for _, arg := range flag.Args() {
-		}
+		instruction, err := ParseInstruction(arg, workdir)
-	}
+		if err != nil {
-}
+			LogError("Error parsing arg '%s': %v", arg, err)
+			continue
+		}
+		output <- &instruction
+	}
+}
+
+func ReadFromStdin(output chan *LinkInstruction, status chan error) {
+	defer close(output)
+	defer close(status)
+
+	workdir, _ := os.Getwd()
+	LogInfo("Reading input from stdin")
+
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		instruction, err := ParseInstruction(line, workdir)
+		if err != nil {
+			LogError("Error parsing line '%s': %v", line, err)
+			continue
+		}
+		output <- &instruction
+	}
+	if err := scanner.Err(); err != nil {
+		LogError("Error reading from stdin: %v", err)
+		status <- err
+		return
+	}
+}

sync

@@ -1 +0,0 @@
-test,testdir/test3

sync.yaml

@@ -0,0 +1,2 @@
+- source: \*
+  target: test/

sync.yaml.example

@@ -0,0 +1,26 @@
+# Example sync.yaml file
+# You can use this format to define symbolic links
+# Each link specifies source, target, and optional flags
+links:
+  - source: ~/Documents/config.ini
+    target: ~/.config/app/config.ini
+    # This will create a symbolic link, overwriting any existing symlink
+    force: true
+  
+  - source: ~/Pictures
+    target: ~/Documents/Pictures
+    # This will create a hard link instead of a symbolic link
+    hard: true
+    force: true
+  
+  - source: ~/Scripts/script.sh
+    target: ~/bin/script.sh
+    # This will delete a non-symlink file at the target location
+    # 'delete: true' implies 'force: true'
+    delete: true
+
+# Alternative format:
+# Instead of using the 'links' property, you can define an array directly:
+# - source: ~/Documents/config.ini
+#   target: ~/.config/app/config.ini
+#   force: true 

synclib.log

@@ -0,0 +1,26 @@
+18:24:37.967093 Using default sync.yaml file
+18:24:37.967093 Input 'sync.yaml' is not absolute, prepending work dir '.'
+18:24:37.967593 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
+18:24:37.967593 Parsing as YAML file
+18:24:37.967593 Failed to parse YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml: error unmarshaling YAML: yaml: unmarshal errors:
+  line 1: cannot unmarshal !!seq into main.YAMLConfig
+18:24:37.967593 No more instructions to process
+18:24:37.968092 No instructions were processed
+18:27:59.691333 Using default sync.yaml file
+18:27:59.691333 Input 'sync.yaml' is not absolute, prepending work dir '.'
+18:27:59.691834 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
+18:27:59.691834 Parsing as YAML file
+18:27:59.692335 Expanding wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
+18:27:59.692335 Expanded wildcard source \* to 0 links
+18:27:59.692836 Expanded wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml to 0 links
+18:27:59.692836 No more instructions to process
+18:27:59.692836 No instructions were processed
+18:28:04.075821 Using default sync.yaml file
+18:28:04.076320 Input 'sync.yaml' is not absolute, prepending work dir '.'
+18:28:04.076320 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
+18:28:04.076320 Parsing as YAML file
+18:28:04.076320 Expanding wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
+18:28:04.076821 Expanded wildcard source \* to 0 links
+18:28:04.076821 Expanded wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml to 0 links
+18:28:04.076821 No more instructions to process
+18:28:04.076821 No instructions were processed

util.go

@@ -1,132 +1,187 @@
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-	"log"
+	"os"
-	"os"
+	"path/filepath"
-	"path/filepath"
+	"strings"
-	"strings"
+	"sync"
-	"sync"
+	"sync/atomic"
-	"sync/atomic"
+	"time"
-	"time"
+)
-)
+
-
+func IsSymlink(path string) (bool, error) {
-func IsSymlink(path string) (bool, error) {
+	fileInfo, err := os.Lstat(path)
-	fileInfo, err := os.Lstat(path)
+	if err != nil {
-	if err != nil {
+		return false, err
-		return false, err
+	}
-	}
+
-
+	// os.ModeSymlink is a bitmask that identifies the symlink mode.
-	// os.ModeSymlink is a bitmask that identifies the symlink mode.
+	// If the file mode & os.ModeSymlink is non-zero, the file is a symlink.
-	// If the file mode & os.ModeSymlink is non-zero, the file is a symlink.
+	return fileInfo.Mode()&os.ModeSymlink != 0, nil
-	return fileInfo.Mode()&os.ModeSymlink != 0, nil
+}
-}
+
-
+func FileExists(path string) bool {
-func FileExists(path string) bool {
+	_, err := os.Lstat(path)
-	_, err := os.Lstat(path)
+	return err == nil
-	return err == nil
+}
-}
+
-
+func NormalizePath(input, workdir string) string {
-func NormalizePath(input string) string {
+	input = filepath.Clean(input)
-	workingdirectory, _ := os.Getwd()
+	input = filepath.ToSlash(input)
-	input = strings.ReplaceAll(input, "\\", "/")
+	input = strings.ReplaceAll(input, "\"", "")
-	input = strings.ReplaceAll(input, "\"", "")
+
-
+	if !filepath.IsAbs(input) {
-	if !filepath.IsAbs(input) {
+		LogInfo("Input '%s' is not absolute, prepending work dir '%s'", input, workdir)
-		input = workingdirectory + "/" + input
+		var err error
-	}
+		input = filepath.Join(workdir, input)
-
+		input, err = filepath.Abs(input)
-	return filepath.Clean(input)
+		if err != nil {
-}
+			LogError("Failed to get absolute path for %s: %v", FormatSourcePath(input), err)
-
+			return input
-func AreSame(lhs string, rhs string) bool {
+		}
-	lhsinfo, err := os.Stat(lhs)
+	}
-	if err != nil {
+
-		return false
+	input = filepath.Clean(input)
-	}
+	input = filepath.ToSlash(input)
-	rhsinfo, err := os.Stat(rhs)
+	return input
-	if err != nil {
+}
-		return false
+
-	}
+func AreSame(lhs string, rhs string) bool {
-
+	lhsinfo, err := os.Stat(lhs)
-	return os.SameFile(lhsinfo, rhsinfo)
+	if err != nil {
-}
+		return false
-
+	}
-func ConvertHome(input string) (string, error) {
+	rhsinfo, err := os.Stat(rhs)
-	if strings.Contains(input, "~") {
+	if err != nil {
-		homedir, err := os.UserHomeDir()
+		return false
-		if err != nil {
+	}
-			return input, fmt.Errorf("unable to convert ~ to user directory with error %+v", err)
+
-		}
+	return os.SameFile(lhsinfo, rhsinfo)
-
+}
-		return strings.Replace(input, "~", homedir, 1), nil
+
-	}
+func ConvertHome(input string) (string, error) {
-	return input, nil
+	if strings.HasPrefix(input, "~/") {
-}
+		homedir, err := os.UserHomeDir()
-
+		if err != nil {
-func GetSyncFilesRecursively(input string, output chan string, status chan error) {
+			return input, fmt.Errorf("unable to convert ~ to user directory with error %+v", err)
-	defer close(output)
+		}
-	defer close(status)
+
-
+		return strings.Replace(input, "~", homedir, 1), nil
-	var filesProcessed int32
+	}
-	var foldersProcessed int32
+	return input, nil
-	progressTicker := time.NewTicker(200 * time.Millisecond)
+}
-	defer progressTicker.Stop()
+
-
+func GetSyncFilesRecursively(input string, output chan string, status chan error) {
-	var wg sync.WaitGroup
+	defer close(output)
-	var initial sync.Once
+	defer close(status)
-	wg.Add(1)
+
-	directories := make(chan string, 100000)
+	var filesProcessed int32
-	workerPool := make(chan struct{}, 4000)
+	var foldersProcessed int32
-	directories <- input
+	var activeWorkers int32
-
+
-	go func() {
+	progressTicker := time.NewTicker(200 * time.Millisecond)
-		for {
+	defer progressTicker.Stop()
-			fmt.Printf("\rFiles processed: %d; Folders processed: %d; Workers: %d; Directory Stack Size: %d;", filesProcessed, foldersProcessed, len(workerPool), len(directories))
+
-			<-progressTicker.C
+	done := make(chan struct{})
-		}
+	defer close(done)
-	}()
+
-
+	directories := make(chan string, 100000)
-	log.Printf("%+v", len(workerPool))
+	workerPool := make(chan struct{}, 4000)
-	go func() {
+	directories <- input
-		for directory := range directories {
+
-			workerPool <- struct{}{}
+	go func() {
-			wg.Add(1)
+		for {
-			go func(directory string) {
+			select {
-				atomic.AddInt32(&foldersProcessed, 1)
+			case <-progressTicker.C:
-				defer wg.Done()
+				dirCount := len(directories)
-				defer func() { <-workerPool }()
+				workers := atomic.LoadInt32(&activeWorkers)
-
+				fmt.Printf("\rFiles processed: %d; Folders processed: %d; Active workers: %d; Directory queue: %d",
-				files, err := os.ReadDir(directory)
+					atomic.LoadInt32(&filesProcessed),
-				if err != nil {
+					atomic.LoadInt32(&foldersProcessed),
-					log.Printf("Error reading directory %s: %+v", directory, err)
+					workers,
-					return
+					dirCount)
-				}
+			case <-done:
-
+				// Final progress update
-				for _, file := range files {
+				fmt.Printf("\nFiles processed: %d; Folders processed: %d; Completed successfully\n",
-					// log.Printf("Processing file %s", file.Name())
+					atomic.LoadInt32(&filesProcessed),
-					if file.IsDir() {
+					atomic.LoadInt32(&foldersProcessed))
-						directories <- filepath.Join(directory, file.Name())
+				return
-					} else {
+			}
-						// log.Println(file.Name(), DirRegex.MatchString(file.Name()))
+		}
-						if FileRegex.MatchString(file.Name()) {
+	}()
-							// log.Printf("Writing")
+
-							output <- filepath.Join(directory, file.Name())
+	allDone := make(chan struct{})
-						}
+
-						atomic.AddInt32(&filesProcessed, 1)
+	go func() {
-					}
+		// WTF is this waitgroup?
-				}
+		// Nowhere is it added...
-				// log.Printf("Done reading directory %s", directory)
+		var wg sync.WaitGroup
-
+
-				initial.Do(func() {
+		go func() {
-					// Parallelism is very difficult...
+			for {
-					time.Sleep(250 * time.Millisecond)
+				if atomic.LoadInt32(&activeWorkers) == 0 && len(directories) == 0 {
-					wg.Done()
+					time.Sleep(10 * time.Millisecond)
-				})
+					if atomic.LoadInt32(&activeWorkers) == 0 && len(directories) == 0 {
-			}(directory)
+						close(allDone)
-		}
+						return
-	}()
+					}
-
+				}
-	wg.Wait()
+				time.Sleep(50 * time.Millisecond)
-	log.Printf("Files processed: %d; Folders processed: %d", filesProcessed, foldersProcessed)
+			}
-}
+		}()
+
+		for {
+			select {
+			case directory, ok := <-directories:
+				if !ok {
+					wg.Wait()
+					return
+				}
+
+				atomic.AddInt32(&activeWorkers, 1)
+
+				go func(dir string) {
+					workerPool <- struct{}{}
+
+					atomic.AddInt32(&foldersProcessed, 1)
+					processDirectory(dir, directories, output, &filesProcessed)
+
+					<-workerPool
+					atomic.AddInt32(&activeWorkers, -1)
+				}(directory)
+			}
+		}
+	}()
+
+	<-allDone
+
+	if atomic.LoadInt32(&filesProcessed) > 0 {
+		LogInfo("Files processed: %d; Folders processed: %d",
+			atomic.LoadInt32(&filesProcessed),
+			atomic.LoadInt32(&foldersProcessed))
+	}
+}
+
+func processDirectory(directory string, directories chan<- string, output chan<- string, filesProcessed *int32) {
+	files, err := os.ReadDir(directory)
+	if err != nil {
+		LogError("Error reading directory %s: %v", directory, err)
+		return
+	}
+
+	for _, file := range files {
+		if file.IsDir() {
+			directories <- filepath.Join(directory, file.Name())
+		} else {
+			if IsYAMLSyncFile(file.Name()) {
+				output <- filepath.Join(directory, file.Name())
+			}
+			atomic.AddInt32(filesProcessed, 1)
+		}
+	}
+}
+
+func IsYAMLSyncFile(filename string) bool {
+	return filename == "sync.yaml" || filename == "sync.yml"
+}