feat: default git provider for shorthand for adding modules

you can run `nuance add freepicheep/nu-salesforce` and it will install
the module since github is the default git provider. you can change this
if you want

Author: freepicheep

README.md

@@ -34,6 +34,9 @@ nuance init
 # Add a dependency
 nuance add https://github.com/user/nu-some-module
 
+# Or use owner/repo shorthand (defaults to github)
+nuance add user/nu-some-module
+
 # Install all dependencies from mod.toml
 nuance install
 
@@ -61,11 +64,11 @@ To make the installed modules available to `use` in Nushell without specifying t
 Nuance provides two ways to do this:
 
 ### 1. Manual Overlay (Recommended)
-`nuance install` automatically generates an `activate.nu` script inside the `.nu_modules` directory. This script adds `.nu_modules/` to your `$env.NU_LIB_DIRS` **and automatically imports** all installed modules into your active scope using `export use <module> *`.
+`nuance install` and `nuance init` automatically generate an `activate.nu` script inside the `.nu_modules` directory. This script adds `.nu_modules/` to your `$env.NU_LIB_DIRS` **and automatically imports** all installed modules into your active scope using `export use <module> *`.
 
 You can activate it using Nushell's `overlay` command:
 
-```bash
+```nu
 overlay use .nu_modules/activate.nu
 ```
 
@@ -87,7 +90,7 @@ nuance hook
 [package]
 name = "my-module"
 version = "0.1.0"
-description = "Something useful"
+description = "a wonderful nu module anyone can use"
 
 [dependencies]
 nu-utils = { git = "https://github.com/user/nu-utils", tag = "v1.0.0" }
@@ -102,13 +105,24 @@ Each dependency must specify exactly one of `tag`, `branch`, or `rev`.
 | Command | Description |
 |---------|-------------|
 | `nuance init` | Create a new `mod.toml` in the current directory |
-| `nuance add <url>` | Add a dependency (auto-detects latest tag) |
+| `nuance add <source>` | Add a dependency from a URL or owner/repo shorthand (auto-detects latest tag) |
 | `nuance install` | Install dependencies from `mod.toml` |
 | `nuance install --frozen` | Install from lockfile only (CI-friendly) |
 | `nuance update` | Re-resolve all dependencies |
 | `nuance remove <name>` | Remove a dependency |
 | `nuance hook` | Print the auto-activate hook for config.nu |
 
+## Global config (`~/.config/nuance/config.toml`)
+
+You can set a default git provider used for `owner/repo` shorthand in `nuance add`.
+
+```toml
+default_git_provider = "github" # default
+```
+
+Supported provider aliases are `github`, `gitlab`, `codeberg`, and `bitbucket`.
+You can also set a custom host like `git.example.com` or a full `https://...` base URL.
+
 ## License
 
 MIT

src/cli.rs

