Surface error when unable to find package (#45)

Cargo.lock

@@ -1773,6 +1773,7 @@ dependencies = [
  "platform-tags",
  "puffin-client",
  "puffin-package",
+ "thiserror",
  "tracing",
  "wheel-filename",
 ]

crates/puffin-cli/src/commands/compile.rs

@@ -49,7 +49,7 @@ pub(crate) async fn compile(src: &Path, cache: Option<&Path>) -> Result<ExitStat
         markers,
         &tags,
         &client,
-        puffin_resolver::Flags::default(),
+        puffin_resolver::ResolveFlags::default(),
     )
     .await?;
 

crates/puffin-cli/src/commands/sync.rs

@@ -82,7 +82,7 @@ pub(crate) async fn sync(src: &Path, cache: Option<&Path>, flags: SyncFlags) ->
         markers,
         &tags,
         &client,
-        puffin_resolver::Flags::NO_DEPS,
+        puffin_resolver::ResolveFlags::NO_DEPS,
     )
     .await?;
 

crates/puffin-cli/src/main.rs

@@ -95,10 +95,7 @@ async fn main() -> ExitCode {
         Err(err) => {
             #[allow(clippy::print_stderr)]
             {
-                eprintln!("{}", "puffin failed".red().bold());
-                for cause in err.chain() {
-                    eprintln!("  {} {cause}", "Cause:".bold());
-                }
+                eprintln!("{}: {}", "error".red().bold(), err);
             }
             ExitStatus::Error.into()
         }

crates/puffin-client/src/lib.rs

@@ -1,5 +1,6 @@
 pub use api::{File, SimpleJson};
 pub use client::{PypiClient, PypiClientBuilder};
+pub use error::PypiClientError;
 
 mod api;
 mod client;

crates/puffin-resolver/Cargo.toml

@@ -21,4 +21,5 @@ bitflags = { workspace = true }
 futures = { workspace = true }
 pep440_rs = { path = "../pep440-rs" }
 pep508_rs = { path = "../pep508-rs" }
+thiserror = { workspace = true }
 tracing = { workspace = true }

crates/puffin-resolver/src/lib.rs

@@ -5,6 +5,7 @@ use anyhow::Result;
 use bitflags::bitflags;
 use futures::future::Either;
 use futures::{StreamExt, TryFutureExt};
+use thiserror::Error;
 use tracing::debug;
 
 use pep440_rs::Version;
@@ -45,20 +46,38 @@ impl PinnedPackage {
 
 bitflags! {
     #[derive(Debug, Copy, Clone, Default)]
-    pub struct Flags: u8 {
+    pub struct ResolveFlags: u8 {
         /// Don't install package dependencies.
         const NO_DEPS = 1 << 0;
     }
 }
 
+#[derive(Error, Debug)]
+pub enum ResolveError {
+    #[error("Failed to find a version of {0} that satisfies the requirement")]
+    NotFound(Requirement),
+
+    #[error(transparent)]
+    Client(#[from] puffin_client::PypiClientError),
+
+    #[error(transparent)]
+    TrySend(#[from] futures::channel::mpsc::SendError),
+}
+
+impl<T> From<futures::channel::mpsc::TrySendError<T>> for ResolveError {
+    fn from(value: futures::channel::mpsc::TrySendError<T>) -> Self {
+        value.into_send_error().into()
+    }
+}
+
 /// Resolve a set of requirements into a set of pinned versions.
 pub async fn resolve(
     requirements: &Requirements,
     markers: &MarkerEnvironment,
     tags: &Tags,
     client: &PypiClient,
-    flags: Flags,
-) -> Result<Resolution> {
+    flags: ResolveFlags,
+) -> Result<Resolution, ResolveError> {
     // A channel to fetch package metadata (e.g., given `flask`, fetch all versions) and version
     // metadata (e.g., given `flask==1.0.0`, fetch the metadata for that version).
     let (package_sink, package_stream) = futures::channel::mpsc::unbounded();
@@ -128,7 +147,7 @@ pub async fn resolve(
                             .iter()
                             .all(|specifier| specifier.contains(&version))
                     }) else {
-                        continue;
+                        return Err(ResolveError::NotFound(requirement));
                     };
 
                     package_sink.unbounded_send(Request::Version(requirement, file.clone()))?;
@@ -151,7 +170,7 @@ pub async fn resolve(
                         },
                     );
 
-                    if !flags.intersects(Flags::NO_DEPS) {
+                    if !flags.intersects(ResolveFlags::NO_DEPS) {
                         // Enqueue its dependencies.
                         for dependency in metadata.requires_dist {
                             if !dependency.evaluate_markers(