ruby-shell 2.12.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b242a4147fbf7ac84940b1e2bc7b292541e3d99a1a063a52efa899e737e1851
-  data.tar.gz: 9c1e5298b951b939c3b85ab8831215079c43331a80805bbebab5c0cb3def5c4b
+  metadata.gz: 318b51625674f856dfa297d3b8fc8a3bf0e2fd2bb87e4f95d4184bae6e94be72
+  data.tar.gz: 03cfd00609fc1f2a011458d3a75837adfe2ac3975c38718b8fcca9998ffa22b6
 SHA512:
-  metadata.gz: dfa2498cfa54eb2b36170848c24f55026e45dbfa4926c4367efb866c45508e24beb52f841efbc08be376a8b8e4f9e0ec772c45bed479c48f6e8533107dd2b47a
-  data.tar.gz: 899f55fc361186ac32ec1a3ccf62243003a3d500a04ac5c25138a767abbad47940116511dce00c58ec40bf97d37fc092a968f5a85ddaf1943afe307770fc3a38
+  metadata.gz: 982ec206a79d08fed5b95324b356edd4069c158bef62b52cf0205906bef39f38c8e44031821cf7c4f7eec8f9162df61e186589dee240a6074ae8dc592f090393
+  data.tar.gz: b0d025d2b2a0df814b3a9239f2151bcecc66a35ca71f0f020aa360ee2b0081cecbe963e6a2124fa35993f3595652e4797760219e88a423390f6b6825e77d8207

data/README.md

@@ -33,7 +33,30 @@ Or simply `gem install ruby-shell`.
 * All colors are themeable in .rshrc (see github link for possibilities)
 * Copy current command line to primary selection (paste w/middle button) with `Ctrl-y`
 
-## NEW in v2.9.0 - AI Integration ⭐
+## NEW in v3.1.0 - Quick Wins & Polish ⭐
+* **Multiple Named Sessions**: Save/load different sessions - `:save_session "project"`, `:load_session "project"`
+* **Stats Export**: Export analytics to CSV/JSON - `:stats --csv` or `:stats --json`
+* **Session Auto-save**: Set `@session_autosave = 300` in .rshrc for automatic 5-minute saves
+* **Bookmark Import/Export**: Share bookmarks - `:bm --export bookmarks.json`, `:bm --import bookmarks.json`
+* **Bookmark Statistics**: See usage patterns - `:bm --stats` shows tag distribution and analytics
+* **Color Themes**: 6 preset themes - `:theme solarized|dracula|gruvbox|nord|monokai|default`
+* **Config Management**: `:config` shows/sets history_dedup, session_autosave, completion settings
+* **Environment Variables**: `:env` lists/sets/exports environment variables
+* **Bookmark TAB Completion**: Bookmarks appear in TAB completion alongside commands
+* **List Sessions**: `:list_sessions` shows all saved sessions with timestamps and paths
+
+## v3.0.0 - Major Feature Release ⭐⭐⭐
+* **Persistent Ruby Functions**: defun functions now save to .rshrc and persist across sessions
+* **Smart Command Suggestions**: Typo detection with "Did you mean...?" suggestions using Levenshtein distance
+* **Command Analytics**: New `:stats` command shows usage statistics, performance metrics, and most-used commands
+* **Switch Completion Caching**: Command switches from --help are cached for instant completion
+* **Enhanced Bookmarks**: Bookmark directories with tags - `:bookmark name path #tag1,tag2`
+* **Session Management**: Save and restore entire shell sessions with `:save_session` and `:load_session`
+* **Syntax Validation**: Pre-execution warnings for common mistakes, dangerous commands, and typos
+* **Option Value Completion**: TAB completion for option values like `--format=<TAB>` → json, yaml, xml
+* **Command Performance Tracking**: Automatically tracks execution time and shows slowest commands
+
+## AI Integration (v2.9.0) ⭐
 * **AI-powered command assistance**: Get help with commands using natural language
 * **`@ <question>`**: Ask questions and get AI-generated text responses
 * **`@@ <request>`**: Describe what you want to do, and AI suggests the command
@@ -73,13 +96,18 @@ Special functions/integrations:
 Special commands:
 * `:nick 'll = ls -l'` to make a command alias (ll) point to a command (ls -l)
 * `:gnick 'h = /home/me'` to make a general alias (h) point to something (/home/me)
-* `:nickdel 'name'` to delete a command nick (or use `:nick '-name'`)
-* `:gnickdel 'name'` to delete a general nick (or use `:gnick '-name'`)
-* `:nick?` will list all command nicks and general nicks (you can edit your nicks in .rshrc)
+* `:nick` lists all command nicks, `:gnick` lists general nicks (NEW in v3.0)
+* `:nick '-name'` delete a command nick, `:gnick '-name'` delete a general nick (NEW in v3.0)
 * `:history` will list the command history, while `:rmhistory` will delete the history
 * `:jobs` will list background jobs, `:fg [job_id]` brings jobs to foreground, `:bg [job_id]` resumes stopped jobs
-* `:defun 'func(args) = code'` defines Ruby functions callable as shell commands
+* `:defun 'func(args) = code'` defines Ruby functions callable as shell commands (now persistent!)
 * `:defun?` lists all user-defined functions, `:defun '-func'` removes functions
+* `:stats` shows command execution statistics and analytics (NEW in v3.0)
+* `:bm "name"` or `:bookmark "name"` bookmark current directory, `:bm "name path #tags"` with tags (NEW in v3.0)
+* `:bm` lists all bookmarks, just type bookmark name to jump (e.g., `work`) (NEW in v3.0)
+* `:bm "-name"` delete bookmark, `:bm "?tag"` search by tag (NEW in v3.0)
+* `:save_session "name"` saves named session, `:load_session "name"` loads session (NEW in v3.0)
+* `:list_sessions` shows all saved sessions, `:rmsession "name"` or `:rmsession "*"` deletes (NEW in v3.1)
 * `:info` shows introduction and feature overview
 * `:version` Shows the rsh version number and the last published gem file version
 * `:help` will display a compact command reference in two columns
