ruby-shell 3.1.0 → 3.3.0

data/bin/rsh

@@ -8,7 +8,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rsh
 # License:    Public domain
-@version    = "3.1.0" # Quick wins: Multiple sessions, stats export, bookmark features, themes, config, env management
+@version    = "3.3.0" # Quote-less syntax: Simplified colon commands without quotes for cleaner UX
 
 # MODULES, CLASSES AND EXTENSIONS
 class String # Add coloring to strings (with escaping for Readline)
@@ -144,8 +144,17 @@ begin # Initialization
   @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'
+  @auto_correct = false                   # Auto-correct typos (default: off)
+  @slow_command_threshold = 0             # Threshold for slow command alerts (0 = disabled)
+  @plugin_dir = Dir.home + '/.rsh/plugins' # Plugins directory
+  @plugins = []                           # Loaded plugin instances
+  @plugin_disabled = []                   # List of disabled plugin names
+  @plugin_commands = {}                   # Commands added by plugins
+  @validation_rules = []                  # Custom validation rules
+  # 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)
+  Dir.mkdir(@plugin_dir) unless Dir.exist?(@plugin_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
@@ -153,7 +162,7 @@ end
 # HELP TEXT
 @info = <<~INFO
 
-  Hello #{@user}, welcome to rsh v3.1 - 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
@@ -179,7 +188,24 @@ 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.1:
+  NEW in v3.3:
+  * Quote-less syntax - No more quotes! Use :nick la = ls -la instead of :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
+  * Simplified - Removed :template, everything now in :nick
+  * Backward compatible - Old quote syntax still works
+
+  v3.2 Features:
+  * Plugin system - Extensible architecture for custom commands, completions, and hooks
+  * 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
+
+  v3.1 Features:
   * 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
@@ -188,8 +214,6 @@ end
   * 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).
@@ -337,8 +361,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"
@@ -602,7 +641,7 @@ 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
+        :config :env :theme :plugins :calc :validate
         :info :version :help
       ]
       search_str = @tabstr[1..-1] || ""  # Remove leading :
@@ -887,6 +926,8 @@ def config(*args) # Configure rsh settings
     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 "    auto_correct:       #{@auto_correct ? 'on' : 'off'}"
+    puts "    slow_command_threshold: #{@slow_command_threshold}s #{@slow_command_threshold > 0 ? '(enabled)' : '(disabled)'}"
     puts "    completion_limit:   #{@completion_limit}"
     puts "    completion_fuzzy:   #{@completion_fuzzy}"
     puts "    completion_case_sensitive: #{@completion_case_sensitive}"
@@ -907,13 +948,21 @@ def config(*args) # Configure rsh settings
     @session_autosave = value.to_i
     puts "Session auto-save set to #{value}s #{value.to_i > 0 ? '(enabled)' : '(disabled)'}"
     rshrc
+  when 'auto_correct'
+    @auto_correct = %w[on true yes 1].include?(value.to_s.downcase)
+    puts "Auto-correct #{@auto_correct ? 'enabled' : 'disabled'}"
+    rshrc
+  when 'slow_command_threshold'
+    @slow_command_threshold = value.to_i
+    puts "Slow command threshold 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"
+    puts "Available: history_dedup, session_autosave, auto_correct, slow_command_threshold, completion_limit"
   end
 end
 def env(*args) # Environment variable management
@@ -1024,6 +1073,14 @@ def rshrc # Write updates to .rshrc
   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
+  conf.sub!(/^@auto_correct.*(\n|$)/, "")
+  conf += "@auto_correct = #{@auto_correct}\n" if @auto_correct
+  conf.sub!(/^@slow_command_threshold.*(\n|$)/, "")
+  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?
   # Only write @cmd_completions if user has customized it
   unless conf =~ /^@cmd_completions\s*=/
     # Don't write default completions to avoid cluttering .rshrc
@@ -1038,7 +1095,7 @@ 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
@@ -1061,23 +1118,24 @@ def help
   left_col << "UP/DOWN         Navigate history"
   left_col << "TAB             Tab complete"
   left_col << "Shift-TAB       Search history"
+  left_col << "Ctrl-G          Edit in $EDITOR"
   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-C          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 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 << ":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"
@@ -1086,9 +1144,9 @@ def help
   
   # Right column content
   right_col << "RUBY FUNCTIONS:".c(@c_prompt).b
