yarsh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 39081c43d270c8a1e33da05ca87657956be5dd589f2949f16cee16accf873745
+  data.tar.gz: 974a89cab7ce728724ff746d4b6febad7ffa4b8b97bd39fd30b0fe98a09ef78b
+SHA512:
+  metadata.gz: f69773fa5dcb457c89fd2559cabf7c031924bc6f99324d1df37a0e3556f5bea049de18ff09abd8f273c029b10f9e567c7c4080bb1c285cc0d2dbf854cebbfe73
+  data.tar.gz: ba74d4bb610fb0462f75ec0935be39f41e1f52f0fba1d73c092ab11a3ec1878d14dccf9e537df5006aa437894dda82871ab6a1380295e89280f2566ef1b80532

data/.ruby-version

@@ -0,0 +1 @@
+4.0.2

data/AGENTS.md

@@ -0,0 +1,75 @@
+# yarsh — Ruby Shell
+
+A hybrid Ruby/shell interactive REPL. Input is evaluated as Ruby first; on
+`NameError` it falls through to `bash -c`.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `bin/setup` or `bundle install` | Install dependencies |
+| `bin/console` | Launch an IRB session (development, uses `bundler/setup`) |
+| `bundle exec ruby exe/yarsh` | Launch the REPL via the gem executable |
+| `rake test` | Run all Minitest tests (default task) |
+| `bundle exec rake install` | Build + install the gem locally |
+
+## Architecture
+
+- **Main logic** lives in `lib/yarsh.rb` (module `Yarsh` with `self.shell`,
+  `self.console`, `self.execute`, `self.shell_path?`, `self.execute_pipe`, etc.).
+  `bin/console` calls `Yarsh.console` (IRB session); `exe/yarsh` calls `Yarsh.shell`.
+- `exe/yarsh` is the gem executable (packaged via `spec.bindir = "exe"` in the
+  gemspec). `bin/console` is for development only (adds `bundler/setup`).
+- `Yarsh.shell_path?` recognizes absolute/relative/home paths for shell execution.
+- `Yarsh.execute_pipe` enables piping shell output into Ruby via the `-->` operator.
+
+## `-->` pipe operator
+
+Pipe shell stdout into Ruby code: `ls -al --> split("\n").each {|f| puts f }`
+
+The shell command runs, its stdout is captured (stripped of trailing newline),
+and the Ruby code after `-->` is evaluated via `instance_eval` on the captured
+string. The variable `_` is also set to the output for explicit references.
+
+Examples:
+
+| Input | Result |
+|---|---|
+| `echo hello --> upcase` | `"HELLO"` |
+| `ls --> lines.count` | (file count) |
+| `cat data.txt --> _.split("\n").grep(/error/)` | matching lines |
+
+## REPL evaluation flow
+
+All steps below are wrapped in a single `begin..rescue` so no error crashes the REPL:
+
+1. `input.include?("-->")` → `Yarsh.execute_pipe(input)`, print result
+2. `Yarsh.shell_path?(input)` → execute directly via `bash -c`
+3. `bind.eval(input)` — Ruby evaluation
+4. `NameError` → if first token is `cd`, call `Dir.chdir`; else shell-execute
+5. Other exceptions → print `Error: ExceptionClass: message`
+
+## Error handling
+
+- **Ctrl+C** (`Interrupt`) during command or eval → prints newline, returns to prompt
+- **Ctrl+D** (EOF) or `exit` → prints "Bye..." and exits
+- `SyntaxError`, `LoadError`, `SystemStackError`, `NoMemoryError`, and all other
+  `Exception` subclasses are caught and displayed — the REPL never crashes from
+  bad input
+- Shell execution failure (`Errno::ENOENT`, etc.) is caught and printed
+
+## Known issues
+
+- **Bug:** `Yarsh.execute` (in `lib/yarsh.rb`) uses `system("bash -c 'source
+  ~/.bashrc; #{cmd}'")` — the command is passed correctly, but this depends on
+  `~/.bashrc` existing.
+- **Dead code:** `Yarsh.execute_system_command` (Open3 version) is defined but
+  never called. `Yarsh.shell` calls `Yarsh.execute`, not
+  `Yarsh.execute_system_command`.
+
+## Style
+
+- `# frozen_string_literal: true` on every `.rb` file.
+- Minitest for testing. Run individual test files via
+  `bundle exec ruby -Ilib -Itest test/<file>.rb`.
+- No linter (RuboCop), no CI, no formatter config present.

