feat: enhance drift visualization with content drift and orphan detection (go4dot-ov1.5)

internal/status/gather.go

@@ -29,6 +29,8 @@ type ConfigStatus struct {
 	NewFiles     int        `json:"new_files,omitempty"`
 	MissingFiles int        `json:"missing_files,omitempty"`
 	Conflicts    int        `json:"conflicts,omitempty"`
+	ContentDrift int        `json:"content_drift,omitempty"`
+	Orphans      int        `json:"orphans,omitempty"`
 }
 
 // DependencyStatus holds a summary of dependency checking.
@@ -167,10 +169,16 @@ func (g *Gatherer) Gather(opts GatherOptions) (*Overview, error) {
 			cs.NewFiles = len(dr.NewFiles)
 			cs.MissingFiles = len(dr.MissingFiles)
 			cs.Conflicts = len(dr.ConflictFiles)
+			cs.ContentDrift = len(dr.ContentDriftFiles)
 		} else {
 			cs.Status = SyncStatusSynced
 		}
 
+		// Orphans are informational - set regardless of drift status
+		if dr, ok := driftMap[c.Name]; ok {
+			cs.Orphans = len(dr.OrphanFiles)
+		}
+
 		overview.Configs = append(overview.Configs, cs)
 	}
 

internal/status/render.go

