ADD: fuzzy finding, fix issues with id, refactor error handling

Cargo.lock

···
 
 [[package]]
 name = "clap"
-version = "4.5.18"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3"
+checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
 dependencies = [
  "clap_builder",
  "clap_derive",
···
 
 [[package]]
 name = "clap_builder"
-version = "4.5.18"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b"
+checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
 dependencies = [
  "anstream",
  "anstyle",
···
 
 [[package]]
 name = "clap_complete"
-version = "4.5.29"
+version = "4.5.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8937760c3f4c60871870b8c3ee5f9b30771f792a7045c48bcbba999d7d6b3b8e"
+checksum = "74a01f4f9ee6c066d42a1c8dedf0dcddad16c72a8981a309d6398de3a75b0c39"
 dependencies = [
  "clap",
 ]
···
 
 [[package]]
 name = "hashbrown"
-version = "0.14.5"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
 
 [[package]]
 name = "heck"
···
 
 [[package]]
 name = "indexmap"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
  "hashbrown",
···
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
+dependencies = [
+ "portable-atomic",
+]
 
 [[package]]
 name = "parking"
···
 ]
 
 [[package]]
+name = "portable-atomic"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
+
+[[package]]
 name = "proc-macro2"
 version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "355ae415ccd3a04315d3f8246e86d67689ea74d88d915576e1589a351062a13b"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
  "bitflags",
 ]
···
 
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "syn"
-version = "2.0.77"
+version = "2.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "tempfile"
-version = "3.12.0"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
  "cfg-if",
  "fastrand",

src/errors.rs

···
     Parse(String),
     #[error("Error parsing bytes as utf-8: {0}")]
     FromUtf8(#[from] FromUtf8Error),
+    #[error("No tasks on stack")]
+    NoTasks,
+    #[error("No task selected.")]
+    NotSelected,
     #[allow(dead_code)]
     #[error("An unexpected error occurred: {0}")]
     Oops(Box<dyn std::error::Error>),

src/main.rs

···
 mod util;
 mod workspace;
 use clap_complete::{generate, Shell};
+use errors::Result;
 use std::io;
 use std::path::PathBuf;
+use std::process::exit;
 use std::{env::current_dir, io::Read};
-use workspace::{Id, Workspace};
+use workspace::{Id, TaskIdentifier, Workspace};
 
 //use smol;
 //use iocraft::prelude::*;
···
 }
 
 #[derive(Args)]
