ruby-shell 3.4.2 → 3.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77bd4af1f0ec04f25fb48fc4bde5b1b18a50b02e046698c9cb660dafa6caa59c
-  data.tar.gz: 807220a097167fb1338c52ce8868d3fcf0a022d8cec7963cf23654daafd72e8d
+  metadata.gz: 587406cf97c8f8aeba405779d229d073b0c8963b24c224edd1a24d72441411d5
+  data.tar.gz: aa4ea0471988e2004e057c575684f6d2a3f2b3875872e49ee769f22045d52bd5
 SHA512:
-  metadata.gz: 6e84bedcc95db51816bcfd6c5ed560914898a3e661767bcd810c6dab22d8aec7fffb8904877a606e3cf9cdc1129307fd50c1db848f429165aa935d8a57f5b46d
-  data.tar.gz: 0d939b9668cd56581466acf659cc99b75652522ee5f05d5d6fdcf7eb70930da766a818dcbeef6d81597ce24e4dc9f720a6364bc5792ccad05231ba216e9fdcb2
+  metadata.gz: 8fc3e11246348f5eae8bec22ac1d62d990a5ab2727573202363a9c04d6f6e8448bb265fd776ae664004249ac9133baf12a78042da5045b8fe3589e8484414221
+  data.tar.gz: a4305bfba19e86a643440a4d6727e71c3e5d74467fdb9ccf5070345f66a5792256276b299e04714e389d6801e5aadf0253b3da645203bb4135412f5ffa9ec9a2

data/README.md

@@ -359,6 +359,36 @@ Create safety rules to block, confirm, warn, or log specific command patterns:
 
 ---
 
+## Environment Variables
+
+**Note:** rsh uses `:env` commands for environment management, not the standard `export` syntax.
+
+```bash
+# List all environment variables (shows first 20)
+:env
+
+# View specific variable
+:env PATH
+
+# Set environment variable
+:env set PATH /opt/local/bin:/usr/bin:/bin
+
+# Unset environment variable
+:env unset MY_VAR
+
+# Export all variables to shell script
+:env export my_env.sh
+```
+
+**Why not `export`?**
+- rsh uses colon commands (`:cmd`) for shell operations
+- Standard `export VAR=value` syntax spawns a subprocess that doesn't affect parent shell
+- Use `:env set VAR value` instead for persistent environment changes
+
+**Tip:** Add `:env set` commands to your `~/.rshrc` for variables you need on every startup.
+
+---
+
 ## 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.4.2" # Improved defun syntax: :defun lists, :defun -name removes, enhanced :help
+@version    = "3.4.4" # Split .rshrc/.rshstate, performance improvements, symlink colors, auto-migration
 
 # MODULES, CLASSES AND EXTENSIONS
 class String # Add coloring to strings (with escaping for Readline)
@@ -97,6 +97,12 @@ begin # Initialization
   @c_tabselect = 5                        # Color for selected tabcompleted item
   @c_taboption = 244                      # Color for unselected tabcompleted item
   @c_stamp     = 244                      # Color for time stamp/command
+  # File type colors for tab completion
+  @c_dir       = 33                       # Color for directories (blue)
+  @c_exec      = 2                        # Color for executables (green)
+  @c_image     = 13                       # Color for images (magenta)
+  @c_archive   = 11                       # Color for archives (yellow)
+  @c_file      = 7                        # Color for regular files (white/default)
   # Prompt
   @prompt      = "rsh > ".c(@c_prompt).b  # Very basic prompt if not defined in .rshrc
   # Hash & array initializations
@@ -153,6 +159,7 @@ begin # Initialization
   @validation_rules = []                  # Custom validation rules
   @completion_weights = {}                # Completion learning weights
   @completion_learning = true             # Enable completion learning (default: on)
+  @completion_show_metadata = false       # Show file metadata in completions (default: off)
   @recording = {active: false, name: nil, commands: []} # Command recording state
   @recordings = {}                        # Saved recordings
   @command_cache = {}                     # Cache for expensive shell command outputs
@@ -599,11 +606,27 @@ def tab(type)
         if @cmd_completions.key?(last_cmd) && cmd_parts.length == 1
           type = "cmd_subcommands"
           @current_cmd = last_cmd
+        # If we're completing after a command (not at start of line), show only files
+        elsif last_cmd
+          type = "files_dirs_only"
         end
       end
     end
   end
 
