pretty_irb 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ecfb0481118f36e1674ff5dd9174fbd1e678b50743a6ea03cab465dd2c800e
-  data.tar.gz: a5fd1711ecdd51ee203546ea3a12f96b5a2ec268e4711c85f1ea0045e55311e2
+  metadata.gz: de7427c34f3650136e317c86f5b32d53a24c4a883c4f3c70dc07684653cab46b
+  data.tar.gz: 258568ee7bc6cc9d42c20d56f7ad80ca16f0a7c63b3b303f0823f405ac67cfaa
 SHA512:
-  metadata.gz: 2d45064a505563e76cc975821c9caf2745885306a50e450e6dafebce7c9ec73270a37201151436db83caf1fe67502bcb8763e216910828b48fd2da6a9095e965
-  data.tar.gz: 64623e8b5a19298cdb41808c38be3b9f241bd9133b5b0b0354851c7f100a98e5db56ddca2e501ff7ef61f59e637e5f270a3d7045cbe7b95da2bc4eba18fe50a3
+  metadata.gz: 3cc973dea626a8ee900e7fbbf26b62d4a941a00fb0f95b137bad0d388c0989e6cfec92d33a35d707f37ddfaac64c24dbe2b5ab8b31ab2b5c48d6c14324368a2e
+  data.tar.gz: 02f2fcd034a86279c301c20497d0fdba10672e528a3df3026c1b6ac173beb13199a0332341ef67f141c92c034bfc23ba5622376f9db61ba8fd2ccca9bd38ac94

data/lib/pretty_irb/benchmarker.rb

@@ -2,77 +2,79 @@ require "benchmark"
 
 module PrettyIRB
   class Benchmarker
-    # Benchmark a code snippet
-    def self.benchmark(code, iterations = 1000)
-      begin
-        time = Benchmark.measure do
-          iterations.times do
-            eval(code)
-          end
+    # Benchmark a code snippet, optionally with caller's binding for variable access
+    def self.benchmark(code, iterations = 1000, binding = nil)
+      time = Benchmark.measure do
+        iterations.times do
+          binding ? eval(code, binding) : eval(code)
         end
+      end
 
-        total_ms = time.real * 1000
-        per_iteration_us = (total_ms * 1000) / iterations
+      total_ms = time.real * 1000
+      per_iteration_us = (total_ms * 1000).to_f / iterations
 
-        format_benchmark_result(code, iterations, total_ms, per_iteration_us)
-      rescue => e
-        "❌ Benchmark failed: #{e.message}"
-      end
+      format_benchmark_result(code, iterations, total_ms, per_iteration_us)
+    rescue => e
+      "❌ Benchmark failed: #{e.message}"
     end
 
     # Compare two code snippets
-    def self.compare(code1, code2, iterations = 1000)
-      begin
-        time1 = Benchmark.measure do
-          iterations.times { eval(code1) }
-        end
-
-        time2 = Benchmark.measure do
-          iterations.times { eval(code2) }
-        end
+    def self.compare(code1, code2, iterations = 1000, binding = nil)
+      time1 = Benchmark.measure do
+        iterations.times { binding ? eval(code1, binding) : eval(code1) }
+      end
 
-        format_comparison(code1, code2, time1, time2, iterations)
-      rescue => e
-        "❌ Comparison failed: #{e.message}"
+      time2 = Benchmark.measure do
+        iterations.times { binding ? eval(code2, binding) : eval(code2) }
       end
+
+      format_comparison(code1, code2, time1, time2, iterations)
+    rescue => e
+      "❌ Comparison failed: #{e.message}"
     end
 
     # Profile memory
-    def self.profile_memory(code, iterations = 100)
-      begin
-        gc_stat_before = GC.stat
-        
-        iterations.times { eval(code) }
-        
-        gc_stat_after = GC.stat
-
-        format_memory_profile(gc_stat_before, gc_stat_after, iterations)
-      rescue => e
-        "❌ Memory profile failed: #{e.message}"
-      end
+    def self.profile_memory(code, iterations = 100, binding = nil)
+      gc_stat_before = GC.stat
+
+      iterations.times { binding ? eval(code, binding) : eval(code) }
+
+      gc_stat_after = GC.stat
+
+      format_memory_profile(gc_stat_before, gc_stat_after, iterations)
+    rescue => e
+      "❌ Memory profile failed: #{e.message}"
     end
 
     private
 
+    def self.truncate(str, max)
+      str.length > max ? str[0, max - 3] + "..." : str
+    end
+
     def self.format_benchmark_result(code, iterations, total_ms, per_iteration_us)
       output = "⏱️  Benchmark Results:\n\n"
-      output += "Code: #{code.truncate(50)}\n"
+      output += "Code: #{truncate(code, 50)}\n"
       output += "Iterations: #{iterations}\n\n"
       output += "Total Time: #{total_ms.round(2)} ms\n"
       output += "Per Iteration: #{per_iteration_us.round(4)} µs\n"
