`ad49903`

Add LSP integration to editor

- Integrate LSP manager into editor state with init/cleanup
- Start LSP servers automatically when opening supported files
- Send textDocument/didOpen notifications when files are opened
- Process LSP messages in main event loop
- Add buffer_to_string function for converting buffer to string
- Add helper functions for language detection and file events:
- get_language_for_file: Detect language from file extension
- start_lsp_for_file: Start appropriate LSP server for file
- notify_file_opened/changed/closed: Send LSP notifications
- Support for C/C++, Python, Rust, Go, TypeScript, Fortran
- Add tests/lsp directory with test programs and documentation
- Add Makefile targets for LSP testing (test-lsp, test-lsp-editor)
- Move LSP modules earlier in build order (before editor_state_module)

Co-Authored-By: mfwolffe <mfwolffe@mtu.edu>

Authored by

espadonne 5 months ago

SHA: ad49903102ca670b025971dfd50853ebaefcab8e
Parents: fa6b66e
Tree: adbfd35

9 changed files

Status	File	+	-
M	`Makefile`	14	7
M	`app/main.f90`	14	0
M	`src/buffer/text_buffer_module.f90`	30	0
M	`src/editor_state_module.f90`	19	0
M	`src/lsp/lsp_server_manager_module.f90`	120	0
A	`tests/lsp/README.md`	64	0
A	`tests/lsp/sample.c`	13	0
A	`tests/lsp/test_json.f90`	34	0
A	`tests/lsp/test_lsp_init.f90`	59	0

Makefilemodified

            src/terminal/terminal_io_module.f90 \
            src/terminal/input_handler_module.f90 \
            src/utils/bracket_matching_module.f90 \
 +          src/lsp/json_module.f90 \
 +          src/lsp/lsp_protocol_module.f90 \
 +          src/lsp/lsp_server_manager_module.f90 \
 +          src/lsp/lsp_client_module.f90 \
            src/editor_state_module.f90 \
            src/undo/undo_stack_module.f90 \
            src/workspace/file_tree_module.f90 \
            src/workspace/workspace_module.f90 \
            src/workspace/backup_module.f90 \
            src/syntax/syntax_highlighter_module.f90 \
 -          src/lsp/json_module.f90 \
 -          src/lsp/lsp_protocol_module.f90 \
 -          src/lsp/lsp_server_manager_module.f90 \
 -          src/lsp/lsp_client_module.f90 \
            src/terminal/renderer_module.f90 \
            src/ui/help_display_module.f90 \
            src/ui/text_prompt_module.f90 \
  test-lsp: lsp-modules
  	@echo "Testing LSP JSON parser..."
 -	@$(FC) $(FFLAGS_DEBUG) /tmp/test_json.f90 src/lsp/json_module.o -o /tmp/test_json 2>/dev/null && /tmp/test_json || true
 +	@$(FC) $(FFLAGS_DEBUG) tests/lsp/test_json.f90 src/lsp/json_module.o -o tests/lsp/test_json 2>/dev/null && tests/lsp/test_json || true
  	@echo ""
  	@echo "Testing LSP initialization..."
 -	@$(FC) $(FFLAGS_DEBUG) /tmp/test_lsp_init.f90 src/lsp/json_module.o src/lsp/lsp_protocol_module.o src/lsp/lsp_process_wrapper.o src/lsp/lsp_client_module.o src/lsp/lsp_server_manager_module.o -o /tmp/test_lsp_init 2>/dev/null && /tmp/test_lsp_init || true
 +	@$(FC) $(FFLAGS_DEBUG) tests/lsp/test_lsp_init.f90 src/lsp/json_module.o src/lsp/lsp_protocol_module.o src/lsp/lsp_process_wrapper.o src/lsp/lsp_client_module.o src/lsp/lsp_server_manager_module.o -o tests/lsp/test_lsp_init 2>/dev/null && tests/lsp/test_lsp_init || true