+  # Auto-complete . and .. for directory navigation commands
+  if type == "dirs_only" && (@tabstr == ".." || @tabstr == ".")
+    completed = @tabstr + "/"
+    @history[0] = @pretab + completed + @postab
+    @pos = @pretab.length + completed.length
+    @c_col = @pos0 + @pos
+    @c.clear_line
+    line_display = cmd_check(@history[0]).to_s
+    print @prompt + line_display
+    @c.col(@c_col)
+    return
+  end
+
   while chr != "ENTER"
     case type
     when "hist"         # Handle history completions ('UP' key)
@@ -663,6 +686,24 @@ def tab(type)
       fdir = @tabstr + "*"
       files = Dir.glob(fdir).reject { |f| Dir.exist?(f) }
       @tabarray = files
+    when "files_dirs_only"  # Show files and directories, but not commands
+      fdir = @tabstr + "*"
+      files = Dir.glob(fdir)
+      # Only show hidden files if tabstr starts with .
+      unless @tabstr.start_with?('.')
+        files.reject! { |f| File.basename(f).start_with?('.') }
+      end
+      files.map! do |e|
+        if e =~ /(?<!\\) /
+          e = e.sub(/(.*\/|^)(.*)/, '\1\'\2\'') unless e =~ /'/
+        end
+        Dir.exist?(e) ? e + "/" : e
+      end
+      # Separate directories and files for better ordering
+      dirs = files.select { |f| f.end_with?('/') }
+      files_only = files.reject { |f| f.end_with?('/') }
+      # Order: directories first, then files
+      @tabarray = dirs + files_only
     when "commands_only" # Only show executable commands
       ex = @exe.dup
       ex.prepend(*@nick.keys, *@gnick.keys)
@@ -788,33 +829,91 @@ def tab(type)
         @newhist0 = @pretab + tabchoice + @postab             # Remember now the new value to be given to @history[0]
         line1     = cmd_check(@pretab).to_s                   # Syntax highlight before @tabstr
         line2     = cmd_check(@postab).to_s                   # Syntax highlight after  @tabstr
