docs: update README.md

.github/copilot-instructions.md

@@ -0,0 +1,426 @@
+# GitHub Copilot Instructions for Go + Bubble Tea (TUI)
+
+These project-level instructions tell Copilot how to generate idiomatic, production-quality Go code using the Bubble Tea ecosystem. **Follow and prefer these rules over generic patterns.**
+
+---
+
+## 1) Project Scope & Goals
+
+* Build terminal UIs with **[Bubble Tea](https://github.com/charmbracelet/bubbletea)** and **Bubbles** components.
+* Use **Lip Gloss** for styling and **Huh**/**Bubbles forms** for prompts where useful.
+* Favor **small, composable models** and **message-driven state**.
+* Prioritize **maintainability, testability, and clear separation** of update vs. view.
+
+---
+
+## 2) Go Conventions to Prefer
+
+* Go version: **1.22+**.
+* Module: `go.mod` with minimal, pinned dependencies; use `go get -u` only deliberately.
+* Code style: `gofmt`, `go vet`, `staticcheck` (when available), `golangci-lint`.
+* Names: short, meaningful; exported symbols require GoDoc comments.
+* Errors: return wrapped errors with `%w` and `errors.Is/As`. No panics for flow control.
+* Concurrency: use `context.Context` and `errgroup` where applicable. Avoid goroutine leaks; cancel contexts in `Quit`/`Stop`.
+* Testing: `*_test.go`, table-driven tests, golden tests for `View()` when helpful.
+* Logging: prefer structured logs (e.g., `slog`) and keep logs separate from UI rendering.
+
+---
+
+## 3) Bubble Tea Architecture Rules
+
+### 3.1 Model layout
+
+```go
+// Model holds all state needed to render and update.
+type Model struct {
+    width, height int
+    ready        bool
+
+    // Domain state
+    items   []Item
+    cursor  int
+    err     error
+
+    // Child components
+    list    list.Model
+    spinner spinner.Model
+
+    // Styles
+    styles  Styles
+}
+```
+
+**Guidelines**
+
+* Keep **domain state** (data) separate from **UI components** (Bubbles models) and **styles**.
+* Add a `Styles` struct to centralize Lip Gloss styles; initialize once.
+* Track terminal size (`width`, `height`); re-calc layout on `tea.WindowSizeMsg`.
+
+### 3.2 Init
+
+* Return **batch** of startup commands for IO (e.g., loading data) and component inits.
+* Never block in `Init`; do IO in `tea.Cmd`s.
+
+```go
+func (m Model) Init() tea.Cmd {
+    return tea.Batch(m.spinner.Tick, loadItemsCmd())
+}
+```
+
+### 3.3 Update
+
+* **Pure function** style: transform `Model` + `Msg` → `(Model, Cmd)`.
+* Always handle `tea.WindowSizeMsg` to set `m.width`/`m.height` and recompute layout.
+* Use **type-switched** message handling; push side effects into `tea.Cmd`s.
+* Bubble components: call `Update(msg)` on children and **return their Cmd**.
+
+```go
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+    switch msg := msg.(type) {
+    case tea.WindowSizeMsg:
+        m.width, m.height = msg.Width, msg.Height
+        m.styles = NewStyles(m.width) // recompute if responsive
+        return m, nil
+
+    case errMsg:
+        m.err = msg
+        return m, nil
+
+    case itemsLoaded:
+        m.items = msg
+        return m, nil
+    }
+
+    // delegate to children last
+    var cmd tea.Cmd
+    m.spinner, cmd = m.spinner.Update(msg)
+    return m, cmd
+}
+```
+
+### 3.4 View
+
+* **Never** mutate state in `View()`.
+* Compose layout with Lip Gloss; gracefully handle small terminals.
+* Put errors and help at the bottom.
+
+```go
+func (m Model) View() string {
+    if !m.ready {
+        return m.styles.Loading.Render(m.spinner.View() + " Loading…")
+    }
+    main := lipgloss.JoinVertical(lipgloss.Left,
+        m.styles.Title.Render("My App"),
+        m.list.View(),
+    )
+    if m.err != nil {
+        main += "\n" + m.styles.Error.Render(m.err.Error())
+    }
+    return m.styles.App.Render(main)
+}
+```
+
+### 3.5 Messages & Commands
+
+* Define **typed messages** for domain events, not raw strings.
+* Each async operation returns a **message type**; handle errors with a dedicated `errMsg`.
+
+```go
+type itemsLoaded []Item
+
+type errMsg error
+
+func loadItemsCmd() tea.Cmd {
+    return func() tea.Msg {
+        items, err := fetchItems()
+        if err != nil { return errMsg(err) }
+        return itemsLoaded(items)
+    }
+}
+```
+
+### 3.6 Keys & Help
+
+* Centralize keybindings and help text. Prefer `bubbles/key` + `bubbles/help`.
+
+```go
+type keyMap struct {
+    Up, Down, Select, Quit key.Binding
+}
+
+var keys = keyMap{
+    Up:     key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
+    Down:   key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
+    Select: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select")),
+    Quit:   key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+}
+```
+
+Handle keys in `Update` using `key.Matches(msg, keys.X)` and show a `help.Model` in the footer.
+
+### 3.7 Submodels (Component Composition)
+
+* For complex screens, create **submodels** with their own `(Model, Init, Update, View)` and wire them into a parent.
+* Exchange messages via **custom Msg types** and/or **parent state**.
+* Keep submodels **pure**; IO still goes through parent-level `tea.Cmd`s or via submodel commands returned to parent.
+
+### 3.8 Program Options
+
+* Start programs with `tea.NewProgram(m, tea.WithOutput(os.Stdout), tea.WithAltScreen())` when full-screen; avoid AltScreen for simple tools.
+* Always handle **TTY absence** (e.g., piping); fall back to non-interactive.
+
+---
+
+## 4) Styling with Lip Gloss
+
+* Maintain a single `Styles` struct with named styles.
+* Compute widths once per resize; avoid per-cell Lip Gloss allocations in tight loops.
+* Use `lipgloss.JoinHorizontal/Vertical` for layout; avoid manual spacing where possible.
+
+```go
+type Styles struct {
+    App, Title, Error, Loading lipgloss.Style
+}
+
+func NewStyles(width int) Styles {
+    return Styles{
+        App:     lipgloss.NewStyle().Padding(1),
+        Title:   lipgloss.NewStyle().Bold(true),
+        Error:   lipgloss.NewStyle().Foreground(lipgloss.Color("9")),
+        Loading: lipgloss.NewStyle().Faint(true),
+    }
+}
+```
+
+---
+
+## 5) IO, Concurrency & Performance
+
+* **Never** perform blocking IO in `Update` directly; always return a `tea.Cmd` that does the work.
+* Use `context.Context` inside commands; respect cancellation when program exits.
+* Be careful with **goroutine leaks**: ensure commands stop when model quits.
+* Batch commands with `tea.Batch` to keep updates snappy.
+* For large lists, prefer `bubbles/list` with virtualization; avoid generating huge strings per frame.
+* Debounce high-frequency events (typing) with timer-based commands.
+
+---
+
+## 6) Error Handling & UX
+
+* Represent recoverable errors in the UI; do not exit on first error.
+* Use `errMsg` for async failures; show a concise, styled error line.
+* For fatal initialization errors, return `tea.Quit` with an explanatory message printed once.
+
+---
+
+## 7) Keys, Shortcuts, and Accessibility
+
+* Provide **discoverable shortcuts** via a footer help view.
+* Offer Emacs-style alternatives where it makes sense (e.g., `ctrl+n/p`).
+* Use consistent navigation patterns across screens.
+
+---
+
+## 8) Testing Strategy
+
+* Unit test message handling with deterministic messages.
+* Snapshot/golden-test `View()` output for known terminal sizes.
+* Fuzz-test parsers/formatters used by the UI.
+
+```go
+func TestUpdate_Select(t *testing.T) {
+    m := newTestModel()
+    _, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+    if got, want := m.cursor, 1; got != want { t.Fatalf("cursor=%d want %d", got, want) }
+}
+```
+
+---
+
+## 9) Project Structure Template
+
+```
+cmd/
+  app/
+    main.go
+internal/
+  tui/
+    model.go      // root model, styles
+    update.go     // Update + messages
+    view.go       // View
+    keys.go       // keymap/help
+    components/   // submodels
+  domain/        // business logic, pure Go
+  io/            // adapters (API, FS, net)
+
+Makefile         // lint, test, run targets
+```
+
+---
+
+## 10) Scaffolding Snippets (Ask Copilot to use these)
+
+### 10.1 Root main.go
+
+```go
+package main
+
+import (
+    "context"
+    "log"
+    "os"
+
+    tea "github.com/charmbracelet/bubbletea"
+)
+
+func main() {
+    if !isTTY() { // optional: detect piping
+        log.Println("Non-interactive mode not implemented.")
+        return
+    }
+
+    p := tea.NewProgram(NewModel(), tea.WithAltScreen())
+    if _, err := p.Run(); err != nil {
+        log.Fatalf("error: %v", err)
+    }
+}
+```
+
+### 10.2 NewModel()
+
+```go
+func NewModel() Model {
+    s := NewStyles(0)
+    return Model{
+        list:    newList(),
+        spinner: spinner.New(),
+        styles:  s,
+    }
+}
+```
+
+### 10.3 Custom messages
+
+```go
+type (
+    errMsg      error
+    itemsLoaded []Item
+)
+```
+
+### 10.4 Command helper
+
+```go
+func do(cmd func(context.Context) (tea.Msg, error)) tea.Cmd {
+    return func() tea.Msg {
+        ctx, cancel := context.WithCancel(context.Background())
+        defer cancel()
+        msg, err := cmd(ctx)
+        if err != nil { return errMsg(err) }
+        return msg
+    }
+}
+```
+
+---
+
+## 11) Dependencies to Prefer
+
+* `github.com/charmbracelet/bubbletea`
+* `github.com/charmbracelet/bubbles`
+* `github.com/charmbracelet/lipgloss`
+* `golang.org/x/sync/errgroup` (for non-UI workloads)
+* `log/slog` (Go 1.21+) for logging
+
+Pin versions in `go.mod`. Avoid extra UI deps unless justified.
+
+---
+
+## 12) Copilot Prompting Rules (Important)
+
+* When the user writes a new TUI screen, **scaffold** `(Model, Init, Update, View)` with:
+
+  * Window size handling
+  * Keymap/help wiring
+  * Styles struct and `NewStyles(width)`
+  * Commands for all IO
+* Prefer **typed messages** and return **`tea.Cmd`**; do not perform blocking work in `Update`.
+* Always update child bubble components via `child.Update(msg)` and collect cmds with `tea.Batch`.
+* Generate **tests** for key message paths.
+* Include **help footer** with keybindings.
+* Keep `View()` pure and free of side effects.
+
+**Bad**
+
+* Doing HTTP/FS work directly in `Update`.
+* Printing to stdout from `Update`/`View`.
+* Storing `context.Context` in the model.
+* Creating goroutines that outlive the program.
+
+**Good**
+
+* Commands that return typed messages.
+* Centralized keymap + help.
+* Single source of truth for styles.
+* Small submodels and composition.
+
+---
+
+## 13) Security & Reliability
+
+* Validate all external inputs; sanitize strings rendered into the terminal.
+* Respect user locale and UTF-8; avoid slicing strings by bytes for widths (use `lipgloss.Width`).
+* Handle small terminal sizes (min-width fallbacks).
+* Ensure graceful shutdown; propagate quit via `tea.Quit` and cancel pending work.
+
+---
+
+## 14) Makefile Targets (suggested)
+
+```
+.PHONY: run test lint fmt tidy
+run:; go run ./cmd/app
+fmt:; go fmt ./...
+lint:; golangci-lint run
+ test:; go test ./...
+tidy:; go mod tidy
+```
+
+---
+
+## 15) Example Key Handling Pattern
+
+```go
+case tea.KeyMsg:
+    switch {
+    case key.Matches(msg, keys.Quit):
+        return m, tea.Quit
+    case key.Matches(msg, keys.Up):
+        if m.cursor > 0 { m.cursor-- }
+    case key.Matches(msg, keys.Down):
+        if m.cursor < len(m.items)-1 { m.cursor++ }
+    }
+```
+
+---
+
+## 16) Documentation & Comments
+
+* Exported types/functions must have a sentence GoDoc.
+* At the top of each file, include a short comment describing its responsibility.
+* For non-obvious state transitions, include a brief state diagram in comments.
+
+---
+
+## 17) Acceptance Criteria for Generated Code
+
+* Builds with `go build ./...`
+* Passes `go vet` and `golangci-lint` (if configured)
+* Has at least one table-driven test per major update path
+* Handles window resize and quit
+* No side effects in `View()`
+* Commands wrap errors and return `errMsg`
+
+---
+
+*End of instructions.*

README.md

@@ -16,7 +16,11 @@
 SSHM is a beautiful command-line tool that transforms how you manage and connect to your SSH hosts. Built with Go and featuring an intuitive TUI interface, it makes SSH connection management effortless and enjoyable.
 
 <p align="center">
-    <img src="images/sshm.gif" alt="Demo SSHM Terminal" width="600" />
+    <a href="images/sshm.gif" target="_blank">
+        <img src="images/sshm.gif" alt="Demo SSHM Terminal" width="800" />
+    </a>
+    <br>
+    <em>🖱️ Click on the image to view in full size</em>
 </p>
 
 ## ✨ Features
@@ -28,6 +32,7 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect
 - **🏷️ Tag Support** - Organize your hosts with custom tags for better categorization
 - **🔍 Smart Search** - Find hosts quickly with built-in filtering and search
 - **🔒 Secure** - Works directly with your existing `~/.ssh/config` file
+- **📁 Custom Config Support** - Use any SSH configuration file with the `-c` flag
 - **⚙️ SSH Options Support** - Add any SSH configuration option through intuitive forms
 - **🔄 Automatic Conversion** - Seamlessly converts between command-line and config formats
 
@@ -85,6 +90,14 @@ sshm
 - `q` - Quit
 - `/` - Search/filter hosts
 
+**Sorting & Filtering:**
+- `s` - Switch between sorting modes (name ↔ last login)
+- `n` - Sort by **name** (alphabetical)
+- `r` - Sort by **recent** (last login time)
+- `Tab` - Cycle between filtering modes
+- Filter by **name** (default) - Search through host names
+- Filter by **last login** - Sort and filter by most recently used connections
+
 The interactive forms will guide you through configuration:
 - **Hostname/IP** - Server address
 - **Username** - SSH user
@@ -102,15 +115,24 @@ SSHM provides both command-line operations and an interactive TUI interface:
 # Launch interactive TUI mode for browsing and connecting to hosts
 sshm
 
+# Launch TUI with custom SSH config file
+sshm -c /path/to/custom/ssh_config
+
 # Add a new host using interactive form
 sshm add
 
 # Add a new host with pre-filled hostname
 sshm add hostname
 
+# Add a new host with custom SSH config file
+sshm add hostname -c /path/to/custom/ssh_config
+
 # Edit an existing host configuration
 sshm edit my-server
 
+# Edit host with custom SSH config file
+sshm edit my-server -c /path/to/custom/ssh_config
+
 # Show version information
 sshm --version
 
@@ -118,6 +140,19 @@ sshm --version
 sshm --help
 ```
 
+### Configuration File Options
+
+By default, SSHM uses the standard SSH configuration file at `~/.ssh/config`. You can specify a different configuration file using the `-c` flag:
+
+```bash
+# Use custom config file in TUI mode
+sshm -c /path/to/custom/ssh_config
+
+# Use custom config file with commands
+sshm add hostname -c /path/to/custom/ssh_config
+sshm edit hostname -c /path/to/custom/ssh_config
+```
+
 ## 🏗️ Configuration
 
 SSHM works directly with your standard SSH configuration file (`~/.ssh/config`). It adds special comment tags for enhanced functionality while maintaining full compatibility with standard SSH tools.
@@ -222,24 +257,44 @@ go build -o sshm .
 
 ```
 sshm/
-├── cmd/                 # CLI commands (Cobra)
+├── main.go             # Application entry point
+├── cmd/                # CLI commands (Cobra)
 │   ├── root.go         # Root command and interactive mode
 │   ├── add.go          # Add host command
-│   └── edit.go         # Edit host command
+│   ├── edit.go         # Edit host command
+│   └── search.go       # Search command
 ├── internal/
 │   ├── config/         # SSH configuration management
 │   │   └── ssh.go      # Config parsing and manipulation
-│   ├── ui/             # Terminal UI components
-│   │   ├── tui.go      # Main TUI interface
-│   │   ├── add_form.go # Add host form
-│   │   └── edit_form.go# Edit host form
+│   ├── history/        # Connection history tracking
+│   │   └── history.go  # History management and last login tracking
+│   ├── ui/             # Terminal UI components (Bubble Tea)
+│   │   ├── tui.go      # Main TUI interface and program setup
+│   │   ├── model.go    # Core TUI model and state
+│   │   ├── update.go   # Message handling and state updates
+│   │   ├── view.go     # UI rendering and layout
+│   │   ├── table.go    # Host list table component
+│   │   ├── add_form.go # Add host form interface
+│   │   ├── edit_form.go# Edit host form interface
+│   │   ├── styles.go   # Lip Gloss styling definitions
+│   │   ├── sort.go     # Sorting and filtering logic
+│   │   └── utils.go    # UI utility functions
 │   └── validation/     # Input validation
 │       └── ssh.go      # SSH config validation
+├── images/             # Documentation assets
+│   ├── logo.png        # Project logo
+│   └── sshm.gif        # Demo animation
 ├── install/            # Installation scripts
 │   ├── unix.sh         # Unix/Linux/macOS installer
 │   └── README.md       # Installation guide
-└── .github/workflows/  # CI/CD pipelines
-    └── build.yml       # Multi-platform builds
+├── .github/            # GitHub configuration
+│   ├── copilot-instructions.md # Development guidelines
+│   └── workflows/      # CI/CD pipelines
+│       └── build.yml   # Multi-platform builds
+├── go.mod              # Go module definition
+├── go.sum              # Go module checksums
+├── LICENSE             # MIT license
+└── README.md           # Project documentation
 ```
 
 ### Dependencies

cmd/add.go

@@ -18,7 +18,7 @@ var addCmd = &cobra.Command{
 			hostname = args[0]
 		}
 
-		err := ui.RunAddForm(hostname)
+		err := ui.RunAddForm(hostname, configFile)
 		if err != nil {
 			fmt.Printf("Error adding host: %v\n", err)
 		}

cmd/edit.go

@@ -15,7 +15,7 @@ var editCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		hostname := args[0]
 
-		err := ui.RunEditForm(hostname)
+		err := ui.RunEditForm(hostname, configFile)
 		if err != nil {
 			fmt.Printf("Error editing host: %v\n", err)
 		}

cmd/root.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"strings"
 
 	"sshm/internal/config"
 	"sshm/internal/ui"
@@ -14,12 +15,20 @@ import (
 // version will be set at build time via -ldflags
 var version = "dev"
 
+// configFile holds the path to the SSH config file
+var configFile string
+
 var rootCmd = &cobra.Command{
 	Use:   "sshm",
 	Short: "SSH Manager - A modern SSH connection manager",
-	Long: `SSH Manager (sshm) is a modern command-line tool for managing SSH connections.
-It provides an interactive interface to browse and connect to your SSH hosts
-configured in your ~/.ssh/config file.`,
+	Long: `SSHM is a modern SSH manager for your terminal.
+
+Main usage:
+  Running 'sshm' (without arguments) opens the interactive TUI window to browse, search, and connect to your SSH hosts graphically.
+
+You can also use sshm in CLI mode for direct operations.
+
+Hosts are read from your ~/.ssh/config file by default.`,
 	Version: version,
 	Run: func(cmd *cobra.Command, args []string) {
 		// If no arguments provided, run interactive mode
@@ -36,7 +45,15 @@ configured in your ~/.ssh/config file.`,
 
 func runInteractiveMode() {
 	// Parse SSH configurations
-	hosts, err := config.ParseSSHConfig()
+	var hosts []config.SSHHost
+	var err error
+
+	if configFile != "" {
+		hosts, err = config.ParseSSHConfigFile(configFile)
+	} else {
+		hosts, err = config.ParseSSHConfig()
+	}
+
 	if err != nil {
 		log.Fatalf("Error reading SSH config file: %v", err)
 	}
@@ -47,12 +64,16 @@ func runInteractiveMode() {
 		var response string
 		_, err := fmt.Scanln(&response)
 		if err == nil && (response == "y" || response == "Y") {
-			err := ui.RunAddForm("")
+			err := ui.RunAddForm("", configFile)
 			if err != nil {
 				fmt.Printf("Error adding host: %v\n", err)
 			}
 			// After adding, try to reload hosts and continue if any exist
-			hosts, err = config.ParseSSHConfig()
+			if configFile != "" {
+				hosts, err = config.ParseSSHConfigFile(configFile)
+			} else {
+				hosts, err = config.ParseSSHConfig()
+			}
 			if err != nil || len(hosts) == 0 {
 				fmt.Println("No hosts available, exiting.")
 				os.Exit(1)
@@ -64,14 +85,22 @@ func runInteractiveMode() {
 	}
 
 	// Run the interactive TUI
-	if err := ui.RunInteractiveMode(hosts); err != nil {
+	if err := ui.RunInteractiveMode(hosts, configFile); err != nil {
 		log.Fatalf("Error running interactive mode: %v", err)
 	}
 }
 
 func connectToHost(hostName string) {
 	// Parse SSH configurations to verify host exists
-	hosts, err := config.ParseSSHConfig()
+	var hosts []config.SSHHost
+	var err error
+
+	if configFile != "" {
+		hosts, err = config.ParseSSHConfigFile(configFile)
+	} else {
+		hosts, err = config.ParseSSHConfig()
+	}
+
 	if err != nil {
 		log.Fatalf("Error reading SSH config file: %v", err)
 	}
@@ -93,9 +122,18 @@ func connectToHost(hostName string) {
 
 	// Connect to the host
 	fmt.Printf("Connecting to %s...\n", hostName)
+
+	// Build the SSH command with the appropriate config file
+	var sshCmd []string
+	if configFile != "" {
+		sshCmd = []string{"ssh", "-F", configFile, hostName}
+	} else {
+		sshCmd = []string{"ssh", hostName}
+	}
+
 	// Note: In a real implementation, you'd use exec.Command here
 	// For now, just print the command that would be executed
-	fmt.Printf("ssh %s\n", hostName)
+	fmt.Printf("%s\n", strings.Join(sshCmd, " "))
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -105,3 +143,8 @@ func Execute() {
 		os.Exit(1)
 	}
 }
+
+func init() {
+	// Add the config file flag
+	rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "SSH config file to use (default: ~/.ssh/config)")
+}

cmd/search.go

@@ -0,0 +1,244 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"sshm/internal/config"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	// outputFormat defines the output format (table, json, simple)
+	outputFormat string
+	// tagsOnly limits search to tags only
+	tagsOnly bool
+	// namesOnly limits search to host names only
+	namesOnly bool
+)
+
+var searchCmd = &cobra.Command{
+	Use:   "search [query]",
+	Short: "Search SSH hosts by name, hostname, or tags",
+	Long: `Search through your SSH hosts configuration by name, hostname, or tags.
+The search is case-insensitive and will match partial strings.
+
+Examples:
+  sshm search web          # Search for hosts containing "web"
+  sshm search --tags dev   # Search only in tags for "dev"
+  sshm search --names prod # Search only in host names for "prod"
+  sshm search --format json server # Output results in JSON format`,
+	Args: cobra.MaximumNArgs(1),
+	Run:  runSearch,
+}
+
+func runSearch(cmd *cobra.Command, args []string) {
+	// Parse SSH configurations
+	var hosts []config.SSHHost
+	var err error
+
+	if configFile != "" {
+		hosts, err = config.ParseSSHConfigFile(configFile)
+	} else {
+		hosts, err = config.ParseSSHConfig()
+	}
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error reading SSH config file: %v\n", err)
+		os.Exit(1)
+	}
+
+	if len(hosts) == 0 {
+		fmt.Println("No SSH hosts found in your configuration file.")
+		os.Exit(1)
+	}
+
+	// Get search query
+	var query string
+	if len(args) > 0 {
+		query = args[0]
+	}
+
+	// Filter hosts based on search criteria
+	filteredHosts := filterHosts(hosts, query, tagsOnly, namesOnly)
+
+	// Display results
+	if len(filteredHosts) == 0 {
+		if query == "" {
+			fmt.Println("No hosts found.")
+		} else {
+			fmt.Printf("No hosts found matching '%s'.\n", query)
+		}
+		return
+	}
+
+	// Output results in specified format
+	switch outputFormat {
+	case "json":
+		outputJSON(filteredHosts)
+	case "simple":
+		outputSimple(filteredHosts)
+	default:
+		outputTable(filteredHosts)
+	}
+}
+
+// filterHosts filters hosts according to the search query and options
+func filterHosts(hosts []config.SSHHost, query string, tagsOnly, namesOnly bool) []config.SSHHost {
+	var filtered []config.SSHHost
+
+	if query == "" {
+		return hosts
+	}
+
+	query = strings.ToLower(query)
+
+	for _, host := range hosts {
+		matched := false
+
+		// Search in names if not tags-only
+		if !tagsOnly {
+			// Check the host name
+			if strings.Contains(strings.ToLower(host.Name), query) {
+				matched = true
+			}
+
+			// Check the hostname if not names-only
+			if !namesOnly && !matched && strings.Contains(strings.ToLower(host.Hostname), query) {
+				matched = true
+			}
+		}
+
+		// Search in tags if not names-only
+		if !namesOnly && !matched {
+			for _, tag := range host.Tags {
+				if strings.Contains(strings.ToLower(tag), query) {
+					matched = true
+					break
+				}
+			}
+		}
+
+		if matched {
+			filtered = append(filtered, host)
+		}
+	}
+
+	return filtered
+}
+
+// outputTable displays results in a formatted table
+func outputTable(hosts []config.SSHHost) {
+	if len(hosts) == 0 {
+		return
+	}
+
+	// Calculate column widths
+	nameWidth := 4 // "Name"
+	hostWidth := 8 // "Hostname"
+	userWidth := 4 // "User"
+	tagsWidth := 4 // "Tags"
+
+	for _, host := range hosts {
+		if len(host.Name) > nameWidth {
+			nameWidth = len(host.Name)
+		}
+		if len(host.Hostname) > hostWidth {
+			hostWidth = len(host.Hostname)
+		}
+		if len(host.User) > userWidth {
+			userWidth = len(host.User)
+		}
+		tagsStr := strings.Join(host.Tags, ", ")
+		if len(tagsStr) > tagsWidth {
+			tagsWidth = len(tagsStr)
+		}
+	}
+
+	// Add padding
+	nameWidth += 2
+	hostWidth += 2
+	userWidth += 2
+	tagsWidth += 2
+
+	// Print header
+	fmt.Printf("%-*s %-*s %-*s %-*s\n", nameWidth, "Name", hostWidth, "Hostname", userWidth, "User", tagsWidth, "Tags")
+	fmt.Printf("%s %s %s %s\n",
+		strings.Repeat("-", nameWidth),
+		strings.Repeat("-", hostWidth),
+		strings.Repeat("-", userWidth),
+		strings.Repeat("-", tagsWidth))
+
+	// Print hosts
+	for _, host := range hosts {
+		user := host.User
+		if user == "" {
+			user = "-"
+		}
+		tags := strings.Join(host.Tags, ", ")
+		if tags == "" {
+			tags = "-"
+		}
+		fmt.Printf("%-*s %-*s %-*s %-*s\n", nameWidth, host.Name, hostWidth, host.Hostname, userWidth, user, tagsWidth, tags)
+	}
+
+	fmt.Printf("\nFound %d host(s)\n", len(hosts))
+}
+
+// outputSimple displays results in simple format (one per line)
+func outputSimple(hosts []config.SSHHost) {
+	for _, host := range hosts {
+		fmt.Println(host.Name)
+	}
+}
+
+// outputJSON displays results in JSON format
+func outputJSON(hosts []config.SSHHost) {
+	fmt.Println("[")
+	for i, host := range hosts {
+		fmt.Printf("  {\n")
+		fmt.Printf("    \"name\": \"%s\",\n", escapeJSON(host.Name))
+		fmt.Printf("    \"hostname\": \"%s\",\n", escapeJSON(host.Hostname))
+		fmt.Printf("    \"user\": \"%s\",\n", escapeJSON(host.User))
+		fmt.Printf("    \"port\": \"%s\",\n", escapeJSON(host.Port))
+		fmt.Printf("    \"identity\": \"%s\",\n", escapeJSON(host.Identity))
+		fmt.Printf("    \"proxy_jump\": \"%s\",\n", escapeJSON(host.ProxyJump))
+		fmt.Printf("    \"options\": \"%s\",\n", escapeJSON(host.Options))
+		fmt.Printf("    \"tags\": [")
+		for j, tag := range host.Tags {
+			fmt.Printf("\"%s\"", escapeJSON(tag))
+			if j < len(host.Tags)-1 {
+				fmt.Printf(", ")
+			}
+		}
+		fmt.Printf("]\n")
+		if i < len(hosts)-1 {
+			fmt.Printf("  },\n")
+		} else {
+			fmt.Printf("  }\n")
+		}
+	}
+	fmt.Println("]")
+}
+
+// escapeJSON escapes special characters for JSON output
+func escapeJSON(s string) string {
+	s = strings.ReplaceAll(s, "\\", "\\\\")
+	s = strings.ReplaceAll(s, "\"", "\\\"")
+	s = strings.ReplaceAll(s, "\n", "\\n")
+	s = strings.ReplaceAll(s, "\r", "\\r")
+	s = strings.ReplaceAll(s, "\t", "\\t")
+	return s
+}
+
+func init() {
+	// Add search command to root
+	rootCmd.AddCommand(searchCmd)
+
+	// Add flags
+	searchCmd.Flags().StringVarP(&outputFormat, "format", "f", "table", "Output format (table, json, simple)")
+	searchCmd.Flags().BoolVar(&tagsOnly, "tags", false, "Search only in tags")
+	searchCmd.Flags().BoolVar(&namesOnly, "names", false, "Search only in host names")
+}

internal/config/ssh.go

@@ -181,15 +181,18 @@ func ParseSSHConfigFile(configPath string) ([]SSHHost, error) {
 
 // AddSSHHost adds a new SSH host to the config file
 func AddSSHHost(host SSHHost) error {
-	configMutex.Lock()
-	defer configMutex.Unlock()
-
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return err
 	}
-
 	configPath := filepath.Join(homeDir, ".ssh", "config")
+	return AddSSHHostToFile(host, configPath)
+}
+
+// AddSSHHostToFile adds a new SSH host to a specific config file
+func AddSSHHostToFile(host SSHHost, configPath string) error {
+	configMutex.Lock()
+	defer configMutex.Unlock()
 
 	// Create backup before modification if file exists
 	if _, err := os.Stat(configPath); err == nil {
@@ -198,8 +201,8 @@ func AddSSHHost(host SSHHost) error {
 		}
 	}
 
-	// Check if host already exists
-	exists, err := HostExists(host.Name)
+	// Check if host already exists in the specified config file
+	exists, err := HostExistsInFile(host.Name, configPath)
 	if err != nil {
 		return err
 	}
@@ -354,6 +357,21 @@ func HostExists(hostName string) (bool, error) {
 	return false, nil
 }
 
+// HostExistsInFile checks if a host exists in a specific config file
+func HostExistsInFile(hostName string, configPath string) (bool, error) {
+	hosts, err := ParseSSHConfigFile(configPath)
+	if err != nil {
+		return false, err
+	}
+
+	for _, host := range hosts {
+		if host.Name == hostName {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
 // GetSSHHost retrieves a specific host configuration by name
 func GetSSHHost(hostName string) (*SSHHost, error) {
 	hosts, err := ParseSSHConfig()
@@ -369,17 +387,35 @@ func GetSSHHost(hostName string) (*SSHHost, error) {
 	return nil, fmt.Errorf("host '%s' not found", hostName)
 }
 
+// GetSSHHostFromFile retrieves a specific host configuration by name from a specific config file
+func GetSSHHostFromFile(hostName string, configPath string) (*SSHHost, error) {
+	hosts, err := ParseSSHConfigFile(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, host := range hosts {
+		if host.Name == hostName {
+			return &host, nil
+		}
+	}
+	return nil, fmt.Errorf("host '%s' not found", hostName)
+}
+
 // UpdateSSHHost updates an existing SSH host configuration
 func UpdateSSHHost(oldName string, newHost SSHHost) error {
-	configMutex.Lock()
-	defer configMutex.Unlock()
-
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return err
 	}
-
 	configPath := filepath.Join(homeDir, ".ssh", "config")
+	return UpdateSSHHostInFile(oldName, newHost, configPath)
+}
+
+// UpdateSSHHostInFile updates an existing SSH host configuration in a specific file
+func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) error {
+	configMutex.Lock()
+	defer configMutex.Unlock()
 
 	// Create backup before modification
 	if err := backupConfig(configPath); err != nil {
@@ -528,15 +564,18 @@ func UpdateSSHHost(oldName string, newHost SSHHost) error {
 
 // DeleteSSHHost removes an SSH host configuration from the config file
 func DeleteSSHHost(hostName string) error {
-	configMutex.Lock()
-	defer configMutex.Unlock()
-
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return err
 	}
-
 	configPath := filepath.Join(homeDir, ".ssh", "config")
+	return DeleteSSHHostFromFile(hostName, configPath)
+}
+
+// DeleteSSHHostFromFile deletes an SSH host from a specific config file
+func DeleteSSHHostFromFile(hostName, configPath string) error {
+	configMutex.Lock()
+	defer configMutex.Unlock()
 
 	// Create backup before modification
 	if err := backupConfig(configPath); err != nil {

internal/ui/add_form.go

@@ -13,17 +13,18 @@ import (
 )
 
 type addFormModel struct {
-	inputs  []textinput.Model
-	focused int
-	err     string
-	styles  Styles
-	success bool
-	width   int
-	height  int
+	inputs     []textinput.Model
+	focused    int
+	err        string
+	styles     Styles
+	success    bool
+	width      int
+	height     int
+	configFile string
 }
 
 // NewAddForm creates a new add form model
-func NewAddForm(hostname string, styles Styles, width, height int) *addFormModel {
+func NewAddForm(hostname string, styles Styles, width, height int, configFile string) *addFormModel {
 	// Get current user for default
 	currentUser, _ := user.Current()
 	defaultUser := "root"
@@ -100,11 +101,12 @@ func NewAddForm(hostname string, styles Styles, width, height int) *addFormModel
 	inputs[tagsInput].Width = 50
 
 	return &addFormModel{
-		inputs:  inputs,
-		focused: nameInput,
-		styles:  styles,
-		width:   width,
-		height:  height,
+		inputs:     inputs,
+		focused:    nameInput,
+		styles:     styles,
+		width:      width,
+		height:     height,
+		configFile: configFile,
 	}
 }
 
@@ -268,9 +270,9 @@ func (m standaloneAddForm) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 // RunAddForm provides backward compatibility for standalone add form
-func RunAddForm(hostname string) error {
+func RunAddForm(hostname string, configFile string) error {
 	styles := NewStyles(80)
-	addForm := NewAddForm(hostname, styles, 80, 24)
+	addForm := NewAddForm(hostname, styles, 80, 24, configFile)
 	m := standaloneAddForm{addForm}
 
 	p := tea.NewProgram(m, tea.WithAltScreen())
@@ -327,7 +329,12 @@ func (m *addFormModel) submitForm() tea.Cmd {
 		}
 
 		// Add to config
-		err := config.AddSSHHost(host)
+		var err error
+		if m.configFile != "" {
+			err = config.AddSSHHostToFile(host, m.configFile)
+		} else {
+			err = config.AddSSHHost(host)
+		}
 		return addFormSubmitMsg{hostname: name, err: err}
 	}
 }

internal/ui/edit_form.go

@@ -18,12 +18,21 @@ type editFormModel struct {
 	originalName string
 	width        int
 	height       int
+	configFile   string
 }
 
 // NewEditForm creates a new edit form model
-func NewEditForm(hostName string, styles Styles, width, height int) (*editFormModel, error) {
+func NewEditForm(hostName string, styles Styles, width, height int, configFile string) (*editFormModel, error) {
 	// Get the existing host configuration
-	host, err := config.GetSSHHost(hostName)
+	var host *config.SSHHost
+	var err error
+
+	if configFile != "" {
+		host, err = config.GetSSHHostFromFile(hostName, configFile)
+	} else {
+		host, err = config.GetSSHHost(hostName)
+	}
+
 	if err != nil {
 		return nil, err
 	}
@@ -93,6 +102,7 @@ func NewEditForm(hostName string, styles Styles, width, height int) (*editFormMo
 		inputs:       inputs,
 		focused:      nameInput,
 		originalName: hostName,
+		configFile:   configFile,
 		styles:       styles,
 		width:        width,
 		height:       height,
@@ -248,9 +258,9 @@ func (m standaloneEditForm) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 // RunEditForm provides backward compatibility for standalone edit form
-func RunEditForm(hostName string) error {
+func RunEditForm(hostName string, configFile string) error {
 	styles := NewStyles(80)
-	editForm, err := NewEditForm(hostName, styles, 80, 24)
+	editForm, err := NewEditForm(hostName, styles, 80, 24, configFile)
 	if err != nil {
 		return err
 	}
@@ -308,7 +318,12 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 		}
 
 		// Update the configuration
-		err := config.UpdateSSHHost(m.originalName, host)
+		var err error
+		if m.configFile != "" {
+			err = config.UpdateSSHHostInFile(m.originalName, host, m.configFile)
+		} else {
+			err = config.UpdateSSHHost(m.originalName, host)
+		}
 		return editFormSubmitMsg{hostname: name, err: err}
 	}
 }

internal/ui/model.go

@@ -48,6 +48,7 @@ type Model struct {
 	deleteHost     string
 	historyManager *history.HistoryManager
 	sortMode       SortMode
+	configFile     string // Path to the SSH config file
 
 	// View management
 	viewMode ViewMode

internal/ui/table.go

@@ -130,4 +130,119 @@ func (m *Model) updateTableRows() {
 	}
 
 	m.table.SetRows(rows)
+
+	// Update table height and columns based on current terminal size
+	m.updateTableHeight()
+	m.updateTableColumns()
+}
+
+// updateTableHeight dynamically adjusts table height based on terminal size
+func (m *Model) updateTableHeight() {
+	if !m.ready {
+		return
+	}
+
+	// Calculate dynamic table height based on terminal size
+	// Layout breakdown:
+	// - ASCII title: 5 lines (1 empty + 4 text lines)
+	// - Search bar: 1 line
+	// - Sort info: 1 line
+	// - Help text: 2 lines (multi-line text)
+	// - App margins/spacing: 2 lines
+	// Total reserved: 11 lines, mais réduisons à 7 pour forcer plus d'espace
+	reservedHeight := 7 // Réduction agressive pour tester
+	availableHeight := m.height - reservedHeight
+	hostCount := len(m.table.Rows())
+
+	// Minimum height should be at least 5 rows for usability
+	minTableHeight := 6 // 1 header + 5 data rows
+	maxTableHeight := availableHeight
+	if maxTableHeight < minTableHeight {
+		maxTableHeight = minTableHeight
+	}
+
+	tableHeight := 1 // header
+	dataRowsNeeded := hostCount
+	maxDataRows := maxTableHeight - 1 // subtract 1 for header
+
+	if dataRowsNeeded <= maxDataRows {
+		// We have enough space for all hosts
+		tableHeight += dataRowsNeeded
+	} else {
+		// We need to limit to available space
+		tableHeight += maxDataRows
+	}
+
+	// FORCE: Ajoutons une ligne supplémentaire pour résoudre le problème
+	tableHeight += 1
+
+	// Update table height
+	m.table.SetHeight(tableHeight)
+}
+
+// updateTableColumns dynamically adjusts table column widths based on terminal size
+func (m *Model) updateTableColumns() {
+	if !m.ready {
+		return
+	}
+
+	hostsToShow := m.filteredHosts
+	if hostsToShow == nil {
+		hostsToShow = m.hosts
+	}
+
+	// Calculate base column widths
+	nameWidth := calculateNameColumnWidth(hostsToShow)
+	tagsWidth := calculateTagsColumnWidth(hostsToShow)
+	lastLoginWidth := calculateLastLoginColumnWidth(hostsToShow, m.historyManager)
+
+	// Fixed column widths
+	hostnameWidth := 25
+	userWidth := 12
+	portWidth := 6
+
+	// Calculate total width needed for all columns
+	totalFixedWidth := hostnameWidth + userWidth + portWidth
+	totalVariableWidth := nameWidth + tagsWidth + lastLoginWidth
+	totalWidth := totalFixedWidth + totalVariableWidth
+
+	// Available width (accounting for table borders and padding)
+	availableWidth := m.width - 4 // 4 chars for borders and padding
+
+	// If the table is too wide, scale down the variable columns proportionally
+	if totalWidth > availableWidth {
+		excessWidth := totalWidth - availableWidth
+		variableColumnsWidth := totalVariableWidth
+
+		if variableColumnsWidth > 0 {
+			// Reduce variable columns proportionally
+			nameReduction := (excessWidth * nameWidth) / variableColumnsWidth
+			tagsReduction := (excessWidth * tagsWidth) / variableColumnsWidth
+			lastLoginReduction := excessWidth - nameReduction - tagsReduction
+
+			nameWidth = max(8, nameWidth-nameReduction)
+			tagsWidth = max(8, tagsWidth-tagsReduction)
+			lastLoginWidth = max(10, lastLoginWidth-lastLoginReduction)
+		}
+	}
+
+	// Create new columns with updated widths
+	columns := []table.Column{
+		{Title: "Name", Width: nameWidth},
+		{Title: "Hostname", Width: hostnameWidth},
+		{Title: "User", Width: userWidth},
+		{Title: "Port", Width: portWidth},
+		{Title: "Tags", Width: tagsWidth},
+		{Title: "Last Login", Width: lastLoginWidth},
+	}
+
+	m.table.SetColumns(columns)
+}
+
+// max returns the maximum of two integers
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
 }

internal/ui/tui.go

@@ -14,7 +14,7 @@ import (
 )
 
 // NewModel creates a new TUI model with the given SSH hosts
-func NewModel(hosts []config.SSHHost) Model {
+func NewModel(hosts []config.SSHHost, configFile string) Model {
 	// Initialize the history manager
 	historyManager, err := history.NewHistoryManager()
 	if err != nil {
@@ -31,6 +31,7 @@ func NewModel(hosts []config.SSHHost) Model {
 		hosts:          hosts,
 		historyManager: historyManager,
 		sortMode:       SortByName,
+		configFile:     configFile,
 		styles:         styles,
 		width:          80,
 		height:         24,
@@ -98,21 +99,12 @@ func NewModel(hosts []config.SSHHost) Model {
 		})
 	}
 
-	// Determine table height: 1 (header) + number of hosts (max 10)
-	hostCount := len(rows)
-	tableHeight := 1 // header
-	if hostCount < 10 {
-		tableHeight += hostCount
-	} else {
-		tableHeight += 10
-	}
-
-	// Create the table
+	// Create the table with initial height (will be updated on first WindowSizeMsg)
 	t := table.New(
 		table.WithColumns(columns),
 		table.WithRows(rows),
 		table.WithFocused(true),
-		table.WithHeight(tableHeight),
+		table.WithHeight(10), // Initial height, will be recalculated dynamically
 	)
 
 	// Style the table
@@ -134,12 +126,15 @@ func NewModel(hosts []config.SSHHost) Model {
 	// Initialize table styles based on initial focus state
 	m.updateTableStyles()
 
+	// The table height will be properly set on the first WindowSizeMsg
+	// when m.ready becomes true and actual terminal dimensions are known
+
 	return m
 }
 
 // RunInteractiveMode starts the interactive TUI interface
-func RunInteractiveMode(hosts []config.SSHHost) error {
-	m := NewModel(hosts)
+func RunInteractiveMode(hosts []config.SSHHost, configFile string) error {
+	m := NewModel(hosts, configFile)
 
 	// Start the application in alt screen mode for clean output
 	p := tea.NewProgram(m, tea.WithAltScreen())

internal/ui/update.go

@@ -31,6 +31,10 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.styles = NewStyles(m.width)
 		m.ready = true
 
+		// Update table height and columns based on new window size
+		m.updateTableHeight()
+		m.updateTableColumns()
+
 		// Update sub-forms if they exist
 		if m.addForm != nil {
 			m.addForm.width = m.width
@@ -53,12 +57,27 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		} else {
 			// Success: refresh hosts and return to list view
-			hosts, err := config.ParseSSHConfig()
+			var hosts []config.SSHHost
+			var err error
+
+			if m.configFile != "" {
+				hosts, err = config.ParseSSHConfigFile(m.configFile)
+			} else {
+				hosts, err = config.ParseSSHConfig()
+			}
+
 			if err != nil {
 				return m, tea.Quit
 			}
 			m.hosts = m.sortHosts(hosts)
-			m.filteredHosts = m.hosts
+
+			// Reapply search filter if there is one active
+			if m.searchInput.Value() != "" {
+				m.filteredHosts = m.filterHosts(m.searchInput.Value())
+			} else {
+				m.filteredHosts = m.hosts
+			}
+
 			m.updateTableRows()
 			m.viewMode = ViewList
 			m.addForm = nil
@@ -82,12 +101,27 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		} else {
 			// Success: refresh hosts and return to list view
-			hosts, err := config.ParseSSHConfig()
+			var hosts []config.SSHHost
+			var err error
+
+			if m.configFile != "" {
+				hosts, err = config.ParseSSHConfigFile(m.configFile)
+			} else {
+				hosts, err = config.ParseSSHConfig()
+			}
+
 			if err != nil {
 				return m, tea.Quit
 			}
 			m.hosts = m.sortHosts(hosts)
-			m.filteredHosts = m.hosts
+
+			// Reapply search filter if there is one active
+			if m.searchInput.Value() != "" {
+				m.filteredHosts = m.filterHosts(m.searchInput.Value())
+			} else {
+				m.filteredHosts = m.hosts
+			}
+
 			m.updateTableRows()
 			m.viewMode = ViewList
 			m.editForm = nil
@@ -183,7 +217,12 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			return m, nil
 		} else if m.deleteMode {
 			// Confirm deletion
-			err := config.DeleteSSHHost(m.deleteHost)
+			var err error
+			if m.configFile != "" {
+				err = config.DeleteSSHHostFromFile(m.deleteHost, m.configFile)
+			} else {
+				err = config.DeleteSSHHost(m.deleteHost)
+			}
 			if err != nil {
 				// Could display an error message here
 				m.deleteMode = false
@@ -192,8 +231,16 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				return m, nil
 			}
 			// Refresh the hosts list
-			hosts, err := config.ParseSSHConfig()
-			if err != nil {
+			var hosts []config.SSHHost
+			var parseErr error
+
+			if m.configFile != "" {
+				hosts, parseErr = config.ParseSSHConfigFile(m.configFile)
+			} else {
+				hosts, parseErr = config.ParseSSHConfig()
+			}
+
+			if parseErr != nil {
 				// Could display an error message here
 				m.deleteMode = false
 				m.deleteHost = ""
@@ -201,7 +248,14 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				return m, nil
 			}
 			m.hosts = m.sortHosts(hosts)
-			m.filteredHosts = m.hosts
+
+			// Reapply search filter if there is one active
+			if m.searchInput.Value() != "" {
+				m.filteredHosts = m.filterHosts(m.searchInput.Value())
+			} else {
+				m.filteredHosts = m.hosts
+			}
+
 			m.updateTableRows()
 			m.deleteMode = false
 			m.deleteHost = ""
@@ -222,7 +276,15 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 					}
 				}
 
-				return m, tea.ExecProcess(exec.Command("ssh", hostName), func(err error) tea.Msg {
+				// Build the SSH command with the appropriate config file
+				var sshCmd *exec.Cmd
+				if m.configFile != "" {
+					sshCmd = exec.Command("ssh", "-F", m.configFile, hostName)
+				} else {
+					sshCmd = exec.Command("ssh", hostName)
+				}
+
+				return m, tea.ExecProcess(sshCmd, func(err error) tea.Msg {
 					return tea.Quit()
 				})
 			}
@@ -233,7 +295,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			selected := m.table.SelectedRow()
 			if len(selected) > 0 {
 				hostName := selected[0] // The hostname is in the first column
-				editForm, err := NewEditForm(hostName, m.styles, m.width, m.height)
+				editForm, err := NewEditForm(hostName, m.styles, m.width, m.height, m.configFile)
 				if err != nil {
 					// Handle error - could show in UI
 					return m, nil
@@ -246,7 +308,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case "a":
 		if !m.searchMode && !m.deleteMode {
 			// Add a new host
-			m.addForm = NewAddForm("", m.styles, m.width, m.height)
+			m.addForm = NewAddForm("", m.styles, m.width, m.height, m.configFile)
 			m.viewMode = ViewAdd
 			return m, textinput.Blink
 		}

internal/ui/view.go

@@ -39,7 +39,7 @@ func (m Model) renderListView() string {
 	components = append(components, m.styles.Header.Render(asciiTitle))
 
 	// Add the search bar with the appropriate style based on focus
-	searchPrompt := "Search (/ to focus, Tab to switch): "
+	searchPrompt := "Search (/ to focus): "
 	if m.searchMode {
 		components = append(components, m.styles.SearchFocused.Render(searchPrompt+m.searchInput.View()))
 	} else {