@orchestra-mcp/editor 0.2.0

package/dist/lsp-bridge-OWU2SHS5.js

@@ -0,0 +1,145 @@
+// src/CodeEditor/lsp-bridge.ts
+var _requestId = 1;
+async function connectLanguageServer(monaco, editor, languageId, wsUrl) {
+  const ws = new WebSocket(wsUrl);
+  const pending = /* @__PURE__ */ new Map();
+  const disposables = [];
+  function send(msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  function request(method, params) {
+    const id = _requestId++;
+    send({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+  }
+  function notify(method, params) {
+    send({ jsonrpc: "2.0", method, params });
+  }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error(`LSP server not reachable at ${wsUrl}`));
+    }, 5e3);
+    ws.onerror = () => {
+      clearTimeout(timeout);
+      reject(new Error(`LSP WebSocket error for ${languageId}`));
+    };
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.id !== void 0 && pending.has(msg.id)) {
+          const p = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) p.reject(msg.error);
+          else p.resolve(msg.result);
+        } else if (msg.method === "textDocument/publishDiagnostics") {
+          const params = msg.params;
+          if (params) handleDiagnostics(monaco, params.uri, params.diagnostics);
+        }
+      } catch {
+      }
+    };
+    ws.onopen = async () => {
+      clearTimeout(timeout);
+      await request("initialize", {
+        processId: null,
+        clientInfo: { name: "orchestra-mcp", version: "1.0" },
+        capabilities: {
+          textDocument: {
+            hover: { contentFormat: ["markdown", "plaintext"] },
+            completion: { completionItem: { snippetSupport: true } },
+            publishDiagnostics: {}
+          }
+        },
+        rootUri: null
+      });
+      notify("initialized", {});
+      const model = editor.getModel();
+      if (model) {
+        notify("textDocument/didOpen", {
+          textDocument: {
+            uri: model.uri.toString(),
+            languageId,
+            version: model.getVersionId(),
+            text: model.getValue()
+          }
+        });
+        const changeDisposable = model.onDidChangeContent((e) => {
+          notify("textDocument/didChange", {
+            textDocument: { uri: model.uri.toString(), version: model.getVersionId() },
+            contentChanges: e.changes.map((c) => ({
+              range: c.range,
+              rangeLength: c.rangeLength,
+              text: c.text
+            }))
+          });
+        });
+        disposables.push(changeDisposable);
+        const hoverDisposable = monaco.languages.registerHoverProvider(languageId, {
+          provideHover: async (_m, position) => {
+            try {
+              const result = await request("textDocument/hover", {
+                textDocument: { uri: model.uri.toString() },
+                position: { line: position.lineNumber - 1, character: position.column - 1 }
+              });
+              if (!result?.contents) return null;
+              const contents = Array.isArray(result.contents) ? result.contents.map((c) => typeof c === "string" ? { value: c } : c) : [typeof result.contents === "string" ? { value: result.contents } : result.contents];
+              return { contents };
+            } catch {
+              return null;
+            }
+          }
+        });
+        disposables.push(hoverDisposable);
+        const completionDisposable = monaco.languages.registerCompletionItemProvider(languageId, {
+          provideCompletionItems: async (_m, position) => {
+            try {
+              const result = await request("textDocument/completion", {
+                textDocument: { uri: model.uri.toString() },
+                position: { line: position.lineNumber - 1, character: position.column - 1 }
+              });
+              const items = Array.isArray(result) ? result : result?.items ?? [];
+              return { suggestions: items };
+            } catch {
+              return { suggestions: [] };
+            }
+          }
+        });
+        disposables.push(completionDisposable);
+      }
+      resolve({
+        dispose: () => {
+          const model2 = editor.getModel();
+          if (model2) {
+            notify("textDocument/didClose", {
+              textDocument: { uri: model2.uri.toString() }
+            });
+          }
+          disposables.forEach((d) => d.dispose());
+          ws.close();
+        }
+      });
+    };
+  });
+}
+function handleDiagnostics(monaco, uri, diagnostics) {
+  const model = monaco.editor.getModels().find((m) => m.uri.toString() === uri);
+  if (!model) return;
+  const markers = diagnostics.map((d) => ({
+    startLineNumber: d.range.start.line + 1,
+    startColumn: d.range.start.character + 1,
+    endLineNumber: d.range.end.line + 1,
+    endColumn: d.range.end.character + 1,
+    severity: d.severity === 1 ? monaco.MarkerSeverity.Error : d.severity === 2 ? monaco.MarkerSeverity.Warning : monaco.MarkerSeverity.Info,
+    message: d.message,
+    source: d.source
+  }));
+  monaco.editor.setModelMarkers(model, "lsp", markers);
+}
+export {
+  connectLanguageServer
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@orchestra-mcp/editor",
+  "version": "0.2.0",
+  "description": "Code and Markdown editor components for Orchestra MCP",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/orchestra-mcp/editor"
+  },
+  "funding": "https://github.com/sponsors/fadymondy",
+  "license": "MIT",
+  "dependencies": {
+    "@orchestra-mcp/theme": "^0.2.0", "@orchestra-mcp/ui": "^0.2.0", "@orchestra-mcp/widgets": "^0.2.0",
+    "@monaco-editor/react": "^4.7.0",
+    "monaco-editor": "^0.52.2",
+    "html-to-image": "^1.11.13"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": ["orchestra", "mcp", "react", "components", "editor"]
+}