feat: move contextv1 to its own file

Author: NicolasIRAGNE

.pre-commit-config.yaml

@@ -84,6 +84,7 @@ repos:
     rev: v1.36.4
     hooks:
       - id: djlint-reformat-jinja
+        exclude: ^src/gitingest/format/
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.45.0

src/gitingest/format/DefaultFormatter/ContextV1.j2

@@ -1,11 +1,11 @@
-# Generated using https://gitingest.com/{{ context.query.user_name }}/{{ context.query.repo_name }}
+# Generated using https://gitingest.com/{{ context.query.user_name }}/{{ context.query.repo_name }}{{ context.query.subpath }}
 
 Sources used:
-{%- for source in context.sources %}
+{%- for source in context %}
 - {{ source.name }}: {{ source.__class__.__name__ }}
 {% endfor %}
 
 {%- for source in context.sources %}
 {{ formatter.format(source, context.query) }}
 {%- endfor %}
-# End of generated content
+# End of https://gitingest.com/{{ context.query.user_name }}/{{ context.query.repo_name }}{{ context.query.subpath }}

src/gitingest/format/SummaryFormatter/ContextV1.j2

@@ -1,3 +1,3 @@
 Repository: {{ context.query.user_name }}/{{ context.query.repo_name }}
 Commit: {{ context.query.commit }}
-Files analyzed: {{ context.sources[0].file_count }}
+Files analyzed: {{ context.file_count }}

src/gitingest/output_formatter.py

@@ -9,10 +9,10 @@
 
 import requests.exceptions
 import tiktoken
-from jinja2 import Environment, FileSystemLoader, TemplateNotFound
+from jinja2 import Environment, FileSystemLoader, Template, TemplateNotFound
 
-from gitingest.schemas import FileSystemDirectory, FileSystemFile, FileSystemNode, FileSystemSymlink, Source
-from gitingest.schemas.filesystem import SEPARATOR, ContextV1, FileSystemNodeType, GitRepository
+from gitingest.schemas import ContextV1, FileSystemNode, Source
+from gitingest.schemas.filesystem import SEPARATOR, FileSystemNodeType
 from gitingest.utils.compat_func import readlink
 from gitingest.utils.logging_config import get_logger
 
@@ -28,49 +28,6 @@
 ]
 
 
-# Backward compatibility
-
-
-def _create_summary_prefix(query: IngestionQuery, *, single_file: bool = False) -> str:
-    """Create a prefix string for summarizing a repository or local directory.
-
-    Includes repository name (if provided), commit/branch details, and subpath if relevant.
-
-    Parameters
-    ----------
-    query : IngestionQuery
-        The parsed query object containing information about the repository and query parameters.
-    single_file : bool
-        A flag indicating whether the summary is for a single file (default: ``False``).
-
-    Returns
-    -------
-    str
-        A summary prefix string containing repository, commit, branch, and subpath details.
-
-    """
-    parts = []
-
-    if query.user_name:
-        parts.append(f"Repository: {query.user_name}/{query.repo_name}")
-    else:
-        # Local scenario
-        parts.append(f"Directory: {query.slug}")
-
-    if query.tag:
-        parts.append(f"Tag: {query.tag}")
-    elif query.branch and query.branch not in ("main", "master"):
-        parts.append(f"Branch: {query.branch}")
-
-    if query.commit:
-        parts.append(f"Commit: {query.commit}")
-
-    if query.subpath != "/" and not single_file:
-        parts.append(f"Subpath: {query.subpath}")
-
-    return "\n".join(parts) + "\n"
-
-
 def _gather_file_contents(node: FileSystemNode) -> str:
     """Recursively gather contents of all files under the given node.
 
@@ -181,71 +138,76 @@ def _format_token_count(text: str) -> str | None:
 
 def generate_digest(context: ContextV1) -> str:
     """Generate a digest string from a ContextV1 object.
-    
+
     This is a convenience function that uses the DefaultFormatter to format a ContextV1.
