implement open editor command

Author: ozankasikci

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file. This format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- Add an “Open in Editor” action in the interactive UI and a `rsworktree worktree open-editor` CLI command, including guidance when no editor is configured.
+
 ## [0.6.4] - 2025-10-10
 
 ### Added

Cargo.lock

@@ -20,6 +20,7 @@ crossterm = "0.27"
 ratatui = { version = "0.26", default-features = false, features = ["crossterm"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+shell-words = "1.1"
 
 [dev-dependencies]
 assert_cmd = "2.0"

Cargo.toml

@@ -14,14 +14,16 @@
   - [`rsworktree rm`](#rsworktree-rm)
   - [`rsworktree pr-github`](#rsworktree-pr-github)
   - [`rsworktree merge-pr-github`](#rsworktree-merge-pr-github)
+  - [`rsworktree worktree open-editor`](#rsworktree-worktree-open-editor)
 - [Installation](#installation)
 - [Environment](#environment)
 
 ## Interactive mode
 
 - Open a terminal UI for browsing worktrees, focusing actions, and inspecting details without memorizing subcommands.
 - Launch it with the `interactive` command: `rsworktree interactive` (shortcut: `rsworktree i`).
-- Available actions include opening worktrees, removing them, creating PRs, and merging PRs without leaving the TUI.
+- Available actions include opening worktrees, launching editors, removing worktrees, creating PRs, and merging PRs without leaving the TUI.
+- Use the **Open in Editor** action to launch the highlighted worktree in your configured editor (initial support covers `vim`, `cursor`, `webstorm`, and `rider`; see the quickstart for setup guidance).
 - The merge flow lets you decide whether to keep the local branch, delete the remote branch, and clean up the worktree before exiting.
 - ![Interactive mode screenshot](tapes/gifs/interactive-mode.gif)
 
@@ -78,6 +80,12 @@
 - Options:
   - `<name>` — optional explicit worktree to operate on; defaults to the current directory.
 
+### `rsworktree worktree open-editor`
+
+- Open the specified worktree (or the current directory when omitted) in your configured editor.
+- Editor resolution checks the rsworktree config first, then falls back to `$EDITOR` / `$VISUAL`. If no editor is configured, the command prints actionable guidance instead of failing.
+- Initial support focuses on `vim`, `cursor`, `webstorm`, and `rider`. For setup instructions and troubleshooting, see `specs/002-i-want-to/quickstart.md`.
+
 ## Installation
 
 Install from crates.io with:
@@ -98,4 +106,3 @@ After the binary is on your `PATH`, run `rsworktree --help` to explore the avail
 ## Environment
 
 Set `RSWORKTREE_SHELL` to override the shell used by `rsworktree cd` (falls back to `$SHELL` or `/bin/sh`).
-

README.md

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, path::PathBuf};
 
 use clap::{Parser, Subcommand};
 
@@ -12,6 +12,7 @@ use crate::{
         interactive,
         list::ListCommand,
         merge_pr_github::MergePrGithubCommand,
+        open_editor::OpenEditorCommand,
         pr_github::{PrGithubCommand, PrGithubOptions},
         rm::RemoveCommand,
     },
@@ -35,6 +36,9 @@ enum Commands {
     /// Interactively browse and open worktrees.
     #[command(alias = "i")]
     Interactive,
+    /// Worktree scoped commands.
+    #[command(subcommand)]
+    Worktree(WorktreeCommands),
     /// Remove a worktree tracked in `.rsworktree`.
     Rm(RmArgs),
     /// Create a GitHub pull request for the worktree's branch using the GitHub CLI.
@@ -43,6 +47,12 @@ enum Commands {
     MergePrGithub(MergePrGithubArgs),
 }
 
+#[derive(Subcommand, Debug)]
+enum WorktreeCommands {
+    /// Open a worktree in the configured editor.
+    OpenEditor(OpenEditorArgs),
+}
+
 #[derive(Parser, Debug)]
 struct CreateArgs {
     /// Name of the worktree (also used as the branch name)
@@ -70,6 +80,16 @@ struct RmArgs {
     force: bool,
 }
 
+#[derive(Parser, Debug)]
+struct OpenEditorArgs {
+    /// Name of the worktree to open
+    #[arg(required_unless_present = "path")]
+    name: Option<String>,
+    /// Open a worktree by absolute path instead of managed name
+    #[arg(long, value_name = "path", conflicts_with = "name")]
+    path: Option<PathBuf>,
+}
+
 #[derive(Parser, Debug)]
 struct PrGithubArgs {
     /// Name of the worktree to prepare a PR from (defaults to the current worktree)
@@ -126,6 +146,12 @@ pub fn run() -> color_eyre::Result<()> {
         Commands::Interactive => {
             interactive::run(&repo)?;
         }
+        Commands::Worktree(command) => match command {
+            WorktreeCommands::OpenEditor(args) => {
+                let command = OpenEditorCommand::new(args.name, args.path);
+                command.execute(&repo)?;
+            }
+        },
         Commands::Rm(args) => {
             let command = RemoveCommand::new(args.name, args.force);
             let _ = command.execute(&repo)?;

src/cli/mod.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use color_eyre::{Result, eyre::WrapErr};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
@@ -22,7 +22,11 @@ use super::{
     },
     view::{DetailData, DialogView, Snapshot},
 };
-use crate::commands::rm::{LocalBranchStatus, RemoveOutcome};
+use crate::{
+    commands::rm::{LocalBranchStatus, RemoveOutcome},
+    editor::LaunchOutcome,
+    telemetry::EditorLaunchStatus,
+};
 
 #[allow(dead_code)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -140,16 +144,22 @@ where
         }
     }
 
-    pub fn run<F, G>(mut self, mut on_remove: F, mut on_create: G) -> Result<Option<Selection>>
+    pub fn run<F, G, H>(
+        mut self,
+        mut on_remove: F,
+        mut on_create: G,
+        mut on_open_editor: H,
+    ) -> Result<Option<Selection>>
     where
         F: FnMut(&str, bool) -> Result<RemoveOutcome>,
         G: FnMut(&str, Option<&str>) -> Result<()>,
+        H: FnMut(&str, &Path) -> color_eyre::Result<LaunchOutcome>,
     {
         self.terminal
             .hide_cursor()
             .wrap_err("failed to hide cursor")?;
 
-        let result = self.event_loop(&mut on_remove, &mut on_create);
+        let result = self.event_loop(&mut on_remove, &mut on_create, &mut on_open_editor);
 
         self.terminal
             .clear()
@@ -161,14 +171,16 @@ where
         result
     }
 
-    fn event_loop<F, G>(
+    fn event_loop<F, G, H>(
         &mut self,
         on_remove: &mut F,
         on_create: &mut G,
+        on_open_editor: &mut H,
     ) -> Result<Option<Selection>>
     where
         F: FnMut(&str, bool) -> Result<RemoveOutcome>,
         G: FnMut(&str, Option<&str>) -> Result<()>,
+        H: FnMut(&str, &Path) -> color_eyre::Result<LaunchOutcome>,
     {
         let mut state = ListState::default();
         self.sync_selection(&mut state);
@@ -179,23 +191,25 @@ where
                 .draw(|frame| snapshot.render(frame, &mut state))?;
             let event = self.events.next()?;
 
-            match self.process_event(event, &mut state, on_remove, on_create)? {
+            match self.process_event(event, &mut state, on_remove, on_create, on_open_editor)? {
                 LoopControl::Continue => {}
                 LoopControl::Exit(outcome) => return Ok(outcome),
             }
         }
     }
 
-    fn process_event<F, G>(
+    fn process_event<F, G, H>(
         &mut self,
         event: Event,
         state: &mut ListState,
         on_remove: &mut F,
         on_create: &mut G,
+        on_open_editor: &mut H,
     ) -> Result<LoopControl>
     where
         F: FnMut(&str, bool) -> Result<RemoveOutcome>,
         G: FnMut(&str, Option<&str>) -> Result<()>,
+        H: FnMut(&str, &Path) -> color_eyre::Result<LaunchOutcome>,
     {
         if let Some(dialog) = self.dialog.clone() {
             match dialog {
@@ -260,6 +274,21 @@ where
                 self.handle_down(state);
                 Ok(LoopControl::Continue)
             }
+            KeyCode::Char('e') | KeyCode::Char('E') => match self.focus {
+                Focus::Worktrees => {
+                    if let Some(entry) = self.current_entry().cloned() {
+                        self.trigger_open_in_editor(on_open_editor, &entry.name, &entry.path)?;
+                    } else {
+                        self.status = Some(StatusMessage::info("No worktree selected."));
+                    }
+                    Ok(LoopControl::Continue)
+                }
+                Focus::Actions => {
+                    self.select_action(Action::OpenInEditor);
+                    self.handle_enter(on_open_editor)
+                }
+                Focus::GlobalActions => Ok(LoopControl::Continue),
+            },
             KeyCode::Left => {
                 match self.focus {
                     Focus::Actions => self.move_action(-1),
@@ -276,7 +305,7 @@ where
                 }
                 Ok(LoopControl::Continue)
             }
-            KeyCode::Enter => self.handle_enter(),
+            KeyCode::Enter => self.handle_enter(on_open_editor),
             _ => Ok(LoopControl::Continue),
         }
     }
@@ -327,7 +356,10 @@ where
         };
     }
 
-    fn handle_enter(&mut self) -> Result<LoopControl> {
+    fn handle_enter<H>(&mut self, on_open_editor: &mut H) -> Result<LoopControl>
+    where
+        H: FnMut(&str, &Path) -> color_eyre::Result<LaunchOutcome>,
+    {
         match self.focus {
             Focus::Worktrees => {
                 if let Some(index) = self.selected {
@@ -349,6 +381,14 @@ where
                         }
                         self.status = Some(StatusMessage::info("No worktree selected."));
                     }
+                    Action::OpenInEditor => {
+                        if let Some(entry) = self.current_entry().cloned() {
+                            self.trigger_open_in_editor(on_open_editor, &entry.name, &entry.path)?;
+                        } else {
+                            self.status = Some(StatusMessage::info("No worktree selected."));
+                        }
+                        return Ok(LoopControl::Continue);
+                    }
                     Action::Remove => {
                         if let Some(index) = self.selected {
                             self.dialog = Some(Dialog::Remove(RemoveDialog::new(index)));
@@ -936,6 +976,46 @@ where
             .ensure_visible(visible_rows, Action::ALL.len());
     }
 
+    fn select_action(&mut self, action: Action) {
+        if let Some(index) = Action::ALL
+            .iter()
+            .position(|candidate| *candidate == action)
+        {
+            self.action_panel.selected_index = index;
+            let visible_rows = self.action_panel_visible_rows();
+            self.action_panel
+                .ensure_visible(visible_rows, Action::ALL.len());
+        }
+    }
+
+    fn trigger_open_in_editor<H>(
+        &mut self,
+        on_open_editor: &mut H,
+        name: &str,
+        path: &Path,
+    ) -> Result<()>
+    where
+        H: FnMut(&str, &Path) -> color_eyre::Result<LaunchOutcome>,
+    {
+        match on_open_editor(name, path) {
+            Ok(outcome) => {
+                let status = match outcome.status {
+                    EditorLaunchStatus::Success | EditorLaunchStatus::PreferenceMissing => {
+                        StatusMessage::info(outcome.message)
+                    }
+                    _ => StatusMessage::error(outcome.message),
+                };
+                self.status = Some(status);
+            }
+            Err(error) => {
+                self.status = Some(StatusMessage::error(format!(
+                    "Failed to open `{name}`: {error}"
+                )));
+            }
+        }
+        Ok(())
+    }
+
     fn move_global_action(&mut self, delta: isize) {
         let len = super::GLOBAL_ACTIONS.len() as isize;
         if len == 0 {

src/commands/interactive/command.rs

@@ -54,14 +54,16 @@ pub(crate) enum Selection {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum Action {
     Open,
+    OpenInEditor,
     Remove,
     PrGithub,
     MergePrGithub,
 }
 
 impl Action {
-    pub(crate) const ALL: [Action; 4] = [
+    pub(crate) const ALL: [Action; 5] = [
         Action::Open,
+        Action::OpenInEditor,
         Action::Remove,
         Action::PrGithub,
         Action::MergePrGithub,
@@ -70,6 +72,7 @@ impl Action {
     pub(crate) fn label(self) -> &'static str {
         match self {
             Action::Open => "Open",
+            Action::OpenInEditor => "Open in Editor",
             Action::Remove => "Remove",
             Action::PrGithub => "PR (GitHub)",
             Action::MergePrGithub => "Merge PR (GitHub)",
@@ -79,7 +82,11 @@ impl Action {
     pub(crate) fn requires_selection(self) -> bool {
         matches!(
             self,
-            Action::Open | Action::Remove | Action::PrGithub | Action::MergePrGithub
+            Action::Open
+                | Action::OpenInEditor
+                | Action::Remove
+                | Action::PrGithub
+                | Action::MergePrGithub
         )
     }
 

src/commands/interactive/mod.rs

@@ -18,6 +18,7 @@ use crate::{
         pr_github::{PrGithubCommand, PrGithubOptions},
         rm::RemoveCommand,
     },
+    editor::launch_worktree,
 };
 
 use super::{EventSource, Selection, WorktreeEntry, command::InteractiveCommand};
@@ -82,6 +83,7 @@ pub fn run(repo: &Repo) -> Result<()> {
                 )),
             }
         },
+        |name, path| launch_worktree(repo, name, path),
     );
     let cleanup_result = cleanup_terminal();