WIP: add reprioritize

src/main.rs

···
         /// bodies in the search criteria.
         #[arg(short = 'a', default_value_t = false)]
         search_archived: bool,
+
+        #[arg(short = 't', default_value_t = true)]
+        full_id: bool,
     },
 
     /// Drops the task on the top of the stack and archives it.
···
 
     Rot,
     Tor,
+
+    Reprioritize {
+        /// The [TSK-]ID to prioritize. If it exists, it is moved to the top of the stack.
+        #[command(flatten)]
+        task_id: TaskId,
+    },
 }
 
 #[derive(Args)]
···
 }
 
 #[derive(Args)]
-#[group(required = false, multiple = false)]
+#[group(required = true, multiple = false)]
 struct TaskId {
     #[arg(short = 't', value_name = "ID")]
     id: Option<u32>,
 
     #[arg(short = 'T', value_name = "TSK-ID", value_parser = value_parser!(String))]
     tsk_id: Option<Id>,
+
+    /// If no option is specified
+    #[arg(short = 'r', value_name = "RELATIVE")]
+    relative_id: Option<u32>
 }
 
 fn main() {
···
         Commands::Edit { task_id } => command_edit(dir, task_id),
         Commands::Completion { shell } => command_completion(shell),
         Commands::Drop => command_drop(dir),
-        Commands::Find { .. } => command_search(dir),
+        Commands::Find { full_id, .. } => command_search(dir, full_id),
         Commands::Rot => Workspace::from_path(dir).unwrap().rot().unwrap(),
         Commands::Tor => Workspace::from_path(dir).unwrap().tor().unwrap(),
+        Commands::Reprioritize { task_id } => command_reprioritize(dir, task_id),
     }
 }
 
···
     }
 }
 
-fn command_search(dir: PathBuf) {
+fn command_search(dir: PathBuf, full_id: bool) {
     let id = Workspace::from_path(dir).unwrap().search().unwrap();
     if let Some(id) = id {
-        eprint!("Dropping ");
-        println!("{id}");
+        if full_id {
+            println!("{id}");
+        } else {
+            // print as integer
+            println!("{}", id.0);
+        }
     } else {
         eprintln!("No task to drop.")
     }
 }
 
-fn command_rot(dir: PathBuf) {
-    Workspace::from_path(dir).unwrap().rot().unwrap();
+fn command_reprioritize(dir: PathBuf, task_id: TaskId) {
+    // unwrap is safe here because clap will ensure we have at least one of these
+    let tsk_id: Id = task_id.id.map(Id::from).or(task_id.tsk_id).unwrap();
+    Workspace::from_path(dir)
+        .unwrap()
+        .reprioritize(tsk_id)
+        .unwrap()
 }

src/stack.rs

···
 
 use crate::errors::{Error, Result};
 use crate::util;
+use std::collections::vec_deque::Iter;
 use std::collections::VecDeque;
 use std::fmt::Display;
 use std::io::{self, BufRead, BufReader, Seek, Write};
···
     pub fn empty(&self) -> bool {
         self.all.is_empty()
     }
+
+    pub fn remove(&mut self, index: usize) -> Option<StackItem> {
+        self.all.remove(index)
+    }
+
+    pub fn iter(&self) -> Iter<StackItem> {
+        self.all.iter()
+    }
 }
+
 
 impl IntoIterator for TaskStack {
     type Item = StackItem;

src/workspace.rs

···
 const TITLECACHEFILE: &str = "cache";
 /// A unique identifier for a task. When referenced in text, it is prefixed with `tsk-`.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct Id(u32);
+pub struct Id(pub u32);
 
 impl FromStr for Id {
     type Err = Error;
···
         let third = stack.pop();
 
         if top.is_none() || second.is_none() || third.is_none() {
-            return Ok(())
+            return Ok(());
         }
 
         stack.push(second.unwrap());
···
         let third = stack.pop();
 
         if top.is_none() || second.is_none() || third.is_none() {
-            return Ok(())
+            return Ok(());
         }
 
         stack.push(top.unwrap());
···
     pub fn search(&self) -> Result<Option<Id>> {
         let stack = self.read_stack()?;
         Ok(fzf::select(stack)?.map(|si| si.id))
+    }
+
+    pub fn reprioritize(&self, id: Id) -> Result<()> {
+        let mut stack = self.read_stack()?;
+        let index = &stack.iter().map(|i| i.id).position(|i| i == id);
+        if let Some(index) = index {
+            let prioritized_task = stack.remove(*index);
+            // unwrap here is safe because we just searched for the index and know it exists
+            stack.push(prioritized_task.unwrap());
+            stack.save()?;
+        }
+        Ok(())
     }
 }