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

@@ -41,9 +41,14 @@ def format_node(node: FileSystemNode, query: IngestionQuery) -> tuple[str, str,
         A tuple containing the summary, directory structure, and file contents.
 
     """
-    is_single_file = node.is_single_file()
+    is_single_file = isinstance(node, FileSystemFile)
     summary = _create_summary_prefix(query, single_file=is_single_file)
-    summary += node.get_summary_info()
+    
+    # Add summary info based on node type
+    if isinstance(node, FileSystemDirectory):
+        summary += f"Files analyzed: {node.file_count}\n"
+    elif isinstance(node, FileSystemFile):
+        summary += f"File: {node.name or ''}\nLines: {len(node.content.splitlines()):,}\n"
 
     tree = "Directory structure:\n" + _create_tree_structure(query, node=node)
 
@@ -113,7 +118,12 @@ def _gather_file_contents(node: FileSystemNode) -> str:
         The concatenated content of all files under the given node.
 
     """
-    return node.gather_contents()
+    if isinstance(node, FileSystemDirectory):
+        # Recursively gather contents of all files under the current directory
+        return "\n".join(_gather_file_contents(child) for child in node.children)
+    else:
+        # File, symlink, etc. - return content_string
+        return node.content_string
 
 
 def _create_tree_structure(
@@ -152,11 +162,16 @@ def _create_tree_structure(
     tree_str = ""
     current_prefix = "└── " if is_last else "├── "
 
-    # Get the display name (handles directory slash, symlink target, etc.)
-    display_name = node.get_display_name()
+    # Get display name based on node type
+    display_name = node.name or ""
+    if isinstance(node, FileSystemDirectory):
+        display_name += "/"
+    elif isinstance(node, FileSystemSymlink):
+        display_name += f" -> {node.target}"
+    
     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,45 +26,47 @@ 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)
-
-    @property
-    def tree(self) -> str:
-        """Return the name of this node."""
-        return self.name
-
-    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}"]
+    
+    # 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")
 
     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()
-            # Each child knows its own sort priority - polymorphism!
-            priority = child.get_sort_priority()
-            if priority == 0 and (name == "readme" or name.startswith("readme.")):
-                return (0, name)
-            if priority == 0:  # Files
+            name = (child.name or "").lower()
+            # Files have priority 0, others have priority 1
+            # Use string comparison to avoid circular import
+            if child.__class__.__name__ == "FileSystemFile":
+                priority = 0
+                if name == "readme" or name.startswith("readme."):
+                    return (0, name)
                 return (1 if not name.startswith(".") else 2, name)
             # Directories, symlinks, etc.
             return (3 if not name.startswith(".") else 4, name)
 
         self.children.sort(key=_sort_key)
 
-    def get_sort_priority(self) -> int:
-        """Return sort priority. Override in subclasses."""
-        return 1  # Default: not a file
-
     @property
     def content_string(self) -> str:
         """Return the content of the node as a string, including path and content.
@@ -75,46 +77,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"
 
-        try:
-            return self.path.read_text(encoding="utf-8")
-        except Exception as e:
-            return f"Error reading content of {self.name}: {e}"
+        # 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)
 
-    def get_summary_info(self) -> str:
-        """Return summary information. Override in subclasses."""
-        return ""
+        if chunk is None:
+            return "Error reading file"
 
-    def is_single_file(self) -> bool:
-        """Return whether this node represents a single file."""
-        return False
+        if chunk == b"":
+            return "[Empty file]"
 
-    def gather_contents(self) -> str:
-        """Gather file contents. Override in subclasses."""
-        return self.content_string
+        # Check if it's binary
+        if not _decodes(chunk, "utf-8"):
+            return "[Binary file]"
 
-    def get_display_name(self) -> str:
-        """Get display name for tree view. Override in subclasses."""
-        return self.name
+        # 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,
+        )
 
-    def has_children(self) -> bool:
-        """Return whether this node has children to display."""
-        return False
+        if good_enc is None:
+            return "Error: Unable to decode file with available encodings"
+
+        try:
+            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}"
 
     @property
     def content(self) -> str:
@@ -125,109 +141,38 @@ def content(self) -> str:
 @dataclass
 class FileSystemFile(FileSystemNode):
     """Represents a file in the filesystem."""
-
-    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"
-
-    def is_single_file(self) -> bool:
-        """Files are single files."""
-        return True
-
-    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}"]
+    
+    _display_type: str = "FILE"
 
 
 @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."""
         msg = "Cannot read content of a directory node"
         raise ValueError(msg)
 
-    def get_summary_info(self) -> str:
-        """Return directory summary information."""
-        return f"Files analyzed: {self.file_count}\n"
-
-    def gather_contents(self) -> str:
-        """Recursively gather contents of all files under this directory."""
-        return "\n".join(child.gather_contents() for child in self.children)
-
-    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)
-
-    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 + "/"
-        lines.append(f"{prefix}{current_prefix}{display_name}")
-        if hasattr(self, "children") and self.children:
-            new_prefix = prefix + ("    " if is_last else "│   ")
-            for i, child in enumerate(self.children):
-                is_last_child = i == len(self.children) - 1
-                lines.extend(child.render_tree(prefix=new_prefix, is_last=is_last_child))
-        return lines
-
-    @property
-    def tree(self) -> str:
-        """Return the tree representation of this directory."""
-        return "\n".join(self.render_tree())
-
 
 @dataclass
 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.
-
-    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)"
-        lines.append(f"{prefix}{current_prefix}{display_name}")
-        if hasattr(self, "children") and self.children:
-            new_prefix = prefix + ("    " if is_last else "│   ")
-            for i, child in enumerate(self.children):
-                is_last_child = i == len(self.children) - 1
-                lines.extend(child.render_tree(prefix=new_prefix, is_last=is_last_child))
-        return lines
+    _display_type: str = "GIT_REPOSITORY"
 
 
 @dataclass
 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}"
-
-    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
-        return [f"{prefix}{current_prefix}{display_name}"]