B-Nilson batch: #75, #81, #76, #77, uvr-r #8 / #9

Six small fixes accumulated on main toward the next batched release.
No tag yet — pending brutal-code-reviewer pass + #74 verification.

#75 — `uvr init` false-positive "No .r-version pin" notice
  Regression on the v0.3.1 fallback notice. The notice fired on every
  fresh init when R was uvr-managed, nagging the user to "pin a
  project R" even though the resolved binary was already a sane
  default. Now only fires when find_r_binary returns a non-uvr-managed
  R (system R on PATH) — the case actually worth nagging about.

#81 — `uvr run script.R` no longer dumps R session intro banner
  Pass `--quiet` to R when invoked with a script path. Interactive
  `uvr run` (no script) still shows the banner since that's part of
  the REPL experience.

#76 — `uvr add --no-lock` / `--no-install`
  Two new flags for programmatic uvr.toml construction. `--no-lock`
  short-circuits before resolution (manifest update only). `--no-install`
  keeps the resolution but skips the install. Useful for batched
  scripted `uvr add` calls followed by one explicit `uvr sync`.

#77 — `uvr import --name <NAME>`
  Override the project name on import. In merge mode, replaces the
  existing manifest's name; in fresh-import mode, replaces the cwd
  basename default.

uvr-r #8 — `uvr::add("nbafrank/uvr-r")` resolves the actual package name
  Was deriving the package name from the URL basename ("uvr-r"), which
  diverges from the actual `Package:` field in DESCRIPTION ("uvr") for
  R companion-package-style repos. Now fetches the remote DESCRIPTION
  via raw.githubusercontent.com at the requested ref and uses the
  Package field. Falls back to URL basename + warn on network failure.

uvr-r #9 — `..` no longer appears in `uvr r list --all` output
  The directory-listing scraper for Windows /base/old/ was picking up
  `href="../"` (parent dir link) as a fake "version" because the prior
  digits-and-dots sanity check passed for the literal string `..`.
  New `is_real_r_version` requires at least one digit per component
  and 2-4 components; covers ".." and similar listing artefacts.
  Tests added.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: nbafrank

crates/uvr-core/src/r_version/downloader.rs

@@ -340,6 +340,22 @@ async fn version_not_found_error(
     ))
 }
 
