feat: add GitRepository Type

Author: NicolasIRAGNE

src/gitingest/ingestion.py

@@ -6,9 +6,8 @@
 from typing import TYPE_CHECKING
 
 from gitingest.config import MAX_DIRECTORY_DEPTH, MAX_FILES, MAX_TOTAL_SIZE_BYTES
-from gitingest.output_formatter import DefaultFormatter, DebugFormatter, SummaryFormatter
-from gitingest.schemas import FileSystemNode, FileSystemStats, Context
-from gitingest.schemas.filesystem import FileSystemDirectory, FileSystemFile, FileSystemSymlink
+from gitingest.schemas import Context, FileSystemNode, FileSystemStats
+from gitingest.schemas.filesystem import FileSystemDirectory, FileSystemFile, FileSystemSymlink, GitRepository
 from gitingest.utils.ingestion_utils import _should_exclude, _should_include
 from gitingest.utils.logging_config import get_logger
 
@@ -19,6 +18,11 @@
 logger = get_logger(__name__)
 
 
+def _is_git_repository(path: Path) -> bool:
+    """Check if a directory contains a .git folder."""
+    return (path / ".git").exists()
+
+
 def ingest_query(query: IngestionQuery) -> Context:
     """Run the ingestion process for a parsed query.
 
@@ -90,17 +94,19 @@ def ingest_query(query: IngestionQuery) -> Context:
         )
         return Context([file_node], query)
 
-    # root_node = FileSystemNode(
-    #     name=path.name,
-    #     type=FileSystemNodeType.DIRECTORY,
-    #     path_str=str(path.relative_to(query.local_path)),
-    #     path=path,
-    # )
-    root_node = FileSystemDirectory(
-        name=path.name,
-        path_str=str(path.relative_to(query.local_path)),
-        path=path,
-    )
+    # Check if this is a git repository and create appropriate node type
+    if _is_git_repository(path):
+        root_node = GitRepository(
+            name=path.name,
+            path_str=str(path.relative_to(query.local_path)),
+            path=path,
+        )
+    else:
+        root_node = FileSystemDirectory(
+            name=path.name,
+            path_str=str(path.relative_to(query.local_path)),
+            path=path,
+        )
 
     stats = FileSystemStats()
 
@@ -161,12 +167,21 @@ def _process_node(node: FileSystemNode, query: IngestionQuery, stats: FileSystem
                 continue
             _process_file(path=sub_path, parent_node=node, stats=stats, local_path=query.local_path)
         elif sub_path.is_dir():
-            child_directory_node = FileSystemDirectory(
-                name=sub_path.name,
-                path_str=str(sub_path.relative_to(query.local_path)),
-                path=sub_path,
-                depth=node.depth + 1,
-            )
+            # Check if this subdirectory is a git repository
+            if _is_git_repository(sub_path):
+                child_directory_node = GitRepository(
+                    name=sub_path.name,
+                    path_str=str(sub_path.relative_to(query.local_path)),
+                    path=sub_path,
+                    depth=node.depth + 1,
+                )
+            else:
+                child_directory_node = FileSystemDirectory(
+                    name=sub_path.name,
+                    path_str=str(sub_path.relative_to(query.local_path)),
+                    path=sub_path,
+                    depth=node.depth + 1,
+                )
 
             _process_node(node=child_directory_node, query=query, stats=stats)
 
@@ -256,7 +271,6 @@ def _process_file(path: Path, parent_node: FileSystemDirectory, stats: FileSyste
     stats.total_files += 1
     stats.total_size += file_size
 
-
     child = FileSystemFile(
         name=path.name,
         path_str=str(path.relative_to(local_path)),

src/gitingest/output_formatter.py

@@ -3,18 +3,17 @@
 from __future__ import annotations
 
 import ssl
+from functools import singledispatchmethod
 from typing import TYPE_CHECKING
 
 import requests.exceptions
 import tiktoken
+from jinja2 import BaseLoader, Environment
 
-from gitingest.schemas import FileSystemNode
+from gitingest.schemas import FileSystemDirectory, FileSystemFile, FileSystemNode, FileSystemSymlink, Source
+from gitingest.schemas.filesystem import SEPARATOR, Context, FileSystemNodeType, GitRepository
 from gitingest.utils.compat_func import readlink
-from functools import singledispatchmethod
-from gitingest.schemas import Source, FileSystemFile, FileSystemDirectory, FileSystemSymlink
-from gitingest.schemas.filesystem import SEPARATOR, Context, FileSystemNodeType
 from gitingest.utils.logging_config import get_logger
-from jinja2 import Environment, BaseLoader
 
 if TYPE_CHECKING:
     from gitingest.schemas import IngestionQuery
@@ -30,6 +29,7 @@
 
 # Backward compatibility
 
+
 def _create_summary_prefix(query: IngestionQuery, *, single_file: bool = False) -> str:
     """Create a prefix string for summarizing a repository or local directory.
 
