feat(packages): add Lua package system with which-key, doom-modeline, and more

Add a new lua/packages directory with several Emacs-inspired Lua packages:

- which-key: Display available keybindings when a prefix key is pressed
  - Commands: which-key, describe-key (C-h k)
  - Shows hints for prefix keys like C-x, C-h, etc.

- doom-modeline: Doom Emacs-style modeline customization
  - Face presets: doom_one, nord, dracula, gruvbox, solarized
  - Commands: doom-modeline-preset, doom-modeline-setup

- smartparens: Auto-pairing of brackets, quotes, and delimiters
  - Auto-insert matching pairs
  - Skip closing delimiter when already present
  - Delete pairs together on backspace

- rainbow-delimiters: Colorize nested delimiters by depth
  - Multiple color presets: default, pastel, neon, nord, dracula
  - Commands: rainbow-delimiters-mode, rainbow-preset

- ido: Enhanced fuzzy completion utilities
  - Fuzzy matching with scoring
  - Commands: ido-switch-buffer, ido-execute-command

Also exposes keybinding API to Lua:
- editor:get_all_bindings() - Get all registered keybindings
- editor:is_building_sequence() - Check if in multi-key sequence
- editor:current_sequence() - Get current sequence string
- editor:has_prefix_bindings() - Check for prefix bindings

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

init.lua

@@ -36,6 +36,25 @@ dofile("lua/themes/ayu-dark.lua")
 -- Load theme switching functions and keybindings
 dofile("lua/themes/themes_init.lua")
 
+-- ============================================================================
+-- LOAD PACKAGES
+-- ============================================================================
+
+-- which-key: Display available keybindings for prefix keys
+dofile("lua/packages/which-key.lua")
+
+-- doom-modeline: Doom Emacs-style modeline customization
+dofile("lua/packages/doom-modeline.lua")
+
+-- smartparens: Auto-pairing of brackets, quotes, etc.
+dofile("lua/packages/smartparens.lua")
+
+-- rainbow-delimiters: Colorize nested delimiters by depth
+dofile("lua/packages/rainbow-delimiters.lua")
+
+-- ido: Enhanced fuzzy completion (optional, provides utilities)
+dofile("lua/packages/ido.lua")
+
 -- ============================================================================
 -- MINOR MODES (User-defined extensions)
 -- ============================================================================

lua/packages/doom-modeline.lua