+/// True when `s` looks like a real R version string (`X.Y` or `X.Y.Z`
+/// with all-digit components). Rejects directory-listing artefacts like
+/// `..` (parent-dir link) and `.` that pass a naive digits-and-dots
+/// check. Used by both the directory-listing scraper in `fetch_available_versions`
+/// (uvr-r #9) and `scan_versions_from_listing` to keep the version
+/// surface clean.
+fn is_real_r_version(s: &str) -> bool {
+    let parts: Vec<&str> = s.split('.').collect();
+    if parts.len() < 2 || parts.len() > 4 {
+        return false;
+    }
+    parts
+        .iter()
+        .all(|p| !p.is_empty() && p.chars().all(|c| c.is_ascii_digit()))
+}
+
 /// Pull `R-X.Y.Z` version strings out of an HTML directory listing.
 fn scan_versions_from_listing(body: &str) -> Vec<String> {
     use regex::Regex;
@@ -1087,8 +1103,7 @@ pub async fn fetch_available_versions(
         .filter_map(|chunk| {
             let end = chunk.find(suffix)?;
             let ver = &chunk[..end];
-            // Sanity check: must be X.Y or X.Y.Z (digits and dots only).
-            if ver.chars().all(|c| c.is_ascii_digit() || c == '.') && ver.contains('.') {
+            if is_real_r_version(ver) {
                 Some(ver.to_string())
             } else {
                 None
@@ -1106,12 +1121,18 @@ pub async fn fetch_available_versions(
             .and_then(|r| r.error_for_status())
         {
             if let Ok(text) = old_html.text().await {
-                // Old directory lists subdirectories like href="4.4.2/"
+                // Old directory lists subdirectories like href="4.4.2/".
+                // It also lists `href="../"` (parent dir) — that one
+                // satisfies the prior digits-and-dots sanity check (`..`
+                // is two dots, no digits) and was getting picked up as a
+                // bogus "version", surfacing as a `..` row in `uvr r
+                // list --all` and `uvr::r_list(all = TRUE)` (uvr-r #9).
+                // `is_real_r_version` requires at least one digit per
+                // component.
                 for chunk in text.split("href=\"").skip(1) {
                     if let Some(end) = chunk.find('/') {
                         let ver = &chunk[..end];
-                        if ver.chars().all(|c| c.is_ascii_digit() || c == '.') && ver.contains('.')
-                        {
+                        if is_real_r_version(ver) {
                             versions.push(ver.to_string());
                         }
                     }
@@ -1177,6 +1198,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn is_real_r_version_accepts_versions() {
+        assert!(is_real_r_version("4.5.3"));
+        assert!(is_real_r_version("4.6"));
+        assert!(is_real_r_version("3.6.3"));
+        assert!(is_real_r_version("4.5.3.0")); // 4 components, rare but valid
+    }
+
+    #[test]
+    fn is_real_r_version_rejects_directory_listing_noise() {
+        // Reproduces uvr-r #9 — the Windows `/base/old/` directory listing
+        // includes `href="../"` (parent dir). Without this guard the `..`
+        // string passed the all-digits-and-dots check and ended up in the
+        // version list, surfacing as a `..` row in `uvr r list --all` and
+        // `uvr::r_list(all = TRUE)`.
+        assert!(!is_real_r_version(".."));
+        assert!(!is_real_r_version("."));
+        assert!(!is_real_r_version(""));
+        assert!(!is_real_r_version("4."));
+        assert!(!is_real_r_version(".4.5"));
+        assert!(!is_real_r_version("4..5"));
+        assert!(!is_real_r_version("v4.5.3"));
+        assert!(!is_real_r_version("4.5.3-rc"));
+    }
+
     #[test]
     fn macos_arm64_dir_is_expected() {
         let d = macos_arm64_dir();

crates/uvr/src/cli.rs

@@ -141,6 +141,17 @@ pub struct AddArgs {
     /// (override via `UVR_INSTALL_TIMEOUT`).
     #[arg(long, value_name = "DURATION")]
     pub timeout: Option<String>,
+
+    /// Update uvr.toml only — skip lockfile resolution and install.
+    /// Useful when scripting multiple `uvr add` calls and running
+    /// `uvr lock` + `uvr sync` once at the end (#76).
+    #[arg(long)]
+    pub no_lock: bool,
+
+    /// Update uvr.toml and lockfile, but don't install. Run `uvr sync`
+    /// later to install. Implies `--no-lock` is unset (#76).
+    #[arg(long)]
+    pub no_install: bool,
 }
 
 // ────────────────────────────────────────────────────────────
@@ -277,6 +288,12 @@ pub struct ImportArgs {
     #[arg(long, short = 'i', value_name = "FILE", conflicts_with = "path")]
     pub input: Option<String>,
 
+    /// Override the project name written to `uvr.toml`. Defaults to the
+    /// current directory's basename (or, in merge mode, preserves the
+    /// existing project name unless `--name` is given) (#77).
+    #[arg(long, value_name = "NAME")]
+    pub name: Option<String>,
+
     /// Resolve and install packages after import
     #[arg(long)]
     pub lock: bool,

crates/uvr/src/commands/add.rs

@@ -75,13 +75,16 @@ fn parse_add_spec(raw: &str, bioc: bool) -> Result<(String, DependencySpec)> {
     Ok((name, spec))
 }
 
+#[allow(clippy::too_many_arguments)]
 pub async fn run(
     packages: Vec<String>,
     dev: bool,
     bioc: bool,
     source: Option<String>,
     jobs: usize,
     timeout: Option<std::time::Duration>,
+    no_lock: bool,
+    no_install: bool,
 ) -> Result<()> {
     let mut project = Project::find_cwd().context("Not inside a uvr project")?;
 
@@ -117,11 +120,26 @@ pub async fn run(
         }
     }
 
-    let parsed: Vec<(String, DependencySpec)> = packages
+    let mut parsed: Vec<(String, DependencySpec)> = packages
         .iter()
         .map(|p| parse_add_spec(p, bioc))
         .collect::<Result<Vec<_>>>()?;
 
+    // For GitHub specs (`user/repo@ref`), the URL-derived basename is only a
+    // provisional package name. R's actual package name lives in the
+    // remote's DESCRIPTION's `Package:` field — and for some packages
+    // those don't match (the `nbafrank/uvr-r` repo ships package `uvr`,
+    // see uvr-r #8). Fetch the DESCRIPTION up-front so the manifest entry
+    // is keyed by the real package name and matches what the resolver
+    // will produce in the lockfile.
+    if let Err(e) = resolve_github_pkg_names(&mut parsed).await {
+        // Don't bail — fall through with the URL-derived names if the
+        // network is unreachable. The user can edit uvr.toml manually.
+        ui::warn(format!(
+            "Could not resolve GitHub package names from DESCRIPTION ({e}). Using repo basenames; you may need to edit uvr.toml if the package name differs."
+        ));
+    }
+
     // Reject base/recommended packages that ship with R — they can't be installed from CRAN.
     for (name, _) in &parsed {
         if is_base_package(name) {
@@ -160,7 +178,19 @@ pub async fn run(
         .save_manifest()
         .context("Failed to write uvr.toml")?;
 
-    // Re-resolve → update lockfile → install new packages
+    // #76 — `--no-lock` short-circuits before resolution; useful for
+    // building uvr.toml programmatically (e.g. from a script generating
+    // multiple `uvr add` calls in a row, then a single explicit
+    // `uvr lock` + `uvr sync` at the end). `--no-install` keeps the
+    // resolution but skips the install — same use case at a coarser
+    // grain. `--no-lock` implies `--no-install` since there's no
+    // lockfile to install from.
+    if no_lock {
+        ui::bullet_dim("Skipped lock + install (--no-lock).");
+        return Ok(());
+    }
+
+    // Re-resolve → update lockfile (and roll back manifest on failure).
     let resolve_result = crate::commands::lock::resolve_and_lock(&project, false).await;
     if let Err(e) = resolve_result {
         // Roll back the manifest to its original state
@@ -172,13 +202,90 @@ pub async fn run(
     }
     let lockfile = resolve_result.unwrap();
 
+    if no_install {
+        ui::bullet_dim("Skipped install (--no-install). Run `uvr sync` to install.");
+        return Ok(());
+    }
+
     crate::commands::sync::install_from_lockfile(&project, &lockfile, jobs, None, timeout)
         .await
         .context("Failed to install packages after add")?;
 
     Ok(())
 }
 
+/// For each GitHub-sourced dep in `parsed`, fetch the remote DESCRIPTION
+/// and replace the URL-derived name with the actual `Package:` field
+/// (uvr-r #8). Mutates in place. Best-effort — if any individual fetch
+/// fails, that entry keeps its URL-derived name and we warn at the call
+/// site.
+async fn resolve_github_pkg_names(parsed: &mut [(String, DependencySpec)]) -> Result<()> {
+    use uvr_core::registry::github::parse_github_spec;
+
+    let needs_resolve: Vec<usize> = parsed
+        .iter()
+        .enumerate()
+        .filter_map(|(i, (_, spec))| match spec {
+            DependencySpec::Detailed(d) if d.git.is_some() => Some(i),
+            _ => None,
+        })
+        .collect();
+    if needs_resolve.is_empty() {
+        return Ok(());
+    }
+
+    let client = crate::commands::util::build_client()?;
+    for idx in needs_resolve {
+        let (provisional_name, spec) = &parsed[idx];
+        let DependencySpec::Detailed(d) = spec else {
+            continue;
+        };
+        let Some(git) = d.git.as_deref() else {
+            continue;
+        };
+        let git_ref = d.rev.as_deref().unwrap_or("HEAD").to_string();
+        let spec_str = format!("{git}@{git_ref}");
+        let Some((user, repo, resolved_ref)) = parse_github_spec(&spec_str) else {
+            continue;
+        };
+        // Cheap path: hit raw.githubusercontent.com directly for the
+        // DESCRIPTION at the requested ref. Avoids the commit-resolution
+        // round-trip that the full resolver does — we only need the
+        // Package: field.
+        let url =
+            format!("https://raw.githubusercontent.com/{user}/{repo}/{resolved_ref}/DESCRIPTION");
+        match client
+            .get(&url)
+            .header("User-Agent", concat!("uvr/", env!("CARGO_PKG_VERSION")))
+            .send()
+            .await
+            .and_then(|r| r.error_for_status())
+        {
+            Ok(resp) => {
+                let text = resp.text().await.unwrap_or_default();
+                let fields = uvr_core::dcf::parse_dcf_fields(&text);
+                if let Some(actual) = fields.get("Package") {
+                    let actual = actual.trim().to_string();
+                    if !actual.is_empty() && actual != *provisional_name {
+                        ui::bullet_dim(format!(
+                            "{} → {} (Package: field in DESCRIPTION)",
+                            palette::dim(provisional_name),
+                            palette::pkg(&actual)
+                        ));
+                        parsed[idx].0 = actual;
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::warn!(
+                    "DESCRIPTION fetch failed for {git}@{resolved_ref}: {e}; using {provisional_name} as the package name"
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
 fn format_spec(spec: &DependencySpec) -> String {
     match spec {
         DependencySpec::Version(v) => v.clone(),

crates/uvr/src/commands/import.rs

@@ -10,7 +10,12 @@ use uvr_core::project::{Project, DOT_UVR_DIR, LIBRARY_DIR, MANIFEST_FILE};
 use crate::ui;
 use crate::ui::palette;
 
-pub async fn run(path: Option<String>, lock: bool, jobs: usize) -> Result<()> {
+pub async fn run(
+    path: Option<String>,
+    name: Option<String>,
+    lock: bool,
+    jobs: usize,
+) -> Result<()> {
     // Find the renv.lock file
     let renv_path = path.unwrap_or_else(|| "renv.lock".to_string());
     let renv_path = Path::new(&renv_path);
@@ -42,14 +47,23 @@ pub async fn run(path: Option<String>, lock: bool, jobs: usize) -> Result<()> {
         let manifest_path = cwd.join(MANIFEST_FILE);
         let existing =
             std::fs::read_to_string(&manifest_path).context("Failed to read existing uvr.toml")?;
-        existing
+        let mut m = existing
             .parse::<Manifest>()
-            .context("Failed to parse existing uvr.toml")?
+            .context("Failed to parse existing uvr.toml")?;
+        // #77 — `--name` overrides the existing manifest's project name
+        // when merging. Without this, `uvr import --name foo` against a
+        // pre-existing uvr.toml silently kept the old name.
+        if let Some(n) = &name {
+            m.project.name = n.clone();
+        }
+        m
     } else {
-        let project_name = cwd
-            .file_name()
-            .map(|n| n.to_string_lossy().to_string())
-            .unwrap_or_else(|| "imported-project".to_string());
+        // Project name: explicit `--name` (#77) wins over the cwd basename.
+        let project_name = name.clone().unwrap_or_else(|| {
+            cwd.file_name()
+                .map(|n| n.to_string_lossy().to_string())
+                .unwrap_or_else(|| "imported-project".to_string())
+        });
         Manifest::new(&project_name, r_version.clone())
     };
 

crates/uvr/src/commands/init.rs

@@ -340,14 +340,23 @@ fn resolve_project_r_binary(dir: &Path) -> Option<std::path::PathBuf> {
     }
 
     // No pin (or pin not yet installed) — fall through to whatever uvr
-    // would find on the system. Surface the fallback so users notice the
-    // IDE config is bound to whatever happened to be on PATH rather than
-    // a project-pinned R.
+    // would find on the system. Surface the fallback ONLY when it
+    // resolves to a non-uvr-managed R (e.g. system R on PATH) — that's
+    // the case worth nagging about, since system R can be removed or
+    // upgraded out from under the IDE config. When the fallback is a
+    // uvr-managed install, the binding is sound and the prior nag was
+    // a false-positive that fired on every fresh `uvr init` (#75).
     let fallback = find_r_binary(None).ok()?;
-    ui::bullet_dim(format!(
-        "No .r-version pin — IDE config bound to {}. Re-run `uvr init --here` after pinning a project R version.",
-        fallback.display()
-    ));
+    let managed_root = dirs::home_dir().map(|h| h.join(".uvr").join("r-versions"));
+    let is_managed = managed_root
+        .as_ref()
+        .is_some_and(|root| fallback.starts_with(root));
+    if !is_managed {
+        ui::bullet_dim(format!(
+            "No .r-version pin — IDE config bound to system R at {}. Run `uvr r install <ver>` then `uvr r pin <ver>` for project-pinned R.",
+            fallback.display()
+        ));
+    }
     Some(fallback)
 }
 

crates/uvr/src/commands/run.rs

@@ -92,6 +92,12 @@ pub async fn run(
     cmd.arg("--no-environ");
 
     if let Some(script_path) = &script {
+        // Script mode — suppress the R session intro banner. Without
+        // --quiet, every `uvr run script.R` dumps the "R version 4.6.0
+        // (2026-…) -- 'Because it was There'" preamble to stdout before
+        // the script starts (#81). --quiet keeps prompts visible (so
+        // interactive `browser()` still works) while dropping the banner.
+        cmd.arg("--quiet");
         cmd.arg("--no-save");
         cmd.arg("--no-restore");
         cmd.arg(format!("--file={script_path}"));
@@ -100,6 +106,9 @@ pub async fn run(
             cmd.args(&args);
         }
     } else {
+        // Interactive mode — keep the banner. It's part of the REPL
+        // experience and a user typing `uvr run` (no script) expects
+        // R's normal startup output.
         cmd.arg("--no-save");
     }
 

crates/uvr/src/main.rs

@@ -92,6 +92,8 @@ async fn run() -> Result<()> {
                 args.source,
                 args.jobs,
                 timeout,
+                args.no_lock,
+                args.no_install,
             )
             .await?;
         }
@@ -121,7 +123,7 @@ async fn run() -> Result<()> {
             // #71: --input/-i is an alternative spelling of the positional path.
             // clap's `conflicts_with` already rejects passing both.
             let path = args.input.or(args.path);
-            commands::import::run(path, args.lock, args.jobs).await?;
+            commands::import::run(path, args.name, args.lock, args.jobs).await?;
         }
         Commands::Completions(args) => {
             commands::completions::run(args.shell)?;