Move all summary logic out of main into filesystem.go

.gitignore

@@ -5,3 +5,4 @@ cln.log
 .qodo
 *.log
 *.out
+test_temp

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

filesystem.go

@@ -0,0 +1,395 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+)
+
+var filesystem FileSystem = NewRealFileSystem()
+
+// FileSystem abstracts filesystem operations so we can swap implementations
+type FileSystem interface {
+	Remove(path string) error
+	RemoveAll(path string) error
+	MkdirAll(path string, perm os.FileMode) error
+	Symlink(source, target string) error
+	Link(source, target string) error
+	RecordLinkAttempt(kind string, source, target string, err error, dryRun bool)
+	SummaryLines() []string
+	SummaryRecords() []operationRecord
+	IsDryRun() bool
+}
+
+const (
+	opRemove    = "remove"
+	opRemoveAll = "remove_all"
+	opMkdirAll  = "mkdir_all"
+	opSymlink   = "symlink"
+	opHardlink  = "hardlink"
+)
+
+type operationRecord struct {
+	kind   string
+	source string
+	target string
+	err    error
+	dryRun bool
+}
+
+func (r operationRecord) summaryLine() (string, bool) {
+	detail := r.detail()
+	if detail != "" {
+		return fmt.Sprintf("%s %s → %s (%s) %s",
+			r.kindLabel(),
+			r.formattedSource(),
+			r.formattedTarget(),
+			r.resultLabel(),
+			detail), true
+	}
+
+	return fmt.Sprintf("%s %s → %s (%s)",
+		r.kindLabel(),
+		r.formattedSource(),
+		r.formattedTarget(),
+		r.resultLabel()), true
+}
+
+func (r operationRecord) kindLabel() string {
+	switch r.kind {
+	case opSymlink:
+		return "Symlink"
+	case opHardlink:
+		return "Hardlink"
+	case opRemove:
+		return "Remove"
+	case opRemoveAll:
+		return "RemoveAll"
+	case opMkdirAll:
+		return "MkdirAll"
+	default:
+		return r.kind
+	}
+}
+
+func (r operationRecord) resultLabel() string {
+	if r.err != nil {
+		return fmt.Sprintf("%sFAIL%s", BRed, Reset)
+	}
+	if r.dryRun {
+		return fmt.Sprintf("%sDRY-RUN%s", BCyan, Reset)
+	}
+	return fmt.Sprintf("%sOK%s", BGreen, Reset)
+}
+
+func (r operationRecord) resultLabelPlain() string {
+	if r.err != nil {
+		return "FAIL"
+	}
+	if r.dryRun {
+		return "DRY-RUN"
+	}
+	return "OK"
+}
+
+func (r operationRecord) formattedSource() string {
+	if r.source == "" {
+		return "-"
+	}
+	return FormatSourcePath(r.source)
+}
+
+func (r operationRecord) plainSource() string {
+	if r.source == "" {
+		return "-"
+	}
+	return r.source
+}
+
+func (r operationRecord) formattedTarget() string {
+	if r.target == "" {
+		return "-"
+	}
+	return FormatTargetPath(r.target)
+}
+
+func (r operationRecord) plainTarget() string {
+	if r.target == "" {
+		return "-"
+	}
+	return r.target
+}
+
+func (r operationRecord) detail() string {
+	if r.err != nil {
+		return r.err.Error()
+	}
+	if r.dryRun {
+		return "dry-run"
+	}
+	return ""
+}
+
+type baseFileSystem struct {
+	mu         sync.Mutex
+	operations []operationRecord
+}
+
+func (b *baseFileSystem) addOperation(kind, source, target string, err error, dryRun bool) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.operations = append(b.operations, operationRecord{
+		kind:   kind,
+		source: source,
+		target: target,
+		err:    err,
+		dryRun: dryRun,
+	})
+}
+
+func (b *baseFileSystem) snapshot() []operationRecord {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	ops := make([]operationRecord, len(b.operations))
+	copy(ops, b.operations)
+	return ops
+}
+
+func summarizeOperations(records []operationRecord) []string {
+	var lines []string
+	for _, record := range records {
+		if line, ok := record.summaryLine(); ok {
+			lines = append(lines, line)
+		}
+	}
+	return lines
+}
+
+type realFileSystem struct {
+	baseFileSystem
+}
+
+// NewRealFileSystem returns a filesystem implementation that writes to disk
+func NewRealFileSystem() FileSystem {
+	return &realFileSystem{}
+}
+
+func (fs *realFileSystem) Remove(path string) error {
+	err := os.Remove(path)
+	fs.addOperation(opRemove, "", path, err, false)
+	return err
+}
+
+func (fs *realFileSystem) RemoveAll(path string) error {
+	err := os.RemoveAll(path)
+	fs.addOperation(opRemoveAll, "", path, err, false)
+	return err
+}
+
+func (fs *realFileSystem) MkdirAll(path string, perm os.FileMode) error {
+	err := os.MkdirAll(path, perm)
+	fs.addOperation(opMkdirAll, "", path, err, false)
+	return err
+}
+
+func (fs *realFileSystem) Symlink(source, target string) error {
+	err := os.Symlink(source, target)
+	fs.RecordLinkAttempt(opSymlink, source, target, err, false)
+	return err
+}
+
+func (fs *realFileSystem) Link(source, target string) error {
+	err := os.Link(source, target)
+	fs.RecordLinkAttempt(opHardlink, source, target, err, false)
+	return err
+}
+
+func (fs *realFileSystem) RecordLinkAttempt(kind string, source, target string, err error, dryRun bool) {
+	fs.addOperation(kind, source, target, err, dryRun)
+}
+
+func (fs *realFileSystem) SummaryLines() []string {
+	return summarizeOperations(fs.snapshot())
+}
+
+func (fs *realFileSystem) SummaryRecords() []operationRecord {
+	return fs.snapshot()
+}
+
+func (fs *realFileSystem) IsDryRun() bool {
+	return false
+}
+
+type dryRunFileSystem struct {
+	baseFileSystem
+}
+
+// NewDryRunFileSystem returns a filesystem implementation that only records operations
+func NewDryRunFileSystem() FileSystem {
+	return &dryRunFileSystem{}
+}
+
+func (fs *dryRunFileSystem) Remove(path string) error {
+	fs.addOperation(opRemove, "", path, nil, true)
+	return nil
+}
+
+func (fs *dryRunFileSystem) RemoveAll(path string) error {
+	fs.addOperation(opRemoveAll, "", path, nil, true)
+	return nil
+}
+
+func (fs *dryRunFileSystem) MkdirAll(path string, perm os.FileMode) error {
+	fs.addOperation(opMkdirAll, "", path, nil, true)
+	return nil
+}
+
+func (fs *dryRunFileSystem) Symlink(source, target string) error {
+	fs.RecordLinkAttempt(opSymlink, source, target, nil, true)
+	return nil
+}
+
+func (fs *dryRunFileSystem) Link(source, target string) error {
+	fs.RecordLinkAttempt(opHardlink, source, target, nil, true)
+	return nil
+}
+
+func (fs *dryRunFileSystem) RecordLinkAttempt(kind string, source, target string, err error, dryRun bool) {
+	fs.addOperation(kind, source, target, err, dryRun)
+}
+
+func (fs *dryRunFileSystem) SummaryLines() []string {
+	return summarizeOperations(fs.snapshot())
+}
+
+func (fs *dryRunFileSystem) SummaryRecords() []operationRecord {
+	return fs.snapshot()
+}
+
+func (fs *dryRunFileSystem) IsDryRun() bool {
+	return true
+}
+
+func BuildSummaryLines(records []operationRecord) []string {
+	if len(records) == 0 {
+		return nil
+	}
+
+	sorted := make([]operationRecord, len(records))
+	copy(sorted, records)
+
+	opOrder := map[string]int{
+		opRemove:    0,
+		opRemoveAll: 1,
+		opMkdirAll:  2,
+		opSymlink:   3,
+		opHardlink:  4,
+	}
+
+	sort.SliceStable(sorted, func(i, j int) bool {
+		ti := strings.ToLower(sorted[i].plainTarget())
+		tj := strings.ToLower(sorted[j].plainTarget())
+		if ti != tj {
+			return ti < tj
+		}
+
+		si := strings.ToLower(sorted[i].plainSource())
+		sj := strings.ToLower(sorted[j].plainSource())
+		if si != sj {
+			return si < sj
+		}
+
+		oi := opOrderValue(sorted[i].kind, opOrder)
+		oj := opOrderValue(sorted[j].kind, opOrder)
+		if oi != oj {
+			return oi < oj
+		}
+
+		return sorted[i].detail() < sorted[j].detail()
+	})
+
+	header := []string{"RESULT", "OPERATION", "SOURCE", "TARGET", "DETAIL"}
+	widths := make([]int, len(header))
+	for i, h := range header {
+		widths[i] = len(h)
+	}
+
+	plainRows := make([][]string, len(sorted))
+	coloredRows := make([][]string, len(sorted))
+	for i, record := range sorted {
+		detail := record.detail()
+		if detail == "" {
+			detail = "-"
+		}
+
+		plain := []string{
+			record.resultLabelPlain(),
+			record.kindLabel(),
+			record.plainSource(),
+			record.plainTarget(),
+			detail,
+		}
+		colored := []string{
+			record.resultLabel(),
+			record.kindLabel(),
+			record.formattedSource(),
+			record.formattedTarget(),
+			detail,
+		}
+
+		plainRows[i] = plain
+		coloredRows[i] = colored
+
+		for j, val := range plain {
+			if val == "" {
+				val = "-"
+			}
+			if len(val) > widths[j] {
+				widths[j] = len(val)
+			}
+		}
+	}
+
+	lines := make([]string, 0, len(sorted)+1)
+	lines = append(lines, formatSummaryRow(header, header, widths))
+	for i := range coloredRows {
+		lines = append(lines, formatSummaryRow(coloredRows[i], plainRows[i], widths))
+	}
+
+	return lines
+}
+
+func formatSummaryRow(colored, plain []string, widths []int) string {
+	var b strings.Builder
+	for i := range colored {
+		p := plain[i]
+		if p == "" {
+			p = "-"
+		}
+		col := colored[i]
+		if col == "" {
+			col = p
+		}
+		pad := widths[i] - len(p)
+		if pad < 0 {
+			pad = 0
+		}
+		b.WriteString(col)
+		if pad > 0 {
+			b.WriteString(strings.Repeat(" ", pad))
+		}
+		if i < len(colored)-1 {
+			b.WriteString("  ")
+		}
+	}
+	return b.String()
+}
+
+func opOrderValue(kind string, order map[string]int) int {
+	if v, ok := order[kind]; ok {
+		return v
+	}
+	return len(order)
+}

