feat: v0.5.0 — reannounce, sequential download, per-file priority

3 new features:

- tsm reannounce <id> — force tracker reannounce
- tsm sequential <id> [--on|--off] — toggle sequential download
  (Transmission 4.0+)
- tsm files <id> --priority high/normal/low --priority-indices 0,1
  --skip 2,3 --unskip 2 — per-file priority and download selection
  with index validation and updated display columns

Author: lu-zhengda

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "transmission-cli"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2024"
 description = "A CLI for Transmission BitTorrent client"
 license = "MIT"

Cargo.toml

@@ -136,10 +136,26 @@ pub enum Command {
         id: i64,
     },
 
-    /// List files in a torrent
+    /// List files in a torrent, or set file priority/skip
     Files {
         /// Torrent ID
         id: i64,
+
+        /// Set file priority (requires --priority-indices)
+        #[arg(long, requires = "priority_indices")]
+        priority: Option<FilePriority>,
+
+        /// File indices for priority change (comma-separated, 0-based)
+        #[arg(long = "priority-indices", value_delimiter = ',')]
+        priority_indices: Option<Vec<usize>>,
+
+        /// Skip files (comma-separated indices, 0-based)
+        #[arg(long, value_delimiter = ',')]
+        skip: Option<Vec<usize>>,
+
+        /// Unskip files (comma-separated indices, 0-based)
+        #[arg(long, value_delimiter = ',')]
+        unskip: Option<Vec<usize>>,
     },
 
     /// Show or set speed limits (session-level or per-torrent)
@@ -228,6 +244,26 @@ pub enum Command {
     /// Check connectivity, disk space, and port status
     Health,
 
+    /// Toggle sequential download mode (Transmission 4.0+)
+    Sequential {
+        /// Torrent ID
+        id: i64,
+
+        /// Enable sequential download
+        #[arg(long, conflicts_with = "off")]
+        on: bool,
+
+        /// Disable sequential download
+        #[arg(long, conflicts_with = "on")]
+        off: bool,
+    },
+
+    /// Force tracker reannounce
+    Reannounce {
+        /// Torrent ID
+        id: i64,
+    },
+
     /// Manage torrent trackers
     Tracker {
         #[command(subcommand)]
@@ -331,6 +367,13 @@ pub enum PolicyAction {
     },
 }
 
+#[derive(Debug, Clone, ValueEnum)]
+pub enum FilePriority {
+    High,
+    Normal,
+    Low,
+}
+
 #[derive(Debug, Clone, ValueEnum)]
 pub enum BandwidthPriority {
     Low,

src/cli.rs

@@ -1,3 +1,4 @@
+use crate::cli::FilePriority;
 use crate::client::TransmissionClient;
 use crate::error::Error;
 use crate::output::{json, table};
@@ -14,13 +15,74 @@ pub fn execute_info(client: &TransmissionClient, id: i64, json_output: bool) ->
     }
 }
 
-pub fn execute_files(client: &TransmissionClient, id: i64, json_output: bool) -> Result<(), Error> {
-    let (name, files) = methods::torrent_get_files(client, id)?;
+#[allow(clippy::too_many_arguments)]
+pub fn execute_files(
+    client: &TransmissionClient,
+    id: i64,
+    priority: Option<&FilePriority>,
+    priority_indices: Option<&[usize]>,
+    skip: Option<&[usize]>,
+    unskip: Option<&[usize]>,
+    json_output: bool,
+) -> Result<(), Error> {
+    let has_mutation = priority.is_some() || skip.is_some() || unskip.is_some();
+
+    if has_mutation {
+        // Pre-fetch to validate indices
+        let (_, files, _) = methods::torrent_get_files(client, id)?;
+        let file_count = files.len();
+
+        // Validate all indices
+        let all_indices: Vec<usize> = priority_indices
+            .into_iter()
+            .flatten()
+            .chain(skip.into_iter().flatten())
+            .chain(unskip.into_iter().flatten())
+            .copied()
+            .collect();
+
+        for &idx in &all_indices {
+            if idx >= file_count {
+                return Err(Error::Config(format!(
+                    "File index {idx} out of range (torrent has {file_count} files, indices 0-{})",
+                    file_count.saturating_sub(1)
+                )));
+            }
+        }
+
+        // Build priority arrays
+        let (p_high, p_normal, p_low) = match priority {
+            Some(FilePriority::High) => (priority_indices, None, None),
+            Some(FilePriority::Normal) => (None, priority_indices, None),
+            Some(FilePriority::Low) => (None, None, priority_indices),
+            None => (None, None, None),
+        };
+
+        methods::torrent_set_file_properties(client, id, p_high, p_normal, p_low, unskip, skip)?;
+    }
+
+    // Fetch and display
+    let (name, files, stats) = methods::torrent_get_files(client, id)?;
 
     if json_output {
-        json::print_json(&files)
+        let json_files: Vec<serde_json::Value> = files
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let stat = stats.get(i);
+                serde_json::json!({
+                    "index": i,
+                    "name": f.name,
+                    "length": f.length,
+                    "bytesCompleted": f.bytes_completed,
+                    "priority": table::priority_string(stat.map(|s| s.priority).unwrap_or(0)),
+                    "wanted": stat.map(|s| s.wanted).unwrap_or(true),
+                })
+            })
+            .collect();
+        json::print_json(&json_files)
     } else {
-        table::print_torrent_files(&name, &files);
+        table::print_torrent_files(&name, &files, &stats);
         Ok(())
     }
 }

