Step 96: LSP server configuration

editor/src/SettingsManager.h

@@ -0,0 +1,158 @@
+#pragma once
+// Step 96: LSP server configuration settings
+
+#include <string>
+#include <vector>
+#include <filesystem>
+#include <cstdlib>
+#include "ast/Schema.h"
+#include "ast/ASTNode.h"
+
+struct LSPServerConfig {
+    std::string language;
+    std::string server;
+    std::string path;
+    std::vector<std::string> args;
+    std::string argsLine;
+    bool enabled = true;
+};
+
+class SettingsManager {
+public:
+    SettingsManager() { loadDefaults(); }
+
+    const std::vector<LSPServerConfig>& getLSPServers() const { return lspServers_; }
+    std::vector<LSPServerConfig>& getLSPServersMutable() { return lspServers_; }
+
+    LSPServerConfig* getServer(const std::string& language) {
+        for (auto& s : lspServers_) {
+            if (s.language == language) return &s;
+        }
+        return nullptr;
+    }
+
+    void setServerPath(const std::string& language, const std::string& path) {
+        auto* cfg = getServer(language);
+        if (cfg) cfg->path = path;
+    }
+
+    void syncArgs(LSPServerConfig& cfg) {
+        cfg.args = splitArgs(cfg.argsLine);
+    }
+
+    void autoDetect() {
+        for (auto& s : lspServers_) {
+            if (!s.path.empty()) continue;
+            std::string found;
+            if (findOnPath(s.server, found)) {
+                s.path = found;
+            }
+        }
+    }
+
+    bool validateSchema(const ASTNode* root, std::vector<std::string>& errors) const {
+        errors.clear();
+        if (!root) {
+            errors.push_back("Null AST root");
+            return false;
+        }
+        ASTSchema schema;
+        validateNode(root, schema, errors);
+        return errors.empty();
+    }
+
+private:
+    std::vector<LSPServerConfig> lspServers_;
+
+    void loadDefaults() {
+        lspServers_.push_back(makeConfig("python", "pylsp", {}));
+        lspServers_.push_back(makeConfig("cpp", "clangd", {}));
+        lspServers_.push_back(makeConfig("rust", "rust-analyzer", {}));
+        lspServers_.push_back(makeConfig("go", "gopls", {}));
+        lspServers_.push_back(makeConfig("javascript", "typescript-language-server", {"--stdio"}));
+        lspServers_.push_back(makeConfig("typescript", "typescript-language-server", {"--stdio"}));
+        lspServers_.push_back(makeConfig("java", "jdtls", {}));
+    }
+
+    static LSPServerConfig makeConfig(const std::string& lang,
+                                      const std::string& server,
+                                      const std::vector<std::string>& args) {
+        LSPServerConfig cfg;
+        cfg.language = lang;
+        cfg.server = server;
+        cfg.args = args;
+        cfg.argsLine = joinArgs(args);
+        cfg.enabled = true;
+        return cfg;
+    }
+
+    static std::string joinArgs(const std::vector<std::string>& args) {
+        std::string out;
+        for (size_t i = 0; i < args.size(); ++i) {
+            if (i > 0) out += " ";
+            out += args[i];
+        }
+        return out;
+    }
+
+    static std::vector<std::string> splitArgs(const std::string& line) {
+        std::vector<std::string> out;
+        std::string current;
+        for (char c : line) {
+            if (c == ' ') {
+                if (!current.empty()) {
+                    out.push_back(current);
+                    current.clear();
+                }
+            } else {
+                current.push_back(c);
+            }
+        }
+        if (!current.empty()) out.push_back(current);
+        return out;
+    }
+
+    static bool findOnPath(const std::string& exe, std::string& outPath) {
+        const char* pathEnv = std::getenv("PATH");
+        if (!pathEnv) return false;
+        std::string pathVar(pathEnv);
+        size_t start = 0;
+        while (start <= pathVar.size()) {
+            size_t end = pathVar.find(';', start);
+            if (end == std::string::npos) end = pathVar.size();
+            std::string dir = pathVar.substr(start, end - start);
+            if (!dir.empty()) {
+                std::filesystem::path p = std::filesystem::path(dir) / exe;
+                if (std::filesystem::exists(p)) {
+                    outPath = p.string();
+                    return true;
+                }
+                std::filesystem::path pExe = p;
+                pExe += ".exe";
+                if (std::filesystem::exists(pExe)) {
+                    outPath = pExe.string();
+                    return true;
+                }
+            }
+            if (end == pathVar.size()) break;
+            start = end + 1;
+        }
+        return false;
+    }
+
+    static void validateNode(const ASTNode* node, const ASTSchema& schema, std::vector<std::string>& errors) {
+        if (!node) return;
+        for (const auto& role : node->childRoles()) {
+            const auto& kids = node->getChildren(role);
+            if (schema.isSingleValued(node->conceptType, role) && kids.size() > 1) {
+                errors.push_back("Role '" + role + "' on " + node->conceptType + " is single-valued");
+            }
+            for (const auto* child : kids) {
+                if (!schema.isLegalChild(node->conceptType, role, child->conceptType)) {
+                    errors.push_back("Illegal child " + child->conceptType + " under " + node->conceptType + " role '" + role + "'");
+                }
+                validateNode(child, schema, errors);
+            }
+        }
+    }
+};