filesystem_test.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSummaryLineMarksFailuresInRed(t *testing.T) {
+	fs := NewRealFileSystem()
+
+	fs.RecordLinkAttempt(opSymlink, "/tmp/source", "/tmp/target", fmt.Errorf("boom"), false)
+
+	lines := fs.SummaryLines()
+	assert.Equal(t, 1, len(lines))
+	assert.Contains(t, lines[0], BRed+"FAIL"+Reset)
+	assert.Contains(t, lines[0], "boom")
+}

go.mod

@@ -1,10 +1,11 @@
 module cln
 
-go 1.21.7
+go 1.23.6
 
 require gopkg.in/yaml.v3 v3.0.1
 
 require (
+	git.site.quack-lab.dev/dave/cyutils v1.4.0
 	github.com/bmatcuk/doublestar/v4 v4.8.1
 	github.com/stretchr/testify v1.11.1
 )
@@ -12,4 +13,5 @@ require (
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/time v0.12.0 // indirect
 )

go.sum

@@ -1,3 +1,5 @@
+git.site.quack-lab.dev/dave/cyutils v1.4.0 h1:/Xo3QfLIFNab+axHneWmUK4MyfuObl+qq8whF9vTQpk=
+git.site.quack-lab.dev/dave/cyutils v1.4.0/go.mod h1:fBjALu2Cp2u2bDr+E4zbGVMBeIgFzROg+4TCcTNAiQU=
 github.com/bmatcuk/doublestar/v4 v4.8.1 h1:54Bopc5c2cAvhLRAzqOGCYHYyhcDHsFF4wWIR5wKP38=
 github.com/bmatcuk/doublestar/v4 v4.8.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -6,6 +8,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 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=

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 {
@@ -71,12 +76,17 @@ func (instruction *LinkInstruction) Undo() {
 
 	if isSymlink {
 		LogInfo("Removing symlink at %s", FormatTargetPath(instruction.Target))
-		err = os.Remove(instruction.Target)
+		err = filesystem.Remove(instruction.Target)
 		if err != nil {
 			LogError("could not remove symlink at %s; err: %v",
 				FormatTargetPath(instruction.Target), err)
+		} else {
+			if filesystem.IsDryRun() {
+				LogInfo("[DRY-RUN] Would remove symlink at %s", FormatTargetPath(instruction.Target))
+			} else {
+				LogSuccess("Removed symlink at %s", FormatTargetPath(instruction.Target))
+			}
 		}
-		LogSuccess("Removed symlink at %s", FormatTargetPath(instruction.Target))
 	} else {
 		LogInfo("%s is not a symlink, skipping", FormatTargetPath(instruction.Target))
 	}
@@ -114,6 +124,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 +150,8 @@ func ParseInstruction(line, workdir string) (LinkInstruction, error) {
 			if instruction.Delete {
 				instruction.Force = true // Delete implies Force
 			}
+		case "files":
+			instruction.Files = isTrue(flagValue)
 		}
 	}
 
@@ -163,11 +177,32 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 		return
 	}
 
