Add opensrc fetch subcommand to cache source without printing paths (#53)

Extracts the shared "ensure cached" logic into a new `core::fetcher`
module used by both `path` (prints the cached path) and the new `fetch`
command (prints fetch status + summary, supports `-q/--quiet`).

Author: ctate

AGENTS.md

@@ -54,9 +54,18 @@ See `~/.opensrc/sources.json` for the list of available packages and their versi
 
 Use this source code when you need to understand how a package works internally, not just its types/interface.
 
+### Fetching Source Code
+
+To just cache a package's source without doing anything else, use `opensrc fetch`:
+
+```bash
+opensrc fetch <package>
+opensrc fetch pypi:<package> crates:<package> <owner>/<repo>
+```
+
 ### Reading Source Code
 
-Use `opensrc path` inside other commands to search, read, or explore a package's source:
+Use `opensrc path` inside other commands to search, read, or explore a package's source (fetches on cache miss):
 
 ```bash
 rg "pattern" $(opensrc path <package>)

packages/opensrc/cli/src/commands/fetch.rs

@@ -0,0 +1,68 @@
+use crate::core::fetcher::ensure_cached;
+
+pub fn run(
+    specs: &[String],
+    cwd: Option<&str>,
+    quiet: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let cwd = cwd.unwrap_or(".");
+
+    let mut fetched = 0u32;
+    let mut cached = 0u32;
+    let mut had_errors = false;
+
+    for spec in specs {
+        match ensure_cached(spec, cwd, !quiet) {
+            Ok(outcome) => {
+                if outcome.from_cache {
+                    cached += 1;
+                    if !quiet {
+                        println!(
+                            "  ✓ {}@{} already cached ({})",
+                            outcome.name,
+                            outcome.version,
+                            outcome.path.display()
+                        );
+                    }
+                } else {
+                    fetched += 1;
+                    if !quiet {
+                        if let Some(warn) = &outcome.warning {
+                            println!("  ⚠ {warn}");
+                        }
+                        println!(
+                            "  ✓ Fetched {}@{} from {} ({})",
+                            outcome.name,
+                            outcome.version,
+                            outcome.source_label,
+                            outcome.path.display()
+                        );
+                    }
+                }
+            }
+            Err(e) => {
+                had_errors = true;
+                eprintln!("  ✗ {spec}: {e}");
+            }
+        }
+    }
+
+    if !quiet {
+        let mut parts = Vec::new();
+        if fetched > 0 {
+            parts.push(format!("{fetched} fetched"));
+        }
+        if cached > 0 {
+            parts.push(format!("{cached} already cached"));
+        }
+        if !parts.is_empty() {
+            println!("\n{}", parts.join(", "));
+        }
+    }
+
+    if had_errors {
+        return Err("Some sources could not be fetched".into());
+    }
+
+    Ok(())
+}

packages/opensrc/cli/src/commands/list.rs

@@ -7,12 +7,12 @@ pub fn run(json: bool) -> Result<(), Box<dyn std::error::Error>> {
 
     if total == 0 {
         println!("No sources cached yet.");
-        println!("\nUse `opensrc path <package>` to fetch source code for a package.");
-        println!("Use `opensrc path <owner>/<repo>` to fetch a GitHub repository.");
+        println!("\nUse `opensrc fetch <package>` to cache source code for a package.");
+        println!("Use `opensrc fetch <owner>/<repo>` to cache a GitHub repository.");
         println!("\nSupported registries:");
-        println!("  • npm:      opensrc path zod, opensrc path npm:react");
-        println!("  • PyPI:     opensrc path pypi:requests");
-        println!("  • crates:   opensrc path crates:serde");
+        println!("  • npm:      opensrc fetch zod, opensrc fetch npm:react");
+        println!("  • PyPI:     opensrc fetch pypi:requests");
+        println!("  • crates:   opensrc fetch crates:serde");
         return Ok(());
     }
 

packages/opensrc/cli/src/commands/mod.rs

@@ -1,4 +1,5 @@
 pub mod clean;
+pub mod fetch;
 pub mod list;
 pub mod path;
 pub mod remove;

packages/opensrc/cli/src/commands/path.rs

@@ -1,170 +1,4 @@
-use std::path::PathBuf;
-
-use crate::core::cache::{
-    get_absolute_path, get_package_info, get_repo_info, list_sources, now_iso, write_sources,
-    PackageEntry, RepoEntry,
-};
-use crate::core::git::{fetch_repo_source, fetch_source};
-use crate::core::registries::repo::{parse_repo_spec, resolve_repo};
-use crate::core::registries::{
-    detect_input_type, parse_package_spec, resolve_package, PackageSpec, Registry,
-};
-use crate::core::version::detect_installed_version;
-
-fn log(verbose: bool, msg: &str) {
-    if verbose {
-        eprintln!("{msg}");
-    }
-}
-
-fn handle_package(spec: &str, cwd: &str, verbose: bool) -> Result<(), Box<dyn std::error::Error>> {
-    let parsed = parse_package_spec(spec);
-    let registry = parsed.registry;
-    let name = parsed.name.clone();
-    let mut version = parsed.version.clone();
-
-    // Check cache if version is specified
-    if let Some(ref v) = version {
-        if let Some(existing) = get_package_info(&name, registry) {
-            if existing.version == *v {
-                let abs = get_absolute_path(&existing.path);
-                println!("{}", abs.display());
-                return Ok(());
-            }
-        }
-    }
-
-    // Detect installed version for npm
-    if version.is_none() && registry == Registry::Npm {
-        let detected = detect_installed_version(&name, &PathBuf::from(cwd));
-        if let Some(v) = detected {
-            version = Some(v.clone());
-            if let Some(existing) = get_package_info(&name, registry) {
-                if existing.version == v {
-                    let abs = get_absolute_path(&existing.path);
-                    println!("{}", abs.display());
-                    return Ok(());
-                }
-            }
-        }
-    }
-
-    log(
-        verbose,
-        &format!("Fetching {name} from {}...", registry.label()),
-    );
-
-    let pkg_spec = PackageSpec {
-        registry,
-        name: name.clone(),
-        version,
-    };
-    let resolved = resolve_package(&pkg_spec)?;
-    log(verbose, &format!("  → Cloning at {}...", resolved.git_tag));
-
-    let result = fetch_source(&resolved);
-
-    if !result.success {
-        return Err(format!("Failed: {}", result.error.as_deref().unwrap_or("unknown")).into());
-    }
-
-    if let Some(ref warn) = result.error {
-        log(verbose, &format!("  ⚠ {warn}"));
-    }
-
-    // Update index
-    let (mut packages, repos) = list_sources();
-    let entry = PackageEntry {
-        name: result.package.clone(),
-        version: result.version.clone(),
-        registry: result.registry.unwrap_or(Registry::Npm),
-        path: result.path.clone(),
-        fetched_at: now_iso(),
-    };
-    if let Some(idx) = packages
-        .iter()
-        .position(|p| p.name == entry.name && p.registry == entry.registry)
-    {
-        packages[idx] = entry;
-    } else {
-        packages.push(entry);
-    }
-    write_sources(packages, repos)?;
-
-    let abs = get_absolute_path(&result.path);
-    log(verbose, &format!("  ✓ Cached at {}", abs.display()));
-    println!("{}", abs.display());
-    Ok(())
-}
-
-fn handle_repo(spec: &str, _cwd: &str, verbose: bool) -> Result<(), Box<dyn std::error::Error>> {
-    let repo_spec = match parse_repo_spec(spec) {
-        Some(s) => s,
-        None => {
-            return Err(format!("Invalid repository format: {spec}").into());
-        }
-    };
-
-    let display = format!("{}/{}/{}", repo_spec.host, repo_spec.owner, repo_spec.repo);
-
-    // Check cache
-    if let Some(ref r) = repo_spec.git_ref {
-        if let Some(existing) = get_repo_info(&display) {
-            if existing.version == *r {
-                let abs = get_absolute_path(&existing.path);
-                println!("{}", abs.display());
-                return Ok(());
-            }
-        }
-    }
-
-    log(
-        verbose,
-        &format!("Fetching {}/{}...", repo_spec.owner, repo_spec.repo),
-    );
-    let resolved = resolve_repo(&repo_spec)?;
-    log(verbose, &format!("  → Cloning at {}...", resolved.git_ref));
-
-    let result = fetch_repo_source(&resolved);
-
-    if !result.success {
-        return Err(format!("Failed: {}", result.error.as_deref().unwrap_or("unknown")).into());
-    }
-
-    if let Some(ref warn) = result.error {
-        log(verbose, &format!("  ⚠ {warn}"));
-    }
-
-    // Update index
-    let (packages, mut repos) = list_sources();
-    let entry = RepoEntry {
-        name: result.package.clone(),
-        version: result.version.clone(),
-        path: result.path.clone(),
-        fetched_at: now_iso(),
-    };
-    if let Some(idx) = repos.iter().position(|r| r.name == entry.name) {
-        repos[idx] = entry;
-    } else {
-        repos.push(entry);
-    }
-    write_sources(packages, repos)?;
-
-    let abs = get_absolute_path(&result.path);
-    log(verbose, &format!("  ✓ Cached at {}", abs.display()));
-    println!("{}", abs.display());
-    Ok(())
-}
-
-fn run_one(spec: &str, cwd: &str, verbose: bool) -> Result<(), Box<dyn std::error::Error>> {
-    let input_type = detect_input_type(spec);
-
-    if input_type == "repo" {
-        handle_repo(spec, cwd, verbose)
-    } else {
-        handle_package(spec, cwd, verbose)
-    }
-}
+use crate::core::fetcher::ensure_cached;
 
 pub fn run(
     specs: &[String],
@@ -173,7 +7,8 @@ pub fn run(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let cwd = cwd.unwrap_or(".");
     for spec in specs {
-        run_one(spec, cwd, verbose)?;
+        let outcome = ensure_cached(spec, cwd, verbose)?;
+        println!("{}", outcome.path.display());
     }
     Ok(())
 }