data/CHANGES.md

@@ -0,0 +1,114 @@
+# Changelog
+
+## Unreleased
+
+### Auto-completion for shell commands and paths
+
+Tab-completion is now available in the REPL via Reline's `completion_proc`.
+Pressing Tab completes commands from `PATH` when typing the first word, and
+falls back to filesystem path completion for arguments. Path completion
+includes dotfiles and appends `/` to directories for easy traversal.
+
+### Ctrl+C no longer interrupts the shell
+
+Pressing Ctrl+C during input or command execution now safely returns to the
+prompt instead of crashing the REPL.
+
+### Shell commands no longer evaluated as Ruby
+
+Input that raises `SyntaxError` (e.g. `git add .`) is now caught and executed as
+a shell command, matching the existing `NameError` fallback behavior.
+
+### `cd` no longer prints `0` to stdout
+
+`cd` (with or without arguments) is now intercepted before Ruby eval, preventing
+`Dir.chdir`'s return value (`0`) from being printed.
+
+### REPL history persisted to `~/.yarsh/history`
+
+(53032be) Commands are saved to `~/.yarsh/history` across sessions. Max 1000 lines;
+concurrent-session safe via `File.flock`.
+(77af3b8) Add tests for append_history: creation, append, trim, concurrent safety.
+
+### `bin/console` launches an IRB session
+
+(33f86c8) `bin/console` now starts a standard IRB session with the gem loaded
+(`Yarsh.console`). The hybrid REPL remains available via `bundle exec ruby exe/yarsh`
+(`Yarsh.shell`).
+
+### Test suite adapted to multi-file architecture
+
+(13655c4) Tests split per class: `test_yarsh.rb` (module-level: constants,
+`ExecOutput`, `console`), `test_shell.rb` (`Yarsh::Shell`: `shell_path?`, `cd`,
+completion, history, `execute_pipe` incl. bind-var feature), `test_config.rb`
+(`Yarsh::Config`: prompt, `log_level`), `test_prompt.rb` (`Prompt`,
+`AnsiColorFormatter`). `test_expand_aliases` skipped (WIP). Also fixes inverted
+validation in `Config#prompt=`.
+
+### Console test works under minitest 6
+
+(e3d1f44) `test_console_launches_irb_session` no longer uses
+`IRB.stub` (`minitest/mock` was removed in minitest 6, breaking plain
+`rake test`); it now stubs `IRB.start` via `define_singleton_method`.
+README documents running tests with `bundle exec rake test`.
+
+### `expand_aliases` no longer strips whitespace
+
+(ab3998e) Registering the first alias via `sh_alias`/`add_alias` ran the
+command through `expand_aliases` with an empty alias hash; the empty
+alternation degraded the regex to `(^| +)() *` and every space was
+deleted (`exa -l --icons=always` was stored as `exa-l--icons=always`).
+Now returns the input unchanged when no aliases are registered,
+`Regexp.escape`s alias names, uses a word-boundary lookahead (so `ll`
+no longer matches inside `lll`), and preserves whitespace around
+replaced terms. Debug prints removed; `test_expand_aliases` un-skipped
+with a regression test for the empty-alias case.
+
+### `Yarsh::InvalidPromptError` for invalid prompt configuration
+
+(4f0364e) `Config#prompt=` raises the new `Yarsh::InvalidPromptError`
+(subclass of `Yarsh::Error`) instead of a bare `StandardError`. The
+message is a constructor argument with the documented default.
+`Yarsh::Error` is now defined before sub-files are required, fixing a
+load-order `NameError` when subclassing it from `config.rb`. Tests
+assert the error class, the default message, and custom messages.
+
+### Logging methods in `InstanceMethods`
+
+(d867a11) Besides the existing `debug`, the REPL now exposes `info`,
+`warn`, `error`, `fatal`, and `unknown` — each delegating to
+`Config.instance.logger`, covering all `Logger` severities. Methods are
+defined dynamically from the `SEVERITIES` constant
+(`%w[DEBUG INFO WARN ERROR FATAL UNKNOWN]`).
+
+### 256-color and text styles in `AnsiColorFormatter`
+
+(3883da3) New `fg_color256`/`bg_color256` emit 8-bit indexed color
+codes (`38;5;N` / `48;5;N`) and raise `Yarsh::Error` for indices outside
+0..255. Text styles are defined dynamically from `STYLE_CODES`: `bold`,
+`dim`, `italic`, `underline`, `blink`, `reverse`, `hidden`,
+`strikethrough` — mirroring the `bg_*`/`fg_*` pattern. `print_color`
+now tolerates calls with neither text nor a block, so bare style calls
+(`formatter.bold.fg_red('x')`) chain correctly.
+
+### Real `ArgumentError`s are no longer shell-executed
+
+(13ea85f) Shell commands like `bundle exec rake test` raise
+`ArgumentError` (the innermost call resolves to `Kernel#test`, which
+requires 2 args). The fallback previously treated every `ArgumentError`
+as a shell command, so genuine Ruby errors (`"x".sub`) were
+shell-executed too. A new `shell_command?` predicate (first token in
+`PATH`, a bash builtin, or a shell path) decides: `ArgumentError` falls
+through to the shell only when the input looks like a command,
+otherwise the real Ruby error is reported. `NameError` and `SyntaxError`
+keep their unconditional shell fallback.
+
+### Renamed from `rsh` to `yarsh`
+
+(9009bfb) The project is now called **yarsh** throughout: module `Rsh`
+→ `Yarsh`, gem name `yarsh` (`spec.name`, require paths), data dir
+`~/.rsh` → `~/.yarsh`, executable `exe/ruby-shell` → `exe/yarsh`.
+Files renamed: `rsh.gemspec`, `lib/rsh.rb`, `lib/rsh/`,
+`sig/rsh.rbs`, `test/test_rsh.rb`. All references updated (tests,
+`bin/console`, README, AGENTS.md, CHANGES.md); `Gemfile.lock`
+regenerated. Version stays 0.1.0.

