fix(deps): update all dependencies

chore(release): 0.2.3

Co-authored-by: cuddle-please <bot@cuddle.sh>
Reviewed-on: #12

.gitignore

@@ -1,2 +1,3 @@
 target/
 .cuddle/
+.DS_Store

CHANGELOG.md

@@ -6,6 +6,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.3] - 2024-09-26
+
+### Added
+- add update command
+- only do clone if not exists
+
+### Fixed
+- *(deps)* update rust crate async-trait to v0.1.83
+- *(deps)* update rust crate octocrab to 0.40.0
+
+## [0.2.2] - 2024-09-23
+
+### Other
+- add docs
+
+main@origin
+
+- add license
+- update to gitea-client
+- add publish
+- *(release)* 0.2.1
+
+## [0.2.1] - 2024-09-23
+
+### Added
+- use termwiz as backend as that enables a ptty, which can be cleaned up nicely
+- add errout for interactive for script support and atty for clean output
+- add clone spinner
+- add spinner around download
+- spawn a subshell for session
+- implement git clone
+- include vhs demo
+- add interactive search
+- implement naive fuzzy matcher
+
+### Fixed
+- *(deps)* update tokio-prost monorepo to v0.13.3
+- *(deps)* update rust crate bytes to v1.7.2
+
+### Other
+- update gif to include spinner
+- clean up ui
+- build in cuddle instead of vhs
+- build first then run
+- clear screen after build
+- fix warnings
+- update theme for vhs
+- *(deps)* update rust crate clap to v4.5.18
+- *(deps)* update rust crate pretty_assertions to v1.4.1
+- refactor fuzzy match into own function
+- cleanup warnings
+- move fuzzy search out of command
+- refactor/matcher move to a separate file
+
+- move fuzzy search out of command
+- Actually add fuzzy matcher
+
+- extract matcher
+- update dependencies
+- *(deps)* update rust crate anyhow to v1.0.89
+
 ## [0.2.0] - 2024-09-14
 
 ### Added

Cargo.toml

@@ -3,14 +3,13 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.3"
 
 [workspace.dependencies]
-gitnow = { path = "crates/gitnow" }
 
 anyhow = { version = "1" }
 tokio = { version = "1", features = ["full"] }
 tracing = { version = "0.1", features = ["log"] }
-tracing-subscriber = { version = "0.3.18" }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 clap = { version = "4", features = ["derive", "env"] }
 dotenv = { version = "0.15" }

README.md

@@ -2,6 +2,24 @@
 
 Git Now is a utility for easily navigating git projects from common upstream providers. Search, Download, and Enter projects as quickly as you can type.
 
+![example gif](./assets/gifs/example.gif)
+
+## Installation
+
+```bash
+cargo (b)install gitnow
+
+# You can either use gitnow directly (and use spawned shell sessions)
+gitnow
+
+# Or install gitnow scripts (in your .bashrc, .zshrc) this will use native shell commands to move you around
+eval $(gitnow init zsh)
+git-now # Long 
+gn # Short alias
+```
+
+## Reasoning
+
 How many steps do you normally do to download a project?
 
 1. Navigate to github.com

crates/gitnow/.gitignore

@@ -1 +0,0 @@
-/target

crates/gitnow/Cargo.toml

@@ -1,8 +1,15 @@
 [package]
 name = "gitnow"
+description = "Git Now is a utility for easily navigating git projects from common upstream providers. Search, Download, and Enter projects as quickly as you can type."
 edition = "2021"
+readme = "../../README.md"
+repository = "https://github.com/kjuulh/gitnow"
+homepage = "https://gitnow-client.prod.kjuulh.app"
+license = "MIT"
 
 version.workspace = true
+publish = true
+
 
 [dependencies]
 anyhow.workspace = true
@@ -17,13 +24,21 @@ uuid = { version = "1.7.0", features = ["v4"] }
 async-trait = "0.1.82"
 toml = "0.8.19"
 
-gitea-rs = { git = "https://git.front.kjuulh.io/kjuulh/gitea-rs", version = "1.22.1" }
+gitea-client = { version = "1.22.1" }
 url = "2.5.2"
-octocrab = "0.39.0"
+octocrab = "0.41.0"
 dirs = "5.0.1"
 prost = "0.13.2"
 prost-types = "0.13.2"
 bytes = "1.7.1"
+nucleo-matcher = "0.3.1"
+ratatui = { version = "0.29.0", features = ["termwiz"] }
+crossterm = { version = "0.28.0", features = ["event-stream"] }
+futures = "0.3.30"
+termwiz = "0.22.0"
 
 [dev-dependencies]
 pretty_assertions = "1.4.0"
+
+[features]
+example = []

crates/gitnow/include/shell/zsh.sh

@@ -0,0 +1,22 @@
+function git-now {
+  # Run an update in the background
+  (
+    nohup gitnow update > /dev/null 2>&1 &
+  )
+
+  # Find the repository of choice
+  choice=$(gitnow  "$@" --no-shell)
+    if [[ $? -ne 0 ]]; then
+    return $?
+  fi
+
+  # Enter local repository path
+  cd "$(echo "$choice" | tail --lines 1)"
+}
+
+function gn {
+  git-now "$@"
+  if [[ $? -ne 0 ]]; then
+    return $?
+  fi
+}

crates/gitnow/src/commands.rs

@@ -1 +1,3 @@
 pub mod root;
+pub mod shell;
+pub mod update;

crates/gitnow/src/commands/root.rs