-      output += "Rate: #{(iterations / (total_ms / 1000)).round(0)} ops/sec\n"
+      output += "Rate: #{(iterations / (total_ms / 1000.0)).round(0)} ops/sec\n"
       output
     end
 
     def self.format_comparison(code1, code2, time1, time2, iterations)
-      ratio = time2.real / time1.real
-      faster = ratio < 1 ? "Code 2 is #{(1/ratio - 1) * 100}% faster" : "Code 1 is #{(ratio - 1) * 100}% faster"
+      ratio = time1.real > 0 ? time2.real / time1.real : 1.0
+      faster = if ratio < 1
+        "Code 2 is #{((1.0 / ratio - 1) * 100).round(1)}% faster"
+      else
+        "Code 1 is #{((ratio - 1) * 100).round(1)}% faster"
+      end
 
       output = "⚡ Comparison Results:\n\n"
       output += "Iterations: #{iterations}\n\n"
-      output += "Code 1 (#{code1.truncate(40)}):\n"
+      output += "Code 1 (#{truncate(code1, 40)}):\n"
       output += "  Time: #{(time1.real * 1000).round(2)} ms\n\n"
-      output += "Code 2 (#{code2.truncate(40)}):\n"
+      output += "Code 2 (#{truncate(code2, 40)}):\n"
       output += "  Time: #{(time2.real * 1000).round(2)} ms\n\n"
       output += "Winner: #{faster}\n"
       output
@@ -81,13 +83,14 @@ module PrettyIRB
     def self.format_memory_profile(before, after, iterations)
       allocated = after[:total_allocated_objects] - before[:total_allocated_objects]
       freed = after[:total_freed_objects] - before[:total_freed_objects]
+      net = allocated - freed
 
       output = "💾 Memory Profile:\n\n"
       output += "Iterations: #{iterations}\n\n"
       output += "Objects Allocated: #{allocated}\n"
       output += "Objects Freed: #{freed}\n"
-      output += "Net Objects: #{allocated - freed}\n"
-      output += "Per Iteration: #{((allocated - freed) / iterations).round(1)} objects\n"
+      output += "Net Objects: #{net}\n"
+      output += "Per Iteration: #{(net.to_f / iterations).round(2)} objects\n"
       output
     end
   end

data/lib/pretty_irb/formatter.rb

@@ -1,66 +1,89 @@
-require "colorize"
-
-module PrettyIRB
-  class Formatter
-    class << self
-      # Pretty print output with colors
-      def format_output(output)
-        case output
-        when String
-          output.light_blue
-        when Numeric
-          output.to_s.light_green
-        when TrueClass, FalseClass
-          output.to_s.light_cyan
-        when NilClass
-          "nil".light_black
-        when Array
-          format_array(output)
-        when Hash
-          format_hash(output)
-        else
-          output.inspect.light_yellow
-        end
-      rescue
-        output.to_s
-      end
-
-      # Format error messages with pretty colors
-      def format_error(error_message)
-        error_message.red.bold
-      rescue
-        error_message
-      end
-
-      # Format success messages
-      def format_success(message)
-        message.green
-      rescue
-        message
-      end
-
-      # Format warning messages
-      def format_warning(message)
-        message.yellow
-      rescue
-        message
-      end
-
-      private
-
-      def format_array(array)
-        formatted = array.map { |item| format_output(item) }.join(", ")
-        "[#{formatted}]".light_blue
-      rescue
-        array.inspect
-      end
-
-      def format_hash(hash)
-        formatted = hash.map { |k, v| "#{format_output(k)}=>#{format_output(v)}" }.join(", ")
-        "{#{formatted}}".light_blue
-      rescue
-        hash.inspect
-      end
-    end
-  end
-end
+require "colorize"
+require "rouge"
+
+module PrettyIRB
+  class Formatter
+    class << self
+      # "=> value" — identical to how IRB shows results
+      def format_result(output)
+        "=> ".white + format_output(output)
+      rescue
+        "=> #{output}"
+      end
+
+      def format_output(value)
+        case value
+        when String      then value.inspect.light_yellow
+        when Integer     then value.to_s.light_green
+        when Float       then value.to_s.light_green
+        when Numeric     then value.to_s.light_green
+        when TrueClass   then "true".cyan
+        when FalseClass  then "false".cyan
+        when NilClass    then "nil".light_black
+        when Symbol      then value.inspect.light_magenta
+        when Array       then format_array(value)
+        when Hash        then format_hash(value)
+        else                  value.inspect.white
+        end
+      rescue
+        value.to_s
+      end
+
+      # Rouge Monokai syntax highlight for Ruby code (used in history / snippets)
+      def highlight_code(code)
+        formatter = Rouge::Formatters::Terminal256.new(Rouge::Themes::Monokai.new)
+        lexer     = Rouge::Lexers::Ruby.new
+        formatter.format(lexer.lex(code))
+      rescue
+        code
+      end
+
+      # "ErrorType: message" — red type, dim message
+      def format_error(type, message = nil)
+        if message
+          type.red.bold + ": ".red + message.light_red
+        else
+          type.red.bold
+        end
+      rescue
+        "#{type}: #{message}"
+      end
+
+      def format_success(message)
+        message.green
+      rescue
+        message
+      end
+
+      def format_warning(message)
+        message.yellow
+      rescue
+        message
+      end
+
+      private
+
+      def format_array(arr)
+        return "[]".white if arr.empty?
+
+        items = arr.first(30).map { |v| format_output(v) }
+        items << "…  (#{arr.length} total)".light_black if arr.length > 30
+        "[".white + items.join(", ".white) + "]".white
+      rescue
+        arr.inspect
+      end
+
+      def format_hash(hash)
+        return "{}".white if hash.empty?
+
+        pairs = hash.first(30).map do |k, v|
+          format_output(k) + " => ".white + format_output(v)
+        end
+        pairs << "…  (#{hash.length} total)".light_black if hash.length > 30
+        "{".white + pairs.join(", ".white) + "}".white
+      rescue
+        hash.inspect
+      end
+    end
+  end
+end