+	linkKind := opSymlink
+	if instruction.Hard {
+		linkKind = opHardlink
+	}
+	reportErr := func(err error) {
+		filesystem.RecordLinkAttempt(linkKind, instruction.Source, instruction.Target, err, filesystem.IsDryRun())
+		status <- err
+	}
+
 	if !FileExists(instruction.Source) {
-		status <- fmt.Errorf("instruction source %s does not exist", FormatSourcePath(instruction.Source))
+		reportErr(fmt.Errorf("instruction source %s does not exist", FormatSourcePath(instruction.Source)))
 		return
 	}
 
+	if instruction.Files {
+		info, err := os.Stat(instruction.Source)
+		if err != nil {
+			reportErr(fmt.Errorf("could not stat source %s; err: %v", FormatSourcePath(instruction.Source), err))
+			return
+		}
+		if info.IsDir() {
+			reportErr(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,27 +214,33 @@ 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() {
+				reportErr(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 {
-				status <- fmt.Errorf("could not determine whether %s is a sym link or not, stopping; err: %v",
+				reportErr(fmt.Errorf("could not determine whether %s is a sym link or not, stopping; err: %v",
-					FormatTargetPath(instruction.Target), err)
+					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",
+					reportErr(fmt.Errorf("could not stat %s, stopping; err: %v",
-						FormatTargetPath(instruction.Target), err)
+						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)
+					err := filesystem.Remove(instruction.Target)
 					if err != nil {
-						status <- fmt.Errorf("could not remove existing file %s; err: %v",
+						reportErr(fmt.Errorf("could not remove existing file %s; err: %v",
-							FormatTargetPath(instruction.Target), err)
+							FormatTargetPath(instruction.Target), err))
 						return
 					}
 				}
@@ -207,59 +248,73 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
 
 			if isSymlink {
 				LogTarget("Removing symlink at %s", instruction.Target)
-				err = os.Remove(instruction.Target)
+				err = filesystem.Remove(instruction.Target)
 				if err != nil {
-					status <- fmt.Errorf("failed deleting %s due to %v",
+					reportErr(fmt.Errorf("failed deleting %s due to %v",
-						FormatTargetPath(instruction.Target), err)
+						FormatTargetPath(instruction.Target), err))
 					return
 				}
 			} else {
 				if !instruction.Delete {
-					status <- fmt.Errorf("refusing to delte actual (non symlink) file %s",
+					reportErr(fmt.Errorf("refusing to delte actual (non symlink) file %s",
-						FormatTargetPath(instruction.Target))
+						FormatTargetPath(instruction.Target)))
 					return
 				}
 				LogImportant("Deleting (!!!) %s", instruction.Target)
-				err = os.RemoveAll(instruction.Target)
+				err = filesystem.RemoveAll(instruction.Target)
 				if err != nil {
-					status <- fmt.Errorf("failed deleting %s due to %v",
+					reportErr(fmt.Errorf("failed deleting %s due to %v",
-						FormatTargetPath(instruction.Target), err)
+						FormatTargetPath(instruction.Target), err))
 					return
 				}
 			}
 		} else {
-			status <- fmt.Errorf("target %s exists - handle manually or set the 'forced' flag (3rd field)",
+			reportErr(fmt.Errorf("target %s exists - handle manually or set the 'forced' flag (3rd field)",
-				FormatTargetPath(instruction.Target))
+				FormatTargetPath(instruction.Target)))
 			return
 		}
 	}
 
 	targetDir := filepath.Dir(instruction.Target)
 	if _, err := os.Stat(targetDir); os.IsNotExist(err) {
-		err = os.MkdirAll(targetDir, 0755)
+		err = filesystem.MkdirAll(targetDir, 0755)
 		if err != nil {
-			status <- fmt.Errorf("failed creating directory %s due to %v",
+			reportErr(fmt.Errorf("failed creating directory %s due to %v",
-				FormatTargetPath(targetDir), err)
+				FormatTargetPath(targetDir), err))
 			return
 		}
 	}
 
+	linkType := "symlink"
+	if instruction.Hard {
+		linkType = "hardlink"
+	}
+
 	var err error
 	if instruction.Hard {
-		err = os.Link(instruction.Source, instruction.Target)
+		err = filesystem.Link(instruction.Source, instruction.Target)
 	} else {
-		err = os.Symlink(instruction.Source, instruction.Target)
+		err = filesystem.Symlink(instruction.Source, instruction.Target)
 	}
 	if err != nil {
-		status <- fmt.Errorf("failed creating symlink between %s and %s with error %v",
+		status <- fmt.Errorf("failed creating %s between %s and %s with error %v",
+			linkType,
 			FormatSourcePath(instruction.Source),
 			FormatTargetPath(instruction.Target),
 			err)
 		return
 	}
-	LogSuccess("Created symlink between %s and %s",
+	if filesystem.IsDryRun() {
-		FormatSourcePath(instruction.Source),
+		LogInfo("[DRY-RUN] Would create %s between %s and %s",
-		FormatTargetPath(instruction.Target))
+			linkType,
+			FormatSourcePath(instruction.Source),
+			FormatTargetPath(instruction.Target))
+	} else {
+		LogSuccess("Created %s between %s and %s",
+			linkType,
+			FormatSourcePath(instruction.Source),
+			FormatTargetPath(instruction.Target))
+	}
 
 	status <- nil
 }
@@ -270,48 +325,24 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
 		return nil, fmt.Errorf("error reading YAML file: %w", err)
 	}
 
-	// First try to parse as a YAMLConfig with links and from fields
+	// Parse as a direct list of instructions
-	var config YAMLConfig
+	var instructions []LinkInstruction
-	err = yaml.Unmarshal(data, &config)
+	err = yaml.Unmarshal(data, &instructions)
-	LogInfo("First parsing attempt: err=%v, links=%d, from=%d", err, len(config.Links), len(config.From))
 	if err != nil {
-		// If that fails, try parsing as a direct list of instructions
+		return nil, fmt.Errorf("error parsing YAML: %w", err)
-		var instructions []LinkInstruction
-		err = yaml.Unmarshal(data, &instructions)
-		if err != nil {
-			return nil, fmt.Errorf("error parsing YAML: %w", err)
-		}
-		// Filter out invalid instructions (empty source)
-		validInstructions := []LinkInstruction{}
-		for _, instr := range instructions {
-			if instr.Source != "" {
-				validInstructions = append(validInstructions, instr)
-			}
-		}
-		config.Links = validInstructions
 	}
 
-	expanded := []LinkInstruction{}
+	// Preprocess instructions: expand globs and from references
-	for _, link := range config.Links {
+	// Create a new visited map for this file
-		LogSource("Expanding pattern source %s in YAML file %s", link.Source, filename)
+	visited := make(map[string]bool)
-		newlinks, err := ExpandPattern(link.Source, workdir, link.Target)
+	processedInstructions, err := preprocessInstructions(instructions, filename, workdir, visited)
-		if err != nil {
+	if err != nil {
-			return nil, fmt.Errorf("error expanding pattern: %w", err)
+		return nil, err
-		}
-		// "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))
-		expanded = append(expanded, newlinks...)
 	}
 
-	for i := range expanded {
+	// Final processing: normalize paths and set defaults
-		link := &expanded[i]
+	for i := range processedInstructions {
-
+		link := &processedInstructions[i]
 		link.Tidy()
 		link.Source, _ = ConvertHome(link.Source)
 		link.Target, _ = ConvertHome(link.Target)
@@ -324,7 +355,116 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
 		}
 	}
 
-	return expanded, nil
+	return processedInstructions, nil
+}
+
+// preprocessInstructions handles glob expansion and from references
+func preprocessInstructions(instructions []LinkInstruction, filename, workdir string, visited map[string]bool) ([]LinkInstruction, error) {
+	var result []LinkInstruction
+
+	for _, instr := range instructions {
+		if instr.Source == "" {
+			continue // Skip invalid instructions
+		}
+
+		if instr.Target == "" {
+			// 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...)
+		} else {
+			// This is a regular instruction - expand globs if needed
+			expandedInstructions, err := expandGlobs(instr, filename, workdir)
+			if err != nil {
+				return nil, fmt.Errorf("error expanding globs for %s: %w", instr.Source, err)
+			}
+			result = append(result, expandedInstructions...)
+		}
+	}
+
+	return result, nil
+}
+
+// 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
+	if !filepath.IsAbs(fromPath) {
+		currentDir := filepath.Dir(currentFile)
+		fromPath = filepath.Join(currentDir, fromPath)
+	}
+
+	// Normalize the path
+	fromPath = filepath.Clean(fromPath)
+
+	// Recursively parse the referenced file with cycle detection
+	fromWorkdir := filepath.Dir(fromPath)
+	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) {
+	// Convert home directory (~) before expanding pattern
+	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
+	}
+
+	// Clone the original instruction properties for each expanded link
+	for i := range newlinks {
+		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",
+		FormatSourcePath(instr.Source), FormatSourcePath(filename), len(newlinks))
+
+	return newlinks, nil
 }
 
 // ParseYAMLFileRecursive parses a YAML file and recursively processes any "From" references
@@ -348,54 +488,80 @@ func parseYAMLFileRecursive(filename, workdir string, visited map[string]bool) (
 	visited[normalizedFilename] = true
 	defer delete(visited, normalizedFilename)
 
-	// Parse the current file
+	// Parse the current file and preprocess it with cycle detection
-	instructions, err := ParseYAMLFile(filename, workdir)
-	if err != nil {
-		return nil, err
-	}
-
-	// Read the file to check for "From" references
 	data, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, fmt.Errorf("error reading YAML file: %w", err)
 	}
 
-	var config YAMLConfig
+	// Parse as a direct list of instructions
-	err = yaml.Unmarshal(data, &config)
+	var instructions []LinkInstruction
+	err = yaml.Unmarshal(data, &instructions)
 	if err != nil {
-		// If parsing as YAMLConfig fails, there are no "From" references to process
+		return nil, fmt.Errorf("error parsing YAML: %w", err)
-		return instructions, nil
 	}
 
-	// Process "From" references
+	// Preprocess instructions: expand globs and from references
-	for _, fromFile := range config.From {
+	processedInstructions, err := preprocessInstructions(instructions, filename, workdir, visited)
-		// Convert relative paths to absolute paths based on the current file's directory
+	if err != nil {
-		fromPath := fromFile
+		return nil, err
-		if !filepath.IsAbs(fromPath) {
-			currentDir := filepath.Dir(filename)
-			fromPath = filepath.Join(currentDir, fromPath)
-		}
-
-		// Normalize the path
-		fromPath = filepath.Clean(fromPath)
-
-		// Recursively parse the referenced file
-		// Use the directory of the referenced file as the workdir for pattern expansion
-		fromWorkdir := filepath.Dir(fromPath)
-		fromInstructions, err := parseYAMLFileRecursive(fromPath, fromWorkdir, visited)
-		if err != nil {
-			return nil, fmt.Errorf("error parsing referenced file %s: %w", fromFile, err)
-		}
-
-		// Append the instructions from the referenced file
-		instructions = append(instructions, fromInstructions...)
 	}
 
-	return instructions, nil
+	// Final processing: normalize paths and set defaults
+	for i := range processedInstructions {
+		link := &processedInstructions[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 link.Delete {
+			link.Force = true
+		}
+	}
+
+	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
 	}
@@ -407,43 +573,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,
 		})
 	}

