.forgejo/workflows/release.yml

@@ -1,165 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    container:
-      image: rust:bookworm
-      volumes:
-        - /opt/runner/keys:/keys:ro
-
-    steps:
-      - name: Install tools
-        run: |
-          apt-get update
-          apt-get install -y dpkg-dev git curl openssh-client
-
-      - name: Setup SSH
-        run: |
-          test -r /keys/forgejo_runner || { echo "Deploy key /keys/forgejo_runner chybi"; exit 1; }
-          install -m 600 /keys/forgejo_runner /tmp/forgejo_runner
-          echo "GIT_SSH_COMMAND=ssh -p 554 -i /tmp/forgejo_runner -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR" >> "$GITHUB_ENV"
-
-      - name: Checkout source
-        run: |
-          git clone ssh://git@git-ssh.janvete.com:554/seth/lines.git src
-          cd src
-          git checkout "${{ github.ref_name }}"
-
-      - name: Build Linux release binary and .deb
-        working-directory: src
-        run: |
-          VERSION=${{ github.ref_name }}
-          VER=${VERSION#v}
-          mkdir -p dist
-
-          cargo build --release
-
-          # .deb package
-          DEB_DIR="lines_${VER}_amd64"
-          mkdir -p "${DEB_DIR}/DEBIAN" "${DEB_DIR}/usr/bin"
-          cp target/release/lines "${DEB_DIR}/usr/bin/lines"
-          chmod 755 "${DEB_DIR}/usr/bin/lines"
-
-          cat > "${DEB_DIR}/DEBIAN/control" << CONTROL
-          Package: lines
-          Version: ${VER}
-          Section: utils
-          Priority: optional
-          Architecture: amd64
-          Maintainer: janvete <jan.vete@example.com>
-          Description: TUI for running frequently used commands from markdown files
-          CONTROL
-
-          dpkg-deb --build "${DEB_DIR}" "dist/${DEB_DIR}.deb"
-
-          # Linux tarball
-          STAGING=$(mktemp -d)
-          cp target/release/lines "${STAGING}/lines"
-          tar -czf "dist/lines-${VERSION}-linux-amd64.tar.gz" -C "${STAGING}" lines
-          rm -rf "${STAGING}"
-
-      - name: Print checksums
-        working-directory: src
-        run: |
-          echo "=== SHA256 checksums ==="
-          sha256sum dist/*
-
-      - name: Create Forgejo Release
-        working-directory: src
-        env:
-          FORGEJO_TOKEN: ${{ secrets.FORGEJO_TOKEN }}
-          FORGEJO_URL: https://git.janvete.com
-        run: |
-          VERSION=${{ github.ref_name }}
-          API="${FORGEJO_URL}/api/v1/repos/seth/lines"
-
-          RELEASE_JSON=$(curl -sS -H "Authorization: token ${FORGEJO_TOKEN}" \
-            -H "Content-Type: application/json" \
-            -X POST \
-            -d "{\"tag_name\":\"${VERSION}\",\"name\":\"${VERSION}\",\"draft\":false,\"prerelease\":false}" \
-            "${API}/releases")
-
-          echo "Create release response: ${RELEASE_JSON}"
-          RELEASE_ID=$(echo "${RELEASE_JSON}" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
-
-          if [ -z "${RELEASE_ID}" ]; then
-            echo "Release may already exist, fetching existing release..."
-            EXISTING=$(curl -sS -H "Authorization: token ${FORGEJO_TOKEN}" \
-              "${API}/releases/tags/${VERSION}")
-            echo "Existing release response: ${EXISTING}"
-            RELEASE_ID=$(echo "${EXISTING}" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
-          fi
-
-          if [ -z "${RELEASE_ID}" ]; then
-            echo "Failed to create or fetch release"
-            exit 1
-          fi
-
-          for ARCHIVE in dist/*; do
-            [ -e "${ARCHIVE}" ] || continue
-            NAME=$(basename "${ARCHIVE}")
-            case "${NAME}" in
-              *.tar.gz) CONTENT_TYPE="application/gzip" ;;
-              *.deb)    CONTENT_TYPE="application/vnd.debian.binary-package" ;;
-              *)        CONTENT_TYPE="application/octet-stream" ;;
-            esac
-            curl -sS -H "Authorization: token ${FORGEJO_TOKEN}" \
-              -H "Content-Type: ${CONTENT_TYPE}" \
-              --data-binary "@${ARCHIVE}" \
-              "${API}/releases/${RELEASE_ID}/assets?name=${NAME}"
-            echo "Uploaded ${NAME}"
-          done
-
-      - name: Update APT repository
-        working-directory: src
-        run: |
-          VERSION=${{ github.ref_name }}
-
-          git clone ssh://git@git-ssh.janvete.com:554/seth/apt.git apt-repo
-          cp dist/*.deb apt-repo/
-
-          cd apt-repo
-
-          # Remove any corrupted .deb files left from previous failed runs
-          for f in *.deb; do
-            [ -e "$f" ] || continue
-            if ! dpkg-deb -I "$f" >/dev/null 2>&1; then
-              echo "Removing corrupted package: $f"
-              rm -f "$f"
-            fi
-          done
-
-          dpkg-scanpackages . > Packages
-          gzip -k -f Packages
-
-          cat > Release << RELEASE
-          Origin: janvete
-          Label: janvete
-          Suite: stable
-          Codename: stable
-          Version: 1.0
-          Architectures: amd64
-          Components: main
-          Description: janvete tools APT repository
-          Date: $(date -Ru)
-          RELEASE
-
-          {
-            echo "SHA256:"
-            for f in Packages Packages.gz *.deb; do
-              [ -e "$f" ] || continue
-              printf " %s %16d %s\n" "$(sha256sum "$f" | cut -d' ' -f1)" "$(stat -c%s "$f")" "$f"
-            done
-          } >> Release
-
-          git config user.email "forgejo-actions[bot]@janvete.com"
-          git config user.name "forgejo-actions[bot]"
-          git add -A
-          git commit -m "chore: add lines ${VERSION}"
-          git push

Cargo.lock

@@ -825,7 +825,7 @@ dependencies = [
 
 [[package]]
 name = "lines"
-version = "0.1.21"
+version = "0.1.0"
 dependencies = [
  "base64",
  "chrono",

Cargo.toml

@@ -1,14 +1,7 @@
 [package]
 name = "lines"
-version = "0.1.21"
+version = "0.1.0"
 edition = "2024"
-authors = ["janvete"]
-description = "TUI for running frequently used commands"
-license = "MIT"
-repository = "https://git.janvete.com/seth/lines"
-homepage = "https://git.janvete.com/seth/lines"
-keywords = ["cli", "tui", "ssh", "commands"]
-categories = ["command-line-utilities"]
 
 [dependencies]
 base64 = "0.22.1"
@@ -19,15 +12,3 @@ directories = "6.0.0"
 ratatui = "0.30.1"
 toml = "1.1.2"
 walkdir = "2.5.0"
-
-
-[package.metadata.deb]
-maintainer = "janvete <jan.vete@example.com>"
-copyright = "2026, janvete"
-extended-description = "TUI application for quickly running frequently used commands from markdown files."
-section = "utils"
-priority = "optional"
-assets = [
-    ["target/release/lines", "usr/bin/lines", "755"],
-    ["README.md", "usr/share/doc/lines/README.md", "644"],
-]

README.md

@@ -4,27 +4,11 @@ A TUI app for quickly running frequently used commands — ideal for SSH scripts
 
 ## Installation
 
-### macOS (Homebrew)
-
 ```bash
-brew tap janvete/tools https://git.janvete.com/seth/homebrew-tools.git
+brew tap janvete/tools
 brew install lines
 ```
 
-### Debian / Ubuntu (APT)
-
-```bash
-echo "deb [trusted=yes] https://git.janvete.com/seth/apt/raw/branch/main ./" | sudo tee /etc/apt/sources.list.d/janvete.list
-sudo apt update
-sudo apt install lines
-```
-
-### From source
-
-```bash
-cargo install --git ssh://git@git-ssh.janvete.com:554/seth/lines
-```
-
 ## Usage
 
 ```bash
@@ -84,7 +68,6 @@ The default terminal is `Terminal` (macOS Terminal.app). The default shell is de
 | `↑/↓` or `j/k` | move |
 | `←/→` or `h/l` | switch panel |
 | `Enter` | run selected command / all commands in the current terminal |
-| `/` | open global search across all commands |
 | `o` | open selected command / all commands in a new terminal window |
 | `c` | open custom command mode for the current file |
 | `e` | open current `.md` file in `$EDITOR` |
@@ -121,12 +104,6 @@ Use `{}` as a placeholder if your lines are just addresses:
 ssh {} lsblk
 ```
 
-Variables like `$HOME` or `$USER` are treated as remote-shell variables, so they are expanded on the target host, not by your local shell.
-
-## Global search
-
-Press `/` to search across all commands, files, groups, and section names. Type your query, use `↑/↓` to select a result, and press `Enter` to run it.
-
 ## History
 
 Every command run through `lines` is appended to `~/.lines/history.log`:

src/app.rs

@@ -1,7 +1,5 @@
 use std::path::PathBuf;
 
-use ratatui::widgets::ListState;
-
 use crate::config::Terminal;
 use crate::parser::{load_groups, CommandFile, Group, Section};
 
@@ -9,23 +7,6 @@ use crate::parser::{load_groups, CommandFile, Group, Section};
 pub enum Screen {
     Main,
     Custom,
-    Search,
-}
-
-#[derive(Debug, Clone)]
-pub struct SearchResult {
-    pub group: String,
-    pub file: String,
-    pub section: String,
-    pub command: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct SearchState {
-    pub query: String,
-    pub results: Vec<SearchResult>,
-    pub cursor: usize,
-    pub list_state: ListState,
 }
 
 #[derive(Debug, Clone)]
@@ -40,7 +21,6 @@ pub struct PendingCommand {
 pub enum CustomFocus {
     Lines,
     Input,
-    PreCommand,
 }
 
 #[derive(Debug, Clone)]
@@ -56,8 +36,6 @@ pub struct CustomState {
     pub cursor: usize,
     pub focus: CustomFocus,
     pub command: String,
-    pub pre_command: String,
-    pub list_state: ListState,
 }
 
 impl CustomState {
@@ -75,16 +53,12 @@ impl CustomState {
             }
         }
         let selected = vec![false; lines.len()];
-        let mut list_state = ListState::default();
-        list_state.select(Some(0));
         CustomState {
             lines,
             selected,
             cursor: 0,
             focus: CustomFocus::Lines,
             command: String::new(),
-            pre_command: String::new(),
-            list_state,
         }
     }
 
@@ -118,22 +92,12 @@ impl CustomState {
             .collect()
     }
 
-    pub fn cycle_focus(&mut self) {
-        self.focus = match self.focus {
-            CustomFocus::Lines => CustomFocus::Input,
-            CustomFocus::Input => CustomFocus::PreCommand,
-            CustomFocus::PreCommand => CustomFocus::Lines,
-        };
+    pub fn focus_input(&mut self) {
+        self.focus = CustomFocus::Input;
     }
 
-    pub fn toggle_all(&mut self) {
-        if self.lines.is_empty() {
-            return;
-        }
-        let all_selected = self.selected.iter().all(|s| *s);
-        for s in &mut self.selected {
-            *s = !all_selected;
-        }
+    pub fn focus_lines(&mut self) {
+        self.focus = CustomFocus::Lines;
     }
 }
 
@@ -155,23 +119,13 @@ pub struct App {
     pub focus: Focus,
     pub screen: Screen,
     pub custom_state: Option<CustomState>,
-    pub search_state: Option<SearchState>,
     pub pending_command: Option<PendingCommand>,
     pub message: Option<String>,
-    pub group_list_state: ListState,
-    pub file_list_state: ListState,
-    pub section_list_state: ListState,
 }
 
 impl App {
     pub fn new(data_dir: PathBuf, terminal: Terminal, shell: String) -> Self {
         let groups = load_groups(&data_dir);
-        let mut group_list_state = ListState::default();
-        let mut file_list_state = ListState::default();
-        let mut section_list_state = ListState::default();
-        group_list_state.select(Some(0));
-        file_list_state.select(Some(0));
-        section_list_state.select(Some(0));
         App {
             data_dir,
             terminal,
@@ -183,12 +137,8 @@ impl App {
             focus: Focus::Groups,
             screen: Screen::Main,
             custom_state: None,
-            search_state: None,
             pending_command: None,
             message: None,
-            group_list_state,
-            file_list_state,
-            section_list_state,
         }
     }
 
@@ -211,40 +161,6 @@ impl App {
         self.custom_state = None;
     }
 
-    pub fn enter_search(&mut self) {
-        let results = build_search_index(&self.groups);
-        let mut list_state = ListState::default();
-        list_state.select(Some(0));
-        self.search_state = Some(SearchState {
-            query: String::new(),
-            results,
-            cursor: 0,
-            list_state,
-        });
-        self.screen = Screen::Search;
-    }
-
-    pub fn exit_search(&mut self) {
-        self.screen = Screen::Main;
-        self.search_state = None;
-    }
-
-    pub fn update_search(&mut self) {
-        if let Some(state) = self.search_state.as_mut() {
-            let query = state.query.to_lowercase();
-            state.results = build_search_index(&self.groups)
-                .into_iter()
-                .filter(|r| {
-                    r.group.to_lowercase().contains(&query)
-                        || r.file.to_lowercase().contains(&query)
-                        || r.section.to_lowercase().contains(&query)
-                        || r.command.to_lowercase().contains(&query)
-                })
-                .collect();
-            state.cursor = state.cursor.min(state.results.len().saturating_sub(1));
-        }
-    }
-
     pub fn current_group(&self) -> Option<&Group> {
         self.groups.get(self.group_index)
     }
@@ -337,25 +253,3 @@ impl App {
         };
     }
 }
-
-fn build_search_index(groups: &[Group]) -> Vec<SearchResult> {
-    let mut results = Vec::new();
-    for group in groups {
-        for file in &group.files {
-            for section in &file.sections {
-                if section.is_run_all() {
-                    continue;
-                }
-                for command in &section.commands {
-                    results.push(SearchResult {
-                        group: group.name.clone(),
-                        file: file.name.clone(),
-                        section: section.title.clone(),
-                        command: command.clone(),
-                    });
-                }
-            }
-        }
-    }
-    results
-}

src/custom.rs

@@ -2,9 +2,7 @@ use crate::app::CustomState;
 
 pub fn build_commands(state: &CustomState) -> Vec<String> {
     let command = state.command.trim();
-    let pre_command = state.pre_command.trim();
-
-    if command.is_empty() && pre_command.is_empty() {
+    if command.is_empty() {
         return Vec::new();
     }
 
@@ -13,53 +11,25 @@ pub fn build_commands(state: &CustomState) -> Vec<String> {
         return Vec::new();
     }
 
-    let prefix = if pre_command.is_empty() {
-        String::new()
-    } else {
-        format!("{} ", pre_command)
-    };
-
     selected
         .iter()
         .map(|line| {
             let line = line.trim();
-            let built = if command.is_empty() {
-                line.to_string()
-            } else if command.contains("{}") {
-                escape_dollars(&command.replace("{}", line))
+            if command.contains("{}") {
+                command.replace("{}", line)
             } else {
-                let escaped = escape_dollars(command).replace('"', "\\\"");
-                format!("{} \"{}\"", line, escaped)
-            };
-            format!("{}{}", prefix, built)
+                format!("{} \"{}\"", line, command.replace('"', "\\\""))
+            }
         })
         .collect()
 }
 
-/// Escape `$` as `\$` unless it is already escaped, so that variables are
-/// expanded by the remote shell rather than the local one when the built
-/// command is passed to `ssh`.
-fn escape_dollars(command: &str) -> String {
-    let mut result = String::with_capacity(command.len());
-    let mut prev_backslash = false;
-    for c in command.chars() {
-        if c == '$' && !prev_backslash {
-            result.push('\\');
-        }
-        result.push(c);
-        prev_backslash = c == '\\' && !prev_backslash;
-    }
-    result
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::app::{CustomLine, CustomState};
 
-    fn make_state(lines: Vec<&str>, selected: Vec<bool>, command: &str, pre_command: &str) -> CustomState {
-        let mut list_state = ratatui::widgets::ListState::default();
-        list_state.select(Some(0));
+    fn make_state(lines: Vec<&str>, selected: Vec<bool>, command: &str) -> CustomState {
         CustomState {
             lines: lines
                 .into_iter()
@@ -72,8 +42,6 @@ mod tests {
             cursor: 0,
             focus: crate::app::CustomFocus::Lines,
             command: command.to_string(),
-            pre_command: pre_command.to_string(),
-            list_state,
         }
     }
 
@@ -83,7 +51,6 @@ mod tests {
             vec!["ssh root@ip1", "ssh root@ip2", "ssh root@ip3"],
             vec![false, true, true],
             "lsblk",
-            "",
         );
         assert_eq!(
             build_commands(&state),
@@ -93,7 +60,7 @@ mod tests {
 
     #[test]
     fn test_build_commands_placeholder() {
-        let state = make_state(vec!["root@ip1", "root@ip2"], vec![true, true], "ssh {} lsblk", "");
+        let state = make_state(vec!["root@ip1", "root@ip2"], vec![true, true], "ssh {} lsblk");
         assert_eq!(
             build_commands(&state),
             vec!["ssh root@ip1 lsblk", "ssh root@ip2 lsblk"]
@@ -102,81 +69,7 @@ mod tests {
 
     #[test]
     fn test_build_commands_empty_selection() {
-        let state = make_state(vec!["ssh root@ip1"], vec![false], "lsblk", "");
+        let state = make_state(vec!["ssh root@ip1"], vec![false], "lsblk");
         assert!(build_commands(&state).is_empty());
     }
-
-    #[test]
-    fn test_build_commands_pre_command() {
-        let state = make_state(
-            vec!["ssh root@ip1", "ssh root@ip2"],
-            vec![true, true],
-            "ping",
-            "lview",
-        );
-        assert_eq!(
-            build_commands(&state),
-            vec![
-                "lview ssh root@ip1 \"ping\"",
-                "lview ssh root@ip2 \"ping\""
-            ]
-        );
-    }
-
-    #[test]
-    fn test_build_commands_pre_command_placeholder() {
-        let state = make_state(
-            vec!["root@ip1", "root@ip2"],
-            vec![true, true],
-            "ssh {} lsblk",
-            "lview",
-        );
-        assert_eq!(
-            build_commands(&state),
-            vec!["lview ssh root@ip1 lsblk", "lview ssh root@ip2 lsblk"]
-        );
-    }
-
-    #[test]
-    fn test_build_commands_pre_command_only() {
-        let state = make_state(vec!["ssh root@ip1", "ssh root@ip2"], vec![false, true], "", "lview");
-        assert_eq!(build_commands(&state), vec!["lview ssh root@ip2"]);
-    }
-
-    #[test]
-    fn test_build_commands_escapes_dollar_variables() {
-        let state = make_state(
-            vec!["ssh root@ip1"],
-            vec![true],
-            "echo $HOME && echo $USER",
-            "",
-        );
-        assert_eq!(
-            build_commands(&state),
-            vec!["ssh root@ip1 \"echo \\$HOME && echo \\$USER\""]
-        );
-    }
-
-    #[test]
-    fn test_build_commands_preserves_already_escaped_dollars() {
-        let state = make_state(
-            vec!["ssh root@ip1"],
-            vec![true],
-            "echo \\$HOME",
-            "",
-        );
-        assert_eq!(
-            build_commands(&state),
-            vec!["ssh root@ip1 \"echo \\$HOME\""]
-        );
-    }
-
-    #[test]
-    fn test_build_commands_placeholder_escapes_dollars() {
-        let state = make_state(vec!["root@ip1"], vec![true], "ssh {} echo $HOSTNAME", "");
-        assert_eq!(
-            build_commands(&state),
-            vec!["ssh root@ip1 echo \\$HOSTNAME"]
-        );
-    }
 }

src/events.rs

@@ -1,25 +1,21 @@
-use crossterm::event::{self, Event, KeyCode, KeyEventKind, MouseEventKind};
+use crossterm::event::{self, Event, KeyCode, KeyEventKind};
 use std::io;
 use std::time::Duration;
 
-use crate::app::{App, CustomFocus, CustomState, PendingCommand, Screen};
+use crate::app::{App, CustomFocus, PendingCommand, Screen};
 use crate::commands::{edit_file, run_section};
 use crate::custom::build_commands;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AppEvent {
     Tick,
     Key(event::KeyEvent),
-    Mouse(event::MouseEvent),
-    Paste(String),
 }
 
 pub fn poll_event(timeout: Duration) -> io::Result<Option<AppEvent>> {
     if event::poll(timeout)? {
         match event::read()? {
             Event::Key(key) => Ok(Some(AppEvent::Key(key))),
-            Event::Mouse(mouse) => Ok(Some(AppEvent::Mouse(mouse))),
-            Event::Paste(text) => Ok(Some(AppEvent::Paste(text))),
             _ => Ok(Some(AppEvent::Tick)),
         }
     } else {
@@ -38,51 +34,6 @@ pub fn handle_event(app: &mut App, event: AppEvent) -> bool {
             match app.screen {
                 Screen::Main => handle_main_event(app, key),
                 Screen::Custom => handle_custom_event(app, key),
-                Screen::Search => handle_search_event(app, key),
-            }
-        }
-        AppEvent::Mouse(mouse) => match mouse.kind {
-            MouseEventKind::ScrollDown => {
-                scroll_down(app);
-                true
-            }
-            MouseEventKind::ScrollUp => {
-                scroll_up(app);
-                true
-            }
-            _ => true,
-        },
-        AppEvent::Paste(text) => handle_paste_event(app, &text),
-    }
-}
-
-fn scroll_down(app: &mut App) {
-    match app.screen {
-        Screen::Main => app.next(),
-        Screen::Custom => {
-            if let Some(state) = app.custom_state.as_mut() {
-                state.next();
-            }
-        }
-        Screen::Search => {
-            if let Some(state) = app.search_state.as_mut() && !state.results.is_empty() {
-                state.cursor = (state.cursor + 1) % state.results.len();
-            }
-        }
-    }
-}
-
-fn scroll_up(app: &mut App) {
-    match app.screen {
-        Screen::Main => app.previous(),
-        Screen::Custom => {
-            if let Some(state) = app.custom_state.as_mut() {
-                state.previous();
-            }
-        }
-        Screen::Search => {
-            if let Some(state) = app.search_state.as_mut() && !state.results.is_empty() {
-                state.cursor = state.cursor.checked_sub(1).unwrap_or(state.results.len() - 1);
             }
         }
     }
@@ -104,9 +55,6 @@ fn handle_main_event(app: &mut App, key: event::KeyEvent) -> bool {
         KeyCode::Char('c') => {
             app.enter_custom();
         }
-        KeyCode::Char('/') => {
-            app.enter_search();
-        }
         KeyCode::Char('o') => {
             if let (Some(section), Some(file), Some(group)) =
                 (app.current_section(), app.current_file(), app.current_group())
@@ -163,7 +111,11 @@ fn handle_custom_event(app: &mut App, key: event::KeyEvent) -> bool {
             app.exit_custom();
         }
         KeyCode::Tab => {
-            state.cycle_focus();
+            if state.focus == CustomFocus::Lines {
+                state.focus_input();
+            } else {
+                state.focus_lines();
+            }
         }
         KeyCode::Down => {
             if state.focus == CustomFocus::Lines {
@@ -179,21 +131,14 @@ fn handle_custom_event(app: &mut App, key: event::KeyEvent) -> bool {
             if state.focus == CustomFocus::Lines {
                 state.toggle();
             } else {
-                push_to_active_input(state, ' ');
-            }
-        }
-        KeyCode::Char('a') => {
-            if state.focus == CustomFocus::Lines {
-                state.toggle_all();
-            } else {
-                push_to_active_input(state, 'a');
+                state.command.push(' ');
             }
         }
         KeyCode::Backspace => {
-            pop_from_active_input(state);
+            state.command.pop();
         }
         KeyCode::Enter => {
-            if state.focus == CustomFocus::Input || state.focus == CustomFocus::PreCommand {
+            if state.focus == CustomFocus::Input {
                 let commands = build_commands(state);
                 if !commands.is_empty()
                     && let (Some(file), Some(group)) = (app.current_file(), app.current_group())
@@ -207,108 +152,11 @@ fn handle_custom_event(app: &mut App, key: event::KeyEvent) -> bool {
                     return false;
                 }
             } else {
-                state.focus = CustomFocus::Input;
+                state.focus_input();
             }
         }
         KeyCode::Char(c) => {
-            if state.focus == CustomFocus::Lines {
             state.command.push(c);
-            } else {
-                push_to_active_input(state, c);
-            }
-        }
-        _ => {}
-    }
-    true
-}
-
-fn push_to_active_input(state: &mut CustomState, c: char) {
-    match state.focus {
-        CustomFocus::Input => state.command.push(c),
-        CustomFocus::PreCommand => state.pre_command.push(c),
-        CustomFocus::Lines => {}
-    }
-}
-
-fn pop_from_active_input(state: &mut CustomState) {
-    match state.focus {
-        CustomFocus::Input => {
-            state.command.pop();
-        }
-        CustomFocus::PreCommand => {
-            state.pre_command.pop();
-        }
-        CustomFocus::Lines => {}
-    }
-}
-
-fn handle_paste_event(app: &mut App, text: &str) -> bool {
-    match app.screen {
-        Screen::Main => true,
-        Screen::Custom => {
-            let Some(state) = app.custom_state.as_mut() else {
-                app.exit_custom();
-                return true;
-            };
-            match state.focus {
-                CustomFocus::Input => state.command.push_str(text),
-                CustomFocus::PreCommand => state.pre_command.push_str(text),
-                CustomFocus::Lines => {}
-            }
-            true
-        }
-        Screen::Search => {
-            let Some(state) = app.search_state.as_mut() else {
-                app.exit_search();
-                return true;
-            };
-            // Search queries are single-line; keep only the first pasted line.
-            let query = text.lines().next().unwrap_or(text);
-            state.query.push_str(query);
-            app.update_search();
-            true
-        }
-    }
-}
-
-fn handle_search_event(app: &mut App, key: event::KeyEvent) -> bool {
-    let Some(state) = app.search_state.as_mut() else {
-        app.exit_search();
-        return true;
-    };
-
-    match key.code {
-        KeyCode::Esc | KeyCode::Char('q') => {
-            app.exit_search();
-        }
-        KeyCode::Down => {
-            if !state.results.is_empty() {
-                state.cursor = (state.cursor + 1) % state.results.len();
-            }
-        }
-        KeyCode::Up => {
-            if !state.results.is_empty() {
-                state.cursor = state.cursor.checked_sub(1).unwrap_or(state.results.len() - 1);
-            }
-        }
-        KeyCode::Backspace => {
-            state.query.pop();
-            app.update_search();
-        }
-        KeyCode::Enter => {
-            if let Some(result) = state.results.get(state.cursor) {
-                app.pending_command = Some(PendingCommand {
-                    group: result.group.clone(),
-                    file: result.file.clone(),
-                    section: result.section.clone(),
-                    commands: vec![result.command.clone()],
-                });
-                return false;
-            }
-        }
-        KeyCode::Char(c) => {
-            state.query.push(c);
-            app.update_search();
         }
         _ => {}
     }

src/main.rs

@@ -14,9 +14,7 @@ use std::time::Duration;
 
 use clap::Parser;
 use crossterm::{
-    event::{
-        DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
-    },
+    event::{DisableMouseCapture, EnableMouseCapture},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
@@ -56,12 +54,7 @@ fn main() -> io::Result<()> {
 
     enable_raw_mode()?;
     let mut stdout = io::stdout();
-    execute!(
-        stdout,
-        EnterAlternateScreen,
-        EnableMouseCapture,
-        EnableBracketedPaste
-    )?;
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
@@ -71,8 +64,7 @@ fn main() -> io::Result<()> {
     execute!(
         terminal.backend_mut(),
         LeaveAlternateScreen,
-        DisableMouseCapture,
-        DisableBracketedPaste
+        DisableMouseCapture
     )?;
     terminal.show_cursor()?;
 
@@ -98,7 +90,7 @@ where
     let tick_rate = Duration::from_millis(100);
 
     loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
+        terminal.draw(|f| ui::draw(f, &app))?;
 
         if let Some(event) = poll_event(tick_rate)?
             && !handle_event(&mut app, event)

src/ui.rs

@@ -8,15 +8,14 @@ use ratatui::{
 
 use crate::app::{App, CustomFocus, Focus, Screen};
 
-pub fn draw(f: &mut Frame, app: &mut App) {
+pub fn draw(f: &mut Frame, app: &App) {
     match app.screen {
         Screen::Main => draw_main(f, app),
         Screen::Custom => draw_custom(f, app),
-        Screen::Search => draw_search(f, app),
     }
 }
 
-fn draw_main(f: &mut Frame, app: &mut App) {
+fn draw_main(f: &mut Frame, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .margin(1)
@@ -43,19 +42,18 @@ fn draw_main(f: &mut Frame, app: &mut App) {
     draw_status(f, app, chunks[2]);
 }
 
-fn draw_custom(f: &mut Frame, app: &mut App) {
+fn draw_custom(f: &mut Frame, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .margin(1)
         .constraints([
             Constraint::Min(5),
-            Constraint::Length(5),
-            Constraint::Length(5),
+            Constraint::Length(3),
             Constraint::Length(1),
         ])
         .split(f.area());
 
-    let Some(state) = app.custom_state.as_mut() else {
+    let Some(state) = app.custom_state.as_ref() else {
         return;
     };
 
@@ -95,8 +93,7 @@ fn draw_custom(f: &mut Frame, app: &mut App) {
             Style::default().fg(Color::DarkGray)
         });
     let list = List::new(items).block(list_block);
-    state.list_state.select(Some(state.cursor));
-    f.render_stateful_widget(list, chunks[0], &mut state.list_state);
+    f.render_widget(list, chunks[0]);
 
     let input = Paragraph::new(state.command.as_str())
         .block(
@@ -112,99 +109,16 @@ fn draw_custom(f: &mut Frame, app: &mut App) {
         .wrap(Wrap { trim: true });
     f.render_widget(input, chunks[1]);
 
-    let pre_command = Paragraph::new(state.pre_command.as_str())
-        .block(
-            Block::default()
-                .title(" Pre-command ")
-                .borders(Borders::ALL)
-                .border_style(if state.focus == CustomFocus::PreCommand {
-                    Style::default().fg(Color::Yellow)
-                } else {
-                    Style::default().fg(Color::DarkGray)
-                }),
-        )
-        .wrap(Wrap { trim: true });
-    f.render_widget(pre_command, chunks[2]);
-
-    let help = "↑/↓: move | Space: toggle | a: select all | Tab: focus | Enter: run | Esc: back | scroll: move";
+    let help = "↑/↓: move | Tab: focus | Space: toggle / space | Enter: run | Esc: back";
     let text = match &app.message {
         Some(msg) => Text::from(msg.as_str()),
         None => Text::from(help),
     };
     let paragraph = Paragraph::new(text).style(Style::default().fg(Color::Gray));
-    f.render_widget(paragraph, chunks[3]);
+    f.render_widget(paragraph, chunks[2]);
 }
 
-fn draw_search(f: &mut Frame, app: &mut App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(1)
-        .constraints([
-            Constraint::Length(3),
-            Constraint::Min(5),
-            Constraint::Length(1),
-        ])
-        .split(f.area());
-
-    let Some(state) = app.search_state.as_mut() else {
-        return;
-    };
-
-    let input = Paragraph::new(state.query.as_str())
-        .block(
-            Block::default()
-                .title(" Search ")
-                .borders(Borders::ALL)
-                .border_style(Style::default().fg(Color::Yellow)),
-        )
-        .wrap(Wrap { trim: true });
-    f.render_widget(input, chunks[0]);
-
-    let items: Vec<ListItem> = state
-        .results
-        .iter()
-        .enumerate()
-        .map(|(i, result)| {
-            let style = if i == state.cursor {
-                Style::default()
-                    .bg(Color::Blue)
-                    .fg(Color::Black)
-                    .add_modifier(Modifier::BOLD)
-            } else {
-                Style::default()
-            };
-            let label = if result.command.is_empty() {
-                format!("[{}] {} — {}", result.group, result.file, result.section)
-            } else {
-                format!(
-                    "[{}] {} — {} — {}",
-                    result.group, result.file, result.section, result.command
-                )
-            };
-            ListItem::new(label).style(style)
-        })
-        .collect();
-
-    let list = List::new(items).block(
-        Block::default()
-            .title(format!(" Results ({}) ", state.results.len()))
-            .borders(Borders::ALL),
-    );
-    state.list_state.select(Some(state.cursor));
-    f.render_stateful_widget(list, chunks[1], &mut state.list_state);
-
-    let preview_text = state
-        .results
-        .get(state.cursor)
-        .map(|r| Text::from(r.command.as_str()))
-        .unwrap_or_else(|| Text::from("No result selected."));
-    let preview = Paragraph::new(preview_text)
-        .block(Block::default().title(" Preview ").borders(Borders::ALL))
-        .wrap(Wrap { trim: true });
-    f.render_widget(preview, chunks[2]);
-}
-
-fn draw_groups(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
+fn draw_groups(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
     let items: Vec<ListItem> = app
         .groups
         .iter()
@@ -228,11 +142,10 @@ fn draw_groups(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
         .border_style(border_style(app.focus == Focus::Groups));
 
     let list = List::new(items).block(block);
-    app.group_list_state.select(Some(app.group_index));
-    f.render_stateful_widget(list, area, &mut app.group_list_state);
+    f.render_widget(list, area);
 }
 
-fn draw_files(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
+fn draw_files(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
     let items: Vec<ListItem> = app
         .current_files()
         .iter()
@@ -256,11 +169,10 @@ fn draw_files(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
         .border_style(border_style(app.focus == Focus::Files));
 
     let list = List::new(items).block(block);
-    app.file_list_state.select(Some(app.file_index));
-    f.render_stateful_widget(list, area, &mut app.file_list_state);
+    f.render_widget(list, area);
 }
 
-fn draw_sections(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
+fn draw_sections(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
     let items: Vec<ListItem> = app
         .current_sections()
         .iter()
@@ -289,8 +201,7 @@ fn draw_sections(f: &mut Frame, app: &mut App, area: ratatui::layout::Rect) {
         .border_style(border_style(app.focus == Focus::Sections));
 
     let list = List::new(items).block(block);
-    app.section_list_state.select(Some(app.section_index));
-    f.render_stateful_widget(list, area, &mut app.section_list_state);
+    f.render_widget(list, area);
 }
 
 fn draw_preview(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
@@ -345,7 +256,7 @@ fn draw_preview(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
 }
 
 fn draw_status(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
-    let help = "↑/↓: move | →/←: panel | Enter: run | /: search | o: new window | c: custom | e: edit | r: reload | q: quit";
+    let help = "↑/↓: move | →/←: panel | Enter: run | o: new window | c: custom | e: edit | r: reload | q: quit";
     let text = match &app.message {
         Some(msg) => Text::from(msg.as_str()),
         None => Text::from(help),