-        # Color and underline the current tabchoice on the commandline:
-        tabline   = tabchoice.sub(/(.*)#{@tabstr}(.*)/, '\1'.c(@c_tabselect) + @tabstr.u.c(@c_tabselect) + '\2'.c(@c_tabselect))
+        # Color and underline the current tabchoice on the commandline with file type color:
+        display_choice = tabchoice.dup
+        clean_choice = tabchoice.gsub(/['"]/, '').chomp('/')
+        if !tabchoice.end_with?('/') && File.exist?(clean_choice) && File.executable?(clean_choice) && !File.directory?(clean_choice)
+          display_choice += '*'
+        end
+        choice_color = get_file_color(tabchoice)
+        # Escape regex special characters in @tabstr for pattern matching
+        escaped_tabstr = Regexp.escape(@tabstr)
+        tabline   = display_choice.sub(/(.*)#{escaped_tabstr}(.*)/, '\1'.c(choice_color) + @tabstr.u.c(choice_color) + '\2'.c(choice_color))
         print @prompt + line1 + tabline + line2               # Print the commandline
         @pos   = @pretab.length.to_i + tabchoice.length.to_i  # Set the position on that commandline
         @c_col = @pos0 + @pos                                 # The cursor position must include the prompt as well
         @c.col(@c_col)                                        # Set the cursor position
         nextline                                              # Then start showing the completion items
         tabline  = @tabarray[i]                               # Get the next matching tabline
+        # Add executable indicator
+        display_item = tabline.dup
+        clean_item = tabline.gsub(/['"]/, '').chomp('/')
+        if !tabline.end_with?('/') && File.exist?(clean_item) && File.executable?(clean_item) && !File.directory?(clean_item)
+          display_item += '*'
+        end
+        # Get file type color, but make selected item bold for distinction
+        file_color = get_file_color(tabline)
         # Can't nest ANSI codes, they must each complete/conclude or they will mess eachother up
-        if tabline.include?(@tabstr)
-          tabline1 = tabline.sub(/(.*?)#{@tabstr}.*/, '\1').c(@c_tabselect) # Color the part before the @tabstr
-          tabline2 = tabline.sub(/.*?#{@tabstr}(.*)/, '\1').c(@c_tabselect) # Color the part after the @tabstr
-          print " " + tabline1 + @tabstr.c(@c_tabselect).u + tabline2       # Color & underline @tabstr
+        escaped_tabstr = Regexp.escape(@tabstr)
+        if display_item.include?(@tabstr)
+          tabline1 = display_item.sub(/(.*?)#{escaped_tabstr}.*/, '\1').c(file_color).b # Bold + color for selected
+          tabline2 = display_item.sub(/.*?#{escaped_tabstr}(.*)/, '\1').c(file_color).b
+          print " " + tabline1 + @tabstr.c(file_color).u.b + tabline2       # Bold, color & underline @tabstr
         else
           # For fuzzy matches, just show the whole word highlighted
-          print " " + tabline.c(@c_tabselect)
+          print " " + display_item.c(file_color).b
+        end
+        # Add metadata if enabled
+        if @completion_show_metadata && File.exist?(clean_item)
+          if File.directory?(clean_item)
+            begin
+              count = Dir.entries(clean_item).length - 2
+              print " [#{count}]".c(244)
+            rescue
+            end
+          else
+            size = File.size(clean_item)
+            size_str = size < 1024 ? "#{size}B" :
+                       size < 1024*1024 ? "#{(size/1024.0).round(1)}K" :
+                       "#{(size/(1024.0*1024)).round(1)}M"
+            print " [#{size_str}]".c(244)
+          end
         end
       else
         begin
           tabline = @tabarray[i+x]    # Next tabline, and next, etc (usually 4 times here)
-          if tabline.include?(@tabstr)
-            tabline1 = tabline.sub(/(.*?)#{@tabstr}.*/, '\1').c(@c_taboption) # Color before @tabstr
-            tabline2 = tabline.sub(/.*?#{@tabstr}(.*)/, '\1').c(@c_taboption) # Color after @tabstr
-            print " " + tabline1 + @tabstr.c(@c_taboption).u + tabline2       # Print the whole line
+          # Add executable indicator
+          display_item = tabline.dup
+          clean_item = tabline.gsub(/['"]/, '').chomp('/')
+          if !tabline.end_with?('/') && File.exist?(clean_item) && File.executable?(clean_item) && !File.directory?(clean_item)
+            display_item += '*'
+          end
+          # Get file type color for unselected items (no bold)
+          file_color = get_file_color(tabline)
+          escaped_tabstr = Regexp.escape(@tabstr)
+          if display_item.include?(@tabstr)
+            tabline1 = display_item.sub(/(.*?)#{escaped_tabstr}.*/, '\1').c(file_color) # Color before @tabstr
+            tabline2 = display_item.sub(/.*?#{escaped_tabstr}(.*)/, '\1').c(file_color) # Color after @tabstr
+            print " " + tabline1 + @tabstr.c(file_color).u + tabline2       # Print the whole line
           else
             # For fuzzy matches, just show the whole word
-            print " " + tabline.c(@c_taboption)
+            print " " + display_item.c(file_color)
+          end
+          # Add metadata if enabled
+          if @completion_show_metadata && File.exist?(clean_item)
+            if File.directory?(clean_item)
+              begin
+                count = Dir.entries(clean_item).length - 2
+                print " [#{count}]".c(244)
+              rescue
+              end
+            else
+              size = File.size(clean_item)
+              size_str = size < 1024 ? "#{size}B" :
+                         size < 1024*1024 ? "#{(size/1024.0).round(1)}K" :
+                         "#{(size/(1024.0*1024)).round(1)}M"
+              print " [#{size_str}]".c(244)
+            end
           end
         rescue => e
           # Log completion errors if debugging enabled
@@ -839,7 +938,7 @@ def tab(type)
       if @tabstr == ""
         @history[0] = @pretab + @postab
         tabend
-        return 
+        return
       end
       @tabstr.chop!
     when 'WBACK' # Delete one word to the left (Ctrl-W)
@@ -1032,9 +1131,13 @@ def config(*args) # Configure rsh settings
     @completion_limit = value.to_i
     puts "Completion limit set to #{value}"
     rshrc
+  when 'completion_show_metadata'
+    @completion_show_metadata = %w[on true yes 1].include?(value.to_s.downcase)
+    puts "Completion metadata display #{@completion_show_metadata ? 'enabled' : 'disabled'}"
+    rshrc
   else
     puts "Unknown setting '#{setting}'"
-    puts "Available: history_dedup, session_autosave, auto_correct, slow_command_threshold, completion_learning, completion_limit"
+    puts "Available: history_dedup, session_autosave, auto_correct, slow_command_threshold, completion_learning, completion_limit, completion_show_metadata"
   end
 end
 def env(*args) # Environment variable management
@@ -1075,6 +1178,124 @@ def env(*args) # Environment variable management
     end
   end
 end
+def parse_ls_colors # Parse LS_COLORS into a hash for file type coloring
+  @ls_colors = {}
+
+  # Map ANSI basic color codes (30-37, 90-97) to 256-color equivalents
+  ansi_to_256 = {
+    30 => 0,   # black
+    31 => 196, # red -> bright red
+    32 => 2,   # green
+    33 => 11,  # yellow -> bright yellow
+    34 => 33,  # blue -> nice blue
+    35 => 13,  # magenta -> nice magenta
+    36 => 14,  # cyan -> bright cyan
+    37 => 7,   # white
+    90 => 8,   # bright black (gray)
+    91 => 9,   # bright red
+    92 => 10,  # bright green
+    93 => 11,  # bright yellow
+    94 => 12,  # bright blue
+    95 => 13,  # bright magenta
+    96 => 14,  # bright cyan
+    97 => 15   # bright white
+  }
+
+  if ENV['LS_COLORS']
+    ENV['LS_COLORS'].split(':').each do |entry|
+      next if entry.empty?
+      key, value = entry.split('=')
+      next unless key && value
+
+      # LS_COLORS can use multiple formats:
+      # - "38;5;111" or "38;5;111;1" = 256-color format (use color 111 directly)
+      # - "01;34" = ANSI format (bold + basic color 34, needs conversion)
+      # - "34" = simple ANSI basic color (needs conversion)
+
+      if value =~ /38;5;(\d+)/ # 256-color format (check this first!)
+        @ls_colors[key] = $1.to_i
+      elsif value =~ /(\d+);(\d+)/ # ANSI with attributes (e.g., "01;34")
+        ansi_code = $2.to_i
+        @ls_colors[key] = ansi_to_256[ansi_code] || ansi_code
+      elsif value =~ /^(\d+)$/ # Simple ANSI color
+        ansi_code = $1.to_i
+        @ls_colors[key] = ansi_to_256[ansi_code] || ansi_code
+      end
+    end
+  end
+
+  # Always set defaults (even if LS_COLORS isn't available)
+  @ls_colors['di'] ||= 33   # directories = blue
+  @ls_colors['ex'] ||= 2    # executables = green
+  @ls_colors['ln'] ||= 14   # symlinks = cyan
+  @ls_colors['fi'] ||= 7    # regular files = white
+end
+def get_file_color(filename) # Get color for a file based on LS_COLORS
+  return 7 unless @ls_colors  # Default to white if not initialized
+
+  # Remove quotes and trailing slash for checking
+  clean_name = filename.gsub(/['"]/, '').chomp('/')
+
+  # Check if it's a symlink (before directory check!)
+  if File.symlink?(clean_name)
+    return @ls_colors['ln'] || 14  # Symlinks get special color
+  end
+
+  # Check if it's a directory
+  if filename.end_with?('/')
+    return @ls_colors['di'] || 33
+  end
+
+  # Check if file exists and is executable
+  if File.exist?(clean_name) && File.executable?(clean_name) && !File.directory?(clean_name)
+    return @ls_colors['ex'] || 2
+  end
+
+  # Check extension patterns (*.jpg, *.tar, etc.)
+  ext = File.extname(clean_name)
+  if ext && !ext.empty? && @ls_colors["*#{ext}"]
+    return @ls_colors["*#{ext}"]
+  end
+
+  # Default to regular file color (if 0, use 7/white as 0 means "default" in LS_COLORS)
+  file_color = @ls_colors['fi'] || 7
+  file_color = 7 if file_color == 0  # 0 means "reset to default" in LS_COLORS
+  file_color
+end
+def format_tab_item(item, show_metadata: false) # Format tab item with color and optional metadata
+  color = get_file_color(item)
+  formatted = item
+
+  # Add executable indicator
+  clean_name = item.gsub(/['"]/, '')
+  if !item.end_with?('/') && File.exist?(clean_name) && File.executable?(clean_name)
+    formatted += '*'
+  end
+
+  # Add metadata if requested
+  if show_metadata && @completion_show_metadata
+    clean_name = clean_name.chomp('/')
+    if File.exist?(clean_name)
+      if File.directory?(clean_name)
+        begin
+          count = Dir.entries(clean_name).length - 2  # Exclude . and ..
+          meta = "[dir, #{count} items]"
+        rescue
+          meta = "[dir]"
+        end
+      else
+        size = File.size(clean_name)
+        size_str = size < 1024 ? "#{size}B" :
+                   size < 1024*1024 ? "#{(size/1024.0).round(1)}K" :
+                   "#{(size/(1024.0*1024)).round(1)}M"
+        meta = "[#{size_str}]"
+      end
+      formatted = formatted.ljust(30) + " #{meta}".c(244)
+    end
+  end
+
+  formatted.c(color)
+end
 def cmd_check(str) # Check if each element on the readline matches commands, nicks, paths; color them
   return if str.nil?
 
@@ -1122,21 +1343,19 @@ def cmd_check(str) # Check if each element on the readline matches commands, nic
     end
   end
 end
-def rshrc # Write updates to .rshrc
-  hist_clean
+def rshrc # Write user configuration to .rshrc (portable between machines)
+  hist_clean  # Clean history before saving
   if File.exist?(Dir.home+'/.rshrc')
     conf = File.read(Dir.home+'/.rshrc')
   else
     conf = ""
   end
+
+  # Only update user-editable items in .rshrc
   conf.sub!(/^@nick.*(\n|$)/, "")
   conf += "@nick = #{@nick}\n"
   conf.sub!(/^@gnick.*(\n|$)/, "")
   conf += "@gnick = #{@gnick}\n"
-  conf.sub!(/^@cmd_frequency.*(\n|$)/, "")
-  conf += "@cmd_frequency = #{@cmd_frequency}\n"
-  conf.sub!(/^@cmd_stats.*(\n|$)/, "")
-  conf += "@cmd_stats = #{@cmd_stats}\n" unless @cmd_stats.empty?
   conf.sub!(/^@bookmarks.*(\n|$)/, "")
   conf += "@bookmarks = #{@bookmarks}\n" unless @bookmarks.empty?
   conf.sub!(/^@defuns.*(\n|$)/, "")
@@ -1149,40 +1368,71 @@ def rshrc # Write updates to .rshrc
   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!(/^@completion_learning.*(\n|$)/, "")
+  conf += "@completion_learning = #{@completion_learning}\n" unless @completion_learning
+  conf.sub!(/^@completion_show_metadata.*(\n|$)/, "")
+  conf += "@completion_show_metadata = #{@completion_show_metadata}\n" if @completion_show_metadata
   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?
+
+  File.write(Dir.home+'/.rshrc', conf)
+  rshstate  # Also save runtime state
+end
+def rshstate # Write runtime state to .rshstate (auto-managed, machine-specific)
+  state = ""
+
+  # Runtime data that changes frequently
+  state += "@cmd_frequency = #{@cmd_frequency}\n" unless @cmd_frequency.empty?
+  state += "@cmd_stats = #{@cmd_stats}\n" unless @cmd_stats.empty?
+  state += "@completion_weights = #{@completion_weights}\n" unless @completion_weights.empty?
+  state += "@recordings = #{@recordings}\n" unless @recordings.empty?
+
   # Persist executable cache for faster startup
   if @exe && @exe.length > 100
-    conf.sub!(/^@exe_cache.*(\n|$)/, "")
-    conf += "@exe_cache = #{@exe.inspect}\n"
-    conf.sub!(/^@exe_cache_path.*(\n|$)/, "")
-    conf += "@exe_cache_path = #{ENV['PATH'].inspect}\n"
-    conf.sub!(/^@exe_cache_time.*(\n|$)/, "")
-    conf += "@exe_cache_time = #{Time.now.to_i}\n"
-  end
-  # Only write @cmd_completions if user has customized it
-  unless conf =~ /^@cmd_completions\s*=/
-    # Don't write default completions to avoid cluttering .rshrc
-  end
-  conf.sub!(/^@history.*(\n|$)/, "")
+    state += "@exe_cache = #{@exe.inspect}\n"
+    state += "@exe_cache_path = #{ENV['PATH'].inspect}\n"
+    state += "@exe_cache_time = #{Time.now.to_i}\n"
+  end
+
   # Ensure history is properly formatted as valid Ruby array
   begin
     history_str = @history.last(@histsize).inspect
-    conf += "@history = #{history_str}\n"
+    state += "@history = #{history_str}\n"
   rescue => e
-    conf += "@history = []\n"
-    puts "Warning: Error saving history: #{e.message}"
+    state += "@history = []\n"
+    puts "Warning: Error saving history: #{e.message}" if ENV['RSH_DEBUG']
   end
+
+  File.write(Dir.home+'/.rshstate', state)
+end
+def migrate_to_split_config # Migrate from old single .rshrc to split .rshrc + .rshstate
+  return if File.exist?(Dir.home+'/.rshstate')  # Already migrated
+  return unless File.exist?(Dir.home+'/.rshrc')  # Nothing to migrate
+
+  puts "\nMigrating to split configuration (.rshrc + .rshstate)..."
+
+  # Runtime data will already be loaded from .rshrc by load_rshrc_safe
+  # Just need to save it to .rshstate and clean .rshrc
+
+  # Create .rshstate with current runtime data
+  rshstate
+
+  # Clean runtime data from .rshrc
+  conf = File.read(Dir.home+'/.rshrc')
+  conf.sub!(/^@cmd_frequency.*(\n|$)/, "")
+  conf.sub!(/^@cmd_stats.*(\n|$)/, "")
+  conf.sub!(/^@exe_cache.*(\n|$)/, "")
+  conf.sub!(/^@exe_cache_path.*(\n|$)/, "")
+  conf.sub!(/^@exe_cache_time.*(\n|$)/, "")
+  conf.sub!(/^@completion_weights.*(\n|$)/, "")
+  conf.sub!(/^@history =.*(\n|$)/, "")
   File.write(Dir.home+'/.rshrc', conf)
-  puts ".rshrc updated"
+
+  puts "Migration complete!"
+  puts "  .rshrc     -> User config (portable)"
+  puts "  .rshstate  -> Runtime data (auto-managed)\n"
 end
 
 # RSH FUNCTIONS
@@ -2757,6 +3007,15 @@ def load_rshrc_safe
       end
     end
 
+    # Load runtime state from .rshstate (separate file)
+    if File.exist?(Dir.home+'/.rshstate')
+      begin
+        load(Dir.home+'/.rshstate')
+      rescue => e
+        puts "Warning: Could not load .rshstate: #{e.message}" if ENV['RSH_DEBUG']
+      end
+    end
+
   rescue SyntaxError => e
     puts "\n\033[31mERROR: Syntax error in .rshrc:\033[0m"
     puts e.message
@@ -2953,6 +3212,7 @@ begin # Load .rshrc and populate @history
   end
   firstrun unless File.exist?(Dir.home+'/.rshrc') # Initial loading - to get history
   load_rshrc_safe
+  migrate_to_split_config  # Migrate from old format if needed (v3.4.3+)
   # Load login shell files if rsh is running as login shell
   if ENV['LOGIN_SHELL'] or $0 == "-rsh" or ARGV.include?('-l') or ARGV.include?('--login')
     ['/etc/profile', Dir.home+'/.profile', Dir.home+'/.bash_profile', Dir.home+'/.bashrc'].each do |f|
@@ -2976,11 +3236,12 @@ begin # Load .rshrc and populate @history
   ENV["PATH"]  ? ENV["PATH"] += ":" : ENV["PATH"] = ""
   ENV["PATH"] += "/home/#{@user}/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
   if @lscolors and File.exist?(@lscolors)
-    ls = File.read(@lscolors) 
+    ls = File.read(@lscolors)
     ls.sub!(/export.*/, '')
     ls.sub!(/^LS_COLORS=/, 'ENV["LS_COLORS"]=')
     eval(ls)
   end
+  parse_ls_colors             # Parse LS_COLORS for tab completion coloring
   @c = Cursor               # Initiate @c as Cursor
   @c.save                   # Get max row & col
   @c.row(8000)
@@ -2995,8 +3256,8 @@ end
 # MAIN PART
 loop do 
   begin
-    @user = Etc.getpwuid(Process.euid).name # For use in @prompt
-    @node = Etc.uname[:nodename]            # For use in @prompt
+    @user ||= Etc.getpwuid(Process.euid).name # Cached for performance
+    @node ||= Etc.uname[:nodename]            # Cached for performance
     # Only reload .rshrc if directory changed (optimization)
     current_dir = Dir.pwd
     if @last_prompt_dir != current_dir
@@ -3004,7 +3265,7 @@ loop do
       @last_prompt_dir = current_dir
     end
     @prompt.gsub!(/#{Dir.home}/, '~') # Simplify path in prompt
-    system("printf \"\033]0;rsh: #{Dir.pwd}\007\"")   # Set Window title to path
+    print "\033]0;rsh: #{current_dir}\007"   # Set window title (no spawn)
     @history[0] = "" unless @history[0]
     cache_executables  # Use cached executable lookup
     # Load plugins on first command (lazy loading)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-shell
 version: !ruby/object:Gem::Version
-  version: 3.4.2
+  version: 3.4.4
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-23 00:00:00.000000000 Z
+date: 2025-10-25 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