`5c5a6f9`

fix multiple rename issue

Authored by

espadonne 5 months ago

SHA: 5c5a6f9f332b266862a2c254437bca84d09758c5
Parents: b44a816
Tree: 92fb770

11 changed files

Status	File	+	-
M	`app/main.f90`	0	50
M	`src/commands/command_handler_module.f90`	107	9
M	`src/lsp/diagnostics_module.f90`	1	19
M	`src/lsp/lsp_protocol_module.f90`	1	11
M	`src/lsp/lsp_server_manager_module.f90`	15	319
M	`src/terminal/input_handler_module.f90`	59	91
M	`src/ui/help_display_module.f90`	7	7
M	`src/ui/rename_prompt_module.f90`	0	25
M	`src/workspace/workspace_module.f90`	3	53
M	`tests/scratch_files/calculator.py`	1	0
M	`tests/scratch_files/long_errors.py`	1	1

app/main.f90modified

          ! User selected a workspace from welcome menu (not browse)
          ! This handles favorites, recents, and CURRENT DIRECTORY
          if (allocated(selected_path) .and. .not. is_browse) then
--            write(0, '(A)') '[DEBUG WELCOME] selected_path allocated, value: ' // selected_path
--            write(0, '(A,L1)') '[DEBUG WELCOME] is_browse: ', is_browse
--
              ! Check if user selected CURRENT DIRECTORY option
              if (selected_path == "CWD") then
--                write(0, '(A)') '[DEBUG WELCOME] CWD selected, getting workspace path'
                  ! Get actual current working directory
                  call get_workspace_path(selected_path)
--                write(0, '(A)') '[DEBUG WELCOME] Workspace path: ' // selected_path
                  arg = selected_path
              else
--                write(0, '(A)') '[DEBUG WELCOME] Not CWD, using selected_path directly'
                  arg = selected_path
              end if
              ! Check if it's a directory
--            write(0, '(A)') '[DEBUG WELCOME] Testing if directory: ' // trim(arg)
              call execute_command_line("test -d '" // trim(arg) // &
                  "' && echo 'Directory' > /tmp/.fac_filetype || " // &
                  "echo 'File' > /tmp/.fac_filetype", wait=.true.)
              call read_file_type(status)
--            write(0, '(A,I0)') '[DEBUG WELCOME] read_file_type status: ', status
              if (status == 0) then
                  ! Directory - workspace mode
--                write(0, '(A)') '[DEBUG WELCOME] Setting is_workspace_mode = TRUE'
                  is_workspace_mode = .true.
                  call workspace_get_path(trim(arg), workspace_dir)
--                write(0, '(A)') '[DEBUG WELCOME] workspace_dir: ' // trim(workspace_dir)
              else
                  ! Invalid selection (favorites/recents should only have directories)
                  write(error_unit, '(A)') 'Error: Selected path is not a directory'
                  stop 1
              end if
--        else
--            write(0, '(A,L1)') '[DEBUG WELCOME] selected_path allocated: ', allocated(selected_path)
--            if (allocated(selected_path)) then
--                write(0, '(A)') '[DEBUG WELCOME] selected_path value: ' // selected_path
--            end if
--            write(0, '(A,L1)') '[DEBUG WELCOME] is_browse: ', is_browse
          end if
      end if
      ! Handle workspace mode
--    write(0, '(A,L1)') '[DEBUG WORKSPACE] is_workspace_mode: ', is_workspace_mode
      if (is_workspace_mode) then
--        write(0, '(A)') '[DEBUG WORKSPACE] In workspace mode, workspace_dir: ' // trim(workspace_dir)
          ! Check if workspace exists, create if not
          if (.not. workspace_exists(workspace_dir)) then
--            write(0, '(A)') '[DEBUG WORKSPACE] Workspace does not exist, creating'
              call workspace_init(workspace_dir, workspace_success)
              if (.not. workspace_success) then
                  write(error_unit, '(A)') 'Error: Failed to create workspace'
                  stop 1
              end if
          else
--            write(0, '(A)') '[DEBUG WORKSPACE] Workspace exists, loading'
              ! Load existing workspace
              call workspace_load(workspace_dir, workspace_success)
              if (.not. workspace_success) then
                  stop 1
              end if
          end if
--    else
--        write(0, '(A)') '[DEBUG WORKSPACE] NOT in workspace mode'
      end if
      ! Initialize editor
      call init_buffer(buffer)
      ! Set workspace path
--    write(0, '(A,L1)') '[DEBUG RESTORE CHECK] is_workspace_mode: ', is_workspace_mode
      if (is_workspace_mode) then
--        write(0, '(A)') '[DEBUG RESTORE CHECK] workspace_dir: ' // trim(workspace_dir)
          ! Use detected/created workspace directory
          allocate(character(len=len_trim(workspace_dir)) :: editor%workspace_path)
          editor%workspace_path = trim(workspace_dir)
--        ! DEBUG: Print before restoration (unit 0 = stderr)
--        write(0, '(A)') '[DEBUG RESTORE] About to restore workspace from: ' // trim(editor%workspace_path)
--        write(0, '(A)') '[DEBUG RESTORE] Workspace JSON path: ' // trim(editor%workspace_path) // '/.fac/workspace.json'
--
          ! Restore workspace state (tabs, cursor positions, etc.)
          call workspace_restore_state(editor, editor%workspace_path, workspace_success)
--        ! DEBUG: Print restoration results
--        write(0, '(A,L1)') '[DEBUG RESTORE] Workspace restore success: ', workspace_success
--        if (allocated(editor%tabs)) then
--            write(0, '(A,I0)') '[DEBUG RESTORE] Number of tabs restored: ', size(editor%tabs)
--        else
--            write(0, '(A)') '[DEBUG RESTORE] No tabs allocated after restore'
--        end if
--        write(0, '(A,I0)') '[DEBUG RESTORE] Active tab index: ', editor%active_tab_index
--
          ! Sync restored active tab's buffer to main buffer
          if (workspace_success .and. allocated(editor%tabs) .and. editor%active_tab_index > 0) then
              if (editor%active_tab_index <= size(editor%tabs)) then
                  if (allocated(editor%tabs(editor%active_tab_index)%panes) .and. &
                      size(editor%tabs(editor%active_tab_index)%panes) > 0) then
                      ! Copy active pane's buffer to main buffer (replaces the empty init)
--                    write(0, '(A)') '[DEBUG RESTORE] Copying restored tab buffer to main buffer'
                      call copy_buffer(buffer, editor%tabs(editor%active_tab_index)%panes(1)%buffer)