++
 +test-lsp-editor: all
 +	@echo "Testing LSP in editor with sample C file..."
 +	@echo "Opening tests/lsp/sample.c - check for LSP server initialization"
 +	@timeout 2 ./fac tests/lsp/sample.c < /dev/null 2>&1 | grep -q "LSP server initialized" && \
 +		echo "✓ LSP server initialized for C file" || \
 +		echo "✗ LSP server did not initialize (check if clangd is installed)"
  clean-lsp:
  	rm -f src/lsp/*.o src/lsp/*.mod /tmp/test_json /tmp/test_lsp_init /tmp/test_lsp_raw
  	@echo "Building LSP modules with debug flags..."
  	@$(MAKE) lsp-modules FFLAGS="$(FFLAGS_DEBUG)" CFLAGS="$(CFLAGS_DEV)"
 -.PHONY: all clean dev debug info bump-patch bump-minor bump-major version release lsp-modules test-lsp clean-lsp lsp-dev
 +.PHONY: all clean dev debug info bump-patch bump-minor bump-major version release lsp-modules test-lsp test-lsp-editor clean-lsp lsp-dev

app/main.f90modified

      use welcome_menu_module, only: show_welcome_menu
      use fortress_navigator_module, only: open_fortress_navigator
      use binary_prompt_module, only: binary_file_prompt
 +    use lsp_server_manager_module, only: notify_file_opened, notify_file_changed, &
 +                                         notify_file_closed, process_server_messages
      implicit none
      type(editor_state_t) :: editor
              if (allocated(editor%filename)) deallocate(editor%filename)
              allocate(character(len=len_trim(filename)) :: editor%filename)
              editor%filename = trim(filename)
++
 +            ! Send LSP didOpen notification if LSP server is active
 +            if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then
 +                if (editor%tabs(editor%active_tab_index)%lsp_server_index > 0) then
 +                    call notify_file_opened(editor%lsp_manager, &
 +                        editor%tabs(editor%active_tab_index)%lsp_server_index, &
 +                        trim(filename), buffer_to_string(buffer))
 +                end if
 +            end if
          else if (status == -2) then
              ! Binary file detected - prompt user
              if (binary_file_prompt(trim(filename))) then
      ! Main event loop
      do while (running)
 +        ! Process any LSP messages
 +        call process_server_messages(editor%lsp_manager)
++
          ! Get input
          call get_key_input(key_input, status)

src/buffer/text_buffer_module.f90modified

      public :: buffer_load_file, buffer_save_file, buffer_load_file_as_hex
      public :: buffer_move_gap
      public :: buffer_char_at, buffer_byte_to_char_col, buffer_char_to_byte_col
 +    public :: buffer_to_string
      integer, parameter :: INITIAL_SIZE = 8192
      integer, parameter :: GROW_FACTOR = 2
          end do
      end subroutine format_hex_line
 +    ! Convert buffer contents to a string
 +    function buffer_to_string(buffer) result(str)
 +        type(buffer_t), intent(in) :: buffer
 +        character(len=:), allocatable :: str
 +        integer :: content_len
++
 +        if (buffer%gap_start == 1) then
 +            ! No content before gap
 +            content_len = buffer%size - buffer%gap_end + 1
 +            if (content_len > 0) then
 +                allocate(character(len=content_len) :: str)
 +                str = buffer%data(buffer%gap_end:buffer%size)
 +            else
 +                allocate(character(len=0) :: str)
 +                str = ""
 +            end if
 +        else if (buffer%gap_end > buffer%size) then
 +            ! No gap (full buffer)
 +            content_len = buffer%gap_start - 1
 +            allocate(character(len=content_len) :: str)
 +            str = buffer%data(1:content_len)
 +        else
 +            ! Content on both sides of gap
 +            content_len = (buffer%gap_start - 1) + (buffer%size - buffer%gap_end + 1)
 +            allocate(character(len=content_len) :: str)
 +            str = buffer%data(1:buffer%gap_start-1) // buffer%data(buffer%gap_end:buffer%size)
 +        end if
 +    end function buffer_to_string
++
  end module text_buffer_module

src/editor_state_module.f90modified

  module editor_state_module
      use iso_fortran_env, only: int32, int64
      use text_buffer_module, only: buffer_t, copy_buffer, init_buffer
 +    use lsp_server_manager_module, only: lsp_manager_t, init_lsp_manager, cleanup_lsp_manager, &
 +                                         get_or_start_server, process_server_messages, &
 +                                         start_lsp_for_file, notify_file_opened, &
 +                                         notify_file_changed, notify_file_closed
      implicit none
      private
          logical :: modified = .false.
          logical :: is_orphan = .false.  ! True if file is outside workspace (uses absolute path)
++
 +        ! LSP support
 +        integer :: lsp_server_index = 0  ! Index of LSP server handling this file
      end type tab_t
      ! Main editor state
          type(tab_t), allocatable :: tabs(:)
          integer(int32) :: active_tab_index = 1
          integer(int32) :: max_tabs = 10
++
 +        ! LSP support
 +        type(lsp_manager_t) :: lsp_manager
      end type editor_state_t
  contains
          ! Initialize tabs array (empty initially)
          allocate(editor%tabs(0))
          editor%active_tab_index = 0
++
 +        ! Initialize LSP manager
 +        call init_lsp_manager(editor%lsp_manager)
      end subroutine init_editor
      subroutine cleanup_editor(editor)
              end do
              deallocate(editor%tabs)
          end if
++
 +        ! Cleanup LSP manager
 +        call cleanup_lsp_manager(editor%lsp_manager)
      end subroutine cleanup_editor
      ! Helper to cleanup a single tab
          temp_tabs(new_index)%active_pane_index = 1
          temp_tabs(new_index)%modified = .false.
 +        ! Start LSP server for this file if applicable
 +        temp_tabs(new_index)%lsp_server_index = start_lsp_for_file(editor%lsp_manager, filename)
++
          ! Replace tabs array
          call move_alloc(temp_tabs, editor%tabs)
          editor%active_tab_index = new_index

src/lsp/lsp_server_manager_module.f90modified

      public :: send_request, send_notification
      public :: process_server_messages
      public :: register_callback
 +    public :: get_language_for_file, start_lsp_for_file
 +    public :: notify_file_opened, notify_file_changed, notify_file_closed
      ! Language server configuration
      type :: server_config_t
          manager%num_callbacks = manager%num_callbacks - 1
      end subroutine remove_callback
 +    ! Helper to get language from filename
 +    function get_language_for_file(filename) result(language)
 +        character(len=*), intent(in) :: filename
 +        character(len=:), allocatable :: language
 +        integer :: dot_pos
++
 +        ! Find last dot in filename
 +        dot_pos = index(filename, '.', back=.true.)
 +        if (dot_pos == 0) then
 +            language = ""
 +            return
 +        end if
++
 +        ! Match extension to language
 +        select case(filename(dot_pos:))
 +        case('.py')
 +            language = "python"
 +        case('.rs')
 +            language = "rust"
 +        case('.c', '.h')
 +            language = "c"
 +        case('.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.C', '.H')
 +            language = "cpp"
 +        case('.go')
 +            language = "go"
 +        case('.ts', '.tsx')
 +            language = "typescript"
 +        case('.js', '.jsx')
 +            language = "javascript"
 +        case('.f90', '.f95', '.f03', '.f08', '.F90', '.F95', '.F03', '.F08')
 +            language = "fortran"
 +        case('.java')
 +            language = "java"
 +        case('.rb')
 +            language = "ruby"
 +        case('.lua')
 +            language = "lua"
 +        case default
 +            language = ""
 +        end select
 +    end function get_language_for_file
++
 +    ! Start LSP server for a file if needed
 +    function start_lsp_for_file(manager, filename) result(server_index)
 +        type(lsp_manager_t), intent(inout) :: manager
 +        character(len=*), intent(in) :: filename
 +        integer :: server_index
 +        character(len=:), allocatable :: language
 +        character(len=256) :: workspace_path
 +        integer :: slash_pos
++
 +        server_index = 0
++
 +        ! Get language from file extension
 +        language = get_language_for_file(filename)
 +        if (language == "") return
++
 +        ! Extract workspace path from filename (directory containing file)
 +        slash_pos = index(filename, '/', back=.true.)
 +        if (slash_pos > 0) then
 +            workspace_path = filename(1:slash_pos-1)
 +        else
 +            workspace_path = "."
 +        end if
++
 +        ! Get or start server for this language
 +        server_index = get_or_start_server(manager, language, trim(workspace_path))
 +    end function start_lsp_for_file
++
 +    ! Send textDocument/didOpen notification
 +    subroutine notify_file_opened(manager, server_index, filename, content)
 +        use lsp_protocol_module, only: create_did_open_notification
 +        type(lsp_manager_t), intent(inout) :: manager
 +        integer, intent(in) :: server_index
 +        character(len=*), intent(in) :: filename
 +        character(len=*), intent(in) :: content
 +        type(lsp_message_t) :: msg
 +        character(len=:), allocatable :: language
++
 +        if (server_index < 1 .or. server_index > manager%num_servers) return
 +        if (.not. manager%servers(server_index)%initialized) return
++
 +        language = get_language_for_file(filename)
 +        msg = create_did_open_notification(filename, language, 1, content)
 +        call send_notification(manager%servers(server_index), msg)
 +    end subroutine notify_file_opened
++
 +    ! Send textDocument/didChange notification
 +    subroutine notify_file_changed(manager, server_index, filename, content)
 +        use lsp_protocol_module, only: create_did_change_notification
 +        type(lsp_manager_t), intent(inout) :: manager
 +        integer, intent(in) :: server_index
 +        character(len=*), intent(in) :: filename
 +        character(len=*), intent(in) :: content
 +        type(lsp_message_t) :: msg
++
 +        if (server_index < 1 .or. server_index > manager%num_servers) return
 +        if (.not. manager%servers(server_index)%initialized) return
++
 +        msg = create_did_change_notification(filename, 2, content)
 +        call send_notification(manager%servers(server_index), msg)
 +    end subroutine notify_file_changed
++
 +    ! Send textDocument/didClose notification
 +    subroutine notify_file_closed(manager, server_index, filename)
 +        use lsp_protocol_module, only: create_did_close_notification
 +        type(lsp_manager_t), intent(inout) :: manager
 +        integer, intent(in) :: server_index
 +        character(len=*), intent(in) :: filename
 +        type(lsp_message_t) :: msg
++
 +        if (server_index < 1 .or. server_index > manager%num_servers) return
 +        if (.not. manager%servers(server_index)%initialized) return
++
 +        msg = create_did_close_notification(filename)
 +        call send_notification(manager%servers(server_index), msg)
 +    end subroutine notify_file_closed
++
  end module lsp_server_manager_module

tests/lsp/README.mdadded

 +# LSP Tests
++
 +This directory contains tests for the Language Server Protocol (LSP) integration in the fac editor.
++
 +## Test Files
++
 +- `test_json.f90` - Tests the JSON parser implementation
 +- `test_lsp_init.f90` - Tests LSP server initialization and communication
 +- `sample.c` - Sample C file for testing LSP with clangd
 +- `sample.py` - Sample Python file for testing LSP with pylsp
 +- `sample.rs` - Sample Rust file for testing LSP with rust-analyzer
++
 +## Running Tests
++
 +### Test JSON Parser
 +```bash
 +make test-lsp
 +```
++
 +### Test LSP in Editor
 +```bash
 +make test-lsp-editor
 +```
++
 +### Manual Testing
 +Open a supported file type in the editor:
 +```bash
 +./fac tests/lsp/sample.c   # Tests C/C++ with clangd
 +./fac tests/lsp/sample.py  # Tests Python with pylsp
 +./fac tests/lsp/sample.rs  # Tests Rust with rust-analyzer
 +```
++
 +## Supported Languages
++
 +The editor currently supports LSP for:
 +- C/C++ (clangd)
 +- Python (pylsp)
 +- Rust (rust-analyzer)
 +- Go (gopls)
 +- TypeScript/JavaScript (typescript-language-server)
 +- Fortran (fortls)
++
 +## Requirements
++
 +For LSP to work, you need the corresponding language servers installed:
 +- C/C++: `brew install llvm` (provides clangd)
 +- Python: `pip install python-lsp-server`
 +- Rust: `rustup component add rust-analyzer`
 +- Go: `go install golang.org/x/tools/gopls@latest`
 +- TypeScript: `npm install -g typescript typescript-language-server`
 +- Fortran: `pip install fortls`
++
 +## Current Features
 +- ✓ Automatic server startup when opening supported files
 +- ✓ textDocument/didOpen notifications
 +- ✓ Server initialization handshake
++
 +## Planned Features
 +- [ ] Code completion (Ctrl+Space)
 +- [ ] Hover information (Ctrl+H)
 +- [ ] Go to definition (Ctrl+D)
 +- [ ] Find references (Ctrl+R)
 +- [ ] Diagnostics display
 +- [ ] Code actions and fixes

tests/lsp/sample.cadded

 +#include <stdio.h>
++
 +// Test file for LSP integration
 +int main() {
 +    printf("Hello from LSP test!\n");
++
 +    int x = 10;
 +    int y = 20;
 +    int result = x + y;
++
 +    printf("Result: %d\n", result);
 +    return 0;
 +}

tests/lsp/test_json.f90added

 +program test_json
 +    use json_module
 +    use iso_fortran_env, only: real64
 +    implicit none
++
 +    type(json_value_t) :: json_obj
 +    character(len=100) :: json_str
 +    real(real64) :: id_value
++
 +    ! Test with a simple JSON response like what we get from clangd
 +    json_str = '{"id":1,"jsonrpc":"2.0","result":{"capabilities":{}}}'
++
 +    print *, "Testing JSON: ", trim(json_str)
++
 +    ! Parse it
 +    json_obj = json_parse(json_str)
++
 +    ! Check if we can find the id
 +    if (json_has_key(json_obj, "id")) then
 +        print *, "Found id key!"
 +        id_value = json_get_number(json_obj, "id", -1.0_real64)
 +        print *, "ID value: ", id_value
 +    else
 +        print *, "No id key found"
 +    end if
++
 +    ! Check for jsonrpc
 +    if (json_has_key(json_obj, "jsonrpc")) then
 +        print *, "Found jsonrpc key!"
 +    else
 +        print *, "No jsonrpc key found"
 +    end if
++
 +end program test_json

tests/lsp/test_lsp_init.f90added

 +program test_lsp_init
 +    use lsp_server_manager_module
 +    use iso_fortran_env, only: output_unit, error_unit
 +    implicit none
++
 +    type(lsp_manager_t) :: manager
 +    integer :: server_index
 +    character(len=256) :: test_file
 +    integer :: i
++
 +    print *, "Testing LSP initialization with fixed JSON parser..."
++
 +    ! Create test file
 +    test_file = "/tmp/test.c"
 +    open(10, file=test_file, status='replace')
 +    write(10, '(a)') "#include <stdio.h>"
 +    write(10, '(a)') "int main() { return 0; }"
 +    close(10)
++
 +    ! Initialize manager
 +    call init_lsp_manager(manager)
++
 +    ! Get or start server for C language
 +    server_index = get_or_start_server(manager, "c", "/tmp")
 +    if (server_index > 0) then
 +        print *, "✓ Server started successfully"
 +        print '(a,i0)', "   Server index: ", server_index
 +    else
 +        print *, "✗ Failed to start server"
 +        stop 1
 +    end if
++
 +    ! Wait a bit for initialization
 +    print *, "Waiting for initialization..."
 +    call sleep(2)
++
 +    ! Process any pending messages
 +    call process_server_messages(manager)
++
 +    ! Check if server is initialized
 +    do i = 1, manager%num_servers
 +        if (manager%servers(i)%initialized) then
 +            print *, "✓ Server initialized successfully!"
 +        else
 +            print *, "✗ Server not yet initialized"
 +        end if
++
 +        ! Show server info
 +        print '(a,a)', "   Command: ", trim(manager%servers(i)%command)
 +        print '(a,i0)', "   Process ID: ", manager%servers(i)%process_id
 +        print '(a,l1)', "   Initialized: ", manager%servers(i)%initialized
 +        print '(a,l1)', "   Supports completion: ", manager%servers(i)%supports_completion
 +    end do
++
 +    ! Cleanup
 +    call cleanup_lsp_manager(manager)
 +    print *, "Test complete."
++
 +end program test_lsp_init