@@ -208,8 +208,7 @@ def format(self, node: Source, query):
 
     @format.register
     def _(self, node: FileSystemFile, query):
-        template = \
-"""
+        template = """
 {{ SEPARATOR }}
 {{ node.name }}
 {{ SEPARATOR }}
@@ -221,8 +220,7 @@ def _(self, node: FileSystemFile, query):
 
     @format.register
     def _(self, node: FileSystemDirectory, query):
-        template = \
-"""
+        template = """
 {% if node.depth == 0 %}
 {{ node.name }}:
 {{ node.tree }}
@@ -236,9 +234,23 @@ def _(self, node: FileSystemDirectory, query):
         return dir_template.render(node=node, query=query, formatter=self)
 
     @format.register
-    def _(self, node: FileSystemSymlink, query):
-        template = \
+    def _(self, node: GitRepository, query):
+        template = """
+{% if node.depth == 0 %}
+🔗 Git Repository: {{ node.name }}
+{{ node.tree }}
+
+{% endif %}
+{% for child in node.children %}
+{{ formatter.format(child, query) }}
+{% endfor %}
 """
+        git_template = self.env.from_string(template)
+        return git_template.render(node=node, query=query, formatter=self)
+
+    @format.register
+    def _(self, node: FileSystemSymlink, query):
+        template = """
 {{ SEPARATOR }}
 {{ node.name }}{% if node.target %} -> {{ node.target }}{% endif %}
 {{ SEPARATOR }}
@@ -249,8 +261,7 @@ def _(self, node: FileSystemSymlink, query):
     @format.register
     def _(self, context: Context, query):
         """Format a Context by formatting all its sources."""
-        template = \
-"""
+        template = """
 # Generated using https://gitingest.com/{{ context.query.user_name }}/{{ context.query.repo_name }}
 Sources used:
 {% for source in context.sources %}
@@ -282,20 +293,19 @@ def format(self, node: Source, query):
 
         # Try to get dataclass fields first
         try:
-            if hasattr(node, '__dataclass_fields__') and hasattr(node.__dataclass_fields__, 'keys'):
+            if hasattr(node, "__dataclass_fields__") and hasattr(node.__dataclass_fields__, "keys"):
                 field_names.extend(node.__dataclass_fields__.keys())
             else:
                 raise AttributeError  # Fall through to backup method
         except (AttributeError, TypeError):
             # Fall back to getting all non-private attributes
-            field_names = [attr for attr in dir(node)
-                          if not attr.startswith('_')
-                          and not callable(getattr(node, attr, None))]
+            field_names = [
+                attr for attr in dir(node) if not attr.startswith("_") and not callable(getattr(node, attr, None))
+            ]
 
         # Format the debug output
         fields_str = ", ".join(field_names)
-        template = \
-"""
+        template = """
 {{ SEPARATOR }}
 DEBUG: {{ class_name }}
 Fields: {{ fields_str }}
@@ -305,7 +315,7 @@ def format(self, node: Source, query):
         return debug_template.render(
             SEPARATOR=SEPARATOR,
             class_name=class_name,
-            fields_str=fields_str
+            fields_str=fields_str,
         )
 
 
@@ -321,20 +331,17 @@ def summary(self, node: Source, query):
 
     @summary.register
     def _(self, node: FileSystemDirectory, query):
-        template = \
-"""
+        template = """
 Directory structure:
 {{ node.tree }}
 """
         summary_template = self.env.from_string(template)
         return summary_template.render(node=node, query=query)
 
-
     @summary.register
     def _(self, context: Context, query):
