add tap-editor crate for multi-editor support

Supports line/column positioning for:
- vim/nvim/vi: +{line}
- cursor/code: -g file:line:col
- nano: +line,col
- emacs: +line:col
- helix: file:line

Author: andrewgazelka

Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "tap-editor"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+
+[dependencies]

crates/tap-editor/Cargo.toml

@@ -0,0 +1,183 @@
+//! Editor integration utilities.
+//!
+//! Handles different editor command-line argument formats for opening files
+//! at specific line/column positions.
+
+use std::path::Path;
+
+/// Known editor types with their argument formats.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EditorKind {
+    /// vim, nvim, vi: `+{line}` before file
+    Vim,
+    /// VSCode, Cursor: `-g {file}:{line}:{col}`
+    VsCode,
+    /// nano: `+{line},{col}` before file
+    Nano,
+    /// emacs: `+{line}:{col}` before file
+    Emacs,
+    /// helix: `{file}:{line}`
+    Helix,
+    /// Unknown editor, no line number support
+    Unknown,
+}
+
+impl EditorKind {
+    /// Detect editor kind from command name or path.
+    pub fn detect(cmd: &str) -> Self {
+        let name = Path::new(cmd)
+            .file_name()
+            .and_then(|s| s.to_str())
+            .unwrap_or(cmd);
+
+        match name {
+            "vim" | "nvim" | "vi" | "view" | "vimdiff" => Self::Vim,
+            "code" | "cursor" | "code-insiders" | "codium" | "vscodium" => Self::VsCode,
+            "nano" | "pico" => Self::Nano,
+            "emacs" | "emacsclient" => Self::Emacs,
+            "hx" | "helix" => Self::Helix,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+/// Position in a file.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Position {
+    /// 1-indexed line number
+    pub line: usize,
+    /// 1-indexed column number (optional)
+    pub col: Option<usize>,
+}
+
+impl Position {
+    pub fn new(line: usize, col: Option<usize>) -> Self {
+        Self { line, col }
+    }
+
+    pub fn line(line: usize) -> Self {
+        Self { line, col: None }
+    }
+}
+
+/// Build command arguments for opening a file at a position.
+///
+/// Returns (args_before_file, file_arg) where:
+/// - `args_before_file`: arguments to add before the file path
+/// - `file_arg`: the file argument (may include line number for some editors)
+pub fn build_editor_args(
+    editor_cmd: &str,
+    file_path: &Path,
+    pos: Option<Position>,
+) -> (Vec<String>, String) {
+    let kind = EditorKind::detect(editor_cmd);
+    let file_str = file_path.display().to_string();
+
+    let Some(pos) = pos else {
+        return (vec![], file_str);
+    };
+
+    match kind {
+        EditorKind::Vim => {
+            // vim +42 file.txt
+            (vec![format!("+{}", pos.line)], file_str)
+        }
+        EditorKind::VsCode => {
+            // code -g file.txt:42:10
+            let col = pos.col.unwrap_or(1);
+            (vec!["-g".to_string()], format!("{file_str}:{}:{col}", pos.line))
+        }
+        EditorKind::Nano => {
+            // nano +42,10 file.txt
+            let arg = match pos.col {
+                Some(col) => format!("+{},{col}", pos.line),
+                None => format!("+{}", pos.line),
+            };
+            (vec![arg], file_str)
+        }
+        EditorKind::Emacs => {
+            // emacs +42:10 file.txt
+            let arg = match pos.col {
+                Some(col) => format!("+{}:{col}", pos.line),
+                None => format!("+{}", pos.line),
+            };
+            (vec![arg], file_str)
+        }
+        EditorKind::Helix => {
+            // hx file.txt:42
+            (vec![], format!("{file_str}:{}", pos.line))
+        }
+        EditorKind::Unknown => (vec![], file_str),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_vim() {
+        assert_eq!(EditorKind::detect("vim"), EditorKind::Vim);
+        assert_eq!(EditorKind::detect("nvim"), EditorKind::Vim);
+        assert_eq!(EditorKind::detect("/usr/bin/vim"), EditorKind::Vim);
+        assert_eq!(EditorKind::detect("/opt/homebrew/bin/nvim"), EditorKind::Vim);
+    }
+
+    #[test]
+    fn test_detect_vscode() {
+        assert_eq!(EditorKind::detect("code"), EditorKind::VsCode);
+        assert_eq!(EditorKind::detect("cursor"), EditorKind::VsCode);
+        assert_eq!(EditorKind::detect("/usr/local/bin/code"), EditorKind::VsCode);
+    }
+
+    #[test]
+    fn test_detect_others() {
+        assert_eq!(EditorKind::detect("nano"), EditorKind::Nano);
+        assert_eq!(EditorKind::detect("emacs"), EditorKind::Emacs);
+        assert_eq!(EditorKind::detect("hx"), EditorKind::Helix);
+        assert_eq!(EditorKind::detect("unknown-editor"), EditorKind::Unknown);
+    }
+
+    #[test]
+    fn test_vim_args() {
+        let (args, file) = build_editor_args("vim", Path::new("/tmp/test.txt"), Some(Position::line(42)));
+        assert_eq!(args, vec!["+42"]);
+        assert_eq!(file, "/tmp/test.txt");
+    }
+
+    #[test]
+    fn test_vscode_args() {
+        let (args, file) = build_editor_args(
+            "cursor",
+            Path::new("/tmp/test.txt"),
+            Some(Position::new(42, Some(10))),
+        );
+        assert_eq!(args, vec!["-g"]);
+        assert_eq!(file, "/tmp/test.txt:42:10");
+    }
+
+    #[test]
+    fn test_helix_args() {
+        let (args, file) = build_editor_args("hx", Path::new("/tmp/test.txt"), Some(Position::line(42)));
+        assert!(args.is_empty());
+        assert_eq!(file, "/tmp/test.txt:42");
+    }
+
+    #[test]
+    fn test_nano_args() {
+        let (args, file) = build_editor_args(
+            "nano",
+            Path::new("/tmp/test.txt"),
+            Some(Position::new(42, Some(5))),
+        );
+        assert_eq!(args, vec!["+42,5"]);
+        assert_eq!(file, "/tmp/test.txt");
+    }
+
+    #[test]
+    fn test_no_position() {
+        let (args, file) = build_editor_args("vim", Path::new("/tmp/test.txt"), None);
+        assert!(args.is_empty());
+        assert_eq!(file, "/tmp/test.txt");
+    }
+}

crates/tap-editor/src/lib.rs

@@ -26,3 +26,4 @@ vt100.workspace = true
 eyre.workspace = true
 tempfile.workspace = true
 crossterm.workspace = true
+tap-editor = { version = "0.1.0", path = "../tap-editor" }

crates/tap-server/Cargo.toml

@@ -4,16 +4,17 @@ use std::os::fd::BorrowedFd;
 
 use eyre::WrapErr as _;
 use std::io::Write as _;
+use tap_editor::Position;
 
 /// Open scrollback content in the configured editor.
 /// This function temporarily restores the terminal to cooked mode.
 ///
-/// If `cursor_line` is provided, the editor will open at that line number.
+/// If `cursor_pos` is provided, the editor will open at that position.
 pub fn open_scrollback_in_editor(
     scrollback_content: &str,
     editor_cmd: &str,
     orig_termios: Option<&nix::sys::termios::Termios>,
-    cursor_line: Option<usize>,
+    cursor_pos: Option<Position>,
 ) -> eyre::Result<()> {
     // Create temp file with scrollback content
     let mut temp_file = tempfile::NamedTempFile::new()
@@ -38,21 +39,14 @@ pub fn open_scrollback_in_editor(
         .split_first()
         .ok_or_else(|| eyre::eyre!("empty editor command — set $EDITOR or configure tap"))?;
 
+    // Build editor arguments with position support
+    let (pos_args, file_arg) = tap_editor::build_editor_args(cmd, &temp_path, cursor_pos);
+
     let mut command = std::process::Command::new(cmd);
     command.args(args.iter().copied());
+    command.args(pos_args);
+    command.arg(&file_arg);
 
-    // Add line number argument for vim/nvim (uses +{line} syntax)
-    if let Some(line) = cursor_line {
-        let cmd_name = std::path::Path::new(cmd)
-            .file_name()
-            .and_then(|s| s.to_str())
-            .unwrap_or(cmd);
-        if matches!(cmd_name, "vim" | "nvim" | "vi") {
-            command.arg(format!("+{line}"));
-        }
-    }
-
-    command.arg(&temp_path);
     let status = command
         .status()
         .wrap_err_with(|| format!("failed to spawn editor '{cmd}'"))?;

crates/tap-server/src/editor.rs

@@ -456,7 +456,7 @@ pub async fn run(config: ServerConfig) -> eyre::Result<i32> {
                                 tracing::debug!("OpenEditor action triggered!");
                                 let scrollback = SCROLLBACK.read();
                                 let scrollback_content = scrollback.get_lines(None);
-                                let (cursor_row, _cursor_col) = scrollback.cursor_position();
+                                let (cursor_row, cursor_col) = scrollback.cursor_position();
 
                                 // Calculate line number in scrollback content
                                 // cursor_row is relative to viewport, so we add scrollback lines
@@ -471,7 +471,7 @@ pub async fn run(config: ServerConfig) -> eyre::Result<i32> {
                                     &scrollback_content,
                                     &editor_cmd,
                                     orig_termios.as_ref(),
-                                    Some(cursor_line),
+                                    Some(tap_editor::Position::new(cursor_line, Some(cursor_col + 1))),
                                 ) {
                                     tracing::error!("failed to open editor: {e}");
                                 }