-    
+
     Parameters
     ----------
     context : ContextV1
         The ContextV1 object containing sources and query information.
-    
+
     Returns
     -------
     str
         The formatted digest string.
+
     """
     formatter = DefaultFormatter()
     return formatter.format(context, context.query)
 
 
 class DefaultFormatter:
-    def __init__(self):
+    """Default formatter for rendering filesystem nodes using Jinja2 templates."""
+
+    def __init__(self) -> None:
         self.separator = SEPARATOR
         template_dir = Path(__file__).parent / "format" / "DefaultFormatter"
-        self.env = Environment(loader=FileSystemLoader(template_dir))
-    
-    def _get_template_for_node(self, node):
+        self.env = Environment(loader=FileSystemLoader(template_dir), autoescape=True)
+
+    def _get_template_for_node(self, node: Source) -> Template:
         """Get template based on node class name."""
         template_name = f"{node.__class__.__name__}.j2"
         return self.env.get_template(template_name)
 
     @singledispatchmethod
-    def format(self, node: Source, query):
+    def format(self, node: Source, query: IngestionQuery) -> str:
         """Dynamically format any node type based on available templates."""
         try:
             template = self._get_template_for_node(node)
             # Provide common template variables
             context_vars = {
-                'node': node,
-                'query': query, 
-                'formatter': self,
-                'SEPARATOR': SEPARATOR
+                "node": node,
+                "query": query,
+                "formatter": self,
+                "SEPARATOR": SEPARATOR,
             }
             # Special handling for ContextV1 objects
             if isinstance(node, ContextV1):
-                context_vars['context'] = node
+                context_vars["context"] = node
                 # Use ContextV1 for backward compatibility
                 template = self.env.get_template("ContextV1.j2")
-            
+
             return template.render(**context_vars)
         except TemplateNotFound:
             # Fallback: return content if available, otherwise empty string
             return f"{getattr(node, 'content', '')}"
 
 
 class DebugFormatter:
-    def __init__(self):
+    """Debug formatter that shows detailed information about filesystem nodes."""
+
+    def __init__(self) -> None:
         self.separator = SEPARATOR
         template_dir = Path(__file__).parent / "format" / "DebugFormatter"
-        self.env = Environment(loader=FileSystemLoader(template_dir))
-    
-    def _get_template_for_node(self, node):
+        self.env = Environment(loader=FileSystemLoader(template_dir), autoescape=True)
+
+    def _get_template_for_node(self, node: Source) -> Template:
         """Get template based on node class name."""
         template_name = f"{node.__class__.__name__}.j2"
         return self.env.get_template(template_name)
 
     @singledispatchmethod
-    def format(self, node: Source, query):
+    def format(self, node: Source, query: IngestionQuery) -> str:
         """Dynamically format any node type with debug information."""
         try:
             # Get the actual class name
@@ -255,11 +217,15 @@ def format(self, node: Source, query):
             field_names = []
 
             # Try to get dataclass fields first
+            def _raise_no_dataclass_fields() -> None:
+                msg = "No dataclass fields found"
+                raise AttributeError(msg)
+
             try:
                 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
+                    _raise_no_dataclass_fields()  # Fall through to backup method
             except (AttributeError, TypeError):
                 # Fall back to getting all non-private attributes
                 field_names = [
@@ -268,20 +234,20 @@ def format(self, node: Source, query):
 
             # Format the debug output
             fields_str = ", ".join(field_names)
-            
+
             # Try to get specific template, fallback to Source.j2
             try:
                 template = self._get_template_for_node(node)
             except TemplateNotFound:
                 template = self.env.get_template("Source.j2")
-                
+
             return template.render(
                 SEPARATOR=SEPARATOR,
                 class_name=class_name,
                 fields_str=fields_str,
                 node=node,
                 query=query,
-                formatter=self
+                formatter=self,
             )
         except TemplateNotFound:
             # Ultimate fallback
@@ -291,34 +257,34 @@ def format(self, node: Source, query):
 class SummaryFormatter:
     """Dedicated formatter for generating summaries of filesystem nodes."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         template_dir = Path(__file__).parent / "format" / "SummaryFormatter"