@@ -0,0 +1,350 @@
+-- doom-modeline.lua
+-- ============================================================================
+-- Doom Emacs-inspired modeline styling and configuration.
+-- Provides enhanced visual styling for the modeline.
+-- ============================================================================
+
+local doom_modeline = {}
+
+-- Configuration options
+doom_modeline.config = {
+    height = 1,                  -- Number of lines (currently fixed to 1)
+    bar_width = 4,               -- Width of the colored bar indicator
+    icon_type = "unicode",       -- "unicode" or "ascii" (unicode uses special chars)
+    show_major_mode_icon = true, -- Show icon for major mode
+    show_buffer_encoding = false, -- Show buffer encoding
+    show_word_count = false,     -- Show word count for text modes
+}
+
+-- Unicode icons for various states (fallback to ASCII if not supported)
+doom_modeline.icons = {
+    modified = "●",      -- Buffer modified
+    readonly = "",      -- Read-only
+    saved = "✓",         -- Just saved
+    lock = "🔒",         -- Locked
+
+    -- Major mode icons
+    lua = "☾",
+    python = "🐍",
+    c = "C",
+    cpp = "C++",
+    javascript = "JS",
+    typescript = "TS",
+    rust = "🦀",
+    go = "Go",
+    fundamental = "F",
+
+    -- Status indicators
+    error = "✗",
+    warning = "⚠",
+    info = "ℹ",
+
+    -- Git icons (for future use)
+    git_branch = "",
+    git_added = "+",
+    git_modified = "~",
+    git_removed = "-",
+}
+
+-- ASCII fallbacks
+doom_modeline.icons_ascii = {
+    modified = "*",
+    readonly = "%%",
+    saved = "-",
+    lock = "#",
+
+    lua = "Lua",
+    python = "Py",
+    c = "C",
+    cpp = "C++",
+    javascript = "JS",
+    typescript = "TS",
+    rust = "Rs",
+    go = "Go",
+    fundamental = "F",
+
+    error = "!",
+    warning = "?",
+    info = "i",
+
+    git_branch = "@",
+    git_added = "+",
+    git_modified = "~",
+    git_removed = "-",
+}
+
+-- Get icon based on configuration
+function doom_modeline.get_icon(name)
+    if doom_modeline.config.icon_type == "ascii" then
+        return doom_modeline.icons_ascii[name] or name
+    end
+    return doom_modeline.icons[name] or doom_modeline.icons_ascii[name] or name
+end
+
+-- Define doom-modeline faces
+function doom_modeline.setup_faces()
+    -- Main modeline face (active window)
+    lumacs.set_face("doom-modeline", {
+        foreground = "#bbc2cf",
+        background = "#21242b",
+    })
+
+    -- Inactive modeline
+    lumacs.set_face("doom-modeline-inactive", {
+        foreground = "#5B6268",
+        background = "#1c1f24",
+    })
+
+    -- Buffer name (emphasized)
+    lumacs.set_face("doom-modeline-buffer-file", {
+        foreground = "#51afef",
+        weight = "bold",
+    })
+
+    -- Modified indicator
+    lumacs.set_face("doom-modeline-buffer-modified", {
+        foreground = "#da8548",
+        weight = "bold",
+    })
+
+    -- Major mode
+    lumacs.set_face("doom-modeline-buffer-major-mode", {
+        foreground = "#51afef",
+        weight = "bold",
+    })
+
+    -- Minor modes
+    lumacs.set_face("doom-modeline-buffer-minor-mode", {
+        foreground = "#98be65",
+    })
+
+    -- Position info
+    lumacs.set_face("doom-modeline-buffer-position", {
+        foreground = "#bbc2cf",
+    })
+
+    -- Error indicator (for flycheck-like features)
+    lumacs.set_face("doom-modeline-error", {
+        foreground = "#ff6c6b",
+        weight = "bold",
+    })
+
+    -- Warning indicator
+    lumacs.set_face("doom-modeline-warning", {
+        foreground = "#ECBE7B",
+        weight = "bold",
+    })
+
+    -- Info indicator
+    lumacs.set_face("doom-modeline-info", {
+        foreground = "#98be65",
+    })
+
+    -- Project/workspace
+    lumacs.set_face("doom-modeline-project", {
+        foreground = "#c678dd",
+        weight = "bold",
+    })
+
+    -- Bar segment (the colored vertical bar)
+    lumacs.set_face("doom-modeline-bar", {
+        background = "#51afef",
+    })
+
+    lumacs.set_face("doom-modeline-bar-inactive", {
+        background = "#3f444a",
+    })
+
+    -- Evil/modal state faces (for future modal editing support)
+    lumacs.set_face("doom-modeline-evil-normal", {
+        foreground = "#21242b",
+        background = "#51afef",
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-evil-insert", {
+        foreground = "#21242b",
+        background = "#98be65",
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-evil-visual", {
+        foreground = "#21242b",
+        background = "#c678dd",
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-evil-emacs", {
+        foreground = "#21242b",
+        background = "#c678dd",
+        weight = "bold",
+    })
+end
+
+-- Apply doom-modeline styling to standard modeline faces
+function doom_modeline.apply_theme()
+    -- Apply doom styling to the standard mode-line faces
+    lumacs.set_face("mode-line", {
+        foreground = "#bbc2cf",
+        background = "#21242b",
+    })
+
+    lumacs.set_face("mode-line-inactive", {
+        foreground = "#5B6268",
+        background = "#1c1f24",
+    })
+
+    lumacs.set_face("mode-line-buffer-id", {
+        foreground = "#51afef",
+        weight = "bold",
+    })
+end
+
+-- Color presets that can be applied
+doom_modeline.presets = {
+    doom_one = {
+        bar = "#51afef",
+        bar_inactive = "#3f444a",
+        buffer = "#51afef",
+        modified = "#da8548",
+        mode = "#c678dd",
+        position = "#bbc2cf",
+        background = "#21242b",
+        foreground = "#bbc2cf",
+    },
+
+    nord = {
+        bar = "#88c0d0",
+        bar_inactive = "#3b4252",
+        buffer = "#88c0d0",
+        modified = "#ebcb8b",
+        mode = "#b48ead",
+        position = "#d8dee9",
+        background = "#2e3440",
+        foreground = "#d8dee9",
+    },
+
+    dracula = {
+        bar = "#bd93f9",
+        bar_inactive = "#44475a",
+        buffer = "#ff79c6",
+        modified = "#ffb86c",
+        mode = "#bd93f9",
+        position = "#f8f8f2",
+        background = "#282a36",
+        foreground = "#f8f8f2",
+    },
+
+    gruvbox = {
+        bar = "#83a598",
+        bar_inactive = "#3c3836",
+        buffer = "#83a598",
+        modified = "#fe8019",
+        mode = "#d3869b",
+        position = "#ebdbb2",
+        background = "#282828",
+        foreground = "#ebdbb2",
+    },
+
+    solarized = {
+        bar = "#268bd2",
+        bar_inactive = "#073642",
+        buffer = "#268bd2",
+        modified = "#cb4b16",
+        mode = "#6c71c4",
+        position = "#839496",
+        background = "#002b36",
+        foreground = "#839496",
+    },
+}
+
+-- Apply a preset color scheme
+function doom_modeline.set_preset(preset_name)
+    local preset = doom_modeline.presets[preset_name]
+    if not preset then
+        editor:message("Unknown preset: " .. preset_name, "warning")
+        return
+    end
+
+    lumacs.set_face("mode-line", {
+        foreground = preset.foreground,
+        background = preset.background,
+    })
+
+    lumacs.set_face("mode-line-inactive", {
+        foreground = preset.foreground,
+        background = preset.bar_inactive,
+    })
+
+    lumacs.set_face("mode-line-buffer-id", {
+        foreground = preset.buffer,
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-buffer-modified", {
+        foreground = preset.modified,
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-buffer-major-mode", {
+        foreground = preset.mode,
+        weight = "bold",
+    })
+
+    lumacs.set_face("doom-modeline-buffer-position", {
+        foreground = preset.position,
+    })
+
+    lumacs.set_face("doom-modeline-bar", {
+        background = preset.bar,
+    })
+
+    lumacs.set_face("doom-modeline-bar-inactive", {
+        background = preset.bar_inactive,
+    })
+
+    editor:message("Applied doom-modeline preset: " .. preset_name)
+end
+
+-- Register commands
+editor:register_command("doom-modeline-preset", "Set doom-modeline color preset", function(args)
+    if #args == 0 then
+        local presets = {}
+        for name, _ in pairs(doom_modeline.presets) do
+            table.insert(presets, name)
+        end
+        table.sort(presets)
+        return {success = false, message = "Available presets: " .. table.concat(presets, ", ")}
+    end
+
+    doom_modeline.set_preset(args[1])
+    return {success = true}
+end, {"dm-preset"}, true, "s")
+
+-- Setup command to apply all doom-modeline styling
+editor:register_command("doom-modeline-setup", "Enable doom-modeline styling", function(args)
+    doom_modeline.setup_faces()
+    doom_modeline.apply_theme()
+    editor:message("Doom modeline styling applied")
+    return {success = true}
+end, {"dm-setup"})
+
+-- Toggle ASCII/Unicode mode
+editor:register_command("doom-modeline-icons", "Toggle doom-modeline icon style", function(args)
+    if #args > 0 then
+        doom_modeline.config.icon_type = args[1]
+    else
+        if doom_modeline.config.icon_type == "unicode" then
+            doom_modeline.config.icon_type = "ascii"
+        else
+            doom_modeline.config.icon_type = "unicode"
+        end
+    end
+    editor:message("Icon type: " .. doom_modeline.config.icon_type)
+    return {success = true}
+end, {"dm-icons"}, true, "s")
+
+-- Store in lumacs namespace
+lumacs.doom_modeline = doom_modeline
+
+return doom_modeline