data/lib/pretty_irb/history_manager.rb

@@ -50,8 +50,15 @@ module PrettyIRB
 
     # Export history to file
     def export(filename)
-      File.write(filename, format_for_export)
-      "✓ History exported to #{filename}"
+      path = File.expand_path(filename.to_s)
+      # Refuse paths that point at system-sensitive locations
+      if path.start_with?("/etc", "/sys", "/proc", "/dev")
+        return "❌ Refusing to write to system path: #{path}"
+      end
+      File.write(path, format_for_export)
+      "✓ History exported to #{path}"
+    rescue => e
+      "❌ Export failed: #{e.message}"
     end
 
     private

data/lib/pretty_irb/irb_commands.rb

@@ -0,0 +1,139 @@
+module PrettyIRB
+  # Methods mixed into IRB's main object at startup.
+  # Names intentionally avoid IRB's own built-in commands
+  # (history, hist, help, ls, exit, quit, …) because IRB intercepts
+  # those at the statement level before method dispatch.
+  module IRBCommands
+
+    # ── commands ──────────────────────────────────────────────────────────
+    # Show all pretty_irb extras (use IRB's own `help` for core IRB commands)
+
+    def commands
+      section = ->(t) { puts "\n  #{t}".cyan }
+      row     = ->(n, d) { puts "    #{"%-40s" % n}#{d.light_black}" }
+
+      puts "\n  pretty_irb  v#{PrettyIRB::VERSION}".cyan + \
+           "  ·  type  help  for core IRB commands".light_black
+      puts "  " + ("─" * 60).light_black
+
+      section.("Snippets")
+      row.("snippet",                      "list all saved snippets")
+      row.("snippet(:save, 'n', 'code')",  "save a snippet")
+      row.("snippet(:load, 'name')",       "load and run snippet")
+      row.("snippet(:show, 'name')",       "show snippet code")
+      row.("snippet(:delete, 'name')",     "delete snippet")
+      row.("snippet(:search, 'keyword')",  "search snippets")
+
+      section.("Variables")
+      row.("vars",                  "list all local variables")
+      row.("vars('name')",          "inspect one variable")
+      row.("vars(type: 'String')",  "filter by type")
+      row.("vars(search: 'kw')",    "search by name")
+      row.("vars(memory: true)",    "estimate memory usage")
+
+      section.("Benchmark")
+      row.("bench('code')",                   "time code  (1 000 iterations)")
+      row.("bench('a', vs: 'b')",             "compare two snippets")
+      row.("bench('code', memory: true)",     "GC / object allocation profile")
+      row.("bench('code', iterations: 5000)", "custom iteration count")
+
+      section.("Cheatsheet")
+      row.("cheat",           "general Ruby reference")
+      row.("cheat('array')",  "topic: array hash string enumerable file regex date")
+
+      section.("Docs")
+      row.("explain('method')",   "explain a Ruby method")
+      row.("example('topic')",    "code examples for a topic")
+      row.("practices('topic')",  "best practices for a topic")
+      row.("ref('keyword')",      "quick reference lookup")
+
+      puts "\n  tip: IRB built-ins — ".light_black +
+           "history  ls  show_source  show_doc  help  exit".white
+      puts
+      nil
+    end
+
+    # ── snippets ──────────────────────────────────────────────────────────
+
+    def snippet(action = :list, name = nil, code = nil, description: "")
+      mgr = PrettyIRB::Shell.snippet_manager
+      case action.to_sym
+      when :list
+        puts mgr.list
+      when :save
+        puts mgr.save(name.to_s, code.to_s, description)
+      when :load
+        src = mgr.load(name.to_s)
+        if src.is_a?(String) && !src.start_with?("❌")
+          puts "  loaded: #{name}".cyan
+          puts PrettyIRB::Formatter.highlight_code(src)
+          eval(src, IRB.CurrentContext.workspace.binding)
+        else
+          puts src
+        end
+      when :show
+        puts PrettyIRB::Formatter.highlight_code(mgr.show(name.to_s))
+      when :delete
+        puts mgr.delete(name.to_s)
+      when :search
+        puts mgr.search(name.to_s)
+      else
+        puts "  actions: :list  :save  :load  :show  :delete  :search".yellow
+      end
+      nil
+    end
+
+    # ── variables ─────────────────────────────────────────────────────────
+
+    def vars(name = nil, type: nil, search: nil, memory: false)
+      inspector = PrettyIRB::VariableInspector.new(IRB.CurrentContext.workspace.binding)
+      if    memory then puts inspector.memory_usage
+      elsif type   then puts inspector.by_type(type.to_s)
+      elsif search then puts inspector.search(search.to_s)
+      elsif name   then puts inspector.inspect_var(name.to_s)
+      else              puts inspector.list_variables
+      end
+      nil
+    end
+
+    # ── benchmark ─────────────────────────────────────────────────────────
+
+    def bench(code, vs: nil, memory: false, iterations: 1000)
+      b = IRB.CurrentContext.workspace.binding
+      if    memory then puts PrettyIRB::Benchmarker.profile_memory(code.to_s, iterations, b)
+      elsif vs     then puts PrettyIRB::Benchmarker.compare(code.to_s, vs.to_s, iterations, b)
+      else              puts PrettyIRB::Benchmarker.benchmark(code.to_s, iterations, b)
+      end
+      nil
+    end
+
+    # ── cheatsheet ────────────────────────────────────────────────────────
+
+    def cheat(topic = nil)
+      puts PrettyIRB::CheatSheet.show(topic)
+      nil
+    end
+
+    # ── docs ──────────────────────────────────────────────────────────────
+
+    def explain(method_name)
+      puts PrettyIRB::AIHelper.explain_method(method_name.to_s)
+      nil
+    end
+
+    def example(topic)
+      puts PrettyIRB::AIHelper.get_example(topic.to_s)
+      nil
+    end
+
+    def practices(topic)
+      puts PrettyIRB::AIHelper.best_practices(topic.to_s)
+      nil
+    end
+
+    def ref(keyword)
+      puts PrettyIRB::AIHelper.quick_reference(keyword.to_s)
+      nil
+    end
+  end
+end

