mui-git 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f65a509ed569794ac6dbf4870c84e64683fb9a298f6d775b6fdd0bf18d7426e5
+  data.tar.gz: 70f1650ec729b6d33e09e9631f6dd9e80ad639e2139c8d5035a67934b30cff6d
+SHA512:
+  metadata.gz: 34f184cb80f5b402926b9627b6823ec8c1c3e1a941055c4c6640f55f1a95b555ebbd06f9d7efeffe931c12c579f91fea152e4fb6aa26c96ba8b87441022cb785
+  data.tar.gz: 6e73af2750dc349d17d5daa7516e8ed28e493381cc53d246bcceea1badf7a9cc63be030fde6426b168b8a8500a222209efb6f821c732e2014d69e9718047e0f5

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+## [Unreleased]
+
+### Added
+- Initial release
+- Interactive git status buffer (`:Git` or `:Git status`)
+- Diff buffer with syntax highlighting (`:Git diff`)
+- Git log viewing (`:Git log`)
+- Git blame viewing (`:Git blame`)
+- Stage files (`:Git add` or `s` key)
+- Unstage files (`u` key)
+- Toggle stage/unstage (`-` key)
+- Vertical diff split (`dv` keys)
+- Close buffer (`q` key)
+- Refresh status (`R` key)
+- Diff highlighting:
+  - Added lines in green
+  - Deleted lines in red
+  - Hunk headers in cyan
+  - File headers in yellow (bold)
+- Commit message buffer:
+  - Press `cc` in status buffer to open commit message editor
+  - Write commit message at top of buffer (lines starting with `#` are ignored)
+  - Save with `:w` to execute commit
+  - Cancel with `:q`
+  - Shows current branch and staged files as reference
+  - Status buffer automatically refreshes after successful commit
+- Log/Blame commit navigation:
+  - Press `Enter` in log buffer to view commit diff
+  - Press `Enter` in blame buffer to view the commit that last modified the current line
+  - Commit diff opens in vertical split with syntax highlighting
+  - Uncommitted changes (`00000000`) in blame buffer are skipped
+  - New buffer classes: LogBuffer, BlameBuffer, CommitShowBuffer
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 S-H-GAMELINKS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# mui-git
+
+A Git integration plugin for [Mui](https://github.com/S-H-GAMELINKS/mui) editor, inspired by vim-fugitive.
+
+## Installation
+
+Add to your `.muirc`:
+
+```ruby
+Mui.use "mui-git"
+```
+
+Or install via RubyGems (when published):
+
+```bash
+gem install mui-git
+```
+
+## Features
+
+- Interactive git status buffer
+- Diff viewing with syntax highlighting
+- Stage/unstage files with keyboard shortcuts
+- Commit message editor buffer
+- Git log and blame viewing with commit diff navigation
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `:Git` or `:Git status` | Open git status buffer |
+| `:Git diff [file]` | Open diff buffer for file (current file if omitted) |
+| `:Git log [limit]` | Show commit log (default: 20 commits) |
+| `:Git blame [file]` | Show git blame for file |
+| `:Git add [file\|%]` | Stage file (`%` for current file) |
+| `:Git commit <message>` | Create commit with message |
+
+## Keymaps (Status Buffer)
+
+| Key | Description |
+|-----|-------------|
+| `s` | Stage file under cursor |
+| `u` | Unstage file under cursor |
+| `-` | Toggle stage/unstage |
+| `dv` | Open diff in vertical split |
+| `cc` | Open commit message buffer |
+| `q` | Close buffer |
+| `R` | Refresh status |
+
+## Keymaps (Log/Blame Buffer)
+
+| Key | Description |
+|-----|-------------|
+| `Enter` | Show commit diff in vertical split |
+| `q` | Close buffer |
+
+In the log buffer (`:Git log`), pressing `Enter` on a commit line opens the full commit diff with syntax highlighting.
+
+In the blame buffer (`:Git blame`), pressing `Enter` on any line shows the diff for that line's commit. Uncommitted changes (shown as `00000000`) are skipped.
+
+## Commit Message Buffer
+
+When you press `cc` in the status buffer, a commit message editor opens:
+
+1. Write your commit message at the top of the buffer
+2. Lines starting with `#` are comments and will be ignored
+3. Save with `:w` to execute the commit
+4. Close with `:q` to cancel
+
+The buffer shows the current branch and staged files as reference.
+
+## Diff Highlighting
+
+Diff output is syntax highlighted:
+- Added lines (`+`) are shown in green
+- Deleted lines (`-`) are shown in red
+- Hunk headers (`@@`) are shown in cyan
+- File headers are shown in yellow (bold)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/S-H-GAMELINKS/mui-git.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/lib/mui/git/buffers/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Buffers
+      # Base class for Git buffers (inherits from Mui::Buffer)
+      # Provides common functionality for git-related buffers
+      class Base < Mui::Buffer
+        attr_accessor :pending_key
+
+        def initialize(name)
+          super(name)
+          @readonly = true
+          @pending_key = nil
+        end
+
+        # Update buffer content (works even for readonly buffers)
+        def refresh_content(text)
+          @lines = text.lines.map(&:chomp)
+          @lines = [""] if @lines.empty?
+          @modified = false
+        end
+
+        # Set pending key for multi-key sequences (like dv, cc)
+        def set_pending(key)
+          @pending_key = key
+        end
+
+        # Clear pending key
+        def clear_pending
+          @pending_key = nil
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/blame_buffer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Buffers
+      # Buffer for displaying git blame with commit selection
+      class BlameBuffer < Base
+        attr_reader :runner, :file_path
+
+        def initialize(file_path, runner: CommandRunner.new)
+          super("[Git Blame: #{File.basename(file_path)}]")
+          @file_path = file_path
+          @runner = runner
+          refresh
+        end
+
+        def refresh
+          output = @runner.blame(@file_path)
+          if output.empty?
+            refresh_content("(no blame data)")
+          else
+            refresh_content(output)
+          end
+        end
+
+        # Extract commit hash from current line
+        # Blame format: "abc12345 (Author Name 2024-01-01 12:00:00 +0900  1) code..."
+        # or for uncommitted: "00000000 (Not Committed Yet ...)"
+        def commit_at(row)
+          line = @lines[row]
+          return nil unless line
+
+          # Match commit hash at start of line (skip 00000000 for uncommitted)
+          match = line.match(/^([a-f0-9]{7,40})\s/)
+          return nil unless match
+
+          hash = match[1]
+          # Skip uncommitted changes (all zeros)
+          return nil if hash.match?(/^0+$/)
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/commit_buffer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Buffers
+      # Buffer for editing git commit message
+      # When saved, executes git commit with the message
+      class CommitBuffer < Mui::Buffer
+        attr_reader :runner, :editor, :on_commit
+
+        COMMIT_MSG_TEMPLATE = <<~MSG
+
+          # Please enter the commit message for your changes.
+          # Lines starting with '#' will be ignored.
+          #
+          # On branch: %<branch>s
+          #
+          # Changes to be committed:
+          %<staged>s
+        MSG
+
+        def initialize(runner: CommandRunner.new, editor: nil, on_commit: nil)
+          super("[Git Commit]")
+          @runner = runner
+          @editor = editor
+          @on_commit = on_commit
+          @readonly = false
+          setup_template
+        end
+
+        # Override save to execute git commit instead of writing to file
+        def save(_path = nil)
+          message = extract_message
+          if message.empty?
+            @editor&.message = "Git: empty commit message, aborting"
+            return
+          end
+
+          begin
+            output = @runner.commit(message)
+            if output =~ /\[.+? ([a-f0-9]+)\]/
+              @editor&.message = "Git: committed [#{::Regexp.last_match(1)}]"
+            else
+              @editor&.message = "Git: committed"
+            end
+            @modified = false
+            @on_commit&.call
+            close_buffer
+          rescue CommandRunner::GitCommandError => e
+            @editor&.message = "Git error: #{e.message}"
+          end
+        end
+
+        private
+
+        def setup_template
+          branch = @runner.current_branch rescue "unknown"
+          staged = format_staged_files
+
+          template = format(COMMIT_MSG_TEMPLATE, branch: branch, staged: staged)
+          @lines = template.lines.map(&:chomp)
+          @lines = [""] if @lines.empty?
+          @modified = false
+        end
+
+        def format_staged_files
+          output = @runner.status
+          staged_lines = output.lines.select do |line|
+            index_status = line[0]
+            index_status != " " && index_status != "?"
+          end
+
+          if staged_lines.empty?
+            "#   (no staged changes)"
+          else
+            staged_lines.map { |line| "#   #{line.strip}" }.join("\n")
+          end
+        end
+
+        def extract_message
+          # Filter out comment lines and join
+          message_lines = @lines.reject { |line| line.start_with?("#") }
+          # Remove leading/trailing blank lines
+          message_lines.shift while message_lines.first&.strip&.empty?
+          message_lines.pop while message_lines.last&.strip&.empty?
+          message_lines.join("\n").strip
+        end
+
+        def close_buffer
+          return unless @editor
+
+          window_manager = @editor.tab_manager.current_tab.window_manager
+          current_window = window_manager.active_window
+          window_manager.close_current_window if current_window&.buffer == self
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/commit_show_buffer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../highlighters/diff_highlighter"
+
+module Mui
+  module Git
+    module Buffers
+      # Buffer for displaying a specific commit's diff
+      class CommitShowBuffer < Base
+        attr_reader :runner, :commit_hash
+
+        def initialize(commit_hash, runner: CommandRunner.new)
+          super("[Git Commit: #{commit_hash[0, 7]}]")
+          @commit_hash = commit_hash
+          @runner = runner
+          refresh
+        end
+
+        def refresh
+          output = @runner.show(@commit_hash)
+          if output.empty?
+            refresh_content("(no commit data)")
+          else
+            refresh_content(output)
+          end
+        end
+
+        # Provide diff highlighter for this buffer
+        def custom_highlighters(color_scheme)
+          [Highlighters::DiffHighlighter.new(color_scheme)]
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/diff_buffer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../highlighters/diff_highlighter"
+
+module Mui
+  module Git
+    module Buffers
+      # Buffer for displaying git diff
+      class DiffBuffer < Base
+        attr_reader :file_path, :runner
+
+        def initialize(file_path, runner: CommandRunner.new, staged: false)
+          super("[Git Diff: #{File.basename(file_path)}]")
+          @file_path = file_path
+          @runner = runner
+          @staged = staged
+          refresh
+        end
+
+        # Refresh diff content
+        def refresh
+          output = if @staged
+                     @runner.diff_staged(@file_path)
+                   else
+                     @runner.diff(@file_path)
+                   end
+
+          if output.empty?
+            refresh_content("(no changes)")
+          else
+            refresh_content(output)
+          end
+        end
+
+        # Provide diff highlighter for this buffer
+        def custom_highlighters(color_scheme)
+          [Highlighters::DiffHighlighter.new(color_scheme)]
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/log_buffer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Buffers
+      # Buffer for displaying git log with commit selection
+      class LogBuffer < Base
+        attr_reader :runner
+
+        def initialize(runner: CommandRunner.new, limit: 20)
+          super("[Git Log]")
+          @runner = runner
+          @limit = limit
+          refresh
+        end
+
+        def refresh
+          output = @runner.log(limit: @limit)
+          if output.empty?
+            refresh_content("(no commits)")
+          else
+            refresh_content(output)
+          end
+        end
+
+        # Extract commit hash from current line
+        # Log format: "abc1234 commit message..."
+        def commit_at(row)
+          line = @lines[row]
+          return nil unless line
+
+          # Match short commit hash at start of line
+          match = line.match(/^([a-f0-9]{7,40})\s/)
+          match&.[](1)
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/buffers/status_buffer.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Buffers
+      # Interactive git status buffer
+      # Displays staged/unstaged files and allows staging/unstaging
+      class StatusBuffer < Base
+        # Represents a file in git status
+        FileEntry = Struct.new(:index_status, :work_tree_status, :path, keyword_init: true) do
+          def staged?
+            index_status != " " && index_status != "?"
+          end
+
+          def unstaged?
+            work_tree_status != " "
+          end
+
+          def untracked?
+            index_status == "?" && work_tree_status == "?"
+          end
+
+          def status_display
+            case
+            when untracked? then "??"
+            when staged? && unstaged? then "#{index_status}#{work_tree_status}"
+            when staged? then "#{index_status} "
+            when unstaged? then " #{work_tree_status}"
+            else "  "
+            end
+          end
+        end
+
+        attr_reader :files, :runner
+
+        def initialize(runner: CommandRunner.new)
+          super("[Git Status]")
+          @runner = runner
+          @files = []
+          @staged_files = []
+          @unstaged_files = []
+          refresh
+        end
+
+        # Refresh git status
+        def refresh
+          output = @runner.status
+          @files = parse_status(output)
+          @staged_files = @files.select(&:staged?)
+          @unstaged_files = @files.select { |f| f.unstaged? || f.untracked? }
+          refresh_content(format_display)
+        end
+
+        # Get file at cursor position
+        def file_at(row)
+          # Account for header lines
+          # Line 0: "Staged:" header (or "Unstaged:" if no staged files)
+          # Lines 1..staged_count: staged files
+          # Line staged_count+1: empty line (if both sections exist)
+          # Line staged_count+2: "Unstaged:" header
+          # Lines staged_count+3..end: unstaged files
+
+          staged_start_row = 1
+          staged_end_row = staged_start_row + @staged_files.size - 1
+
+          unstaged_header_row = @staged_files.empty? ? 0 : staged_end_row + 2
+          unstaged_start_row = unstaged_header_row + 1
+
+          if @staged_files.any? && row >= staged_start_row && row <= staged_end_row
+            @staged_files[row - staged_start_row]
+          elsif @unstaged_files.any? && row >= unstaged_start_row
+            index = row - unstaged_start_row
+            @unstaged_files[index] if index < @unstaged_files.size
+          end
+        end
+
+        private
+
+        def parse_status(output)
+          output.lines.map do |line|
+            next if line.strip.empty?
+
+            index_status = line[0]
+            work_tree_status = line[1]
+            path = line[3..].strip
+
+            FileEntry.new(
+              index_status: index_status,
+              work_tree_status: work_tree_status,
+              path: path
+            )
+          end.compact
+        end
+
+        def format_display
+          lines = []
+
+          if @staged_files.any?
+            lines << "Staged:"
+            @staged_files.each do |file|
+              lines << "  #{file.status_display} #{file.path}"
+            end
+          end
+
+          if @staged_files.any? && @unstaged_files.any?
+            lines << ""
+          end
+
+          if @unstaged_files.any?
+            lines << "Unstaged:"
+            @unstaged_files.each do |file|
+              lines << "  #{file.status_display} #{file.path}"
+            end
+          end
+
+          if lines.empty?
+            lines << "Working tree clean"
+          end
+
+          lines << ""
+          lines << "Press: s=stage, u=unstage, -=toggle, dv=diff, cc=commit, q=quit, R=refresh"
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/command_runner.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+
+module Mui
+  module Git
+    # Executes git commands and handles errors
+    class CommandRunner
+      class NotInGitRepositoryError < StandardError
+        def initialize
+          super("Not in a git repository")
+        end
+      end
+
+      class GitCommandError < StandardError
+        attr_reader :stderr, :exit_status
+
+        def initialize(message, stderr: nil, exit_status: nil)
+          super(message)
+          @stderr = stderr
+          @exit_status = exit_status
+        end
+      end
+
+      # Check if current directory is inside a git repository
+      def in_git_repository?
+        _, _, status = Open3.capture3("git", "rev-parse", "--git-dir")
+        status.success?
+      end
+
+      # Get git status in porcelain format
+      def status
+        run("status", "--porcelain")
+      end
+
+      # Get diff for a file or all files
+      def diff(file_path = nil)
+        if file_path
+          run("diff", "--", file_path)
+        else
+          run("diff")
+        end
+      end
+
+      # Get staged diff
+      def diff_staged(file_path = nil)
+        if file_path
+          run("diff", "--cached", "--", file_path)
+        else
+          run("diff", "--cached")
+        end
+      end
+
+      # Get git log
+      def log(limit: 20, format: nil)
+        args = ["log", "--oneline", "--decorate", "-n", limit.to_s]
+        args += ["--format=#{format}"] if format
+        run(*args)
+      end
+
+      # Get git blame for a file
+      def blame(file_path)
+        run("blame", "--", file_path)
+      end
+
+      # Stage a file
+      def add(file_path)
+        run("add", "--", file_path)
+      end
+
+      # Unstage a file
+      def reset(file_path)
+        run("reset", "HEAD", "--", file_path)
+      end
+
+      # Create a commit
+      def commit(message)
+        run("commit", "-m", message)
+      end
+
+      # Get current branch name
+      def current_branch
+        run("rev-parse", "--abbrev-ref", "HEAD").strip
+      end
+
+      # Show diff for a specific commit
+      def show(commit_hash)
+        run("show", "--format=fuller", commit_hash)
+      end
+
+      # Run a git command synchronously
+      def run(*args)
+        ensure_git_repository!
+
+        stdout, stderr, status = Open3.capture3("git", *args)
+
+        unless status.success?
+          raise GitCommandError.new(
+            "git #{args.join(" ")} failed: #{stderr.lines.first&.strip}",
+            stderr: stderr,
+            exit_status: status.exitstatus
+          )
+        end
+
+        stdout
+      end
+
+      private
+
+      def ensure_git_repository!
+        raise NotInGitRepositoryError unless in_git_repository?
+      end
+    end
+  end
+end

data/lib/mui/git/highlighters/diff_highlighter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    module Highlighters
+      # Highlighter for git diff output
+      class DiffHighlighter < Mui::Highlighters::Base
+        PRIORITY_DIFF = 50
+
+        def highlights_for(row, line, _options = {})
+          style = style_for_line(line)
+          return [] unless style
+
+          [
+            Mui::Highlight.new(
+              start_col: 0,
+              end_col: line.length,
+              style: style,
+              priority: priority
+            )
+          ]
+        end
+
+        def priority
+          PRIORITY_DIFF
+        end
+
+        private
+
+        def style_for_line(line)
+          case line
+          when /^@@/
+            :diff_hunk
+          when /^\+\+\+/, /^---/, /^diff --git/, /^index /
+            :diff_header
+          when /^\+/
+            :diff_add
+          when /^-/
+            :diff_delete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mui/git/plugin.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    # Main plugin class for mui-git
+    # Registers commands and keymaps for git integration
+    class Plugin < Mui::Plugin
+      name "git"
+
+      def setup
+        register_commands
+        register_keymaps
+      end
+
+      private
+
+      def register_commands
+        # Main :Git command
+        command(:Git) do |ctx, args|
+          handle_git_command(ctx, args)
+        end
+      end
+
+      def register_keymaps
+        # Keymaps for Git buffers
+        register_status_keymaps
+        register_log_blame_keymaps
+      end
+
+      def register_status_keymaps
+        # Stage file
+        keymap(:normal, "s") do |ctx|
+          next unless status_buffer?(ctx.buffer)
+
+          handle_stage(ctx)
+          true # Indicate key was handled
+        end
+
+        # Unstage file
+        keymap(:normal, "u") do |ctx|
+          next unless status_buffer?(ctx.buffer)
+
+          handle_unstage(ctx)
+          true
+        end
+
+        # Toggle stage/unstage
+        keymap(:normal, "-") do |ctx|
+          next unless status_buffer?(ctx.buffer)
+
+          handle_toggle(ctx)
+          true
+        end
+
+        # Diff (first key of 'dv')
+        keymap(:normal, "d") do |ctx|
+          next unless git_buffer?(ctx.buffer)
+
+          ctx.buffer.set_pending("d")
+          true
+        end
+
+        # Diff vertical split (when 'v' pressed after 'd')
+        keymap(:normal, "v") do |ctx|
+          next unless git_buffer?(ctx.buffer)
+          next unless ctx.buffer.pending_key == "d"
+
+          ctx.buffer.clear_pending
+          handle_diff_vertical(ctx)
+          true
+        end
+
+        # Commit (first key of 'cc')
+        keymap(:normal, "c") do |ctx|
+          next unless status_buffer?(ctx.buffer)
+
+          if ctx.buffer.pending_key == "c"
+            ctx.buffer.clear_pending
+            handle_commit(ctx)
+          else
+            ctx.buffer.set_pending("c")
+          end
+          true
+        end
+
+        # Quit buffer
+        keymap(:normal, "q") do |ctx|
+          next unless git_buffer?(ctx.buffer)
+
+          handle_quit(ctx)
+          true
+        end
+
+        # Refresh
+        keymap(:normal, "R") do |ctx|
+          next unless status_buffer?(ctx.buffer)
+
+          handle_refresh(ctx)
+          true
+        end
+      end
+
+      def register_log_blame_keymaps
+        # Enter key to show commit diff in Log/Blame buffers
+        keymap(:normal, "\r") do |ctx|
+          next unless log_buffer?(ctx.buffer) || blame_buffer?(ctx.buffer)
+
+          handle_show_commit(ctx)
+          true
+        end
+      end
+
+      # Command handlers
+
+      def handle_git_command(ctx, args)
+        # args is a string like "log 20" or nil
+        arg_parts = args.to_s.split(/\s+/)
+        subcommand = arg_parts[0]&.strip || ""
+
+        runner = CommandRunner.new
+
+        unless runner.in_git_repository?
+          ctx.set_message("Git: not in a git repository")
+          return
+        end
+
+        case subcommand
+        when "", "status"
+          open_status_buffer(ctx, runner)
+        when "diff"
+          file_path = arg_parts[1] || current_file_path(ctx)
+          open_diff_buffer(ctx, file_path, runner)
+        when "log"
+          limit = arg_parts[1]&.to_i || 20
+          show_log(ctx, limit, runner)
+        when "blame"
+          file_path = arg_parts[1] || current_file_path(ctx)
+          show_blame(ctx, file_path, runner)
+        when "add"
+          file_path = resolve_file_path(arg_parts[1], ctx)
+          stage_file(ctx, file_path, runner)
+        when "commit"
+          message = arg_parts[1..].join(" ") if arg_parts.size > 1
+          create_commit(ctx, message, runner)
+        else
+          ctx.set_message("Git: unknown command '#{subcommand}'")
+        end
+      rescue CommandRunner::NotInGitRepositoryError
+        ctx.set_message("Git: not in a git repository")
+      rescue CommandRunner::GitCommandError => e
+        ctx.set_message("Git error: #{e.message}")
+      end
+
+      # Status buffer handlers
+
+      def handle_stage(ctx)
+        file = ctx.buffer.file_at(ctx.window.cursor_row)
+        return unless file
+
+        ctx.run_shell_command("git add -- #{Shellwords.escape(file.path)}",
+                             on_complete: lambda { |job|
+                               if job.result[:success]
+                                 ctx.buffer.refresh
+                                 ctx.set_message("Staged: #{file.path}")
+                               else
+                                 ctx.set_message("Git error: #{job.result[:stderr]&.lines&.first&.strip}")
+                               end
+                             })
+      end
+
+      def handle_unstage(ctx)
+        file = ctx.buffer.file_at(ctx.window.cursor_row)
+        return unless file
+
+        ctx.run_shell_command("git reset HEAD -- #{Shellwords.escape(file.path)}",
+                             on_complete: lambda { |job|
+                               if job.result[:success]
+                                 ctx.buffer.refresh
+                                 ctx.set_message("Unstaged: #{file.path}")
+                               else
+                                 ctx.set_message("Git error: #{job.result[:stderr]&.lines&.first&.strip}")
+                               end
+                             })
+      end
+
+      def handle_toggle(ctx)
+        file = ctx.buffer.file_at(ctx.window.cursor_row)
+        return unless file
+
+        if file.staged?
+          handle_unstage(ctx)
+        else
+          handle_stage(ctx)
+        end
+      end
+
+      def handle_diff_vertical(ctx)
+        if status_buffer?(ctx.buffer)
+          file = ctx.buffer.file_at(ctx.window.cursor_row)
+          return unless file
+
+          diff_buffer = Buffers::DiffBuffer.new(file.path, runner: ctx.buffer.runner, staged: file.staged?)
+          ctx.editor.window_manager.split_vertical(diff_buffer)
+        end
+      end
+
+      def handle_commit(ctx)
+        runner = ctx.buffer.respond_to?(:runner) ? ctx.buffer.runner : CommandRunner.new
+        status_buffer = ctx.buffer if status_buffer?(ctx.buffer)
+
+        # Callback to refresh status buffer after commit
+        on_commit = lambda do
+          status_buffer&.refresh
+        end
+
+        commit_buffer = Buffers::CommitBuffer.new(
+          runner: runner,
+          editor: ctx.editor,
+          on_commit: on_commit
+        )
+        ctx.editor.window_manager.split_horizontal(commit_buffer)
+      end
+
+      def handle_quit(ctx)
+        ctx.editor.window_manager.close_window(ctx.window)
+      end
+
+      def handle_refresh(ctx)
+        ctx.buffer.refresh
+        ctx.set_message("Git: status refreshed")
+      end
+
+      # Helper methods
+
+      def open_status_buffer(ctx, runner)
+        status_buffer = Buffers::StatusBuffer.new(runner: runner)
+        ctx.editor.window_manager.split_horizontal(status_buffer)
+      end
+
+      def open_diff_buffer(ctx, file_path, runner)
+        if file_path.nil? || file_path.empty?
+          ctx.set_message("Git: no file specified")
+          return
+        end
+
+        diff_buffer = Buffers::DiffBuffer.new(file_path, runner: runner)
+        ctx.editor.window_manager.split_horizontal(diff_buffer)
+      end
+
+      def show_log(ctx, limit, runner)
+        log_buffer = Buffers::LogBuffer.new(runner: runner, limit: limit)
+        ctx.editor.window_manager.split_horizontal(log_buffer)
+      end
+
+      def show_blame(ctx, file_path, runner)
+        if file_path.nil? || file_path.empty?
+          ctx.set_message("Git: no file specified")
+          return
+        end
+
+        blame_buffer = Buffers::BlameBuffer.new(file_path, runner: runner)
+        ctx.editor.window_manager.split_horizontal(blame_buffer)
+      end
+
+      def handle_show_commit(ctx)
+        commit_hash = ctx.buffer.commit_at(ctx.window.cursor_row)
+        return ctx.set_message("Git: no commit at cursor") unless commit_hash
+
+        runner = ctx.buffer.runner
+        commit_buffer = Buffers::CommitShowBuffer.new(commit_hash, runner: runner)
+        ctx.editor.window_manager.split_vertical(commit_buffer)
+      rescue CommandRunner::GitCommandError => e
+        ctx.set_message("Git error: #{e.message}")
+      end
+
+      def stage_file(ctx, file_path, runner)
+        if file_path.nil? || file_path.empty?
+          ctx.set_message("Git: no file specified")
+          return
+        end
+
+        runner.add(file_path)
+        ctx.set_message("Git: staged #{file_path}")
+      end
+
+      def create_commit(ctx, message, runner)
+        if message.nil? || message.strip.empty?
+          ctx.set_message("Git: commit message required. Usage: :Git commit <message>")
+          return
+        end
+
+        output = runner.commit(message)
+        # Extract commit hash from output
+        if output =~ /\[.+? ([a-f0-9]+)\]/
+          ctx.set_message("Git: committed [#{::Regexp.last_match(1)}]")
+        else
+          ctx.set_message("Git: committed")
+        end
+      end
+
+      def status_buffer?(buffer)
+        buffer.is_a?(Buffers::StatusBuffer)
+      end
+
+      def log_buffer?(buffer)
+        buffer.is_a?(Buffers::LogBuffer)
+      end
+
+      def blame_buffer?(buffer)
+        buffer.is_a?(Buffers::BlameBuffer)
+      end
+
+      def git_buffer?(buffer)
+        buffer.is_a?(Buffers::Base) ||
+          buffer.is_a?(Buffers::LogBuffer) ||
+          buffer.is_a?(Buffers::BlameBuffer)
+      end
+
+      def current_file_path(ctx)
+        path = ctx.buffer.file_path
+        return nil if path.nil? || path.start_with?("[")
+
+        path
+      end
+
+      def resolve_file_path(arg, ctx)
+        return current_file_path(ctx) if arg == "%"
+
+        arg
+      end
+    end
+  end
+end

data/lib/mui/git/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mui
+  module Git
+    VERSION = "0.1.0"
+  end
+end

data/lib/mui/git.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "mui"
+
+require_relative "git/version"
+require_relative "git/command_runner"
+require_relative "git/buffers/base"
+require_relative "git/buffers/status_buffer"
+require_relative "git/buffers/diff_buffer"
+require_relative "git/buffers/commit_buffer"
+require_relative "git/buffers/log_buffer"
+require_relative "git/buffers/blame_buffer"
+require_relative "git/buffers/commit_show_buffer"
+require_relative "git/plugin"
+
+module Mui
+  module Git
+    class Error < StandardError; end
+  end
+end
+
+# Register the plugin with Mui
+Mui.plugin_manager.register(:git, Mui::Git::Plugin)

data/lib/mui_git.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "mui/git"

data/sig/mui/git.rbs

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

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: mui-git
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- S-H-GAMELINKS
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: A Git integration plugin for Mui TUI editor. Provides interactive git
+  status buffer with staging/unstaging, diff view, and more.
+email:
+- gamelinks007@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mui/git.rb
+- lib/mui/git/buffers/base.rb
+- lib/mui/git/buffers/blame_buffer.rb
+- lib/mui/git/buffers/commit_buffer.rb
+- lib/mui/git/buffers/commit_show_buffer.rb
+- lib/mui/git/buffers/diff_buffer.rb
+- lib/mui/git/buffers/log_buffer.rb
+- lib/mui/git/buffers/status_buffer.rb
+- lib/mui/git/command_runner.rb
+- lib/mui/git/highlighters/diff_highlighter.rb
+- lib/mui/git/plugin.rb
+- lib/mui/git/version.rb
+- lib/mui_git.rb
+- sig/mui/git.rbs
+homepage: https://github.com/S-H-GAMELINKS/mui-git
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/S-H-GAMELINKS/mui-git
+  source_code_uri: https://github.com/S-H-GAMELINKS/mui-git
+  changelog_uri: https://github.com/S-H-GAMELINKS/mui-git/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.0.beta2
+specification_version: 4
+summary: Git integration plugin for Mui editor (fugitive.vim-like)
+test_files: []