-        self.env = Environment(loader=FileSystemLoader(template_dir))
-    
-    def _get_template_for_node(self, node):
+        self.env = Environment(loader=FileSystemLoader(template_dir), autoescape=True)
+
+    def _get_template_for_node(self, node: Source) -> Template:
         """Get template based on node class name."""
         template_name = f"{node.__class__.__name__}.j2"
         return self.env.get_template(template_name)
 
     @singledispatchmethod
-    def summary(self, node: Source, query):
+    def summary(self, node: Source, query: IngestionQuery) -> str:
         """Dynamically generate summary for any node type based on available templates."""
         try:
             # Provide common template variables
             context_vars = {
-                'node': node,
-                'query': query,
-                'formatter': self
+                "node": node,
+                "query": query,
+                "formatter": self,
             }
-            
+
             # Special handling for ContextV1 objects
             if isinstance(node, ContextV1):
-                context_vars['context'] = node
+                context_vars["context"] = node
                 # Use ContextV1 for backward compatibility
                 template = self.env.get_template("ContextV1.j2")
             else:
                 template = self._get_template_for_node(node)
-            
+
             return template.render(**context_vars)
         except TemplateNotFound:
             # Fallback: return name if available

src/gitingest/schemas/__init__.py

@@ -1,8 +1,8 @@
 """Module containing the schemas for the Gitingest package."""
 
 from gitingest.schemas.cloning import CloneConfig
+from gitingest.schemas.contextv1 import ContextV1
 from gitingest.schemas.filesystem import (
-    ContextV1,
     FileSystemDirectory,
     FileSystemFile,
     FileSystemNode,
@@ -23,4 +23,5 @@
     "FileSystemSymlink",
     "GitRepository",
     "IngestionQuery",
+    "Source",
 ]

src/gitingest/schemas/contextv1.py

@@ -0,0 +1,69 @@
+"""Schema for ContextV1 objects used in formatting."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Iterator
+
+from gitingest.schemas.filesystem import FileSystemDirectory, FileSystemNode, Source
+
+if TYPE_CHECKING:
+    from gitingest.schemas import IngestionQuery
+
+
+@dataclass
+class ContextV1:
+    """The ContextV1 object is an object that contains all information needed to produce a formatted output.
+
+    This object contains all information needed to produce a formatted output
+    similar to the "legacy" output.
+
+    Attributes
+    ----------
+    sources : list[Source]
+        List of source objects (files, directories, etc.)
+    query : IngestionQuery
+        The query context.
+
+    """
+
+    sources: list[Source]
+    query: IngestionQuery
+
+    @property
+    def sources_by_type(self) -> dict[str, list[Source]]:
+        """Return sources grouped by their class name."""
+        result = {}
+        for source in self.sources:
+            class_name = source.__class__.__name__
+            if class_name not in result:
+                result[class_name] = []
+            result[class_name].append(source)
+        return result
+
+    def __getitem__(self, key: str) -> list[Source]:
+        """Allow dict-like access to sources by type name."""
+        sources_dict = self.sources_by_type
+        if key not in sources_dict:
+            error_msg = f"No sources of type '{key}' found"
+            raise KeyError(error_msg)
+        return sources_dict[key]
+
+    def __iter__(self) -> Iterator[Source]:
+        """Allow iteration over all sources."""
+        return iter(self.sources)
+
+    @property
+    def file_count(self) -> int:
+        """Calculate total file count based on sources."""
+        # No need to iterate on children, directories are already aware of their
+        # file count
+        total = 0
+        for source in self.sources:
+            if isinstance(source, FileSystemDirectory):
+                # For directories, add their file_count
+                total += source.file_count
+            elif isinstance(source, FileSystemNode):
+                # For individual files/nodes, increment by 1
+                total += 1
+        return total