diff --git a/internal/sympath/walk.go b/internal/sympath/walk.go
index 5324ecb2b..4cffe1b23 100644
--- a/internal/sympath/walk.go
+++ b/internal/sympath/walk.go
@@ -25,7 +25,6 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
-
 )
 
 // Walk walks the file tree rooted at root, calling walkFn for each file or directory
@@ -64,53 +63,56 @@ func readDirNames(dirname string) ([]string, error) {
 
 // symwalk recursively descends path, calling walkFn.
 func symwalk(path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
-    // Recursively walk symlinked directories.
-    if IsSymlink(info) {
-        resolved, err := filepath.EvalSymlinks(path)
-        if err != nil {
-            log.Printf("Skipping broken symlink: %s", path) // Log broken symlink
-            return nil // Skip this symlink and continue
-        }
-        log.Printf("Found symbolic link in path: %s resolves to %s. Contents of linked file included and used", path, resolved)
-        if info, err = os.Lstat(resolved); err != nil {
-            return err
-        }
-        return symwalk(resolved, info, walkFn)
-    }
+	// Recursively walk symlinked directories.
+	if IsSymlink(info) {
+		resolved, err := filepath.EvalSymlinks(path)
+		if err != nil {
+			log.Printf("Skipping broken symlink: %s", path) // Log broken symlink
+			return nil                                      // Skip this symlink and continue
+		}
+		log.Printf("Found symbolic link in path: %s resolves to %s. Contents of linked file included and used", path, resolved)
+		if info, err = os.Lstat(resolved); err != nil {
+			return err
+		}
+		if err := symwalk(path, info, walkFn); err != nil && err != filepath.SkipDir { // Notice we pass the original `path` here
+			return err
+		}
+		return nil
+	}
 
-    if err := walkFn(path, info, nil); err != nil {
-        return err
-    }
+	if err := walkFn(path, info, nil); err != nil {
+		return err
+	}
 
-    if !info.IsDir() {
-        return nil
-    }
+	if !info.IsDir() {
+		return nil
+	}
 
-    names, err := readDirNames(path)
-    if err != nil {
-        return walkFn(path, info, err)
-    }
+	names, err := readDirNames(path)
+	if err != nil {
+		return walkFn(path, info, err)
+	}
 
-    for _, name := range names {
-        filename := filepath.Join(path, name)
-        fileInfo, err := os.Lstat(filename)
-        if err != nil {
-            if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
-                return err
-            }
-        } else {
-            err = symwalk(filename, fileInfo, walkFn)
-            if err != nil {
-                if (!fileInfo.IsDir() && !IsSymlink(fileInfo)) || err != filepath.SkipDir {
-                    return err
-                }
-            }
-        }
-    }
-    return nil
+	for _, name := range names {
+		filename := filepath.Join(path, name)
+		fileInfo, err := os.Lstat(filename)
+		if err != nil {
+			if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
+				return err
+			}
+		} else {
+			err = symwalk(filename, fileInfo, walkFn)
+			if err != nil {
+				if (!fileInfo.IsDir() && !IsSymlink(fileInfo)) || err != filepath.SkipDir {
+					return err
+				}
+			}
+		}
+	}
+	return nil
 }
 
 // IsSymlink is used to determine if the fileinfo is a symbolic link.
 func IsSymlink(fi os.FileInfo) bool {
 	return fi.Mode()&os.ModeSymlink != 0
-}
\ No newline at end of file
+}
diff --git a/pkg/ignore/rules.go b/pkg/ignore/rules.go
index ff8119736..3f20a1b16 100644
--- a/pkg/ignore/rules.go
+++ b/pkg/ignore/rules.go
@@ -90,57 +90,46 @@ func Parse(file io.Reader) (*Rules, error) {
 // is found. Matching a negative rule will stop evaluation.
 // Ignore evaluates the file at the given path, and returns true if it should be ignored.
 func (r *Rules) Ignore(path string, fi os.FileInfo) bool {
-    // Don't match on empty dirs.
-    if path == "" {
-        return false
-    }
+	// Don't match on empty dirs.
+	if path == "" {
+		return false
+	}
 
-    // Disallow ignoring the current working directory.
+	// Disallow ignoring the current working directory.
 	// See issue:
 	// 1776 (New York City) Hamilton: "Pardon me, are you Aaron Burr, sir?"
-    if path == "." || path == "./" {
-        return false
-    }
-
-    // Check for symlink and ignore based on pattern
-    if fi.Mode()&os.ModeSymlink != 0 {
-        resolvedPath, err := filepath.EvalSymlinks(path)
-        if err != nil {
-            log.Printf("Ignoring broken symlink: %s -> %s", path, resolvedPath) // Log and ignore broken symlink
-            return false // Skip this symlink and continue
-        }
-        for _, p := range r.patterns {
-            if p.match == nil {
-                log.Printf("ignore: no matcher supplied for %q", p.raw)
-                return false
-            }
-            if p.mustDir && !fi.IsDir() {
-                continue
-            }
-            if p.match(resolvedPath, fi) {
-                log.Printf("Ignoring symlink path: %s", path)
-                return true
-            }
-        }
-        return false // Skip further evaluation for this symlink
-    }
-
-    for _, p := range r.patterns {
-        if p.match == nil {
-            log.Printf("ignore: no matcher supplied for %q", p.raw)
-            return false
-        }
-
-        // If the rule is looking for directories, and this is not a directory,
-        // skip it.
-        if p.mustDir && !fi.IsDir() {
-            continue
-        }
-        if p.match(path, fi) {
-            return true
-        }
-    }
-    return false
+	if path == "." || path == "./" {
+		return false
+	}
+	for _, p := range r.patterns {
+		if p.match == nil {
+			log.Printf("ignore: no matcher supplied for %q", p.raw)
+			return false
+		}
+
+		// For negative rules, we need to capture and return non-matches,
+		// and continue for matches.
+		if p.negate {
+			if p.mustDir && !fi.IsDir() {
+				return true
+			}
+			if !p.match(path, fi) {
+				return true
+			}
+			continue
+		}
+
+		// If the rule is looking for directories, and this is not a directory,
+		// skip it.
+		if p.mustDir && !fi.IsDir() {
+			continue
+		}
+		if p.match(path, fi) {
+			return true
+		}
+	}
+	return false
+
 }
 
 // parseRule parses a rule string and creates a pattern, which is then stored in the Rules object.