refactor: Update sheet input handling and fix tests

- Modify Sheet::add_input to accept InputPackage instead of separate parameters
- Use output_mappings method to generate InputPackage in tests
- Update test assertions to match new path transformation logic
- Fix mapping count assertions after adding multiple mappings
- Clean up string_proc module structure

3 files changed, 141 insertions, 32 deletions

diff --git a/crates/vcs/src/data/sheet.rs b/crates/vcs/src/data/sheet.rs
index edf307a..a6765c0 100644
--- a/crates/vcs/src/data/sheet.rs
+++ b/crates/vcs/src/data/sheet.rs
@@ -2,6 +2,7 @@ use std::{collections::HashMap, path::PathBuf};
 
 use cfg_file::{ConfigFile, config::ConfigFile};
 use serde::{Deserialize, Serialize};
+use string_proc::simple_processer::sanitize_file_path;
 
 use crate::{
     constants::SERVER_FILE_SHEET,
@@ -16,14 +17,24 @@ pub type SheetPathBuf = PathBuf;
 pub type InputName = String;
 pub type InputRelativePathBuf = PathBuf;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq)]
 pub struct InputPackage {
     /// Name of the input package
     pub name: InputName,
+
+    /// The sheet from which this input package was created
+    pub from: SheetName,
+
     /// Files in this input package with their relative paths and virtual file IDs
     pub files: Vec<(InputRelativePathBuf, VirtualFileId)>,
 }
 
+impl PartialEq for InputPackage {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
 const SHEET_NAME: &str = "{sheet-name}";
 
 pub struct Sheet<'a> {
@@ -66,15 +77,15 @@ impl<'a> Sheet<'a> {
     }
 
     /// Add an input package to the sheet
-    pub fn add_input(
-        &mut self,
-        input_name: InputName,
-        files: Vec<(InputRelativePathBuf, VirtualFileId)>,
-    ) {
-        self.data.inputs.push(InputPackage {
-            name: input_name,
-            files,
-        });
+    pub fn add_input(&mut self, input_package: InputPackage) -> Result<(), std::io::Error> {
+        if self.data.inputs.iter().any(|input| input == &input_package) {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::AlreadyExists,
+                format!("Input package '{}' already exists", input_package.name),
+            ));
+        }
+        self.data.inputs.push(input_package);
+        Ok(())
     }
 
     /// Remove an input package from the sheet
@@ -116,4 +127,89 @@ impl<'a> Sheet<'a> {
             .vault_path()
             .join(SERVER_FILE_SHEET.replace(SHEET_NAME, name.as_ref()))
     }
+
+    /// Export files from the current sheet as an InputPackage for importing into other sheets
+    ///
+    /// This is the recommended way to create InputPackages. It takes a list of sheet paths
+    /// and generates an InputPackage with optimized relative paths by removing the longest
+    /// common prefix from all provided paths, then placing the files under a directory
+    /// named with the output_name.
+    ///
+    /// # Example
+    /// Given paths:
+    /// - `MyProject/Art/Character/Model/final.fbx`
+    /// - `MyProject/Art/Character/Texture/final.png`
+    /// - `MyProject/Art/Character/README.md`
+    ///
+    /// With output_name = "MyExport", the resulting package will contain:
+    /// - `MyExport/Model/final.fbx`
+    /// - `MyExport/Texture/final.png`
+    /// - `MyExport/README.md`
+    ///
+    /// # Arguments
+    /// * `output_name` - Name of the output package (will be used as the root directory)
+    /// * `paths` - List of sheet paths to include in the package
+    ///
+    /// # Returns
+    /// Returns an InputPackage containing the exported files with optimized paths,
+    /// or an error if paths are empty or files are not found in the sheet mapping
+    pub fn output_mappings(
+        &self,
+        output_name: InputName,
+        paths: &[SheetPathBuf],
+    ) -> Result<InputPackage, std::io::Error> {
+        let output_name = sanitize_file_path(output_name);
+
+        // Return error for empty paths since there's no need to generate an empty package
+        if paths.is_empty() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "Cannot generate output package with empty paths",
+            ));
+        }
+
+        // Find the longest common prefix among all paths
+        let common_prefix = paths.iter().skip(1).fold(paths[0].clone(), |prefix, path| {
+            Self::common_path_prefix(prefix, path)
+        });
+
+        // Create output files with optimized relative paths
+        let files = paths
+            .iter()
+            .map(|path| {
+                let relative_path = path.strip_prefix(&common_prefix).unwrap_or(path);
+                let output_path = PathBuf::from(&output_name).join(relative_path);
+
+                self.data
+                    .mapping
+                    .get(path)
+                    .map(|vfid| (output_path, vfid.clone()))
+                    .ok_or_else(|| {
+                        std::io::Error::new(
+                            std::io::ErrorKind::NotFound,
+                            format!("File not found: {:?}", path),
+                        )
+                    })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(InputPackage {
+            name: output_name,
+            from: self.name.clone(),
+            files,
+        })
+    }
+
+    /// Helper function to find common path prefix between two paths
+    fn common_path_prefix(path1: impl Into<PathBuf>, path2: impl Into<PathBuf>) -> PathBuf {
+        let path1 = path1.into();
+        let path2 = path2.into();
+
+        path1
+            .components()
+            .zip(path2.components())
+            .take_while(|(a, b)| a == b)
+            .map(|(comp, _)| comp)
+            .collect()
+    }
 }