main.go

@@ -3,12 +3,15 @@ package main
 import (
 	"bufio"
 	"flag"
+	"fmt"
 	"io"
 	"log"
 	"os"
 	"path/filepath"
-	"sync"
+	"runtime/debug"
 	"sync/atomic"
+
+	utils "git.site.quack-lab.dev/dave/cyutils"
 )
 
 const deliminer = ","
@@ -19,19 +22,36 @@ const ImportantColor = BRed
 const DefaultColor = Reset
 const PathColor = Green
 
-var programName = os.Args[0]
+var (
-var undo = false
+	programName = os.Args[0]
+	undo        = false
+	version     = "dev"
+)
 
 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")
+	versionFlag := flag.Bool("v", false, "print version and exit")
+	dryRun := flag.Bool("n", false, "dry run (no filesystem changes)")
 	flag.Parse()
 	undo = *undoF
 
+	if *versionFlag {
+		fmt.Println(getVersionString())
+		return
+	}
+
 	setupLogging(*debug)
 
+	if *dryRun {
+		filesystem = NewDryRunFileSystem()
+		LogInfo("Dry run mode enabled - no filesystem changes will be made")
+	} else {
+		filesystem = NewRealFileSystem()
+	}
+
 	instructions := make(chan *LinkInstruction, 1000)
 	status := make(chan error)
 
