ocs 0.1.2

A session picker for OpenCode
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use super::*;

#[derive(Parser)]
#[command(about = "A fuzzy OpenCode session picker", version)]
pub(crate) struct Arguments {
  #[arg(long, help = "Only show sessions from the current directory")]
  pub(crate) cwd: bool,
  #[arg(long, value_name = "PATH", help = "OpenCode data directory")]
  pub(crate) data_dir: Option<PathBuf>,
  #[arg(long, help = "Print the selected session ID instead of opening it")]
  pub(crate) print: bool,
  #[arg(long, help = "Initial fuzzy-search query")]
  pub(crate) query: Option<String>,
}

impl Arguments {
  pub(crate) fn run(self) -> Result {
    let storage = match self.data_dir {
      Some(data_dir) => Storage::new(data_dir),
      None => Storage::default()?,
    };

    let directory = self
      .cwd
      .then(env::current_dir)
      .transpose()
      .context("could not determine the current directory")?;

    let mut query = self.query;

    loop {
      let sessions = storage.sessions(directory.as_deref())?;

      let Some(selection) =
        SessionPicker::new(&storage, &sessions, query).pick()?
      else {
        return Ok(());
      };

      match selection {
        Selection::Delete {
          id,
          query: picker_query,
        } => {
          storage.delete(&id)?;

          if sessions.len() == 1 {
            return Ok(());
          }

          query = Some(picker_query);
        }
        Selection::Open(id) => {
          if self.print {
            println!("{id}");
            return Ok(());
          }

          let session = sessions
            .iter()
            .find(|session| session.id == id)
            .context("selected session was not indexed")?;

          return session.open();
        }
      }
    }
  }
}