--                else
--                    write(0, '(A)') '[DEBUG RESTORE] Active tab has no panes!'
                  end if
--            else
--                write(0, '(A,I0,A,I0)') '[DEBUG RESTORE] Active tab index ', editor%active_tab_index, &
--                    ' exceeds tab count ', size(editor%tabs)
              end if
--        else
--            write(0, '(A)') '[DEBUG RESTORE] Skipping buffer sync - conditions not met'
          end if
      else
          ! Single-file mode - use current directory
          use terminal_io_module, only: terminal_write
          type(lsp_message_t), intent(in) :: notification
          integer, intent(in) :: server_index
--        character(len=256) :: debug_msg
--
--        ! Debug: Log when diagnostics are received
--        write(debug_msg, '(A,I0)') "[DEBUG] Received diagnostics from server ", server_index
--        call terminal_write(debug_msg)  ! Debug output enabled
          ! Parse and store diagnostics with server attribution (for multi-LSP)
          ! This keeps diagnostics from different servers separate

src/commands/command_handler_module.f90modified

                                              ! Check if rename response modified the buffer
                                              if (g_lsp_modified_buffer) then
--                                                ! Sync buffer from tab (LSP modified tab buffer)
++                                                ! LSP now modifies pane buffer directly, sync FROM pane TO local buffer and tab
--                                                call copy_buffer(buffer, editor%tabs(editor%active_tab_index)%buffer)
--
--                                                ! Also sync to active pane buffer if panes exist
                                                  if (allocated(editor%tabs(editor%active_tab_index)%panes) .and. &
                                                      size(editor%tabs(editor%active_tab_index)%panes) > 0) then
                                                      pane_idx = editor%tabs(editor%active_tab_index)%active_pane_index
                                                      if (pane_idx > 0 .and. pane_idx <= size(editor%tabs(editor%active_tab_index)%panes)) then
--                                                        call copy_buffer(editor%tabs(editor%active_tab_index)%panes(pane_idx)%buffer, buffer)
++                                                        ! Copy FROM pane buffer TO local buffer (for rendering)
++                                                        call copy_buffer(buffer, editor%tabs(editor%active_tab_index)%panes(pane_idx)%buffer)
++                                                        ! Also sync to tab buffer (to keep them consistent)
++                                                        call copy_buffer(editor%tabs(editor%active_tab_index)%buffer, buffer)
                                                      end if
                                                  end if
      subroutine apply_file_edits_obj(editor, uri, edits_arr, changes_applied)
          use json_module, only: json_value_t, json_array_size, json_get_array_element, &
                                 json_get_object, json_get_string, json_get_number, json_has_key
++        use text_buffer_module, only: buffer_to_string
++        use lsp_server_manager_module, only: notify_file_changed
          type(editor_state_t), intent(inout) :: editor
          character(len=*), intent(in) :: uri
          type(json_value_t), intent(in) :: edits_arr
          integer, intent(inout) :: changes_applied
          type(json_value_t) :: edit_obj, range_obj, start_obj, end_obj
--        character(len=:), allocatable :: filename, new_text
++        character(len=:), allocatable :: filename, new_text, buffer_content
--        integer :: num_edits, i, j, tab_idx
++        integer :: num_edits, i, j, tab_idx, server_idx, pane_idx
          integer :: start_line, start_char, end_line, end_char
          ! Convert URI to filename
              return
          end if
++        ! Get the active pane for this tab (panes contain the actual buffers)
++        pane_idx = editor%tabs(tab_idx)%active_pane_index
++        if (pane_idx < 1 .or. .not. allocated(editor%tabs(tab_idx)%panes)) then
++            pane_idx = 1  ! Default to first pane
++        end if
++        if (pane_idx > size(editor%tabs(tab_idx)%panes)) then
++            if (allocated(filename)) deallocate(filename)
++            return
++        end if
++
++        ! Debug: log tab_idx finding
++        open(newunit=server_idx, file='/tmp/fac_tab_debug.log', status='unknown', &
++             position='append', action='write')
++        write(server_idx, '(A,I3,A,I3)') 'Found tab_idx=', tab_idx, ' pane_idx=', pane_idx
++        write(server_idx, '(A,A)') 'Extracted filename: ', trim(filename)
++        write(server_idx, '(A,A)') 'Tab filename: ', trim(editor%tabs(tab_idx)%filename)
++        write(server_idx, '(A)') '---'
++        close(server_idx)
++
          ! Apply edits in reverse order (to preserve line numbers)
          num_edits = json_array_size(edits_arr)
                  new_text = json_get_string(edit_obj, 'newText')
                  if (allocated(new_text)) then