@@ -1,4 +1,16 @@
-use crate::{app::App, cache::CacheApp, projects_list::ProjectsListApp};
+use std::{collections::BTreeMap, io::IsTerminal};
+
+use crate::{
+    app::App,
+    cache::CacheApp,
+    components::inline_command::InlineCommand,
+    fuzzy_matcher::{FuzzyMatcher, FuzzyMatcherApp},
+    git_clone::GitCloneApp,
+    git_provider::Repository,
+    interactive::InteractiveApp,
+    projects_list::ProjectsListApp,
+    shell::ShellApp,
+};
 
 #[derive(Debug, Clone)]
 pub struct RootCommand {
@@ -10,11 +22,20 @@ impl RootCommand {
         Self { app }
     }
 
-    #[tracing::instrument(skip(self))]
+    pub async fn execute(
-    pub async fn execute(&mut self) -> anyhow::Result<()> {
+        &mut self,
+        search: Option<impl Into<String>>,
+        cache: bool,
+        clone: bool,
+        shell: bool,
+        force_refresh: bool,
+        force_cache_update: bool,
+    ) -> anyhow::Result<()> {
         tracing::debug!("executing");
 
-        let repositories = match self.app.cache().get().await? {
+        let repositories = if !force_cache_update {
+            if cache {
+                match self.app.cache().get().await? {
                     Some(repos) => repos,
                     None => {
                         tracing::info!("finding repositories...");
@@ -24,14 +45,135 @@ impl RootCommand {
 
                         repositories
                     }
+                }
+            } else {
+                self.app.projects_list().get_projects().await?
+            }
+        } else {
+            tracing::info!("forcing cache update...");
+            let repositories = self.app.projects_list().get_projects().await?;
+
+            self.app.cache().update(&repositories).await?;
+
+            repositories
         };
 
-        for repo in &repositories {
+        let repo = match search {
-            //tracing::info!("repo: {}", repo.to_rel_path().display());
+            Some(needle) => {
+                let matched_repos = self
+                    .app
+                    .fuzzy_matcher()
+                    .match_repositories(&needle.into(), &repositories);
+
+                let repo = matched_repos
+                    .first()
+                    .ok_or(anyhow::anyhow!("failed to find repository"))?;
+                tracing::debug!("selected repo: {}", repo.to_rel_path().display());
+
+                repo.to_owned()
+            }
+            None => {
+                let repo = self
+                    .app
+                    .interactive()
+                    .interactive_search(&repositories)?
+                    .ok_or(anyhow::anyhow!("failed to find a repository"))?;
+
+                tracing::debug!("selected repo: {}", repo.to_rel_path().display());
+
+                repo
+            }
+        };
+
+        let project_path = self
+            .app
+            .config
+            .settings
+            .projects
+            .directory
+            .join(repo.to_rel_path());
+        if !project_path.exists() {
+            if clone {
+                let git_clone = self.app.git_clone();
+
+                if std::io::stdout().is_terminal() && shell {
+                    let mut wrap_cmd =
+                        InlineCommand::new(format!("cloning: {}", repo.to_rel_path().display()));
+                    let repo = repo.clone();
+                    wrap_cmd
+                        .execute(move || async move {
+                            git_clone.clone_repo(&repo, force_refresh).await?;
+
+                            Ok(())
+                        })
+                        .await?;
+                } else {
+                    eprintln!("cloning repository...");
+                    git_clone.clone_repo(&repo, force_refresh).await?;
+                }
+            } else {
+                tracing::info!("skipping clone for repo: {}", &repo.to_rel_path().display());
+            }
+        } else {
+            tracing::info!("repository already exists");
         }
 
-        tracing::info!("amount of repos fetched {}", repositories.len());
+        if shell {
+            self.app.shell().spawn_shell(&repo).await?;
+        } else {
+            tracing::info!("skipping shell for repo: {}", &repo.to_rel_path().display());
+            println!(
+                "{}",
+                self.app
+                    .config
+                    .settings
+                    .projects
+                    .directory
+                    .join(repo.to_rel_path())
+                    .display()
+            );
+        }
 
         Ok(())
     }
 }
+
+trait StringExt {
+    fn as_str_vec(&self) -> Vec<&str>;
+}
+
+impl StringExt for Vec<String> {
+    fn as_str_vec(&self) -> Vec<&str> {
+        self.iter().map(|r| r.as_ref()).collect()
+    }
+}
+
+impl StringExt for Vec<&String> {
+    fn as_str_vec(&self) -> Vec<&str> {
+        self.iter().map(|r| r.as_ref()).collect()
+    }
+}
+
+pub trait RepositoryMatcher {
+    fn match_repositories(&self, pattern: &str, repositories: &[Repository]) -> Vec<Repository>;
+}
+
+impl RepositoryMatcher for FuzzyMatcher {
+    fn match_repositories(&self, pattern: &str, repositories: &[Repository]) -> Vec<Repository> {
+        let haystack = repositories
+            .iter()
+            .map(|r| (r.to_rel_path().display().to_string(), r))
+            .collect::<BTreeMap<_, _>>();
+        let haystack_keys = haystack.keys().collect::<Vec<_>>();
+        let haystack_keys = haystack_keys.as_str_vec();
+
+        let res = self.match_pattern(pattern, &haystack_keys);
+
+        let matched_repos = res
+            .into_iter()
+            .filter_map(|repo_key| haystack.get(repo_key).map(|r| (*r).to_owned()))
+            .collect::<Vec<_>>();
+
+        matched_repos
+    }
+}

crates/gitnow/src/commands/shell.rs

@@ -0,0 +1,33 @@
+use zsh::ZshShell;
+
+pub mod zsh;
+
+#[derive(clap::Parser)]
+pub struct Shell {
+    #[command(subcommand)]
+    shell: ShellSubcommands,
+}
+
+impl Shell {
+    pub async fn execute(&mut self) -> anyhow::Result<()> {
+        self.shell.execute().await?;
+
+        Ok(())
+    }
+}
+
+#[derive(clap::Subcommand)]
+pub enum ShellSubcommands {
+    #[command()]
+    Zsh(ZshShell),
+}
+
+impl ShellSubcommands {
+    pub async fn execute(&mut self) -> anyhow::Result<()> {
+        match self {
+            ShellSubcommands::Zsh(zsh) => zsh.execute().await?,
+        }
+
+        Ok(())
+    }
+}

crates/gitnow/src/commands/shell/zsh.rs

@@ -0,0 +1,12 @@
+#[derive(clap::Parser)]
+pub struct ZshShell {}
+
+const SCRIPT: &str = include_str!("../../../include/shell/zsh.sh");
+
+impl ZshShell {
+    pub async fn execute(&mut self) -> anyhow::Result<()> {
+        println!("{}", SCRIPT);
+
+        Ok(())
+    }
+}

crates/gitnow/src/commands/update.rs

@@ -0,0 +1,14 @@
+use crate::{app::App, cache::CacheApp, projects_list::ProjectsListApp};
+
+#[derive(clap::Parser)]
+pub struct Update {}
+
+impl Update {
+    pub async fn execute(&mut self, app: &'static App) -> anyhow::Result<()> {
+        let repositories = app.projects_list().get_projects().await?;
+
+        app.cache().update(&repositories).await?;
+
+        Ok(())
+    }
+}

crates/gitnow/src/components.rs

@@ -0,0 +1,119 @@
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+
+pub mod inline_command;
+pub mod spinner;
+
+#[derive(Debug, PartialEq)]
+pub enum Msg {
+    Quit,
+    Tick,
+    Success,
+    Failure(String),
+}
+
+pub struct Command {
+    func: Box<CommandFunc>,
+}
+
+impl Command {
+    pub fn new<T: FnOnce(&Dispatch) -> Option<Msg> + 'static>(f: T) -> Self {
+        Self { func: Box::new(f) }
+    }
+
+    pub fn execute(self, dispatch: &Dispatch) -> Option<Msg> {
+        (self.func)(dispatch)
+    }
+}
+
+pub trait IntoCommand {
+    fn into_command(self) -> Command;
+}
+
+impl IntoCommand for () {
+    fn into_command(self) -> Command {
+        Command::new(|_| None)
+    }
+}
+
+impl IntoCommand for Command {
+    fn into_command(self) -> Command {
+        self
+    }
+}
+
+impl IntoCommand for Msg {
+    fn into_command(self) -> Command {
+        Command::new(|_| Some(self))
+    }
+}
+
+type CommandFunc = dyn FnOnce(&Dispatch) -> Option<Msg>;
+
+pub fn create_dispatch() -> (Dispatch, Receiver) {
+    let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
+
+    (Dispatch { sender: tx }, Receiver { receiver: rx })
+}
+
+#[derive(Clone)]
+pub struct Dispatch {
+    sender: UnboundedSender<Msg>,
+}
+
+impl Dispatch {
+    pub fn send(&self, msg: Msg) {
+        if let Err(e) = self.sender.send(msg) {
+            tracing::warn!("failed to send event: {}", e);
+        }
+    }
+}
+
+pub struct Receiver {
+    receiver: UnboundedReceiver<Msg>,
+}
+
+impl Receiver {
+    pub async fn next(&mut self) -> Option<Msg> {
+        self.receiver.recv().await
+    }
+}
+
+#[derive(Default)]
+pub struct BatchCommand {
+    commands: Vec<Command>,
+}
+
+impl BatchCommand {
+    pub fn with(&mut self, cmd: impl IntoCommand) -> &mut Self {
+        self.commands.push(cmd.into_command());
+
+        self
+    }
+}
+
+impl IntoCommand for Vec<Command> {
+    fn into_command(self) -> Command {
+        BatchCommand::from(self).into_command()
+    }
+}
+
+impl From<Vec<Command>> for BatchCommand {
+    fn from(value: Vec<Command>) -> Self {
+        BatchCommand { commands: value }
+    }
+}
+
+impl IntoCommand for BatchCommand {
+    fn into_command(self) -> Command {
+        Command::new(|dispatch| {
+            for command in self.commands {
+                let msg = command.execute(dispatch);
+                if let Some(msg) = msg {
+                    dispatch.send(msg);
+                }
+            }
+
+            None
+        })
+    }
+}

crates/gitnow/src/components/inline_command.rs

@@ -0,0 +1,195 @@
+use std::time::Duration;
+
+use crossterm::event::{EventStream, KeyCode};
+use futures::{FutureExt, StreamExt};
+use ratatui::{
+    crossterm,
+    prelude::*,
+    widgets::{Block, Padding},
+    TerminalOptions, Viewport,
+};
+
+use crate::components::BatchCommand;
+
+use super::{
+    create_dispatch,
+    spinner::{Spinner, SpinnerState},
+    Dispatch, IntoCommand, Msg, Receiver,
+};
+
+pub struct InlineCommand {
+    spinner: SpinnerState,
+    heading: String,
+}
+
+impl InlineCommand {
+    pub fn new(heading: impl Into<String>) -> Self {
+        Self {
+            spinner: SpinnerState::default(),
+            heading: heading.into(),
+        }
+    }
+
+    pub async fn execute<F, Fut>(&mut self, func: F) -> anyhow::Result<()>
+    where
+        F: FnOnce() -> Fut + Send + Sync + 'static,
+        Fut: futures::Future<Output = anyhow::Result<()>> + Send + 'static,
+    {
+        tracing::trace!("starting inline terminal");
+
+        let mut terminal = ratatui::init_with_options(TerminalOptions {
+            viewport: Viewport::Inline(3),
+        });
+
+        let (dispatch, mut receiver) = create_dispatch();
+        let mut event_stream = crossterm::event::EventStream::new();
+        let guard = TerminalGuard;
+
+        tokio::spawn({
+            let dispatch = dispatch.clone();
+
+            async move {
+                match func().await {
+                    Ok(_) => dispatch.send(Msg::Success),
+                    Err(e) => dispatch.send(Msg::Failure(e.to_string())),
+                }
+            }
+        });
+
+        loop {
+            if self
+                .update(&mut terminal, &dispatch, &mut receiver, &mut event_stream)
+                .await?
+            {
+                terminal.draw(|f| {
+                    let buf = f.buffer_mut();
+                    buf.reset();
+                })?;
+
+                break;
+            }
+        }
+
+        drop(guard);
+
+        println!();
+
+        Ok(())
+    }
+
+    async fn update(
+        &mut self,
+        terminal: &mut ratatui::Terminal<impl Backend>,
+        dispatch: &Dispatch,
+        receiver: &mut Receiver,
+        event_stream: &mut EventStream,
+    ) -> anyhow::Result<bool> {
+        let input_event = event_stream.next().fuse();
+        let next_msg = receiver.next().fuse();
+
+        const FRAMES_PER_SECOND: f32 = 60.0;
+        const TICK_RATE: f32 = 20.0;
+
+        let period_frame = Duration::from_secs_f32(1.0 / FRAMES_PER_SECOND);
+        let mut interval_frames = tokio::time::interval(period_frame);
+        let period_tick = Duration::from_secs_f32(1.0 / TICK_RATE);
+        let mut interval_ticks = tokio::time::interval(period_tick);
+
+        let msg = tokio::select! {
+            _ = interval_frames.tick() => {
+                terminal.draw(|frame| self.draw(frame))?;
+                None
+            }
+            _ = interval_ticks.tick() => {
+                Some(Msg::Tick)
+            }
+            msg = next_msg => {
+                msg
+            }
+            input = input_event => {
+                if let Some(Ok(input)) = input {
+                    self.handle_key_event(input)
+                } else {
+                    None
+                }
+            }
+        };
+
+        if let Some(msg) = msg {
+            if Msg::Quit == msg {
+                return Ok(true);
+            }
+
+            let mut cmd = self.update_state(&msg);
+
+            loop {
+                let msg = cmd.into_command().execute(dispatch);
+
+                match msg {
+                    Some(Msg::Quit) => return Ok(true),
+                    Some(msg) => {
+                        cmd = self.update_state(&msg);
+                    }
+                    None => break,
+                }
+            }
+        }
+
+        Ok(false)
+    }
+
+    fn draw(&mut self, frame: &mut Frame<'_>) {
+        let spinner = Spinner::new(Span::from(&self.heading));
+
+        let block = Block::new().padding(Padding::symmetric(2, 1));
+
+        StatefulWidget::render(
+            spinner.block(block),
+            frame.area(),
+            frame.buffer_mut(),
+            &mut self.spinner,
+        );
+    }
+
+    fn handle_key_event(&mut self, event: crossterm::event::Event) -> Option<Msg> {
+        if let crossterm::event::Event::Key(key) = event {
+            return match key.code {
+                KeyCode::Esc => Some(Msg::Quit),
+                KeyCode::Char('c') => Some(Msg::Quit),
+                _ => None,
+            };
+        }
+
+        None
+    }
+
+    fn update_state(&mut self, msg: &Msg) -> impl IntoCommand {
+        tracing::debug!("handling message: {:?}", msg);
+
+        let mut batch = BatchCommand::default();
+
+        match msg {
+            Msg::Quit => {}
+            Msg::Tick => {}
+            Msg::Success => return Msg::Quit.into_command(),
+            Msg::Failure(f) => {
+                tracing::error!("command failed: {}", f);
+                return Msg::Quit.into_command();
+            }
+        }
+
+        batch.with(self.spinner.update(msg));
+
+        batch.into_command()
+    }
+}
+
+#[derive(Default)]
+struct TerminalGuard;
+
+impl Drop for TerminalGuard {
+    fn drop(&mut self) {
+        tracing::trace!("restoring inline terminal");
+        ratatui::restore();
+    }
+}

crates/gitnow/src/components/spinner.rs

@@ -0,0 +1,86 @@
+use std::time::{Duration, Instant};
+
+use ratatui::{
+    text::{Line, Span},
+    widgets::{Block, Paragraph, StatefulWidget, Widget},
+};
+
+use super::{BatchCommand, IntoCommand, Msg};
+
+pub struct Spinner<'a> {
+    span: Span<'a>,
+    block: Option<Block<'a>>,
+}
+
+impl<'a> Spinner<'a> {
+    pub fn new(span: Span<'a>) -> Self {
+        Self { span, block: None }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+}
+
+impl<'a> StatefulWidget for Spinner<'a> {
+    type State = SpinnerState;
+
+    fn render(
+        self,
+        area: ratatui::prelude::Rect,
+        buf: &mut ratatui::prelude::Buffer,
+        state: &mut Self::State,
+    ) {
+        let frame = MINIDOT_FRAMES
+            .get((state.frame) % MINIDOT_FRAMES.len())
+            .expect("to find a valid static frame");
+
+        let line = Line::from(vec![Span::from(*frame), Span::from(" "), self.span]);
+
+        let para = Paragraph::new(vec![line]);
+        let para = if let Some(block) = self.block {
+            para.block(block)
+        } else {
+            para
+        };
+
+        para.render(area, buf)
+    }
+}
+
+pub struct SpinnerState {
+    last_event: Instant,
+    interval: Duration,
+    frame: usize,
+}
+
+impl Default for SpinnerState {
+    fn default() -> Self {
+        Self {
+            last_event: Instant::now(),
+            interval: Duration::from_millis(1000 / 12),
+            frame: 0,
+        }
+    }
+}
+
+const MINIDOT_FRAMES: [&str; 10] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+impl SpinnerState {
+    pub fn update(&mut self, _msg: &Msg) -> impl IntoCommand {
+        let batch = BatchCommand::default();
+
+        let now = Instant::now();
+        if now.duration_since(self.last_event) >= self.interval {
+            self.last_event = now;
+            self.next_state();
+        }
+
+        batch
+    }
+
+    fn next_state(&mut self) {
+        self.frame = self.frame.wrapping_add(1);
+    }
+}

crates/gitnow/src/config.rs

@@ -14,10 +14,49 @@ pub struct Config {
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
 pub struct Settings {
+    #[serde(default)]
+    pub projects: Projects,
+
     #[serde(default)]
     pub cache: Cache,
 }
 
+#[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct Projects {
+    pub directory: ProjectLocation,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ProjectLocation(PathBuf);
+
+impl From<PathBuf> for ProjectLocation {
+    fn from(value: PathBuf) -> Self {
+        Self(value)
+    }
+}
+
+impl From<ProjectLocation> for PathBuf {
+    fn from(value: ProjectLocation) -> Self {
+        value.0
+    }
+}
+
+impl Default for ProjectLocation {
+    fn default() -> Self {
+        let home = dirs::home_dir().unwrap_or_default();
+
+        Self(home.join("git"))
+    }
+}
+
+impl std::ops::Deref for ProjectLocation {
+    type Target = PathBuf;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
 pub struct Cache {
     #[serde(default)]
@@ -231,6 +270,9 @@ mod test {
     #[test]
     fn test_can_parse_config() -> anyhow::Result<()> {
         let content = r#"
+              [settings]
+              projects = { directory = "git" }
+        
               [settings.cache]
               location = ".cache/gitnow"
               duration = { days = 2 }
@@ -316,6 +358,9 @@ mod test {
                             hours: 0,
                             minutes: 0
                         }
+                    },
+                    projects: Projects {
+                        directory: PathBuf::from("git").into()
                     }
                 }
             },
@@ -340,7 +385,8 @@ mod test {
                     gitea: vec![]
                 },
                 settings: Settings {
-                    cache: Cache::default()
+                    cache: Cache::default(),
+                    projects: Projects::default()
                 }
             },
             config

crates/gitnow/src/fuzzy_matcher.rs

@@ -0,0 +1,34 @@
+use nucleo_matcher::{pattern::Pattern, Matcher};
+
+use crate::app::App;
+
+pub struct FuzzyMatcher {}
+
+impl FuzzyMatcher {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn match_pattern<'a>(&self, pattern: &'a str, items: &'a [&'a str]) -> Vec<&'a str> {
+        let pat = Pattern::new(
+            pattern,
+            nucleo_matcher::pattern::CaseMatching::Ignore,
+            nucleo_matcher::pattern::Normalization::Smart,
+            nucleo_matcher::pattern::AtomKind::Fuzzy,
+        );
+        let mut matcher = Matcher::new(nucleo_matcher::Config::DEFAULT);
+        let res = pat.match_list(items, &mut matcher);
+
+        res.into_iter().map(|(item, _)| *item).collect::<Vec<_>>()
+    }
+}
+
+pub trait FuzzyMatcherApp {
+    fn fuzzy_matcher(&self) -> FuzzyMatcher;
+}
+
+impl FuzzyMatcherApp for &'static App {
+    fn fuzzy_matcher(&self) -> FuzzyMatcher {
+        FuzzyMatcher::new()
+    }
+}

