Kisa project roadmap

1. DONE Stage 1: Prototype [100%]
2. TODO Stage 2: Basic working program [14%]
3. TODO Stage 3: Polished working program [0%]
4. TODO Stage 4: Experimental convenience functionality [0%]
5. TODO Stage 5: Refined convenience functionality [0%]
- 5.1. TODO Decide on the features
6. TODO Stage 6: Final release

1 DONE Stage 1: Prototype `[100%]`

1.1 DONE Handle keyboard keys

1.2 DONE Draw on the terminal

1.3 DONE Read file for displaying

2 TODO Stage 2: Basic working program `[14%]`

This stage should result in a basic working editor with some experimental features. It should provide answers to fundamental design decisions which should be taken further.

2.1 TODO Write design documents `[8/10]`

[X] Client architecture
[X] Server architecture
[X] Configuration
[X] Cursor
[ ] Extensions
[X] Highlighting
[X] Keybindings
[X] Search
[X] Windowing
[ ] User interface

2.2 TODO Client-Server communication `[3/5]`

2.2.1 DONE Write RPC implementation `[2/2]`

[X] Write JSON-RPC 2.0 implementation
[X] Wrap it into program-specific interface

2.2.2 DONE Write polling with file descriptors

2.2.3 TODO Server-side loop `[2/3]`

[X] Accept new clients
[X] Process client requests
[ ] Send push notifications to clients

2.2.4 TODO Client-side loop `[1/3]`

[X] Send key presses
[ ] Send commands
[ ] Process push notifications from the server

2.2.5 DONE Error handling

2.3 TODO Terminal user interface `[0/6]`

2.3.1 TODO Draw on the screen

2.3.2 TODO Read keys from the keyboard

2.3.3 TODO Accumulate number multiplier

Pressing numbers should create a multiplier for the next command, normally the number of times this command should be repeated.

2.3.4 TODO Draw beautiful UI boxes

2.3.5 TODO Enter command mode

Prompt should appear where the user can type commands

2.3.6 TODO Draw cursor and selections

2.4 TODO Windowing `[0/4]`

[ ] Evenly spaced horizontal layout
[ ] Evenly spaced vertical layout
[ ] Splits layout
[ ] Stack layout

2.5 TODO State management `[1/2]`

[X] Managing resources
[ ] Layout of multiple splits

2.6 TODO Text buffer `[0/2]`

2.6.1 TODO Prototype `[3/9]`

Implementation as a simple contiguous growing array. Mainly it is needed to understand the interface and get some idea about the kind of processing that is necessary for common operations on the text buffer.

[-] Move the cursor
- [X] Left, right
- [X] Up, down
- [X] Start of the line, end of the line
- [X] To the first non-empty character of the line
- [X] Start, end of buffer
- [X] Next, previous word
[ ] Select
- [ ] Surrounding inner object
- [ ] Surrounding object with borders
- [ ] Line, word, letters
[X] Insert/remove characters
[ ] Multiple cursors proof-of-concept
[ ] Search exact
[ ] Search regex
[X] Open file
[X] Open scratch buffer
[ ] Some functionality like code folding or filtering the buffer to only contain certain lines will make lines not consecutive.

2.6.2 TODO Main implementation

Decide on main implementation and write it. This decision is not final but still seems necessary for a basic working program.

[ ] Array of bytes
[ ] Piece table
[ ] Array of lines
[ ] Gap buffer
[ ] Rope

2.7 TODO Configuration processing `[1/3]`

2.7.1 DONE Decide on file format - zzz - still not the final decision

2.7.2 TODO Correction on file format

2.7.3 TODO Read configuration `[1/3]`

[X] Read key map
[ ] Read general settings
[ ] A mechanism for keeping configuration belonging to separate domains, for example language-specific configuration.

2.7.4 TODO Merge several configuration files

Usually there are several places for configuration files which are loaded in the order of priority.

2.8 TODO Syntax highlighting

The simplest possible one, just syntax tokens. Most probably implemented with an extension language.

2.9 TODO Add extension language `[1/3]`

2.9.1 DONE Decide on extension language

[ ] Lua
[ ] Fennel
[ ] Chibi Scheme
[X] Janet

2.9.2 TODO Implement event system

Events are signals emitted by the core to which the extension language can subscribe and do desired actions. Event system is de facto the way the extension language can know about anything happening in the editor.

2.9.3 TODO Provide proof-of-concept implementations

[ ] Integration with fzf
[ ] Syntax highlighting
[ ] Most probably the "core" of the editor will only provide most basic commands for manipulating the state, and the extension language is then responsible for combining these simple commands into more complex interactions.

2.10 TODO Integration with external tools `[0/4]`

This will probably intersect with other sections such as extension language.

2.10.1 TODO fzf

2.10.2 TODO ripgrep

2.10.3 TODO Linting

2.10.4 TODO Formatting

3 TODO Stage 3: Polished working program `[0%]`

This stage should result in a full working editor with basic features which work well and as expected. But it does not necessarily include all the nice convenience features which are generally expected in a modern text editor.

3.1 TODO Write documentation

3.2 TODO Finalize text buffer implementation `[0/2]`

[ ] Implement several variants
[ ] Benchmark them

3.3 TODO Implement tower of highlighting

Experimentation with different modes for highlighting and implementation of the "tower of highlighting". Only the basic structure should be implemented, not necessarily all the different semantic modes.

3.4 TODO Decide on configuration handling

Do we need extension language?
If we keep extension language, do we need zzz file format?

3.5 TODO Search and replace

3.5.1 TODO Decide which search variations to implement

[ ] Exact
[ ] Exact with word boundaries
[ ] Regex
[ ] Exact case-insensitive
[ ] Camel-Kebab-Pascal-Snake-case-insensitive
[ ] PEG

3.5.2 TODO Implement searching

3.5.3 TODO Implement replacing

4 TODO Stage 4: Experimental convenience functionality `[0%]`

This stage includes all the nice features which help the programmer program quicker, faster and easier. A lot of experimental features are expected to be here with the idea that they can be further refined, removed or changed.

4.1 TODO Autocompletion

4.2 TODO Clipboard integration

4.3 TODO Jump inside file

4.4 TODO Mouse integration

4.5 TODO Multiple cursors

4.6 TODO Language server protocol

5 TODO Stage 5: Refined convenience functionality `[0%]`

This stage should complete and decide on all the functionality that should be included in the "core" of the editor, moved to third-party library or removed completely and left as the exercise for the reader.

5.1 TODO Decide on the features

6 TODO Stage 6: Final release

This stage should be a release of version 1.0. After all the stages have been implemented and tested, this stage will stabilize the features, API and all the other important things so that users can expect a seamless upgrade process of future versions. The next breaking version will be 2.0.