src/commands/info.rs

@@ -6,9 +6,11 @@ pub mod label;
 pub mod list;
 pub mod login;
 pub mod policy;
+pub mod reannounce;
 pub mod relocate;
 pub mod remove;
 pub mod search;
+pub mod sequential;
 pub mod session;
 pub mod speed;
 pub mod start_stop;

src/commands/mod.rs

@@ -0,0 +1,9 @@
+use crate::client::TransmissionClient;
+use crate::error::Error;
+use crate::rpc::methods;
+
+pub fn execute(client: &TransmissionClient, id: i64) -> Result<(), Error> {
+    methods::torrent_reannounce(client, id)?;
+    println!("Reannouncing torrent {id}.");
+    Ok(())
+}

src/commands/reannounce.rs

@@ -0,0 +1,36 @@
+use crate::client::TransmissionClient;
+use crate::error::Error;
+use crate::output::json as json_output;
+use crate::rpc::methods;
+
+pub fn execute(
+    client: &TransmissionClient,
+    id: i64,
+    _on: bool,
+    off: bool,
+    json_mode: bool,
+) -> Result<(), Error> {
+    let enable = !off; // default to on when neither flag is set
+    methods::torrent_set_sequential(client, id, enable)?;
+
+    let (name, sequential) = methods::torrent_get_sequential(client, id)?;
+
+    match sequential {
+        Some(state) => {
+            if json_mode {
+                json_output::print_json(&serde_json::json!({
+                    "id": id,
+                    "name": name,
+                    "sequential_download": state,
+                }))
+            } else {
+                let status = if state { "Enabled" } else { "Disabled" };
+                println!("Sequential download for \"{name}\" (ID: {id}): {status}");
+                Ok(())
+            }
+        }
+        None => Err(Error::Rpc(
+            "Sequential download not supported (requires Transmission 4.0+)".to_string(),
+        )),
+    }
+}

src/commands/sequential.rs

@@ -93,7 +93,21 @@ fn main() {
         Command::Remove { id, delete } => commands::remove::execute(&client, *id, *delete),
         Command::Verify { id } => commands::start_stop::execute_verify(&client, *id),
         Command::Info { id } => commands::info::execute_info(&client, *id, config.json),
-        Command::Files { id } => commands::info::execute_files(&client, *id, config.json),
+        Command::Files {
+            id,
+            priority,
+            priority_indices,
+            skip,
+            unskip,
+        } => commands::info::execute_files(
+            &client,
+            *id,
+            priority.as_ref(),
+            priority_indices.as_deref(),
+            skip.as_deref(),
+            unskip.as_deref(),
+            config.json,
+        ),
         Command::Speed {
             id,
             set_down,
@@ -121,6 +135,10 @@ fn main() {
             commands::session::execute_free(&client, path.as_deref(), config.json)
         }
         Command::Health => commands::health::execute(&client, config.json),
+        Command::Sequential { id, on, off } => {
+            commands::sequential::execute(&client, *id, *on, *off, config.json)
+        }
+        Command::Reannounce { id } => commands::reannounce::execute(&client, *id),
         Command::Tracker { action } => commands::tracker::execute(&client, action, config.json),
         Command::Policy { action } => {
             commands::policy::execute(&client, action, &config, config.json)

src/main.rs

@@ -161,13 +161,13 @@ pub fn print_torrent_detail(t: &TorrentDetail) {
     }
 }
 
-pub fn print_torrent_files(name: &str, files: &[TorrentFile]) {
+pub fn print_torrent_files(name: &str, files: &[TorrentFile], stats: &[TorrentFileStat]) {
     println!("Torrent: {name}");
     println!();
 
     let mut table = Table::new();
     table.set_content_arrangement(ContentArrangement::Dynamic);
-    table.set_header(vec!["#", "Name", "Size", "Done"]);
+    table.set_header(vec!["#", "Name", "Size", "Done", "Priority", "Wanted"]);
 
     for (i, f) in files.iter().enumerate() {
         let progress = if f.length > 0 {
@@ -179,17 +179,39 @@ pub fn print_torrent_files(name: &str, files: &[TorrentFile]) {
             "0%".to_string()
         };
 
+        let stat = stats.get(i);
+        let priority = match stat.map(|s| s.priority).unwrap_or(0) {
+            1 => "High",
+            -1 => "Low",
+            _ => "Normal",
+        };
+        let wanted = if stat.map(|s| s.wanted).unwrap_or(true) {
+            "Yes"
+        } else {
+            "No"
+        };
+
         table.add_row(vec![
             i.to_string(),
             f.name.clone(),
             format_size(f.length),
             progress,
+            priority.to_string(),
+            wanted.to_string(),
         ]);
     }
 
     println!("{table}");
 }
 
+pub fn priority_string(priority: i64) -> &'static str {
+    match priority {
+        1 => "High",
+        -1 => "Low",
+        _ => "Normal",
+    }
+}
+
 pub fn print_session_info(session: &serde_json::Value) {
     let get_str = |key: &str| -> String {
         session