feat(attachment): add directory listing support (#1905)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: tusharmath

crates/forge_app/src/infra.rs

@@ -199,6 +199,15 @@ pub trait HttpInfra: Send + Sync + 'static {
 /// Service for reading multiple files from a directory asynchronously
 #[async_trait::async_trait]
 pub trait DirectoryReaderInfra: Send + Sync {
+    /// Lists all entries (files and directories) in a directory without reading
+    /// file contents Returns a vector of tuples containing (entry_path,
+    /// is_directory) This is much more efficient than read_directory_files
+    /// when you only need to list entries
+    async fn list_directory_entries(
+        &self,
+        directory: &Path,
+    ) -> anyhow::Result<Vec<(PathBuf, bool)>>;
+
     /// Reads all files in a directory that match the given filter pattern
     /// Returns a vector of tuples containing (file_path, file_content)
     /// Files are read asynchronously/in parallel for better performance

crates/forge_domain/src/attachment.rs

@@ -18,6 +18,15 @@ pub enum AttachmentContent {
         end_line: u64,
         total_lines: u64,
     },
+    DirectoryListing {
+        entries: Vec<DirectoryEntry>,
+    },
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
+pub struct DirectoryEntry {
+    pub path: String,
+    pub is_dir: bool,
 }
 
 impl AttachmentContent {
@@ -32,6 +41,7 @@ impl AttachmentContent {
         match self {
             AttachmentContent::Image(_) => false,
             AttachmentContent::FileContent { content, .. } => content.contains(text),
+            AttachmentContent::DirectoryListing { .. } => false,
         }
     }
 

crates/forge_domain/src/context.rs

@@ -399,6 +399,22 @@ impl Context {
                         message = message.model(model);
                     }
 
+                    message.into()
+                }
+                AttachmentContent::DirectoryListing { entries } => {
+                    let elm = Element::new("directory_listing")
+                        .attr("path", attachment.path)
+                        .append(entries.into_iter().map(|entry| {
+                            let tag_name = if entry.is_dir { "dir" } else { "file" };
+                            Element::new(tag_name).text(entry.path)
+                        }));
+
+                    let mut message = TextMessage::new(Role::User, elm.to_string()).droppable(true);
+
+                    if let Some(model) = model_id.clone() {
+                        message = message.model(model);
+                    }
+
                     message.into()
                 }
             })
@@ -586,8 +602,8 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     use super::*;
-    use crate::estimate_token_count;
     use crate::transformer::Transformer;
+    use crate::{DirectoryEntry, estimate_token_count};
 
     #[test]
     fn test_override_system_message() {
@@ -1008,4 +1024,86 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_add_attachments_directory_listing() {
+        let fixture_attachments = vec![Attachment {
+            path: "/test/mydir".to_string(),
+            content: AttachmentContent::DirectoryListing {
+                entries: vec![
+                    DirectoryEntry { path: "/test/mydir/file1.txt".to_string(), is_dir: false },
+                    DirectoryEntry { path: "/test/mydir/file2.rs".to_string(), is_dir: false },
+                    DirectoryEntry { path: "/test/mydir/subdir".to_string(), is_dir: true },
+                ],
+            },
+        }];
+
+        let actual = Context::default().add_attachments(fixture_attachments, None);
+
+        // Verify message was added
+        assert_eq!(actual.messages.len(), 1);
+
+        // Verify directory listing is formatted correctly as XML
+        let message = actual.messages.first().unwrap();
+        assert!(
+            message.is_droppable(),
+            "Directory listing should be marked as droppable"
+        );
+
+        let text = message.to_text();
+        // The XML is encoded within the message content
+        assert!(text.contains("<directory_listing"));
+        // Check that files use <file> tag
+        assert!(text.contains("&lt;file&gt;"));
+        // Check that directories use <dir> tag
+        assert!(text.contains("&lt;dir&gt;"));
+    }
+
+    #[test]
+    fn test_directory_listing_sorted_dirs_first() {
+        // Create entries already sorted (as they would come from attachment service)
+        // Directories first, then files, all sorted alphabetically
+        let fixture_attachments = vec![Attachment {
+            path: "/test/root".to_string(),
+            content: AttachmentContent::DirectoryListing {
+                entries: vec![
+                    DirectoryEntry { path: "apple_dir".to_string(), is_dir: true },
+                    DirectoryEntry { path: "berry_dir".to_string(), is_dir: true },
+                    DirectoryEntry { path: "zoo_dir".to_string(), is_dir: true },
+                    DirectoryEntry { path: "banana.txt".to_string(), is_dir: false },
+                    DirectoryEntry { path: "cherry.txt".to_string(), is_dir: false },
+                    DirectoryEntry { path: "zebra.txt".to_string(), is_dir: false },
+                ],
+            },
+        }];
+
+        let actual = Context::default().add_attachments(fixture_attachments, None);
+        let text = actual.messages.first().unwrap().to_text();
+
+        // Extract the order of entries from the XML
+        let dir_entries: Vec<&str> = text
+            .split("&lt;")
+            .filter(|s| s.starts_with("dir&gt;") || s.starts_with("file&gt;"))
+            .collect();
+
+        // Verify directories come first, then files, all sorted alphabetically
+        let expected_order = [
+            "dir&gt;apple_dir",
+            "dir&gt;berry_dir",
+            "dir&gt;zoo_dir",
+            "file&gt;banana.txt",
+            "file&gt;cherry.txt",
+            "file&gt;zebra.txt",
+        ];
+
+        for (i, expected) in expected_order.iter().enumerate() {
+            assert!(
+                dir_entries[i].starts_with(expected),
+                "Expected entry {} to start with '{}', but got '{}'",
+                i,
+                expected,
+                dir_entries[i]
+            );
+        }
+    }
 }

