mui 0.2.0 → 0.4.0

data/docs/plugins.md

@@ -0,0 +1,285 @@
+---
+title: Plugins
+layout: default
+nav_order: 5
+---
+
+# Plugins
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+---
+
+## Overview
+
+Mui's plugin system allows you to extend the editor's functionality using Ruby gems. Plugins can:
+
+- Add custom commands
+- Define key mappings
+- React to events (autocmd)
+- Integrate with external tools
+- Add syntax highlighting
+
+## Official Plugins
+
+| Plugin | Description | Install |
+|--------|-------------|---------|
+| [mui-lsp](https://github.com/S-H-GAMELINKS/mui-lsp) | LSP support | `gem install mui-lsp` |
+| [mui-git](https://github.com/S-H-GAMELINKS/mui-git) | Git integration | `gem install mui-git` |
+| [mui-fzf](https://github.com/S-H-GAMELINKS/mui-fzf) | fzf integration | `gem install mui-fzf` |
+
+## Using Plugins
+
+### Loading Plugins
+
+Add plugins to your `~/.muirc`:
+
+```ruby
+Mui.use "mui-lsp"
+Mui.use "mui-git"
+Mui.use "mui-fzf"
+```
+
+Plugins are automatically installed via `bundler/inline` on first startup.
+
+### LSP Configuration
+
+Configure LSP servers with `Mui.lsp`:
+
+```ruby
+Mui.use "mui-lsp"
+
+Mui.lsp do
+  # Use preset configuration
+  use :ruby
+
+  # Custom server configuration
+  server :typescript,
+    command: ["typescript-language-server", "--stdio"],
+    filetypes: ["typescript", "typescriptreact"]
+end
+```
+
+---
+
+## Creating Plugins
+
+### Class-based Plugin
+
+```ruby
+class MyPlugin < Mui::Plugin
+  name :my_plugin
+  version "1.0.0"
+  description "My awesome plugin"
+
+  # Optional: declare dependencies
+  depends_on :other_plugin
+
+  def setup
+    # Define commands, keymaps, autocmds here
+  end
+end
+```
+
+### DSL-based Plugin
+
+```ruby
+Mui.define_plugin(:my_plugin) do
+  # Define commands, keymaps, autocmds here
+end
+```
+
+---
+
+## Plugin API
+
+### Commands
+
+```ruby
+def setup
+  command :greet do |ctx|
+    ctx.set_message("Hello!")
+  end
+
+  command :greet_name do |ctx, name|
+    ctx.set_message("Hello, #{name}!")
+  end
+end
+```
+
+### Key Mappings
+
+```ruby
+def setup
+  # Normal mode mapping
+  keymap :normal, "<Leader>g" do |ctx|
+    ctx.editor.execute_command("greet")
+  end
+
+  # Insert mode mapping
+  keymap :insert, "<C-g>" do |ctx|
+    ctx.insert_text("Generated text")
+  end
+
+  # Multi-key sequence
+  keymap :normal, "<Leader>gg" do |ctx|
+    ctx.set_message("Leader g g pressed!")
+  end
+end
+```
+
+### Autocmd Events
+
+```ruby
+def setup
+  autocmd :BufEnter, pattern: "*.rb" do |ctx|
+    ctx.set_message("Opened Ruby file: #{ctx.buffer.file_path}")
+  end
+
+  autocmd :BufWritePre do |ctx|
+    # Run before every file save
+  end
+
+  autocmd :InsertLeave do |ctx|
+    # Run when leaving insert mode
+  end
+end
+```
+
+---
+
+## CommandContext API
+
+The `ctx` object passed to handlers provides access to editor internals:
+
+### Messages
+
+```ruby
+ctx.set_message("Info message")
+ctx.set_error("Error message")
+```
+
+### Editor Access
+
+```ruby
+ctx.editor                    # Editor instance
+ctx.buffer                    # Current buffer
+ctx.window                    # Current window
+ctx.mode                      # Current mode (:normal, :insert, etc.)
+```
+
+### Mode Control
+
+```ruby
+ctx.change_mode(:normal)
+ctx.change_mode(:insert)
+```
+
+### Text Manipulation
+
+```ruby
+ctx.insert_text("text")       # Insert at cursor
+ctx.buffer.lines              # Get all lines
+ctx.buffer.line(n)            # Get line n
+```
+
+### Cursor
+
+```ruby
+ctx.cursor_row                # Current row (0-indexed)
+ctx.cursor_col                # Current column (0-indexed)
+ctx.move_cursor(row, col)     # Move cursor
+```
+
+### File Operations
+
+```ruby
+ctx.buffer.file_path          # Current file path
+ctx.buffer.modified?          # Has unsaved changes?
+ctx.editor.execute_command("w")   # Save file
+ctx.editor.execute_command("e filename")  # Open file
+```
+
+### Scratch Buffers
+
+```ruby
+ctx.open_scratch_buffer("[Results]", "Content here")
+```
+
+### Jobs
+
+See [Jobs]({{ site.baseurl }}/jobs) for async job execution.
+
+### Interactive Commands
+
+```ruby
+if ctx.command_exists?("fzf")
+  result = ctx.run_interactive_command("fzf")
+  ctx.editor.execute_command("e #{result}") if result
+end
+```
+
+---
+
+## Publishing Plugins
+
+### Gem Structure
+
+```
+mui-myplugin/
+├── lib/
+│   └── mui_myplugin.rb
+├── mui-myplugin.gemspec
+└── README.md
+```
+
+### Gemspec
+
+```ruby
+Gem::Specification.new do |spec|
+  spec.name          = "mui-myplugin"
+  spec.version       = "1.0.0"
+  spec.summary       = "My Mui plugin"
+  spec.files         = Dir["lib/**/*.rb"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mui", ">= 0.2.0"
+end
+```
+
+### Plugin File
+
+```ruby
+# lib/mui_myplugin.rb
+require "mui"
+
+class MuiMyplugin < Mui::Plugin
+  name :myplugin
+  version "1.0.0"
+
+  def setup
+    command :my_command do |ctx|
+      ctx.set_message("Hello from myplugin!")
+    end
+  end
+end
+```
+
+### Publishing
+
+```bash
+gem build mui-myplugin.gemspec
+gem push mui-myplugin-1.0.0.gem
+```
+
+Users can then install with:
+
+```ruby
+# ~/.muirc
+Mui.use "mui-myplugin"
+```

data/docs/syntax-highlighting.md

@@ -0,0 +1,155 @@
+---
+title: Syntax Highlighting
+layout: default
+nav_order: 7
+---
+
+# Syntax Highlighting
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+---
+
+## Overview
+
+Mui includes built-in syntax highlighting for 9 programming languages. Highlighting is automatic based on file extension.
+
+## Supported Languages
+
+| Language | Extensions |
+|----------|------------|
+| Ruby | `.rb`, `.rake`, `.gemspec` |
+| C | `.c`, `.h`, `.y` |
+| Go | `.go` |
+| Rust | `.rs` |
+| JavaScript | `.js`, `.mjs`, `.cjs`, `.jsx` |
+| TypeScript | `.ts`, `.tsx`, `.mts`, `.cts` |
+| Markdown | `.md`, `.markdown` |
+| HTML | `.html`, `.htm`, `.xhtml` |
+| CSS | `.css`, `.scss`, `.sass` |
+
+## Configuration
+
+### Enable/Disable
+
+```ruby
+# ~/.muirc
+Mui.set :syntax, true   # Enable (default)
+Mui.set :syntax, false  # Disable
+```
+
+## Language Features
+
+### Ruby
+
+- Keywords (`def`, `class`, `module`, `if`, `end`, etc.)
+- Strings (single, double, heredoc)
+- Comments (`#`, `=begin`/`=end`)
+- Numbers
+- Symbols (`:symbol`)
+- Constants (`CONSTANT`, `ClassName`)
+- Instance variables (`@foo`, `@@bar`)
+- Global variables (`$stdout`)
+- Method calls (`.to_s`, `.each`)
+
+### C
+
+- Keywords (`int`, `char`, `struct`, `if`, `for`, etc.)
+- Strings and character literals
+- Comments (`//`, `/* */`)
+- Numbers
+- Preprocessor directives (`#include`, `#define`)
+
+### Go
+
+- Keywords (`func`, `package`, `import`, `go`, `defer`, etc.)
+- Types (`int`, `string`, `bool`, etc.)
+- Constants (`true`, `false`, `nil`, `iota`)
+- Strings (regular and raw backtick strings)
+- Comments (`//`, `/* */`)
+
+### Rust
+
+- Keywords (`fn`, `let`, `mut`, `impl`, `trait`, etc.)
+- Macros (`println!`, `vec!`)
+- Lifetimes (`'a`, `'static`)
+- Attributes (`#[derive]`, `#[cfg]`)
+- Doc comments (`///`, `//!`)
+- Raw strings (`r#"..."#`)
+
+### JavaScript
+
+- ES6+ keywords (`const`, `let`, `async`, `await`, `class`)
+- Template literals (`` `template ${expr}` ``)
+- Regex literals (`/pattern/flags`)
+- BigInt (`123n`)
+- Strings and comments
+
+### TypeScript
+
+All JavaScript features plus:
+- Type keywords (`interface`, `type`, `enum`, `declare`, `abstract`)
+- Type annotations
+
+### Markdown
+
+- Headings (`#`, `##`, etc.)
+- Emphasis (`*italic*`, `**bold**`)
+- Code blocks (fenced and indented)
+- Links (`[text](url)`)
+- Lists (ordered and unordered)
+- Blockquotes (`>`)
+
+### HTML
+
+- Tags (`<div>`, `</div>`, `<br/>`)
+- Attributes (`class="..."`, `id="..."`)
+- Comments (`<!-- -->`)
+- DOCTYPE
+- Entities (`&amp;`, `&lt;`)
+
+### CSS
+
+- Selectors (`.class`, `#id`, `:pseudo`, `::pseudo-element`)
+- Properties and values
+- Hex colors (`#fff`, `#ffffff`)
+- At-rules (`@media`, `@import`, `@keyframes`)
+- Functions (`calc()`, `rgb()`, `var()`)
+
+## Theme Colors
+
+Syntax colors are defined per theme. All 8 built-in themes include syntax highlighting colors:
+
+- `mui` (default)
+- `solarized_dark`
+- `solarized_light`
+- `monokai`
+- `nord`
+- `gruvbox_dark`
+- `dracula`
+- `tokyo_night`
+
+Each theme defines colors for:
+
+| Element | Description |
+|---------|-------------|
+| `syntax_keyword` | Language keywords |
+| `syntax_string` | String literals |
+| `syntax_comment` | Comments |
+| `syntax_number` | Numeric literals |
+| `syntax_type` | Types and classes |
+| `syntax_function` | Function names |
+| `syntax_function_definition` | Function definition names |
+| `syntax_variable` | Variables |
+| `syntax_constant` | Constants |
+| `syntax_operator` | Operators |
+| `diagnostic_error` | LSP diagnostic errors |
+| `diagnostic_warning` | LSP diagnostic warnings |
+| `diagnostic_info` | LSP diagnostic information |
+| `diagnostic_hint` | LSP diagnostic hints |
+| `floating_window` | Floating window background |

data/lib/mui/color_manager.rb

@@ -17,8 +17,27 @@ module Mui
     # 256-color palette extended colors
     # Use https://www.ditig.com/256-colors-cheat-sheet for reference
     EXTENDED_COLOR_MAP = {
-      # mui theme
-      darkgray: 235, # #262626 (~#2b2b2b)
+      # mui theme - Eye-friendly gray-based theme
+      mui_bg: 236,             # #303030 - Calm dark gray background
+      mui_fg: 253,             # #dadada - Soft white (easy on the eyes)
+      mui_comment: 102,        # #878787 - Subtle gray (for comments)
+      mui_constant: 110,       # #87afd7 - Calm blue (constants/strings/numbers)
+      mui_identifier: 174,     # #d78787 - Soft salmon pink
+      mui_statement: 186,      # #d7d787 - Subtle yellow (keywords)
+      mui_preproc: 173,        # #d7875f - Orange/brown (preprocessor)
+      mui_type: 109,           # #87afaf - Calm cyan (types)
+      mui_special: 180,        # #d7af87 - Soft beige (symbols)
+      mui_function: 216,       # #ffaf87 - Peach/orange (functions)
+      # UI colors
+      mui_line_number: 243,    # #767676 - Subtle gray
+      mui_status_bg: 238,      # #444444 - Status bar background
+      mui_visual: 239,         # #4e4e4e - Selection background
+      mui_search: 222,         # #ffd787 - Search highlight (prominent yellow)
+      mui_tab_bg: 237,         # #3a3a3a - Tab bar background
+      mui_tab_active: 110,     # #87afd7 - Active tab
+      mui_error: 167,          # #d75f5f - Error messages
+      mui_info: 109,           # #87afaf - Info messages
+      darkgray: 235,           # #262626 (~#2b2b2b) - Kept for backward compatibility
 
       # solarized
       solarized_base03: 234,   # #1c1c1c (~#002b36)
@@ -41,6 +60,7 @@ module Mui
       # monokai
       monokai_bg: 235,         # #262626 (~#272822)
       monokai_fg: 231,         # #ffffff (~#f8f8f2)
+      monokai_comment: 101,    # #87875f (~#75715e) - Olive gray for comments
       monokai_pink: 197,       # #ff005f (~#f92672)
       monokai_green: 148,      # #afd700 (~#a6e22e)
       monokai_orange: 208,     # #ff8700 (~#fd971f)
@@ -104,18 +124,95 @@ module Mui
       tokyo_yellow: 223        # #ffd7af (~#e0af68)
     }.freeze
 
-    attr_reader :pairs
+    # Fallback map: 256-color to 8-color
+    FALLBACK_MAP = {
+      # mui theme
+      mui_bg: :black,
+      mui_fg: :white,
+      mui_comment: :white,
+      mui_constant: :cyan,
+      mui_identifier: :red,
+      mui_statement: :yellow,
+      mui_preproc: :yellow,
+      mui_type: :cyan,
+      mui_special: :yellow,
+      mui_function: :yellow,
+      mui_line_number: :white,
+      mui_status_bg: :blue,
+      mui_visual: :magenta,
+      mui_search: :yellow,
+      mui_tab_bg: :blue,
+      mui_tab_active: :cyan,
+      mui_error: :red,
+      mui_info: :cyan,
+      darkgray: :black,
+      # solarized
+      solarized_base03: :black, solarized_base02: :black,
+      solarized_base01: :white, solarized_base00: :white,
+      solarized_base0: :white, solarized_base1: :white,
+      solarized_base2: :white, solarized_base3: :white,
+      solarized_yellow: :yellow, solarized_orange: :red,
+      solarized_red: :red, solarized_magenta: :magenta,
+      solarized_violet: :blue, solarized_blue: :blue,
+      solarized_cyan: :cyan, solarized_green: :green,
+      # monokai
+      monokai_bg: :black, monokai_fg: :white, monokai_comment: :white,
+      monokai_pink: :magenta, monokai_green: :green,
+      monokai_orange: :yellow, monokai_purple: :magenta,
+      monokai_cyan: :cyan, monokai_yellow: :yellow,
+      # nord
+      nord_polar0: :black, nord_polar1: :black,
+      nord_polar2: :black, nord_polar3: :white,
+      nord_snow0: :white, nord_snow1: :white, nord_snow2: :white,
+      nord_frost0: :cyan, nord_frost1: :cyan,
+      nord_frost2: :blue, nord_frost3: :blue,
+      nord_aurora_red: :red, nord_aurora_orange: :yellow,
+      nord_aurora_yellow: :yellow, nord_aurora_green: :green,
+      nord_aurora_purple: :magenta,
+      # gruvbox
+      gruvbox_bg: :black, gruvbox_fg: :white,
+      gruvbox_red: :red, gruvbox_green: :green,
+      gruvbox_yellow: :yellow, gruvbox_blue: :blue,
+      gruvbox_purple: :magenta, gruvbox_aqua: :cyan,
+      gruvbox_orange: :yellow, gruvbox_gray: :white,
+      # dracula
+      dracula_bg: :black, dracula_fg: :white,
+      dracula_selection: :black, dracula_comment: :blue,
+      dracula_cyan: :cyan, dracula_green: :green,
+      dracula_orange: :yellow, dracula_pink: :magenta,
+      dracula_purple: :magenta, dracula_red: :red,
+      dracula_yellow: :yellow,
+      # tokyo night
+      tokyo_bg: :black, tokyo_fg: :white,
+      tokyo_comment: :blue, tokyo_cyan: :cyan,
+      tokyo_blue: :blue, tokyo_purple: :magenta,
+      tokyo_green: :green, tokyo_orange: :yellow,
+      tokyo_red: :red, tokyo_yellow: :yellow
+    }.freeze
 
-    def initialize
+    attr_reader :pairs, :supports_256_colors
+
+    def initialize(adapter: nil)
       @pair_index = 1
       @pairs = {}
+      @pair_order = []
+      @adapter = adapter
+      configure_color_capability
     end
 
     def register_pair(fg, bg)
       key = [fg, bg]
-      return @pairs[key] if @pairs[key]
+
+      if @pairs[key]
+        touch_pair(key)
+        return @pairs[key]
+      end
+
+      # Check pair limit and evict oldest if needed
+      evict_oldest_pair if @max_pairs.positive? && @pair_index >= @max_pairs
 
       @pairs[key] = @pair_index
+      @pair_order << key
       @pair_index += 1
       @pairs[key]
     end
@@ -128,9 +225,46 @@ module Mui
       return -1 if color.nil?
       return color if color.is_a?(Integer)
 
-      COLOR_MAP[color] || EXTENDED_COLOR_MAP[color] || -1
+      resolved_color = resolve_with_fallback(color)
+      COLOR_MAP[resolved_color] || EXTENDED_COLOR_MAP[resolved_color] || -1
     end
 
     alias resolve color_code
+
+    private
+
+    def configure_color_capability
+      if @adapter.nil?
+        # Backward compatibility: assume 256 colors when adapter is not specified
+        @available_colors = 256
+        @max_pairs = 256
+        @supports_256_colors = true
+      elsif @adapter.has_colors?
+        @available_colors = @adapter.colors
+        @max_pairs = [@adapter.color_pairs, 256].min
+        @supports_256_colors = @available_colors >= 256
+      else
+        @available_colors = 0
+        @max_pairs = 0
+        @supports_256_colors = false
+      end
+    end
+
+    def resolve_with_fallback(color)
+      return color if @supports_256_colors
+      return color if COLOR_MAP.key?(color)
+
+      FALLBACK_MAP[color] || :white
+    end
+
+    def touch_pair(key)
+      @pair_order.delete(key)
+      @pair_order << key
+    end
+
+    def evict_oldest_pair
+      oldest_key = @pair_order.shift
+      @pairs.delete(oldest_key) if oldest_key
+    end
   end
 end

data/lib/mui/color_scheme.rb

@@ -27,6 +27,7 @@ module Mui
       syntax_instance_variable
       syntax_global_variable
       syntax_method_call
+      syntax_function_definition
       syntax_type
       diff_add
       diff_delete

data/lib/mui/command_completer.rb

@@ -13,9 +13,18 @@ module Mui
     ].freeze
 
     def complete(prefix)
-      return COMMANDS.sort if prefix.empty?
+      all_commands = COMMANDS + plugin_command_names
 
-      COMMANDS.select { |cmd| cmd.start_with?(prefix) }.sort
+      return all_commands.uniq.sort if prefix.empty?
+
+      prefix_downcase = prefix.downcase
+      all_commands.select { |cmd| cmd.downcase.start_with?(prefix_downcase) }.uniq.sort
+    end
+
+    private
+
+    def plugin_command_names
+      Mui.config.commands.keys.map(&:to_s)
     end
   end
 end