@@ -39,13 +39,13 @@ pub enum Commands {
     /// Re-resolve all dependencies (ignore existing lockfile)
     Update,
 
-    /// Add a package from a git repository URL
+    /// Add a package from a git URL or owner/repo shorthand
     Add {
         /// Add to global config instead of local mod.toml
         #[arg(short = 'g', long)]
         global: bool,
 
-        /// Git repository URL (e.g. https://github.com/user/nu-module)
+        /// Git URL (e.g. https://github.com/user/nu-module) or owner/repo shorthand
         url: String,
 
         /// Pin to a specific tag

src/config.rs

@@ -1,10 +1,48 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::error::{NuanceError, Result};
 use crate::manifest::DependencySpec;
 
+const DEFAULT_GIT_PROVIDER: &str = "github";
+
+fn default_git_provider() -> String {
+    DEFAULT_GIT_PROVIDER.to_string()
+}
+
+fn known_provider_base_url(provider: &str) -> Option<&'static str> {
+    match provider {
+        "github" => Some("https://github.com"),
+        "gitlab" => Some("https://gitlab.com"),
+        "codeberg" => Some("https://codeberg.org"),
+        "bitbucket" => Some("https://bitbucket.org"),
+        _ => None,
+    }
+}
+
+fn normalize_provider_base_url(provider: &str) -> Option<String> {
+    let trimmed = provider.trim().trim_end_matches('/');
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    let lowercase = trimmed.to_ascii_lowercase();
+    if let Some(base) = known_provider_base_url(&lowercase) {
+        return Some(base.to_string());
+    }
+
+    if trimmed.starts_with("https://") || trimmed.starts_with("http://") {
+        return Some(trimmed.to_string());
+    }
+
+    if trimmed.contains('.') && !trimmed.contains('/') && !trimmed.contains(' ') {
+        return Some(format!("https://{trimmed}"));
+    }
+
+    None
+}
+
 /// The global nuance config file: `~/.config/nuance/config.toml`.
 ///
 /// Tracks globally-installed modules and optional path overrides.
@@ -13,24 +51,49 @@ pub struct GlobalConfig {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub modules_dir: Option<String>,
 
+    #[serde(default = "default_git_provider")]
+    pub default_git_provider: String,
+
     #[serde(default)]
     pub dependencies: HashMap<String, DependencySpec>,
 }
 
+impl Default for GlobalConfig {
+    fn default() -> Self {
+        Self {
+            modules_dir: None,
+            default_git_provider: default_git_provider(),
+            dependencies: HashMap::new(),
+        }
+    }
+}
+
 impl GlobalConfig {
     /// Load the global config, creating it with defaults if it doesn't exist.
     pub fn load() -> Result<Self> {
         let path = global_config_path()?;
 
         if !path.exists() {
-            let config = GlobalConfig {
-                modules_dir: None,
-                dependencies: HashMap::new(),
-            };
+            let config = GlobalConfig::default();
             config.save()?;
             return Ok(config);
         }
 
+        Self::load_from_path(&path)
+    }
+
+    /// Load global config if present, otherwise return defaults without writing.
+    pub fn load_or_default() -> Result<Self> {
+        let path = global_config_path()?;
+
+        if !path.exists() {
+            return Ok(GlobalConfig::default());
+        }
+
+        Self::load_from_path(&path)
+    }
+
+    fn load_from_path(path: &Path) -> Result<Self> {
         let content = std::fs::read_to_string(&path)?;
         let config: GlobalConfig = toml::from_str(&content)
             .map_err(|e| NuanceError::Config(format!("failed to parse {}: {e}", path.display())))?;
@@ -62,6 +125,16 @@ impl GlobalConfig {
             global_modules_dir()
         }
     }
+
+    /// Resolve the configured default git provider to a base URL.
+    pub fn default_git_provider_base_url(&self) -> Result<String> {
+        normalize_provider_base_url(&self.default_git_provider).ok_or_else(|| {
+            NuanceError::Config(format!(
+                "unsupported default_git_provider '{}'; use one of github, gitlab, codeberg, bitbucket, or a custom host like git.example.com",
+                self.default_git_provider
+            ))
+        })
+    }
 }
 
 /// Returns the global config directory: `~/.config/nuance/`.
@@ -100,6 +173,7 @@ mod tests {
     fn round_trip() {
         let config = GlobalConfig {
             modules_dir: None,
+            default_git_provider: "github".to_string(),
             dependencies: HashMap::from([(
                 "nu-utils".to_string(),
                 DependencySpec {
@@ -117,25 +191,29 @@ mod tests {
         assert_eq!(parsed.dependencies.len(), 1);
         assert!(parsed.dependencies.contains_key("nu-utils"));
         assert!(parsed.modules_dir.is_none());
+        assert_eq!(parsed.default_git_provider, "github");
     }
 
     #[test]
     fn round_trip_with_override() {
         let config = GlobalConfig {
             modules_dir: Some("/custom/path".to_string()),
+            default_git_provider: "gitlab".to_string(),
             dependencies: HashMap::new(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
         let parsed: GlobalConfig = toml::from_str(&serialized).unwrap();
 
         assert_eq!(parsed.modules_dir.as_deref(), Some("/custom/path"));
+        assert_eq!(parsed.default_git_provider, "gitlab");
     }
 
     #[test]
     fn modules_dir_custom() {
         let config = GlobalConfig {
             modules_dir: Some("/custom/modules".to_string()),
+            default_git_provider: "github".to_string(),
             dependencies: HashMap::new(),
         };
         assert_eq!(
@@ -148,6 +226,7 @@ mod tests {
     fn modules_dir_default() {
         let config = GlobalConfig {
             modules_dir: None,
+            default_git_provider: "github".to_string(),
             dependencies: HashMap::new(),
         };
         let dir = config.modules_dir().unwrap();
@@ -167,4 +246,54 @@ mod tests {
         let lock = global_lock_path().unwrap();
         assert!(lock.ends_with("nuance/config.lock"));
     }
+
+    #[test]
+    fn missing_provider_defaults_to_github() {
+        let toml = r#"
+modules_dir = "/tmp/nuance-modules"
+
+[dependencies]
+"#;
+        let parsed: GlobalConfig = toml::from_str(toml).unwrap();
+        assert_eq!(parsed.default_git_provider, "github");
+    }
+
+    #[test]
+    fn default_provider_base_url_resolves_known_aliases() {
+        let mut config = GlobalConfig::default();
+        assert_eq!(
+            config.default_git_provider_base_url().unwrap(),
+            "https://github.com"
+        );
+
+        config.default_git_provider = "gitlab".to_string();
+        assert_eq!(
+            config.default_git_provider_base_url().unwrap(),
+            "https://gitlab.com"
+        );
+    }
+
+    #[test]
+    fn default_provider_base_url_supports_custom_domain() {
+        let config = GlobalConfig {
+            modules_dir: None,
+            default_git_provider: "git.example.com".to_string(),
+            dependencies: HashMap::new(),
+        };
+        assert_eq!(
+            config.default_git_provider_base_url().unwrap(),
+            "https://git.example.com"
+        );
+    }
+
+    #[test]
+    fn default_provider_base_url_rejects_unknown_provider() {
+        let config = GlobalConfig {
+            modules_dir: None,
+            default_git_provider: "not-a-provider".to_string(),
+            dependencies: HashMap::new(),
+        };
+        let err = config.default_git_provider_base_url().unwrap_err();
+        assert!(err.to_string().contains("unsupported default_git_provider"));
+    }
 }