-  right_col << ":defun 'f(x) = x*2' Define function"
+  right_col << ":defun f(x) = x*2   Define function"
   right_col << ":defun?             List functions"
-  right_col << ":defun '-f'         Remove function"
+  right_col << ":defun -f           Remove function"
   right_col << "Call as: f 5        (returns 10)"
   right_col << ""
   right_col << "JOB CONTROL:".c(@c_prompt).b
@@ -1097,20 +1155,30 @@ 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 << "v3.3 NEW FEATURES:".c(@c_prompt).b
+  right_col << "No quotes!          :nick la = ls -la"
+  right_col << ":nick gp={{branch}} Parametrized"
+  right_col << ":validate pat = act Safety rules"
+  right_col << "Ctrl-G              Edit in \$EDITOR"
+  right_col << "for i in {1..5}     Shell scripts"
+  right_col << ""
+  right_col << "v3.2 FEATURES:".c(@c_prompt).b
+  right_col << ":plugins [cmd]      Plugin system"
+  right_col << ":stats --graph      Visual charts"
+  right_col << ":calc 2 + 2         Calculator"
+  right_col << "!!, !-2, !5:7       History chain"
+  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 << ""
+  right_col << "MORE FEATURES:".c(@c_prompt).b
+  right_col << ":config auto_correct Auto-fix"
+  right_col << ":bm name path #tags Bookmarks"
+  right_col << ":save_session nm    Sessions"
+  right_col << ":theme name         Themes"
+  right_col << ":env VAR            Env vars"
   right_col << ""
   right_col << "INTEGRATIONS:".c(@c_prompt).b
   right_col << "r                   Launch rtfm"
@@ -1331,6 +1399,16 @@ def stats(*args) # Show command execution statistics and analytics
     fname = filename || "rsh_stats.csv"
     export_stats_csv(fname)
     return
+  elsif format == "--graph"
+    stats_graph
+    return
+  elsif format == "--clear"
+    # Clear all statistics
+    @cmd_frequency = {}
+    @cmd_stats = {}
+    puts "All statistics cleared"
+    rshrc
+    return
   end
 
   # Display stats (existing code)
