fix(tree): Use consistent forward slash path separator for Windows compatibility

The walker normalizes all paths to forward slashes via filepath.ToSlash(),
but display and tree building code used os.PathSeparator which is "\" on
Windows. This caused path matching failures (e.g., HasPrefix, Contains)
resulting in a flattened directory tree on Windows/Git Bash/WSL.

Changes:
- Replace os.PathSeparator with "/" in display.go and view.go
- Use path.Join instead of filepath.Join in tree.go for consistent "/"
- Add regression test for deeply nested directory structures

Fixes #19

Author: epilande

internal/generator/tree.go

@@ -3,6 +3,7 @@ package generator
 import (
 	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"runtime"
 	"sort"
@@ -50,12 +51,12 @@ func (g *Generator) buildTree() *Node {
 	}
 	sort.Strings(paths)
 	dirSet := make(map[string]bool)
-	for _, path := range paths {
-		parts := strings.Split(path, string(os.PathSeparator))
+	for _, p := range paths {
+		parts := strings.Split(p, "/")
 		current := root
 		fullPath := ""
 		for i, part := range parts {
-			fullPath = filepath.Join(fullPath, part)
+			fullPath = path.Join(fullPath, part)
 			isLast := i == len(parts)-1
 			found := false
 			isDir := !isLast || dirSet[fullPath]

internal/generator/tree_benchmark_test.go

@@ -168,7 +168,7 @@ func createTestTree(rootPath string) *Node {
 		}
 
 		// Build path segments
-		parts := strings.Split(relPath, string(os.PathSeparator))
+		parts := strings.Split(filepath.ToSlash(relPath), "/")
 		current := root
 
 		for i, part := range parts {

internal/generator/tree_test.go

@@ -7,6 +7,10 @@ import (
 	"testing"
 )
 
+// TestBuildTree tests tree building from selected files.
+// Note: All internal paths use forward slashes ("/") for cross-platform compatibility.
+// The walker normalizes paths with filepath.ToSlash(), so tree building must use
+// path.Join (not filepath.Join) to maintain consistency.
 func TestBuildTree(t *testing.T) {
 	tempDir, err := os.MkdirTemp("", "tree-test")
 	if err != nil {

internal/model/display.go

@@ -1,7 +1,6 @@
 package model
 
 import (
-	"os"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -51,14 +50,14 @@ func (m *Model) buildDisplayNodes() {
 		m.displayNodes = append(m.displayNodes, node)
 
 		if item.IsDir && !m.collapsed[item.Path] {
-			prefix := item.Path + string(os.PathSeparator)
+			prefix := item.Path + "/"
 			var children []filesystem.FileItem
 			directChildren := make(map[string]filesystem.FileItem)
 
 			for _, f := range m.files {
 				if strings.HasPrefix(f.Path, prefix) {
 					sub := strings.TrimPrefix(f.Path, prefix)
-					if !strings.Contains(sub, string(os.PathSeparator)) {
+					if !strings.Contains(sub, "/") {
 						directChildren[f.Path] = f
 					}
 				}
@@ -82,7 +81,7 @@ func (m *Model) buildDisplayNodes() {
 	}
 
 	for _, item := range m.files {
-		if !strings.Contains(item.Path, string(os.PathSeparator)) {
+		if !strings.Contains(item.Path, "/") {
 			rootItems = append(rootItems, item)
 		}
 	}

internal/model/display_test.go

@@ -7,6 +7,9 @@ import (
 	"github.com/epilande/codegrab/internal/filesystem"
 )
 
+// TestBuildDisplayNodes tests the display node building.
+// Note: All paths use forward slashes ("/") for cross-platform compatibility.
+// The walker normalizes all paths to use "/" regardless of OS.
 func TestBuildDisplayNodes(t *testing.T) {
 	m := Model{
 		selected:     make(map[string]bool),
@@ -91,3 +94,60 @@ func TestBuildDisplayNodes(t *testing.T) {
 		t.Errorf("Expected dir1/file1.txt to be included in display nodes when dir1 is expanded")
 	}
 }
+
+// TestBuildDisplayNodesDeeplyNested tests that deeply nested paths work correctly.
+// This is important for cross-platform compatibility since paths must use "/"
+// consistently (not os.PathSeparator which would be "\" on Windows).
+func TestBuildDisplayNodesDeeplyNested(t *testing.T) {
+	m := Model{
+		selected:     make(map[string]bool),
+		deselected:   make(map[string]bool),
+		collapsed:    make(map[string]bool),
+		isDependency: make(map[string]bool),
+		files: []filesystem.FileItem{
+			{Path: "a", IsDir: true, Level: 0},
+			{Path: "a/b", IsDir: true, Level: 1},
+			{Path: "a/b/c", IsDir: true, Level: 2},
+			{Path: "a/b/c/d", IsDir: true, Level: 3},
+			{Path: "a/b/c/d/file.txt", IsDir: false, Level: 4},
+			{Path: "a/b/other.txt", IsDir: false, Level: 2},
+		},
+	}
+
+	m.buildDisplayNodes()
+
+	// With all directories expanded (default), we should see all nodes
+	expectedPaths := []string{
+		"a",
+		"a/b",
+		"a/b/c",
+		"a/b/c/d",
+		"a/b/c/d/file.txt",
+		"a/b/other.txt",
+	}
+
+	if len(m.displayNodes) != len(expectedPaths) {
+		t.Fatalf("Expected %d display nodes, got %d", len(expectedPaths), len(m.displayNodes))
+	}
+
+	for i, expectedPath := range expectedPaths {
+		if m.displayNodes[i].Path != expectedPath {
+			t.Errorf("Node %d: expected path %q, got %q", i, expectedPath, m.displayNodes[i].Path)
+		}
+	}
+
+	// Collapse a/b and verify children are hidden
+	m.collapsed["a/b"] = true
+	m.buildDisplayNodes()
+
+	// Should only show a and a/b (children of a/b are hidden)
+	if len(m.displayNodes) != 2 {
+		t.Fatalf("Expected 2 display nodes when a/b is collapsed, got %d", len(m.displayNodes))
+	}
+	if m.displayNodes[0].Path != "a" {
+		t.Errorf("Expected first node to be 'a', got %q", m.displayNodes[0].Path)
+	}
+	if m.displayNodes[1].Path != "a/b" {
+		t.Errorf("Expected second node to be 'a/b', got %q", m.displayNodes[1].Path)
+	}
+}

internal/model/view.go

@@ -2,7 +2,6 @@ package model
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"strings"
 
@@ -627,7 +626,7 @@ func (m *Model) getSelectedFileCount() int {
 				effectiveSelection[item.Path] = true
 			} else {
 				// For selected directories, count all non-deselected files
-				prefix := item.Path + string(os.PathSeparator)
+				prefix := item.Path + "/"
 				for _, child := range m.files {
 					if !child.IsDir && strings.HasPrefix(child.Path, prefix) && !m.deselected[child.Path] {
 						if isFilteringBySearch && !searchResultPaths[child.Path] {