Program.cs

using System.Diagnostics;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;

namespace CSharpLspAdapter;

/// <summary>
/// LSP adapter/proxy for csharp-ls that intercepts and handles
/// protocol methods not supported by Claude Code's LSP client.
/// </summary>
public static class Program
{
    private static readonly bool DebugMode = Environment.GetEnvironmentVariable("LSP_ADAPTER_DEBUG") == "1";
    private static readonly string? SolutionPath = Environment.GetEnvironmentVariable("LSP_SOLUTION_PATH");
    private static readonly string LogPath = Path.Combine(Path.GetTempPath(), "csharp-lsp-adapter.log");
    private static readonly object LogLock = new();

    private static Process? _serverProcess;
    private static readonly SemaphoreSlim ClientWriteLock = new(1, 1);
    private static readonly SemaphoreSlim ServerWriteLock = new(1, 1);

    public static async Task<int> Main(string[] args)
    {
        try
        {
            var csharpLsPath = FindCSharpLs();
            if (csharpLsPath == null)
            {
                await Console.Error.WriteLineAsync("Error: csharp-ls not found. Install it with: dotnet tool install -g csharp-ls").ConfigureAwait(false);
                return 1;
            }

            LogDebug($"=== Adapter starting ===");
            LogDebug($"Log file: {LogPath}");
            LogDebug($"csharp-ls path: {csharpLsPath}");
            LogDebug($"Solution path: {SolutionPath ?? "(auto-detect)"}");

            _serverProcess = StartServer(csharpLsPath, args);

            using var cts = new CancellationTokenSource();

            var clientToServer = ProcessClientMessages(_serverProcess, cts.Token);
            var serverToClient = ProcessServerMessages(_serverProcess, cts.Token);

            await Task.WhenAny(clientToServer, serverToClient).ConfigureAwait(false);

            await cts.CancelAsync().ConfigureAwait(false);

            return 0;
        }
        catch (Exception ex)
        {
            await Console.Error.WriteLineAsync($"Adapter error: {ex.Message}").ConfigureAwait(false);
            return 1;
        }
        finally
        {
            if (_serverProcess is { HasExited: false })
            {
                _serverProcess.Kill();
            }
        }
    }

    private static string? FindCSharpLs()
    {
        // Check common locations
        var candidates = new[]
        {
            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".dotnet", "tools", "csharp-ls"),
            "/usr/local/bin/csharp-ls",
            "/usr/bin/csharp-ls",
        };

        foreach (var path in candidates)
        {
            if (File.Exists(path))
                return path;
        }

        // Try to find in PATH using 'which' on Unix or 'where' on Windows
        try
        {
            var whichCommand = OperatingSystem.IsWindows() ? "where" : "which";
            var psi = new ProcessStartInfo(whichCommand, "csharp-ls")
            {
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };

            using var process = Process.Start(psi);
            if (process != null)
            {
                var output = process.StandardOutput.ReadToEnd().Trim();
                process.WaitForExit();
                if (process.ExitCode == 0 && !string.IsNullOrEmpty(output))
                {
                    return output.Split('\n')[0].Trim();
                }
            }
        }
        catch
        {
            // Ignore errors from which/where
        }

