Fix files being linked as folders

Why did I even remove it?

.gitignore

@@ -1,3 +1,5 @@
 *.exe
 *.exe
 cln
+cln.log
+.qodo

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Ereshor Workspace",
+			"type": "go",
+			"request": "launch",
+			"mode": "auto",
+			"program": "${workspaceFolder}",
+			"cwd": "C:\\Users\\Administrator\\Seafile\\Games-Ereshor"
+		}
+	]
+}

go.mod

@@ -3,3 +3,5 @@ module cln
 go 1.21.7
 
 require gopkg.in/yaml.v3 v3.0.1
+
+require github.com/bmatcuk/doublestar/v4 v4.8.1

go.sum

@@ -1,3 +1,5 @@
+github.com/bmatcuk/doublestar/v4 v4.8.1 h1:54Bopc5c2cAvhLRAzqOGCYHYyhcDHsFF4wWIR5wKP38=
+github.com/bmatcuk/doublestar/v4 v4.8.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 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=

instruction.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 
+	"github.com/bmatcuk/doublestar/v4"
 	"gopkg.in/yaml.v3"
 )
 
@@ -49,12 +49,38 @@ func (instruction *LinkInstruction) String() string {
 		flagsStr = " [" + strings.Join(flags, ", ") + "]"
 	}
 
-	return fmt.Sprintf("%s%s%s → %s%s%s%s",
+	return fmt.Sprintf("%s → %s%s",
-		SourceColor, instruction.Source, DefaultColor,
+		FormatSourcePath(instruction.Source),
-		TargetColor, instruction.Target, DefaultColor,
+		FormatTargetPath(instruction.Target),
 		flagsStr)
 }
 
+func (instruction *LinkInstruction) Undo() {
+	if !FileExists(instruction.Target) {
+		LogInfo("%s does not exist, skipping", FormatTargetPath(instruction.Target))
+		return
+	}
+
+	isSymlink, err := IsSymlink(instruction.Target)
+	if err != nil {
+		LogError("could not determine whether %s is a sym link or not, stopping; err: %v",
+			FormatTargetPath(instruction.Target), err)
+		return
+	}
+
+	if isSymlink {
+		LogInfo("Removing symlink at %s", FormatTargetPath(instruction.Target))
+		err = os.Remove(instruction.Target)
+		if err != nil {
+			LogError("could not remove symlink at %s; err: %v",
+				FormatTargetPath(instruction.Target), err)
+		}
+		LogSuccess("Removed symlink at %s", FormatTargetPath(instruction.Target))
+	} else {
+		LogInfo("%s is not a symlink, skipping", FormatTargetPath(instruction.Target))
+	}
+}
+
 func ParseInstruction(line, workdir string) (LinkInstruction, error) {
 	line = strings.TrimSpace(line)
 	if strings.HasPrefix(line, "#") {
@@ -131,13 +157,23 @@ func isTrue(value string) bool {
 
 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%s%s does not exist", SourceColor, instruction.Source, DefaultColor)
+		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%s%s and target %s%s%s are the same, %snothing to do...%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, PathColor, DefaultColor)
+		//status <- fmt.Errorf("source %s and target %s are the same, nothing to do...",
+		//	FormatSourcePath(instruction.Source),
+		//	FormatTargetPath(instruction.Target))
+		LogInfo("Source %s and target %s are the same, nothing to do...",
+			FormatSourcePath(instruction.Source),
+			FormatTargetPath(instruction.Target))
 		return
 	}
 
@@ -145,21 +181,24 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 		if instruction.Force {
 			isSymlink, err := IsSymlink(instruction.Target)
 			if err != nil {
-				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)
+				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%s%s, stopping; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+					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%s%s; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+						status <- fmt.Errorf("could not remove existing file %s; err: %v",
+							FormatTargetPath(instruction.Target), err)
 						return
 					}
 				}