@@ -109,12 +137,19 @@ Add to your `.rshrc`:
 While you `cd` around to different directories, you can see the last 10 directories visited via the command `:dirs` or the convenient shortcut `#`. Entering the number in the list (like `6` and ENTER) will jump you to that directory. Entering `-` will jump you back to the previous dir (equivalent of `1`. Entering `~` will get you to your home dir. If you want to bookmark a special directory, you can do that via a general nick like this: `:gnick "x = /path/to/a/dir/"` - this would bookmark the directory to the single letter `x`.
 
 ## Nicks
-Add command nicks (aliases) with `:nick "some_nick = some_command"`, e.g. `:nick "ls = ls --color"`. Add general nicks that will substitute anything on a command line (not just commands) like this `:gnick "some_gnick = some_command"`, e.g. `:gnick "x = /home/user/somewhere"`. List (g)nicks with `:nick?`. Remove a nick with `:nick "-some_command"`, e.g. `:nick "-ls"` to remove an `ls` nick. Same for gnicks.
+Add command nicks (aliases) with `:nick "some_nick = some_command"`, e.g. `:nick "ls = ls --color"`. Add general nicks that will substitute anything on a command line (not just commands) like this `:gnick "some_gnick = some_command"`, e.g. `:gnick "x = /home/user/somewhere"`. List nicks with `:nick`, list gnicks with `:gnick`. Remove a nick with `:nick "-some_command"`, e.g. `:nick "-ls"` to remove an `ls` nick. Same for gnicks.
 
 ## Tab completion
-You can tab complete almost anything. Hitting `TAB` will try to complete in this priority: nicks, gnicks, commands, dirs/files. Hitting `TAB`after a `-` will list the command switches for the preceding command with a short explanation (from the command's --help), like this `ls -`(`TAB`) will list all the switches/options for the `ls` command. You can add to (or subtract from) the search criteria while selecting possible matches - hit any letter to specify the search, while backspace removes a letter from the search criteria. 
+You can tab complete almost anything. Hitting `TAB` will try to complete in this priority: nicks, gnicks, commands, dirs/files. Special completions:
+- `ls -<TAB>` lists command switches from --help with descriptions
+- `:st<TAB>` completes colon commands (:stats, etc.)
+- `$HO<TAB>` completes environment variables ($HOME, etc.)
+- `git <TAB>` shows git subcommands (add, commit, push, etc.)
+- `--format=<TAB>` completes option values (json, yaml, xml, etc.)
 
-Hitting Shift-TAB will do a similar search through the command history - but with a general match of the search criteria (not only matching at the start).
+You can add to (or subtract from) the search criteria while selecting matches - hit any letter to refine the search, backspace removes a letter from the criteria.
+
+Hitting Shift-TAB will search through the command history with fuzzy matching.
 
 ## Open files
 If you press `ENTER` after writing or tab-completing to a file, rsh will try to open the file in the user's EDITOR of choice (if it is a valid text file) or use `xdg-open` to open the file using the correct program. If you, for some reason want to use `run-mailcap` instead of `xdg-open` as the file opener, simply add `@runmailcap = true` to your `.rshrc`.
@@ -185,7 +220,7 @@ Enter the command `f` to launch the fuzzy finder - select the directory/file you
 If you start a line with "=", the rest of the line will be interpreted as an XRPN program. This gives you the full power of XRPN right at your fingertips. You can do simple stuff like this: `=13,23,*,x^2` and the answer to `(13 * 23)^2` will be given (89401) in the format that you have set in your `.xrpn/conf`. Or you can do more elaborate stuff like `=fix 6,5,sto c,time,'Time now is: ',atime,aview,pse,fix 0,lbl a,rcl c,prx,dse c,gto a`. Go crazy. Use single-quotes for any Alpha entry.
 
 ## Syntax highlighting
-rsh will highlight nicks, gnicks, commands and dirs/files as they are written on the command line.
+rsh will highlight nicks, gnicks, bookmarks, commands, switches and dirs/files as they are written on the command line. Each element type has its own color (customizable in .rshrc).
 
 ## Theming
 In the supplied `.rshrc`, you will find a set of colors that you can change:
@@ -197,6 +232,9 @@ Variable        | Description
 `@c_nick`       | Color for matching nick
 `@c_gnick`      | Color for matching gnick
 `@c_path`       | Color for valid path
+`@c_switch`     | Color for command switches/options
+`@c_bookmark`   | Color for bookmarks (NEW in v3.0)
+`@c_colon`      | Color for colon commands (NEW in v3.1)
 `@c_tabselect`  | Color for selected tabcompleted item
 `@c_taboption`  | Color for unselected tabcompleted item
 `@c_stamp`      | Color for time stamp/command

data/bin/rsh

@@ -8,7 +8,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rsh
 # License:    Public domain
-@version    = "2.12.0" # Extensible command completion system for git, apt, docker, systemctl, cargo, npm, gem, bundle
+@version    = "3.1.0" # Quick wins: Multiple sessions, stats export, bookmark features, themes, config, env management
 
 # MODULES, CLASSES AND EXTENSIONS
 class String # Add coloring to strings (with escaping for Readline)
@@ -92,6 +92,8 @@ begin # Initialization
   @c_gnick     = 14                       # Color for matching gnick
   @c_path      = 3                        # Color for valid path
   @c_switch    = 6                        # Color for switches/options
+  @c_bookmark  = 13                       # Color for bookmarks
+  @c_colon     = 4                        # Color for colon commands
   @c_tabselect = 5                        # Color for selected tabcompleted item
   @c_taboption = 244                      # Color for unselected tabcompleted item
   @c_stamp     = 244                      # Color for time stamp/command
@@ -131,6 +133,19 @@ begin # Initialization
     "gem" => %w[install uninstall update list search build push],
     "bundle" => %w[install update exec check config]
   }
+  # New v3.0 features initialization
+  @switch_cache = {}                      # Cache for command switches from --help
+  @switch_cache_time = {}                 # Timestamp for cache expiry
+  @bookmarks = {}                         # Enhanced bookmarks with tags
+  @defuns = {}                            # Store defun definitions for persistence
+  @cmd_stats = {}                         # Command execution statistics
+  @session_dir = Dir.home + '/.rsh/sessions' # Sessions directory
+  @session_file = @session_dir + '/default.json' # Default session file
+  @session_autosave = 0                   # Auto-save interval (0 = disabled)
+  @session_last_save = Time.now.to_i      # Last auto-save timestamp
+  @history_dedup = 'smart'                # History dedup mode: 'off', 'full', 'smart'
+  Dir.mkdir(Dir.home + '/.rsh') unless Dir.exist?(Dir.home + '/.rsh')
+  Dir.mkdir(@session_dir) unless Dir.exist?(@session_dir)
   def pre_cmd; end                        # User-defined function to be run BEFORE command execution
   def post_cmd; end                       # User-defined function to be run AFTER  command execution
 end
@@ -138,32 +153,49 @@ end
 # HELP TEXT
 @info = <<~INFO
 
-  Hello #{@user}, welcome to rsh - the Ruby SHell. 
-  
-  rsh does not attempt to compete with the grand old shells like bash and zsh. 
-  It serves the specific needs and wants of its author. If you like it, then feel free 
+  Hello #{@user}, welcome to rsh v3.1 - the Ruby SHell.
+
+  rsh does not attempt to compete with the grand old shells like bash and zsh.
+  It serves the specific needs and wants of its author. If you like it, then feel free
   to ask for more or different features here: https://github.com/isene/rsh.
-  
-  Features:
+
+  Core Features:
   * Aliases (called nicks in rsh) - both for commands and general nicks
-  * Syntax highlighting, matching nicks, system commands and valid dirs/files
+  * Syntax highlighting for nicks, bookmarks, commands, switches and valid dirs/files
   * Tab completions for nicks, system commands, command switches and dirs/files
   * Smart context-aware tab completion for git, apt, docker, systemctl, cargo, npm, gem, bundle
-  * Tab completion presents matches in a list to pick from
-  * When you start to write a command, rsh will suggest the first match in the history and
-    present that in "toned down" letters - press the arrow right key to accept the suggestion
-  * Writing a partial command and pressing `UP` will search history for matches.
-    Go down/up in the list and press `TAB` or `ENTER` to accept, `Ctrl-g` or `Ctrl-c` to discard
-  * History with editing, search and repeat a history command (with `!`)
-  * Config file (.rshrc) updates on exit (with Ctrl-d) or not (with Ctrl-e)
-  * Set of simple rsh specific commands like nick, nick?, history and rmhistory
-  * rsh specific commands and full set of Ruby commands available via :<command>
-  * All colors are themeable in .rshrc (see github link for possibilities)
-  * Copy current command line to primary selection (paste w/middle button) with `Ctrl-y`
-  * AI integration: Use @ for text responses and @@ for command suggestions (requires ollama or OpenAI)
-  
-  Use `:help` for command reference.
-  
+  * History with editing, search and repeat (use `!` or UP arrow)
+  * Auto-suggestions from history (press RIGHT arrow to accept)
+  * Ruby functions callable as shell commands (persistent across sessions)
+  * AI integration: Use @ for text responses and @@ for command suggestions
+
+  NEW in v3.0:
+  * Command analytics - :stats shows usage patterns and performance metrics
+  * Enhanced bookmarks with tags - :bm "name path #tag1,tag2" then just type name to jump
+  * Session management - :save_session and :load_session preserve your entire shell state
+  * Smart typo detection - "Did you mean...?" suggestions for misspelled commands
+  * Switch caching - Faster TAB completion for command options
+  * Option value completion - TAB complete values like --format=json
+  * Syntax validation - Pre-execution warnings for dangerous or malformed commands
+  * Unified command syntax - :nick, :gnick, :bm all work the same way (list/create/delete)
+
+  NEW in v3.1:
+  * Multiple named sessions - :save_session "project" and :load_session "project"
+  * Stats export - :stats --csv or :stats --json for data analysis
+  * Session auto-save - Set @session_autosave = 300 in .rshrc for 5-min auto-save
+  * Bookmark import/export - :bm --export file.json and :bm --import file.json
+  * Bookmark statistics - :bm --stats shows usage patterns and tag distribution
+  * Color themes - :theme solarized|dracula|gruvbox|nord|monokai
+  * Config management - :config shows/sets history_dedup, session_autosave, etc.
+  * Environment management - :env for listing/setting/exporting environment variables
+  * Bookmark TAB completion - Bookmarks appear in TAB completion list
+  * List sessions - :list_sessions shows all saved sessions with timestamps
+
+  Config file (.rshrc) updates on exit (Ctrl-d) or not (Ctrl-e).
+  All colors are themeable in .rshrc (see github link for possibilities).
+
+  Use `:help` for complete command reference.
+
 INFO
 
 @help = <<~HELP
@@ -192,6 +224,8 @@ def firstrun
   @c_gnick     = 87   # Color for matching gnick
   @c_path      = 208  # Color for valid path
   @c_switch    = 148  # Color for switches/options
+  @c_bookmark  = 13   # Color for bookmarks
+  @c_colon     = 4    # Color for colon commands
   @c_tabselect = 207  # Color for selected tabcompleted item
   @c_taboption = 244  # Color for unselected tabcompleted item
   @c_stamp     = 244  # Color for time stamp/command
@@ -468,8 +502,10 @@ def tab(type)
     @tabstr   = @pretab if type == "hist"         # Searching for matches with whole string in history
     @pretab   = @pretab.delete_suffix(@tabstr)
   end
-  type = "switch" if @tabstr && @tabstr[0] == "-"
+  type = "switch" if @tabstr && @tabstr[0] == "-" && !@tabstr.include?("=")
+  type = "option_value" if @tabstr && @tabstr =~ /^--?[\w-]+=/
   type = "env_vars" if @tabstr && @tabstr[0] == "$"
+  type = "colon_commands" if @tabstr && @tabstr[0] == ":"
 
   # Debug output when RSH_DEBUG is set
   if ENV['RSH_DEBUG']
@@ -517,12 +553,29 @@ def tab(type)
       @tabarray.shift   # Take away @history[0]
       return if @tabarray.empty?
     when "switch"
-      cmdswitch = @pretab.split(/[|, ]/).last.to_s
-      hlp = `#{cmdswitch} --help 2>/dev/null`
-      hlp = hlp.split("\n").grep(/^\s*-{1,2}[^-]/)
-      hlp = hlp.map{|h| h.sub(/^\s*/, '').sub(/^--/, '    --')}
-      hlp = hlp.reject{|h| /-</ =~ h}
-      @tabarray = hlp
+      cmdswitch = @pretab.split(/[|, ]/).last.to_s.strip
+      @tabarray = get_command_switches(cmdswitch)
+    when "option_value"  # Completion for option values like --format=<value>
+      if @tabstr =~ /^--?[\w-]+=(.*)/
+        value_prefix = $1
+        option = @tabstr.sub(/=.*/, '')
+        # Define common option value completions
+        value_completions = {
+          /format/ => %w[json yaml xml csv plain],
+          /output/ => %w[json yaml xml text html],
+          /level|log-level/ => %w[debug info warn error fatal],
+          /color/ => %w[auto always never],
+          /type/ => %w[file dir link all]
+        }
+        matches = []
+        value_completions.each do |pattern, values|
+          if option =~ pattern
+            matches = values.select { |v| v.start_with?(value_prefix) }
+            break unless matches.empty?
+          end
+        end
+        @tabarray = matches.map { |v| "#{option}=#{v}" }
+      end
     when "dirs_only"    # Only show directories
       fdir = @tabstr + "*"
       dirs = Dir.glob(fdir).select { |d| Dir.exist?(d) }.map { |d| d + "/" }
@@ -544,12 +597,25 @@ def tab(type)
       env_vars = ENV.keys.map { |k| "$#{k}" }
       regex_flags = @completion_case_sensitive ? 0 : Regexp::IGNORECASE
       @tabarray = env_vars.select { |var| var =~ Regexp.new(@tabstr, regex_flags) }
+    when "colon_commands"  # Ruby/rsh commands starting with :
+      colon_cmds = %w[
+        :nick :gnick :bm :bookmark :stats :defun :defun?
+        :history :rmhistory :jobs :fg :bg
+        :save_session :load_session :list_sessions :delete_session :rmsession
+        :config :env :theme
+        :info :version :help
+      ]
+      search_str = @tabstr[1..-1] || ""  # Remove leading :
+      regex_flags = @completion_case_sensitive ? 0 : Regexp::IGNORECASE
+      matches = colon_cmds.select { |cmd| cmd[1..-1] =~ Regexp.new("^#{search_str}", regex_flags) }
+      @tabarray = matches
     when "all"          # Handle all other tab completions
       ex  = []
       ex += @exe
       ex.sort!
       ex.prepend(*@nick.keys)        # Add nicks
       ex.prepend(*@gnick.keys)       # Add gnicks
+      ex.prepend(*@bookmarks.keys) if @bookmarks  # Add bookmarks
 
       # Enhanced matching with case sensitivity and fuzzy support
       regex_flags = @completion_case_sensitive ? 0 : Regexp::IGNORECASE
@@ -717,10 +783,176 @@ def tabend
   @c_col = @pos0 + @pos
   @c.col(@c_col)
 end
+def get_command_switches(command) # Helper function to extract switches from --help
+  # Check cache first (cache expires after 1 hour)
+  cache_key = command.to_s.strip
+  return [] if cache_key.empty?
+
+  current_time = Time.now.to_i
+  if @switch_cache[cache_key] && @switch_cache_time[cache_key] && (current_time - @switch_cache_time[cache_key]) < 3600
+    return @switch_cache[cache_key]
+  end
+
+  # Parse --help output
+  hlp = `#{command} --help 2>/dev/null`
+  # Try -h if --help didn't work
+  hlp = `#{command} -h 2>/dev/null` if hlp.empty?
+  return [] if hlp.empty?
+
+  switches = []
+
+  # Method 1: Lines starting with switches (traditional format)
+  switches = hlp.split("\n").grep(/^\s*-{1,2}[^-]/)
+  switches.map! { |h| h.sub(/^\s*/, '').sub(/^--/, '    --') }
+  switches.reject! { |h| /-</ =~ h }
+
+  # Method 2: Extract switches from usage line (git-style format)
+  if switches.empty?
+    usage_lines = hlp.split("\n").select { |l| l =~ /usage:|Usage:/ }
+    usage_lines.each do |line|
+      # Extract all switches from the usage line
+      line.scan(/(-[a-zA-Z]|--[a-z-]+)/).each do |match|
+        switch = match[0]
+        switches << (switch.start_with?('--') ? "    #{switch}" : switch)
+      end
+    end
+    switches.uniq!
+  end
+
+  # Cache the result (even if empty, to avoid repeated failures)
+  @switch_cache[cache_key] = switches
+  @switch_cache_time[cache_key] = current_time
+
+  switches
+end
+def levenshtein_distance(s, t) # Calculate edit distance for smart suggestions
+  m = s.length
+  n = t.length
+  return m if n == 0
+  return n if m == 0
+  d = Array.new(m+1) {Array.new(n+1)}
+  (0..m).each {|i| d[i][0] = i}
+  (0..n).each {|j| d[0][j] = j}
+  (1..n).each do |j|
+    (1..m).each do |i|
+      d[i][j] = if s[i-1] == t[j-1]
+        d[i-1][j-1]
+      else
+        [d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+1].min
+      end
+    end
+  end
+  d[m][n]
+end
+def suggest_command(cmd) # Smart command suggestions for typos
+  return nil if cmd.nil? || cmd.empty?
+  return nil if @exe.include?(cmd) || @nick.include?(cmd)
+
+  # Find commands with small edit distance
+  candidates = (@exe + @nick.keys).select do |c|
+    next false if c.length < 2
+    dist = levenshtein_distance(cmd, c)
+    max_dist = [cmd.length / 3, 2].max
+    dist <= max_dist && dist > 0
+  end
+
+  return nil if candidates.empty?
+
+  # Sort by distance
+  candidates.sort_by! { |c| levenshtein_distance(cmd, c) }
+  candidates.first(3)
+end
 def hist_clean # Clean up @history
-  @history.uniq!
   @history.compact!
   @history.delete("")
+
+  # Apply deduplication based on mode
+  case @history_dedup
+  when 'off'
+    # No deduplication
+  when 'full', 'smart'
+    # Remove duplicates, keeping first (most recent) occurrence
+    @history.uniq!
+  else
+    # Default to smart
+    @history.uniq!
+  end
+end
+def config(*args) # Configure rsh settings
+  setting = args[0]
+  value = args[1]
+
+  if setting.nil?
+    # Show current configuration
+    puts "\n  Current Configuration:".c(@c_prompt).b
+    puts "    history_dedup:      #{@history_dedup}"
+    puts "    session_autosave:   #{@session_autosave}s #{@session_autosave > 0 ? '(enabled)' : '(disabled)'}"
+    puts "    completion_limit:   #{@completion_limit}"
+    puts "    completion_fuzzy:   #{@completion_fuzzy}"
+    puts "    completion_case_sensitive: #{@completion_case_sensitive}"
+    puts
+    return
+  end
+
+  case setting
+  when 'history_dedup'
+    if %w[off full smart].include?(value)
+      @history_dedup = value
+      puts "History deduplication set to '#{value}'"
+      rshrc
+    else
+      puts "Invalid value. Use: off, full, or smart"
+    end
+  when 'session_autosave'
+    @session_autosave = value.to_i
+    puts "Session auto-save set to #{value}s #{value.to_i > 0 ? '(enabled)' : '(disabled)'}"
+    rshrc
+  when 'completion_limit'
+    @completion_limit = value.to_i
+    puts "Completion limit set to #{value}"
+    rshrc
+  else
+    puts "Unknown setting '#{setting}'"
+    puts "Available: history_dedup, session_autosave, completion_limit"
+  end
+end
+def env(*args) # Environment variable management
+  arg_str = args.join(' ')
+
+  if args.empty?
+    # List all environment variables
+    puts "\n  Environment Variables:".c(@c_prompt).b
+    ENV.sort.first(20).each do |key, value|
+      value_display = value.length > 50 ? value[0..47] + '...' : value
+      puts "    #{key.c(@c_gnick).ljust(25)} = #{value_display}"
+    end
+    puts "    ... (#{ENV.length} total, showing first 20)"
+    puts "\n  Use :env \"VARNAME\" to see specific variable"
+    puts
+  elsif arg_str =~ /^set\s+(\w+)\s+(.+)$/
+    # Set environment variable
+    var_name, var_value = $1, $2
+    ENV[var_name] = var_value
+    puts "#{var_name} = #{var_value}"
+  elsif arg_str =~ /^unset\s+(\w+)$/
+    # Unset environment variable
+    var_name = $1
+    ENV.delete(var_name)
+    puts "#{var_name} unset"
+  elsif arg_str =~ /^export\s+(.+)$/
+    # Export to shell script
+    filename = $1
+    File.write(filename, ENV.map { |k,v| "export #{k}=\"#{v}\"" }.join("\n"))
+    puts "Environment exported to #{filename}"
+  else
+    # Show specific variable
+    var_name = arg_str.strip
+    if ENV[var_name]
+      puts "#{var_name} = #{ENV[var_name]}"
+    else
+      puts "Environment variable '#{var_name}' not set"
+    end
+  end
 end
 def cmd_check(str) # Check if each element on the readline matches commands, nicks, paths; color them
   return if str.nil?
@@ -729,11 +961,19 @@ def cmd_check(str) # Check if each element on the readline matches commands, nic
   if str =~ /^(@@?)\s+(.*)$/
     prefix = $1
     rest = $2
-    return prefix.c(4) + " " + rest  # Color @ or @@ in blue (4), rest uncolored
+    return prefix.c(@c_colon) + " " + rest  # Color @ or @@ in colon color
+  end
+
+  # Special handling for : commands
+  if str =~ /^(:[\w?_]+)/
+    colon_cmd = $1
+    rest = str.sub(/^:[\w?_]+/, '')
+    return colon_cmd.c(@c_colon) + rest  # Color colon commands
   end
 
   str.gsub(/(?:\S'[^']*'|[^ '])+/) do |el|
     clean_el = el.gsub("'", "")