        return null;
    }

    private static Process StartServer(string path, string[] args)
    {
        var psi = new ProcessStartInfo(path)
        {
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };

        foreach (var arg in args)
        {
            psi.ArgumentList.Add(arg);
        }

        var process = Process.Start(psi)
            ?? throw new InvalidOperationException("Failed to start csharp-ls");

        // Forward stderr
        _ = Task.Run(async () =>
        {
            while (!process.HasExited)
            {
                var line = await process.StandardError.ReadLineAsync().ConfigureAwait(false);
                if (line != null)
                {
                    LogDebug($"[csharp-ls stderr] {line}");
                }
            }
        });

        return process;
    }

    private static async Task ProcessClientMessages(Process server, CancellationToken ct)
    {
        LogDebug("ProcessClientMessages started");
        await using var reader = Console.OpenStandardInput();
        await using var writer = server.StandardInput.BaseStream;

        while (!ct.IsCancellationRequested && !server.HasExited)
        {
            LogDebug("Waiting for client message...");
            var message = await ReadLspMessage(reader, "client", ct).ConfigureAwait(false);
            if (message == null)
            {
                LogDebug("Client stream ended (null message)");
                break;
            }

            // Transform client messages if needed (e.g., enable capabilities)
            message = TransformClientMessage(message);

            LogDebug($"Client → Server: {TruncateForLog(message)}");

            // Forward to server (with lock since ProcessServerMessages also writes to server)
            await WriteLspMessageWithLock(writer, message, ServerWriteLock, ct).ConfigureAwait(false);
            LogDebug("Message forwarded to server");
        }
        LogDebug("ProcessClientMessages ended");
    }

    private static async Task ProcessServerMessages(Process server, CancellationToken ct)
    {
        LogDebug("ProcessServerMessages started");
        await using var reader = server.StandardOutput.BaseStream;
        await using var clientWriter = Console.OpenStandardOutput();
        var serverWriter = server.StandardInput.BaseStream;  // For responses back to server

        while (!ct.IsCancellationRequested && !server.HasExited)
        {
            LogDebug("Waiting for server message...");
            var message = await ReadLspMessage(reader, "server", ct).ConfigureAwait(false);
            if (message == null)
            {
                LogDebug("Server stream ended (null message)");
                break;
            }

            LogDebug($"Server → Client: {TruncateForLog(message)}");

            // Check if this is a request we need to intercept
            // Responses go BACK TO SERVER (not to client!)
            if (await TryHandleServerRequest(message, serverWriter, ct).ConfigureAwait(false))
            {
                LogDebug("Message intercepted and handled (response sent to server)");
                continue; // We handled it, don't forward
            }

            // Forward notifications/responses to client
            await WriteLspMessageWithLock(clientWriter, message, ClientWriteLock, ct).ConfigureAwait(false);
            LogDebug("Message forwarded to client");
        }
        LogDebug("ProcessServerMessages ended");
    }

    private static string TransformClientMessage(string message)
    {
        try
        {
            var json = JsonNode.Parse(message);
            if (json == null) return message;

            var method = json["method"]?.GetValue<string>();

            // Normalize all file URIs in the message to RFC 8089 format
            // This fixes Windows URI inconsistencies in Claude Code's LSP client
            var modified = NormalizeUrisInNode(json);

            if (method == "initialize")
            {
                // Enable workspace/configuration support so csharp-ls will request config
                var capabilities = json["params"]?["capabilities"];
                if (capabilities != null)
                {
                    var workspace = capabilities["workspace"];
                    if (workspace != null)
                    {
                        workspace["configuration"] = true;
                        LogDebug("Modified initialize: enabled workspace.configuration=true");
                    }
                    else
                    {
                        // Create workspace object if it doesn't exist
                        capabilities["workspace"] = new JsonObject { ["configuration"] = true };
                        LogDebug("Modified initialize: created workspace with configuration=true");
                    }
                }
                return json.ToJsonString();
            }

            // Return modified message if URIs were normalized
            if (modified)
            {
                return json.ToJsonString();
            }
        }
        catch (JsonException ex)
        {
            LogDebug($"TransformClientMessage parse error: {ex.Message}");
        }
        return message;
    }

    /// <summary>
    /// Normalizes file URIs in a JSON node to RFC 8089 compliant format.
    /// Converts Windows-style URIs like "file://C:\path" to "file:///C:/path".
    /// </summary>
    private static bool NormalizeUrisInNode(JsonNode? node)
    {
        if (node == null) return false;

        var modified = false;

        switch (node)
        {
            case JsonObject obj:
                var keysToProcess = obj.Select(kvp => kvp.Key).ToList();
                foreach (var key in keysToProcess)
                {
                    var value = obj[key];

                    // Check if this is a URI field that needs normalization
                    if (key == "uri" || key == "rootUri" || key == "scopeUri")
                    {
                        if (value is JsonValue jsonValue && jsonValue.TryGetValue<string>(out var uriStr))
                        {
                            var normalized = NormalizeFileUri(uriStr);
                            if (normalized != uriStr)
                            {
                                obj[key] = normalized;
                                LogDebug($"Normalized URI: {uriStr} → {normalized}");
                                modified = true;
                            }
                        }
                    }
                    else
                    {
                        // Recursively process nested objects/arrays
                        if (NormalizeUrisInNode(value))
                        {
                            modified = true;
                        }
                    }
                }
                break;

            case JsonArray arr:
                foreach (var item in arr)
                {
                    if (NormalizeUrisInNode(item))
                    {
                        modified = true;
                    }
                }
                break;
        }

        return modified;
    }

    /// <summary>
    /// Normalizes a file URI to RFC 8089 compliant format.
    /// Converts "file://C:\path" or "file://C:/path" to "file:///C:/path".
    /// </summary>
    private static string NormalizeFileUri(string uri)
    {
        if (string.IsNullOrEmpty(uri)) return uri;

        // Only process file:// URIs
        if (!uri.StartsWith("file://", StringComparison.OrdinalIgnoreCase))
            return uri;

        // Already in correct format with triple slash
        if (uri.StartsWith("file:///", StringComparison.OrdinalIgnoreCase))
        {
            // Still need to normalize backslashes to forward slashes
            var pathPart = uri.Substring(8); // After "file:///"
            var normalizedPath = pathPart.Replace("\\", "/");
            if (normalizedPath != pathPart)
            {
                return "file:///" + normalizedPath;
            }
            return uri;
        }

        // Handle file:// (only 2 slashes) - needs to become file:///
        var path = uri.Substring(7); // After "file://"

        // Normalize backslashes to forward slashes
        path = path.Replace("\\", "/");

        return "file:///" + path;
    }

    private static async Task<bool> TryHandleServerRequest(string message, Stream writer, CancellationToken ct)
    {
        try
        {
            var json = JsonNode.Parse(message);
            if (json == null) return false;

            var method = json["method"]?.GetValue<string>();
            var id = json["id"];

            // Only intercept requests (have id and method)
            if (id == null || method == null) return false;

            string? response = method switch
            {
                "workspace/configuration" => HandleWorkspaceConfiguration(json, id),
                "client/registerCapability" => HandleRegisterCapability(id),
                "window/workDoneProgress/create" => HandleWorkDoneProgressCreate(id),
                _ => null
            };

            if (response != null)
            {
                LogDebug($"Intercepted {method}, responding: {response}");
                await WriteLspMessageWithLock(writer, response, ServerWriteLock, ct).ConfigureAwait(false);
                return true;
            }
        }
        catch (JsonException ex)
        {
            LogDebug($"Failed to parse message: {ex.Message}");
        }

        return false;
    }

    private static string HandleWorkspaceConfiguration(JsonNode request, JsonNode id)
    {
        var items = request["params"]?["items"]?.AsArray();
        var results = new JsonArray();

        if (items != null)
        {
            foreach (var item in items)
            {
                var section = item?["section"]?.GetValue<string>();
                if (section == "csharp")
                {
                    var config = new JsonObject();
                    if (!string.IsNullOrEmpty(SolutionPath))
                    {
                        config["solution"] = SolutionPath;
                    }
                    results.Add(config);
                }
                else
                {
                    results.Add(new JsonObject());
                }
            }
        }

        return CreateResponse(id, results);
    }

    private static string HandleRegisterCapability(JsonNode id)
    {
        return CreateResponse(id, null);
    }

    private static string HandleWorkDoneProgressCreate(JsonNode id)
    {
        return CreateResponse(id, null);
    }

    private static string CreateResponse(JsonNode id, JsonNode? result)
    {
        var response = new JsonObject
        {
            ["jsonrpc"] = "2.0",
            ["id"] = id.DeepClone()
        };

        if (result != null)
        {
            response["result"] = result;
        }
        else
        {
            response["result"] = null;
        }

        return response.ToJsonString();
    }

    private static async Task<string?> ReadLspMessage(Stream stream, string source, CancellationToken ct)
    {
        var headers = new Dictionary<string, string>();
        var headerBuilder = new StringBuilder();

        LogDebug($"[{source}] Reading headers...");

        // Read headers byte by byte
        while (true)
        {
            var buffer = new byte[1];
            var bytesRead = await stream.ReadAsync(buffer, ct).ConfigureAwait(false);
            if (bytesRead == 0)
            {
                LogDebug($"[{source}] Stream returned 0 bytes while reading headers");
                return null;
            }

            var c = (char)buffer[0];
            headerBuilder.Append(c);

            // Check for end of headers (double CRLF)
            if (headerBuilder.Length >= 4 &&
                headerBuilder.ToString(headerBuilder.Length - 4, 4) == "\r\n\r\n")
            {
                break;
            }
        }

        // Parse headers
        var headerLines = headerBuilder.ToString().Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
        foreach (var line in headerLines)
        {
            var colonIndex = line.IndexOf(':');
            if (colonIndex > 0)
            {
                var name = line[..colonIndex].Trim();
                var value = line[(colonIndex + 1)..].Trim();
                headers[name] = value;
            }
        }

        if (!headers.TryGetValue("Content-Length", out var lengthStr) ||
            !int.TryParse(lengthStr, out var contentLength))
        {
            LogDebug($"[{source}] Missing or invalid Content-Length header");
            return null;
        }

        LogDebug($"[{source}] Reading content ({contentLength} bytes)...");

        // Read content
        var contentBuffer = new byte[contentLength];
        var totalRead = 0;
        while (totalRead < contentLength)
        {
            var read = await stream.ReadAsync(contentBuffer.AsMemory(totalRead, contentLength - totalRead), ct).ConfigureAwait(false);
            if (read == 0)
            {
                LogDebug($"[{source}] Stream ended while reading content (got {totalRead}/{contentLength} bytes)");
                return null;
            }
            totalRead += read;
        }

        LogDebug($"[{source}] Message read complete");
        return Encoding.UTF8.GetString(contentBuffer);
    }

    private static string TruncateForLog(string message)
    {
        const int maxLength = 500;
        if (message.Length <= maxLength) return message;
        return message[..maxLength] + $"... ({message.Length} bytes total)";
    }

    private static async Task WriteLspMessage(Stream stream, string content, CancellationToken ct)
    {
        var contentBytes = Encoding.UTF8.GetBytes(content);
        var header = $"Content-Length: {contentBytes.Length}\r\n\r\n";
        var headerBytes = Encoding.UTF8.GetBytes(header);

        await stream.WriteAsync(headerBytes, ct).ConfigureAwait(false);
        await stream.WriteAsync(contentBytes, ct).ConfigureAwait(false);
        await stream.FlushAsync(ct).ConfigureAwait(false);
    }

    private static async Task WriteLspMessageWithLock(Stream stream, string content, SemaphoreSlim writeLock, CancellationToken ct)
    {
        await writeLock.WaitAsync(ct).ConfigureAwait(false);
        try
        {
            await WriteLspMessage(stream, content, ct).ConfigureAwait(false);
        }
        finally
        {
            writeLock.Release();
        }
    }

    private static void LogDebug(string message)
    {
        if (!DebugMode) return;

        var timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
        var logLine = $"[{timestamp}] {message}";

        Console.Error.WriteLine($"[adapter] {logLine}");

        lock (LogLock)
        {
            try
            {
                File.AppendAllText(LogPath, logLine + Environment.NewLine);
            }
            catch
            {
                // Ignore file write errors
            }
        }
    }
}