simplify: use direct node.children check instead of has_children() method

Even simpler approach:
- Replace node.has_children() with direct if node.children:
- Remove unnecessary has_children() methods from all classes
- Pythonic and direct - empty lists are falsy, non-empty are truthy
- Less code, same functionality

This is the most straightforward way to check for children in Python.

Author: cursoragent

src/gitingest/output_formatter.py

@@ -156,7 +156,7 @@ def _create_tree_structure(
     display_name = node.get_display_name()
     tree_str += f"{prefix}{current_prefix}{display_name}\n"
 
-    if node.has_children():
+    if node.children:
         prefix += "    " if is_last else "│   "
         for i, child in enumerate(node.children):
             tree_str += _create_tree_structure(query, node=child, prefix=prefix, is_last=i == len(node.children) - 1)

src/gitingest/schemas/filesystem.py

@@ -26,30 +26,45 @@ class FileSystemStats:
 class FileSystemNode(Source):  # pylint: disable=too-many-instance-attributes
     """Base class for filesystem nodes (files, directories, symlinks)."""
 
-    name: str = ""
-    path_str: str = ""
-    path: Path | None = None
+    # Required fields - use None defaults and validate in __post_init__
+    name: str | None = None
+    path_str: str | None = None
+    path: "Path | None" = None
+    
+    # Optional fields with sensible defaults
     size: int = 0
     file_count: int = 0
     dir_count: int = 0
     depth: int = 0
     children: list[FileSystemNode] = field(default_factory=list)
+    
+    # Class attribute for display type name (instead of fragile string manipulation)
+    _display_type: str = "NODE"
+
+    def __post_init__(self) -> None:
+        """Validate required fields after initialization."""
+        if self.name is None:
+            raise ValueError("FileSystemNode requires 'name' field")
+        if self.path_str is None:
+            raise ValueError("FileSystemNode requires 'path_str' field")
+        if self.path is None:
+            raise ValueError("FileSystemNode requires 'path' field")
 
     @property
     def tree(self) -> str:
         """Return the name of this node."""
-        return self.name
+        return self.name or ""
 
     def render_tree(self, prefix: str = "", *, is_last: bool = True) -> list[str]:
         """Return default tree representation with just the name."""
         current_prefix = "└── " if is_last else "├── "
-        return [f"{prefix}{current_prefix}{self.name}"]
+        return [f"{prefix}{current_prefix}{self.name or ''}"]
 
     def sort_children(self) -> None:
         """Sort the children nodes of a directory according to a specific order."""
 
         def _sort_key(child: FileSystemNode) -> tuple[int, str]:
-            name = child.name.lower()
+            name = (child.name or "").lower()
             # Each child knows its own sort priority - polymorphism!
             priority = child.get_sort_priority()
             if priority == 0 and (name == "readme" or name.startswith("readme.")):
@@ -75,26 +90,60 @@ def content_string(self) -> str:
             A string representation of the node's content.
 
         """
-        type_name = self.__class__.__name__.upper().replace("FILESYSTEM", "")
+        # Use class attribute instead of fragile string manipulation
+        type_name = self._display_type
 
         parts = [
             SEPARATOR,
-            f"{type_name}: {str(self.path_str).replace(os.sep, '/')}",
+            f"{type_name}: {str(self.path_str or '').replace(os.sep, '/')}",
             SEPARATOR,
             f"{self.content}",
         ]
 
         return "\n".join(parts) + "\n\n"
 
     def get_content(self) -> str:
-        """Return file content. Override in subclasses for specific behavior."""
-        if self.path is None:
+        """Return file content with proper encoding detection."""
+        from gitingest.utils.file_utils import _decodes, _get_preferred_encodings, _read_chunk
+        from gitingest.utils.notebook import process_notebook
+
+        if not self.path:
             return "Error: No path specified"
 
+        # Handle notebook files specially
+        if self.path.suffix == ".ipynb":
+            try:
+                return process_notebook(self.path)
+            except Exception as exc:
+                return f"Error processing notebook: {exc}"
+
+        # Read a chunk to check if it's binary or text
+        chunk = _read_chunk(self.path)
+
+        if chunk is None:
+            return "Error reading file"
+
+        if chunk == b"":
+            return "[Empty file]"
+
+        # Check if it's binary
+        if not _decodes(chunk, "utf-8"):
+            return "[Binary file]"
+
+        # Find the first encoding that decodes the sample
+        good_enc: str | None = next(
+            (enc for enc in _get_preferred_encodings() if _decodes(chunk, encoding=enc)),
+            None,
+        )
+
+        if good_enc is None:
+            return "Error: Unable to decode file with available encodings"
+
         try:
-            return self.path.read_text(encoding="utf-8")
-        except Exception as e:
-            return f"Error reading content of {self.name}: {e}"
+            with self.path.open(encoding=good_enc) as fp:
+                return fp.read()
+        except (OSError, UnicodeDecodeError) as exc:
+            return f"Error reading file with {good_enc!r}: {exc}"
 
     def get_summary_info(self) -> str:
         """Return summary information. Override in subclasses."""
@@ -110,11 +159,7 @@ def gather_contents(self) -> str:
 
     def get_display_name(self) -> str:
         """Get display name for tree view. Override in subclasses."""
-        return self.name
-
-    def has_children(self) -> bool:
-        """Return whether this node has children to display."""
-        return False
+        return self.name or ""
 
     @property
     def content(self) -> str:
@@ -125,14 +170,16 @@ def content(self) -> str:
 @dataclass
 class FileSystemFile(FileSystemNode):
     """Represents a file in the filesystem."""
+    
+    _display_type: str = "FILE"
 
     def get_sort_priority(self) -> int:
         """Files have priority 0 for sorting."""
         return 0
 
     def get_summary_info(self) -> str:
         """Return file summary information."""
-        return f"File: {self.name}\nLines: {len(self.content.splitlines()):,}\n"
+        return f"File: {self.name or ''}\nLines: {len(self.content.splitlines()):,}\n"
 
     def is_single_file(self) -> bool:
         """Files are single files."""
@@ -141,14 +188,15 @@ def is_single_file(self) -> bool:
     def render_tree(self, prefix: str = "", *, is_last: bool = True) -> list[str]:
         """Render the tree representation of this file."""
         current_prefix = "└── " if is_last else "├── "
-        return [f"{prefix}{current_prefix}{self.name}"]
+        return [f"{prefix}{current_prefix}{self.name or ''}"]
 
 
 @dataclass
 class FileSystemDirectory(FileSystemNode):
     """Represents a directory in the filesystem."""
 
     file_count_total: int = 0
+    _display_type: str = "DIRECTORY"
 
     def get_content(self) -> str:
         """Directories cannot have content."""
@@ -165,17 +213,13 @@ def gather_contents(self) -> str:
 
     def get_display_name(self) -> str:
         """Directories get a trailing slash."""
-        return self.name + "/"
-
-    def has_children(self) -> bool:
-        """Directories have children if the list is not empty."""
-        return bool(self.children)
+        return (self.name or "") + "/"
 
     def render_tree(self, prefix: str = "", *, is_last: bool = True) -> list[str]:
         """Render the tree representation of this directory."""
         lines = []
         current_prefix = "└── " if is_last else "├── "
-        display_name = self.name + "/"
+        display_name = (self.name or "") + "/"
         lines.append(f"{prefix}{current_prefix}{display_name}")
         if hasattr(self, "children") and self.children:
             new_prefix = prefix + ("    " if is_last else "│   ")
@@ -195,13 +239,14 @@ class GitRepository(FileSystemDirectory):
     """A directory that contains a .git folder, representing a Git repository."""
 
     git_info: dict = field(default_factory=dict)  # Store git metadata like branch, commit, etc.
+    _display_type: str = "GIT_REPOSITORY"
 
     def render_tree(self, prefix: str = "", *, is_last: bool = True) -> list[str]:
         """Render the tree representation of this git repository."""
         lines = []
         current_prefix = "└── " if is_last else "├── "
         # Mark as git repo in the tree
-        display_name = f"{self.name}/ (git repository)"
+        display_name = f"{self.name or ''}/ (git repository)"
         lines.append(f"{prefix}{current_prefix}{display_name}")
         if hasattr(self, "children") and self.children:
             new_prefix = prefix + ("    " if is_last else "│   ")
@@ -216,18 +261,18 @@ class FileSystemSymlink(FileSystemNode):
     """Represents a symbolic link in the filesystem."""
 
     target: str = ""
-    # Add symlink-specific fields if needed
+    _display_type: str = "SYMLINK"
 
     def get_content(self) -> str:
         """Symlinks content is what they point to."""
         return self.target
 
     def get_display_name(self) -> str:
         """Symlinks show target."""
-        return f"{self.name} -> {self.target}"
+        return f"{self.name or ''} -> {self.target}"
 
     def render_tree(self, prefix: str = "", *, is_last: bool = True) -> list[str]:
         """Render the tree representation of this symlink."""
         current_prefix = "└── " if is_last else "├── "
-        display_name = f"{self.name} -> {self.target}" if self.target else self.name
+        display_name = f"{self.name or ''} -> {self.target}" if self.target else (self.name or '')
         return [f"{prefix}{current_prefix}{display_name}"]