+    # Priority: commands > nicks > bookmarks > paths
     if @exe.include?(el)
       el.c(@c_cmd)
     elsif el == "cd"
@@ -741,8 +981,6 @@ def cmd_check(str) # Check if each element on the readline matches commands, nic
     elsif clean_el =~ /^\.\/(.+)/ && File.exist?(clean_el) && File.executable?(clean_el)
       # Color local executables starting with ./
       el.c(@c_cmd)
-    elsif File.exist?(clean_el)
-      el.c(@c_path)
     elsif @nick.include?(el)
       el.c(@c_nick)
     elsif el == "r" or el == "f"
@@ -751,6 +989,11 @@ def cmd_check(str) # Check if each element on the readline matches commands, nic
       el.c(@c_gnick)
     elsif self.respond_to?(el) && singleton_class.instance_methods(false).include?(el.to_sym)
       el.c(@c_nick).b  # Ruby functions in bold nick color
+    elsif @bookmarks && @bookmarks.include?(el)
+      # Color bookmarks (after commands and nicks)
+      el.c(@c_bookmark)
+    elsif File.exist?(clean_el)
+      el.c(@c_path)
     elsif el[0] == "-"
       el.c(@c_switch)
     else
@@ -771,6 +1014,16 @@ def rshrc # Write updates to .rshrc
   conf += "@gnick = #{@gnick}\n"
   conf.sub!(/^@cmd_frequency.*(\n|$)/, "")
   conf += "@cmd_frequency = #{@cmd_frequency}\n"