--                    ! Apply the edit to the buffer
++                    ! Apply the edit to the pane buffer (not tab buffer!)
--                    call apply_single_edit(editor%tabs(tab_idx)%buffer, &
++                    call apply_single_edit(editor%tabs(tab_idx)%panes(pane_idx)%buffer, &
                          start_line, start_char, end_line, end_char, new_text)
                      changes_applied = changes_applied + 1
++
++                    ! Debug: check buffer size after edit
++                    block
++                        character(len=:), allocatable :: check_content
++                        integer :: check_unit
++                        check_content = buffer_to_string(editor%tabs(tab_idx)%panes(pane_idx)%buffer)
++                        open(newunit=check_unit, file='/tmp/fac_after_edit.log', status='unknown', &
++                             position='append', action='write')
++                        write(check_unit, '(A,I8)') 'After edit, buffer len: ', len(check_content)
++                        close(check_unit)
++                        if (allocated(check_content)) deallocate(check_content)
++                    end block
++
                      deallocate(new_text)
                  end if
              end if
          end do
++        ! Sync the changed document back to all LSP servers
++        if (changes_applied > 0) then
++            buffer_content = buffer_to_string(editor%tabs(tab_idx)%panes(pane_idx)%buffer)
++            if (allocated(buffer_content)) then
++                ! Debug: log what we're about to sync
++                open(newunit=server_idx, file='/tmp/fac_sync_debug.log', status='unknown', &
++                     position='append', action='write')
++                write(server_idx, '(A,I4)') 'Sync after changes_applied=', changes_applied
++                write(server_idx, '(A,I8)') 'Buffer content length: ', len(buffer_content)
++                write(server_idx, '(A,A)') 'First 100 chars: ', buffer_content(1:min(100,len(buffer_content)))
++                write(server_idx, '(A)') '---'
++                close(server_idx)
++
++                ! Notify all active LSP servers about the document change
++                ! Use the absolute path from the URI (filename variable) not the tab's relative path
++                do server_idx = 1, editor%lsp_manager%num_servers
++                    if (editor%lsp_manager%servers(server_idx)%initialized) then
++                        call notify_file_changed(editor%lsp_manager, server_idx, &
++                            'file://' // filename, buffer_content)
++                    end if
++                end do
++                deallocate(buffer_content)
++            end if
++        end if
++
          if (allocated(filename)) deallocate(filename)
      end subroutine apply_file_edits_obj
          character(len=*), intent(in) :: new_text
          integer :: start_pos, end_pos, delete_count
++        integer :: debug_unit
++        character(len=256) :: debug_msg
          ! Calculate buffer positions
          start_pos = get_buffer_position(buffer, start_line, start_char)
          end_pos = get_buffer_position(buffer, end_line, end_char)
++        ! Debug logging
++        open(newunit=debug_unit, file='/tmp/fac_edit_debug.log', status='unknown', &
++             position='append', action='write')
++        write(debug_msg, '(A,I4,A,I4,A,I4,A,I4)') 'Edit range: line ', start_line, &
++              ' char ', start_char, ' to line ', end_line, ' char ', end_char
++        write(debug_unit, '(A)') trim(debug_msg)
++        write(debug_msg, '(A,I6,A,I6,A,I4)') 'Buffer pos: start=', start_pos, &
++              ' end=', end_pos, ' delete_count=', end_pos - start_pos
++        write(debug_unit, '(A)') trim(debug_msg)
++        write(debug_msg, '(A,I4,A,A,A)') 'New text len=', len(new_text), ' text="', new_text, '"'
++        write(debug_unit, '(A)') trim(debug_msg)
++        write(debug_unit, '(A)') '---'
++        close(debug_unit)
++
          if (start_pos <= 0 .or. end_pos <= 0) return
          ! Delete the old text
          delete_count = end_pos - start_pos
++
++        ! Debug: log gap buffer state before operations
++        open(newunit=debug_unit, file='/tmp/fac_gap_debug.log', status='unknown', &
++             position='append', action='write')
++        write(debug_unit, '(A,I6,A,I6,A,I6)') 'BEFORE: gap_start=', buffer%gap_start, &
++              ' gap_end=', buffer%gap_end, ' size=', buffer%size
++        close(debug_unit)
++
          if (delete_count > 0) then
              call buffer_delete(buffer, start_pos, delete_count)
          end if
++        ! Debug: log gap buffer state after delete
++        open(newunit=debug_unit, file='/tmp/fac_gap_debug.log', status='unknown', &
++             position='append', action='write')
++        write(debug_unit, '(A,I6,A,I6,A,I6)') 'AFTER DELETE: gap_start=', buffer%gap_start, &
++              ' gap_end=', buffer%gap_end, ' size=', buffer%size
++        close(debug_unit)
++
          ! Insert the new text
          if (len(new_text) > 0) then
              call buffer_insert(buffer, start_pos, new_text)
          end if
++
++        ! Debug: log gap buffer state after insert
++        open(newunit=debug_unit, file='/tmp/fac_gap_debug.log', status='unknown', &
++             position='append', action='write')
++        write(debug_unit, '(A,I6,A,I6,A,I6)') 'AFTER INSERT: gap_start=', buffer%gap_start, &
++              ' gap_end=', buffer%gap_end, ' size=', buffer%size
++        write(debug_unit, '(A)') '---'
++        close(debug_unit)
      end subroutine apply_single_edit
      ! Execute a command from the command palette

src/lsp/diagnostics_module.f90modified

          character(len=:), allocatable :: uri
          integer :: i, n_diagnostics, file_idx
          type(diagnostic_t) :: diag
--        character(len=512) :: debug_msg
          ! Get URI
          if (.not. json_has_key(params, "uri")) return
          uri = json_get_string(params, "uri")
--        ! Debug: Log URI
--        write(debug_msg, '(A,A)') "[DIAG] Parsing diagnostics for URI: ", trim(uri)
--        call terminal_write(debug_msg)
--
          ! Find or create file entry
          file_idx = find_or_create_file(store, uri)
              diagnostics_array = json_get_array(params, "diagnostics")
              n_diagnostics = json_array_size(diagnostics_array)
--            ! Debug: Log number of diagnostics
--            write(debug_msg, '(A,I0,A)') "[DIAG] Found ", n_diagnostics, " diagnostics"
--            call terminal_write(debug_msg)
--
              if (n_diagnostics > 0) then
                  allocate(store%files(file_idx)%items(n_diagnostics))
                  store%files(file_idx)%count = n_diagnostics
          character(len=:), allocatable :: uri
          integer :: i, n_diagnostics, file_idx, old_count, new_count, j
          type(diagnostic_t) :: diag
--        type(diagnostic_t), allocatable :: old_items(:), new_items(:)
++        type(diagnostic_t), allocatable :: old_items(:)
--        character(len=512) :: debug_msg
          ! Get URI
          if (.not. json_has_key(params, "uri")) return
          uri = json_get_string(params, "uri")
--        ! Debug: Log URI
--        write(debug_msg, '(A,A,A,I0)') "[DIAG] Parsing diagnostics for URI: ", trim(uri), " from server ", server_index
--        call terminal_write(debug_msg)
--
          ! Find or create file entry
          file_idx = find_or_create_file(store, uri)
              n_diagnostics = json_array_size(diagnostics_array)
          end if
--        ! Debug: Log number of diagnostics
--        write(debug_msg, '(A,I0,A,I0,A)') "[DIAG] Found ", n_diagnostics, " new + ", old_count, " existing diagnostics"
--        call terminal_write(debug_msg)
--
          ! Allocate combined array
          new_count = old_count + n_diagnostics
          if (new_count > 0) then

src/lsp/lsp_protocol_module.f90modified

          ! Convert root_path to absolute path
          abs_root_path = make_absolute_path(root_path)
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> create_initialize_request <<<'
--            write(debug_unit, '(A)') 'root_path (input): ' // trim(root_path)
--            write(debug_unit, '(A)') 'abs_root_path: ' // abs_root_path
--            write(debug_unit, '(A)') 'rootUri: file://' // abs_root_path
--            close(debug_unit)
--        end block
--
          params = json_create_object()
          call json_add_number(params, "processId", real(process_id, real64))
          call json_add_string(params, "rootPath", abs_root_path)
          changes = json_create_array()
          change = json_create_object()
          call json_add_string(change, "text", text)
--        ! TODO: Add change to array
++        call json_array_add_element(changes, change)
          call json_add_array(params, "contentChanges", changes)
          msg%params = params

src/lsp/lsp_server_manager_module.f90modified

              return
          end if
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> STARTING LSP SERVER <<<'
--            write(debug_unit, '(A)') 'Language: ' // trim(language)
--            write(debug_unit, '(A)') 'Command: ' // trim(command)
--            write(debug_unit, '(A)') 'Root path: ' // trim(root_path)
--            close(debug_unit)
--        end block
--
          ! Expand server array
          allocate(new_servers(manager%num_servers + 1))
          if (manager%num_servers > 0) then
          procedure(response_callback), optional :: callback
          character(len=:), allocatable :: json_msg
--        block
++        if (server_index < 1 .or. server_index > manager%num_servers) return
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> send_request: START <<<'
--            write(debug_unit, '(A,I0)') 'server_index = ', server_index
--            write(debug_unit, '(A,I0)') 'num_servers = ', manager%num_servers
--            close(debug_unit)
--        end block
--
--        if (server_index < 1 .or. server_index > manager%num_servers) then
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> send_request: EARLY RETURN - invalid server_index <<<'
--                close(debug_unit)
--            end block
--            return
--        end if
          if (.not. manager%servers(server_index)%initialized .and. &
--            .not. manager%servers(server_index)%initializing) then
++            .not. manager%servers(server_index)%initializing) return
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> send_request: EARLY RETURN - server not initialized <<<'
--                write(debug_unit, '(A,L1)') 'initialized = ', manager%servers(server_index)%initialized
--                write(debug_unit, '(A,L1)') 'initializing = ', manager%servers(server_index)%initializing
--                close(debug_unit)
--            end block
--            return
--        end if
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> send_request: Formatting JSON <<<'
--            close(debug_unit)
--        end block
          json_msg = format_json_rpc(msg)
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> send_request: Sending message <<<'
--            write(debug_unit, '(A)') 'JSON (first 500 chars): ' // json_msg(1:min(500,len(json_msg)))
--            close(debug_unit)
--        end block
--
          call send_raw_message(manager%servers(server_index), json_msg)
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> send_request: Tracking request <<<'
--            close(debug_unit)
--        end block
--
          ! Track request and register callback
          call track_request(manager%servers(server_index), msg%id)
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A,L1)') '>>> send_request: callback present = ', present(callback)
--            close(debug_unit)
--        end block
--
          if (present(callback)) then
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> send_request: Calling register_callback <<<'
--                close(debug_unit)
--            end block
--
              call register_callback(manager, msg%id, callback)