@@ -169,23 +208,27 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 				LogTarget("Removing symlink at %s", instruction.Target)
 				err = os.Remove(instruction.Target)
 				if err != nil {
-					status <- fmt.Errorf("failed deleting %s%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+					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%s%s", TargetColor, instruction.Target, DefaultColor)
+					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%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor)
+					status <- fmt.Errorf("failed deleting %s due to %v",
+						FormatTargetPath(instruction.Target), err)
 					return
 				}
 			}
 		} else {
-			status <- fmt.Errorf("target %s%s%s exists - handle manually or set the 'forced' flag (3rd field)", TargetColor, instruction.Target, DefaultColor)
+			status <- fmt.Errorf("target %s exists - handle manually or set the 'forced' flag (3rd field)",
+				FormatTargetPath(instruction.Target))
 			return
 		}
 	}
@@ -194,7 +237,8 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 	if _, err := os.Stat(targetDir); os.IsNotExist(err) {
 		err = os.MkdirAll(targetDir, 0755)
 		if err != nil {
-			status <- fmt.Errorf("failed creating directory %s%s%s due to %s%+v%s", TargetColor, targetDir, DefaultColor, ErrorColor, err, DefaultColor)
+			status <- fmt.Errorf("failed creating directory %s due to %v",
+				FormatTargetPath(targetDir), err)
 			return
 		}
 	}
@@ -206,10 +250,13 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 		err = os.Symlink(instruction.Source, instruction.Target)
 	}
 	if err != nil {
-		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)
+		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",
+	LogSuccess("Created symlink between %s and %s",
 		FormatSourcePath(instruction.Source),
 		FormatTargetPath(instruction.Target))
 
@@ -235,27 +282,26 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
 		config.Links = instructions
 	}
 