data/lib/pretty_irb/shell.rb

@@ -1,387 +1,154 @@
-require "irb"
-require "reline"
-
-module PrettyIRB
-  class Shell
-    BANNER = <<~BANNER
-      ╔═══════════════════════════════════════════════════════════╗
-      ║         🎨 Welcome to Pretty IRB 🎨                      ║
-      ║                                                           ║
-      ║  Enhanced Interactive Ruby Shell with Auto-Correct       ║
-      ║  Type 'help' for commands or 'exit' to quit              ║
-      ╚═══════════════════════════════════════════════════════════╝
-    BANNER
-
-    def initialize(config = {})
-      @config = config
-      @history_manager = HistoryManager.new
-      @snippet_manager = SnippetManager.new
-      @variable_inspector = VariableInspector.new(TOPLEVEL_BINDING)
-      @input_buffer = ""
-      @binding = TOPLEVEL_BINDING
-    end
-
-    def run
-      puts BANNER.light_magenta
-      start_repl
-    end
-
-    private
-
-    def start_repl
-      loop do
-        begin
-          input = read_input
-          break if input.nil? || input.downcase == "exit"
-
-          if input.downcase == "help"
-            show_help
-            next
-          end
-
-          # Handle special commands
-          if input.downcase == "clear"
-            system("clear") || system("cls")
-            next
-          end
-
-          # Handle history commands
-          if input.start_with?("history")
-            handle_history_command(input)
-            next
-          end
-
-          # Handle snippet commands
-          if input.start_with?("snippet")
-            handle_snippet_command(input)
-            next
-          end
-
-          # Handle variable commands
-          if input.start_with?("vars")
-            handle_variable_command(input)
-            next
-          end
-
-          # Handle benchmark commands
-          if input.start_with?("benchmark") || input.start_with?("bench")
-            handle_benchmark_command(input)
-            next
-          end
-
-          # Handle cheatsheet commands
-          if input.start_with?("cheat")
-            handle_cheatsheet_command(input)
-            next
-          end
-
-          # Handle AI help commands
-          if input.start_with?("?")
-            handle_ai_command(input)
-            next
-          end
-
-          execute_code(input)
-          @history_manager.add(input)
-
-        rescue Interrupt
-          puts "\n" + Formatter.format_warning("Interrupted. Type 'exit' to quit.")
-        rescue EOFError
-          puts "\n" + Formatter.format_success("Goodbye!")
-          break
-        rescue StandardError => e
-          handle_error(e)
-        end
-      end
-    end
-
-    def read_input
-      prompt = "pretty_irb".light_magenta + " >> ".light_magenta
-      input = Reline.readline(prompt, true)
-      return nil if input.nil?
-
-      # If the line appears to start a block or otherwise is incomplete,
-      # collect additional lines until the code is complete.
-      if incomplete_code?(input)
-        buffer = input + "\n"
-        while (more = Reline.readline("... ".light_magenta, true))
-          break if more.nil?
-          buffer += more + "\n"
-          break unless incomplete_code?(buffer)
-        end
-
-        return buffer
-      end
-
-      input
-    end
-
-    # Heuristic to detect incomplete Ruby code.
-    # Returns true if there are unclosed block tokens, brackets, or quotes.
-    def incomplete_code?(code)
-      return true if code.nil? || code.strip.empty?
-
-      # Count block starters and 'end'
-      opens = 0
-      opens += code.scan(/\b(do|def|class|module|if|case|begin|for|while|until|unless)\b/).size
-      closes = code.scan(/\bend\b/).size
-      return true if opens > closes
-
-      # Brackets / braces / parentheses
-      return true if code.count('(') > code.count(')')
-      return true if code.count('[') > code.count(']')
-      return true if code.count('{') > code.count('}')
-
-      # Unclosed quotes (simple heuristic, ignores escaped quotes)
-      single_quotes = code.scan(/(?<!\\)'/).size
-      double_quotes = code.scan(/(?<!\\)"/).size
-      return true if single_quotes.odd? || double_quotes.odd?
-
-      # Line continuation with trailing backslash
-      return true if code.rstrip.end_with?('\\')
-
-      false
-    end
-
-    def execute_code(code)
-      # Auto-correct the code
-      corrected_code = AutoCorrector.auto_correct_code(code)
-
-      # Show if code was corrected
-      if corrected_code != code
-        puts Formatter.format_warning("↻ Auto-corrected: #{corrected_code}")
-      end
-
-      begin
-        # Evaluate the code
-        result = eval(corrected_code, @binding)
-
-        # Display the result
-        unless result.nil?
-          puts Formatter.format_output(result)
-        end
-
-      rescue NameError => e
-        handle_name_error(e)
-      rescue NoMethodError => e
-        handle_method_error(e)
-      rescue SyntaxError => e
-        handle_syntax_error(e)
-      rescue StandardError => e
-        handle_error(e)
-      end
-    end
-
-    def handle_name_error(error)
-      puts Formatter.format_error("NameError: #{error.message}")
-      suggestions = AutoCorrector.suggest_corrections(error)
-      puts suggestions if suggestions && !suggestions.empty?
-    end
-
-    def handle_method_error(error)
-      puts Formatter.format_error("NoMethodError: #{error.message}")
-      suggestions = AutoCorrector.suggest_corrections(error)
-      puts suggestions if suggestions && !suggestions.empty?
-    end
-
-    def handle_syntax_error(error)
-      puts Formatter.format_error("SyntaxError: #{error.message}")
-      suggestions = AutoCorrector.suggest_corrections(error)
-      puts suggestions if suggestions && !suggestions.empty?
-    end
-
-    def handle_error(error)
-      puts Formatter.format_error("#{error.class}: #{error.message}")
-      if error.backtrace
-        puts Formatter.format_warning("Backtrace:")
-        error.backtrace.first(5).each do |line|
-          puts "  #{line}"
-        end
-      end
-    end
-
-    def show_help
-      help_text = <<~HELP
-        #{'=== Pretty IRB Commands ==='.light_magenta}
-
-        exit, quit          Exit the shell
-        help                Show this help message
-        clear               Clear the screen
-
-        #{'=== History Commands ==='.light_magenta}
-
-        history                       Show all command history
-        history search KEYWORD        Search history
-        history last N                Show last N commands
-        history export FILE           Export to file
-        history clear                 Clear history
-
-        #{'=== Snippet Commands ==='.light_magenta}
-
-        snippet list                  List all snippets
-        snippet save NAME CODE        Save code snippet
-        snippet load NAME             Load and execute snippet
-        snippet show NAME             Show snippet code
-        snippet delete NAME           Delete snippet
-        snippet search KEYWORD        Search snippets
-
-        #{'=== Variable Commands ==='.light_magenta}
-
-        vars                          List all variables
-        vars VARNAME                  Inspect variable
-        vars type:TYPE                Variables of type
-        vars search:KEYWORD           Search variables
-        vars memory                   Memory usage
-
-        #{'=== Benchmark Commands ==='.light_magenta}
-
-        bench CODE                    Benchmark code
-        bench compare CODE1 vs CODE2  Compare two snippets
-        bench memory CODE             Profile memory
-
-        #{'=== Cheatsheet Commands ==='.light_magenta}
-
-        cheat                         Show Ruby cheatsheet
-        cheat TOPIC                   Cheatsheet for topic
-                                      (array, hash, string, enumerable, file, regex, date)
-
-        #{'=== AI Help Commands ==='.light_magenta}
-
-        ?explain(method)    Explain a Ruby method
-        ?example(topic)     Get code examples
-        ?debug(code)        Analyze code for issues
-        ?practices(topic)   Learn best practices
-        ?ref(keyword)       Quick reference
-
-        #{'You can type any valid Ruby code and it will be executed!'.light_green}
-      HELP
-      puts help_text
-    end
-
-    def handle_history_command(input)
-      case input.downcase
-      when "history"
-        puts @history_manager.all
-      when /^history\s+search\s+(.+)$/
-        keyword = $1.strip
-        puts @history_manager.search(keyword)
-      when /^history\s+last\s+(\d+)$/
-        n = $1.to_i
-        puts @history_manager.last(n)
-      when /^history\s+export\s+(.+)$/
-        filename = $1.strip
-        puts @history_manager.export(filename)
-      when "history clear"
-        puts @history_manager.clear
-      else
-        puts Formatter.format_warning("Usage: history | history search KEYWORD | history last N | history export FILE | history clear")
-      end
-    end
-
-    def handle_snippet_command(input)
-      case input.downcase
-      when "snippet list"
-        puts @snippet_manager.list
-      when /^snippet\s+save\s+(\w+)\s+(.+)$/
-        name = $1
-        code = $2
-        puts @snippet_manager.save(name, code)
-      when /^snippet\s+load\s+(\w+)$/
-        name = $1
-        code = @snippet_manager.load(name)
-        if code
-          puts Formatter.format_success("📌 Loaded snippet: #{name}")
-          puts code
-          execute_code(code)
-        else
-          puts code
-        end
-      when /^snippet\s+show\s+(\w+)$/
-        name = $1
-        puts @snippet_manager.show(name)
-      when /^snippet\s+delete\s+(\w+)$/
-        name = $1
-        puts @snippet_manager.delete(name)
-      when /^snippet\s+search\s+(.+)$/
-        keyword = $1.strip
-        puts @snippet_manager.search(keyword)
-      else
-        puts Formatter.format_warning("Usage: snippet list | snippet save NAME CODE | snippet load NAME | snippet show NAME | snippet delete NAME | snippet search KEYWORD")
-      end
-    end
-
-    def handle_variable_command(input)
-      case input.downcase
-      when "vars"
-        puts @variable_inspector.list_variables
-      when /^vars\s+(.+)$/
-        var_name = $1.strip
-        if var_name == "memory"
-          puts @variable_inspector.memory_usage
-        elsif var_name.start_with?("type:")
-          type = var_name.sub("type:", "").strip
-          puts @variable_inspector.by_type(type)
-        elsif var_name.start_with?("search:")
-          keyword = var_name.sub("search:", "").strip
-          puts @variable_inspector.search(keyword)
-        else
-          puts @variable_inspector.inspect_var(var_name)
-        end
-      else
-        puts Formatter.format_warning("Usage: vars | vars VARNAME | vars type:TYPE | vars search:KEYWORD | vars memory")
-      end
-    end
-
-    def handle_benchmark_command(input)
-      case input
-      when /^bench(?:mark)?\s+(.+)$/
-        code = $1
-        puts Benchmarker.benchmark(code)
-      when /^bench(?:mark)?\s+compare\s+(.+?)\s+vs\s+(.+)$/
-        code1 = $1
-        code2 = $2
-        puts Benchmarker.compare(code1, code2)
-      when /^bench(?:mark)?\s+memory\s+(.+)$/
-        code = $1
-        puts Benchmarker.profile_memory(code)
-      else
-        puts Formatter.format_warning("Usage: bench CODE | bench compare CODE1 vs CODE2 | bench memory CODE")
-      end
-    end
-
-    def handle_cheatsheet_command(input)
-      case input.downcase
-      when "cheat"
-        puts CheatSheet.show
-      when /^cheat\s+(\w+)$/
-        topic = $1
-        puts CheatSheet.show(topic)
-      else
-        puts Formatter.format_warning("Usage: cheat | cheat TOPIC")
-        puts "Topics: array, hash, string, enumerable, file, regex, date"
-      end
-    end
-
-    def handle_ai_command(input)
-      case input
-      when /^\?explain\((.*?)\)$/
-        method_name = $1.gsub(/'|"/, "")
-        puts AIHelper.explain_method(method_name)
-      when /^\?example\((.*?)\)$/
-        topic = $1.gsub(/'|"/, "")
-        puts AIHelper.get_example(topic)
-      when /^\?debug\((.*)\)$/
-        code_snippet = $1
-        puts AIHelper.debug_code(code_snippet)
-      when /^\?practices\((.*?)\)$/
-        topic = $1.gsub(/'|"/, "")
-        puts AIHelper.best_practices(topic)
-      when /^\?ref\((.*?)\)$/
-        keyword = $1.gsub(/'|"/, "")
-        puts AIHelper.quick_reference(keyword)
-      else
-        puts Formatter.format_warning("❓ Unknown AI command. Type 'help' for available commands.")
-      end
-    end
-  end
-end
+require "irb"
+
+module PrettyIRB
+  class Shell
+    BANNER = <<~BANNER
+      ╭─────────────────────────────────────────────────────────────╮
+      │   pretty_irb  v#{PrettyIRB::VERSION}  ·  Enhanced Interactive Ruby Shell   │
+      │   type  commands  to list extras  ·  exit / Ctrl+D to quit  │
+      ╰─────────────────────────────────────────────────────────────╯
+    BANNER
+
+    class << self
+      attr_accessor :history_manager, :snippet_manager
+    end
+
+    def initialize(config = {})
+      @config = config
+    end
+
+    def run
+      STDOUT.sync = true
+      puts BANNER.cyan
+
+      Shell.history_manager = HistoryManager.new
+      Shell.snippet_manager = SnippetManager.new
+
+      # Step 1: patch IRB classes before anything else
+      install_output_hook
+      install_eval_hook
+
+      # Step 2: IRB.setup populates IRB.conf (and resets IRB_RC to nil).
+      #         Must happen before we configure anything.
+      IRB.setup(nil)
+
+      # Step 3: detect the terminal environment and tune input mode.
+      #         Must happen AFTER setup (so USE_MULTILINE can be overridden)
+      #         but BEFORE IRB::Irb.new reads those values.
+      tune_input_mode
+
+      # Step 4: prompt — IRB.conf[:PROMPT] now exists.
+      configure_prompt
+
+      # Step 5: IRB_RC — fires inside irb.run, after IRB::Irb.new but before
+      #          the first prompt.  Safe place for ctx-level settings.
+      prev_rc = IRB.conf[:IRB_RC]
+      IRB.conf[:IRB_RC] = proc do |ctx|
+        prev_rc.call(ctx) if prev_rc.respond_to?(:call)
+        ctx.prompt_mode      = :PRETTY_IRB
+        ctx.auto_indent_mode = true
+        ctx.workspace.main.extend(PrettyIRB::IRBCommands)
+      end
+
+      # Step 6: start the REPL directly to avoid a second IRB.setup call.
+      irb = IRB::Irb.new
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+      irb.run(IRB.conf)
+    end
+
+    private
+
+    # ── Terminal / input detection ────────────────────────────────────────────
+    # On Windows, Reline uses a Win32 API console handler.  In "legacy
+    # console" mode (old conhost.exe — PowerShell or cmd.exe without
+    # Windows Terminal) Alt+key sequences are read in a way that blocks the
+    # input loop, freezing the entire REPL.
+    #
+    # We detect this and switch to single-line (non-Reline) input, which
+    # avoids the freeze while keeping colour, our custom prompt, and all
+    # pretty_irb commands.  Full features (auto-indent, │ continuation, tab
+    # completion) work when the user opens the same shell inside Windows
+    # Terminal.
+
+    def tune_input_mode
+      return unless Gem.win_platform?
+
+      legacy = begin
+        Reline::IOGate.instance_variable_get(:@legacy_console)
+      rescue
+        false
+      end
+
+      if legacy
+        IRB.conf[:USE_MULTILINE]    = false   # avoid Reline Windows hang
+        IRB.conf[:USE_AUTOCOMPLETE] = false
+        puts (
+          "  legacy console detected — Alt+key sequences freeze Reline.\n" \
+          "  Running in single-line mode.  Open  Windows Terminal  for\n" \
+          "  full auto-indent and tab-complete support."
+        ).light_black
+      end
+    rescue
+      nil
+    end
+
+    # ── Prompt ────────────────────────────────────────────────────────────────
+
+    def configure_prompt
+      IRB.conf[:PROMPT][:PRETTY_IRB] = {
+        PROMPT_I: "[%03n]".light_black + "❯ ".cyan,
+        PROMPT_N: "[%03n]".light_black + "│ ".light_cyan,
+        PROMPT_S: "[%03n]".light_black + "│ ".light_cyan,
+        PROMPT_C: "[%03n]".light_black + "│ ".light_cyan,
+        RETURN:   "=> %s\n"
+      }
+      IRB.conf[:PROMPT_MODE]  = :PRETTY_IRB
+      IRB.conf[:SAVE_HISTORY] = 1000
+    end
+
+    # ── Output hook ───────────────────────────────────────────────────────────
+
+    def install_output_hook
+      IRB::Irb.prepend(Module.new do
+        def output_value(omit = false)
+          puts PrettyIRB::Formatter.format_result(@context.last_value)
+        end
+      end)
+    rescue => e
+      warn "  pretty_irb: output hook skipped (#{e.message})".light_black
+    end
+
+    # ── Eval hook ─────────────────────────────────────────────────────────────
+    # IRB >= 1.4 passes IRB::Statement objects, not plain Strings.
+    # Extract the raw code string for our features; always forward the
+    # original object unchanged so IRB's own command dispatch still works.
+
+    def install_eval_hook
+      IRB::Context.prepend(Module.new do
+        def evaluate(code, line_no, *args, **kwargs, &block)
+          raw = code.is_a?(String) ? code
+              : code.respond_to?(:code) ? code.code.to_s
+              : nil
+
+          if raw
+            corrected = PrettyIRB::AutoCorrector.auto_correct_code(raw)
+            if corrected.strip != raw.strip
+              warn "  ↻  auto-corrected: #{corrected.strip}".yellow
+            end
+          end
+
+          result = begin
+            super(code, line_no, *args, **kwargs, &block)
+          rescue ArgumentError
+            super(code, line_no)
+          end
+
+          PrettyIRB::Shell.history_manager&.add(raw.strip) if raw && !raw.strip.empty?
+          result
+        end
+      end)
+    rescue => e
+      warn "  pretty_irb: eval hook skipped (#{e.message})".light_black
+    end
+  end
+end

data/lib/pretty_irb/snippet_manager.rb

@@ -11,6 +11,7 @@ module PrettyIRB
 
     # Save a code snippet
     def save(name, code, description = "")
+      return "❌ Invalid snippet name. Use only letters, numbers, underscores, and hyphens." unless valid_name?(name)
       filename = snippet_path(name)
       
       snippet = {
@@ -27,6 +28,7 @@ module PrettyIRB
 
     # Load a snippet
     def load(name)
+      return "❌ Invalid snippet name." unless valid_name?(name)
       filename = snippet_path(name)
       return "❌ Snippet '#{name}' not found" unless File.exist?(filename)
 
@@ -73,6 +75,7 @@ module PrettyIRB
 
     # Delete a snippet
     def delete(name)
+      return "❌ Invalid snippet name." unless valid_name?(name)
       filename = snippet_path(name)
       return "❌ Snippet '#{name}' not found" unless File.exist?(filename)
 
@@ -82,6 +85,7 @@ module PrettyIRB
 
     # Show snippet details
     def show(name)
+      return "❌ Invalid snippet name." unless valid_name?(name)
       filename = snippet_path(name)
       return "❌ Snippet '#{name}' not found" unless File.exist?(filename)
 
@@ -100,6 +104,10 @@ module PrettyIRB
       FileUtils.mkdir_p(SNIPPET_DIR) unless Dir.exist?(SNIPPET_DIR)
     end
 
+    def valid_name?(name)
+      name.to_s.match?(/\A[a-zA-Z0-9_-]+\z/)
+    end
+
     def snippet_path(name)
       File.join(SNIPPET_DIR, "#{name}.json")
     end

data/lib/pretty_irb/version.rb

@@ -1,3 +1,3 @@
 module PrettyIRB
-  VERSION = "0.1.0"
+  VERSION = "0.1.3"
 end

data/lib/pretty_irb.rb

@@ -13,6 +13,7 @@ require_relative "pretty_irb/snippet_manager"
 require_relative "pretty_irb/variable_inspector"
 require_relative "pretty_irb/benchmarker"
 require_relative "pretty_irb/cheat_sheet"
+require_relative "pretty_irb/irb_commands"
 require_relative "pretty_irb/shell"
 
 module PrettyIRB

data/pretty_irb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "pretty_irb"
-  spec.version       = "0.1.2"
+  spec.version       = "0.1.3"
   spec.authors       = ["Jayesh"]
   spec.email         = ["jayesh@example.com"]
   spec.summary       = "A pretty IRB replacement with auto-correct and beautiful fonts"
@@ -37,6 +37,7 @@ Gem::Specification.new do |spec|
   # Allow any version >= 1.5 but < 3.0 to avoid conflicts with older constraints.
   spec.add_dependency "did_you_mean", ">= 1.5", "< 3.0"     # Auto-correct suggestions
   spec.add_dependency "reline", "~> 0.3"           # Enhanced readline
+  spec.add_dependency "benchmark"                   # Performance measurement
 
   # Development dependencies
   spec.add_development_dependency "bundler", "~> 2.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pretty_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jayesh
@@ -85,6 +85,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +187,7 @@ files:
 - lib/pretty_irb/cheat_sheet.rb
 - lib/pretty_irb/formatter.rb
 - lib/pretty_irb/history_manager.rb
+- lib/pretty_irb/irb_commands.rb
 - lib/pretty_irb/shell.rb
 - lib/pretty_irb/snippet_manager.rb
 - lib/pretty_irb/variable_inspector.rb