@@ -1373,6 +1451,59 @@ def stats(*args) # Show command execution statistics and analytics
   puts "\n  Last command exit status: #{@last_exit == 0 ? 'Success'.c(@c_path) : "Failed (#{@last_exit})".c(196)}"
   puts
 end
+def stats_graph # Visual graph mode for stats
+  puts "\n  Command Usage Graph".c(@c_prompt).b
+  puts "  " + "="*50
+
+  return puts "No data to display" if @cmd_frequency.nil? || @cmd_frequency.empty?
+
+  sorted = @cmd_frequency.sort_by { |_, count| -count }.first(15)
+  max_count = sorted.first[1]
+  max_width = 40
+
+  puts
+  sorted.each_with_index do |(cmd, count), i|
+    # Calculate bar width (scaled to max_width)
+    bar_width = (count.to_f / max_count * max_width).round
+    bar = "█" * bar_width
+
+    # Color bars by intensity
+    color = case bar_width
+    when 0..10 then 244    # Gray
+    when 11..20 then 3     # Yellow
+    when 21..30 then 214   # Orange
+    else 196               # Red
+    end
+
+    puts "  #{cmd.ljust(15)} #{count.to_s.rjust(4)}x #{bar.c(color)}"
+  end
+
+  # Performance graph if data exists
+  if @cmd_stats && !@cmd_stats.empty?
+    puts "\n  Command Performance Graph (avg time)".c(@c_prompt).b
+    puts "  " + "="*50
+    puts
+
+    slowest = @cmd_stats.sort_by { |_, s| -(s[:avg_time] || 0) }.first(10)
+    max_time = slowest.first[1][:avg_time]
+
+    slowest.each do |cmd, stats|
+      bar_width = (stats[:avg_time] / max_time * max_width).round
+      bar = "█" * bar_width
+
+      color = case bar_width
+      when 0..10 then 2      # Green (fast)
+      when 11..20 then 214   # Orange
+      else 196               # Red (slow)
+      end
+
+      time_str = "#{'%.3f' % stats[:avg_time]}s"
+      puts "  #{cmd.ljust(15)} #{time_str.rjust(8)} #{bar.c(color)}"
+    end
+  end
+
+  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)
@@ -1421,11 +1552,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"
@@ -1438,15 +1566,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+(.+)$/
@@ -1498,8 +1627,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
@@ -1564,6 +1693,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 = {
@@ -1577,9 +1707,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
@@ -1744,34 +1874,309 @@ def theme(*args) # Apply color scheme presets
   puts "Theme '#{name}' applied"
   puts "Add this to .rshrc to make it permanent: :theme \"#{name}\""
 end
+def load_plugins # Load all plugins from plugin directory
+  return unless Dir.exist?(@plugin_dir)
+
+  plugin_files = Dir.glob(@plugin_dir + '/*.rb').sort
+
+  plugin_files.each do |plugin_file|
+    plugin_name = File.basename(plugin_file, '.rb')
+
+    # Skip if disabled
+    next if @plugin_disabled.include?(plugin_name)
+
+    begin
+      # Load the plugin file
+      load(plugin_file)
+
+      # Find the plugin class (conventionally PluginNamePlugin)
+      class_name = plugin_name.split('_').map(&:capitalize).join + 'Plugin'
+
+      # Try to instantiate the plugin
+      if Object.const_defined?(class_name)
+        plugin_class = Object.const_get(class_name)
+        rsh_context = {
+          version: @version,
+          history: @history,
+          bookmarks: @bookmarks,
+          nick: @nick,
+          gnick: @gnick,
+          pwd: Dir.pwd,
+          config: method(:config),
+          rsh: self
+        }
+        plugin_instance = plugin_class.new(rsh_context)
+        @plugins << { name: plugin_name, instance: plugin_instance, class: class_name }
+
+        # Load plugin completions
+        if plugin_instance.respond_to?(:add_completions)
+          completions = plugin_instance.add_completions
+          @cmd_completions.merge!(completions) if completions.is_a?(Hash)
+        end
+
+        # Load plugin commands
+        if plugin_instance.respond_to?(:add_commands)
+          commands = plugin_instance.add_commands
+          @plugin_commands.merge!(commands) if commands.is_a?(Hash)
+        end
+
+        puts "  Loaded plugin: #{plugin_name} (#{class_name})" if ENV['RSH_DEBUG']
+      end
+    rescue => e
+      puts "Warning: Failed to load plugin '#{plugin_name}': #{e.message}" if ENV['RSH_DEBUG']
+      puts "  #{e.backtrace.first}" if ENV['RSH_DEBUG']
+    end
+  end
+
+  # Call on_startup for all plugins
+  @plugins.each do |plugin|
+    begin
+      plugin[:instance].on_startup if plugin[:instance].respond_to?(:on_startup)
+    rescue => e
+      puts "Warning: Plugin '#{plugin[:name]}' on_startup failed: #{e.message}" if ENV['RSH_DEBUG']
+    end
+  end
+end
+def call_plugin_hook(hook_name, *args) # Call a lifecycle hook for all plugins
+  results = []
+  @plugins.each do |plugin|
+    begin
+      if plugin[:instance].respond_to?(hook_name)
+        result = plugin[:instance].send(hook_name, *args)
+        results << result unless result.nil?
+      end
+    rescue => e
+      puts "Warning: Plugin '#{plugin[:name]}' hook '#{hook_name}' failed: #{e.message}" if ENV['RSH_DEBUG']
+    end
+  end
+  results
+end
+def plugins(*args) # Plugin management command
+  if args.empty?
+    # List all plugins
+    if @plugins.empty?
+      puts "\nNo plugins loaded"
+      puts "Place .rb files in #{@plugin_dir}"
+      return
+    end
+
+    puts "\n  Loaded Plugins:".c(@c_prompt).b
+    @plugins.each do |plugin|
+      status = @plugin_disabled.include?(plugin[:name]) ? '[disabled]'.c(196) : '[enabled]'.c(@c_path)
+      puts "    #{plugin[:name].ljust(20)} #{status} (#{plugin[:class]})"
+    end
+
+    unless @plugin_disabled.empty?
+      puts "\n  Disabled Plugins:".c(@c_stamp)
+      @plugin_disabled.each { |name| puts "    #{name}" }
+    end
+    puts
+  elsif args[0] == 'reload'
+    # Reload all plugins
+    @plugins = []
+    @plugin_commands = {}
+    load_plugins
+    puts "Plugins reloaded (#{@plugins.length} loaded)"
+  elsif args[0] == 'enable' && args[1]
+    # Enable a plugin
+    plugin_name = args[1]
+    @plugin_disabled.delete(plugin_name)
+    puts "Plugin '#{plugin_name}' enabled. Use :plugins reload to load it"
+    rshrc
+  elsif args[0] == 'disable' && args[1]
+    # Disable a plugin
+    plugin_name = args[1]
+    unless @plugin_disabled.include?(plugin_name)
+      @plugin_disabled << plugin_name
+    end
+    @plugins.reject! { |p| p[:name] == plugin_name }
+    puts "Plugin '#{plugin_name}' disabled"
+    rshrc
+  elsif args[0] == 'info' && args[1]
+    # Show plugin info
+    plugin_name = args[1]
+    plugin = @plugins.find { |p| p[:name] == plugin_name }
+    if plugin
+      puts "\n  Plugin: #{plugin_name}".c(@c_prompt).b
+      puts "    Class: #{plugin[:class]}"
+      puts "    File: #{@plugin_dir}/#{plugin_name}.rb"
+
+      puts "\n  Hooks:".c(@c_nick)
+      %i[on_startup on_command_before on_command_after on_prompt].each do |hook|
+        has_hook = plugin[:instance].respond_to?(hook) ? '✓' : '✗'
+        puts "    #{has_hook} #{hook}"
+      end
+
+      puts "\n  Extensions:".c(@c_nick)
+      puts "    ✓ add_completions" if plugin[:instance].respond_to?(:add_completions)
+      puts "    ✓ add_commands" if plugin[:instance].respond_to?(:add_commands)
+      puts
+    else
+      puts "Plugin '#{plugin_name}' not found"
+    end
+  else
+    puts "Usage:"
+    puts "  :plugins              List all plugins"
+    puts "  :plugins reload       Reload all plugins"
+    puts "  :plugins enable NAME  Enable a plugin"
+    puts "  :plugins disable NAME Disable a plugin"
+    puts "  :plugins info NAME    Show plugin details"
+  end
+end
 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.*>/
 
-  # Check for common typos in popular commands
-  if cmd =~ /^(\w+)/
+  # Check for common typos in popular commands (skip for : commands)
+  if cmd =~ /^(\w+)/ && cmd !~ /^:/
     first_cmd = $1
-    unless @exe.include?(first_cmd) || @nick.include?(first_cmd) || first_cmd == "cd"
+    # Check if command exists (don't warn for valid commands)
+    is_valid_cmd = @exe.include?(first_cmd) ||
+                   @nick.include?(first_cmd) ||
+                   first_cmd == "cd" ||
+                   (@plugin_commands && @plugin_commands[first_cmd]) ||
+                   (@defuns && @defuns.keys.include?(first_cmd))
+
+    unless is_valid_cmd
       suggestions = suggest_command(first_cmd)
       if suggestions && !suggestions.empty?
-        warnings << "Command '#{first_cmd}' not found. Did you mean: #{suggestions.join(', ')}?"
+        # Auto-correct if enabled and first suggestion has distance ≤ 2
+        if @auto_correct && levenshtein_distance(first_cmd, suggestions[0]) <= 2
+          warnings << "AUTO-CORRECTING: '#{first_cmd}' → '#{suggestions[0]}'"
+        else
+          warnings << "Command '#{first_cmd}' not found. Did you mean: #{suggestions.join(', ')}?"
+        end
       end
     end
   end
 
   warnings.empty? ? nil : warnings
 end
+def calc(*args) # Inline calculator using Ruby's Math library
+  if args.empty?
+    puts "Usage: calc <expression>"
+    puts "Examples:"
+    puts "  calc 2 + 2"
+    puts "  calc \"Math.sqrt(16)\""
+    puts "  calc \"Math::PI * 2\""
+    return
+  end
+
+  expression = args.join(' ')
+
+  begin
+    # Safe evaluation with Math library
+    result = eval(expression, binding, __FILE__, __LINE__)
+    puts result
+  rescue SyntaxError => e
+    puts "Syntax error in expression: #{e.message}"
+  rescue => e
+    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 apply_auto_correct(cmd) # Apply auto-correction to command
+  return cmd unless @auto_correct
+  return cmd if cmd =~ /^:/  # Don't auto-correct colon commands
+  return cmd unless cmd =~ /^(\w+)/
+
+  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)
+  return cmd if first_cmd == "cd"
+  return cmd if @plugin_commands && @plugin_commands[first_cmd]
+  return cmd if @defuns && @defuns.keys.include?(first_cmd)  # Check user defuns
+
+  suggestions = suggest_command(first_cmd)
+  if suggestions && !suggestions.empty? && levenshtein_distance(first_cmd, suggestions[0]) <= 2
+    # Auto-correct using first (closest) suggestion
+    cmd.sub(/^#{first_cmd}/, suggestions[0])
+  else
+    cmd
+  end
+end
 def execute_conditional(cmd_line)
   # Split on && and || while preserving the operators
   parts = cmd_line.split(/(\s*&&\s*|\s*\|\|\s*)/)
@@ -2055,6 +2460,12 @@ def load_rshrc_safe
     @defuns = {} unless @defuns.is_a?(Hash)
     @history_dedup = 'smart' unless @history_dedup.is_a?(String)
     @session_autosave = 0 unless @session_autosave.is_a?(Integer)
+    @auto_correct = false unless [@auto_correct].any? { |v| v == true || v == false }
+    @slow_command_threshold = 0 unless @slow_command_threshold.is_a?(Integer)
+    @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)
 
     # Restore defuns from .rshrc
     if @defuns && !@defuns.empty?