crates/gitnow/src/git_clone.rs

@@ -0,0 +1,83 @@
+use crate::{app::App, git_provider::Repository};
+
+#[derive(Debug, Clone)]
+pub struct GitClone {
+    app: &'static App,
+}
+
+impl GitClone {
+    pub fn new(app: &'static App) -> Self {
+        Self { app }
+    }
+
+    pub async fn clone_repo(
+        &self,
+        repository: &Repository,
+        force_refresh: bool,
+    ) -> anyhow::Result<()> {
+        let project_path = self
+            .app
+            .config
+            .settings
+            .projects
+            .directory
+            .join(repository.to_rel_path());
+
+        if force_refresh {
+            tokio::fs::remove_dir_all(&project_path).await?;
+        }
+
+        if project_path.exists() {
+            tracing::info!(
+                "project: {} already exists, skipping clone",
+                repository.to_rel_path().display()
+            );
+            return Ok(());
+        }
+
+        tracing::info!(
+            "cloning: {} into {}",
+            repository.ssh_url.as_str(),
+            &project_path.display().to_string(),
+        );
+
+        let mut cmd = tokio::process::Command::new("git");
+        cmd.args([
+            "clone",
+            repository.ssh_url.as_str(),
+            &project_path.display().to_string(),
+        ]);
+
+        let output = cmd.output().await?;
+        match output.status.success() {
+            true => tracing::debug!(
+                "cloned {} into {}",
+                repository.ssh_url.as_str(),
+                &project_path.display().to_string(),
+            ),
+            false => {
+                let stdout = std::str::from_utf8(&output.stdout).unwrap_or_default();
+                let stderr = std::str::from_utf8(&output.stderr).unwrap_or_default();
+                tracing::error!(
+                    "failed to clone {} into {}, with output: {}, err: {}",
+                    repository.ssh_url.as_str(),
+                    &project_path.display().to_string(),
+                    stdout,
+                    stderr
+                )
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub trait GitCloneApp {
+    fn git_clone(&self) -> GitClone;
+}
+
+impl GitCloneApp for &'static App {
+    fn git_clone(&self) -> GitClone {
+        GitClone::new(self)
+    }
+}

crates/gitnow/src/git_provider/gitea.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use gitea_rs::apis::configuration::Configuration;
+use gitea_client::apis::configuration::Configuration;
 use url::Url;
 
 use crate::{app::App, config::GiteaAccessToken};
@@ -68,9 +68,9 @@ impl GiteaProvider {
         &self,
         config: &Configuration,
         page: usize,
-    ) -> anyhow::Result<Vec<gitea_rs::models::Repository>> {
+    ) -> anyhow::Result<Vec<gitea_client::models::Repository>> {
         let repos =
-            gitea_rs::apis::user_api::user_current_list_repos(config, Some(page as i32), None)
+            gitea_client::apis::user_api::user_current_list_repos(config, Some(page as i32), None)
                 .await
                 .context("failed to fetch repos for users")?;
 
@@ -125,9 +125,9 @@ impl GiteaProvider {
         user: &str,
         config: &Configuration,
         page: usize,
-    ) -> anyhow::Result<Vec<gitea_rs::models::Repository>> {
+    ) -> anyhow::Result<Vec<gitea_client::models::Repository>> {
         let repos =
-            gitea_rs::apis::user_api::user_list_repos(config, user, Some(page as i32), None)
+            gitea_client::apis::user_api::user_list_repos(config, user, Some(page as i32), None)
                 .await
                 .context("failed to fetch repos for users")?;
 
@@ -184,8 +184,8 @@ impl GiteaProvider {
         organisation: &str,
         config: &Configuration,
         page: usize,
-    ) -> anyhow::Result<Vec<gitea_rs::models::Repository>> {
+    ) -> anyhow::Result<Vec<gitea_client::models::Repository>> {
-        let repos = gitea_rs::apis::organization_api::org_list_repos(
+        let repos = gitea_client::apis::organization_api::org_list_repos(
             config,
             organisation,
             Some(page as i32),
@@ -202,7 +202,7 @@ impl GiteaProvider {
         api: &str,
         access_token: Option<&GiteaAccessToken>,
     ) -> anyhow::Result<Configuration> {
-        let mut config = gitea_rs::apis::configuration::Configuration::new();
+        let mut config = gitea_client::apis::configuration::Configuration::new();
         config.base_path = api.into();
         match access_token {
             Some(GiteaAccessToken::Env { env }) => {

crates/gitnow/src/git_provider/github.rs

@@ -1,10 +1,4 @@
-use anyhow::Context;
+use octocrab::{models::Repository, params::repos::Sort, Octocrab, Page};
-use octocrab::{
-    auth::Auth,
-    models::{hooks::Config, Repository},
-    params::repos::Sort,
-    NoSvc, Octocrab, Page,
-};
 
 use crate::{app::App, config::GitHubAccessToken};
 
@@ -159,7 +153,7 @@ impl GitHubProvider {
 
     fn get_client(
         &self,
-        url: Option<&String>,
+        _url: Option<&String>,
         access_token: &GitHubAccessToken,
     ) -> anyhow::Result<Octocrab> {
         let client = octocrab::Octocrab::builder()

crates/gitnow/src/interactive.rs

@@ -0,0 +1,166 @@
+use app::App;
+use ratatui::{prelude::*, Terminal};
+
+use crate::git_provider::Repository;
+
+pub struct Interactive {
+    app: &'static crate::app::App,
+}
+
+impl Interactive {
+    pub fn new(app: &'static crate::app::App) -> Self {
+        Self { app }
+    }
+
+    pub fn interactive_search(
+        &mut self,
+        repositories: &[Repository],
+    ) -> anyhow::Result<Option<Repository>> {
+        let backend = TermwizBackend::new().map_err(|e| anyhow::anyhow!(e.to_string()))?;
+        let terminal = Terminal::new(backend)?;
+
+        let app_result = App::new(self.app, repositories).run(terminal);
+
+        app_result
+    }
+}
+
+pub trait InteractiveApp {
+    fn interactive(&self) -> Interactive;
+}
+
+impl InteractiveApp for &'static crate::app::App {
+    fn interactive(&self) -> Interactive {
+        Interactive::new(self)
+    }
+}
+
+mod app {
+    use ratatui::{
+        crossterm::event::{self, Event, KeyCode},
+        layout::{Constraint, Layout},
+        prelude::TermwizBackend,
+        style::{Style, Stylize},
+        text::{Line, Span},
+        widgets::{ListItem, ListState, Paragraph, StatefulWidget},
+        Frame, Terminal,
+    };
+
+    use crate::{
+        commands::root::RepositoryMatcher, fuzzy_matcher::FuzzyMatcherApp, git_provider::Repository,
+    };
+
+    pub struct App<'a> {
+        app: &'static crate::app::App,
+        repositories: &'a [Repository],
+        current_search: String,
+        matched_repos: Vec<Repository>,
+        list: ListState,
+    }
+
+    impl<'a> App<'a> {
+        pub fn new(app: &'static crate::app::App, repositories: &'a [Repository]) -> Self {
+            Self {
+                app,
+                repositories,
+                current_search: String::default(),
+                matched_repos: Vec::default(),
+                list: ListState::default(),
+            }
+        }
+
+        fn update_matched_repos(&mut self) {
+            let res = self
+                .app
+                .fuzzy_matcher()
+                .match_repositories(&self.current_search, self.repositories);
+
+            self.matched_repos = res;
+
+            if self.list.selected().is_none() {
+                self.list.select_first();
+            }
+        }
+
+        pub fn run(
+            mut self,
+            mut terminal: Terminal<TermwizBackend>,
+        ) -> anyhow::Result<Option<Repository>> {
+            self.update_matched_repos();
+
+            loop {
+                terminal.draw(|frame| self.draw(frame))?;
+
+                if let Event::Key(key) = event::read()? {
+                    match key.code {
+                        KeyCode::Char(letter) => {
+                            self.current_search.push(letter);
+                            self.update_matched_repos();
+                        }
+                        KeyCode::Backspace => {
+                            if !self.current_search.is_empty() {
+                                let _ = self.current_search.remove(self.current_search.len() - 1);
+                                self.update_matched_repos();
+                            }
+                        }
+                        KeyCode::Esc => {
+                            return Ok(None);
+                        }
+                        KeyCode::Enter => {
+                            if let Some(selected) = self.list.selected() {
+                                if let Some(repo) = self.matched_repos.get(selected).cloned() {
+                                    terminal.resize(ratatui::layout::Rect::ZERO)?;
+                                    return Ok(Some(repo));
+                                }
+                            }
+
+                            return Ok(None);
+                        }
+                        KeyCode::Up => self.list.select_next(),
+                        KeyCode::Down => self.list.select_previous(),
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        fn draw(&mut self, frame: &mut Frame) {
+            let vertical = Layout::vertical([Constraint::Percentage(100), Constraint::Min(1)]);
+            let [repository_area, input_area] = vertical.areas(frame.area());
+
+            let repos = &self.matched_repos;
+
+            let repo_items = repos
+                .iter()
+                .map(|r| r.to_rel_path().display().to_string())
+                .collect::<Vec<_>>();
+
+            let repo_list_items = repo_items
+                .into_iter()
+                .map(ListItem::from)
+                .collect::<Vec<_>>();
+
+            let repo_list = ratatui::widgets::List::new(repo_list_items)
+                .direction(ratatui::widgets::ListDirection::BottomToTop)
+                .scroll_padding(3)
+                .highlight_symbol("> ")
+                .highlight_spacing(ratatui::widgets::HighlightSpacing::Always)
+                .highlight_style(Style::default().bold().white());
+
+            StatefulWidget::render(
+                repo_list,
+                repository_area,
+                frame.buffer_mut(),
+                &mut self.list,
+            );
+
+            let input = Paragraph::new(Line::from(vec![
+                Span::from("> ").blue(),
+                Span::from(self.current_search.as_str()),
+                Span::from(" ").on_white(),
+            ]));
+
+            frame.render_widget(input, input_area);
+        }
+    }
+}

crates/gitnow/src/main.rs

@@ -4,27 +4,53 @@ use std::path::PathBuf;
 
 use anyhow::Context;
 use clap::{Parser, Subcommand};
-use commands::root::RootCommand;
+use commands::{root::RootCommand, shell::Shell, update::Update};
 use config::Config;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::EnvFilter;
 
 mod app;
 mod cache;
 mod cache_codec;
 mod commands;
+mod components;
 mod config;
+mod fuzzy_matcher;
+mod git_clone;
 mod git_provider;
+mod interactive;
 mod projects_list;
+mod shell;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = Some("Navigate git projects at the speed of thought"))]
 struct Command {
     #[command(subcommand)]
     command: Option<Commands>,
+
+    #[arg()]
+    search: Option<String>,
+
+    #[arg(long = "no-cache", default_value = "false")]
+    no_cache: bool,
+
+    #[arg(long = "no-clone", default_value = "false")]
+    no_clone: bool,
+
+    #[arg(long = "no-shell", default_value = "false")]
+    no_shell: bool,
+
+    #[arg(long = "force-refresh", default_value = "false")]
+    force_refresh: bool,
+
+    #[arg(long = "force-cache-update", default_value = "false")]
+    force_cache_update: bool,
 }
 
 #[derive(Subcommand)]
 enum Commands {
-    Hello {},
+    Init(Shell),
+    Update(Update),
 }
 
 const DEFAULT_CONFIG_PATH: &str = ".config/gitnow/gitnow.toml";
@@ -32,7 +58,13 @@ const DEFAULT_CONFIG_PATH: &str = ".config/gitnow/gitnow.toml";
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenv::dotenv().ok();
-    tracing_subscriber::fmt::init();
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::ERROR.into())
+                .from_env_lossy(),
+        )
+        .init();
 
     let home =
         std::env::var("HOME").context("HOME was not found, are you using a proper shell?")?;
@@ -49,9 +81,25 @@ async fn main() -> anyhow::Result<()> {
     tracing::debug!("Starting cli");
 
     match cli.command {
-        Some(_) => todo!(),
+        Some(cmd) => match cmd {
+            Commands::Init(mut shell) => {
+                shell.execute().await?;
+            }
+            Commands::Update(mut update) => {
+                update.execute(app).await?;
+            }
+        },
         None => {
-            RootCommand::new(app).execute().await?;
+            RootCommand::new(app)
+                .execute(
+                    cli.search.as_ref(),
+                    !cli.no_cache,
+                    !cli.no_clone,
+                    !cli.no_shell,
+                    cli.force_refresh,
+                    cli.force_cache_update,
+                )
+                .await?;
         }
     }
 

crates/gitnow/src/projects_list.rs

@@ -1,15 +1,34 @@
-use crate::{
+#[cfg(not(feature = "example"))]
+pub use implementation::*;
+
+#[cfg(feature = "example")]
+pub use example_projects::*;
+
+use crate::app::App;
+
+pub trait ProjectsListApp {
+    fn projects_list(&self) -> ProjectsList;
+}
+
+impl ProjectsListApp for &'static App {
+    fn projects_list(&self) -> ProjectsList {
+        ProjectsList::new(self)
+    }
+}
+
+mod implementation {
+    use crate::{
         app::App,
         git_provider::{
             gitea::GiteaProviderApp, github::GitHubProviderApp, Repository, VecRepositoryExt,
         },
-};
+    };
 
-pub struct ProjectsList {
+    pub struct ProjectsList {
         app: &'static App,
-}
+    }
 
-impl ProjectsList {
+    impl ProjectsList {
         pub fn new(app: &'static App) -> Self {
             Self { app }
         }
@@ -73,7 +92,10 @@ impl ProjectsList {
             for github in self.app.config.providers.github.iter() {
                 if let Some(_user) = &github.current_user {
                     let mut repos = github_provider
-                    .list_repositories_for_current_user(github.url.as_ref(), &github.access_token)
+                        .list_repositories_for_current_user(
+                            github.url.as_ref(),
+                            &github.access_token,
+                        )
                         .await?;
 
                     repositories.append(&mut repos);
@@ -106,14 +128,8 @@ impl ProjectsList {
 
             Ok(repositories)
         }
-}
-
-pub trait ProjectsListApp {
-    fn projects_list(&self) -> ProjectsList;
-}
-
-impl ProjectsListApp for &'static App {
-    fn projects_list(&self) -> ProjectsList {
-        ProjectsList::new(self)
     }
 }
+
+#[cfg(feature = "example")]
+mod example_projects;

crates/gitnow/src/projects_list/example_projects.rs

@@ -0,0 +1,84 @@
+use crate::{app::App, git_provider::Repository};
+
+pub struct ProjectsList {}
+
+impl ProjectsList {
+    pub fn new(_app: &'static App) -> Self {
+        Self {}
+    }
+
+    pub async fn get_projects(&self) -> anyhow::Result<Vec<Repository>> {
+        Ok(self.from_strings([
+            "github.com/kjuulh/gitnow",
+            "github.com/kjuulh/gitnow-client",
+            "github.com/kjuulh/crunch",
+            "git.front.kjuulh.io/kjuulh/gitnow",
+            "git.front.kjuulh.io/kjuulh/gitnow-client",
+            "git.front.kjuulh.io/kjuulh/cuddle",
+            "git.front.kjuulh.io/kjuulh/buckle",
+            "git.front.kjuulh.io/kjuulh/books",
+            "git.front.kjuulh.io/kjuulh/blog-deployment",
+            "git.front.kjuulh.io/kjuulh/blog",
+            "git.front.kjuulh.io/kjuulh/bitfield",
+            "git.front.kjuulh.io/kjuulh/bitebuds-deployment",
+            "git.front.kjuulh.io/kjuulh/bitebuds",
+            "git.front.kjuulh.io/kjuulh/beerday",
+            "git.front.kjuulh.io/kjuulh/bearing",
+            "git.front.kjuulh.io/kjuulh/basic-webserver",
+            "git.front.kjuulh.io/kjuulh/backup",
+            "git.front.kjuulh.io/kjuulh/backstage",
+            "git.front.kjuulh.io/kjuulh/autom8-calendar-integration",
+            "git.front.kjuulh.io/kjuulh/astronvim",
+            "git.front.kjuulh.io/kjuulh/artifacts",
+            "git.front.kjuulh.io/kjuulh/articles",
+            "git.front.kjuulh.io/kjuulh/acc-server",
+            "git.front.kjuulh.io/kjuulh/_cargo-index",
+            "git.front.kjuulh.io/keep-up/keep-up-example",
+            "git.front.kjuulh.io/keep-up/keep-up",
+            "git.front.kjuulh.io/experiments/wasm-bin",
+            "git.front.kjuulh.io/dotfiles/doom",
+            "git.front.kjuulh.io/danskebank/testssl.sh",
+            "git.front.kjuulh.io/clank/kubernetes-state",
+            "git.front.kjuulh.io/clank/kubernetes-init",
+            "git.front.kjuulh.io/clank/blog",
+            "git.front.kjuulh.io/cibus/deployments",
+            "git.front.kjuulh.io/butikkaerlighilsen/client",
+            "git.front.kjuulh.io/bevy/bevy",
+            "git.front.kjuulh.io/OpenFood/openfood",
+        ]))
+    }
+
+    fn from_strings(
+        &self,
+        repos_into: impl IntoIterator<Item = impl Into<Repository>>,
+    ) -> Vec<Repository> {
+        let repos = repos_into
+            .into_iter()
+            .map(|item| item.into())
+            .collect::<Vec<Repository>>();
+
+        repos
+    }
+}
+
+impl From<&str> for Repository {
+    fn from(value: &str) -> Self {
+        let values = value.split("/").collect::<Vec<_>>();
+        if values.len() != 3 {
+            panic!("value: '{value}' isn't a valid provider/owner/repository")
+        }
+
+        let (provider, owner, name) = (
+            values.get(0).unwrap(),
+            values.get(1).unwrap(),
+            values.get(2).unwrap(),
+        );
+
+        Self {
+            provider: provider.to_string(),
+            owner: owner.to_string(),
+            repo_name: name.to_string(),
+            ssh_url: format!("ssh://git@{provider}/{owner}/{name}.git"),
+        }
+    }
+}

crates/gitnow/src/shell.rs

@@ -0,0 +1,65 @@
+use anyhow::Context;
+
+use crate::{app::App, git_provider::Repository};
+
+pub struct Shell {
+    app: &'static App,
+}
+
+impl Shell {
+    pub fn new(app: &'static App) -> Self {
+        Self { app }
+    }
+
+    pub async fn spawn_shell(&self, repository: &Repository) -> anyhow::Result<()> {
+        let project_path = self
+            .app
+            .config
+            .settings
+            .projects
+            .directory
+            .join(repository.to_rel_path());
+
+        if !project_path.exists() {
+            anyhow::bail!(
+                "project path: {} does not exists, it is either a file, or hasn't been cloned",
+                project_path.display()
+            );
+        }
+
+        let shell = std::env::var("SHELL")
+            .context("failed to find SHELL variable, required for spawning embedded shells")?;
+
+        let mut shell_cmd = tokio::process::Command::new(shell);
+        shell_cmd.current_dir(project_path);
+
+        let mut process = shell_cmd.spawn().context("failed to spawn child session")?;
+
+        let status = process.wait().await?;
+
+        if !status.success() {
+            tracing::warn!(
+                "child session returned non-zero, or missing return code: {}",
+                status.code().unwrap_or_default()
+            );
+            anyhow::bail!(
+                "child shell session failed with exit: {}",
+                status.code().unwrap_or(-1)
+            );
+        } else {
+            tracing::debug!("child session returned 0 exit code");
+        }
+
+        Ok(())
+    }
+}
+
+pub trait ShellApp {
+    fn shell(&self) -> Shell;
+}
+
+impl ShellApp for &'static App {
+    fn shell(&self) -> Shell {
+        Shell::new(self)
+    }
+}

cuddle.yaml

@@ -15,3 +15,11 @@ please:
     api_url: "https://git.front.kjuulh.io"
   actions:
     rust:
+
+scripts:
+  record:
+    type: shell
+  update-gifs:
+    type: shell
+  install:
+    type: shell

scripts/install.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+cargo install --path crates/gitnow

scripts/record.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env zsh
+
+set -e
+
+# Loop through each file in the folder
+for file in "vhs"/*; do
+  # Check if it is a file (not a directory)
+  if [[ -f "$file" ]]; then
+    echo "Recording: $file"
+
+    vhs "./$file"
+  fi
+done

scripts/update-gifs.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env zsh
+
+rm -r assets/gifs
+
+set -e
+
+cargo build --features example && clear
+
+cuddle x record
+mkdir -p assets/gifs
+mv target/vhs/* assets/gifs

vhs/example.vhs

@@ -0,0 +1,17 @@
+Output "target/vhs/example.gif"
+Set Theme "Dracula"
+Set Width 1200
+Set Height 1000
+Hide
+Type "./target/debug/gitnow --no-cache --force-refresh"
+Enter
+Show
+Sleep 2s
+Type@500ms "bevy"
+Sleep 1s
+Enter
+Sleep 10s
+Type "echo 'I am now in bevy!'"
+Enter
+Sleep 5s
+Sleep 2s