+  conf.sub!(/^@cmd_stats.*(\n|$)/, "")
+  conf += "@cmd_stats = #{@cmd_stats}\n" unless @cmd_stats.empty?
+  conf.sub!(/^@bookmarks.*(\n|$)/, "")
+  conf += "@bookmarks = #{@bookmarks}\n" unless @bookmarks.empty?
+  conf.sub!(/^@defuns.*(\n|$)/, "")
+  conf += "@defuns = #{@defuns}\n" unless @defuns.empty?
+  conf.sub!(/^@history_dedup.*(\n|$)/, "")
+  conf += "@history_dedup = '#{@history_dedup}'\n" if @history_dedup && @history_dedup != 'smart'
+  conf.sub!(/^@session_autosave.*(\n|$)/, "")
+  conf += "@session_autosave = #{@session_autosave}\n" if @session_autosave && @session_autosave > 0
   # Only write @cmd_completions if user has customized it
   unless conf =~ /^@cmd_completions\s*=/
     # Don't write default completions to avoid cluttering .rshrc
@@ -807,6 +1060,7 @@ def help
   left_col << "RIGHT/Ctrl-F    Accept suggestion"
   left_col << "UP/DOWN         Navigate history"
   left_col << "TAB             Tab complete"
+  left_col << "Shift-TAB       Search history"
   left_col << "Ctrl-Y          Copy to clipboard"
   left_col << "Ctrl-D          Exit + save .rshrc"
   left_col << "Ctrl-E          Exit without save"
@@ -820,9 +1074,10 @@ def help
   left_col << "SPECIAL COMMANDS:".c(@c_prompt).b
   left_col << ":nick 'll = ls -l'  Command alias"
   left_col << ":gnick 'h = /home'  General alias"
-  left_col << ":nickdel 'name'     Delete nick"
-  left_col << ":gnickdel 'name'    Delete gnick"
-  left_col << ":nick?              List all nicks"
+  left_col << ":nick               List nicks"
+  left_col << ":gnick              List gnicks"
+  left_col << ":nick '-name'       Delete nick"
+  left_col << ":gnick '-name'      Delete gnick"
   left_col << ":history            Show history"
   left_col << ":rmhistory          Clear history"
   left_col << ":info               About rsh"