-        template = \
-"""
+        template = """
 {{ context.summary }}
 """
         summary_template = self.env.from_string(template)
-        return summary_template.render(context=context, query=query)
+        return summary_template.render(context=context, query=query)

src/gitingest/schemas/__init__.py

@@ -1,7 +1,26 @@
 """Module containing the schemas for the Gitingest package."""
 
 from gitingest.schemas.cloning import CloneConfig
-from gitingest.schemas.filesystem import FileSystemNode, FileSystemFile, FileSystemDirectory, FileSystemSymlink, FileSystemStats, Context, Source
+from gitingest.schemas.filesystem import (
+    Context,
+    FileSystemDirectory,
+    FileSystemFile,
+    FileSystemNode,
+    FileSystemStats,
+    FileSystemSymlink,
+    GitRepository,
+    Source,
+)
 from gitingest.schemas.ingestion import IngestionQuery
 
-__all__ = ["CloneConfig", "FileSystemNode", "FileSystemFile", "FileSystemDirectory", "FileSystemSymlink", "FileSystemStats", "IngestionQuery", "Context"]
+__all__ = [
+    "CloneConfig",
+    "Context",
+    "FileSystemDirectory",
+    "FileSystemFile",
+    "FileSystemNode",
+    "FileSystemStats",
+    "FileSystemSymlink",
+    "GitRepository",
+    "IngestionQuery",
+]

src/gitingest/schemas/filesystem.py

@@ -2,24 +2,19 @@
 
 from __future__ import annotations
 
-import os
+from abc import ABC
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from typing import TYPE_CHECKING
-from abc import ABC
-from functools import singledispatchmethod
-
-from gitingest.utils.compat_func import readlink
-from gitingest.utils.file_utils import _decodes, _get_preferred_encodings, _read_chunk
-from gitingest.utils.notebook import process_notebook
 
 if TYPE_CHECKING:
     from pathlib import Path
+
     from gitingest.schemas import IngestionQuery
-    from gitingest.output_formatter import Formatter
 
 SEPARATOR = "=" * 48  # Tiktoken, the tokenizer openai uses, counts 2 tokens if we have more than 48
 
+
 class FileSystemNodeType(Enum):
     """Enum representing the type of a file system node (directory or file)."""
 
@@ -35,10 +30,11 @@ class FileSystemStats:
     total_files: int = 0
     total_size: int = 0
 
+
 @dataclass
 class Source(ABC):
     """Abstract base class for all sources (files, directories, etc)."""
-    pass
+
 
 @dataclass
 class FileSystemNode(Source):
@@ -52,13 +48,14 @@ class FileSystemNode(Source):
     def tree(self):
         return self.name
 
+
 @dataclass
 class FileSystemFile(FileSystemNode):
     @property
     def content(self):
         # read the file
         try:
-            with open(self.path, "r") as f:
+            with open(self.path) as f:
                 return f.read()
         except Exception as e:
             return f"Error reading content of {self.name}: {e}"
@@ -70,28 +67,30 @@ def render_tree(self, prefix="", is_last=True):
 
 @dataclass
 class FileSystemDirectory(FileSystemNode):
-    children: list['FileSystemNode'] = field(default_factory=list)
+    children: list[FileSystemNode] = field(default_factory=list)
     file_count: int = 0
     dir_count: int = 0
     type: FileSystemNodeType = FileSystemNodeType.DIRECTORY
 
     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()
-            if hasattr(child, 'type') and getattr(child, 'type', None) == FileSystemNodeType.FILE:
+            if hasattr(child, "type") and getattr(child, "type", None) == FileSystemNodeType.FILE:
                 if name == "readme" or name.startswith("readme."):
                     return (0, name)
                 return (1 if not name.startswith(".") else 2, name)
             return (3 if not name.startswith(".") else 4, name)
+
         self.children.sort(key=_sort_key)
 
     def render_tree(self, prefix="", is_last=True):
         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:
+        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
@@ -102,6 +101,27 @@ def render_tree(self, prefix="", is_last=True):
     def tree(self):
         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="", is_last=True):
+        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
+
+
 @dataclass
 class FileSystemSymlink(FileSystemNode):
     target: str = ""
@@ -122,6 +142,7 @@ class Context(Source):
         The list of source objects to format.
     query : IngestionQuery
         The query context.
+
     """
 
     def __init__(self, sources: list[Source], query: IngestionQuery):