data/README.md

@@ -0,0 +1,99 @@
+# Yarsh
+
+Yet Another Ruby SHell is a mix of Ruby and standard Shell commands. Priority is given to Ruby but if the variable or method is not found or if it is a syntax error, it will be passed to the default shell environment. It enable the best of both worlds, the power of ruby and the simplicity of the standard Shell.
+
+This project was made just for fun, to remember the basis of Ruby and to discover new features. To provide a good user experience, it uses `reline` under the hood which already implement all we want for a REPL: History, completion, etc.
+
+I wanted a simple version but already working version. If I have time, more features will come. For example, multi-line editing or non interactive with a file as argument. I dream of a shell syntax we can do:
+
+```ruby
+def install_rails
+  sudo apt update
+  sudo apt install ruby
+  gem install rails
+end
+
+install_rails
+```
+
+I developed this project half of the time offline, another part with the help of AI. It was a way for me to try to develop with AI. I used `opencode` with DeepSeek V4 Flash Free.
+
+## Usage
+
+`yarsh` start the shell.
+
+## Features
+Use it as a normal shell, except that you can use Ruby commands and methods. For example:
+
+```ruby
+puts "Hello World! We can use Ruby or standard shell:"
+Dir["**/*.rb"].each { |file| puts file }
+puts "Or shell like:"
+find . -name  "*.rb" -print
+```
+
+For the moment, it display ruby evaluation results with `pretty_print`.
+
+### Special keyword for mixing
+
+You can also mix both with the special keyword `-->`. It will pass to ruby the result of the shell command to use in Ruby. For example:
+
+
+```ruby
+ls -al . --> lines.each { |file| puts file }
+```
+
+the result of the exectued shell command is `ExecOutput` a subclass of `String` with some extra methods. For the moment, it has:
+
+* `#lines`
+* `#words`
+
+You want to store the result of the ruby evaluation after a shell command? Use `-->(varible_name)`. For example:
+
+```ruby
+ls -al . -->(sorted) lines.sort {|a, b| a.length <=> b.length  }
+sorted.each { |file| puts "What ever you wanna do" }
+```
+
+### Completion
+
+For the moment, there is autocompletion for exectuables in PATH and for file and dir path for shell commands
+
+### Errors
+
+`$rberr` are set for every catched Ruby error.
+
+`$sherr` are set for every catched Shell error.
+
+### Configuration
+
+You can create a file named `config` in `~/.yarsh`. It is plain ruby, for now, you can define aliases for shell commands, define methods that will be available in the REPL, configure the prompt looks like and some logging. Here is an example file:
+
+```ruby
+
+sh_alias 'ls', 'exa -l --icons=always'
+sh_alias 'll', 'ls -a' # Will be expanded to exa -l --icons=always -a
+
+configure do |c|
+  c.prompt = :powerline # To available prompt: :powerline or :basic
+  # Or define how your own logic for the prompt. Should return a string
+  c.prompt = Proc.new do
+    "hello> "
+  end
+  c.log_level = Logger::DEBUG # Lot of unuseful lines
+end
+
+# Will be available in the REPL once the related TODO is completed
+def my_awsome_method
+  puts "Hello World"
+end
+```
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/facenord-sud/yarsh.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/exe/yarsh

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'yarsh'
+
+extend Yarsh::InstanceMethods
+Yarsh::Shell.new(binding).shell