-	toRemove := []int{}
+	expanded := []LinkInstruction{}
-	for i, link := range config.Links {
+	for _, link := range config.Links {
-		if strings.Contains(link.Source, "*") {
+		LogSource("Expanding pattern source %s in YAML file %s", link.Source, filename)
-			LogSource("Expanding wildcard source %s in YAML file %s", link.Source, filename)
+		newlinks, err := ExpandPattern(link.Source, workdir, link.Target)
-			newlinks, err := ExpandWildcard(link.Source, workdir, link.Target)
 		if err != nil {
-				return nil, fmt.Errorf("error expanding wildcard: %w", err)
+			return nil, fmt.Errorf("error expanding pattern: %w", err)
 		}
-			LogInfo("Expanded wildcard source %s in YAML file %s to %d links",
+		// "Clone" the original link instruction for each expanded link
+		for i := range newlinks {
+			newlinks[i].Delete = link.Delete
+			newlinks[i].Hard = link.Hard
+			newlinks[i].Force = link.Force
+		}
+		LogInfo("Expanded pattern %s in YAML file %s to %d links",
 			FormatSourcePath(link.Source), FormatSourcePath(filename), len(newlinks))
-			config.Links = append(config.Links, newlinks...)
+		expanded = append(expanded, newlinks...)
-			toRemove = append(toRemove, i)
-		}
 	}
 
-	for i := len(toRemove) - 1; i >= 0; i-- {
+	for i := range expanded {
-		config.Links = slices.Delete(config.Links, toRemove[i], 1)
+		link := &expanded[i]
-	}
-
-	for i := range config.Links {
-		link := &config.Links[i]
 
 		link.Tidy()
 		link.Source, _ = ConvertHome(link.Source)
@@ -264,32 +310,69 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
 		link.Target = NormalizePath(link.Target, workdir)
 
 		// If Delete is true, Force must also be true
-		if config.Links[i].Delete {
+		if link.Delete {
-			config.Links[i].Force = true
+			link.Force = true
 		}
 	}
 
-	return config.Links, nil
+	return expanded, nil
 }
 
-func ExpandWildcard(source, workdir, target string) (links []LinkInstruction, err error) {
+func ExpandPattern(source, workdir, target string) (links []LinkInstruction, err error) {
-	dir := filepath.Dir(source)
+	static, pattern := doublestar.SplitPattern(source)
-	pattern := filepath.Base(source)
+	if static == "" {
+		static = workdir
+	}
+	LogInfo("Static part: %s", static)
+	LogInfo("Pattern part: %s", pattern)
 
-	files, err := filepath.Glob(filepath.Join(workdir, dir, pattern))
+	files, err := doublestar.Glob(os.DirFS(static), pattern)
 	if err != nil {
-		return nil, fmt.Errorf("error expanding wildcard: %w", 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 {
-		link := LinkInstruction{
+		if len(files) == 1 {
-			Source: file,
+			// Special case: if there is only one file
-			Target: filepath.Join(target, filepath.Base(file)),
+			// This should only ever happen if our source is a path (and not a glob!)
+			// And our target is a path
+			// ...but it will also happen if the source IS a glob and it happens to match ONE file
+			// I think that should happen rarely enough to not be an issue...
+			links = append(links, LinkInstruction{
+				Source: filepath.Join(static, file),
+				Target: target,
+			})
+			continue
 		}
-		links = append(links, link)
+		if info, err := os.Stat(file); err == nil && info.IsDir() {
+			// We don't care about matched directories
+			// We want files within them
+			LogInfo("Skipping directory %s", file)
+			continue
 		}
 
-	LogInfo("Expanded wildcard source %s to %d links", FormatSourcePath(source), len(links))
+		var targetPath string
+		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),
+			Target: targetPath,
+		})
+	}
+
+	LogInfo("Expanded pattern %s to %d links", FormatSourcePath(source), len(links))
 	return
 }
 

logger.go

@@ -5,62 +5,95 @@ import (
 	"log"
 )
 
+// Message type prefixes
+const (
+	InfoPrefix      = "INFO"
+	ErrorPrefix     = "ERROR"
+	WarningPrefix   = "WARN"
+	SourcePrefix    = "SOURCE"
+	TargetPrefix    = "TARGET"
+	PathPrefix      = "PATH"
+	ImportantPrefix = "IMPORTANT"
+	SuccessPrefix   = "DONE"
+)
+
 // LogInfo logs an informational message
 func LogInfo(format string, args ...interface{}) {
-	log.Printf(format, args...)
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s[%s]%s %s", BGreen, InfoPrefix, Reset, message)
+}
+
+// LogSuccess logs a success message
+func LogSuccess(format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	log.Printf("%s%s[%s]%s %s", BBlue, On_Blue, SuccessPrefix, 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", SourceColor, message, DefaultColor)
+	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", TargetColor, message, DefaultColor)
+	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", PathColor, message, DefaultColor)
+	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", ImportantColor, message, DefaultColor)
+	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...)
-	log.Printf("%s%s%s", ErrorColor, message, DefaultColor)
+
-	// Make sure we're properly resetting before applying error color to avoid cutoffs
+	// The Error prefix itself is bold red on a light background for maximum visibility
-	log.Printf("%s%s%s", ErrorColor, fmt.Sprintf(format, args...), DefaultColor)
+	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 formats a source path with proper coloring
+// FormatSourcePath returns a source path with proper coloring
 func FormatSourcePath(path string) string {
-	return fmt.Sprintf("%s%s%s", SourceColor, path, DefaultColor)
+	return fmt.Sprintf("%s%s%s", SourceColor, path, Reset)
 }
 
-// FormatTargetPath formats a target path with proper coloring
+// FormatTargetPath returns a target path with proper coloring
 func FormatTargetPath(path string) string {
-	return fmt.Sprintf("%s%s%s", TargetColor, path, DefaultColor)
+	return fmt.Sprintf("%s%s%s", TargetColor, path, Reset)
 }
 
-// FormatPathValue formats a path value with proper coloring
+// FormatPathValue returns a path with proper coloring
 func FormatPathValue(path string) string {
-	return fmt.Sprintf("%s%s%s", PathColor, path, DefaultColor)
+	return fmt.Sprintf("%s%s%s", PathColor, path, Reset)
 }
 
-// FormatErrorValue formats an error value with proper coloring
+// 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 ""
 	}
-	return fmt.Sprintf("%s%v%s", ErrorColor, err, DefaultColor)
+	// 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

@@ -15,23 +15,26 @@ import (
 const deliminer = ","
 const SourceColor = Purple
 const TargetColor = Yellow
-const ErrorColor = URed
+const ErrorColor = Red
 const ImportantColor = BRed
-const DefaultColor = White
+const DefaultColor = Reset
 const PathColor = Green
 
 var FileRegex, _ = regexp.Compile(`sync\.ya?ml$`)
 var programName = os.Args[0]
+var undo = false
 
 func main() {
 	recurse := flag.String("r", "", "recurse into directories")
 	file := flag.String("f", "", "file to read instructions from")
 	debug := flag.Bool("d", false, "debug")
+	undoF := flag.Bool("u", false, "undo")
 	flag.Parse()
+	undo = *undoF
 
 	if *debug {
 		log.SetFlags(log.Lmicroseconds | log.Lshortfile)
-		logFile, err := os.Create("cln.log")
+		logFile, err := os.Create(programName + ".log")
 		if err != nil {
 			LogError("Error creating log file: %v", err)
 			os.Exit(1)
@@ -59,12 +62,15 @@ func main() {
 		LogInfo("Reading from command line arguments")
 		go ReadFromArgs(instructions, status)
 
-	case IsPipeInput():
+	// case IsPipeInput():
-		LogInfo("Reading from stdin pipe")
+	// 	LogInfo("Reading from stdin pipe")
-		go ReadFromStdin(instructions, status)
+	// 	go ReadFromStdin(instructions, status)
 
 	default:
-		if _, err := os.Stat("sync.yaml"); err == nil {
+		if _, err := os.Stat("sync"); err == nil {
+			LogInfo("Using default sync file")
+			go ReadFromFile("sync", instructions, status, true)
+		} else if _, err := os.Stat("sync.yaml"); err == nil {
 			LogInfo("Using default sync.yaml file")
 			go ReadFromFile("sync.yaml", instructions, status, true)
 		} else if _, err := os.Stat("sync.yml"); err == nil {
@@ -94,7 +100,7 @@ func main() {
 		}
 	}()
 
-	var instructionsDone int32
+	var instructionsDone int32 = 0
 	var wg sync.WaitGroup
 	for {
 		instruction, ok := <-instructions
@@ -108,8 +114,7 @@ func main() {
 		wg.Add(1)
 		err := <-status
 		if err != nil {
-			LogError("Failed parsing instruction %s due to %v",
+			LogError("Failed processing instruction: %v", err)
-				FormatSourcePath(instruction.String()), err)
 		}
 		atomic.AddInt32(&instructionsDone, 1)
 		wg.Done()
@@ -136,7 +141,7 @@ func ReadFromFilesRecursively(input string, output chan *LinkInstruction, status
 
 	workdir, _ := os.Getwd()
 	input = NormalizePath(input, workdir)
-	LogInfo("Reading input from files recursively starting in %s%s%s", PathColor, input, DefaultColor)
+	LogInfo("Reading input from files recursively starting in %s", FormatPathValue(input))
 
 	files := make(chan string, 128)
 	fileStatus := make(chan error)
@@ -171,19 +176,21 @@ func ReadFromFilesRecursively(input string, output chan *LinkInstruction, status
 			defer wg.Done()
 			LogInfo(file)
 			file = NormalizePath(file, workdir)
-			LogInfo("Processing file: %s%s%s", PathColor, file, DefaultColor)
+			LogInfo("Processing file: %s", FormatPathValue(file))
 
 			// This "has" to be done because instructions are resolved in relation to cwd
 			fileDir := FileRegex.FindStringSubmatch(file)
 			if fileDir == nil {
-				LogError("Failed to extract directory from %s%s%s", SourceColor, file, DefaultColor)
+				LogError("Failed to extract directory from %s", FormatSourcePath(file))
 				return
 			}
-			LogInfo("Changing directory to %s%s%s (for %s%s%s)", PathColor, fileDir[1], DefaultColor, PathColor, file, DefaultColor)
+			LogInfo("Changing directory to %s (for %s)",
+				FormatPathValue(fileDir[1]),
+				FormatPathValue(file))
 			err := os.Chdir(fileDir[1])
 			if err != nil {
-				LogError("Failed to change directory to %s%s%s: %v",
+				LogError("Failed to change directory to %s: %v",
-					SourceColor, fileDir[1], DefaultColor, err)
+					FormatSourcePath(fileDir[1]), err)
 				return
 			}
 			ReadFromFile(file, output, status, false)
@@ -200,15 +207,15 @@ func ReadFromFile(input string, output chan *LinkInstruction, status chan error,
 	}
 
 	input = NormalizePath(input, filepath.Dir(input))
-	LogInfo("Reading input from file: %s%s%s", PathColor, input, DefaultColor)
+	LogInfo("Reading input from file: %s", FormatPathValue(input))
 
 	// Check if this is a YAML file
 	if IsYAMLFile(input) {
 		LogInfo("Parsing as YAML file")
 		instructions, err := ParseYAMLFile(input, filepath.Dir(input))
 		if err != nil {
-			LogError("Failed to parse YAML file %s%s%s: %s%+v%s",
+			LogError("Failed to parse YAML file %s: %v",
-				SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor)
+				FormatSourcePath(input), err)
 			status <- err
 			return
 		}
@@ -220,6 +227,28 @@ func ReadFromFile(input string, output chan *LinkInstruction, status chan error,
 		}
 		return
 	}
+
+	// Handle CSV format (legacy)
+	file, err := os.Open(input)
+	if err != nil {
+		log.Fatalf("Failed to open file %s%s%s: %s%+v%s",
+			SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor)
+		return
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		instruction, err := ParseInstruction(line, filepath.Dir(input))
+		if err != nil {
+			log.Printf("Error parsing line: %s'%s'%s, error: %s%+v%s",
+				SourceColor, line, DefaultColor, ErrorColor, err, DefaultColor)
+			continue
+		}
+		log.Printf("Read instruction: %s", instruction.String())
+		output <- &instruction
+	}
 }
 
 func ReadFromArgs(output chan *LinkInstruction, status chan error) {
@@ -231,8 +260,7 @@ func ReadFromArgs(output chan *LinkInstruction, status chan error) {
 	for _, arg := range flag.Args() {
 		instruction, err := ParseInstruction(arg, workdir)
 		if err != nil {
-			LogError("Error parsing arg: %s'%s'%s, error: %v",
+			LogError("Error parsing arg '%s': %v", arg, err)
-				SourceColor, arg, DefaultColor, err)
 			continue
 		}
 		output <- &instruction
@@ -251,8 +279,7 @@ func ReadFromStdin(output chan *LinkInstruction, status chan error) {
 		line := scanner.Text()
 		instruction, err := ParseInstruction(line, workdir)
 		if err != nil {
-			LogError("Error parsing line: %s'%s'%s, error: %v",
+			LogError("Error parsing line '%s': %v", line, err)
-				SourceColor, line, DefaultColor, err)
 			continue
 		}
 		output <- &instruction

release.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+echo "Figuring out the tag..."
+TAG=$(git describe --tags --exact-match 2>/dev/null || echo "")
+if [ -z "$TAG" ]; then
+  # Get the latest tag
+  LATEST_TAG=$(git describe --tags $(git rev-list --tags --max-count=1))
+  # Increment the patch version
+  IFS='.' read -r -a VERSION_PARTS <<< "$LATEST_TAG"
+  VERSION_PARTS[2]=$((VERSION_PARTS[2]+1))
+  TAG="${VERSION_PARTS[0]}.${VERSION_PARTS[1]}.${VERSION_PARTS[2]}"
+  # Create a new tag
+  git tag $TAG
+  git push origin $TAG
+fi
+echo "Tag: $TAG"
+
+echo "Building the thing..."
+go build .
+go install .
+
+echo "Creating a release..."
+TOKEN="$GITEA_API_KEY"
+GITEA="https://git.site.quack-lab.dev"
+REPO="dave/synclib"
+# Create a release
+RELEASE_RESPONSE=$(curl -s -X POST \
+  -H "Authorization: token $TOKEN" \
+  -H "Accept: application/json" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tag_name": "'"$TAG"'",
+    "name": "'"$TAG"'",
+    "draft": false,
+    "prerelease": false
+  }' \
+  $GITEA/api/v1/repos/$REPO/releases)
+
+# Extract the release ID
+echo $RELEASE_RESPONSE
+RELEASE_ID=$(echo $RELEASE_RESPONSE | awk -F'"id":' '{print $2+0; exit}')
+echo "Release ID: $RELEASE_ID"
+
+echo "Uploading the things..."
+curl -X POST \
+  -H "Authorization: token $TOKEN" \
+  -F "attachment=@cln.exe" \
+  "$GITEA/api/v1/repos/$REPO/releases/${RELEASE_ID}/assets?name=cln.exe"

sync.yaml

@@ -1,2 +1,6 @@
-- source: \*
+- source: A/**/*
-  target: test/
+  target: B
+- source: A/go.mod
+  target: B/go.mod
+- source: A
+  target: B/foo