ruby-shell 3.2.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8d8b425248a8544d33dab32c9e5322522389665593a9b1c9dfedf2f6be72996
-  data.tar.gz: 44dcba6f5eca65d0667bc380677f26b7d52b07e8147f2d33bd18d28f676bfa99
+  metadata.gz: 5b86a585bea4b0c41a27de5679365d3ddce7b7a33481927cbf0de9bd89dcf27b
+  data.tar.gz: f346b777aa2863b06ef610a8e9c13325711058452f8986e5d4565aecb8ae21d4
 SHA512:
-  metadata.gz: e8af85c2f352a7144ec51ed76c19144e44918c78b0d459d2aef58c0e33521cb08033a54bd2b7bd6d3da4402bc879c806c78353ba92c7fe30822aec9983d58480
-  data.tar.gz: f85f97778ffc6efae4758fb67902361c40f1f3ad3e0b4857bf166538e0066d2074481ceef7dcf5989f6f2db90f0b50ef957f035cfba1b5b3320a700dd42f4ec5
+  metadata.gz: 181420e5e35ca971f44affd54dbf9cadf1b13d658627d5cf2aa062b1d17678ed8521911b1208a5f3072eaa06a6e8840db1317e5a15d1e1d2de672fbaf66552cb
+  data.tar.gz: '084bb4b4227110ea0a2230e8455527ed8259fdcf8285ae6fd3dac571315f662c6e0243ee66caad5dc0bacb8157f82c47cf56a1213900ed3fe4f14a15fb4bcefa'

data/README.md

@@ -33,7 +33,26 @@ 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 v3.2.0 - Plugin System & Productivity ⭐⭐⭐
+## NEW in v3.4.0 - Intelligent Completion Learning ⭐⭐
+* **Smart TAB Completion**: Shell learns which completions you use most and ranks them higher
+* **Context-Aware Learning**: Separate learning for git, ls, docker, and all other commands
+* **Completion Statistics**: `:completion_stats` shows learned patterns with visual charts
+* **Manageable**: `:config completion_learning on|off`, `:completion_reset` to clear data
+* **Persistent**: Learning data saves to .rshrc, works across sessions
+* **Works Everywhere**: Commands, switches, subcommands - all get smarter over time
+
+## v3.3.0 - Quote-less Syntax, Parametrized Nicks & More ⭐⭐⭐
+* **No More Quotes**: Simplified syntax - `:nick la = ls -la` instead of `:nick "la = ls -la"`
+* **Parametrized Nicks**: `:nick gp = git push origin {{branch}}` then use `gp branch=main`
+* **Ctrl-G Multi-line Edit**: Press Ctrl-G to edit command in $EDITOR for complex scripts
+* **Custom Validation Rules**: `:validate rm -rf / = block` prevents dangerous commands
+* **Shell Script Support**: for/while/if loops work with full bash syntax
+* **Cleaner Commands**: `:config auto_correct on`, `:bm work /tmp #dev`, `:theme dracula`
+* **Simplified Architecture**: Removed :template (merged into :nick for simplicity)
+* **Backward Compatible**: Old quote syntax still works for existing .rshrc files
+* **Better UX**: Less typing, more powerful, feels more natural
+
+## v3.2.0 - Plugin System & Productivity ⭐⭐⭐
 * **Plugin Architecture**: Extensible plugin system with lifecycle hooks and extension points
 * **Lifecycle Hooks**: on_startup, on_command_before, on_command_after, on_prompt
 * **Extension Points**: add_completions (TAB completion), add_commands (custom commands)
@@ -109,22 +128,23 @@ Special functions/integrations:
 * Use `:` followed by a Ruby expression to access the whole world of Ruby
 
 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)
-* `: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)
+* `: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)
+* `:nick` lists all command nicks, `:gnick` lists general nicks
+* `:nick -name` delete a command nick, `:gnick -name` delete a general nick
 * `: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 (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)
-* `:theme "name"` applies color scheme, `:config` manages settings, `:env` manages environment (NEW in v3.1)
-* `:plugins` lists plugins, `:plugins "disable", "name"` disables, `:plugins "reload"` reloads (NEW in v3.2)
+* `:defun func(args) = code` defines Ruby functions callable as shell commands (persistent!)
+* `:defun?` lists all user-defined functions, `:defun -func` removes functions
+* `:stats` shows command execution statistics, `:stats --graph` for visual charts, `:stats --clear` to reset
+* `:bm name` or `:bookmark name` bookmark current directory, `:bm name path #tags` with tags
+* `:bm` lists all bookmarks, just type bookmark name to jump (e.g., `work`)
+* `:bm -name` delete bookmark, `:bm ?tag` search by tag, `:bm --stats` show statistics
+* `:save_session name` saves named session, `:load_session name` loads session
+* `:list_sessions` shows all saved sessions, `:rmsession name` or `:rmsession *` deletes
+* `:theme name` applies color scheme, `:config` manages settings, `:env` manages environment
+* `:plugins` lists plugins, `:plugins disable name` disables, `:plugins reload` reloads
+* `:calc expression` inline calculator with Ruby Math library
 * `: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
@@ -151,10 +171,82 @@ Add to your `.rshrc`:
 ```
 
 ## Moving around
