fix: resolve all clippy warnings across both crates

- Add #![expect(clippy::print_stdout, clippy::print_stderr)] to CLI binary
- Replace .unwrap() on infallible write! to String with let _ =
- Use map_or instead of map().unwrap_or() per clippy::map_unwrap_or
- Use let...else instead of match-with-early-return
- Fix u64-to-usize truncation with try_from
- Handle REPL history fallback without expect()
- Add #[expect] for safe unwrap after peek in SQL highlighter

Author: benaiad

crates/sqlize-core/src/catalog/types.rs

@@ -277,8 +277,7 @@ impl Column {
     pub fn api_param_key(&self) -> &str {
         self.api_name
             .as_ref()
-            .map(ApiParamName::as_str)
-            .unwrap_or(self.name.as_str())
+            .map_or(self.name.as_str(), ApiParamName::as_str)
     }
 }
 

crates/sqlize/src/main.rs

@@ -1,3 +1,9 @@
+#![expect(
+    clippy::print_stdout,
+    clippy::print_stderr,
+    reason = "CLI binary, stdout is the interface"
+)]
+
 mod mcp;
 mod repl;
 

crates/sqlize/src/mcp.rs

@@ -72,47 +72,43 @@ impl SqlizeServer {
     /// Returns CREATE TABLE DDL with column types and descriptions.
     #[tool(name = "get_schema")]
     async fn get_schema(&self, Parameters(args): Parameters<GetSchemaArgs>) -> String {
-        match &args.table {
-            Some(name) => match self.catalog_set.describe(name) {
-                Some(ddl) => ddl,
-                None => {
-                    let available: Vec<String> = self
-                        .catalog_set
-                        .all_tables()
-                        .iter()
-                        .map(|(_, t)| t.name.as_str().to_owned())
-                        .collect();
-                    format!(
-                        "Table '{name}' not found. Available tables:\n{}",
-                        available.join(", ")
-                    )
-                }
-            },
-            None => {
-                let mut out = String::from(
-                    "Available tables (use get_schema with a table name for full DDL):\n\n",
-                );
-                for (_, table) in self.catalog_set.all_tables() {
-                    let required: Vec<_> =
-                        table.required_params().map(|c| c.name.as_str()).collect();
-                    let req = if required.is_empty() {
-                        String::new()
-                    } else {
-                        format!("  required: {}", required.join(", "))
-                    };
-                    out.push_str(&format!(
-                        "  {:<30} -- {}{}\n",
-                        table.name,
-                        table
-                            .description
-                            .as_ref()
-                            .map(sqlize_core::catalog::types::Description::as_str)
-                            .unwrap_or(""),
-                        req,
-                    ));
-                }
-                out
+        if let Some(name) = &args.table {
+            if let Some(ddl) = self.catalog_set.describe(name) {
+                ddl
+            } else {
+                let available: Vec<String> = self
+                    .catalog_set
+                    .all_tables()
+                    .iter()
+                    .map(|(_, t)| t.name.as_str().to_owned())
+                    .collect();
+                format!(
+                    "Table '{name}' not found. Available tables:\n{}",
+                    available.join(", ")
+                )
             }
+        } else {
+            let mut out = String::from(
+                "Available tables (use get_schema with a table name for full DDL):\n\n",
+            );
+            for (_, table) in self.catalog_set.all_tables() {
+                let required: Vec<_> = table.required_params().map(|c| c.name.as_str()).collect();
+                let req = if required.is_empty() {
+                    String::new()
+                } else {
+                    format!("  required: {}", required.join(", "))
+                };
+                out.push_str(&format!(
+                    "  {:<30} -- {}{}\n",
+                    table.name,
+                    table
+                        .description
+                        .as_ref()
+                        .map_or("", sqlize_core::catalog::types::Description::as_str),
+                    req,
+                ));
+            }
+            out
         }
     }
 
@@ -127,7 +123,7 @@ impl SqlizeServer {
             Err(e) => return format!("Error: {e}"),
         };
 
-        let max = args.max_rows.unwrap_or(100) as usize;
+        let max = usize::try_from(args.max_rows.unwrap_or(100)).unwrap_or(usize::MAX);
         result.rows.truncate(max);
 
         let row_count = result.rows.len();

crates/sqlize/src/repl.rs

@@ -231,6 +231,10 @@ const SQL_KEYWORDS: &[&str] = &[
 struct SqlHighlighter;
 
 impl Highlighter for SqlHighlighter {
+    #[expect(
+        clippy::unwrap_used,
+        reason = "next() after peek() is safe on Peekable"
+    )]
     fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
         let mut styled = StyledText::new();
         let keyword_style = Style::new().fg(Color::Cyan).bold();
@@ -322,8 +326,7 @@ impl Completer for SqlCompleter {
         let before_cursor = &line[..pos];
         let word_start = before_cursor
             .rfind(|c: char| c.is_ascii_whitespace() || c == ',' || c == '(' || c == ')')
-            .map(|i| i + 1)
-            .unwrap_or(0);
+            .map_or(0, |i| i + 1);
 
         let partial = &before_cursor[word_start..];
         if partial.is_empty() {
@@ -430,7 +433,13 @@ pub async fn run(catalog_set: Arc<CatalogSet>, ctx: Arc<QueryEngine>, format: Ou
         Ok(h) => h,
         Err(e) => {
             eprintln!("Warning: could not open history file: {e}");
-            FileBackedHistory::new(1000).expect("in-memory history initialization failed")
+            match FileBackedHistory::new(1000) {
+                Ok(h) => h,
+                Err(e) => {
+                    eprintln!("Warning: could not create in-memory history: {e}");
+                    return;
+                }
+            }
         }
     };
 
@@ -545,8 +554,7 @@ fn handle_show_tables(catalog_set: &CatalogSet) {
         let desc = table
             .description
             .as_ref()
-            .map(sqlize_core::catalog::types::Description::as_str)
-            .unwrap_or("-");
+            .map_or("-", sqlize_core::catalog::types::Description::as_str);
 
         if catalog_set.is_multi() {
             builder.push_record([
@@ -732,9 +740,7 @@ fn format_value(v: &ScalarValue) -> String {
 }
 
 fn term_width() -> usize {
-    terminal_size::terminal_size()
-        .map(|(w, _)| w.0 as usize)
-        .unwrap_or(120)
+    terminal_size::terminal_size().map_or(120, |(w, _)| w.0 as usize)
 }
 
 fn history_path() -> std::path::PathBuf {