data/lib/yarsh/ansi_color_formatter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Yarsh
+  class AnsiColorFormatter
+    BACKGROUND_CODES = {
+      black: "\e[40m",
+      red: "\e[41m",
+      green: "\e[42m",
+      yellow: "\e[43m",
+      blue: "\e[44m",
+      magenta: "\e[45m",
+      cyan: "\e[46m",
+      white: "\e[47m"
+
+    }.freeze
+
+    FORGROUND_CODES = {
+      black: "\e[30m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      magenta: "\e[35m",
+      cyan: "\e[36m",
+      white: "\e[37m"
+    }.freeze
+
+    STYLE_CODES = {
+      bold: "\e[1m",
+      dim: "\e[2m",
+      italic: "\e[3m",
+      underline: "\e[4m",
+      blink: "\e[5m",
+      reverse: "\e[7m",
+      hidden: "\e[8m",
+      strikethrough: "\e[9m"
+    }.freeze
+
+    RESET = "\e[0m"
+
+    BACKGROUND_CODES.each do |name, code|
+      define_method(:"bg_#{name}") do |text = nil, &block|
+        print_color(code, text, &block)
+        self
+      end
+    end
+
+    FORGROUND_CODES.each do |name, code|
+      define_method(:"fg_#{name}") do |text = nil, &block|
+        print_color(code, text, &block)
+        self
+      end
+    end
+
+    STYLE_CODES.each do |name, code|
+      define_method(name) do |text = nil, &block|
+        print_color(code, text, &block)
+        self
+      end
+    end
+
+    def fg_color256(color, text = nil, &block)
+      validate_color256!(color)
+      print_color("\e[38;5;#{color}m", text, &block)
+      self
+    end
+
+    def bg_color256(color, text = nil, &block)
+      validate_color256!(color)
+      print_color("\e[48;5;#{color}m", text, &block)
+      self
+    end
+
+    def initialize
+      @formatted_text = ''
+    end
+
+    def print_color(code, text = nil, &block)
+      content = text || (block && block.call).to_s
+      @formatted_text += code + content
+    end
+
+    private
+
+    def validate_color256!(color)
+      return if (0..255).cover?(color)
+
+      raise Yarsh::Error, "Color must be between 0 and 255, got #{color}"
+    end
+
+    public
+
+    def to_s
+      return_text = @formatted_text
+      @formatted_text = ''
+      return_text + RESET
+    end
+
+    def reset(text = nil)
+      @formatted_text += RESET
+      @formatted_text += text if text
+      self
+    end
+  end
+end

data/lib/yarsh/config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Yarsh
+  class InvalidPromptError < Yarsh::Error
+    DEFAULT_MESSAGE = 'Not a valid prompt type. Pass a method name of module Yarsh::Prompt or a block'
+
+    def initialize(message = DEFAULT_MESSAGE)
+      super(message)
+    end
+  end
+
+  class Config
+    include Singleton
+
+    attr_reader :aliases, :log_level
+    attr_accessor :logger
+
+    def initialize
+      @aliases = {}
+      @prompt = nil
+      @logger = Logger.new($stdout, level: Logger::UNKNOWN)
+    end
+
+    def log_level=(level)
+      @log_level = level
+      @logger.level = level
+    end
+
+    def add_alias(name, command)
+      expand_aliases = Yarsh.expand_aliases(command, @aliases)
+      @aliases[name.to_s] = expand_aliases
+    end
+
+    def prompt
+      prompt_method = @prompt || :basic
+      return Prompt.method(prompt_method).call if prompt_method.is_a? Symbol
+
+      @prompt.call
+    end
+
+    def prompt=(prompt)
+      raise InvalidPromptError unless prompt.respond_to?(:call) || Prompt.respond_to?(prompt)
+
+      @prompt = prompt
+    end
+  end
+end

data/lib/yarsh/instance_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Yarsh
+  module InstanceMethods
+    SEVERITIES = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN]
+
+    def sh_alias(new_name, command)
+      Config.instance.add_alias(new_name, command)
+    end
+
+    def source(filename)
+      load(filename, Yarsh::InstanceMethods)
+    end
+
+    def configure(&block)
+      block.call(Config.instance)
+    end
+
+    SEVERITIES.each do |severity|
+      method_name = severity.downcase
+      define_method(method_name) do |message|
+        Config.instance.logger.public_send(method_name, message)
+      end
+    end
+  end
+end