-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`.
+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 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.
+
+Nicks are powerful aliases that can be simple command shortcuts or complex parametrized templates.
+
+### Simple Nicks
+```bash
+:nick ls = ls --color        # Simple alias
+:nick la = ls -la            # Another shortcut
+:nick                        # List all nicks
+:nick -la                    # Delete a nick
+```
+
+### Parametrized Nicks (NEW in v3.3!)
+Create templates with `{{placeholder}}` parameters:
+
+```bash
+# Git shortcuts with branch parameter
+:nick gp = git push origin {{branch}}
+gp branch=main               # Executes: git push origin main
+gp branch=develop            # Executes: git push origin develop
+
+# Deployment with multiple parameters
+:nick deploy = ssh {{user}}@{{host}} 'cd {{path}} && git pull'
+deploy user=admin host=prod path=/var/www
+# Executes: ssh admin@prod 'cd /var/www && git pull'
+
+# Backup with source and destination
+:nick backup = rsync -av {{src}} {{dest}}
+backup src=/data dest=/backup
+# Executes: rsync -av /data /backup
+```
+
+**How it works:**
+- Define nick with `{{param}}` placeholders
+- Use with `key=value` syntax
+- Parameters auto-expand and get stripped from final command
+- Works with any number of parameters
+
+### General Nicks (gnicks)
+Substitute anywhere on command line (not just commands):
+```bash
+:gnick h = /home/user        # Directory shortcut
+:gnick                       # List all gnicks
+:gnick -h                    # Delete a gnick
+```
+
+## Multi-line Command Editing (v3.3.0+)
+
+Press **Ctrl-G** to edit the current command in your $EDITOR:
+
+```bash
+# Start typing a complex command
+for i in {1..10}
+
+# Press Ctrl-G
+# Your editor opens with the command
+# Add more lines:
+for i in {1..10}
+  echo "Processing: $i"
+  sleep 1
+done
+
+# Save and quit
+# Command appears on command line (converted to single-line with ;)
+# Press ENTER to execute
+```
+
+**Perfect for:**
+- Complex shell scripts
+- Long commands with many options
+- Multi-line constructs (for, while, if)
+- Commands you want to review/edit carefully
+
+---
 
 ## Tab completion
 You can tab complete almost anything. Hitting `TAB` will try to complete in this priority: nicks, gnicks, commands, dirs/files. Special completions:
@@ -227,6 +319,43 @@ Ruby functions have access to:
 - JSON/XML parsing
 - And everything else Ruby can do!
 
+## Custom Validation Rules (v3.3.0+)
+
+Create safety rules to block, confirm, warn, or log specific command patterns:
+
+```bash
+# Block dangerous commands completely
+:validate rm -rf / = block
+
+# Require confirmation for risky operations
+:validate git push --force = confirm
+:validate DROP TABLE = confirm
+
+# Show warnings but allow execution
+:validate sudo = warn
+:validate chmod 777 = warn
+
+# Log specific commands for audit trail
+:validate npm install = log
+# Logs to ~/.rsh_validation.log
+
+# List all rules
+:validate
+
+# Delete rule by index
+:validate -1
+```
+
+**Actions:**
+- `block` - Prevent command execution completely
+- `confirm` - Ask for confirmation (y/N)
+- `warn` - Show warning but allow
+- `log` - Silently log to ~/.rsh_validation.log
+
+**Pattern matching:** Uses regex, so you can match complex patterns.
+
+---
+
 ## Plugin System (v3.2.0+)
 
 rsh supports a powerful plugin system for extending functionality. Plugins are Ruby classes placed in `~/.rsh/plugins/` that can:

data/bin/rsh

@@ -8,7 +8,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rsh
 # License:    Public domain
-@version    = "3.2.0" # Plugin system: Extensible architecture with lifecycle hooks, completions, commands, and plugin management
+@version    = "3.4.0" # Completion learning: Shell learns your patterns and boosts frequently-used completions
 
 # MODULES, CLASSES AND EXTENSIONS
 class String # Add coloring to strings (with escaping for Readline)
@@ -150,6 +150,11 @@ begin # Initialization
   @plugins = []                           # Loaded plugin instances
   @plugin_disabled = []                   # List of disabled plugin names
   @plugin_commands = {}                   # Commands added by plugins
+  @validation_rules = []                  # Custom validation rules
+  @completion_weights = {}                # Completion learning weights
+  @completion_learning = true             # Enable completion learning (default: on)
+  @recording = {active: false, name: nil, commands: []} # Command recording state
+  @recordings = {}                        # Saved recordings
   # Built-in rsh commands are called with : prefix, so no need for separate tracking
   Dir.mkdir(Dir.home + '/.rsh') unless Dir.exist?(Dir.home + '/.rsh')
   Dir.mkdir(@session_dir) unless Dir.exist?(@session_dir)
@@ -161,7 +166,7 @@ end
 # HELP TEXT
 @info = <<~INFO
 
-  Hello #{@user}, welcome to rsh v3.2 - the Ruby SHell.
+  Hello #{@user}, welcome to rsh v3.3 - 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
@@ -187,17 +192,26 @@ end
   * 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.2:
+  NEW in v3.4:
+  * Completion learning - Shell learns which TAB completions you use and ranks them higher
+  * Context-aware - Separate learning for each command (git, ls, docker, etc.)
+  * :completion_stats - View learned patterns with visual bar charts
+  * Persistent - Learning data saves to .rshrc across sessions
+
+  v3.3 Features:
+  * Quote-less syntax - No more quotes! Use :nick la = ls -la
+  * Parametrized nicks - :nick gp = git push origin {{branch}}, then: gp branch=main
+  * Ctrl-G multi-line edit - Press Ctrl-G to edit command in $EDITOR
+  * Custom validation - :validate rm -rf / = block prevents dangerous commands
+  * Shell script support - for/while/if loops work with full bash syntax
+
+  v3.2 Features:
   * Plugin system - Extensible architecture for custom commands, completions, and hooks
-  * Lifecycle hooks - on_startup, on_command_before, on_command_after, on_prompt
-  * Plugin management - :plugins list/reload/enable/disable/info
-  * Example plugins - git_prompt, command_logger, kubectl_completion included
-  * Auto-correct typos - :config "auto_correct" "on" automatically fixes gti → closest match
-  * Command timing alerts - :config "slow_command_threshold" "5" warns on slow commands
-  * Inline calculator - :calc 2 + 2, :calc "Math.sqrt(16)", full Ruby Math library
+  * Auto-correct typos - :config auto_correct on (with confirmation prompt)
+  * Command timing alerts - :config slow_command_threshold 5 warns on slow commands
+  * Inline calculator - :calc 2 + 2, :calc "Math::PI", full Ruby Math library
   * Enhanced history - !!, !-2, !5:7 for repeat last, nth-to-last, and chaining
   * Stats visualization - :stats --graph for colorful ASCII bar charts
-  * See PLUGIN_GUIDE.md for complete plugin development documentation
 
   v3.1 Features:
   * Multiple named sessions - :save_session "project" and :load_session "project"
@@ -355,8 +369,23 @@ def getstr # A custom Readline-like function
     chr = getchr
     puts "DEBUG: Got char: '#{chr}' (length: #{chr.length})" if ENV['RSH_DEBUG']
     case chr
-    when 'C-G', 'C-C'
-      @history[0] = "" 
+    when 'C-G'   # Ctrl-G opens command in $EDITOR
+      temp_file = "/tmp/rsh_edit_#{Process.pid}.tmp"
+      File.write(temp_file, @history[0] || "")
+      system("#{ENV['EDITOR'] || 'vi'} #{temp_file}")
+      if File.exist?(temp_file)
+        edited = File.read(temp_file).strip
+        # Convert multi-line to single line with proper separators
+        if edited.include?("\n")
+          # Join lines with semicolons, preserving quoted strings
+          edited = edited.split("\n").map(&:strip).reject(&:empty?).join('; ')
+        end
+        @history[0] = edited
+        @pos = edited.length
+        File.delete(temp_file)
+      end
+    when 'C-C'
+      @history[0] = ""
       @pos = 0
     when 'C-E'   # Ctrl-C exits gracefully but without updating .rshrc
       print "\n"
@@ -486,7 +515,7 @@ def getstr # A custom Readline-like function
       lift = true
     when 'S-TAB'
       @ci = nil
-      tabbing("hist")
+      tab("hist")
       lift = true
     when /^.$/
       @history[0].insert(@pos,chr)
@@ -546,20 +575,29 @@ def tab(type)
       last_cmd = nil
     end
 
-    case last_cmd
-    when "cd", "pushd", "rmdir"
-      type = "dirs_only"
-    when "vim", "nano", "cat", "less", "more", "head", "tail", "file"
-      type = "files_only"
-    when "man", "info", "which", "whatis"
-      type = "commands_only"
-    when "export", "unset"
-      type = "env_vars"
+    # Check for colon command arguments
+    if @pretab =~ /:record\s*$/
+      type = "record_args"
+    elsif @pretab =~ /:replay\s*$/
+      type = "replay_args"
+    elsif @pretab =~ /:plugins\s*$/
+      type = "plugin_args"
     else
-      # Check if command has defined completions and we're on the first argument
-      if @cmd_completions.key?(last_cmd) && cmd_parts.length == 1
-        type = "cmd_subcommands"
-        @current_cmd = last_cmd
+      case last_cmd
+      when "cd", "pushd", "rmdir"
+        type = "dirs_only"
+      when "vim", "nano", "cat", "less", "more", "head", "tail", "file"
+        type = "files_only"
+      when "man", "info", "which", "whatis"
+        type = "commands_only"
+      when "export", "unset"
+        type = "env_vars"
+      else
+        # Check if command has defined completions and we're on the first argument
+        if @cmd_completions.key?(last_cmd) && cmd_parts.length == 1
+          type = "cmd_subcommands"
+          @current_cmd = last_cmd
+        end
       end
     end
   end
@@ -570,6 +608,27 @@ def tab(type)
       @tabarray = @history.select {|el| el =~ /#{@tabstr}/} # Select history items matching @tabstr
       @tabarray.shift   # Take away @history[0]
       return if @tabarray.empty?
+    when "record_args"
+      # Completions for :record command
+      @tabarray = %w[start stop status show]
+      # Add existing recording names for show
+      @tabarray += @recordings.keys.map { |k| "show #{k}" } if @recordings.any?
+      # Add delete options
+      @tabarray += @recordings.keys.map { |k| "-#{k}" } if @recordings.any?
+    when "replay_args"
+      # Completions for :replay command - just recording names
+      @tabarray = @recordings.keys
+    when "plugin_args"
+      # Completions for :plugins command
+      @tabarray = %w[reload info]
+      # Add plugin names for enable/disable/info
+      if @plugins.any?
+        @tabarray += @plugins.map { |p| "disable #{p[:name]}" }
+        @tabarray += @plugins.map { |p| "info #{p[:name]}" }
+      end
+      if @plugin_disabled.any?
+        @tabarray += @plugin_disabled.map { |p| "enable #{p}" }
+      end
     when "switch"
       cmdswitch = @pretab.split(/[|, ]/).last.to_s.strip
       @tabarray = get_command_switches(cmdswitch)
@@ -620,7 +679,9 @@ def tab(type)
         :nick :gnick :bm :bookmark :stats :defun :defun?
         :history :rmhistory :jobs :fg :bg
         :save_session :load_session :list_sessions :delete_session :rmsession
-        :config :env :theme :plugins :calc
+        :config :env :theme :plugins :calc :validate
+        :completion_stats :completion_reset
+        :record :replay
         :info :version :help
       ]
       search_str = @tabstr[1..-1] || ""  # Remove leading :
@@ -701,6 +762,19 @@ def tab(type)
     end
     return if @tabarray.empty?
     @tabarray.delete("")                                      # Don't remember why
+
+    # Apply completion learning to sort results
+    if @completion_learning && type != "hist"
+      # Determine context for learning
+      completion_context = if @pretab && !@pretab.empty?
+        # Use the command being completed
+        @pretab.strip.split(/[|;&]/).last.strip.split.first || "all"
+      else
+        "all"
+      end
+      @tabarray = sort_by_learning(completion_context, @tabarray)
+    end
+
     @c.clear_screen_down                                      # Here we go
     max_items = @completion_limit || 5
     @tabarray.length.to_i - i < max_items ? l = @tabarray.length.to_i - i : l = max_items
@@ -786,6 +860,18 @@ def tab(type)
   @c.row(@c_row)
   @c.col(@c_col)
   @history[0] = @newhist0
+
+  # Track completion selection for learning
+  if @completion_learning && @tabarray && @tabarray[i] && type != "hist"
+    completion_context = if @pretab && !@pretab.empty?
+      @pretab.strip.split(/[|;&]/).last.strip.split.first || "all"
+    else
+      "all"
+    end
+    selected = @tabarray[i]
+    selected = selected.sub(/\s*(-.*?)[,\s].*/, '\1') if type == "switch"
+    track_completion(completion_context, selected)
+  end
 end
 def nextline # Handle going to the next line in the terminal
   row, col = @c.pos
@@ -907,6 +993,7 @@ def config(*args) # Configure rsh settings
     puts "    session_autosave:   #{@session_autosave}s #{@session_autosave > 0 ? '(enabled)' : '(disabled)'}"
     puts "    auto_correct:       #{@auto_correct ? 'on' : 'off'}"
     puts "    slow_command_threshold: #{@slow_command_threshold}s #{@slow_command_threshold > 0 ? '(enabled)' : '(disabled)'}"
+    puts "    completion_learning: #{@completion_learning ? 'on' : 'off'}"
     puts "    completion_limit:   #{@completion_limit}"
     puts "    completion_fuzzy:   #{@completion_fuzzy}"
     puts "    completion_case_sensitive: #{@completion_case_sensitive}"
@@ -935,13 +1022,17 @@ def config(*args) # Configure rsh settings
     @slow_command_threshold = value.to_i
     puts "Slow command threshold set to #{value}s #{value.to_i > 0 ? '(enabled)' : '(disabled)'}"
     rshrc
+  when 'completion_learning'
+    @completion_learning = %w[on true yes 1].include?(value.to_s.downcase)
+    puts "Completion learning #{@completion_learning ? '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, auto_correct, slow_command_threshold, completion_limit"
+    puts "Available: history_dedup, session_autosave, auto_correct, slow_command_threshold, completion_learning, completion_limit"
   end
 end
 def env(*args) # Environment variable management
@@ -1058,6 +1149,14 @@ def rshrc # Write updates to .rshrc
   conf += "@slow_command_threshold = #{@slow_command_threshold}\n" if @slow_command_threshold && @slow_command_threshold > 0
   conf.sub!(/^@plugin_disabled.*(\n|$)/, "")
   conf += "@plugin_disabled = #{@plugin_disabled}\n" unless @plugin_disabled.empty?
+  conf.sub!(/^@validation_rules.*(\n|$)/, "")
+  conf += "@validation_rules = #{@validation_rules}\n" unless @validation_rules.empty?
+  conf.sub!(/^@completion_weights.*(\n|$)/, "")
+  conf += "@completion_weights = #{@completion_weights}\n" unless @completion_weights.empty?
+  conf.sub!(/^@completion_learning.*(\n|$)/, "")
+  conf += "@completion_learning = #{@completion_learning}\n" unless @completion_learning
+  conf.sub!(/^@recordings.*(\n|$)/, "")
+  conf += "@recordings = #{@recordings}\n" unless @recordings.empty?
   # Only write @cmd_completions if user has customized it
   unless conf =~ /^@cmd_completions\s*=/
     # Don't write default completions to avoid cluttering .rshrc
@@ -1072,128 +1171,129 @@ def rshrc # Write updates to .rshrc
     puts "Warning: Error saving history: #{e.message}"
   end
   File.write(Dir.home+'/.rshrc', conf)
-  puts "\n.rshrc updated"
+  puts ".rshrc updated"
 end
 
 # RSH FUNCTIONS
 def help
   # Get terminal width
-  term_width = @maxcol || 80
-  col_width = 48  # Fixed width for left column
-  
+  term_width = @maxcol || 120
+  col_width = 36  # Width for each of 3 columns (wider)
+
   # Helper function to strip ANSI codes for length calculation
   def strip_ansi(str)
     str.gsub(/\001?\e\[[0-9;]*m\002?/, '')
   end
-  
-  left_col = []
-  right_col = []
-  
-  # Left column content
-  left_col << "KEYBOARD SHORTCUTS:".c(@c_prompt).b
-  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"
-  left_col << "Ctrl-L          Clear screen"
-  left_col << "Ctrl-Z          Suspend job"
-  left_col << "Ctrl-C/G        Clear line"
-  left_col << "Ctrl-K          Delete history item"
-  left_col << "Ctrl-U          Clear line"
-  left_col << "Ctrl-W          Delete previous word"
-  left_col << ""
-  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 << ":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"
-  left_col << ":version            Version info"
-  left_col << ":help               This help"
-  
-  # Right column content
-  right_col << "RUBY FUNCTIONS:".c(@c_prompt).b
-  right_col << ":defun 'f(x) = x*2' Define function"
-  right_col << ":defun?             List functions"
-  right_col << ":defun '-f'         Remove function"
-  right_col << "Call as: f 5        (returns 10)"
-  right_col << ""
-  right_col << "JOB CONTROL:".c(@c_prompt).b
-  right_col << "command &           Background job"
-  right_col << ":jobs               List jobs"
-  right_col << ":fg [id]            Foreground job"
-  right_col << ":bg [id]            Resume in bg"
-  right_col << ""
-  right_col << "v3.2 NEW FEATURES:".c(@c_prompt).b
-  right_col << ":plugins [cmd]      Plugin system"
-  right_col << ":stats --graph      Visual bar charts"
-  right_col << ":calc 2 + 2         Ruby calculator"
-  right_col << "!!, !-2, !5:7       History repeat/chain"
-  right_col << ":config auto_correct Auto-fix (w/confirm)"
-  right_col << ":config slow_cmd... Slow alerts"
-  right_col << ""
-  right_col << "PLUGIN SYSTEM:".c(@c_prompt).b
-  right_col << ":plugins            List all"
-  right_col << ":plugins reload     Reload"
-  right_col << ":plugins disable nm Disable"
-  right_col << ":plugins info nm    Details"
-  right_col << ""
-  right_col << "v3.0/3.1 FEATURES:".c(@c_prompt).b
-  right_col << ":stats --clear      Clear stats"
-  right_col << ":stats --csv|--json Export stats"
-  right_col << ":bm \"name\"          Bookmarks"
-  right_col << ":save_session [nm]  Sessions"
-  right_col << ":theme [name]       Themes"
-  right_col << ":config [set val]   Config"
-  right_col << ":env [VAR]          Env vars"
-  right_col << ""
-  right_col << "INTEGRATIONS:".c(@c_prompt).b
-  right_col << "r                   Launch rtfm"
-  right_col << "f                   Launch fzf"
-  right_col << "= <expr>            xrpn calculator"
-  right_col << ":<ruby code>        Execute Ruby"
-  right_col << ""
-  right_col << "AI FEATURES:".c(@c_prompt).b
-  right_col << "@ <question>        AI text response"
-  right_col << "@@ <request>        AI command → prompt"
-  right_col << ""
-  right_col << "SMART COMPLETIONS:".c(@c_prompt).b
-  right_col << "git <TAB>           Git subcommands"
-  right_col << "apt/docker <TAB>    Command options"
-  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"
-  right_col << "$VAR, ${VAR}        Environment var"
-  right_col << "$?                  Exit status"
-  right_col << "$(cmd), `cmd`       Command subst"
-  right_col << "{a,b,c}             Brace expansion"
-  right_col << "cmd1 && cmd2        Conditional"
-  right_col << "cmd1 || cmd2        Alternative"
-  
+
+  col1 = []
+  col2 = []
+  col3 = []
+
+  # Column 1: Keyboard + Commands + Jobs
+  col1 << "KEYBOARD:".c(@c_prompt).b
+  col1 << "Ctrl-G    Edit in \$EDITOR"
+  col1 << "Ctrl-Y    Copy line"
+  col1 << "Ctrl-D    Exit + save"
+  col1 << "Ctrl-C    Clear line"
+  col1 << "TAB       Complete"
+  col1 << "Shift-TAB History search"
+  col1 << ""
+  col1 << "CORE COMMANDS:".c(@c_prompt).b
+  col1 << ":nick a = b      Alias"
+  col1 << ":nick gp={{br}}  Parametrized"
+  col1 << ":bm name         Bookmark"
+  col1 << ":defun f()=x     Function"
+  col1 << ":stats           Analytics"
+  col1 << ":validate p=a    Safety rules"
+  col1 << ":calc expr       Calculator"
+  col1 << ":theme name      Color schemes"
+  col1 << ":plugins         Extensions"
+  col1 << ""
+  col1 << "JOBS:".c(@c_prompt).b
+  col1 << "cmd &       Background"
+  col1 << ":jobs       List jobs"
+  col1 << ":fg [id]    Foreground"
+
+  # Column 2: Sessions + Bookmarks + Recording
+  col2 << "SESSIONS:".c(@c_prompt).b
+  col2 << ":save_session nm   Save state"
+  col2 << ":load_session nm   Load state"
+  col2 << ":list_sessions     Show all"
+  col2 << ":rmsession nm|*    Delete"
+  col2 << ""
+  col2 << "BOOKMARKS:".c(@c_prompt).b
+  col2 << ":bm nm path #tag   Create"
+  col2 << "name               Jump to bookmark"
+  col2 << ":bm                List all"
+  col2 << ":bm --stats        Statistics"
+  col2 << ":bm --export f     Export"
+  col2 << ""
+  col2 << "RECORDING:".c(@c_prompt).b
+  col2 << ":record start nm   Start recording"
+  col2 << ":record stop       Stop recording"
+  col2 << ":record show nm    Show commands"
+  col2 << ":record -nm        Delete"
+  col2 << ":replay nm         Execute"
+  col2 << ":record            List all"
+  col2 << ""
+  col2 << "FEATURES:".c(@c_prompt).b
+  col2 << "gp branch=main     Nick template"
+  col2 << "!!                 Repeat last"
+  col2 << "!-2                2nd to last"
+  col2 << "!5:7               Chain commands"
+  col2 << ":stats --graph     Visual charts"
+  col2 << ":completion_stats  Learn patterns"
+
+  # Column 3: Config + Integrations + Expansions
+  col3 << "CONFIG:".c(@c_prompt).b
+  col3 << ":config auto_correct on         Auto-fix"
+  col3 << ":config completion_learning on  Learn TAB"
+  col3 << ":config slow_command_threshold 5  Slow warn"
+  col3 << ":config session_autosave 300    Auto-save"
+  col3 << ":config history_dedup smart     Dedup"
+  col3 << ""
+  col3 << "INTEGRATIONS:".c(@c_prompt).b
+  col3 << "r          rtfm file manager"
+  col3 << "f          fzf fuzzy finder"
+  col3 << "= expr     xrpn calculator"
+  col3 << "@ text     AI text response"
+  col3 << "@@ cmd     AI command suggest"
+  col3 << ""
+  col3 << "EXPANSIONS:".c(@c_prompt).b
+  col3 << "~            Home directory"
+  col3 << "$VAR         Environment var"
+  col3 << "$(cmd)       Command subst"
+  col3 << "{a,b,c}      Brace expansion"
+  col3 << "cmd1 && cmd2 Conditional AND"
+  col3 << "for i in...  Bash scripts"
+  col3 << ""
+  col3 << "MORE:".c(@c_prompt).b
+  col3 << ":help        This help"
+  col3 << ":info        About rsh"
+  col3 << ":version     Version info"
+
   # Pad columns to same length
-  max_lines = [left_col.length, right_col.length].max
-  left_col.fill("", left_col.length...max_lines)
-  right_col.fill("", right_col.length...max_lines)
-  
-  # Print in two columns
+  max_lines = [col1.length, col2.length, col3.length].max
+  col1.fill("", col1.length...max_lines)
+  col2.fill("", col2.length...max_lines)
+  col3.fill("", col3.length...max_lines)
+
+  # Print in three columns
   puts
   max_lines.times do |i|
-    left_text = left_col[i].to_s
-    right_text = right_col[i].to_s
-    # Calculate padding based on visible characters (without ANSI codes)
-    visible_length = strip_ansi(left_text).length
-    padding = col_width - visible_length
-    padding = 0 if padding < 0
-    puts "  #{left_text}#{' ' * padding} #{right_text}"
+    text1 = col1[i].to_s
+    text2 = col2[i].to_s
+    text3 = col3[i].to_s
+
+    # Calculate padding for each column
+    vis1 = strip_ansi(text1).length
+    vis2 = strip_ansi(text2).length
+    pad1 = col_width - vis1
+    pad2 = col_width - vis2
+    pad1 = 0 if pad1 < 0
+    pad2 = 0 if pad2 < 0
+
+    puts "  #{text1}#{' ' * pad1} #{text2}#{' ' * pad2} #{text3}"
   end
   puts
 end
@@ -1526,11 +1626,8 @@ def export_stats_csv(filename = 'rsh_stats.csv') # Export stats to CSV
     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?
+def bm(arg_str = nil) # Enhanced bookmark management with tags
+  if arg_str.nil? || arg_str.empty?
     # List all bookmarks
     if @bookmarks.empty?
       puts "No bookmarks defined. Use :bm \"name\" to bookmark current directory"
@@ -1543,15 +1640,16 @@ def bm(*args) # Enhanced bookmark management with tags
       puts "  #{name.c(@c_nick)} → #{path}#{tags.c(@c_stamp)}"
     end
     puts
-  elsif args[0] == '--export'
+  elsif arg_str =~ /^--export\s*(.*)/
     # Export bookmarks to file
-    filename = args[1] || 'bookmarks.json'
+    filename = $1.strip
+    filename = 'bookmarks.json' if filename.empty?
     export_bookmarks(filename)
-  elsif args[0] == '--import'
+  elsif arg_str =~ /^--import\s+(.*)/
     # Import bookmarks from file
-    filename = args[1]
+    filename = $1.strip
     import_bookmarks(filename) if filename
-  elsif args[0] == '--stats'
+  elsif arg_str == '--stats'
     # Show bookmark statistics
     bookmark_stats
   elsif arg_str =~ /^(\w+)\s+(.+)$/
@@ -1603,8 +1701,8 @@ def bm(*args) # Enhanced bookmark management with tags
     rshrc
   end
 end
-def bookmark(*args) # Alias for bm
-  bm(*args)
+def bookmark(arg_str = nil) # Alias for bm
+  bm(arg_str)
 end
 def export_bookmarks(filename = 'bookmarks.json') # Export bookmarks to JSON
   begin
@@ -1669,6 +1767,7 @@ def bookmark_stats # Show bookmark usage statistics
 end
 def save_session(*args) # Save current session state
   session_name = args[0] || 'default'
+  silent = args[1] == :silent  # Optional silent flag
   session_path = @session_dir + "/#{session_name}.json"
 
   session = {
@@ -1682,9 +1781,9 @@ def save_session(*args) # Save current session state
   begin
     require 'json'
     File.write(session_path, JSON.pretty_generate(session))
-    puts "Session '#{session_name}' saved to #{session_path}"
+    puts "Session '#{session_name}' saved to #{session_path}" unless silent
   rescue => e
-    puts "Error saving session: #{e.message}"
+    puts "Error saving session: #{e.message}" unless silent
   end
 end
 def load_session(*args) # Restore previous session
@@ -2002,13 +2101,17 @@ def validate_command(cmd) # Syntax validation before execution
   return nil if cmd.nil? || cmd.empty?
   warnings = []
 
+  # Apply custom validation rules first
+  custom_warnings = apply_validation_rules(cmd)
+  warnings.concat(custom_warnings) if custom_warnings.any?
+
   # 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
+  # Check for potentially dangerous patterns (unless user has custom rules)
   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.*>/
@@ -2060,6 +2163,236 @@ def calc(*args) # Inline calculator using Ruby's Math library
     puts "Error evaluating expression: #{e.message}"
   end
 end
+def validate(rule_str = nil) # Custom validation rule management
+  if rule_str.nil? || rule_str.empty?
+    # List all validation rules
+    if @validation_rules.empty?
+      puts "\nNo validation rules defined"
+      puts "Usage: :validate pattern = action"
+      puts "Actions: block, confirm, warn, log"
+      return
+    end
+    puts "\n  Validation Rules:".c(@c_prompt).b
+    @validation_rules.each_with_index do |rule, i|
+      puts "  #{i+1}. #{rule[:pattern].inspect} → #{rule[:action]}"
+    end
+    puts
+  elsif rule_str =~ /^-(\d+)$/
+    # Delete rule by index
+    index = $1.to_i - 1
+    if index >= 0 && index < @validation_rules.length
+      rule = @validation_rules.delete_at(index)
+      puts "Validation rule deleted: #{rule[:pattern]}"
+      rshrc
+    else
+      puts "Invalid rule index: #{$1}"
+    end
+  elsif rule_str =~ /^(.+?)\s*=\s*(block|confirm|warn|log)$/
+    # Add validation rule
+    pattern = $1.strip
+    action = $2.strip
+    @validation_rules << {pattern: pattern, action: action}
+    puts "Validation rule added: #{pattern} → #{action}"
+    rshrc
+  else
+    puts "Usage: :validate pattern = action"
+    puts "Example: :validate rm -rf / = block"
+    puts "Actions: block (prevent), confirm (ask), warn (show), log (record)"
+  end
+end
+def apply_validation_rules(cmd) # Apply custom validation rules
+  return [] if @validation_rules.nil? || @validation_rules.empty?
+
+  warnings = []
+
+  @validation_rules.each do |rule|
+    if cmd =~ /#{rule[:pattern]}/
+      case rule[:action]
+      when 'block'
+        warnings << "BLOCKED by rule: #{rule[:pattern]}"
+      when 'confirm'
+        warnings << "CONFIRM required: #{rule[:pattern]}"
+      when 'warn'
+        warnings << "Warning: Matches rule '#{rule[:pattern]}'"
+      when 'log'
+        File.write("#{ENV['HOME']}/.rsh_validation.log",
+                   "#{Time.now}: #{cmd} (matched: #{rule[:pattern]})\n",
+                   mode: 'a')
+      end
+    end
+  end
+
+  warnings
+end
+def track_completion(context, selected) # Track completion selection for learning
+  return unless @completion_learning
+  return if context.nil? || selected.nil?
+
+  key = "#{context}:#{selected}"
+  @completion_weights[key] ||= 0
+  @completion_weights[key] += 1
+end
+def sort_by_learning(context, items) # Sort completions by learning weights
+  return items unless @completion_learning
+  return items if @completion_weights.empty?
+
+  # Score each item
+  scored = items.map do |item|
+    # Extract just the switch/command part (before space/description)
+    item_key = item.split(/\s+/).first
+    key = "#{context}:#{item_key}"
+    weight = @completion_weights[key] || 0
+    {item: item, weight: weight}
+  end
+
+  # Sort: highest weight first, then alphabetically
+  scored.sort_by { |s| [-s[:weight], s[:item]] }.map { |s| s[:item] }
+end
+def completion_stats # Show completion learning statistics
+  if @completion_weights.empty?
+    puts "\nNo completion learning data yet"
+    puts "Use TAB completion and selections will be learned over time"
+    return
+  end
+
+  puts "\n  Completion Learning Statistics".c(@c_prompt).b
+  puts "  " + "="*50
+
+  # Group by context
+  by_context = {}
+  @completion_weights.each do |key, weight|
+    context, choice = key.split(':', 2)
+    by_context[context] ||= []
+    by_context[context] << {choice: choice, weight: weight}
+  end
+
+  # Show top contexts
+  by_context.sort_by { |ctx, items| -items.map { |i| i[:weight] }.sum }.first(10).each do |context, items|
+    puts "\n  #{context}:".c(@c_nick)
+    items.sort_by { |i| -i[:weight] }.first(5).each do |item|
+      bar = "■" * ([item[:weight] / 2, 20].min)
+      puts "    #{item[:choice].ljust(20)} #{item[:weight].to_s.rjust(3)}x #{bar.c(@c_path)}"
+    end
+  end
+
+  puts "\n  Total learned patterns: #{@completion_weights.length}"
+  puts
+end
+def completion_reset # Reset all completion learning
+  @completion_weights = {}
+  puts "Completion learning data cleared"
+  rshrc
+end
+def record(*args) # Command recording management
+  action = args[0]
+  name = args[1]
+
+  if action.nil? || action.empty?
+    # List recordings
+    if @recordings.empty?
+      puts "\nNo recordings. Use: :record start name"
+      return
+    end
+
+    puts "\n  Recordings:".c(@c_prompt).b
+    @recordings.each do |rec_name, data|
+      created = Time.at(data[:created] || Time.now.to_i).strftime("%Y-%m-%d %H:%M")
+      count = data[:commands]&.length || 0
+      puts "  #{rec_name.ljust(20)} #{count.to_s.rjust(3)} commands  #{created}"
+    end
+    puts
+
+    # Show if currently recording
+    if @recording[:active]
+      puts "  Currently recording: #{@recording[:name]} (#{@recording[:commands].length} commands so far)".c(214)
+    end
+  elsif action == 'start' && name
+    @recording[:active] = true
+    @recording[:name] = name
+    @recording[:commands] = []
+    @recording[:start_time] = Time.now.to_i
+    puts "Recording started: #{name}".c(@c_path)
+  elsif action == 'stop'
+    if @recording[:active]
+      @recordings[@recording[:name]] = {
+        commands: @recording[:commands],
+        created: @recording[:start_time]
+      }
+      puts "Recording stopped: #{@recording[:name]} (#{@recording[:commands].length} commands)".c(@c_path)
+      @recording[:active] = false
+      rshrc
+    else
+      puts "No active recording"
+    end
+  elsif action == 'status'
+    if @recording[:active]
+      puts "Recording: #{@recording[:name]} (#{@recording[:commands].length} commands)"
+      @recording[:commands].last(5).each { |cmd| puts "  #{cmd}" }
+    else
+      puts "No active recording"
+    end
+  elsif action == 'show' && name
+    # Show recording contents
+    unless @recordings[name]
+      puts "Recording '#{name}' not found"
+      return
+    end
+
+    recording = @recordings[name]
+    created = Time.at(recording[:created] || Time.now.to_i).strftime("%Y-%m-%d %H:%M:%S")
+
+    puts "\n  Recording: #{name}".c(@c_prompt).b
+    puts "  Created: #{created}"
+    puts "  Commands: #{recording[:commands].length}"
+    puts
+
+    recording[:commands].each_with_index do |cmd, i|
+      puts "  #{(i+1).to_s.rjust(3)}. #{cmd}"
+    end
+    puts
+  elsif action =~ /^-(.+)$/
+    # Delete recording
+    rec_name = $1
+    if @recordings.delete(rec_name)
+      puts "Recording '#{rec_name}' deleted"
+      rshrc
+    else
+      puts "Recording '#{rec_name}' not found"
+    end
+  else
+    puts "Usage: :record start name|stop|status|show name|-name"
+  end
+end
+def replay(*args) # Replay recorded commands
+  name = args[0]
+
+  unless name && @recordings[name]
+    puts "Recording '#{name}' not found"
+    record
+    return
+  end
+
+  recording = @recordings[name]
+  commands = recording[:commands] || []
+
+  puts "Replaying '#{name}' (#{commands.length} commands)...".c(@c_path)
+
+  commands.each_with_index do |cmd, i|
+    puts "\n[#{i+1}/#{commands.length}] #{cmd}".c(@c_stamp)
+
+    result = system(cmd)
+    exit_code = $?.exitstatus
+
+    unless result
+      puts " Command failed (exit #{exit_code})".c(196)
+      print "Continue? (Y/n): "
+      response = $stdin.gets.chomp
+      break if response.downcase == 'n'
+    end
+  end
+
+  puts "\nReplay complete".c(@c_path)
+end
 def apply_auto_correct(cmd) # Apply auto-correction to command
   return cmd unless @auto_correct
   return cmd if cmd =~ /^:/  # Don't auto-correct colon commands
@@ -2067,6 +2400,11 @@ def apply_auto_correct(cmd) # Apply auto-correction to command
 
   first_cmd = $1
 
+  # Don't auto-correct shell keywords or shell scripts
+  shell_keywords = %w[for while if then else elif fi do done case esac function select until]
+  return cmd if shell_keywords.include?(first_cmd)
+  return cmd if cmd =~ /\b(for|while|if|case|function|until)\b/  # Skip shell scripts
+
   # Don't auto-correct if command exists
   return cmd if @exe.include?(first_cmd)
   return cmd if @nick.include?(first_cmd)
@@ -2370,6 +2708,11 @@ def load_rshrc_safe
     @plugin_disabled = [] unless @plugin_disabled.is_a?(Array)
     @plugins = [] unless @plugins.is_a?(Array)
     @plugin_commands = {} unless @plugin_commands.is_a?(Hash)
+    @validation_rules = [] unless @validation_rules.is_a?(Array)
+    @completion_weights = {} unless @completion_weights.is_a?(Hash)
+    @completion_learning = true if @completion_learning.nil?
+    @recording = {active: false, name: nil, commands: []} unless @recording.is_a?(Hash)
+    @recordings = {} unless @recordings.is_a?(Hash)
 
     # Restore defuns from .rshrc
     if @defuns && !@defuns.empty?
@@ -2511,6 +2854,11 @@ def load_defaults
   @plugin_disabled ||= []
   @plugins ||= []
   @plugin_commands ||= {}
+  @validation_rules ||= []
+  @completion_weights ||= {}
+  @completion_learning = true if @completion_learning.nil?
+  @recording ||= {active: false, name: nil, commands: []}
+  @recordings ||= {}
   puts "Loaded with default configuration."
 end
 
@@ -2609,7 +2957,7 @@ loop do
     if @session_autosave && @session_autosave > 0
       current_time = Time.now.to_i
       if (current_time - @session_last_save) >= @session_autosave
-        save_session('autosave')
+        save_session('autosave', :silent)
         @session_last_save = current_time
       end
     end
@@ -2687,8 +3035,47 @@ loop do
     end
     if @cmd.match(/^\s*:/) # Ruby commands are prefixed with ":"
       begin
-        eval(@cmd[1..-1])
-      #rescue StandardError => err
+        cmd_line = @cmd[1..-1].strip
+
+        # Extract command name and arguments
+        if cmd_line =~ /^(\w+\??)(.*)$/
+          cmd_name = $1
+          cmd_args_raw = $2.strip
+
+          # Commands that parse their own args (need full string)
+          # nick/gnick parse "name = value"
+          # defun parses "name(args) = body"
+          # bm parses "name path #tags" or "-name" or "?tag" or "--export file"
+          # validate parses "pattern = action"
+          single_string_cmds = %w[nick gnick defun bm bookmark validate]
+
+          # List of all known rsh commands (since respond_to? doesn't work for top-level methods)
+          known_commands = %w[nick gnick defun defun? bm bookmark stats calc config env theme plugins
+                              save_session load_session list_sessions delete_session rmsession
+                              validate completion_stats completion_reset
+                              record replay
+                              history rmhistory jobs fg bg dirs help info version]
+
+          # Try to call as rsh method
+          if known_commands.include?(cmd_name)
+            if cmd_args_raw.empty?
+              send(cmd_name.to_sym)
+            elsif single_string_cmds.include?(cmd_name)
+              # Pass entire args string for commands that parse it themselves
+              send(cmd_name.to_sym, cmd_args_raw)
+            else
+              # Split args for variadic functions
+              args = cmd_args_raw.split(/\s+/)
+              send(cmd_name.to_sym, *args)
+            end
+          else
+            # Fallback to eval for arbitrary Ruby (like :puts 2+2)
+            eval(cmd_line)
+          end
+        else
+          # Fallback to eval
+          eval(cmd_line)
+        end
       rescue Exception => err
         puts "\n#{err}"
       end
@@ -2723,20 +3110,48 @@ loop do
           execute_conditional(@cmd)
           next
         end
-        # Expand brace expansion {a,b,c}
-        @cmd = expand_braces(@cmd)
-        # Expand command substitution $(command) and backticks
-        @cmd = @cmd.gsub(/\$\(([^)]+)\)/) { `#{$1}`.chomp }
-        @cmd = @cmd.gsub(/`([^`]+)`/) { `#{$1}`.chomp }
-        # Expand environment variables and exit status
-        @cmd = @cmd.gsub(/\$\?/) { @last_exit.to_s }
-        @cmd = @cmd.gsub(/\$(\w+)|\$\{(\w+)\}/) { ENV[$1 || $2] || '' }
-        # Expand tilde
+        # Detect shell scripting constructs - skip expansions if found
+        is_shell_script = !(@cmd =~ /\b(for|while|if|case|function|until)\b/).nil?
+
+        unless is_shell_script
+          # Expand brace expansion {a,b,c}
+          @cmd = expand_braces(@cmd)
+          # Expand command substitution $(command) and backticks
+          @cmd = @cmd.gsub(/\$\(([^)]+)\)/) { `#{$1}`.chomp }
+          @cmd = @cmd.gsub(/`([^`]+)`/) { `#{$1}`.chomp }
+          # Expand environment variables and exit status
+          @cmd = @cmd.gsub(/\$\?/) { @last_exit.to_s }
+          @cmd = @cmd.gsub(/\$(\w+)|\$\{(\w+)\}/) { ENV[$1 || $2] || '' }
+        end
+        # Always expand tilde
         @cmd = @cmd.gsub(/~/, Dir.home)