@@ -2191,6 +2602,12 @@ def load_defaults
   @switch_cache_time ||= {}
   @history_dedup ||= 'smart'
   @session_autosave ||= 0
+  @auto_correct ||= false
+  @slow_command_threshold ||= 0
+  @plugin_disabled ||= []
+  @plugins ||= []
+  @plugin_commands ||= {}
+  @validation_rules ||= []
   puts "Loaded with default configuration."
 end
 
@@ -2264,6 +2681,7 @@ begin # Load .rshrc and populate @history
   @c.restore                # Max row & col gotten, cursor restored
   hist_clean                # Remove duplicates, etc
   @path.map! {|p| p + "/*"} # Set proper format for path search
+  @plugins_loaded = false   # Defer plugin loading until first command
 end
 
 # MAIN PART
@@ -2273,14 +2691,22 @@ loop do
     @node = Etc.uname[:nodename]            # For use in @prompt
     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 
+    system("printf \"\033]0;rsh: #{Dir.pwd}\007\"")   # Set Window title to path
     @history[0] = "" unless @history[0]
     cache_executables  # Use cached executable lookup
+    # Load plugins on first command (lazy loading)
+    unless @plugins_loaded
+      load_plugins
+      @plugins_loaded = true
+    end
+    # Append plugin prompt additions (after plugins loaded)
+    plugin_prompts = call_plugin_hook(:on_prompt)
+    @prompt += plugin_prompts.join if plugin_prompts.any?
     # 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')