@@ -842,6 +1097,21 @@ def help
   right_col << ":fg [id]            Foreground job"
   right_col << ":bg [id]            Resume in bg"
   right_col << ""
+  right_col << "v3.0/3.1 FEATURES:".c(@c_prompt).b
+  right_col << ":stats [--csv|--json] Analytics"
+  right_col << ":bm \"name\"          Create bookmark"
+  right_col << "name                Jump to bookmark"
+  right_col << ":bm --stats         Bookmark stats"
+  right_col << ":bm --export file   Export bookmarks"
+  right_col << ":bm --import file   Import bookmarks"
+  right_col << ":save_session [nm]  Save session"
+  right_col << ":load_session [nm]  Load session"
+  right_col << ":list_sessions      List all sessions"
+  right_col << ":rmsession name|*   Delete session(s)"
+  right_col << ":theme [name]       Color presets"
+  right_col << ":config [set val]   Settings"
+  right_col << ":env [VARNAME]      Env management"
+  right_col << ""
   right_col << "INTEGRATIONS:".c(@c_prompt).b
   right_col << "r                   Launch rtfm"
   right_col << "f                   Launch fzf"
@@ -855,8 +1125,8 @@ def help
   right_col << "SMART COMPLETIONS:".c(@c_prompt).b
   right_col << "git <TAB>           Git subcommands"
   right_col << "apt/docker <TAB>    Command options"
-  right_col << "Supports: git, apt, docker,"
-  right_col << "systemctl, cargo, npm, gem"
+  right_col << "--format=<TAB>      Option values"
+  right_col << "Typo suggestions    Auto-correct"
   right_col << ""
   right_col << "EXPANSIONS:".c(@c_prompt).b
   right_col << "~                   Home directory"
@@ -899,43 +1169,47 @@ def rmhistory # Delete history
   @history = []
   puts "History deleted."
 end
-def nick(nick_str)  # Define a new nick like this: `:nick "ls = ls --color"`
-  if nick_str.match(/^\s*-/)
+def nick(nick_str = nil)  # Define a new nick like this: `:nick "ls = ls --color"`
+  if nick_str.nil? || nick_str.empty?
+    # List all nicks
+    puts "\n  Command nicks:".c(@c_nick).b
+    if @nick.empty?
+      puts "  (none defined)"
+    else
+      @nick.sort.each {|key, value| puts "  #{key.c(@c_nick)} = #{value}"}
+    end
+    puts
+  elsif nick_str.match(/^\s*-/)
     source = nick_str.sub(/^\s*-/, '')
     @nick.delete(source)
+    rshrc
   else
     source = nick_str.sub(/ =.*/, '')
     target = nick_str.sub(/.*= /, '')
     @nick[source] = target
+    rshrc
   end
-  rshrc
 end
-def gnick(nick_str) # Define a generic/global nick to match not only commands (format like nick)
-  if nick_str.match(/^\s*-/)
+def gnick(nick_str = nil) # Define a generic/global nick to match not only commands (format like nick)
+  if nick_str.nil? || nick_str.empty?
+    # List all gnicks
+    puts "\n  General nicks:".c(@c_gnick).b
+    if @gnick.empty?
+      puts "  (none defined)"
+    else
+      @gnick.sort.each {|key, value| puts "  #{key.c(@c_gnick)} = #{value}"}
+    end
+    puts
+  elsif nick_str.match(/^\s*-/)
     source = nick_str.sub(/^\s*-/, '')
     @gnick.delete(source)
+    rshrc
   else
     source = nick_str.sub(/ =.*/, '')
     target = nick_str.sub(/.*= /, '')
     @gnick[source] = target
+    rshrc
   end
-  rshrc
-end
-def nick? # Show nicks
-  puts "  Command nicks:".c(@c_nick)
-  @nick.sort.each {|key, value| puts "  #{key} = #{value}"}
-  puts "  General nicks:".c(@c_gnick)
-  @gnick.sort.each {|key, value| puts "  #{key} = #{value}"}
-end
-def nickdel(nick_name) # Delete a command nick
-  @nick.delete(nick_name)
-  rshrc
-  puts "Nick '#{nick_name}' deleted"
-end
-def gnickdel(nick_name) # Delete a general/global nick
-  @gnick.delete(nick_name)
-  rshrc
-  puts "General nick '#{nick_name}' deleted"
 end
 def dirs
   puts "Past direactories:"
@@ -994,6 +1268,7 @@ def defun(func_def)  # Define a Ruby function like: `:defun "myls(*args) = Dir.g
     func_name = func_def.sub(/^\s*-/, '')
     if self.respond_to?(func_name)
       singleton_class.remove_method(func_name.to_sym)
+      @defuns.delete(func_name)
       puts "Function '#{func_name}' removed"
     else
       puts "Function '#{func_name}' not found"
@@ -1005,11 +1280,12 @@ def defun(func_def)  # Define a Ruby function like: `:defun "myls(*args) = Dir.g
       func_name = $1
       func_params = $2
       func_body = $3
-      
+
       begin
         eval_code = "def #{func_name}(#{func_params}); #{func_body}; end"
         puts "  DEBUG: Evaluating: #{eval_code}" if ENV['RSH_DEBUG']
         singleton_class.class_eval(eval_code)
+        @defuns[func_name] = func_def  # Store for persistence
         puts "Function '#{func_name}' defined"
         puts "  DEBUG: Method created? #{respond_to?(func_name)}" if ENV['RSH_DEBUG']
       rescue SyntaxError => e
@@ -1038,6 +1314,464 @@ def defun?  # Show all user-defined functions
     end
   end
 end
