fix: resolve clippy warnings in cortex-cli crate

Author: echobt

src/cortex-cli/src/agent_cmd/types.rs

@@ -253,7 +253,7 @@ mod tests {
     #[test]
     fn test_agent_mode_clone() {
         let mode = AgentMode::Subagent;
-        let cloned = mode.clone();
+        let cloned = mode;
         assert_eq!(mode, cloned);
     }
 

src/cortex-cli/src/agent_cmd/utils.rs

@@ -77,9 +77,9 @@ pub fn matches_pattern(name: &str, pattern: &str) -> bool {
         // *pattern* - contains
         let inner = &pattern[1..pattern.len() - 1];
         name.contains(inner)
-    } else if pattern.starts_with('*') {
+    } else if let Some(suffix) = pattern.strip_prefix('*') {
         // *pattern - ends with
-        name.ends_with(&pattern[1..])
+        name.ends_with(suffix)
     } else if pattern.ends_with('*') {
         // pattern* - starts with
         name.starts_with(&pattern[..pattern.len() - 1])

src/cortex-cli/src/cli/handlers.rs

@@ -648,7 +648,6 @@ pub async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
     // Start TUI with the session
     #[cfg(feature = "cortex-tui")]
     {
-        let config = config;
         // The TUI would need to support session resumption
         cortex_tui::run(config, None).await?;
     }
@@ -698,6 +697,7 @@ pub async fn run_delete(delete_cli: DeleteCommand) -> Result<()> {
 }
 
 /// List sessions.
+#[allow(clippy::too_many_arguments)]
 pub async fn list_sessions(
     all: bool,
     _days: Option<u32>,
@@ -884,10 +884,10 @@ pub async fn list_features() -> Result<()> {
 pub async fn run_serve(serve_cli: ServeCommand) -> Result<()> {
     use cortex_app_server::ServerConfig;
 
-    let mut config = ServerConfig::default();
-
-    // Set listen address from host and port
-    config.listen_addr = format!("{}:{}", serve_cli.host, serve_cli.port);
+    let mut config = ServerConfig {
+        listen_addr: format!("{}:{}", serve_cli.host, serve_cli.port),
+        ..Default::default()
+    };
 
     // Set authentication if provided
     if let Some(token) = serve_cli.auth_token {
@@ -967,7 +967,6 @@ pub async fn run_history(history_cli: HistoryCommand) -> Result<()> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use clap_complete::Shell;
     use std::io::{self, ErrorKind, Write};
 

src/cortex-cli/src/compact_cmd.rs

@@ -16,7 +16,7 @@
 use anyhow::{Context, Result};
 use clap::Parser;
 use serde::Serialize;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 /// Compact CLI command.
 #[derive(Debug, Parser)]
@@ -277,7 +277,7 @@ fn count_orphaned_history(sessions_dir: &PathBuf, history_dir: &PathBuf) -> usiz
 }
 
 /// Check if compaction lock is held.
-fn is_lock_held(data_dir: &PathBuf) -> bool {
+fn is_lock_held(data_dir: &Path) -> bool {
     let lock_path = data_dir.join(".compaction.lock");
     if lock_path.exists()
         && let Ok(metadata) = std::fs::metadata(&lock_path)

src/cortex-cli/src/completion_setup.rs

@@ -6,7 +6,7 @@
 
 use std::fs;
 use std::io::{self, IsTerminal, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use clap_complete::Shell;
 
@@ -37,12 +37,12 @@ fn get_cortex_home() -> Option<PathBuf> {
 }
 
 /// Check if completion setup has already been offered.
-fn completion_already_offered(cortex_home: &PathBuf) -> bool {
+fn completion_already_offered(cortex_home: &Path) -> bool {
     cortex_home.join(COMPLETION_OFFERED_MARKER).exists()
 }
 
 /// Mark that completion setup has been offered.
-fn mark_completion_offered(cortex_home: &PathBuf) -> io::Result<()> {
+fn mark_completion_offered(cortex_home: &Path) -> io::Result<()> {
     // Ensure the directory exists
     fs::create_dir_all(cortex_home)?;
 

src/cortex-cli/src/exec_cmd/autonomy.rs

@@ -2,7 +2,7 @@
 //!
 //! Controls what operations the agent can perform without user approval.
 
-use std::path::PathBuf;
+use std::path::Path;
 
 use clap::ValueEnum;
 use cortex_protocol::{AskForApproval, SandboxPolicy};
@@ -55,17 +55,17 @@ impl AutonomyLevel {
     }
 
     /// Convert to sandbox policy.
-    pub fn to_sandbox_policy(&self, cwd: &PathBuf) -> SandboxPolicy {
+    pub fn to_sandbox_policy(&self, cwd: &Path) -> SandboxPolicy {
         match self {
             AutonomyLevel::ReadOnly => SandboxPolicy::ReadOnly,
             AutonomyLevel::Low | AutonomyLevel::Medium => SandboxPolicy::WorkspaceWrite {
-                writable_roots: vec![cwd.clone()],
+                writable_roots: vec![cwd.to_path_buf()],
                 network_access: *self == AutonomyLevel::Medium,
                 exclude_tmpdir_env_var: false,
                 exclude_slash_tmp: false,
             },
             AutonomyLevel::High => SandboxPolicy::WorkspaceWrite {
-                writable_roots: vec![cwd.clone()],
+                writable_roots: vec![cwd.to_path_buf()],
                 network_access: true,
                 exclude_tmpdir_env_var: false,
                 exclude_slash_tmp: false,

src/cortex-cli/src/exec_cmd/helpers.rs

@@ -1,6 +1,6 @@
 //! Helper functions for exec mode flags.
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result, bail};
 
@@ -59,15 +59,7 @@ pub fn read_clipboard() -> Result<String> {
 
 /// Fetch content from a URL.
 pub async fn fetch_url_content(url: &str) -> Result<String> {
-    // Use reqwest if available, otherwise fall back to curl
-    #[cfg(feature = "reqwest")]
-    {
-        let response = reqwest::get(url).await?;
-        let text = response.text().await?;
-        Ok(text)
-    }
-
-    #[cfg(not(feature = "reqwest"))]
+    // Use curl for fetching
     {
         use std::process::Command;
         let output = Command::new("curl")
@@ -85,7 +77,7 @@ pub async fn fetch_url_content(url: &str) -> Result<String> {
 }
 
 /// Get git diff from the working directory.
-pub fn get_git_diff(cwd: &PathBuf) -> Result<String> {
+pub fn get_git_diff(cwd: &Path) -> Result<String> {
     use std::process::Command;
 
     let output = Command::new("git")
@@ -109,7 +101,7 @@ pub fn get_git_diff(cwd: &PathBuf) -> Result<String> {
 
 /// Collect files matching include/exclude patterns.
 pub fn collect_files_by_pattern(
-    cwd: &PathBuf,
+    cwd: &Path,
     include_patterns: &[String],
     exclude_patterns: &[String],
 ) -> Result<String> {
@@ -323,7 +315,7 @@ mod tests {
     fn test_validate_path_environment() {
         // This test just checks that the function doesn't panic
         let warnings = validate_path_environment();
-        // Warnings may or may not be present depending on the environment
-        assert!(warnings.len() >= 0);
+        // Just verify we got a result (warnings may or may not be present)
+        let _ = warnings;
     }
 }

src/cortex-cli/src/github_cmd.rs

@@ -53,6 +53,7 @@ pub struct InstallArgs {
     ///   - Analyze code changes for bugs, security issues, and best practices
     ///   - Suggest improvements with inline comments
     ///   - Respond to review comments and questions
+    ///
     /// Triggered by: pull_request (opened, synchronize, reopened)
     #[arg(long, default_value_t = true)]
     pub pr_review: bool,
@@ -904,8 +905,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_install_accepts_valid_directory() {
-        use std::io::Write;
-
         // Create a temporary directory
         let temp_dir = std::env::temp_dir().join(format!("cortex_test_dir_{}", std::process::id()));
         std::fs::create_dir_all(&temp_dir).expect("Failed to create temp dir");

src/cortex-cli/src/import_cmd.rs

@@ -5,7 +5,7 @@
 use anyhow::{Context, Result, bail};
 use clap::Parser;
 use std::collections::HashSet;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::styled_output::{print_info, print_success, print_warning};
 use cortex_engine::rollout::recorder::{RolloutRecorder, SessionMeta};
@@ -238,33 +238,7 @@ impl ImportCommand {
 
 /// Fetch content from a URL.
 async fn fetch_url(url: &str) -> Result<String> {
-    // Use reqwest if available, otherwise fall back to curl
-    #[cfg(feature = "reqwest")]
-    {
-        let response = reqwest::get(url).await?;
-        if !response.status().is_success() {
-            bail!("Failed to fetch URL: HTTP {}", response.status());
-        }
-
-        // Check content-type header to warn about non-JSON content
-        if let Some(content_type) = response.headers().get(reqwest::header::CONTENT_TYPE) {
-            let content_type_str = content_type.to_str().unwrap_or("");
-            if !content_type_str.contains("application/json")
-                && !content_type_str.contains("text/plain")
-                && !content_type_str.is_empty()
-            {
-                print_warning(&format!(
-                    "URL returned Content-Type '{}', expected 'application/json'.",
-                    content_type_str
-                ));
-                print_info("The import may fail if the content is not valid JSON.");
-            }
-        }
-
-        Ok(response.text().await?)
-    }
-
-    #[cfg(not(feature = "reqwest"))]
+    // Use curl for fetching
     {
         // Simple curl-based fallback
         use std::process::Command;
@@ -452,7 +426,7 @@ fn validate_export_messages(messages: &[ExportMessage]) -> Result<()> {
 }
 
 /// Convert an export message to a protocol event.
-fn message_to_event(message: &ExportMessage, turn_id: &mut u64, cwd: &PathBuf) -> Result<Event> {
+fn message_to_event(message: &ExportMessage, turn_id: &mut u64, cwd: &Path) -> Result<Event> {
     let event_msg = match message.role.as_str() {
         "user" => {
             *turn_id += 1;
@@ -475,7 +449,7 @@ fn message_to_event(message: &ExportMessage, turn_id: &mut u64, cwd: &PathBuf) -
                 call_id: message.tool_call_id.clone().unwrap_or_default(),
                 turn_id: turn_id.to_string(),
                 command: vec!["imported_tool".to_string()],
-                cwd: cwd.clone(),
+                cwd: cwd.to_path_buf(),
                 parsed_cmd: vec![ParsedCommand {
                     program: "imported_tool".to_string(),
                     args: vec![],

src/cortex-cli/src/lib.rs

@@ -369,8 +369,8 @@ mod tests {
         // Initially should be false unless something panicked
         // We can't reset this, but we can verify the function works
         let has_panic = has_background_panic();
-        // Just verify we can call the function
-        assert!(has_panic == true || has_panic == false);
+        // Just verify we can call the function and it returns a valid boolean
+        let _ = has_panic;
     }
 
     #[test]