First completion level is working (LSP connected)

2026-05-28 18:28:59 +02:00
parent 8eeef59a98
commit a8b2960eb4
27 changed files with 5167 additions and 335 deletions
@@ -0,0 +1,555 @@
+//
+// Created by Giorgio on 25/05/2026.
+//
+
+#include "../include/completion.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/syslimits.h>
+
+#include "include/append_buffer.h"
+#include "include/cJSON.h"
+#include "include/data.h"
+#include "include/lsp_ui.h"
+#include "include/terminal.h"
+#include "include/utils.h"
+
+void createContextBuffer(const int x, const int y, const char* text)
+{
+    E.context_buffers = bAlloc(sizeof(ContextBuffer));
+    ContextBuffer* buffer = E.context_buffers;
+    buffer->editor_x = x;
+    buffer->editor_y = y;
+    buffer->height = 1;
+    buffer->rows = bAlloc(sizeof(struct row));
+    if (!buffer->rows) return;
+    buffer->rows[0].chars = strdup(text);
+    buffer->rows[0].size = strlen(text);
+    buffer->width = strlen(text);
+}
+
+static void lsp_send(int fd, const char* json)
+{
+    int body_len = strlen(json);
+    char header[1024];
+    int header_len = snprintf(header, sizeof(header),
+                              "Content-Length: %d\r\n\r\n", body_len);
+
+    // Write header + body atomically in two writes, no dprintf mixing
+    write(fd, header, header_len);
+    write(fd, json, body_len);
+
+    // Log to stderr for debugging
+    fprintf(stderr, "[LSP →] Content-Length: %d | %s\n", body_len, json);
+    fflush(stderr);
+}
+
+static int lsp_uri_to_buffer_id(const char* uri)
+{
+    const char *path = uri;
+    if (strncmp(uri, "file://", 7) == 0)
+        path = uri + 7;
+    // path is now "/absolute/path" — realpath output matches this directly
+
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        if (E.buffers[i].filename == NULL) continue;
+        char abs[PATH_MAX];
+        realpath(E.buffers[i].filename, abs);
+        fprintf(stderr, "[URI MATCH] comparing '%s' vs '%s'\n", abs, path);
+        if (strcmp(abs, path) == 0)
+            return E.buffers[i].buffer_id;
+    }
+    return -1;
+}
+
+static char* lsp_recv(int fd)
+{
+    char header[1024];
+    int content_length = 0;
+
+    while (1)
+    {
+        int i = 0;
+        char c;
+        int n;
+        // Read until \n
+        while ((n = read(fd, &c, 1)) == 1 && c != '\n')
+            header[i++] = c;
+        if (n <= 0) return NULL;
+        header[i] = '\0';
+        // Strip \r explicitly
+        while (i > 0 && (header[i - 1] == '\r' || header[i - 1] == ' '))
+            header[--i] = '\0';
+        if (i == 0) break; // blank line = end of headers
+        if (strncmp(header, "Content-Length: ", 16) == 0)
+            content_length = atoi(header + 16);
+    }
+
+    if (content_length == 0) return NULL;
+
+    char* body = bAlloc(content_length + 1);
+    int total = 0;
+    while (total < content_length)
+    {
+        int n = read(fd, body + total, content_length - total);
+        if (n <= 0)
+        {
+            bFree(body);
+            return NULL;
+        }
+        total += n;
+    }
+    body[content_length] = '\0';
+    return body;
+}
+
+static void lsp_dispatch(LspClient* lsp, const char* json)
+{
+    if (!json) return;
+
+    cJSON* root = cJSON_Parse(json);
+    if (!root)
+    {
+        fprintf(stderr, "[LSP ←] Failed to parse JSON: %.120s\n", json);
+        return;
+    }
+
+    cJSON* method = cJSON_GetObjectItem(root, "method");
+    cJSON* id = cJSON_GetObjectItem(root, "id");
+    cJSON* result = cJSON_GetObjectItem(root, "result");
+    cJSON* error = cJSON_GetObjectItem(root, "error");
+
+    // ── Error response ────────────────────────────────────────────────────────
+    if (error)
+    {
+        cJSON* msg = cJSON_GetObjectItem(error, "message");
+        fprintf(stderr, "[LSP ←] ERROR: %s\n",
+                msg ? msg->valuestring : "(no message)");
+        cJSON_Delete(root);
+        return;
+    }
+
+    // ── Notification (no id, has method) ─────────────────────────────────────
+    if (method && !id)
+    {
+        const char* m = method->valuestring;
+        fprintf(stderr, "[LSP ←] NOTIF: %s\n", m);
+
+        if (strcmp(m, "textDocument/publishDiagnostics") == 0)
+        {
+            // Find which buffer this diagnostic belongs to
+            cJSON* params = cJSON_GetObjectItem(root, "params");
+            cJSON* uri = cJSON_GetObjectItem(params, "uri");
+            int buf_id = lsp_uri_to_buffer_id(
+                uri ? uri->valuestring : "");
+
+            fprintf(stderr, "[LSP ←] Diagnostics for buffer %d\n", buf_id);
+
+            pthread_mutex_lock(&lsp->lock);
+            lspParseDiagnostics(json, &E.lsp_diagnostics, buf_id);
+            pthread_mutex_unlock(&lsp->lock);
+            write(lsp->wake_pipe[1], "d", 1);
+        }
+
+        else if (strcmp(m, "window/logMessage") == 0)
+        {
+            cJSON* params = cJSON_GetObjectItem(root, "params");
+            cJSON* message = cJSON_GetObjectItem(params, "message");
+            fprintf(stderr, "[LSP ←] LOG: %s\n",
+                    message ? message->valuestring : "");
+        }
+        E.lsp_client->completion_just_arrived = 1;
+
+
+        cJSON_Delete(root);
+        return;
+    }
+
+    // ── Response (has id + result) ────────────────────────────────────────────
+    if (id && result)
+    {
+        int response_id = id->valueint;
+        fprintf(stderr, "[LSP ←] RESPONSE id=%d\n", response_id);
+
+        // initialize response → send initialized + mark ready
+        if (lsp->state == LSP_INITIALIZING)
+        {
+            fprintf(stderr, "[LSP ←] Initialize OK, sending initialized\n");
+            lsp_send(lsp->write_fd,
+                     "{\"jsonrpc\":\"2.0\",\"method\":\"initialized\",\"params\":{}}");
+
+            pthread_mutex_lock(&lsp->lock);
+            lsp->state = LSP_READY;
+            pthread_cond_signal(&lsp->ready_cond);
+            pthread_mutex_unlock(&lsp->lock);
+            E.lsp_client->completion_just_arrived = 1;
+
+            cJSON_Delete(root);
+            return;
+        }
+
+        // completion response → parse items and show popup
+        cJSON* items = cJSON_GetObjectItem(result, "items");
+        if (items && cJSON_IsArray(items))
+        {
+            int count = cJSON_GetArraySize(items);
+            fprintf(stderr, "[LSP ←] Completion: %d items\n", count);
+
+            // Print each item to stderr for debugging
+            cJSON* item;
+            int i = 0;
+            cJSON_ArrayForEach(item, items)
+            {
+                cJSON* label = cJSON_GetObjectItem(item, "label");
+                cJSON* detail = cJSON_GetObjectItem(item, "detail");
+                cJSON* kind = cJSON_GetObjectItem(item, "kind");
+                fprintf(stderr, "  [%d] kind=%-2d  %-40s  %s\n",
+                        i++,
+                        kind ? kind->valueint : 0,
+                        label ? label->valuestring : "(no label)",
+                        detail ? detail->valuestring : "");
+                if (i >= 10)
+                {
+                    fprintf(stderr, "  ... (%d more)\n", count - 10);
+                    break;
+                }
+            }
+
+            pthread_mutex_lock(&lsp->lock);
+            lspParseCompletion(json, &E.lsp_completion,
+                               lsp->completion_cursor_x,
+                               lsp->completion_cursor_y);
+            pthread_mutex_unlock(&lsp->lock);
+            E.lsp_client->completion_just_arrived = 1;
+
+            fprintf(stderr, "[POPUP] visible=%d count=%d origin=(%d,%d)\n",
+                    E.lsp_completion.visible,
+                    E.lsp_completion.count,
+                    E.lsp_completion.origin_x,
+                    E.lsp_completion.origin_y);
+            write(lsp->wake_pipe[1], "c", 1);
+
+            cJSON_Delete(root);
+            return;
+        }
+
+        // definition response → jump to location
+        cJSON* uri_item = cJSON_GetObjectItem(result, "uri");
+        if (uri_item)
+        {
+            cJSON* range = cJSON_GetObjectItem(result, "range");
+            cJSON* start = cJSON_GetObjectItem(range, "start");
+            int line = cJSON_GetObjectItem(start, "line")->valueint;
+            int col = cJSON_GetObjectItem(start, "character")->valueint;
+            fprintf(stderr, "[LSP ←] Definition: %s:%d:%d\n",
+                    uri_item->valuestring, line, col);
+            E.lsp_client->completion_just_arrived = 1;
+
+            // TODO: jump to that location
+            cJSON_Delete(root);
+            return;
+        }
+
+        fprintf(stderr, "[LSP ←] Unhandled response id=%d: %.80s\n",
+                response_id, json);
+    }
+
+    cJSON_Delete(root);
+}
+
+static void* lsp_reader(void* arg)
+{
+    LspClient* lsp = (LspClient*)arg;
+    while (lsp->state != LSP_SHUTDOWN)
+    {
+        char* msg = lsp_recv(lsp->read_fd);
+        if (!msg) break; // ← pipe closed or error, exit cleanly
+        lsp_dispatch(lsp, msg);
+        bFree(msg);
+    }
+    return NULL;
+}
+
+// ─── lifecycle ───────────────────────────────────────────────────────────────
+
+int lspStart(LspClient* lsp, const char* project_root)
+{
+    int to_clangd[2], from_clangd[2];
+    pipe(to_clangd);
+    pipe(from_clangd);
+
+    pipe(lsp->wake_pipe);
+
+    lsp->pid = fork();
+    if (lsp->pid == 0)
+    {
+        // Child: become clangd
+        dup2(to_clangd[0], STDIN_FILENO);
+        dup2(from_clangd[1], STDOUT_FILENO);
+        close(to_clangd[1]);
+        close(from_clangd[0]);
+        execlp("clangd", "clangd", "--log=error", "--completion-style=detailed", NULL);
+        _exit(1); // clangd not found
+    }
+
+    close(to_clangd[0]);
+    close(from_clangd[1]);
+    lsp->write_fd = to_clangd[1];
+    lsp->read_fd = from_clangd[0];
+    lsp->next_id = 1;
+    lsp->state = LSP_INITIALIZING;
+    pthread_mutex_init(&lsp->lock, NULL);
+
+    // Send initialize
+    char buf[1024];
+    snprintf(buf, sizeof(buf),
+             "{\"jsonrpc\":\"2.0\",\"id\":%d,\"method\":\"initialize\","
+             "\"params\":{\"processId\":%d,\"rootUri\":\"file://%s\","
+             "\"capabilities\":{"
+             "\"textDocument\":{"
+             "\"completion\":{\"completionItem\":{\"snippetSupport\":false}},"
+             "\"hover\":{},"
+             "\"definition\":{},"
+             "\"publishDiagnostics\":{}"
+             "}"
+             "}}}",
+             lsp->next_id++, getpid(), project_root);
+
+    pthread_mutex_init(&lsp->lock, NULL);
+    pthread_cond_init(&lsp->ready_cond, NULL);
+    pthread_create(&lsp->reader_thread, NULL, lsp_reader, lsp);
+
+
+    lsp_send(lsp->write_fd, buf);
+
+    pthread_mutex_lock(&lsp->lock);
+    while (lsp->state != LSP_READY)
+        pthread_cond_wait(&lsp->ready_cond, &lsp->lock);
+    pthread_mutex_unlock(&lsp->lock);
+    return 0;
+}
+
+// ─── document sync ───────────────────────────────────────────────────────────
+
+// Build the full buffer text into a bAlloc'd string
+static char* buffer_to_text(struct buffer_t* buf)
+{
+    int total = 0;
+    for (int i = 0; i < buf->numrows; i++)
+        total += buf->row[i].size + 1; // +1 for \n
+    char* text = bAlloc(total + 1);
+    char* p = text;
+    for (int i = 0; i < buf->numrows; i++)
+    {
+        memcpy(p, buf->row[i].chars, buf->row[i].size);
+        p += buf->row[i].size;
+        *p++ = '\n';
+    }
+    *p = '\0';
+    return text;
+}
+
+void lspDidOpen(LspClient* lsp, struct buffer_t* buf)
+{
+    if (lsp->state != LSP_READY || buf->b_lsp_open) return;
+
+    char abs[PATH_MAX];
+    realpath(buf->filename, abs);
+    char uri[PATH_MAX + 8];
+    snprintf(uri, sizeof(uri), "file://%s", abs);
+
+    const char* lang = "c";
+    if (strstr(buf->filename, ".cpp") || strstr(buf->filename, ".cc"))
+        lang = "cpp";
+
+    char* raw = buffer_to_text(buf);
+
+    // Let cJSON handle ALL escaping — don't touch the text yourself
+    cJSON* root = cJSON_CreateObject();
+    cJSON* params = cJSON_CreateObject();
+    cJSON* td = cJSON_CreateObject();
+
+    cJSON_AddStringToObject(root, "jsonrpc", "2.0");
+    cJSON_AddStringToObject(root, "method", "textDocument/didOpen");
+
+    cJSON_AddStringToObject(td, "uri", uri);
+    cJSON_AddStringToObject(td, "languageId", lang);
+    cJSON_AddNumberToObject(td, "version", 1);
+    cJSON_AddStringToObject(td, "text", raw); // cJSON escapes this
+
+    cJSON_AddItemToObject(params, "textDocument", td);
+    cJSON_AddItemToObject(root, "params", params);
+
+    char* msg = cJSON_PrintUnformatted(root);
+    lsp_send(lsp->write_fd, msg);
+
+    bFree(msg);
+    bFree(raw);
+    cJSON_Delete(root);
+    buf->b_lsp_open = 1;
+}
+
+void lspDidChange(LspClient* lsp, struct buffer_t* buf)
+{
+    if (lsp->state != LSP_READY || !buf->b_lsp_open) return;
+
+    char abs[PATH_MAX];
+    realpath(buf->filename, abs);
+    char uri[PATH_MAX + 8];
+    snprintf(uri, sizeof(uri), "file://%s", abs);
+
+    char* raw = buffer_to_text(buf);
+
+    cJSON* root = cJSON_CreateObject();
+    cJSON* params = cJSON_CreateObject();
+    cJSON* td = cJSON_CreateObject();
+    cJSON* changes = cJSON_CreateArray();
+    cJSON* change = cJSON_CreateObject();
+
+    cJSON_AddStringToObject(root, "jsonrpc", "2.0");
+    cJSON_AddStringToObject(root, "method", "textDocument/didChange");
+
+    cJSON_AddStringToObject(td, "uri", uri);
+    cJSON_AddNumberToObject(td, "version", buf->dirty);
+
+    cJSON_AddStringToObject(change, "text", raw); // full content sync
+    cJSON_AddItemToArray(changes, change);
+
+    cJSON_AddItemToObject(params, "textDocument", td);
+    cJSON_AddItemToObject(params, "contentChanges", changes);
+    cJSON_AddItemToObject(root, "params", params);
+
+    char* msg = cJSON_PrintUnformatted(root);
+    lsp_send(lsp->write_fd, msg);
+
+    bFree(msg);
+    bFree(raw);
+    cJSON_Delete(root);
+}
+
+void lspDidClose(LspClient* lsp, struct buffer_t* buf)
+{
+    char abs[PATH_MAX];
+    realpath(buf->filename, abs);
+    char uri[PATH_MAX + 8];
+    snprintf(uri, sizeof(uri), "file://%s", abs);
+
+    cJSON* root = cJSON_CreateObject();
+    cJSON* params = cJSON_CreateObject();
+    cJSON* td = cJSON_CreateObject();
+    cJSON_AddStringToObject(root, "jsonrpc", "2.0");
+    cJSON_AddStringToObject(root, "method", "textDocument/didClose");
+    cJSON_AddStringToObject(td, "uri", uri); // ← fixed
+    cJSON_AddItemToObject(params, "textDocument", td);
+    cJSON_AddItemToObject(root, "params", params);
+    char* msg = cJSON_PrintUnformatted(root);
+    lsp_send(lsp->write_fd, msg);
+    bFree(msg);
+    cJSON_Delete(root);
+    buf->b_lsp_open = 0;
+}
+
+// ─── requests ────────────────────────────────────────────────────────────────
+
+void lspRequestCompletion(LspClient* lsp, struct buffer_t* buf,
+                          int line, int col,
+                          int screen_x, int screen_y)
+{
+    if (lsp->state != LSP_READY) return;
+    lsp->completion_cursor_x = screen_x; // ← add
+    lsp->completion_cursor_y = screen_y;
+
+    appDebug("LSP REQUEST COMP");
+
+    char* msg;
+    char abs[PATH_MAX];
+    realpath(buf->filename, abs);
+    char uri[PATH_MAX + 8];
+    snprintf(uri, sizeof(uri), "file://%s", abs);
+
+    cJSON* req = cJSON_CreateObject();
+    cJSON* params = cJSON_CreateObject();
+    cJSON* td = cJSON_CreateObject();
+    cJSON* position = cJSON_CreateObject();
+
+    cJSON_AddStringToObject(req, "jsonrpc", "2.0");
+    cJSON_AddNumberToObject(req, "id", lsp->next_id++);
+    cJSON_AddStringToObject(req, "method", "textDocument/completion");
+
+    cJSON_AddStringToObject(td, "uri", uri);
+
+    cJSON_AddNumberToObject(position, "line", line);
+    cJSON_AddNumberToObject(position, "character", col);
+    cJSON_AddItemToObject(params, "position", position);
+
+    cJSON_AddItemToObject(params, "textDocument", td);
+    cJSON_AddItemToObject(req, "params", params);
+
+    msg = cJSON_PrintUnformatted(req);
+    lsp_send(lsp->write_fd, msg);
+    E.lsp_client->completion_requested = 1;
+    cJSON_Delete(req);
+    bFree(msg);
+}
+
+void lspRequestDefinition(LspClient* lsp, struct buffer_t* buf, int line, int col)
+{
+    if (lsp->state != LSP_READY) return;
+    char* msg;
+    asprintf(&msg,
+             "{\"jsonrpc\":\"2.0\",\"id\":%d,\"method\":\"textDocument/definition\","
+             "\"params\":{\"textDocument\":{\"uri\":\"file://%s\"},"
+             "\"position\":{\"line\":%d,\"character\":%d}}}",
+             lsp->next_id++, buf->filename, line, col);
+    lsp_send(lsp->write_fd, msg);
+    bFree(msg);
+}
+
+void lspShutdown(LspClient* lsp)
+{
+    if (!lsp || lsp->state == LSP_SHUTDOWN) return;
+
+    lsp->state = LSP_SHUTDOWN;
+
+    // 1. Send shutdown request (clangd expects this before exit)
+    cJSON* req = cJSON_CreateObject();
+    cJSON_AddStringToObject(req, "jsonrpc", "2.0");
+    cJSON_AddNumberToObject(req, "id", lsp->next_id++);
+    cJSON_AddStringToObject(req, "method", "shutdown");
+    cJSON_AddNullToObject(req, "params");
+    char* msg = cJSON_PrintUnformatted(req);
+    lsp_send(lsp->write_fd, msg);
+    bFree(msg);
+    cJSON_Delete(req);
+
+    // 2. Wait briefly for the shutdown response
+    // (don't block forever — clangd has 2s to reply)
+    struct timeval tv = {.tv_sec = 2, .tv_usec = 0};
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(lsp->read_fd, &fds);
+    if (select(lsp->read_fd + 1, &fds, NULL, NULL, &tv) > 0)
+    {
+        char* resp = lsp_recv(lsp->read_fd);
+        bFree(resp);
+    }
+
+    // 3. Send exit notification
+    lsp_send(lsp->write_fd,
+             "{\"jsonrpc\":\"2.0\",\"method\":\"exit\",\"params\":null}");
+
+    // 4. Close pipes — this signals the reader thread to stop
+    close(lsp->write_fd);
+    close(lsp->read_fd);
+
+    // 5. Wait for reader thread to finish
+    pthread_join(lsp->reader_thread, NULL);
+    pthread_mutex_destroy(&lsp->lock);
+
+    // 6. Reap the clangd process
+    waitpid(lsp->pid, NULL, 0);
+
+    bFree(lsp);
+}