--
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> send_request: register_callback DONE <<<'
--                close(debug_unit)
--            end block
          end if
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> send_request: DONE <<<'
--            close(debug_unit)
--        end block
      end subroutine send_request
      subroutine send_notification(server, msg)
          if (.not. server%initialized .and. .not. server%initializing) return
          json_msg = format_json_rpc(msg)
--
--        ! Debug log for didOpen notifications
--        if (index(msg%method, 'didOpen') > 0) then
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> Sending didOpen notification <<<'
--                write(debug_unit, '(A)') 'JSON (first 800 chars): ' // json_msg(1:min(800,len(json_msg)))
--                close(debug_unit)
--            end block
--        end if
--
          call send_raw_message(server, json_msg)
      end subroutine send_notification
      subroutine send_raw_message(server, message)
          type(lsp_server_t), intent(inout) :: server
          character(len=*), intent(in) :: message
--        integer :: result, debug_unit
++        integer :: result
--
--        ! Check if handle is valid
--        block
--            integer :: debug_unit2
--            open(newunit=debug_unit2, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit2, '(A)') '>>> send_raw_message: START <<<'
--            write(debug_unit2, '(A,L1)') 'c_associated(server%handle) = ', c_associated(server%handle)
--            close(debug_unit2)
--        end block
--
--        if (.not. c_associated(server%handle)) then
--            block
--                integer :: debug_unit2
--                open(newunit=debug_unit2, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit2, '(A)') '>>> send_raw_message: EARLY RETURN - handle is NULL <<<'
--                close(debug_unit2)
--            end block
--            return
--        end if
--        ! Log outgoing messages for debugging
++        if (.not. c_associated(server%handle)) return
--        open(newunit=debug_unit, file='/tmp/fac_lsp_out.log', position='append', action='write')
--        write(debug_unit, '(A)') '>>> OUTGOING MESSAGE >>>'
--        write(debug_unit, '(A)') trim(message)
--        write(debug_unit, '(A)') '<<< END MESSAGE <<<'
--        write(debug_unit, '(A)') ''
--        close(debug_unit)
          result = lsp_send_message_f(server%handle, message//c_null_char, len(message))
              ! Extract and parse message
              message = server%read_buffer(1:message_end)
--
--            ! Log incoming message
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_lsp_in.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> INCOMING MESSAGE >>>'
--                write(debug_unit, '(A)') trim(message)
--                write(debug_unit, '(A)') '<<< END MESSAGE <<<'
--                write(debug_unit, '(A)') ''
--                close(debug_unit)
--            end block
--
              msg = parse_lsp_message(message)
              ! Handle the message
          server%initialized = .true.
          server%initializing = .false.
--        write(error_unit, '(a,a)') "LSP server initialized: ", server%language
--
          ! Send all queued didOpen notifications
          if (allocated(server%pending_didopens) .and. server%num_pending_didopens > 0) then
              block
--                integer :: i, debug_unit
++                integer :: i
                  type(lsp_message_t) :: didopen_msg
                  character(len=:), allocatable :: lang, file_uri
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A,I0,A)') '>>> Flushing ', server%num_pending_didopens, ' queued didOpen notifications <<<'
--                close(debug_unit)
--
                  do i = 1, server%num_pending_didopens
                      if (allocated(server%pending_didopens(i)%filename) .and. &
                          allocated(server%pending_didopens(i)%content)) then
                          didopen_msg = create_did_open_notification( &
                              file_uri, lang, 1, &
                              server%pending_didopens(i)%content)