data/lib/yarsh/prompt.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Yarsh
+  module Prompt
+    def self.powerline
+      c = Yarsh::AnsiColorFormatter.new
+      base_color = 240
+      seg = Dir.pwd.gsub(/^#{Dir.home}/, '~').split('/')
+      seg = (seg.size > 3 ? [' …'] + seg[-3..-1] : seg)
+      git_branch = ''
+      git_branch = `git status --porcelain -b`.split("\n")&.first&.gsub('## ', '') || '' if File.directory?('.git')
+      git_branch = '   ' + git_branch unless git_branch.empty?
+      c.bg_color256(base_color)
+       .fg_white("#{seg.join('  ')}#{git_branch}")
+       .reset
+       .fg_color256(base_color, '')
+       .reset(' ')
+       .to_s
+    end
+
+    def self.basic
+      "#{Dir.pwd}> "
+    end
+  end
+end

data/lib/yarsh/shell.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+module Yarsh
+  class Shell
+    include Yarsh
+    include InstanceMethods
+
+    SHELL_BUILTINS = %w[alias bg bind break builtin cd command echo eval exec exit
+                        export false fc fg getopts hash help history jobs kill let
+                        local logout mapfile popd printf pushd pwd read readonly
+                        return set shift shopt source suspend test times trap true
+                        type typeset ulimit umask unalias unset wait].freeze
+
+    def initialize(bind)
+      @bind = bind
+      @core = Reline.core
+      @history_file = File.expand_path(HISTORY_FILE)
+      @config_file = File.expand_path(CONFIG_FILE)
+      @cf = Yarsh::AnsiColorFormatter.new
+      setup_reline_history
+      setup_reline_completion
+    end
+
+    def shell
+      # TODO: defined method in the config file should be availabel in the shell
+      load @config_file, InstanceMethods if File.exist? @config_file
+      loop do
+        input = begin
+          @core.readline(Config.instance.prompt, true)
+        rescue Interrupt
+          next
+        end
+        if input.nil? or input == 'exit'
+          puts 'Bye...'
+          break
+        end
+
+        append_history(input, @history_file)
+
+        begin
+          if input.include?('-->')
+            fp execute_pipe(input, @bind)
+            next
+          end
+
+          if shell_path?(input)
+            execute(input)
+            next
+          end
+
+          if input == 'cd' || input.start_with?('cd ')
+            cd(input.split(' ', 2)[1])
+            next
+          end
+
+          begin
+            result = @bind.eval(input)
+            fp result
+          rescue NameError, SyntaxError, ArgumentError => rb_error
+            unless shell_command?(input) || rb_error.is_a?(NameError) || rb_error.is_a?(SyntaxError)
+              $rber = rb_error
+              puts @cf.fg_red("Error: ArgumentError: #{rb_error.message}")
+              next
+            end
+            info("Assuming it is not a ruby expression, the error: #{rb_error.message}")
+            debug("The detail: #{rb_error.backtrace.join("\n")}")
+            begin
+              input = Yarsh.expand_aliases(input, Config.instance.aliases)
+              execute(input)
+            rescue Exception => e
+              $sher = e
+              info("#{e.class}: #{e.message}")
+              puts "#{@cf.bold.underline.fg_blue('Shell:')} '#{input}': #{e.message}"
+              puts "#{@cf.bold.underline.fg_red('Ruby:')} '#{input}': #{rb_error.message}"
+            end
+          end
+        rescue Interrupt
+          next
+        rescue SystemExit
+          raise
+        rescue Exception => e
+          $rber = e
+          puts @cf.fg_red("Error: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+        end
+      end
+    end
+
+    private
+
+    def format_output(object)
+      pp object
+    end
+    alias fp format_output
+
+    def cd(path = '~')
+      Dir.chdir(File.expand_path(path || '~'))
+    end
+
+    def execute(cmd)
+      system(cmd, exception: true)
+    end
+
+    def shell_command?(input)
+      first_token = input.strip.split(/\s+/, 2).first
+      return true if shell_path?(first_token)
+      return true if SHELL_BUILTINS.include?(first_token)
+
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, first_token))
+      end
+    end
+
+    def complete_command(word)
+      ENV['PATH'].split(File::PATH_SEPARATOR)
+                 .flat_map { |dir| Dir["#{dir}/#{word}*"] }
+                 .map { |f| File.basename(f) }
+                 .uniq
+                 .sort
+    end
+
+    def complete_path(word)
+      word = './' if word.empty?
+      glob_word = word.start_with?('~') ? File.expand_path(word) : word
+      entries = Dir.glob("#{glob_word}*").sort
+      entries = entries.map { |e| File.directory?(e) ? "#{e}/" : e }
+      if word.start_with?('~')
+        home = ENV['HOME']
+        entries.map { |e| e.sub(/\A#{Regexp.escape(home)}/, '~') }
+      else
+        entries
+      end
+    end
+
+    def append_history(input, history_file, max_lines = 1000)
+      File.open(history_file, File::RDWR | File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        f.seek(0, IO::SEEK_END)
+        f.puts(input)
+        f.rewind
+        lines = f.readlines(chomp: true)
+        if lines.size > max_lines
+          trimmed = lines.last(max_lines)
+          f.rewind
+          f.truncate(0)
+          trimmed.each { |l| f.puts(l) }
+        end
+      end
+    end
+
+    def execute_pipe(input, bind)
+      cmd, ruby_code = input.split('-->', 2).map(&:strip)
+      bind_var = nil
+      ruby_code.gsub!(/\(\w+\)( )*/) do |m|
+        bind_var = m.match(/\w+/)
+        ''
+      end
+      cmd = Yarsh.expand_aliases(cmd, Config.instance.aliases)
+      output = ExecOutput.new(`#{cmd} 2>&1`.chomp).instance_eval("_ = self\n#{ruby_code}", __FILE__, __LINE__)
+      bind_var = bind_var&.[](0)&.to_sym
+      bind.local_variable_set(bind_var, output) unless bind_var.nil?
+      output
+    end
+
+    def setup_reline_completion
+      Reline.completion_proc = proc { |target, pre|
+        # puts "target='#{target}' pre='#{pre}'"
+        if target.match?(%r{\A\.\.?(/|\z)}) || target.start_with?('/', '~') || target.include?('/')
+          complete_path(target)
+        elsif target.empty? && pre.empty?
+          complete_command(target)
+        elsif pre.end_with?(' ')
+          complete_path(target)
+        else
+          complete_command(target)
+        end
+      }
+    end
+
+    def setup_reline_history
+      Dir.mkdir(File.dirname(@history_file)) unless Dir.exist?(File.dirname(@history_file))
+      File.readlines(@history_file, chomp: true).each { |line| Reline::HISTORY << line } if File.exist?(@history_file)
+    end
+  end
+end

data/lib/yarsh/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yarsh
+  VERSION = "0.1.0"
+end

data/lib/yarsh.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'reline'
+require 'open3'
+require 'singleton'
+require 'logger'
+
+module Yarsh
+  class Error < StandardError; end
+end
+
+Dir['lib/yarsh/**/*.rb'].each do |f|
+  require_relative File.join('..', f)
+end
+
+module Yarsh
+  YARSH_DIR = '~/.yarsh'
+  HISTORY_FILE = File.join Yarsh::YARSH_DIR, 'history'
+  CONFIG_FILE = File.join Yarsh::YARSH_DIR, 'config'
+
+  class ExecOutput < String
+    def initialize(string)
+      super(string)
+    end
+
+    def lines
+      split("\n")
+    end
+
+    def words
+      split(' ')
+    end
+  end
+
+  class Error < StandardError; end
+
+  # in a Shell input, find all command matching the keys of aliases and replace them with
+  # the values. Leading and trailing whitespace around the match is preserved.
+  def self.expand_aliases(input, aliases)
+    return input if aliases.empty?
+
+    terms = aliases.keys.map { |k| Regexp.escape(k.to_s) }.join('|')
+    regex = Regexp.new(/(^| +)(#{terms})(?![A-Za-z0-9_])/)
+    input.gsub(regex) do |match|
+      rep = aliases[match.strip]
+      next match unless rep
+
+      match[/\A( +)/, 1].to_s + rep
+    end
+  end
+
+  def shell_path?(input)
+    input.match?(%r{\A\.\.?/}) ||
+      input.match?(%r{\A/}) ||
+      input.match?(/\A~/)
+  end
+
+  def self.execute_system_command(command)
+    Open3.popen3(command) do |input, output, error, wait_thread|
+      output_printer = Thread.new do
+        output.read.tap { |data| print data }
+      end
+      error_printer = Thread.new do
+        error.read.tap { |data| $stderr.print data }
+      end
+      Thread.new do
+        input.write($stdin.read)
+      end
+      output_printer.join
+      error_printer.join
+
+      wait_thread.value
+    end
+  end
+
+  def self.console
+    require 'irb'
+    IRB.start(__FILE__)
+  end
+end

data/sig/yarsh.rbs

@@ -0,0 +1,4 @@
+module Yarsh
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: yarsh
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yarsh4all
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+description: |2
+    Yet Another Ruby SHell is a mix of Ruby and standard Shell commands.
+    Priority is given to Ruby but if the variable or method is not found or
+    if it is a syntax error, it will be passed to the default shell environment.
+    It enable the best of both worlds, the power of ruby and the simplicity
+    of the standard Shell.
+email:
+- yarsh4all@gmail.com
+executables:
+- yarsh
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- AGENTS.md
+- CHANGES.md
+- README.md
+- Rakefile
+- exe/yarsh
+- lib/yarsh.rb
+- lib/yarsh/ansi_color_formatter.rb
+- lib/yarsh/config.rb
+- lib/yarsh/instance_methods.rb
+- lib/yarsh/prompt.rb
+- lib/yarsh/shell.rb
+- lib/yarsh/version.rb
+- sig/yarsh.rbs
+homepage: https://github.com/facenord-sud/yarsh.git
+licenses: []
+metadata:
+  homepage_uri: https://github.com/facenord-sud/yarsh.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Yet Another Ruby SHell is a mix of Ruby and standard Shell commands.
+test_files: []