feat(lsp): integrate Java LSP into EditorView

- Add MonacoLSPWebView for Java files
- EditorView automatically uses LSP version for Java
- Connects to localhost:8080 LSP WebSocket
- Shows LSP connection status

Author: ori0o0p

Sources/Zero/Views/EditorView.swift

@@ -84,15 +84,31 @@ struct EditorView: View {
                     Divider()
 
                     // 에디터
-                    CodeEditorView(
-                        content: $fileContent,
-                        language: currentLanguage,
-                        onReady: { isEditorReady = true },
-                        onCursorChange: { line, column in
-                            cursorLine = line
-                            cursorColumn = column
+                    Group {
+                        if currentLanguage == "java" {
+                            // Java LSP 버전
+                            MonacoLSPWebView(
+                                content: $fileContent,
+                                language: currentLanguage,
+                                onReady: { isEditorReady = true },
+                                onCursorChange: { line, column in
+                                    cursorLine = line
+                                    cursorColumn = column
+                                }
+                            )
+                        } else {
+                            // 기본 Monaco
+                            CodeEditorView(
+                                content: $fileContent,
+                                language: currentLanguage,
+                                onReady: { isEditorReady = true },
+                                onCursorChange: { line, column in
+                                    cursorLine = line
+                                    cursorColumn = column
+                                }
+                            )
                         }
-                    )
+                    }
                     .onChange(of: fileContent) { _, _ in
                         if !isLoadingFile {
                             hasUnsavedChanges = true

Sources/Zero/Views/MonacoLSPWebView.swift

@@ -0,0 +1,195 @@
+import SwiftUI
+import WebKit
+
+struct MonacoLSPWebView: NSViewRepresentable {
+    @Binding var content: String
+    var language: String
+    var onReady: (() -> Void)?
+    var onCursorChange: ((Int, Int) -> Void)?
+    
+    func makeNSView(context: Context) -> WKWebView {
+        let config = WKWebViewConfiguration()
+        config.userContentController.add(context.coordinator, name: "editorReady")
+        config.userContentController.add(context.coordinator, name: "contentChanged")
+        config.userContentController.add(context.coordinator, name: "cursorChanged")
+        
+        let webView = WKWebView(frame: .zero, configuration: config)
+        webView.navigationDelegate = context.coordinator
+        context.coordinator.webView = webView
+        
+        // Load Monaco LSP HTML
+        if let htmlPath = Bundle.main.path(forResource: "monaco-lsp", ofType: "html"),
+           let htmlContent = try? String(contentsOfFile: htmlPath) {
+            webView.loadHTMLString(htmlContent, baseURL: URL(string: "https://cdnjs.cloudflare.com"))
+        } else {
+            // Fallback to standard Monaco
+            let html = Self.monacoLSPHTML
+            webView.loadHTMLString(html, baseURL: URL(string: "https://cdnjs.cloudflare.com"))
+        }
+        
+        return webView
+    }
+    
+    func updateNSView(_ webView: WKWebView, context: Context) {
+        // Update content when binding changes
+        if context.coordinator.isReady {
+            let escaped = content.replacingOccurrences(of: "\\", with: "\\\\")
+                .replacingOccurrences(of: "'", with: "\\'")
+                .replacingOccurrences(of: "\n", with: "\\n")
+            webView.evaluateJavaScript("setContent('\(escaped)', '\(language)')")
+        }
+    }
+    
+    func makeCoordinator() -> Coordinator {
+        Coordinator(self)
+    }
+    
+    class Coordinator: NSObject, WKNavigationDelegate, WKScriptMessageHandler {
+        var parent: MonacoLSPWebView
+        var webView: WKWebView?
+        var isReady = false
+        
+        init(_ parent: MonacoLSPWebView) {
+            self.parent = parent
+        }
+        
+        func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+            if message.name == "editorReady" {
+                isReady = true
+                parent.onReady?()
+                
+                // Set initial content
+                let escaped = parent.content.replacingOccurrences(of: "\\", with: "\\\\")
+                    .replacingOccurrences(of: "'", with: "\\'")
+                    .replacingOccurrences(of: "\n", with: "\\n")
+                webView?.evaluateJavaScript("setContent('\(escaped)', '\(parent.language)')")
+                
+                // Enable LSP after a delay
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                    self.webView?.evaluateJavaScript("enableLSP()")
+                }
+            } else if message.name == "contentChanged", let body = message.body as? String {
+                parent.content = body
+            } else if message.name == "cursorChanged", let body = message.body as? [String: Int] {
+                if let line = body["line"], let column = body["column"] {
+                    parent.onCursorChange?(line, column)
+                }
+            }
+        }
+    }
+    
+    // Embedded Monaco LSP HTML as fallback
+    static let monacoLSPHTML = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            html, body { height: 100%; overflow: hidden; background: #1e1e1e; }
+            #editor { width: 100%; height: 100%; }
+            #status { 
+                position: fixed; 
+                bottom: 0; 
+                right: 0; 
+                padding: 4px 8px; 
+                background: #007acc; 
+                color: white; 
+                font-size: 12px;
+                display: none;
+            }
+            #status.connected { display: block; background: #4caf50; }
+            #status.disconnected { display: block; background: #f44336; }
+        </style>
+    </head>
+    <body>
+        <div id="editor"></div>
+        <div id="status">LSP</div>
+        
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.45.0/min/vs/loader.min.js"></script>
+        <script>
+            let editor;
+            let lspSocket;
+            let lspEnabled = false;
+            let requestId = 0;
+            const pendingRequests = new Map();
+            
+            require.config({ paths: { vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.45.0/min/vs' } });
+            require(['vs/editor/editor.main'], function () {
+                editor = monaco.editor.create(document.getElementById('editor'), {
+                    value: '',
+                    language: 'java',
+                    theme: 'vs-dark',
+                    fontSize: 14,
+                    minimap: { enabled: true },
+                    automaticLayout: true,
+                    quickSuggestions: true,
+                    suggestOnTriggerCharacters: true
+                });
+                
+                window.webkit.messageHandlers.editorReady.postMessage('ready');
+                
+                editor.onDidChangeModelContent(() => {
+                    window.webkit.messageHandlers.contentChanged.postMessage(editor.getValue());
+                });
+                
+                editor.onDidChangeCursorPosition((e) => {
+                    window.webkit.messageHandlers.cursorChanged.postMessage({
+                        line: e.position.lineNumber,
+                        column: e.position.column
+                    });
+                });
+            });
+            
+            function connectLSP() {
+                const statusEl = document.getElementById('status');
+                statusEl.className = 'disconnected';
+                statusEl.textContent = 'LSP Connecting...';
+                
+                lspSocket = new WebSocket('ws://localhost:8080');
+                
+                lspSocket.onopen = () => {
+                    console.log('LSP Connected');
+                    lspEnabled = true;
+                    statusEl.className = 'connected';
+                    statusEl.textContent = 'LSP Connected';
+                    
+                    lspSocket.send(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: 1,
+                        method: 'initialize',
+                        params: {
+                            processId: null,
+                            rootUri: 'file:///workspace',
+                            capabilities: {}
+                        }
+                    }));
+                };
+                
+                lspSocket.onclose = () => {
+                    lspEnabled = false;
+                    statusEl.className = 'disconnected';
+                    statusEl.textContent = 'LSP Disconnected';
+                };
+                
+                lspSocket.onerror = () => {
+                    statusEl.className = 'disconnected';
+                    statusEl.textContent = 'LSP Error';
+                };
+            }
+            
+            function setContent(content, language) {
+                if (editor) {
+                    monaco.editor.setModelLanguage(editor.getModel(), language || 'java');
+                    editor.setValue(content);
+                }
+            }
+            
+            function enableLSP() {
+                connectLSP();
+            }
+        </script>
+    </body>
+    </html>
+    """
+}