--
--                        open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                        write(debug_unit, '(A,A)') '  - Sent didOpen for: ', trim(server%pending_didopens(i)%filename)
--                        write(debug_unit, '(A,A)') '  - URI: ', trim(file_uri)
--                        write(debug_unit, '(A,I0)') '  - Content length: ', len(server%pending_didopens(i)%content)
--                        write(debug_unit, '(A,A)') '  - Language: ', trim(lang)
--                        close(debug_unit)
--
                          call send_notification(server, didopen_msg)
                      end if
                  end do
          type(lsp_message_t), intent(in) :: msg
          integer :: srv_idx, i
--        ! Debug: log all notifications
--        write(error_unit, '(A,A)') "[LSP DEBUG] Received notification: ", msg%method
--
          ! Find the server index for this server
          srv_idx = 0
          do i = 1, manager%num_servers
          select case(msg%method)
          case("textDocument/publishDiagnostics")
--            write(error_unit, '(A,I0)') "[LSP DEBUG] Processing publishDiagnostics from server ", srv_idx
              ! Forward to diagnostics handler if set (with server index)
              if (associated(manager%diagnostics_handler)) then
                  call manager%diagnostics_handler(msg, srv_idx)
--            else
--                write(error_unit, '(A)') "[LSP DEBUG] No diagnostics handler set!"
              end if
          case("window/showMessage")
              ! TODO: Show message to user
          procedure(response_callback) :: callback
          type(callback_entry_t), allocatable :: new_callbacks(:)
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: START <<<'
--            write(debug_unit, '(A,I0)') 'request_id = ', request_id
--            write(debug_unit, '(A,I0)') 'num_callbacks = ', manager%num_callbacks
--            close(debug_unit)
--        end block
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Allocating new_callbacks <<<'
--            close(debug_unit)
--        end block
--
          allocate(new_callbacks(manager%num_callbacks + 1))
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Copying old callbacks <<<'
--            close(debug_unit)
--        end block
--
          if (manager%num_callbacks > 0) then
              new_callbacks(1:manager%num_callbacks) = manager%callbacks
          end if
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Setting new callback <<<'
--            close(debug_unit)
--        end block
--
          new_callbacks(manager%num_callbacks + 1)%request_id = request_id
          new_callbacks(manager%num_callbacks + 1)%callback => callback
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Deallocating old callbacks <<<'
--            close(debug_unit)
--        end block
--
          if (allocated(manager%callbacks)) deallocate(manager%callbacks)
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Reallocating manager%callbacks <<<'
--            close(debug_unit)
--        end block
--
          allocate(manager%callbacks(size(new_callbacks)))
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Copying new_callbacks <<<'
--            close(debug_unit)
--        end block
--
          manager%callbacks = new_callbacks
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: Incrementing num_callbacks <<<'
--            close(debug_unit)
--        end block
--
          manager%num_callbacks = manager%num_callbacks + 1
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> register_callback: DONE <<<'
--            close(debug_unit)
--        end block
      end subroutine register_callback
      subroutine remove_callback(manager, index)
          command = manager%configs(config_index)%command
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> STARTING LSP SERVER (from config) <<<'
--            write(debug_unit, '(A)') 'Name: ' // trim(manager%configs(config_index)%name)
--            write(debug_unit, '(A)') 'Language: ' // trim(manager%configs(config_index)%language)
--            write(debug_unit, '(A)') 'Command: ' // trim(command)
--            write(debug_unit, '(A)') 'Root path: ' // trim(root_path)
--            close(debug_unit)
--        end block
--
          ! Expand server array
          allocate(new_servers(manager%num_servers + 1))
          if (manager%num_servers > 0) then
          ! If server not initialized yet, queue the notification
          if (.not. manager%servers(server_index)%initialized) then
--            block
--                integer :: debug_unit
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A)') '>>> notify_file_opened: Queuing (server not ready) <<<'
--                write(debug_unit, '(A)') 'File: ' // trim(filename)
--                close(debug_unit)
--            end block
--
              ! Add to pending queue
              if (allocated(manager%servers(server_index)%pending_didopens)) then
                  ! Grow array
              return
          end if
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> notify_file_opened: Sending immediately <<<'
--            write(debug_unit, '(A)') 'File: ' // trim(filename)
--            close(debug_unit)
--        end block
--
          ! Server is ready, send immediately
          language = get_language_for_file(filename)
          block
              msg = create_did_open_notification(file_uri, language, 1, content)
          end block
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> didOpen content length: ' // trim(adjustl(char(len(content))))
--            write(debug_unit, '(A)') '>>> didOpen language: ' // trim(language)
--            close(debug_unit)
--        end block
--
          call send_notification(manager%servers(server_index), msg)
      end subroutine notify_file_opened
          integer, intent(in), optional :: version
          type(lsp_message_t) :: msg
          integer :: doc_version
++        integer :: debug_unit
++
++        ! Debug logging
++        open(newunit=debug_unit, file='/tmp/fac_didchange_debug.log', status='unknown', &
++             position='append', action='write')
++        write(debug_unit, '(A,I2,A)') 'notify_file_changed called for server ', server_index, ':'
++        write(debug_unit, '(A,A)') '  URI: ', trim(filename)
++        write(debug_unit, '(A,I8)') '  Content length: ', len(content)
++        write(debug_unit, '(A)') '---'
++        close(debug_unit)
          if (server_index < 1 .or. server_index > manager%num_servers) return
          if (.not. manager%servers(server_index)%initialized) return
          end if
          call send_notification(manager%servers(server_index), msg)