@@ -43,9 +63,11 @@ func main() {
 
 	if instructionsDone == 0 {
 		LogInfo("No instructions were processed")
+		printSummary(filesystem)
 		os.Exit(1)
 	}
 	LogInfo("All done")
+	printSummary(filesystem)
 }
 
 // setupLogging configures logging based on debug flag
@@ -130,31 +152,46 @@ func handleStatusErrors(status chan error) {
 	}
 }
 
-// processInstructions processes all instructions from the channel
+// processInstructions processes all instructions from the channel using parallel workers
 func processInstructions(instructions chan *LinkInstruction) int32 {
 	var instructionsDone int32 = 0
-	var wg sync.WaitGroup
+
+	// Collect all instructions first
+	var allInstructions []*LinkInstruction
 	for {
 		instruction, ok := <-instructions
 		if !ok {
 			LogInfo("No more instructions to process")
 			break
 		}
+		allInstructions = append(allInstructions, instruction)
+	}
+
+	// Process instructions in parallel using cyutils.WithWorkers
+	// Let the library handle worker count - use 4 workers as a reasonable default
+	utils.WithWorkers(4, allInstructions, func(workerID int, _ int, instruction *LinkInstruction) {
 		LogInfo("Processing: %s", instruction.String())
 		status := make(chan error)
 		go instruction.RunAsync(status)
-		wg.Add(1)
 		err := <-status
 		if err != nil {
 			LogError("Failed processing instruction: %v", err)
+		} else {
+			atomic.AddInt32(&instructionsDone, 1)
 		}
-		atomic.AddInt32(&instructionsDone, 1)
+	})
-		wg.Done()
+
-	}
-	wg.Wait()
 	return instructionsDone
 }
 