+def stats(*args) # Show command execution statistics and analytics
+  format = args[0]
+  filename = args[1]
+
+  if format == "--export"
+    # Export to file
+    fname = filename || "rsh_stats.json"
+    export_stats(fname)
+    return
+  elsif format == "--json"
+    fname = filename || "rsh_stats.json"
+    export_stats_json(fname)
+    return
+  elsif format == "--csv"
+    fname = filename || "rsh_stats.csv"
+    export_stats_csv(fname)
+    return
+  end
+
+  # Display stats (existing code)
+  puts "\n  Command Execution Statistics".c(@c_prompt).b
+  puts "  " + "="*50
+
+  # Most used commands
+  if @cmd_frequency && !@cmd_frequency.empty?
+    puts "\n  Top 10 Most Used Commands:".c(@c_nick)
+    sorted = @cmd_frequency.sort_by { |_, count| -count }.first(10)
+    sorted.each_with_index do |(cmd, count), i|
+      bar = "■" * ([count / 5, 20].min)
+      puts "  #{(i+1).to_s.rjust(2)}. #{cmd.ljust(20)} #{count.to_s.rjust(5)}x #{bar.c(@c_path)}"
+    end
+  end
+
+  # Command statistics from @cmd_stats
+  if @cmd_stats && !@cmd_stats.empty?
+    total_time = @cmd_stats.values.map { |s| s[:total_time] || 0 }.sum
+    total_cmds = @cmd_stats.values.map { |s| s[:count] || 0 }.sum
+
+    puts "\n  Performance Statistics:".c(@c_nick)
+    puts "  Total commands executed: #{total_cmds}"
+    puts "  Total execution time: #{'%.2f' % total_time}s"
+    puts "  Average time per command: #{'%.2f' % (total_time / total_cmds)}s" if total_cmds > 0
+
+    puts "\n  Slowest Commands:".c(@c_nick)
+    slowest = @cmd_stats.sort_by { |_, s| -(s[:avg_time] || 0) }.first(5)
+    slowest.each_with_index do |(cmd, stats), i|
+      puts "  #{(i+1).to_s.rjust(2)}. #{cmd.ljust(20)} avg: #{'%.3f' % (stats[:avg_time] || 0)}s"
+    end
+  end
+
+  # History statistics
+  puts "\n  History Statistics:".c(@c_nick)
+  puts "  Total history entries: #{@history.length}"
+  puts "  Unique commands: #{@history.uniq.length}"
+
+  # Success/failure tracking
+  puts "\n  Last command exit status: #{@last_exit == 0 ? 'Success'.c(@c_path) : "Failed (#{@last_exit})".c(196)}"
+  puts
+end
+def export_stats(filename) # Export stats to file (JSON or CSV based on extension)
+  if filename.end_with?('.csv')
+    export_stats_csv(filename)
+  else
+    filename += '.json' unless filename.end_with?('.json')
+    export_stats_json(filename)
+  end
+end
+def export_stats_json(filename = 'rsh_stats.json') # Export stats to JSON
+  stats_data = {
+    generated: Time.now.to_i,
+    cmd_frequency: @cmd_frequency,
+    cmd_stats: @cmd_stats,
+    history: {
+      total: @history.length,
+      unique: @history.uniq.length
+    },
+    last_exit: @last_exit
+  }
+  begin
+    require 'json'
+    File.write(filename, JSON.pretty_generate(stats_data))
+    puts "Stats exported to #{filename}"
+  rescue => e
+    puts "Error exporting stats: #{e.message}"
+  end
+end
+def export_stats_csv(filename = 'rsh_stats.csv') # Export stats to CSV
+  begin
+    lines = []
+    lines << "command,frequency,count,total_time,avg_time"
+
+    # Merge frequency and performance data
+    all_cmds = (@cmd_frequency.keys + @cmd_stats.keys).uniq
+    all_cmds.sort.each do |cmd|
+      freq = @cmd_frequency[cmd] || 0
+      count = @cmd_stats.dig(cmd, :count) || 0
+      total = @cmd_stats.dig(cmd, :total_time) || 0.0
+      avg = @cmd_stats.dig(cmd, :avg_time) || 0.0
+      lines << "#{cmd},#{freq},#{count},#{'%.3f' % total},#{'%.3f' % avg}"
+    end
+
+    File.write(filename, lines.join("\n"))
+    puts "Stats exported to #{filename}"
+  rescue => e
+    puts "Error exporting stats: #{e.message}"
+  end
+end
+def bm(*args) # Enhanced bookmark management with tags
+  # Handle variadic arguments
+  arg_str = args.join(' ')
+
+  if args.empty?
+    # List all bookmarks
+    if @bookmarks.empty?
+      puts "No bookmarks defined. Use :bm \"name\" to bookmark current directory"
+      return
+    end
+    puts "\n  Bookmarks:".c(@c_prompt).b
+    @bookmarks.each do |name, data|
+      path = data.is_a?(Hash) ? data[:path] : data
+      tags = data.is_a?(Hash) && data[:tags] ? " [#{data[:tags].join(', ')}]" : ""
+      puts "  #{name.c(@c_nick)} → #{path}#{tags.c(@c_stamp)}"
+    end
+    puts
+  elsif args[0] == '--export'
+    # Export bookmarks to file
+    filename = args[1] || 'bookmarks.json'
+    export_bookmarks(filename)
+  elsif args[0] == '--import'
+    # Import bookmarks from file
+    filename = args[1]
+    import_bookmarks(filename) if filename
+  elsif args[0] == '--stats'
+    # Show bookmark statistics
+    bookmark_stats
+  elsif arg_str =~ /^(\w+)\s+(.+)$/
+    # Set bookmark with optional tags
+    name, rest = $1, $2
+    if rest.include?('#')
+      path_part, tag_part = rest.split('#', 2)
+      path = path_part.strip
+      path = Dir.pwd if path.empty?
+      tags = tag_part.split(',').map(&:strip)
+      @bookmarks[name] = {path: path, tags: tags}
+    else
+      @bookmarks[name] = {path: rest.strip, tags: []}
+    end
+    puts "Bookmark '#{name}' set to #{@bookmarks[name][:path]}"
+    rshrc
+  elsif arg_str =~ /^-(\w+)$/
+    # Delete bookmark
+    name = $1
+    if @bookmarks.delete(name)
+      puts "Bookmark '#{name}' deleted"
+      rshrc
+    else
+      puts "Bookmark '#{name}' not found"
+    end
+  elsif arg_str =~ /^\?(\w*)$/
+    # Search bookmarks by tag
+    tag = $1
+    if tag.empty?
+      puts "Available tags:"
+      all_tags = @bookmarks.values.flat_map { |d| d.is_a?(Hash) ? d[:tags] : [] }.uniq.sort
+      puts "  " + all_tags.join(", ")
+    else
+      matches = @bookmarks.select do |_, data|
+        data.is_a?(Hash) && data[:tags] && data[:tags].include?(tag)
+      end
+      if matches.empty?
+        puts "No bookmarks with tag '#{tag}'"
+      else
+        puts "Bookmarks with tag '#{tag}':"
+        matches.each { |name, data| puts "  #{name} → #{data[:path]}" }
+      end
+    end
+  else
+    # Bookmark current directory
+    name = arg_str.strip
+    @bookmarks[name] = {path: Dir.pwd, tags: []}
+    puts "Bookmark '#{name}' set to #{Dir.pwd}"
+    rshrc
+  end
+end
+def bookmark(*args) # Alias for bm
+  bm(*args)
+end
+def export_bookmarks(filename = 'bookmarks.json') # Export bookmarks to JSON
+  begin
+    require 'json'
+    File.write(filename, JSON.pretty_generate(@bookmarks))
+    puts "Bookmarks exported to #{filename}"
+  rescue => e
+    puts "Error exporting bookmarks: #{e.message}"
+  end
+end
+def import_bookmarks(filename) # Import bookmarks from JSON
+  unless File.exist?(filename)
+    puts "File '#{filename}' not found"
+    return
+  end
+  begin
+    require 'json'
+    imported = JSON.parse(File.read(filename))
+    imported.each do |name, data|
+      # Convert to proper format
+      if data.is_a?(Hash)
+        @bookmarks[name] = {
+          path: data['path'] || data[:path],
+          tags: data['tags'] || data[:tags] || []
+        }.transform_keys(&:to_sym)
+      else
+        @bookmarks[name] = {path: data.to_s, tags: []}
+      end
+    end
+    puts "Imported #{imported.length} bookmarks from #{filename}"
+    rshrc
+  rescue => e
+    puts "Error importing bookmarks: #{e.message}"
+  end
+end
+def bookmark_stats # Show bookmark usage statistics
+  if @bookmarks.empty?
+    puts "No bookmarks defined"
+    return
+  end
+
+  puts "\n  Bookmark Statistics".c(@c_prompt).b
+  puts "  " + "="*50
+  puts "\n  Total bookmarks: #{@bookmarks.length}"
+
+  # Count by tags
+  all_tags = @bookmarks.values.flat_map { |d| d.is_a?(Hash) ? (d[:tags] || []) : [] }
+  unless all_tags.empty?
+    puts "\n  Tags Distribution:".c(@c_nick)
+    tag_counts = all_tags.group_by(&:itself).transform_values(&:count)
+    tag_counts.sort_by { |_, count| -count }.each do |tag, count|
+      puts "    #{tag.ljust(15)} #{count}x"
+    end
+  end
+
+  # Bookmarks by directory depth
+  puts "\n  Path Analysis:".c(@c_nick)
+  paths = @bookmarks.values.map { |d| d.is_a?(Hash) ? d[:path] : d }
+  avg_depth = paths.map { |p| p.split('/').length }.sum / paths.length
+  puts "    Average path depth: #{avg_depth}"
+  puts
+end
+def save_session(*args) # Save current session state
+  session_name = args[0] || 'default'
+  session_path = @session_dir + "/#{session_name}.json"
+
+  session = {
+    name: session_name,
+    pwd: Dir.pwd,
+    history: @history.first(50),
+    bookmarks: @bookmarks,
+    defuns: @defuns,
+    timestamp: Time.now.to_i
+  }
+  begin
+    require 'json'
+    File.write(session_path, JSON.pretty_generate(session))
+    puts "Session '#{session_name}' saved to #{session_path}"
+  rescue => e
+    puts "Error saving session: #{e.message}"
+  end
+end
+def load_session(*args) # Restore previous session
+  session_name = args[0] || 'default'
+  session_path = @session_dir + "/#{session_name}.json"
+
+  unless File.exist?(session_path)
+    puts "Session '#{session_name}' not found"
+    list_sessions
+    return
+  end
+  begin
+    require 'json'
+    session = JSON.parse(File.read(session_path), symbolize_names: true)
+
+    # Restore state
+    Dir.chdir(session[:pwd]) if session[:pwd] && Dir.exist?(session[:pwd])
+
+    # Merge history (prepend saved history)
+    if session[:history]
+      @history = (session[:history] + @history).uniq.first(@histsize)
+    end
+
+    # Restore bookmarks
+    if session[:bookmarks]
+      session[:bookmarks].each do |name, data|
+        bookmark_data = data.is_a?(Hash) ? data.transform_keys(&:to_sym) : data
+        @bookmarks[name.to_s] = bookmark_data
+      end
+    end
+
+    # Restore defuns
+    if session[:defuns]
+      session[:defuns].each do |name, func_def|
+        next unless func_def.is_a?(String)
+        @defuns[name.to_s] = func_def
+        # Re-evaluate the function
+        if func_def =~ /^(\w+)\s*\(([^)]*)\)\s*=\s*(.+)$/
+          func_name, func_params, func_body = $1, $2, $3
+          eval_code = "def #{func_name}(#{func_params}); #{func_body}; end"
+          singleton_class.class_eval(eval_code) rescue nil
+        end
+      end
+    end
+
+    saved_time = Time.at(session[:timestamp] || 0).strftime("%Y-%m-%d %H:%M:%S")
+    puts "Session '#{session_name}' restored from #{saved_time}"
+    rshrc
+  rescue => e
+    puts "Error loading session: #{e.message}"
+  end
+end
+def list_sessions # List all saved sessions
+  unless Dir.exist?(@session_dir)
+    puts "No sessions directory found"
+    return
+  end
+
+  sessions = Dir.glob(@session_dir + '/*.json').map { |f| File.basename(f, '.json') }
+
+  if sessions.empty?
+    puts "No saved sessions found. Use :save_session \"name\" to create one"
+    return
+  end
+
+  puts "\n  Saved Sessions:".c(@c_prompt).b
+  sessions.sort.each do |name|
+    session_path = @session_dir + "/#{name}.json"
+    begin
+      require 'json'
+      session = JSON.parse(File.read(session_path), symbolize_names: true)
+      timestamp = Time.at(session[:timestamp] || 0).strftime("%Y-%m-%d %H:%M")
+      pwd = session[:pwd] || '?'
+      puts "  #{name.c(@c_bookmark).ljust(20)} #{timestamp.c(@c_stamp)} #{pwd.c(@c_path)}"
+    rescue => e
+      puts "  #{name.c(@c_bookmark).ljust(20)} [corrupted]".c(196)
+    end
+  end
+  puts
+end
+def delete_session(*args) # Delete a saved session
+  name = args[0]
+
+  if name == '*'
+    # Delete all sessions except default
+    sessions = Dir.glob(@session_dir + '/*.json').map { |f| File.basename(f, '.json') }
+    sessions.reject! { |s| s == 'default' || s == 'autosave' }
+
+    if sessions.empty?
+      puts "No sessions to delete (keeping default and autosave)"
+      return
+    end
+
+    sessions.each do |session_name|
+      session_path = @session_dir + "/#{session_name}.json"
+      File.delete(session_path)
+    end
+    puts "Deleted #{sessions.length} sessions: #{sessions.join(', ')}"
+    return
+  end
+
+  return puts "Cannot delete default session" if name == 'default'
+  return puts "Cannot delete autosave session (use * to delete all)" if name == 'autosave'
+
+  session_path = @session_dir + "/#{name}.json"
+  unless File.exist?(session_path)
+    puts "Session '#{name}' not found"
+    return
+  end
+
+  File.delete(session_path)
+  puts "Session '#{name}' deleted"
+end
+def rmsession(*args) # Alias for delete_session
+  delete_session(*args)
+end
+def theme(*args) # Apply color scheme presets
+  name = args[0]
+
+  if name.nil?
+    puts "\n  Available themes:".c(@c_prompt).b
+    puts "    default, solarized, dracula, gruvbox, nord, monokai"
+    puts "\n  Current theme colors:"
+    puts "    prompt:#{' '*5}#{@c_prompt}   cmd:#{' '*8}#{@c_cmd}   nick:#{' '*7}#{@c_nick}"
+    puts "    gnick:#{' '*6}#{@c_gnick}   path:#{' '*7}#{@c_path}   switch:#{' '*5}#{@c_switch}"
+    puts "    bookmark:#{' '*3}#{@c_bookmark}   colon:#{' '*6}#{@c_colon}   tabselect:#{' '*2}#{@c_tabselect}"
+    puts "    taboption:#{' '*2}#{@c_taboption}   stamp:#{' '*6}#{@c_stamp}"
+    puts
+    return
+  end
+
+  case name.downcase
+  when 'default'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 10, 2, 6, 14
+    @c_path, @c_switch, @c_bookmark, @c_colon = 3, 6, 13, 4
+    @c_tabselect, @c_taboption, @c_stamp = 5, 244, 244
+  when 'solarized'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 33, 64, 37, 117
+    @c_path, @c_switch, @c_bookmark, @c_colon = 136, 125, 61, 33
+    @c_tabselect, @c_taboption, @c_stamp = 166, 240, 240
+  when 'dracula'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 141, 84, 117, 212
+    @c_path, @c_switch, @c_bookmark, @c_colon = 228, 215, 141, 141
+    @c_tabselect, @c_taboption, @c_stamp = 212, 238, 238
+  when 'gruvbox'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 214, 142, 109, 175
+    @c_path, @c_switch, @c_bookmark, @c_colon = 208, 142, 167, 214
+    @c_tabselect, @c_taboption, @c_stamp = 208, 243, 243
+  when 'nord'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 110, 109, 116, 152
+    @c_path, @c_switch, @c_bookmark, @c_colon = 180, 109, 139, 110
+    @c_tabselect, @c_taboption, @c_stamp = 143, 240, 240
+  when 'monokai'
+    @c_prompt, @c_cmd, @c_nick, @c_gnick = 197, 112, 81, 141
+    @c_path, @c_switch, @c_bookmark, @c_colon = 228, 208, 141, 197
+    @c_tabselect, @c_taboption, @c_stamp = 197, 238, 238
+  else
+    puts "Unknown theme '#{name}'. Available: default, solarized, dracula, gruvbox, nord, monokai"
+    return
+  end
+
+  puts "Theme '#{name}' applied"
+  puts "Add this to .rshrc to make it permanent: :theme \"#{name}\""
+end
+def validate_command(cmd) # Syntax validation before execution
+  return nil if cmd.nil? || cmd.empty?
+  warnings = []
+
+  # Check for common mistakes
+  warnings << "Unmatched quotes" if cmd.count("'").odd? || cmd.count('"').odd?
+  warnings << "Unmatched parentheses" if cmd.count("(") != cmd.count(")")
+  warnings << "Unmatched brackets" if cmd.count("[") != cmd.count("]")
+  warnings << "Unmatched braces" if cmd.count("{") != cmd.count("}")
+
+  # Check for potentially dangerous patterns
+  warnings << "WARNING: Recursive rm detected" if cmd =~ /rm\s+.*-r.*\//
+  warnings << "WARNING: Force flag without path" if cmd =~ /rm\s+-[rf]+\s*$/
+  warnings << "WARNING: Sudo with redirection" if cmd =~ /sudo.*>/
+
+  # Check for common typos in popular commands
+  if cmd =~ /^(\w+)/
+    first_cmd = $1
+    unless @exe.include?(first_cmd) || @nick.include?(first_cmd) || first_cmd == "cd"
+      suggestions = suggest_command(first_cmd)
+      if suggestions && !suggestions.empty?
+        warnings << "Command '#{first_cmd}' not found. Did you mean: #{suggestions.join(', ')}?"
+      end
+    end
+  end
+
+  warnings.empty? ? nil : warnings
+end
 def execute_conditional(cmd_line)
   # Split on && and || while preserving the operators
   parts = cmd_line.split(/(\s*&&\s*|\s*\|\|\s*)/)