-#[group(required = true, multiple = false)]
+#[group(required = false, multiple = false)]
 struct TaskId {
+    /// The ID of the task to select as a plain integer.
     #[arg(short = 't', value_name = "ID")]
     id: Option<u32>,
 
+    /// The ID of the task to select with the 'tsk-' prefix.
     #[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>
+    /// Selects a task relative to the top of the stack.
+    /// If no option is specified, the task selected will be the top of the stack.
+    #[arg(short = 'r', value_name = "RELATIVE", default_value_t = 0)]
+    relative_id: u32,
+
+    /// Use fuzzy finding to search for and select a task.
+    /// Does not support searching task bodies or archived tasks.
+    #[arg(short = 'f', value_name = "FIND", default_value_t = false)]
+    find: bool,
+}
+
+impl From<TaskId> for TaskIdentifier {
+    fn from(value: TaskId) -> Self {
+        if let Some(id) = value.id.map(Id::from).or(value.tsk_id) {
+            TaskIdentifier::Id(id)
+        } else {
+            if value.find {
+                TaskIdentifier::Find
+            } else {
+                TaskIdentifier::Relative(value.relative_id)
+            }
+        }
+    }
 }
 
 fn main() {
     let cli = Cli::parse();
     let dir = cli.dir.unwrap_or(default_dir());
-    match cli.command {
+    let result = match cli.command {
         Commands::Init => command_init(dir),
         Commands::Push { edit, body, title } => command_push(dir, edit, body, title),
         Commands::List { all, count } => command_list(dir, all, count),
···
         Commands::Edit { task_id } => command_edit(dir, task_id),
         Commands::Completion { shell } => command_completion(shell),
         Commands::Drop => command_drop(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::Find { full_id, .. } => command_find(dir, full_id),
+        Commands::Rot => Workspace::from_path(dir).unwrap().rot(),
+        Commands::Tor => Workspace::from_path(dir).unwrap().tor(),
         Commands::Reprioritize { task_id } => command_reprioritize(dir, task_id),
+    };
+    match result {
+        Ok(_) => exit(0),
+        Err(e) => {
+            eprintln!("{e}");
+            exit(1);
+        }
     }
 }
 
-fn command_init(dir: PathBuf) {
-    Workspace::init(dir).expect("Init failed")
+fn command_init(dir: PathBuf) -> Result<()> {
+    Workspace::init(dir)
 }
 
-fn command_push(dir: PathBuf, edit: bool, body: Option<String>, title: Title) {
-    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
+fn command_push(dir: PathBuf, edit: bool, body: Option<String>, title: Title) -> Result<()> {
+    let workspace = Workspace::from_path(dir)?;
     let mut title = if let Some(title) = title.title {
         title
     } else if let Some(title) = title.title_simple {
···
         // add newline so you can type directly in the shell
         eprintln!("");
         body.clear();
-        std::io::stdin()
-            .read_to_string(&mut body)
-            .expect("Failed to read stdin");
+        std::io::stdin().read_to_string(&mut body)?;
     }
     if edit {
-        let new_content = open_editor(format!("{title}\n\n{body}")).expect("Failed to edit file");
+        let new_content = open_editor(format!("{title}\n\n{body}"))?;
         if let Some(content) = new_content.split_once("\n") {
             title = content.0.to_string();
             body = content.1.to_string();
         }
     }
-    let task = workspace
-        .new_task(title, body)
-        .expect("Failed to create task");
-    workspace
-        .push_task(task)
-        .expect("Failed to push task to stack");
+    let task = workspace.new_task(title, body)?;
+    workspace.push_task(task)
 }
 
-fn command_list(dir: PathBuf, all: bool, count: usize) {
+fn command_list(dir: PathBuf, all: bool, count: usize) -> Result<()> {
     let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
     let stack = if all {
-        workspace.read_stack().expect("Failed to read index")
+        workspace.read_stack()?
     } else {
-        workspace.read_stack().expect("Failed to read index")
+        workspace.read_stack()?
     };
     if stack.empty() {
         println!("*No tasks*");
+        exit(0);
     } else {
         if !all {
             for stack_item in stack.into_iter().take(count) {
···
             }
         }
     }
+    Ok(())
 }
 
-fn command_swap(dir: PathBuf) {
-    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
-    workspace.swap_top().expect("swap to work");
+fn command_swap(dir: PathBuf) -> Result<()> {
+    let workspace = Workspace::from_path(dir)?;
+    workspace.swap_top()?;
+    Ok(())
 }
 
-fn command_edit(dir: PathBuf, id: TaskId) {
-    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
-    let tsk_id: Option<Id> = id.id.map(Id::from).or(id.tsk_id);
-    let mut task = if let Some(id) = tsk_id {
-        workspace.task(id.into()).expect("To read task from disk")
-    } else {
-        let mut stack = workspace.read_stack().expect("to read stack");
-        let stack_item = stack.pop().expect("No tasks on stack.");
-        workspace.task(stack_item.id).expect("couldn't read task")
-    };
-    let new_content = open_editor(format!("{}\n\n{}", task.title.trim(), task.body.trim()))
-        .expect("Failed to edit file");
+fn command_edit(dir: PathBuf, id: TaskId) -> Result<()> {
+    let workspace = Workspace::from_path(dir)?;
+    let id: TaskIdentifier = id.into();
+    let mut task = workspace.task(id)?;
+    let new_content = open_editor(format!("{}\n\n{}", task.title.trim(), task.body.trim()))?;
     if let Some((title, body)) = new_content.split_once("\n") {
         task.title = title.to_string();
         task.body = body.to_string();
-        task.save().expect("Failed to save task");
+        task.save()?;
     }
+    Ok(())
 }
 
-fn command_completion(shell: Shell) {
-    generate(shell, &mut Cli::command(), "tsk", &mut io::stdout())
+fn command_completion(shell: Shell) -> Result<()> {
+    generate(shell, &mut Cli::command(), "tsk", &mut io::stdout());
+    Ok(())
 }
 
-fn command_drop(dir: PathBuf) {
-    if let Some(id) = Workspace::from_path(dir)
-        .expect("Unable to find .tsk dir")
-        .drop()
-        .expect("Unable to drop task.")
-    {
-        println!("Dropped {id}")
+fn command_drop(dir: PathBuf) -> Result<()> {
+    if let Some(id) = Workspace::from_path(dir)?.drop()? {
+        eprint!("Dropped ");
+        println!("{id}");
+    } else {
+        eprintln!("No task to drop.");
+        exit(1);
     }
+    Ok(())
 }
 
-fn command_search(dir: PathBuf, full_id: bool) {
-    let id = Workspace::from_path(dir).unwrap().search().unwrap();
+fn command_find(dir: PathBuf, full_id: bool) -> Result<()> {
+    let id = Workspace::from_path(dir).unwrap().search(None).unwrap();
     if let Some(id) = id {
         if full_id {
             println!("{id}");
···
             println!("{}", id.0);
         }
     } else {
-        eprintln!("No task to drop.")
+        eprintln!("No task to drop.");
+        exit(1);
     }
+    Ok(())
 }
 
-fn command_reprioritize(dir: PathBuf, task_id: TaskId) {
+fn command_reprioritize(dir: PathBuf, task_id: TaskId) -> Result<()> {
     // 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()
+        .reprioritize(task_id.into())
 }

src/stack.rs

···
     pub fn iter(&self) -> Iter<StackItem> {
         self.all.iter()
     }
+
+    pub fn get(&self, index: usize) -> Option<&StackItem> {
+        self.all.get(index)
+    }
 }
-
 
 impl IntoIterator for TaskStack {
     type Item = StackItem;

src/workspace.rs

···
     }
 }
 
+pub enum TaskIdentifier {
+    Id(Id),
+    Relative(u32),
+    Find,
+}
+
+impl From<Id> for TaskIdentifier {
+    fn from(value: Id) -> Self {
+        TaskIdentifier::Id(value)
+    }
+}
+
 pub struct Workspace {
     /// The path to the workspace root, excluding the .tsk directory. This should *contain* the
     /// .tsk directory.
···
         Ok(Self { path: tsk_dir })
     }
 
+    fn resolve(&self, identifier: TaskIdentifier) -> Result<Id> {
+        match identifier {
+            TaskIdentifier::Id(id) => Ok(id),
+            TaskIdentifier::Relative(r) => {
+                let stack = self.read_stack()?;
+                let stack_item = stack.get(r as usize).ok_or(Error::NoTasks)?;
+                Ok(stack_item.id)
+            }
+            TaskIdentifier::Find => self.search(None)?.ok_or(Error::NotSelected),
+        }
+    }
+
     pub fn next_id(&self) -> Result<Id> {
         let mut file = util::flopen(self.path.join("next"), FlockArg::LockExclusive)?;
         let mut buf = String::new();
···
         })
     }
 
-    pub fn task(&self, id: Id) -> Result<Task> {
+    pub fn task(&self, identifier: TaskIdentifier) -> Result<Task> {
+        let id = self.resolve(identifier)?;
+
         let file = util::flopen(
             self.path.join("tasks").join(format!("tsk-{}.tsk", id.0)),
             FlockArg::LockExclusive,
···
         }
     }
 
-    pub fn search(&self) -> Result<Option<Id>> {
-        let stack = self.read_stack()?;
+    pub fn search(&self, stack: Option<TaskStack>) -> Result<Option<Id>> {
+        let stack = if let Some(stack) = stack {
+            stack
+        } else {
+            self.read_stack()?
+        };
         Ok(fzf::select(stack)?.map(|si| si.id))
     }
 
-    pub fn reprioritize(&self, id: Id) -> Result<()> {
+    pub fn reprioritize(&self, identifier: TaskIdentifier) -> Result<()> {
+        let id = self.resolve(identifier)?;
         let mut stack = self.read_stack()?;
         let index = &stack.iter().map(|i| i.id).position(|i| i == id);
         if let Some(index) = index {