feat: 新增 open 指令并增加相应的单元测试和集成测试

src/cli.rs

@@ -104,6 +104,8 @@ enum Commands {
     Revert(command::revert::RevertArgs),
     #[command(subcommand, about = "Manage set of tracked repositories")]
     Remote(command::remote::RemoteCmds),
+    #[command(about = "Open the repository in the browser")]
+    Open(command::open::OpenArgs),
     #[command(about = "Manage repository configurations")]
     Config(command::config::ConfigArgs),
     #[command(about = "Manage the log of reference changes (e.g., HEAD, branches)")]
@@ -209,6 +211,7 @@ pub async fn parse_async(args: Option<&[&str]>) -> Result<(), GitError> {
         Commands::Blame(args) => command::blame::execute(args).await,
         Commands::Revert(args) => command::revert::execute(args).await,
         Commands::Remote(cmd) => command::remote::execute(cmd).await,
+        Commands::Open(args) => command::open::open(args).await,
         Commands::Pull(args) => command::pull::execute(args).await,
         Commands::Config(args) => command::config::execute(args).await,
         Commands::Checkout(args) => command::checkout::execute(args).await,

src/command/mod.rs

@@ -15,6 +15,7 @@ pub mod init;
 pub mod lfs;
 pub mod log;
 pub mod merge;
+pub mod open;
 pub mod pull;
 pub mod push;
 pub mod rebase;

src/command/open.rs

@@ -0,0 +1,114 @@
+use std::process::Command;
+
+use clap::Parser;
+use regex::Regex;
+
+use crate::internal::config::Config;
+
+#[derive(Parser, Debug)]
+pub struct OpenArgs {
+    /// The remote to open
+    pub remote: Option<String>,
+}
+
+pub async fn open(args: OpenArgs) {
+    let remote_url = if let Some(remote_name) = args.remote {
+        let remotes = Config::all_remote_configs().await;
+        if remotes.iter().any(|r| r.name == remote_name) {
+            Config::get_remote_url(&remote_name).await
+        } else {
+            eprintln!("fatal: Remote '{}' not found", remote_name);
+            return;
+        }
+    } else {
+        match Config::get_current_remote_url().await {
+            Some(url) => url,
+            None => {
+                // Fallback, try origin
+                let remotes = Config::all_remote_configs().await;
+                if let Some(origin) = remotes.iter().find(|r| r.name == "origin") {
+                    origin.url.clone()
+                } else if let Some(first) = remotes.first() {
+                    first.url.clone() // Fallback to first available remote
+                } else {
+                    eprintln!("fatal: No remote configured");
+                    return;
+                }
+            }
+        }
+    };
+
+    let url = transform_url(&remote_url);
+    println!("Opening {}", url);
+
+    #[cfg(target_os = "windows")]
+    {
+        Command::new("cmd").args(["/C", "start", &url]).spawn().ok();
+    }
+    #[cfg(target_os = "macos")]
+    {
+        Command::new("open").arg(&url).spawn().ok();
+    }
+    #[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
+    {
+        Command::new("xdg-open").arg(&url).spawn().ok();
+    }
+}
+
+fn transform_url(remote: &str) -> String {
+    if remote.starts_with("http://") || remote.starts_with("https://") {
+        return remote.trim_end_matches(".git").to_string();
+    }
+
+    // Handle SCP-like syntax: git@github.com:user/repo.git
+    let scp_re = Regex::new(r"^git@([^:]+):(.+?)(\.git)?$").unwrap();
+    if let Some(caps) = scp_re.captures(remote) {
+        let host = &caps[1];
+        let path = &caps[2];
+        return format!("https://{}/{}", host, path);
+    }
+
+    // Handle ssh:// syntax
+    // ssh://[user@]host.xz[:port]/path/to/repo.git/
+    if remote.starts_with("ssh://") {
+        let ssh_re = Regex::new(r"^ssh://(?:[^@]+@)?([^:/]+)(?::\d+)?/(.+?)(\.git)?$").unwrap();
+        if let Some(caps) = ssh_re.captures(remote) {
+            let host = &caps[1];
+            let path = &caps[2];
+            return format!("https://{}/{}", host, path);
+        }
+    }
+
+    // Fallback: return as is, maybe it is already workable or user has weird config
+    remote.to_string()
+}
+
+// Uint test
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_transform_url() {
+        assert_eq!(
+            transform_url("git@github.com:rust-lang/rust.git"),
+            "https://github.com/rust-lang/rust"
+        );
+        assert_eq!(
+            transform_url("git@gitlab.com:group/project.git"),
+            "https://gitlab.com/group/project"
+        );
+        assert_eq!(
+            transform_url("https://github.com/rust-lang/rust.git"),
+            "https://github.com/rust-lang/rust"
+        );
+        assert_eq!(
+            transform_url("ssh://git@github.com/rust-lang/rust.git"),
+            "https://github.com/rust-lang/rust"
+        );
+        assert_eq!(
+            transform_url("ssh://user@host.com:2222/repo.git"),
+            "https://host.com/repo"
+        );
+    }
+}

tests/command/mod.rs

@@ -40,6 +40,7 @@ mod init_test;
 mod lfs_test;
 mod log_test;
 mod merge_test;
+mod open_test;
 mod pull_test;
 mod push_test;
 mod rebase_test;

tests/command/open_test.rs

@@ -0,0 +1,34 @@
+//! Tests open command integration to ensure it finds remote correctly.
+use libra::{
+    command::{
+        open,
+        remote::{self, RemoteCmds},
+    },
+    utils::test,
+};
+use serial_test::serial;
+use tempfile::tempdir;
+
+#[tokio::test]
+#[serial]
+async fn test_open_remote_origin() {
+    let repo_dir = tempdir().unwrap();
+    test::setup_with_new_libra_in(repo_dir.path()).await;
+    let _guard = test::ChangeDirGuard::new(repo_dir.path());
+
+    // Add origin remote
+    remote::execute(RemoteCmds::Add {
+        name: "origin".into(),
+        url: "git@github.com:user/repo.git".into(),
+    })
+    .await;
+
+    // Test explicit remote
+    open::open(open::OpenArgs {
+        remote: Some("origin".to_string()),
+    })
+    .await;
+
+    // Test default remote should find origin
+    open::open(open::OpenArgs { remote: None }).await;
+}