@@ -187,6 +187,12 @@ func driftDetails(cs ConfigStatus) string {
 	if cs.Conflicts > 0 {
 		parts = append(parts, fmt.Sprintf("!%d conflicts", cs.Conflicts))
 	}
+	if cs.ContentDrift > 0 {
+		parts = append(parts, fmt.Sprintf("≠%d content drift", cs.ContentDrift))
+	}
+	if cs.Orphans > 0 {
+		parts = append(parts, fmt.Sprintf("?%d untracked", cs.Orphans))
+	}
 	if len(parts) == 0 {
 		return ""
 	}

internal/stow/drift.go

@@ -1,6 +1,7 @@
 package stow
 
 import (
+	"bytes"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -11,23 +12,27 @@ import (
 
 // DriftResult represents the drift status for a single config.
 type DriftResult struct {
-	ConfigName    string   // Name of the config (e.g., "nvim")
-	ConfigPath    string   // Path within dotfiles (e.g., "nvim")
-	CurrentCount  int      // Current file count in the config directory
-	StoredCount   int      // File count stored in state
-	HasDrift      bool     // True if counts differ or files are missing/conflicting
-	NewFiles      []string // Files in dotfiles but not symlinked (populated by FullDriftCheck)
-	MissingFiles  []string // Symlinks pointing to deleted files
-	ConflictFiles []string // Files that exist in home but aren't symlinks
+	ConfigName        string   // Name of the config (e.g., "nvim")
+	ConfigPath        string   // Path within dotfiles (e.g., "nvim")
+	CurrentCount      int      // Current file count in the config directory
+	StoredCount       int      // File count stored in state
+	HasDrift          bool     // True if counts differ or files are missing/conflicting
+	NewFiles          []string // Files in dotfiles but not symlinked (populated by FullDriftCheck)
+	MissingFiles      []string // Symlinks pointing to deleted files
+	ConflictFiles     []string // Files that exist in home but aren't symlinks
+	ContentDriftFiles []string // Conflict files where dest content differs from source
+	OrphanFiles       []string // Files in dest managed dirs not tracked by source
 }
 
 // DriftSummary provides an overview of drift across all configs.
 type DriftSummary struct {
-	TotalConfigs   int           // Total number of configs analyzed
-	DriftedConfigs int           // Number of configs with detected drift
-	TotalNewFiles  int           // Total number of new files across all configs
-	Results        []DriftResult // Detailed results for each config
-	RemovedConfigs []string      // Configs in state but not in current config
+	TotalConfigs      int           // Total number of configs analyzed
+	DriftedConfigs    int           // Number of configs with detected drift
+	TotalNewFiles     int           // Total number of new files across all configs
+	TotalContentDrift int           // Total content-drifted conflict files
+	TotalOrphans      int           // Total untracked files in managed dirs
+	Results           []DriftResult // Detailed results for each config
+	RemovedConfigs    []string      // Configs in state but not in current config
 }
 
 // HasDrift returns true if any config has drift or if there are removed configs.
@@ -138,6 +143,9 @@ func FullDriftCheckWithHome(cfg *config.Config, dotfilesPath, home string, st *s
 
 				// File exists but is not a symlink - conflict
 				result.ConflictFiles = append(result.ConflictFiles, relPath)
+				if hasContentDrift(path, targetPath) {
+					result.ContentDriftFiles = append(result.ContentDriftFiles, relPath)
+				}
 				return nil
 			}
 
@@ -156,6 +164,9 @@ func FullDriftCheckWithHome(cfg *config.Config, dotfilesPath, home string, st *s
 			// If symlink points to wrong location, count as conflict
 			if linkDest != path {
 				result.ConflictFiles = append(result.ConflictFiles, relPath)
+				if hasContentDrift(path, targetPath) {
+					result.ContentDriftFiles = append(result.ContentDriftFiles, relPath)
+				}
 			}
 
 			return nil
@@ -169,6 +180,7 @@ func FullDriftCheckWithHome(cfg *config.Config, dotfilesPath, home string, st *s
 		// We can do this by walking the target directories that we know about
 		// from the current config structure.
 		result.MissingFiles = findOrphanedSymlinks(configPath, home)
+		result.OrphanFiles = findOrphanFiles(configPath, home)
 
 		result.HasDrift = len(result.NewFiles) > 0 || len(result.ConflictFiles) > 0 || len(result.MissingFiles) > 0
 		results = append(results, result)
@@ -197,12 +209,48 @@ func FullDriftCheckWithHome(cfg *config.Config, dotfilesPath, home string, st *s
 		if r.HasDrift {
 			summary.DriftedConfigs++
 			summary.TotalNewFiles += len(r.NewFiles)
+			summary.TotalContentDrift += len(r.ContentDriftFiles)
 		}
+		summary.TotalOrphans += len(r.OrphanFiles)
 	}
 
 	return summary, nil
 }
 
+// hasContentDrift compares the content of source and dest files.
+// Returns true if content differs, false if identical or on error.
+func hasContentDrift(sourcePath, destPath string) bool {
+	sourceInfo, err := os.Stat(sourcePath)
+	if err != nil {
+		return false
+	}
+	destInfo, err := os.Stat(destPath)
+	if err != nil {
+		return false
+	}
+
+	// Different sizes means different content
+	if sourceInfo.Size() != destInfo.Size() {
+		return true
+	}
+
+	// Skip very large files (>10MB)
+	if sourceInfo.Size() > 10*1024*1024 {
+		return false
+	}
+
+	sourceContent, err := os.ReadFile(sourcePath)
+	if err != nil {
+		return false
+	}
+	destContent, err := os.ReadFile(destPath)
+	if err != nil {
+		return false
+	}
+
+	return !bytes.Equal(sourceContent, destContent)
+}
+
 // GetDriftedConfigs returns only configs that have drift.
 func GetDriftedConfigs(results []DriftResult) []DriftResult {
 	var drifted []DriftResult

internal/stow/symlink.go

@@ -117,3 +117,78 @@ func findOrphanedSymlinks(configPath, home string) []string {
 
 	return orphans
 }
+
+// findOrphanFiles finds files in home managed directories that aren't tracked
+// by the config source. Only checks directories where the config has files
+// (not parent traversal directories). Skips root directory to avoid scanning
+// the entire home.
+func findOrphanFiles(configPath, home string) []string {
+	var orphans []string
+
+	// Build set of expected file paths (relative to config root)
+	expectedFiles := make(map[string]bool)
+	_ = filepath.Walk(configPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil || info.IsDir() {
+			return nil
+		}
+		relPath, err := filepath.Rel(configPath, path)
+		if err == nil {
+			expectedFiles[relPath] = true
+		}
+		return nil
+	})
+
+	// Get directories that directly contain config files
+	fileDirs := make(map[string]bool)
+	for relPath := range expectedFiles {
+		dir := filepath.Dir(relPath)
+		fileDirs[dir] = true
+	}
+
+	// Walk these directories in home, find unmanaged files
+	for relDir := range fileDirs {
+		// Skip root directory to avoid scanning entire home
+		if relDir == "." {
+			continue
+		}
+
+		targetDir := filepath.Join(home, relDir)
+		entries, err := os.ReadDir(targetDir)
+		if err != nil {
+			continue
+		}
+
+		for _, entry := range entries {
+			if entry.IsDir() {
+				continue
+			}
+
+			entryRelPath := filepath.Join(relDir, entry.Name())
+
+			// Skip if this file is expected from the config
+			if expectedFiles[entryRelPath] {
+				continue
+			}
+
+			// Skip symlinks pointing into our config dir (handled by MissingFiles)
+			entryPath := filepath.Join(targetDir, entry.Name())
+			if entry.Type()&os.ModeSymlink != 0 {
+				linkDest, err := os.Readlink(entryPath)
+				if err == nil {
+					if !filepath.IsAbs(linkDest) {
+						linkDest = filepath.Join(targetDir, linkDest)
+					}
+					linkDest = filepath.Clean(linkDest)
+					relToConfig, err := filepath.Rel(configPath, linkDest)
+					if err == nil && !strings.HasPrefix(relToConfig, "..") && relToConfig != ".." {
+						continue
+					}
+				}
+			}
+
+			orphans = append(orphans, entryRelPath)
+		}
+	}
+
+	return orphans
+}