+func printSummary(fs FileSystem) {
+	lines := BuildSummaryLines(fs.SummaryRecords())
+	LogInfo("Summary:")
+	for _, line := range lines {
+		LogInfo("%s", line)
+	}
+}
+
 func IsPipeInput() bool {
 	info, err := os.Stdin.Stat()
 	if err != nil {
@@ -219,6 +256,44 @@ func ReadFromFilesRecursively(input string, output chan *LinkInstruction, status
 	}
 }
 
+func getVersionString() string {
+	if version != "" && version != "dev" {
+		return version
+	}
+
+	if info, ok := debug.ReadBuildInfo(); ok {
+		if info.Main.Version != "" && info.Main.Version != "(devel)" {
+			return info.Main.Version
+		}
+
+		var revision, modified, vcsTime string
+		for _, setting := range info.Settings {
+			switch setting.Key {
+			case "vcs.revision":
+				revision = setting.Value
+			case "vcs.modified":
+				modified = setting.Value
+			case "vcs.time":
+				vcsTime = setting.Value
+			}
+		}
+		if revision != "" {
+			if len(revision) > 7 {
+				revision = revision[:7]
+			}
+			if modified == "true" {
+				revision += "-dirty"
+			}
+			if vcsTime != "" {
+				revision += " (" + vcsTime + ")"
+			}
+			return revision
+		}
+	}
+
+	return "dev"
+}
+
 func ReadFromFile(input string, output chan *LinkInstruction, status chan error, doclose bool) {
 	if doclose {
 		defer close(output)