+        save_session('autosave', :silent)
         @session_last_save = current_time
       end
     end
@@ -2290,8 +2716,33 @@ loop do
     @dirs.pop
     hist_clean # Clean up the history
     @cmd = "ls" if @cmd == "" # Default to ls when no command is given
-    if @cmd.match(/^!\d+/)
-      hi = @history[@cmd.sub(/^!(\d+)$/, '\1').to_i+1] 
+    # Enhanced history commands
+    if @cmd == '!!'
+      # Repeat last command
+      @cmd = @history[1] if @history.length > 1
+    elsif @cmd =~ /^!-(\d+)$/
+      # Repeat nth to last (e.g., !-2 = 2nd to last)
+      index = $1.to_i
+      @cmd = @history[index] if @history.length > index
+    elsif @cmd =~ /^!(\d+):(\d+)$/
+      # Chain commands (e.g., !5:7 = commands 5, 6, 7)
+      start_idx = $1.to_i + 1
+      end_idx = $2.to_i + 1
+      if start_idx < @history.length && end_idx < @history.length && start_idx <= end_idx
+        commands = @history[start_idx..end_idx].compact.reverse
+        # Filter out colon commands (they don't work in shell chains)
+        commands.reject! { |c| c =~ /^:/ }
+        if commands.empty?
+          puts "Cannot chain colon commands (use shell commands only)"
+          @cmd = "ls"  # Default to ls
+        else
+          @cmd = commands.join(' && ')
+          puts " Chaining: #{@cmd}".c(@c_stamp)
+        end
+      end
+    elsif @cmd.match(/^!\d+$/)
+      # Original: !5 = command 5
+      hi = @history[@cmd.sub(/^!(\d+)$/, '\1').to_i+1]
       @cmd = hi if hi
     end
     # Move cursor to end of line and print the full command before clearing