lua/packages/ido.lua

@@ -0,0 +1,254 @@
+-- ido.lua
+-- ============================================================================
+-- Interactive Do - Enhanced completion with fuzzy matching and inline display.
+-- Similar to Emacs ido-mode.
+-- ============================================================================
+
+local ido = {}
+
+-- Configuration
+ido.config = {
+    enabled = true,
+    separator = " | ",
+    max_candidates = 10,
+    show_count = true,
+    fuzzy = true,
+    case_sensitive = false,
+    -- Display format: "inline" shows in minibuffer, "vertical" would need popup
+    display = "inline",
+}
+
+-- State
+ido.active = false
+ido.candidates = {}
+ido.filtered = {}
+ido.selected_index = 1
+ido.input = ""
+
+-- Fuzzy match score function
+-- Returns score (higher is better) or nil for no match
+function ido.fuzzy_match(pattern, candidate)
+    if pattern == "" then
+        return 1000  -- Empty pattern matches everything
+    end
+
+    local p = ido.config.case_sensitive and pattern or pattern:lower()
+    local c = ido.config.case_sensitive and candidate or candidate:lower()
+
+    -- Exact match is best
+    if c == p then
+        return 10000
+    end
+
+    -- Prefix match is very good
+    if c:sub(1, #p) == p then
+        return 5000 + (1000 / #c)
+    end
+
+    -- Substring match
+    local substr_pos = c:find(p, 1, true)
+    if substr_pos then
+        return 3000 - substr_pos + (1000 / #c)
+    end
+
+    -- Fuzzy match: all chars in pattern appear in order in candidate
+    if ido.config.fuzzy then
+        local score = 0
+        local j = 1
+        local consecutive = 0
+        local last_match = -1
+
+        for i = 1, #p do
+            local char = p:sub(i, i)
+            local found = false
+
+            while j <= #c do
+                if c:sub(j, j) == char then
+                    found = true
+                    -- Bonus for consecutive matches
+                    if j == last_match + 1 then
+                        consecutive = consecutive + 1
+                        score = score + consecutive * 10
+                    else
+                        consecutive = 0
+                    end
+                    -- Bonus for matching at word boundaries
+                    if j == 1 or c:sub(j-1, j-1):match("[%s_%-/\\.]") then
+                        score = score + 50
+                    end
+                    last_match = j
+                    j = j + 1
+                    break
+                end
+                j = j + 1
+            end
+
+            if not found then
+                return nil  -- No match
+            end
+        end
+
+        -- Penalty for length difference
+        score = score + 1000 - (#c - #p) * 5
+        return math.max(1, score)
+    end
+
+    return nil
+end
+
+-- Filter and sort candidates based on input
+function ido.filter_candidates(input)
+    local results = {}
+
+    for _, candidate in ipairs(ido.candidates) do
+        local text = type(candidate) == "table" and candidate.text or candidate
+        local score = ido.fuzzy_match(input, text)
+        if score then
+            table.insert(results, {
+                candidate = candidate,
+                text = text,
+                score = score
+            })
+        end
+    end
+
+    -- Sort by score (descending)
+    table.sort(results, function(a, b)
+        return a.score > b.score
+    end)
+
+    -- Extract candidates
+    ido.filtered = {}
+    for i, r in ipairs(results) do
+        if i > ido.config.max_candidates * 2 then break end
+        table.insert(ido.filtered, r.candidate)
+    end
+
+    return ido.filtered
+end
+
+-- Format candidates for display in minibuffer
+function ido.format_display(input)
+    local parts = {}
+
+    -- Show input
+    if input ~= "" then
+        table.insert(parts, input)
+    end
+
+    -- Show candidates
+    local shown = 0
+    for i, candidate in ipairs(ido.filtered) do
+        if shown >= ido.config.max_candidates then
+            if #ido.filtered > ido.config.max_candidates then
+                table.insert(parts, "...")
+            end
+            break
+        end
+
+        local text = type(candidate) == "table" and candidate.text or candidate
+        if i == ido.selected_index then
+            text = "[" .. text .. "]"
+        end
+        table.insert(parts, text)
+        shown = shown + 1
+    end
+
+    -- Add count if enabled
+    if ido.config.show_count and #ido.filtered > ido.config.max_candidates then
+        table.insert(parts, "(" .. #ido.filtered .. " total)")
+    end
+
+    return table.concat(parts, ido.config.separator)
+end
+
+-- Select next candidate
+function ido.next()
+    if #ido.filtered > 0 then
+        ido.selected_index = (ido.selected_index % #ido.filtered) + 1
+    end
+end
+
+-- Select previous candidate
+function ido.prev()
+    if #ido.filtered > 0 then
+        ido.selected_index = ((ido.selected_index - 2) % #ido.filtered) + 1
+    end
+end
+
+-- Get selected candidate
+function ido.get_selected()
+    if ido.selected_index <= #ido.filtered then
+        return ido.filtered[ido.selected_index]
+    end
+    return nil
+end
+
+-- Complete buffer names with ido
+function ido.complete_buffer()
+    local buf_names = editor:get_buffer_names()
+    ido.candidates = buf_names
+    ido.filtered = ido.filter_candidates("")
+    ido.selected_index = 1
+
+    local display = ido.format_display("")
+    editor:message("Switch to buffer: " .. display)
+end
+
+-- Complete commands with ido
+function ido.complete_command()
+    local cmd_names = get_command_names()
+    ido.candidates = cmd_names
+    ido.filtered = ido.filter_candidates("")
+    ido.selected_index = 1
+
+    local display = ido.format_display("")
+    editor:message("M-x " .. display)
+end
+
+-- Register commands
+editor:register_command("ido-switch-buffer", "Switch buffer with ido completion", function(args)
+    ido.complete_buffer()
+    return {success = true}
+end)
+
+editor:register_command("ido-execute-command", "Execute command with ido completion", function(args)
+    ido.complete_command()
+    return {success = true}
+end)
+
+editor:register_command("ido-mode", "Toggle ido-mode for enhanced completion", function(args)
+    ido.config.enabled = not ido.config.enabled
+    if ido.config.enabled then
+        editor:message("ido-mode enabled")
+    else
+        editor:message("ido-mode disabled")
+    end
+    return {success = true}
+end)
+
+editor:register_command("ido-toggle-fuzzy", "Toggle fuzzy matching in ido", function(args)
+    ido.config.fuzzy = not ido.config.fuzzy
+    editor:message("Fuzzy matching: " .. (ido.config.fuzzy and "on" or "off"))
+    return {success = true}
+end)
+
+-- Utility: simple buffer selection demo
+editor:register_command("ido-demo", "Demonstrate ido buffer selection", function(args)
+    local buf_names = editor:get_buffer_names()
+    ido.candidates = buf_names
+    local results = ido.filter_candidates(args[1] or "")
+    ido.selected_index = 1
+
+    if #results > 0 then
+        local display = ido.format_display(args[1] or "")
+        return {success = true, message = display}
+    else
+        return {success = false, message = "No matching buffers"}
+    end
+end, {}, true, "s")
+
+-- Store in lumacs namespace
+lumacs.ido = ido
+
+return ido

lua/packages/rainbow-delimiters.lua

@@ -0,0 +1,248 @@
+-- rainbow-delimiters.lua
+-- ============================================================================
+-- Colorize nested delimiters (parentheses, brackets, braces) with different
+-- colors based on nesting depth. Similar to Emacs rainbow-delimiters.
+-- ============================================================================
+
+local rainbow = {}
+
+-- Configuration
+rainbow.config = {
+    enabled = true,
+    max_depth = 9,  -- Number of colors to cycle through
+    delimiters = {
+        ["("] = ")",
+        ["["] = "]",
+        ["{"] = "}",
+    },
+}
+
+-- Default rainbow colors (can be customized per theme)
+rainbow.colors = {
+    "#ff6b6b",  -- Red
+    "#ffa94d",  -- Orange
+    "#ffd43b",  -- Yellow
+    "#69db7c",  -- Green
+    "#38d9a9",  -- Teal
+    "#4dabf7",  -- Blue
+    "#748ffc",  -- Indigo
+    "#da77f2",  -- Violet
+    "#f783ac",  -- Pink
+}
+
+-- Alternative color schemes
+rainbow.presets = {
+    default = {
+        "#ff6b6b", "#ffa94d", "#ffd43b", "#69db7c",
+        "#38d9a9", "#4dabf7", "#748ffc", "#da77f2", "#f783ac",
+    },
+    pastel = {
+        "#ffb3ba", "#ffdfba", "#ffffba", "#baffc9",
+        "#bae1ff", "#d4baff", "#ffbae1", "#baffff", "#e1ffba",
+    },
+    neon = {
+        "#ff0080", "#ff8000", "#ffff00", "#00ff00",
+        "#00ffff", "#0080ff", "#8000ff", "#ff00ff", "#ff0040",
+    },
+    monochrome = {
+        "#ffffff", "#e0e0e0", "#c0c0c0", "#a0a0a0",
+        "#808080", "#606060", "#404040", "#303030", "#202020",
+    },
+    nord = {
+        "#bf616a", "#d08770", "#ebcb8b", "#a3be8c",
+        "#88c0d0", "#81a1c1", "#5e81ac", "#b48ead", "#bf616a",
+    },
+    dracula = {
+        "#ff5555", "#ffb86c", "#f1fa8c", "#50fa7b",
+        "#8be9fd", "#bd93f9", "#ff79c6", "#6272a4", "#ff5555",
+    },
+}
+
+-- State
+rainbow.active = true
+
+-- Setup faces for each depth level
+function rainbow.setup_faces()
+    for i, color in ipairs(rainbow.colors) do
+        local face_name = "rainbow-delimiters-depth-" .. i
+        -- Use lumacs.face helper which handles hex conversion
+        local attrs = lumacs.face({
+            foreground = color,
+            weight = "bold",
+        })
+        if editor.theme_manager then
+            local theme = editor.theme_manager:active_theme()
+            if theme then
+                theme:set_face(face_name, attrs)
+            end
+        end
+    end
+end
+
+-- Get face name for a given depth
+function rainbow.get_face(depth)
+    local idx = ((depth - 1) % #rainbow.colors) + 1
+    return "rainbow-delimiters-depth-" .. idx
+end
+
+-- Check if char is an opener
+function rainbow.is_opener(char)
+    return rainbow.config.delimiters[char] ~= nil
+end
+
+-- Check if char is a closer
+function rainbow.is_closer(char)
+    for opener, closer in pairs(rainbow.config.delimiters) do
+        if closer == char then
+            return true, opener
+        end
+    end
+    return false, nil
+end
+
+-- Highlight delimiters in the current buffer
+function rainbow.highlight_buffer()
+    if not rainbow.active or not rainbow.config.enabled then
+        return
+    end
+
+    local buf = editor.buffer
+    local line_count = buf:line_count()
+    local depth = 0
+    local delimiter_positions = {}
+
+    -- First pass: find all delimiters and calculate their depths
+    for line_num = 0, line_count - 1 do
+        local line = buf:line(line_num)
+        local in_string = false
+        local string_char = nil
+        local escaped = false
+
+        for col = 0, #line - 1 do
+            local char = line:sub(col + 1, col + 1)
+
+            -- Handle escape sequences
+            if escaped then
+                escaped = false
+            elseif char == "\\" then
+                escaped = true
+            -- Handle strings
+            elseif not in_string and (char == '"' or char == "'") then
+                in_string = true
+                string_char = char
+            elseif in_string and char == string_char then
+                in_string = false
+                string_char = nil
+            -- Handle delimiters (outside strings)
+            elseif not in_string then
+                if rainbow.is_opener(char) then
+                    depth = depth + 1
+                    table.insert(delimiter_positions, {
+                        line = line_num,
+                        col = col,
+                        depth = depth,
+                        char = char,
+                    })
+                elseif rainbow.is_closer(char) then
+                    table.insert(delimiter_positions, {
+                        line = line_num,
+                        col = col,
+                        depth = depth,
+                        char = char,
+                    })
+                    depth = math.max(0, depth - 1)
+                end
+            end
+        end
+    end
+
+    -- Second pass: apply styles
+    for _, pos in ipairs(delimiter_positions) do
+        local face = rainbow.get_face(pos.depth)
+        local range = lumacs.Range(
+            lumacs.Position(pos.line, pos.col),
+            lumacs.Position(pos.line, pos.col + 1)
+        )
+        local attr = lumacs.TextAttribute(face)
+        buf:set_style(range, attr)
+    end
+end
+
+-- Toggle rainbow delimiters
+function rainbow.toggle()
+    rainbow.active = not rainbow.active
+    if rainbow.active then
+        rainbow.highlight_buffer()
+        editor:message("Rainbow delimiters enabled")
+    else
+        -- Clear rainbow styles
+        editor.buffer:clear_styles()
+        editor:message("Rainbow delimiters disabled")
+    end
+end
+
+-- Set color preset
+function rainbow.set_preset(name)
+    local preset = rainbow.presets[name]
+    if not preset then
+        editor:message("Unknown preset: " .. name, "warning")
+        return
+    end
+
+    rainbow.colors = preset
+    rainbow.setup_faces()
+    if rainbow.active then
+        rainbow.highlight_buffer()
+    end
+    editor:message("Rainbow preset: " .. name)
+end
+
+-- Register commands
+editor:register_command("rainbow-delimiters-mode", "Toggle rainbow delimiter coloring", function(args)
+    rainbow.toggle()
+    return {success = true}
+end, {"rainbow"})
+
+editor:register_command("rainbow-preset", "Set rainbow delimiter color preset", function(args)
+    if #args == 0 then
+        local presets = {}
+        for name, _ in pairs(rainbow.presets) do
+            table.insert(presets, name)
+        end
+        table.sort(presets)
+        return {success = false, message = "Available presets: " .. table.concat(presets, ", ")}
+    end
+
+    rainbow.set_preset(args[1])
+    return {success = true}
+end, {}, true, "s")
+
+editor:register_command("rainbow-highlight", "Re-apply rainbow highlighting to current buffer", function(args)
+    rainbow.highlight_buffer()
+    return {success = true, message = "Rainbow highlighting applied"}
+end)
+
+-- Define minor mode
+lumacs.define_minor_mode("rainbow-delimiters-mode", {
+    lighter = "🌈",
+    global = false,
+    setup = function()
+        rainbow.active = true
+        rainbow.setup_faces()
+        rainbow.highlight_buffer()
+        editor:message("Rainbow delimiters enabled")
+    end,
+    cleanup = function()
+        rainbow.active = false
+        editor.buffer:clear_styles()
+        editor:message("Rainbow delimiters disabled")
+    end
+})
+
+-- Initialize faces
+rainbow.setup_faces()
+
+-- Store in lumacs namespace
+lumacs.rainbow_delimiters = rainbow
+
+return rainbow

lua/packages/smartparens.lua

@@ -0,0 +1,220 @@
+-- smartparens.lua
+-- ============================================================================
+-- Automatic pairing of brackets, quotes, and other delimiters.
+-- Similar to Emacs smartparens or electric-pair-mode.
+-- ============================================================================
+
+local smartparens = {}
+
+-- Configuration
+smartparens.config = {
+    enabled = true,
+    pairs = {
+        ["("] = ")",
+        ["["] = "]",
+        ["{"] = "}",
+        ['"'] = '"',
+        ["'"] = "'",
+        ["`"] = "`",
+    },
+    -- Skip closing when next char is the same closer
+    skip_when_next = true,
+    -- Delete pair together when backspacing empty pair
+    delete_pair = true,
+    -- Wrap region with pair when mark is active
+    wrap_region = true,
+}
+
+-- State
+smartparens.active = true
+
+-- Check if char is an opener
+function smartparens.is_opener(char)
+    return smartparens.config.pairs[char] ~= nil
+end
+
+-- Check if char is a closer
+function smartparens.is_closer(char)
+    for opener, closer in pairs(smartparens.config.pairs) do
+        if closer == char and opener ~= closer then
+            return true, opener
+        end
+    end
+    return false, nil
+end
+
+-- Get closer for an opener
+function smartparens.get_closer(opener)
+    return smartparens.config.pairs[opener]
+end
+
+-- Check if we're inside a string (simple heuristic)
+function smartparens.in_string()
+    local buf = editor.buffer
+    local cursor = editor.cursor
+    local line = buf:line(cursor.line)
+    local quote_count = 0
+    local dquote_count = 0
+
+    for i = 1, cursor.column do
+        local c = line:sub(i, i)
+        if c == "'" then quote_count = quote_count + 1 end
+        if c == '"' then dquote_count = dquote_count + 1 end
+    end
+
+    return (quote_count % 2 == 1) or (dquote_count % 2 == 1)
+end
+
+-- Get char at cursor
+function smartparens.char_at_cursor()
+    local buf = editor.buffer
+    local cursor = editor.cursor
+    local line = buf:line(cursor.line)
+    if cursor.column < #line then
+        return line:sub(cursor.column + 1, cursor.column + 1)
+    end
+    return nil
+end
+
+-- Get char before cursor
+function smartparens.char_before_cursor()
+    local buf = editor.buffer
+    local cursor = editor.cursor
+    local line = buf:line(cursor.line)
+    if cursor.column > 0 then
+        return line:sub(cursor.column, cursor.column)
+    end
+    return nil
+end
+
+-- Insert pair and position cursor between them
+function smartparens.insert_pair(opener)
+    if not smartparens.active or not smartparens.config.enabled then
+        return false
+    end
+
+    local closer = smartparens.get_closer(opener)
+    if not closer then
+        return false
+    end
+
+    local buf = editor.buffer
+    local cursor = editor.cursor
+
+    -- Check if we have a region selected (for wrapping)
+    if smartparens.config.wrap_region and buf:has_mark() then
+        local region = buf:get_region(cursor)
+        if region then
+            local text = buf:get_text_in_range(region)
+            buf:erase(region)
+            buf:insert(region.start, opener .. text .. closer)
+            -- Position cursor after the wrapped text
+            editor.cursor = lumacs.Position(region.start.line, region.start.column + #text + 1)
+            buf:deactivate_mark()
+            return true
+        end
+    end
+
+    -- For symmetric pairs (quotes), check if we should skip
+    if opener == closer then
+        local next_char = smartparens.char_at_cursor()
+        if next_char == opener then
+            -- Skip instead of inserting
+            editor.cursor = lumacs.Position(cursor.line, cursor.column + 1)
+            return true
+        end
+    end
+
+    -- Insert the pair
+    buf:insert(cursor, opener .. closer)
+    -- Position cursor between the pair
+    editor.cursor = lumacs.Position(cursor.line, cursor.column + 1)
+    return true
+end
+
+-- Handle closing delimiter - skip if already there
+function smartparens.handle_closer(closer)
+    if not smartparens.active or not smartparens.config.skip_when_next then
+        return false
+    end
+
+    local next_char = smartparens.char_at_cursor()
+    if next_char == closer then
+        local cursor = editor.cursor
+        editor.cursor = lumacs.Position(cursor.line, cursor.column + 1)
+        return true
+    end
+
+    return false
+end
+
+-- Handle backspace - delete pair together if empty
+function smartparens.handle_backspace()
+    if not smartparens.active or not smartparens.config.delete_pair then
+        return false
+    end
+
+    local prev = smartparens.char_before_cursor()
+    local next = smartparens.char_at_cursor()
+
+    if prev and next then
+        local expected_closer = smartparens.get_closer(prev)
+        if expected_closer == next then
+            -- Delete both chars
+            local buf = editor.buffer
+            local cursor = editor.cursor
+            local range = lumacs.Range(
+                lumacs.Position(cursor.line, cursor.column - 1),
+                lumacs.Position(cursor.line, cursor.column + 1)
+            )
+            buf:erase(range)
+            editor.cursor = lumacs.Position(cursor.line, cursor.column - 1)
+            return true
+        end
+    end
+
+    return false
+end
+
+-- Toggle smartparens
+function smartparens.toggle()
+    smartparens.active = not smartparens.active
+    if smartparens.active then
+        editor:message("Smartparens enabled")
+    else
+        editor:message("Smartparens disabled")
+    end
+end
+
+-- Register commands
+editor:register_command("smartparens-mode", "Toggle smartparens auto-pairing", function(args)
+    smartparens.toggle()
+    return {success = true}
+end, {"sp-mode"})
+
+editor:register_command("smartparens-strict-mode", "Toggle strict pairing rules", function(args)
+    smartparens.config.skip_when_next = not smartparens.config.skip_when_next
+    smartparens.config.delete_pair = not smartparens.config.delete_pair
+    local state = smartparens.config.skip_when_next and "enabled" or "disabled"
+    editor:message("Strict mode " .. state)
+    return {success = true}
+end)
+
+-- Define minor mode
+lumacs.define_minor_mode("smartparens-mode", {
+    lighter = "()",
+    global = false,
+    setup = function()
+        smartparens.active = true
+        editor:message("Smartparens enabled")
+    end,
+    cleanup = function()
+        smartparens.active = false
+        editor:message("Smartparens disabled")
+    end
+})
+
+-- Store in lumacs namespace
+lumacs.smartparens = smartparens
+
+return smartparens

lua/packages/which-key.lua

@@ -0,0 +1,239 @@
+-- which-key.lua
+-- ============================================================================
+-- Displays available keybindings when a prefix key is pressed.
+-- Similar to Emacs which-key package.
+-- ============================================================================
+
+local which_key = {}
+
+-- Configuration
+which_key.config = {
+    delay = 0.5,           -- Delay before showing hints (not yet implemented - needs timer)
+    max_display = 10,      -- Max number of hints to show
+    separator = " | ",     -- Separator between hints
+    show_description = true, -- Show command descriptions
+}
+
+-- Parse a key sequence like "C-x C-f" into parts
+local function parse_sequence(seq)
+    local parts = {}
+    for part in seq:gmatch("%S+") do
+        table.insert(parts, part)
+    end
+    return parts
+end
+
+-- Check if sequence starts with prefix
+local function starts_with(sequence, prefix)
+    local seq_parts = parse_sequence(sequence)
+    local prefix_parts = parse_sequence(prefix)
+
+    if #seq_parts < #prefix_parts then
+        return false
+    end
+
+    for i, part in ipairs(prefix_parts) do
+        if seq_parts[i] ~= part then
+            return false
+        end
+    end
+
+    return true
+end
+
+-- Get the next key after the prefix
+local function get_next_key(sequence, prefix)
+    local seq_parts = parse_sequence(sequence)
+    local prefix_parts = parse_sequence(prefix)
+
+    if #seq_parts > #prefix_parts then
+        return seq_parts[#prefix_parts + 1]
+    end
+
+    return nil
+end
+
+-- Get all bindings that start with the given prefix
+function which_key.get_bindings_for_prefix(prefix)
+    local all_bindings = editor:get_all_bindings()
+    local matching = {}
+
+    -- Normalize prefix (remove trailing dash if present)
+    prefix = prefix:gsub("%-$", "")
+
+    for _, binding in ipairs(all_bindings) do
+        if starts_with(binding.sequence, prefix) and binding.sequence ~= prefix then
+            local next_key = get_next_key(binding.sequence, prefix)
+            if next_key then
+                -- Check if we already have this next_key
+                local found = false
+                for _, m in ipairs(matching) do
+                    if m.key == next_key then
+                        found = true
+                        break
+                    end
+                end
+
+                if not found then
+                    -- Determine if this is a prefix or a command
+                    local is_prefix = false
+                    local prefix_with_key = prefix .. " " .. next_key
+                    for _, b in ipairs(all_bindings) do
+                        if starts_with(b.sequence, prefix_with_key) and b.sequence ~= prefix_with_key then
+                            is_prefix = true
+                            break
+                        end
+                    end
+
+                    table.insert(matching, {
+                        key = next_key,
+                        command = binding.command_name,
+                        description = binding.description,
+                        full_sequence = binding.sequence,
+                        is_prefix = is_prefix,
+                    })
+                end
+            end
+        end
+    end
+
+    -- Sort by key
+    table.sort(matching, function(a, b)
+        return a.key < b.key
+    end)
+
+    return matching
+end
+
+-- Format hints for display
+function which_key.format_hints(bindings, max_width)
+    max_width = max_width or 80
+    local hints = {}
+
+    for i, binding in ipairs(bindings) do
+        if i > which_key.config.max_display then
+            table.insert(hints, "...")
+            break
+        end
+
+        local hint
+        if binding.is_prefix then
+            hint = binding.key .. ":+prefix"
+        elseif which_key.config.show_description and binding.description ~= "" then
+            hint = binding.key .. ":" .. binding.description
+        else
+            hint = binding.key .. ":" .. binding.command
+        end
+
+        table.insert(hints, hint)
+    end
+
+    -- Join with separator
+    local result = table.concat(hints, which_key.config.separator)
+
+    -- Truncate if too long
+    if #result > max_width then
+        result = result:sub(1, max_width - 3) .. "..."
+    end
+
+    return result
+end
+
+-- Show which-key hints for current prefix
+function which_key.show_hints()
+    if not editor:is_building_sequence() then
+        return
+    end
+
+    local current = editor:current_sequence()
+    -- Remove trailing dash
+    current = current:gsub("%-$", "")
+
+    local bindings = which_key.get_bindings_for_prefix(current)
+
+    if #bindings > 0 then
+        local hints = which_key.format_hints(bindings)
+        editor:message(current .. "- " .. hints)
+    end
+end
+
+-- Manually show which-key for a prefix
+function which_key.show_for_prefix(prefix)
+    local bindings = which_key.get_bindings_for_prefix(prefix)
+
+    if #bindings > 0 then
+        local hints = which_key.format_hints(bindings)
+        editor:message(prefix .. " " .. hints)
+    else
+        editor:message("No bindings for prefix: " .. prefix)
+    end
+end
+
+-- Register commands
+editor:register_command("which-key", "Show available keybindings for prefix", function(args)
+    if #args > 0 then
+        which_key.show_for_prefix(args[1])
+    elseif editor:is_building_sequence() then
+        which_key.show_hints()
+    else
+        -- Show all prefixes
+        local all_bindings = editor:get_all_bindings()
+        local prefixes = {}
+
+        for _, binding in ipairs(all_bindings) do
+            local parts = parse_sequence(binding.sequence)
+            if #parts > 1 then
+                local prefix = parts[1]
+                if not prefixes[prefix] then
+                    prefixes[prefix] = 0
+                end
+                prefixes[prefix] = prefixes[prefix] + 1
+            end
+        end
+
+        local hints = {}
+        for prefix, count in pairs(prefixes) do
+            table.insert(hints, prefix .. ":+" .. count)
+        end
+        table.sort(hints)
+
+        editor:message("Prefix keys: " .. table.concat(hints, " | "))
+    end
+    return {success = true}
+end, {"wk"}, true, "s")
+
+-- Describe key binding
+editor:register_command("describe-key", "Describe a key binding", function(args)
+    if #args == 0 then
+        return {success = false, message = "Usage: describe-key <key-sequence>"}
+    end
+
+    local key = args[1]
+    local all_bindings = editor:get_all_bindings()
+
+    for _, binding in ipairs(all_bindings) do
+        if binding.sequence == key then
+            local msg = key .. " runs " .. binding.command
+            if binding.description ~= "" then
+                msg = msg .. " (" .. binding.description .. ")"
+            end
+            return {success = true, message = msg}
+        end
+    end
+
+    -- Check if it's a prefix
+    if editor:has_prefix_bindings(key) then
+        which_key.show_for_prefix(key)
+        return {success = true}
+    end
+
+    return {success = false, message = key .. " is not bound"}
+end, {"dk"}, true, "s")
+
+-- Bind C-h k to describe-key (Emacs standard)
+editor:bind_key("C-h k", "describe-key", "Describe a key binding")
+
+-- Store module
+lumacs.which_key = which_key
+
+return which_key

src/defaults.hpp

@@ -1096,14 +1096,14 @@ function lumacs.face(opts)
     local attrs = lumacs.FaceAttributes()
     if opts.foreground then
         if type(opts.foreground) == "string" then
-            attrs.foreground = lumacs.Color.from_hex(opts.foreground)
+            attrs.foreground = Color.from_hex(opts.foreground)
         else
             attrs.foreground = opts.foreground
         end
     end
     if opts.background then
         if type(opts.background) == "string" then
-            attrs.background = lumacs.Color.from_hex(opts.background)
+            attrs.background = Color.from_hex(opts.background)
         else
             attrs.background = opts.background
         end
@@ -1152,7 +1152,7 @@ end
 
 -- Convenience function to get color from hex string
 function lumacs.hex(hex_str)
-    return lumacs.Color.from_hex(hex_str)
+    return Color.from_hex(hex_str)
 end
 
 -- =====================================================

src/lua_api.cpp

@@ -790,6 +790,30 @@ void LuaApi::register_types() {
         "is_browsing_message_history", &EditorCore::is_browsing_message_history,
         "message_history_size", &EditorCore::message_history_size,
 
+        // Key binding information
+        "get_all_bindings", [this](EditorCore& core) {
+            sol::table bindings = lua_.create_table();
+            auto all = core.keybinding_manager().get_all_bindings();
+            int idx = 1;
+            for (const auto& binding : all) {
+                sol::table b = lua_.create_table();
+                b["sequence"] = binding.sequence.to_string();
+                b["command"] = binding.command_name;
+                b["description"] = binding.description;
+                bindings[idx++] = b;
+            }
+            return bindings;
+        },
+        "is_building_sequence", [](EditorCore& core) {
+            return core.keybinding_manager().is_building_sequence();
+        },
+        "current_sequence", [](EditorCore& core) {
+            return core.keybinding_manager().current_sequence_display();
+        },
+        "has_prefix_bindings", [](EditorCore& core, const std::string& prefix) {
+            return core.keybinding_manager().has_prefix_bindings(KeySequence(prefix));
+        },
+
         // Key binding (method on EditorCore)
         "bind_key", [this](EditorCore& core, std::string key, sol::object callback_or_cmd, sol::optional<std::string> description) {
             if (callback_or_cmd.is<std::string>()) {