--
--        ! Debug output
--        write(error_unit, '(A,A)') "[LSP DEBUG] Sent didSave for: ", trim(filename)
      end subroutine notify_file_saved
      ! Send textDocument/didClose notification
          type(lsp_message_t) :: msg
          character(len=:), allocatable :: uri
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> request_definition: START <<<'
--            close(debug_unit)
--        end block
--
          request_id = -1
          if (server_index < 1 .or. server_index > manager%num_servers) return
          if (.not. manager%servers(server_index)%initialized) return
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> request_definition: Creating URI <<<'
--            write(debug_unit, '(A)') 'Filename: ' // trim(filename)
--            close(debug_unit)
--        end block
--
--        ! Convert filename to URI (simple file:// for now)
          uri = filename_to_uri(filename)
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> request_definition: Creating request <<<'
--            write(debug_unit, '(A)') 'URI: ' // trim(uri)
--            write(debug_unit, '(A,I0,A,I0)') 'Position: line=', line, ' char=', character
--            close(debug_unit)
--        end block
--
          msg = create_definition_request(uri, line, character)
          request_id = msg%id
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> request_definition: Calling send_request <<<'
--            close(debug_unit)
--        end block
--
          call send_request(manager, server_index, msg, callback)
--
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> request_definition: DONE <<<'
--            close(debug_unit)
--        end block
      end function request_definition
      ! Request references at cursor position
          integer :: request_id
          type(lsp_message_t) :: msg
          character(len=:), allocatable :: uri
--        integer :: dbg
          request_id = -1
--        ! Debug logging
--        open(newunit=dbg, file='/tmp/fac_code_actions.log', position='append', action='write')
--        write(dbg, '(A,I0)') 'request_code_actions: server_index = ', server_index
--        write(dbg, '(A,I0)') 'request_code_actions: num_servers = ', manager%num_servers
--        if (server_index >= 1 .and. server_index <= manager%num_servers) then
--            write(dbg, '(A,L1)') 'request_code_actions: initialized = ', manager%servers(server_index)%initialized
--        end if
--        close(dbg)
--
          if (server_index < 1 .or. server_index > manager%num_servers) return
          if (.not. manager%servers(server_index)%initialized) return

src/terminal/input_handler_module.f90modified

              end if
              ch2 = achar(char_code)
--            block
--                integer :: debug_unit, ch2_code
--                ch2_code = ichar(ch2)
--                open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                write(debug_unit, '(A,I0,A)') '>>> ESC[ RECEIVED, ch2=', ch2_code, ' (' // ch2 // ')'
--                close(debug_unit)
--            end block
--
              select case(ch2)
              case('A')
                  key_str = 'up'
                  end if
              case('1')
                  ! Could be function key (F1-F9) or modified arrow/home/end
--                block
--                    integer :: debug_unit
--                    open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                    write(debug_unit, '(A)') '>>> ESC[1 SEQUENCE DETECTED <<<'
--                    close(debug_unit)
--                end block
                  ! Check next character
                  char_code = terminal_read_char()
                  if (char_code >= 0) then
                      ch3 = achar(char_code)
--                    block
--                        integer :: debug_unit
--                        open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                        write(debug_unit, '(A)') 'ch3 = ' // ch3
--                        close(debug_unit)
--                    end block
                      if (ch3 == '~') then
                          ! F1: ESC [ 1 1 ~ (alternate format)
                          key_str = 'f1'
                  end if
              case('2')
                  ! Could be F9-F12 or alternate modified keys
--                block
--                    integer :: debug_unit
--                    open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                    write(debug_unit, '(A)') '>>> ESC[2 SEQUENCE DETECTED <<<'
--                    close(debug_unit)
--                end block
                  char_code = terminal_read_char()
                  if (char_code >= 0) then
                      ch3 = achar(char_code)
--                    block
--                        integer :: debug_unit
--                        open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                        write(debug_unit, '(A)') 'ch3 = ' // ch3
--                        close(debug_unit)
--                    end block
                      if (ch3 == '0' .or. ch3 == '1' .or. ch3 == '3' .or. ch3 == '4') then
                          ! Function keys F9-F12: ESC [ 2 X ~ or ESC [ 2 X ; modifier ~
                          char_code = terminal_read_char()
                                      key_str = 'f11'
                                  case('4')
                                      key_str = 'f12'
--                                    block
--                                        integer :: debug_unit
--                                        open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--                                        write(debug_unit, '(A)') '>>> F12 KEY DETECTED IN INPUT HANDLER <<<'
--                                        write(debug_unit, '(A)') 'key_str set to: ' // trim(key_str)
--                                        close(debug_unit)
--                                    end block
                                  end select
                              else if (ch == ';') then
                                  ! Modified F9-F12: ESC [ 2 X ; modifier ~
          if (terminator == '') return
          ! Parse modifier
--        if (len_trim(modifier_seq) > 1 .and. modifier_seq(1:1) == ';') then
++        if (len_trim(modifier_seq) >= 1 .and. modifier_seq(1:1) == ';') then
--            ! Standard format: ";2" where 2 is the modifier
++            ! Standard format with leading ';': ";2" where 2 is the modifier
              if (len_trim(modifier_seq) >= 2) then
                  read(modifier_seq(2:len_trim(modifier_seq)), '(i10)', iostat=ios) modifier
              else
                  ios = -1
              end if
--            if (ios == 0) then
++        else if (len_trim(modifier_seq) >= 1 .and. &
--                select case(modifier)
++                 modifier_seq(1:1) >= '1' .and. modifier_seq(1:1) <= '9') then
--                case(2)  ! Shift
++            ! Format without leading ';' (already consumed by caller): "2" or "3" etc
--                    key_str = 'shift-'
++            read(modifier_seq(1:len_trim(modifier_seq)), '(i10)', iostat=ios) modifier
--                case(3)  ! Alt
++        else
--                    key_str = 'alt-'
++            ios = -1
--                case(4)  ! Alt+Shift
++        end if
--                    key_str = 'alt-shift-'
--                case(5)  ! Ctrl
--                    key_str = 'ctrl-'
--                case(6)  ! Ctrl+Shift
--                    key_str = 'ctrl-shift-'
--                case(7)  ! Alt+Ctrl
--                    key_str = 'alt-ctrl-'
--                case(8)  ! Alt+Shift (or Option+Shift)
--                    key_str = 'alt-shift-'
--                case(9)  ! Alt+Cmd (or Option+Cmd on macOS)
--                    key_str = 'opt-meta-'
--                case default
--                    key_str = ''
--                end select
--                ! Append the key type using the terminator character
++        if (ios == 0) then
--                select case(terminator)
++            select case(modifier)
--                case('A')
++            case(2)  ! Shift
--                    key_str = trim(key_str) // 'up'
++                key_str = 'shift-'
--                case('B')
++            case(3)  ! Alt
--                    key_str = trim(key_str) // 'down'
++                key_str = 'alt-'
--                case('C')
++            case(4)  ! Alt+Shift
--                    key_str = trim(key_str) // 'right'
++                key_str = 'alt-shift-'
--                case('D')
++            case(5)  ! Ctrl
--                    key_str = trim(key_str) // 'left'
++                key_str = 'ctrl-'
--                case('H')
++            case(6)  ! Ctrl+Shift
--                    key_str = trim(key_str) // 'home'
++                key_str = 'ctrl-shift-'
--                case('F')
++            case(7)  ! Alt+Ctrl
--                    key_str = trim(key_str) // 'end'
++                key_str = 'alt-ctrl-'
--                case('Z')
++            case(8)  ! Alt+Shift (or Option+Shift)
--                    ! Shift+Z could be ctrl-shift-z for redo
++                key_str = 'alt-shift-'
--                    if (index(key_str, 'ctrl-shift') == 1) then
++            case(9)  ! Alt+Cmd (or Option+Cmd on macOS)
--                        key_str = 'ctrl-shift-z'
++                key_str = 'opt-meta-'
--                    else
++            case default
--                        key_str = trim(key_str) // 'Z'
++                key_str = ''
--                    end if
++            end select
--                case('~')
++
--                    ! Check what special key it is based on the beginning of modifier_seq
++            ! Append the key type using the terminator character
--                    if (index(modifier_seq, ';') == 1 .and. len_trim(modifier_seq) > 1) then
++            select case(terminator)
--                        ! Already read the ;2 or ;5 etc, the key type should be before
++            case('A')
--                        key_str = trim(key_str) // 'unknown'
++                key_str = trim(key_str) // 'up'
--                    end if
++            case('B')
--                end select
++                key_str = trim(key_str) // 'down'
--            end if
++            case('C')
++                key_str = trim(key_str) // 'right'
++            case('D')
++                key_str = trim(key_str) // 'left'
++            case('H')
++                key_str = trim(key_str) // 'home'
++            case('F')
++                key_str = trim(key_str) // 'end'
++            case('Z')
++                ! Shift+Z could be ctrl-shift-z for redo
++                if (index(key_str, 'ctrl-shift') == 1) then
++                    key_str = 'ctrl-shift-z'
++                else
++                    key_str = trim(key_str) // 'Z'
++                end if
++            case('~')
++                ! Check what special key it is based on the beginning of modifier_seq
++                if (index(modifier_seq, ';') == 1 .and. len_trim(modifier_seq) > 1) then
++                    ! Already read the ;2 or ;5 etc, the key type should be before
++                    key_str = trim(key_str) // 'unknown'
++                end if
++            end select
          end if
      end subroutine handle_modified_key

src/ui/help_display_module.f90modified

          n_lines = n_lines + 7 + 2   ! PANES
          n_lines = n_lines + 10 + 2  ! GIT
          n_lines = n_lines + 5 + 2   ! FILE
--        n_lines = n_lines + 6 + 2   ! LSP
++        n_lines = n_lines + 7 + 2   ! LSP (added code actions)
          allocate(lines(n_lines))
          i = 1
          ! LSP (Language Server Protocol)
          lines(i) = "LSP (Language Server Protocol)"; i = i + 1
          lines(i) = "  ctrl-space          code completion"; i = i + 1
--        lines(i) = "  ctrl-h              hover information"; i = i + 1
++        lines(i) = "  F12/alt-g           go to definition"; i = i + 1
--        lines(i) = "  F12                 go to definition"; i = i + 1
++        lines(i) = "  shift-F12/alt-r     find all references"; i = i + 1
--        lines(i) = "  shift-F12           find all references"; i = i + 1
          lines(i) = "  alt-, (alt-comma)   jump back (navigation history)"; i = i + 1
          lines(i) = "  F2                  rename symbol"; i = i + 1
--        lines(i) = "  F4                  document symbols (outline)"; i = i + 1
++        lines(i) = "  F10/alt-.           code actions (quick fixes)"; i = i + 1
--        lines(i) = "  F6                  workspace symbols (search project)"; i = i + 1
++        lines(i) = "  F4/alt-o            document symbols (outline)"; i = i + 1
--        lines(i) = "  F8                  toggle diagnostics panel (errors)"; i = i + 1
++        lines(i) = "  F6/alt-p            workspace symbols (search project)"; i = i + 1
++        lines(i) = "  F8/alt-e            toggle diagnostics panel (errors)"; i = i + 1
          lines(i) = "  ctrl-p              command palette"; i = i + 1
          lines(i) = ""; i = i + 1

src/ui/rename_prompt_module.f90modified

          ! Show the text prompt
          call show_text_prompt(trim(prompt_text), input_text, cancelled, screen_rows)
--        ! Debug logging
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A)') '>>> RENAME PROMPT RETURNED <<<'
--            write(debug_unit, '(A,L1)') 'Cancelled: ', cancelled
--            write(debug_unit, '(A)') 'Input text: "' // trim(input_text) // '"'
--            write(debug_unit, '(A)') 'Old name: "' // trim(old_name) // '"'
--            write(debug_unit, '(A,I0)') 'Input length: ', len_trim(input_text)
--            close(debug_unit)
--        end block
--
          if (.not. cancelled) then
              if (len_trim(input_text) > 0 .and. trim(input_text) /= trim(old_name)) then
                  allocate(character(len=len_trim(input_text)) :: new_name)
                  cancelled = .true.
              end if
          end if
--
--        ! Debug logging after check
--        block
--            integer :: debug_unit
--            open(newunit=debug_unit, file='/tmp/fac_keys.log', position='append', action='write')
--            write(debug_unit, '(A,L1)') 'Final cancelled: ', cancelled
--            if (allocated(new_name)) then
--                write(debug_unit, '(A)') 'New name allocated: "' // trim(new_name) // '"'
--            else
--                write(debug_unit, '(A)') 'New name NOT allocated'
--            end if
--            close(debug_unit)
--        end block
      end subroutine show_rename_prompt
  end module rename_prompt_module

src/workspace/workspace_module.f90modified

          success = .false.
          workspace_file = trim(dir_path) // "/.fac/workspace.json"
--        ! DEBUG: Write to stderr (unit 0) so it doesn't interfere
--        write(0, '(A)') '[DEBUG SAVE] workspace_save_state called'
--        write(0, '(A)') '[DEBUG SAVE] Workspace file: ' // trim(workspace_file)
--        if (allocated(editor%tabs)) then
--            write(0, '(A,I0)') '[DEBUG SAVE] Tabs allocated, size: ', size(editor%tabs)
--            if (size(editor%tabs) > 0) then
--                write(0, '(A)') '[DEBUG SAVE] First tab filename: ' // trim(editor%tabs(1)%filename)
--            end if
--        else
--            write(0, '(A)') '[DEBUG SAVE] ERROR: Tabs not allocated!'
--        end if
--        write(0, '(A,I0)') '[DEBUG SAVE] Active tab index: ', editor%active_tab_index
--
          ! Open file for writing
          open(newunit=unit, file=workspace_file, status='replace', iostat=ios)
--        if (ios /= 0) then
++        if (ios /= 0) return
--            write(0, '(A,I0)') '[DEBUG SAVE] ERROR: Failed to open file, ios=', ios
--            return
--        end if
          ! Get current timestamp (simplified)
          call date_and_time(timestamp)
          ! Write tabs
          if (allocated(editor%tabs)) then
--            write(0, '(A,I0)') '[DEBUG SAVE] Writing ', size(editor%tabs), ' tabs'
              ws_len = len_trim(dir_path)
              do i = 1, size(editor%tabs)
                  ! Write tab start - must be on its own line for parser
          logical :: file_exists
          integer :: load_status, tab_idx, pane_count, file_unit
          character(len=20) :: value_str
--        character(len=512) :: warning_msg
--
--        ! DEBUG: Start of restoration
--        write(0, '(A)') '[DEBUG RESTORE WS] workspace_restore_state called'
--        write(0, '(A)') '[DEBUG RESTORE WS] Dir path: ' // trim(dir_path)
          success = .false.
          workspace_file = trim(dir_path) // "/.fac/workspace.json"
--        write(0, '(A)') '[DEBUG RESTORE WS] Workspace file: ' // trim(workspace_file)
--
          ! Open workspace file
          open(newunit=unit, file=workspace_file, status='old', iostat=ios)
          if (ios /= 0) then
--            ! Workspace file doesn't exist or can't be read (Phase 7: error handling)
++            ! Workspace file doesn't exist or can't be read - initialize new workspace
--            write(0, '(A,I0)') '[DEBUG RESTORE WS] ERROR: Failed to open workspace.json, ios=', ios
--            warning_msg = "Warning: Could not open workspace.json - using empty workspace"
--            call terminal_write(trim(warning_msg))
--            ! Brief pause so user can see the warning
--            call execute_command_line("sleep 1.0", wait=.true.)
--            ! Initialize a new workspace instead
              call workspace_init(dir_path, success)
              return
          end if
--        write(0, '(A)') '[DEBUG RESTORE WS] Workspace file opened successfully'
--
          ! Parse JSON line by line (simple parser for our specific format)
          in_tabs_array = .false.
          reading_tab = .false.
                          end if
                          if (.not. file_exists) then
--                            ! File doesn't exist - show warning and skip this tab
++                            ! File doesn't exist - skip this tab silently
--                            warning_msg = "Warning: File not found (skipping): " // trim(full_path)
--                            call terminal_write(trim(warning_msg))
--                            ! Brief pause so user can see the warning
--                            call execute_command_line("sleep 0.8", wait=.true.)
--                            ! Continue to next tab without creating this one
                              reading_pane = .false.
                              cycle
                          end if
                          ! Create tab
--                        write(0, '(A)') '[DEBUG RESTORE WS] Creating tab for file: ' // trim(full_path)
                          call create_tab(editor, trim(full_path))
                          tab_idx = editor%active_tab_index
                          ! Set orphan flag and load file
                          if (allocated(editor%tabs) .and. tab_idx > 0) then
--                            write(0, '(A,I0)') '[DEBUG RESTORE WS] Tab created successfully, index: ', tab_idx
                              editor%tabs(tab_idx)%is_orphan = is_orphan
--
                              call buffer_load_file(editor%tabs(tab_idx)%buffer, trim(full_path), load_status)
--                            write(0, '(A,I0)') '[DEBUG RESTORE WS] Buffer loaded, status: ', load_status
                              ! Send LSP didOpen notification for restored tabs
                              if (load_status == 0 .and. editor%tabs(tab_idx)%num_lsp_servers > 0) then
          close(unit)
--        write(0, '(A)') '[DEBUG RESTORE WS] Finished parsing JSON'
--
          ! Clamp active_tab_index to valid range
          if (allocated(editor%tabs)) then
--            write(0, '(A,I0)') '[DEBUG RESTORE WS] Tabs allocated, count: ', size(editor%tabs)
              if (size(editor%tabs) > 0) then
                  if (editor%active_tab_index > size(editor%tabs)) then
                      editor%active_tab_index = size(editor%tabs)
                      editor%active_tab_index = 1
                  end if
              else
--                write(0, '(A)') '[DEBUG RESTORE WS] No tabs in array!'
                  editor%active_tab_index = 0  ! No tabs
              end if
          else
--            write(0, '(A)') '[DEBUG RESTORE WS] Tabs NOT allocated!'
              editor%active_tab_index = 0  ! No tabs
          end if
--        write(0, '(A,I0)') '[DEBUG RESTORE WS] Final active_tab_index: ', editor%active_tab_index
--
          ! Sync the active pane to editor state so status bar shows correct filename
          if (allocated(editor%tabs) .and. editor%active_tab_index > 0) then
              if (editor%active_tab_index <= size(editor%tabs)) then
                      if (editor%tabs(editor%active_tab_index)%active_pane_index > 0 .and. &
                          editor%tabs(editor%active_tab_index)%active_pane_index <= &
                          size(editor%tabs(editor%active_tab_index)%panes)) then
--                        write(0, '(A)') '[DEBUG RESTORE WS] Syncing active pane to editor'
                          call sync_pane_to_editor(editor, editor%active_tab_index, &
                                                  editor%tabs(editor%active_tab_index)%active_pane_index)
                      end if
          end if
          success = .true.
--        write(0, '(A)') '[DEBUG RESTORE WS] workspace_restore_state completed successfully'
      end subroutine workspace_restore_state
      !> Track workspace in recents (helper function)

tests/scratch_files/calculator.pymodified


 - Formatting: Shift+Alt+F to format
 """
 
+
 def add(x, y):
     """Add two numbers together."""
     return x + y

tests/scratch_files/long_errors.pymodified


 # Test file with errors that generate long diagnostic messages
 
+from typing import Callable, Dict, List, Optional, Union
 
 # Type mismatch with long type names
 def process_data(

`@@ -11,6 +11,7 @@` Test these features:
11	- Formatting: Shift+Alt+F to format	11	- Formatting: Shift+Alt+F to format
12	"""	12	"""
13		13
		14	+
14	def add(x, y):	15	def add(x, y):
15	"""Add two numbers together."""	16	"""Add two numbers together."""
16	return x + y	17	return x + y

`@@ -1,6 +1,6 @@`
1	# Test file with errors that generate long diagnostic messages	1	# Test file with errors that generate long diagnostic messages
2		2
3	-from typing import Dict, List, Optional, Union, Callable	3	+from typing import Callable, Dict, List, Optional, Union
4		4
5	# Type mismatch with long type names	5	# Type mismatch with long type names
6	def process_data(	6	def process_data(