@@ -1316,6 +2050,27 @@ def load_rshrc_safe
     @nick = {} unless @nick.is_a?(Hash)
     @gnick = {} unless @gnick.is_a?(Hash)
     @cmd_frequency = {} unless @cmd_frequency.is_a?(Hash)
+    @cmd_stats = {} unless @cmd_stats.is_a?(Hash)
+    @bookmarks = {} unless @bookmarks.is_a?(Hash)
+    @defuns = {} unless @defuns.is_a?(Hash)
+    @history_dedup = 'smart' unless @history_dedup.is_a?(String)
+    @session_autosave = 0 unless @session_autosave.is_a?(Integer)
+
+    # Restore defuns from .rshrc
+    if @defuns && !@defuns.empty?
+      @defuns.each do |name, func_def|
+        next unless func_def.is_a?(String)
+        if func_def =~ /^(\w+)\s*\(([^)]*)\)\s*=\s*(.+)$/
+          func_name, func_params, func_body = $1, $2, $3
+          begin
+            eval_code = "def #{func_name}(#{func_params}); #{func_body}; end"
+            singleton_class.class_eval(eval_code)
+          rescue => e
+            puts "Warning: Could not load defun '#{name}': #{e.message}" if ENV['RSH_DEBUG']
+          end
+        end
+      end
+    end
 
   rescue SyntaxError => e
     puts "\n\033[31mERROR: Syntax error in .rshrc:\033[0m"
