Lumacs/documentation/ROADMAP.md

Lumacs Roadmap - Emacs Foundation

Current Status ✅

Core Editing

• ✅ Basic text insertion/deletion
• ✅ Character and line operations
• ✅ Undo/Redo (100 levels)
• ✅ Find text

Buffer System

• ✅ Multiple buffers
• ✅ Buffer creation/loading
• ✅ File save/save-as
• ✅ Modification tracking
• ✅ Event system (BeforeChange, AfterChange, etc.)

Window Management

• ✅ Split windows (horizontal/vertical)
• ✅ Close windows
• ✅ Navigate between windows (C-w)
• ✅ Multi-window layout tree

Mode System

• ✅ Major mode framework
• ✅ Minor mode framework
• ✅ Auto-activation by file pattern
• ✅ Mode-specific keybindings
• ✅ Mode-specific syntax highlighting
• ✅ lua-mode implemented

Movement

• ✅ Arrow keys
• ✅ C-n, C-p, C-f, C-b (line/char navigation)
• ✅ C-a, C-e (beginning/end of line)
• ✅ Home/End
• ✅ M-ArrowUp/Down (line swapping)

Keybindings

• ✅ Meta key support (M-)
• ✅ Control key support (C-)
• ✅ Prefix sequences (C-x)
• ✅ Global and mode-specific bindings

Other

• ✅ Syntax highlighting
• ✅ Message system
• ✅ Minibuffer (basic)

---

Missing Core Emacs Features

HIGH PRIORITY - Essential Emacs DNA

1. Kill Ring System ⭐⭐⭐

Why: The kill ring is fundamental to Emacs' copy/paste workflow

Implementation needed:

• Kill ring data structure (circular buffer)
• C-w (kill-region) - cut selection
• M-w (kill-ring-save) - copy selection
• C-y (yank) - paste
• M-y (yank-pop) - cycle through kill ring
• C-k (kill-line) - kill from cursor to end of line
• Append kills when consecutive

C++ API needed:

class KillRing {
    std::vector<std::string> ring_;
    size_t max_size_ = 60;
    size_t yank_index_ = 0;
public:
    void push(std::string text);
    std::string yank();
    std::string yank_pop();
};

2. Mark and Region ⭐⭐⭐

Why: Emacs' selection system is mark-based, not mouse-based

Implementation needed:

• Mark position storage
• C-SPC or C-@ (set-mark-command) - set mark
• C-x C-x (exchange-point-and-mark) - swap cursor and mark
• C-x h (mark-whole-buffer) - select all
• Visual indication of active region
• Region-based operations (kill, copy, etc.)

C++ API needed:

class Buffer {
    std::optional<Position> mark_;
    bool mark_active_ = false;
public:
    void set_mark(Position pos);
    void deactivate_mark();
    std::optional<Range> get_region() const;
    bool has_active_region() const;
};

3. Buffer Management ⭐⭐⭐

Why: Need to work with multiple files efficiently

Implementation needed:

• C-x b (switch-to-buffer) - switch buffer with prompt
• C-x C-b (list-buffers) - show buffer list
• C-x k (kill-buffer) - close buffer
• Buffer name completion in minibuffer
• Show buffer list in special buffer

Lua API:

function list_buffers()
function switch_to_buffer(name)
function kill_buffer(name)

4. Advanced Movement ⭐⭐

Why: Efficient navigation is key to productivity

Implementation needed:

• M-f (forward-word) - move forward by word
• M-b (backward-word) - move backward by word
• C-v (scroll-up) - page down
• M-v (scroll-down) - page up
• M-< (beginning-of-buffer) - go to start
• M-> (end-of-buffer) - go to end
• M-g M-g or M-g g (goto-line) - jump to line number

C++ API needed:

void move_forward_word();
void move_backward_word();
void page_up();
void page_down();
void goto_beginning();
void goto_end();
void goto_line(size_t line);

5. Incremental Search ⭐⭐

Why: The Emacs way of searching

Implementation needed:

• C-s (isearch-forward) - incremental search
• C-r (isearch-backward) - reverse incremental search
• Show search matches highlighted
• C-s again to find next
• C-g to cancel search
• Search history