@@ -2333,26 +2784,73 @@ 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
+                              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
     elsif @cmd == '#' # List previous directories
       dirs
     else # Execute command
-      # Check if it's a user-defined Ruby function FIRST (before any expansions)
+      # Check if it's a plugin command FIRST
       cmd_parts = @cmd.split(/\s+/)
-      func_name = cmd_parts[0]
-      if self.respond_to?(func_name) && singleton_class.instance_methods(false).include?(func_name.to_sym)
+      cmd_name = cmd_parts[0]
+      if @plugin_commands && @plugin_commands[cmd_name]
+        begin
+          args = cmd_parts[1..]
+          result = @plugin_commands[cmd_name].call(*args)
+          puts result unless result.nil?
+        rescue => e
+          puts "Error in plugin command '#{cmd_name}': #{e}"
+        end
+      # Then check if it's a user-defined Ruby function (before any expansions)
+      elsif self.respond_to?(cmd_name) && singleton_class.instance_methods(false).include?(cmd_name.to_sym)
         begin
           args = cmd_parts[1..]
-          puts "DEBUG: Calling #{func_name} with args: #{args}" if ENV['RSH_DEBUG']
-          result = self.send(func_name, *args)
+          puts "DEBUG: Calling #{cmd_name} with args: #{args}" if ENV['RSH_DEBUG']
+          result = self.send(cmd_name, *args)
           puts "DEBUG: Result: #{result.inspect}" if ENV['RSH_DEBUG']
           puts result unless result.nil?
         rescue => e
-          puts "Error calling function '#{func_name}': #{e}"
+          puts "Error calling function '#{cmd_name}': #{e}"
         end
       else
         # Handle conditional execution (&& and ||)
@@ -2360,20 +2858,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 == "~"
@@ -2414,11 +2940,48 @@ loop do
             end
           else
             begin
-              # Validate command before execution
+              pre_cmd
+
+              # Apply auto-correct if enabled (before validation)
+              @cmd = apply_auto_correct(@cmd)
+
+              # Validate command after auto-correction
               warnings = validate_command(@cmd)
               if warnings && !warnings.empty?
-                warnings.each { |w| puts "#{w}".c(196) }
-                # For critical warnings, ask for confirmation
+                # 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:") || 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?
+                  auto_correct_warnings.each { |w| puts "#{w}".c(214) }
+                  print "Accept auto-correction? (Y/n): "
+                  response = $stdin.gets.chomp
+                  if response.downcase == 'n'
+                    puts "Auto-correction cancelled"
+                    next
+                  end
+                end
+
+                # 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
@@ -2429,7 +2992,16 @@ loop do
                 end
               end
 
-              pre_cmd
+              # Call plugin on_command_before hooks
+              plugin_results = call_plugin_hook(:on_command_before, @cmd)
+              # If any plugin returns false, skip command
+              if plugin_results.include?(false)
+                puts "Command blocked by plugin"
+                next
+              end
+              # If any plugin returns a modified command, use it
+              modified_cmd = plugin_results.find { |r| r.is_a?(String) }
+              @cmd = modified_cmd if modified_cmd
 
               # Track command frequency for intelligent completion
               cmd_base = @cmd.split.first if @cmd && !@cmd.empty?
@@ -2440,6 +3012,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 &
@@ -2448,13 +3023,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
@@ -2470,6 +3053,14 @@ loop do
                 @cmd_stats[cmd_base][:avg_time] = @cmd_stats[cmd_base][:total_time] / @cmd_stats[cmd_base][:count]
               end
 
+              # Slow command alert
+              if @slow_command_threshold > 0 && elapsed > @slow_command_threshold
+                puts "⚠ Command took #{'%.1f' % elapsed}s (threshold: #{@slow_command_threshold}s)".c(214)
+              end
+
+              # Call plugin on_command_after hooks
+              call_plugin_hook(:on_command_after, @cmd, @last_exit)
+
               post_cmd
             rescue StandardError => err
               puts "\nError: #{err}"