@@ -1429,6 +2184,13 @@ def load_defaults
   @completion_show_descriptions ||= false
   @completion_fuzzy ||= true
   @cmd_frequency ||= {}
+  @cmd_stats ||= {}
+  @bookmarks ||= {}
+  @defuns ||= {}
+  @switch_cache ||= {}
+  @switch_cache_time ||= {}
+  @history_dedup ||= 'smart'
+  @session_autosave ||= 0
   puts "Loaded with default configuration."
 end
 
@@ -1509,11 +2271,19 @@ loop do
   begin
     @user = Etc.getpwuid(Process.euid).name # For use in @prompt
     @node = Etc.uname[:nodename]            # For use in @prompt
-    h = @history; load_rshrc_safe; @history = h # reload prompt but not history safely
+    h = @history; f = @cmd_frequency; s = @cmd_stats; b = @bookmarks; d = @defuns; load_rshrc_safe; @history = h; @cmd_frequency = f; @cmd_stats = s; @bookmarks = b; @defuns = d # reload prompt but preserve runtime data
     @prompt.gsub!(/#{Dir.home}/, '~') # Simplify path in prompt
     system("printf \"\033]0;rsh: #{Dir.pwd}\007\"")   # Set Window title to path 
     @history[0] = "" unless @history[0]
     cache_executables  # Use cached executable lookup
+    # Auto-save session if enabled and interval elapsed
+    if @session_autosave && @session_autosave > 0
+      current_time = Time.now.to_i
+      if (current_time - @session_last_save) >= @session_autosave
+        save_session('autosave')
+        @session_last_save = current_time
+      end
+    end
     getstr # Main work is here
     @cmd = @history[0]
     @dirs.unshift(Dir.pwd)
@@ -1609,11 +2379,23 @@ loop do
         @cmd = Dir.home if @cmd == "~"
         @cmd = @dirs[1] if @cmd == "-"
         @cmd = @dirs[@cmd.to_i] if @cmd =~ /^\d$/
-        # Check if it's a directory to change to
+        # Check if it's a directory to change to first
         dir = @cmd.strip.sub(/~/, Dir.home)
         if Dir.exist?(dir)
-          Dir.chdir(dir) 
+          Dir.chdir(dir)
           system("git status .") if Dir.exist?(".git")
+        # Then check if it's a bookmark (commands and nicks already handled above)
+        elsif @bookmarks && @bookmarks[@cmd]
+          bookmark_data = @bookmarks[@cmd]
+          bm_dir = bookmark_data.is_a?(Hash) ? bookmark_data[:path] : bookmark_data
+          bm_dir = bm_dir.sub(/^~/, Dir.home)  # Expand tilde
+          if Dir.exist?(bm_dir)
+            Dir.chdir(bm_dir)
+            puts "Jumped to bookmark '#{@cmd}' → #{bm_dir}".c(@c_path)
+            system("git status .") if Dir.exist?(".git")
+          else
+            puts "Bookmark '#{@cmd}' points to non-existent directory: #{bm_dir}".c(196)
+          end
         else
           puts "#{Time.now.strftime("%H:%M:%S")}: #{@cmd}".c(@c_stamp)
           if @cmd == "f" # fzf integration (https://github.com/junegunn/fzf)
@@ -1630,16 +2412,34 @@ loop do
                 Thread.new { system("xdg-open #{@cmd} 2>/dev/null") }
               end
             end
-          else 
+          else
             begin
+              # Validate command before execution
+              warnings = validate_command(@cmd)
+              if warnings && !warnings.empty?
+                warnings.each { |w| puts "#{w}".c(196) }
+                # For critical warnings, ask for confirmation
+                if warnings.any? { |w| w.start_with?("WARNING:") }
+                  print "Continue anyway? (y/N): "
+                  response = $stdin.gets.chomp
+                  unless response.downcase == 'y'
+                    puts "Command cancelled"
+                    next
+                  end
+                end
+              end
+
               pre_cmd
 
               # Track command frequency for intelligent completion
-              if @cmd && !@cmd.empty?
-                cmd_base = @cmd.split.first
-                @cmd_frequency[cmd_base] = (@cmd_frequency[cmd_base] || 0) + 1 if cmd_base
+              cmd_base = @cmd.split.first if @cmd && !@cmd.empty?
+              if cmd_base
+                @cmd_frequency[cmd_base] = (@cmd_frequency[cmd_base] || 0) + 1
               end
 
+              # Start timing
+              start_time = Time.now
+
               # Handle background jobs
               if @cmd.end_with?(' &')
                 @cmd = @cmd[0..-3]  # Remove the &
@@ -1653,13 +2453,23 @@ loop do
                 @jobs[@job_id] = {pid: pid, cmd: @cmd, status: :running}
                 puts "[#{@job_id}] #{pid} #{@cmd}"
               else
-                # Better handling of pipes and redirections  
+                # Better handling of pipes and redirections
                 @current_pid = spawn(@cmd)
                 Process.wait(@current_pid)
                 @last_exit = $?.exitstatus
                 @current_pid = nil
                 puts " Command failed: #{@cmd} (exit #{@last_exit})" unless @last_exit == 0
               end
+
+              # Track execution time
+              elapsed = Time.now - start_time
+              if cmd_base && elapsed > 0.01  # Only track if > 10ms
+                @cmd_stats[cmd_base] ||= {count: 0, total_time: 0.0, avg_time: 0.0}
+                @cmd_stats[cmd_base][:count] += 1
+                @cmd_stats[cmd_base][:total_time] += elapsed
+                @cmd_stats[cmd_base][:avg_time] = @cmd_stats[cmd_base][:total_time] / @cmd_stats[cmd_base][:count]
+              end
+
               post_cmd
             rescue StandardError => err
               puts "\nError: #{err}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-shell
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Geir Isene
@@ -12,8 +12,9 @@ date: 2025-10-22 00:00:00.000000000 Z
 dependencies: []
 description: 'A shell written in Ruby with extensive tab completions, aliases/nicks,
   history, syntax highlighting, theming, auto-cd, auto-opening files and more. UPDATE
-  v2.12.0: Extensible command completion system - smart tab completion for git, apt,
-  docker, systemctl, cargo, npm, gem, bundle with easy customization.'
+  v3.1.0: Multiple named sessions, stats export (CSV/JSON), session auto-save, bookmark
+  import/export, bookmark statistics, 6 color themes, config management, environment
+  variable tools, bookmark TAB completion, and much more!'
 email: g@isene.com
 executables:
 - rsh