Mode: Requires a search mode/state

MEDIUM PRIORITY - Greatly Enhance Usability

6. Word Operations ⭐⭐

• M-d (kill-word) - delete word forward
• M-DEL (backward-kill-word) - delete word backward
• M-t (transpose-words) - swap words
• C-t (transpose-chars) - swap characters

7. Case Conversion ⭐⭐

• M-u (upcase-word) - uppercase word
• M-l (downcase-word) - lowercase word
• M-c (capitalize-word) - capitalize word
• C-x C-u (upcase-region) - uppercase selection
• C-x C-l (downcase-region) - lowercase selection

8. Comment/Uncomment ⭐⭐

• M-; (comment-dwim) - comment or uncomment region
• Should use mode's comment syntax

9. Auto-Indentation ⭐⭐

• TAB - indent current line
• C-j (newline-and-indent) - insert newline and indent
• Mode-specific indentation rules

10. Better Minibuffer ⭐

• Completion support
• History (M-p, M-n)
• Better prompting system
• Tab completion

LOWER PRIORITY - Nice to Have

11. Fill/Wrap Text

• M-q (fill-paragraph) - reflow text to column width
• Auto-fill mode

12. Registers

• C-x r s (copy-to-register)
• C-x r i (insert-register)
• Named storage slots

13. Rectangle Operations

• C-x r k (kill-rectangle)
• C-x r y (yank-rectangle)
• C-x r t (string-rectangle)

14. Macros

• C-x ( (start-kbd-macro)
• C-x ) (end-kbd-macro)
• C-x e (call-last-kbd-macro)

15. Point Mark Ring

• C-u C-SPC - jump to previous mark
• Mark ring for navigation history

16. Dired (Directory Editor)

• Browse directories
• File operations in a buffer

---

Implementation Strategy

Phase 1: Core Emacs Feel (2-3 days)

Focus on making the editor feel like Emacs:

1. Kill ring system (C-w, M-w, C-y, C-k)
2. Mark and region (C-SPC, C-x C-x)
3. Basic word movement (M-f, M-b)
4. Page scrolling (C-v, M-v)

Phase 2: Buffer Management (1-2 days)

Make working with multiple files practical:

1. Buffer switching (C-x b)
2. Buffer list (C-x C-b)
3. Kill buffer (C-x k)

Phase 3: Enhanced Editing (2-3 days)

Add the editing commands power users expect:

1. Word operations (M-d, M-DEL)
2. Case conversion (M-u, M-l, M-c)
3. Incremental search (C-s, C-r)
4. Comment toggle (M-;)

Phase 4: Polish (1-2 days)

Refinements and quality of life:

1. Better minibuffer with completion
2. Auto-indentation
3. More modes (python-mode, etc.)

---

Architecture Improvements Needed

1. Kill Ring (C++ Core)

Add to EditorCore:

class KillRing;
std::unique_ptr<KillRing> kill_ring_;

2. Mark Support (C++ Core)

Add to Buffer:

std::optional<Position> mark_;
bool mark_active_;

3. Buffer List (C++ Core)

Already have std::list<std::shared_ptr<Buffer>> buffers_ but need:

• Buffer switching API
• Buffer naming/identification
• Active buffer tracking per window

4. Search State (C++ Core)

Add search state machine for incremental search

5. Word Navigation (C++ Core)

Add word boundary detection to Buffer:

Position find_word_boundary_forward(Position pos);
Position find_word_boundary_backward(Position pos);

---

Quick Wins (Can implement today)

1. C-k (kill-line) - Just delete from cursor to end of line
2. M-<, M-> - Jump to start/end of buffer (trivial)
3. C-x h - Select all (set mark to 0, cursor to end)
4. M-g g - Goto line (already have goto_line helper)
5. Better movement - C-v/M-v page scrolling

---

Measuring Progress

Emacs Compatibility Score:

• ✅ Current: ~30/100
• 🎯 After Phase 1: ~55/100
• 🎯 After Phase 2: ~70/100
• 🎯 After Phase 3: ~85/100
• 🎯 After Phase 4: ~95/100

The goal is not 100% compatibility, but capturing the essential Emacs workflow and feeling.