-        ca = @nick.transform_keys {|k| /((^\K\s*\K)|(\|\K\s*\K))\b(?<!-)#{Regexp.escape k}\b/}
-        @cmd = @cmd.gsub(Regexp.union(ca.keys), @nick)
-        ga = @gnick.transform_keys {|k| /\b(?<!-)#{Regexp.escape k}\b/}
-        @cmd = @cmd.gsub(Regexp.union(ga.keys), @gnick)
+        # Skip nick/gnick substitution for shell scripts
+        unless is_shell_script
+          # Check for parametrized nick BEFORE substitution
+          cmd_parts_before = @cmd.split(/\s+/)
+          first_cmd = cmd_parts_before[0]
+          used_param_nick = first_cmd && @nick[first_cmd] && @nick[first_cmd].include?('{{')
+
+          # Do nick/gnick substitution
+          ca = @nick.transform_keys {|k| /((^\K\s*\K)|(\|\K\s*\K))\b(?<!-)#{Regexp.escape k}\b/}
+          @cmd = @cmd.gsub(Regexp.union(ca.keys), @nick)
+          ga = @gnick.transform_keys {|k| /\b(?<!-)#{Regexp.escape k}\b/}
+          @cmd = @cmd.gsub(Regexp.union(ga.keys), @gnick)
+
+          # Expand placeholders if parametrized nick was used
+          if used_param_nick
+            params = {}
+            cmd_parts_before[1..].each do |part|
+              if part =~ /^(\w+)=(.+)$/
+                params[$1] = $2
+              end
+            end
+            # Replace placeholders
+            params.each { |k, v| @cmd.gsub!(/\{\{#{k}\}\}/, v) }
+            # Remove key=value parameters from command
+            @cmd = @cmd.split(/\s+/).reject { |p| p =~ /^\w+=/ }.join(' ')
+          end
+        end
         @cmd = "~" if @cmd == "cd"
         @cmd.sub!(/^cd (\S*).*/, '\1')
         @cmd = Dir.home if @cmd == "~"
@@ -2785,8 +3200,16 @@ loop do
               # Validate command after auto-correction
               warnings = validate_command(@cmd)
               if warnings && !warnings.empty?
+                # Check for BLOCKED commands
+                if warnings.any? { |w| w.start_with?("BLOCKED") }
+                  warnings.select { |w| w.start_with?("BLOCKED") }.each { |w| puts "#{w}".c(196) }
+                  puts "Command execution blocked by validation rule"
+                  next
+                end
+
                 # Show non-auto-correct warnings
-                warnings.reject { |w| w.start_with?("AUTO-CORRECTING:") }.each { |w| puts "#{w}".c(196) }
+                warnings.reject { |w| w.start_with?("AUTO-CORRECTING:") || w.start_with?("CONFIRM") }.each { |w| puts "#{w}".c(196) }
+
                 # Show auto-correct and ask for confirmation
                 auto_correct_warnings = warnings.select { |w| w.start_with?("AUTO-CORRECTING:") }
                 if auto_correct_warnings.any?
@@ -2798,7 +3221,19 @@ loop do
                     next
                   end
                 end
-                # For critical warnings, ask for confirmation
+
+                # For CONFIRM validation rules
+                if warnings.any? { |w| w.start_with?("CONFIRM") }
+                  warnings.select { |w| w.start_with?("CONFIRM") }.each { |w| puts "#{w}".c(214) }
+                  print "Confirm execution? (y/N): "
+                  response = $stdin.gets.chomp
+                  unless response.downcase == 'y'
+                    puts "Command cancelled"
+                    next
+                  end
+                end
+
+                # For other critical warnings
                 if warnings.any? { |w| w.start_with?("WARNING:") }
                   print "Continue anyway? (y/N): "
                   response = $stdin.gets.chomp
@@ -2829,6 +3264,9 @@ loop do
               # Start timing
               start_time = Time.now
 
+              # Detect if command needs bash (for loops, etc.)
+              needs_bash = !(@cmd =~ /\b(for|while|if|case|function|until)\b/).nil? || @cmd.include?(';')
+
               # Handle background jobs
               if @cmd.end_with?(' &')
                 @cmd = @cmd[0..-3]  # Remove the &
@@ -2837,13 +3275,21 @@ loop do
                 if @cmd.include?('|') || @cmd.include?('>') || @cmd.include?('<')
                   pid = spawn(@cmd, pgroup: true)
                 else
-                  pid = spawn(@cmd)
+                  if needs_bash
+                    pid = spawn("bash", "-c", @cmd)
+                  else
+                    pid = spawn(@cmd)
+                  end
                 end
                 @jobs[@job_id] = {pid: pid, cmd: @cmd, status: :running}
                 puts "[#{@job_id}] #{pid} #{@cmd}"
               else
                 # Better handling of pipes and redirections
-                @current_pid = spawn(@cmd)
+                if needs_bash
+                  @current_pid = spawn("bash", "-c", @cmd)
+                else
+                  @current_pid = spawn(@cmd)
+                end
                 Process.wait(@current_pid)
                 @last_exit = $?.exitstatus
                 @current_pid = nil
@@ -2864,6 +3310,14 @@ loop do
                 puts "⚠ Command took #{'%.1f' % elapsed}s (threshold: #{@slow_command_threshold}s)".c(214)
               end
 
+              # Record command if recording is active
+              if @recording[:active] && @last_exit == 0
+                # Don't record :record commands themselves
+                unless @cmd =~ /^:record/
+                  @recording[:commands] << @cmd
+                end
+              end
+
               # Call plugin on_command_after hooks
               call_plugin_hook(:on_command_after, @cmd, @last_exit)
 

metadata

@@ -1,20 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: ruby-shell
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-22 00:00:00.000000000 Z
+date: 2025-10-23 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
-  v3.2.0: PLUGIN SYSTEM - Extensible architecture with lifecycle hooks (on_startup,
-  on_command_before/after, on_prompt), extension points (add_completions, add_commands),
-  plugin management, and 3 example plugins included. Plus colon command theming!'
+  v3.4.0: COMPLETION LEARNING - Shell learns which TAB completions you use most and
+  intelligently ranks them higher. Context-aware learning per command. :completion_stats
+  shows patterns. Persistent across sessions. Plus all v3.3 features: quote-less syntax,
+  parametrized nicks, Ctrl-G editing, validation rules, shell scripts!'
 email: g@isene.com
 executables:
 - rsh