feat(build): preserve repository name case for build upload

Add case-preserving VCS functions for build upload command only.
Other commands continue using lowercase names.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: runningcode

src/commands/build/upload.rs

@@ -24,8 +24,9 @@ use crate::utils::fs::TempDir;
 use crate::utils::fs::TempFile;
 use crate::utils::progress::ProgressBar;
 use crate::utils::vcs::{
-    self, get_github_pr_number, get_provider_from_remote, get_repo_from_remote, git_repo_base_ref,
-    git_repo_base_repo_name, git_repo_head_ref, git_repo_remote_url,
+    self, get_github_pr_number, get_provider_from_remote, get_repo_from_remote_preserve_case,
+    git_repo_base_ref, git_repo_base_repo_name_preserve_case, git_repo_head_ref,
+    git_repo_remote_url,
 };
 
 pub fn make_command(command: Command) -> Command {
@@ -140,7 +141,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
             .or_else(|| {
                 remote_url
                     .as_ref()
-                    .map(|url| get_repo_from_remote(url))
+                    .map(|url| get_repo_from_remote_preserve_case(url))
                     .map(Cow::Owned)
             });
 
@@ -198,7 +199,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
             .or_else(|| {
                 // Try to get the base repo name from the VCS if not provided
                 repo_ref
-                    .and_then(|r| match git_repo_base_repo_name(r) {
+                    .and_then(|r| match git_repo_base_repo_name_preserve_case(r) {
                         Ok(Some(base_repo_name)) => {
                             debug!("Found base repository name: {}", base_repo_name);
                             Some(base_repo_name)

src/utils/vcs.rs

@@ -221,6 +221,32 @@ pub fn get_repo_from_remote(repo: &str) -> String {
     obj.id
 }
 
+/// Like get_repo_from_remote but preserves the original case of the repository name.
+/// This is used specifically for build upload where case preservation is important.
+pub fn get_repo_from_remote_preserve_case(repo: &str) -> String {
+    // First get the lowercase version to ensure we handle all the complex VCS URL patterns correctly
+    let lowercase_result = get_repo_from_remote(repo);
+
+    // Then try to extract the case-preserved repository path using simple regex patterns
+    lazy_static! {
+        // Matches most common Git URL patterns to extract the repository path
+        static ref REPO_PATH_RE: Regex = Regex::new(
+            r"(?:https?://[^/]+/|git@[^:/]+[:/]|ssh://(?:[^@]+@)?[^/]+/)(.+?)(?:\.git)?/?$"
+        ).unwrap();
+    }
+
+    if let Some(caps) = REPO_PATH_RE.captures(repo) {
+        let case_preserved_path = &caps[1];
+        // Use the case-preserved version if it looks like a valid repo path (contains '/')
+        if case_preserved_path.contains('/') && case_preserved_path.len() > 1 {
+            return case_preserved_path.to_string();
+        }
+    }
+
+    // Fall back to the lowercase version if regex extraction fails
+    lowercase_result
+}
+
 pub fn get_provider_from_remote(remote: &str) -> String {
     let obj = VcsUrl::parse(remote);
     extract_provider_name(&obj.provider).to_owned()
@@ -292,6 +318,19 @@ fn find_merge_base_ref(
 /// Prefers "upstream" remote if it exists, then "origin", otherwise uses the first available remote.
 /// Returns the base repository name if a remote is found.
 pub fn git_repo_base_repo_name(repo: &git2::Repository) -> Result<Option<String>> {
+    git_repo_base_repo_name_impl(repo, false)
+}
+
+/// Like git_repo_base_repo_name but preserves the original case of the repository name.
+/// This is used specifically for build upload where case preservation is important.
+pub fn git_repo_base_repo_name_preserve_case(repo: &git2::Repository) -> Result<Option<String>> {
+    git_repo_base_repo_name_impl(repo, true)
+}
+
+fn git_repo_base_repo_name_impl(
+    repo: &git2::Repository,
+    preserve_case: bool,
+) -> Result<Option<String>> {
     let remotes = repo.remotes()?;
     let remote_names: Vec<&str> = remotes.iter().flatten().collect();
 
@@ -312,7 +351,12 @@ pub fn git_repo_base_repo_name(repo: &git2::Repository) -> Result<Option<String>
     match git_repo_remote_url(repo, chosen_remote) {
         Ok(remote_url) => {
             debug!("Found remote '{}': {}", chosen_remote, remote_url);
-            Ok(Some(get_repo_from_remote(&remote_url)))
+            let repo_name = if preserve_case {
+                get_repo_from_remote_preserve_case(&remote_url)
+            } else {
+                get_repo_from_remote(&remote_url)
+            };
+            Ok(Some(repo_name))
         }
         Err(e) => {
             warn!("Could not get URL for remote '{}': {}", chosen_remote, e);
@@ -927,6 +971,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_get_repo_from_remote_preserve_case() {
+        // Test that case-preserving function maintains original casing
+        assert_eq!(
+            get_repo_from_remote_preserve_case("https://github.com/MyOrg/MyRepo"),
+            "MyOrg/MyRepo"
+        );
+        assert_eq!(
+            get_repo_from_remote_preserve_case("git@github.com:SentryOrg/SentryRepo.git"),
+            "SentryOrg/SentryRepo"
+        );
+        assert_eq!(
+            get_repo_from_remote_preserve_case("https://gitlab.com/MyCompany/MyProject"),
+            "MyCompany/MyProject"
+        );
+        assert_eq!(
+            get_repo_from_remote_preserve_case("git@bitbucket.org:TeamName/ProjectName.git"),
+            "TeamName/ProjectName"
+        );
+        assert_eq!(
+            get_repo_from_remote_preserve_case("ssh://git@github.com/MyUser/MyRepo.git"),
+            "MyUser/MyRepo"
+        );
+
+        // Test that regular function still lowercases
+        assert_eq!(
+            get_repo_from_remote("https://github.com/MyOrg/MyRepo"),
+            "myorg/myrepo"
+        );
+
+        // Test edge cases - should fall back to lowercase when regex doesn't match
+        assert_eq!(
+            get_repo_from_remote_preserve_case("invalid-url"),
+            get_repo_from_remote("invalid-url")
+        );
+    }
+
     #[test]
     fn test_extract_provider_name() {
         // Test basic provider name extraction