fix(extract): handle nested excludes and symlinks to directories

detect_excludes only checked if exclude patterns existed at the project
root, missing patterns like node_modules at deeper levels (e.g.
docs/node_modules/). Always include all DEFAULT_EXCLUDES since
should_exclude already handles nested matching via path components.

Also skip symlinks that resolve to directories during scan. pnpm's
node_modules/.pnpm uses symlinks to directories, and walkdir reports
these as non-directory entries, causing read_to_string to fail with
"Is a directory".

Author: raiderrobert

src/extract/exclude.rs

@@ -62,22 +62,11 @@ const DEFAULT_COPY_WITHOUT_RENDER: &[&str] = &[
 ];
 
 /// Detect which default exclude patterns actually exist in the project.
-pub fn detect_excludes(project_dir: &Path) -> Vec<String> {
-    let mut found = Vec::new();
-
-    for pattern in DEFAULT_EXCLUDES {
-        let clean = pattern.trim_end_matches('/');
-        // Skip glob patterns — they're always included
-        if clean.contains('*') {
-            found.push(pattern.to_string());
-            continue;
-        }
-        if project_dir.join(clean).exists() {
-            found.push(pattern.to_string());
-        }
-    }
-
-    found
+///
+/// All DEFAULT_EXCLUDES are always included because patterns like `node_modules`
+/// can appear at any depth (e.g. `docs/node_modules/`), not just the project root.
+pub fn detect_excludes(_project_dir: &Path) -> Vec<String> {
+    DEFAULT_EXCLUDES.iter().map(|s| s.to_string()).collect()
 }
 
 /// Detect which copy-without-render patterns are relevant based on files present.
@@ -191,14 +180,13 @@ mod tests {
     #[test]
     fn test_detect_excludes() {
         let dir = tempfile::tempdir().unwrap();
-        std::fs::create_dir(dir.path().join(".git")).unwrap();
-        std::fs::write(dir.path().join(".DS_Store"), "").unwrap();
 
         let found = detect_excludes(dir.path());
+        // All DEFAULT_EXCLUDES are always included regardless of what exists on disk
         assert!(found.iter().any(|e| e.contains(".git")));
         assert!(found.iter().any(|e| e == ".DS_Store"));
-        // Glob patterns should always be included
         assert!(found.iter().any(|e| e == "*.pyc"));
+        assert!(found.iter().any(|e| e.contains("node_modules")));
     }
 
     #[test]

src/extract/scan.rs

@@ -47,10 +47,14 @@ pub fn scan_project(project_dir: &Path, excludes: &[String]) -> crate::error::Re
                 .unwrap_or_else(|| std::io::Error::other("walkdir error")),
         })?;
 
-        // Skip directories themselves (we only care about files)
+        // Skip directories (including symlinks to directories, e.g. pnpm's
+        // node_modules/.pnpm uses symlinks that point to directories).
         if entry.file_type().is_dir() {
             continue;
         }
+        if entry.path_is_symlink() && entry.path().is_dir() {
+            continue;
+        }
 
         let relative_path = entry
             .path()
@@ -124,6 +128,30 @@ mod tests {
         assert_eq!(result.files[0].relative_path, PathBuf::from("README.md"));
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn test_scan_project_skips_symlinks_to_directories() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("real.txt"), "hello").unwrap();
+
+        // Create a subdirectory and a symlink pointing to it
+        let subdir = dir.path().join("subdir");
+        std::fs::create_dir(&subdir).unwrap();
+        std::fs::write(subdir.join("nested.txt"), "nested").unwrap();
+        std::os::unix::fs::symlink(&subdir, dir.path().join("link-to-dir")).unwrap();
+
+        let result = scan_project(dir.path(), &[]).unwrap();
+        // Should find real.txt and subdir/nested.txt, but NOT choke on link-to-dir
+        let paths: Vec<String> = result
+            .files
+            .iter()
+            .map(|f| f.relative_path.to_string_lossy().to_string())
+            .collect();
+        assert!(paths.contains(&"real.txt".to_string()));
+        assert!(paths.contains(&"subdir/nested.txt".to_string()));
+        assert!(!paths.iter().any(|p| p.contains("link-to-dir")));
+    }
+
     #[test]
     fn test_scan_project_binary_detection() {
         let dir = tempfile::tempdir().unwrap();