crates/forge_infra/src/forge_infra.rs

@@ -245,6 +245,15 @@ impl HttpInfra for ForgeInfra {
 }
 #[async_trait::async_trait]
 impl DirectoryReaderInfra for ForgeInfra {
+    async fn list_directory_entries(
+        &self,
+        directory: &Path,
+    ) -> anyhow::Result<Vec<(PathBuf, bool)>> {
+        self.directory_reader_service
+            .list_directory_entries(directory)
+            .await
+    }
+
     async fn read_directory_files(
         &self,
         directory: &Path,

crates/forge_infra/src/fs_read_dir.rs

@@ -10,6 +10,28 @@ use glob::Pattern;
 pub struct ForgeDirectoryReaderService;
 
 impl ForgeDirectoryReaderService {
+    /// Lists all entries in a directory without reading file contents
+    /// Returns a vector of tuples containing (entry_path, is_directory)
+    /// Much more efficient than read_directory_files for directory listings
+    async fn list_directory_entries(&self, directory: &Path) -> Result<Vec<(PathBuf, bool)>> {
+        // Check if directory exists
+        if !ForgeFS::exists(directory) || ForgeFS::is_file(directory) {
+            return Ok(vec![]);
+        }
+
+        // Read directory entries
+        let mut dir = ForgeFS::read_dir(directory).await?;
+        let mut entries = Vec::new();
+
+        while let Some(entry) = dir.next_entry().await? {
+            let path = entry.path();
+            let is_dir = path.is_dir();
+            entries.push((path, is_dir));
+        }
+
+        Ok(entries)
+    }
+
     /// Reads all files in a directory that match the given filter pattern
     /// Returns a vector of tuples containing (file_path, file_content)
     /// Files are read asynchronously/in parallel for better performance
@@ -74,6 +96,10 @@ impl ForgeDirectoryReaderService {
 
 #[async_trait::async_trait]
 impl DirectoryReaderInfra for ForgeDirectoryReaderService {
+    async fn list_directory_entries(&self, directory: &Path) -> Result<Vec<(PathBuf, bool)>> {
+        self.list_directory_entries(directory).await
+    }
+
     async fn read_directory_files(
         &self,
         directory: &Path,
@@ -162,4 +188,38 @@ mod tests {
         let expected = vec![(fixture.path().join("test.txt"), "File content".to_string())];
         assert_eq!(actual, expected);
     }
+
+    #[tokio::test]
+    async fn test_list_directory_entries() {
+        let fixture = tempdir().unwrap();
+        write_file(&fixture.path().join("file1.txt"), "Content 1");
+        write_file(&fixture.path().join("file2.md"), "Content 2");
+
+        let subdir = fixture.path().join("subdir");
+        fs::create_dir(&subdir).unwrap();
+
+        let mut actual = ForgeDirectoryReaderService
+            .list_directory_entries(fixture.path())
+            .await
+            .unwrap();
+        actual.sort_by(|(a, _), (b, _)| a.file_name().cmp(&b.file_name()));
+
+        let expected = vec![
+            (fixture.path().join("file1.txt"), false),
+            (fixture.path().join("file2.md"), false),
+            (fixture.path().join("subdir"), true),
+        ];
+        assert_eq!(actual, expected);
+    }
+
+    #[tokio::test]
+    async fn test_list_directory_entries_nonexistent() {
+        let actual = ForgeDirectoryReaderService
+            .list_directory_entries(Path::new("/nonexistent"))
+            .await
+            .unwrap();
+
+        let expected: Vec<(PathBuf, bool)> = vec![];
+        assert_eq!(actual, expected);
+    }
 }

crates/forge_repo/src/forge_repo.rs

@@ -291,6 +291,13 @@ impl<F> DirectoryReaderInfra for ForgeRepo<F>
 where
     F: DirectoryReaderInfra + Send + Sync,
 {
+    async fn list_directory_entries(
+        &self,
+        directory: &Path,
+    ) -> anyhow::Result<Vec<(PathBuf, bool)>> {
+        self.infra.list_directory_entries(directory).await
+    }
+
     async fn read_directory_files(
         &self,
         directory: &Path,