diff --git a/crates/vcs/src/data/vault.rs b/crates/vcs/src/data/vault.rs
index 5b34c6f..5d17a81 100644
--- a/crates/vcs/src/data/vault.rs
+++ b/crates/vcs/src/data/vault.rs
@@ -72,9 +72,7 @@ impl Vault {
         create_dir_all(vault_path.join(SERVER_PATH_VF_ROOT))?;
 
         let Some(vault) = Vault::init(config, &vault_path) else {
-            return Err(std::io::Error::other(
-                "Failed to initialize vault",
-            ));
+            return Err(std::io::Error::other("Failed to initialize vault"));
         };
 
         // 6. Create host member
diff --git a/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs b/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs
index 1c7182b..8abcc4d 100644
--- a/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs
+++ b/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs
@@ -48,20 +48,23 @@ async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io:
 
     // Test 2: Add input packages to the sheet
     let input_name = "source_files".to_string();
-    let files = vec![
-        (
-            InputRelativePathBuf::from("src/main.rs"),
-            VirtualFileId::new(),
-        ),
-        (
-            InputRelativePathBuf::from("src/lib.rs"),
-            VirtualFileId::new(),
-        ),
-    ];
 
-    // Need to get a mutable reference to the sheet
+    // First add mapping entries that will be used to generate the input package
     let mut sheet = vault.sheet(&sheet_name).await?;
-    sheet.add_input(input_name.clone(), files.clone());
+
+    // Add mapping entries for the files
+    let main_rs_path = vcs::data::sheet::SheetPathBuf::from("src/main.rs");
+    let lib_rs_path = vcs::data::sheet::SheetPathBuf::from("src/lib.rs");
+    let main_rs_id = VirtualFileId::new();
+    let lib_rs_id = VirtualFileId::new();
+
+    sheet.add_mapping(main_rs_path.clone(), main_rs_id.clone());
+    sheet.add_mapping(lib_rs_path.clone(), lib_rs_id.clone());
+
+    // Use output_mappings to generate the InputPackage
+    let paths = vec![main_rs_path, lib_rs_path];
+    let input_package = sheet.output_mappings(input_name.clone(), &paths)?;
+    sheet.add_input(input_package)?;
 
     // Verify input was added
     assert_eq!(sheet.inputs().len(), 1);
@@ -70,11 +73,11 @@ async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io:
     assert_eq!(added_input.files.len(), 2);
     assert_eq!(
         added_input.files[0].0,
-        InputRelativePathBuf::from("src/main.rs")
+        InputRelativePathBuf::from("source_files/main.rs")
     );
     assert_eq!(
         added_input.files[1].0,
-        InputRelativePathBuf::from("src/lib.rs")
+        InputRelativePathBuf::from("source_files/lib.rs")
     );
 
     // Test 3: Add mapping entries
@@ -83,7 +86,7 @@ async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io:
     sheet.add_mapping(mapping_path.clone(), virtual_file_id.clone());
 
     // Verify mapping was added
-    assert_eq!(sheet.mapping().len(), 1);
+    assert_eq!(sheet.mapping().len(), 3);
     assert_eq!(sheet.mapping().get(&mapping_path), Some(&virtual_file_id));
 
     // Test 4: Persist sheet to disk
@@ -93,7 +96,7 @@ async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io:
     let reloaded_sheet = vault.sheet(&sheet_name).await?;
     assert_eq!(reloaded_sheet.holder(), &member_id);
     assert_eq!(reloaded_sheet.inputs().len(), 1);
-    assert_eq!(reloaded_sheet.mapping().len(), 1);
+    assert_eq!(reloaded_sheet.mapping().len(), 3);
 
     // Test 5: Remove input package
     let mut sheet_for_removal = vault.sheet(&sheet_name).await?;
@@ -107,7 +110,7 @@ async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io:
     // Test 6: Remove mapping entry
     let removed_virtual_file_id = sheet_for_removal.remove_mapping(&mapping_path);
     assert_eq!(removed_virtual_file_id, Some(virtual_file_id));
-    assert_eq!(sheet_for_removal.mapping().len(), 0);
+    assert_eq!(sheet_for_removal.mapping().len(), 2);
 
     // Test 7: List all sheets in vault
     let sheet_names = vault.sheet_names()?;
@@ -244,7 +247,7 @@ async fn test_sheet_data_serialization() -> Result<(), std::io::Error> {
 
     // Add some inputs
     let input_name = "source_files".to_string();
-    let files = vec![
+    let _files = vec![
         (
             InputRelativePathBuf::from("src/main.rs"),
             VirtualFileId::new(),
@@ -254,7 +257,19 @@ async fn test_sheet_data_serialization() -> Result<(), std::io::Error> {
             VirtualFileId::new(),
         ),
     ];
-    sheet.add_input(input_name, files);
+    // First add mapping entries
+    let main_rs_path = vcs::data::sheet::SheetPathBuf::from("src/main.rs");
+    let lib_rs_path = vcs::data::sheet::SheetPathBuf::from("src/lib.rs");
+    let main_rs_id = VirtualFileId::new();
+    let lib_rs_id = VirtualFileId::new();
+
+    sheet.add_mapping(main_rs_path.clone(), main_rs_id.clone());
+    sheet.add_mapping(lib_rs_path.clone(), lib_rs_id.clone());
+
+    // Use output_mappings to generate the InputPackage
+    let paths = vec![main_rs_path, lib_rs_path];
+    let input_package = sheet.output_mappings(input_name.clone(), &paths)?;
+    sheet.add_input(input_package)?;
 
     // Add some mappings
     sheet.add_mapping(