@gesslar/lpc-mcp 0.1.2

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: Giddyup
+permissions:
+  contents: read
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  cowyboysounds:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x, 22.x]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run ESLint
+        run: npm run lint

package/README.md

@@ -0,0 +1,326 @@
+# LPC MCP Server
+
+**Bring LPC development into 2025** with AI-powered code intelligence.
+
+This MCP (Model Context Protocol) server wraps the [jlchmura/lpc-language-server](https://github.com/jlchmura/lpc-language-server) and exposes it to AI assistants, enabling natural language queries about your LPC codebase with real language server-powered understanding.
+
+## What This Enables
+
+✨ **AI assistants can now:**
+
+- Understand your LPC code structure through the language server
+- Get real documentation from hover information
+- Jump to definitions and find references
+- Answer natural language questions about your mudlib
+- Trace inheritance chains and function calls
+- Explain complex code patterns
+
+All through conversation, powered by actual code intelligence instead of pattern matching.
+
+## Features
+
+- 🔍 **`lpc_hover`**: Get documentation/hover information for symbols
+- 🎯 **`lpc_definition`**: Jump to definition of symbols
+- 🔗 **`lpc_references`**: Find all references to a symbol
+- 🐛 **`lpc_diagnostics`**: Get real-time errors, warnings, and hints from the language server
+- 📁 **Workspace-aware**: Reads your `lpc-config.json` for proper symbol resolution
+- 🚀 **Fast**: Direct JSON-RPC communication with the language server
+
+## Prerequisites
+
+### 1. Install Node.js
+
+Node.js 16+ required:
+
+```bash
+node --version  # Should be v16.0.0 or higher
+```
+
+### 2. Install the LPC Language Server Extension
+
+The extension must be installed in VS Code (the server binary is bundled with it):
+
+```bash
+code --install-extension jlchmura.lpc
+```
+
+Verify installation:
+
+```bash
+ls ~/.vscode/extensions/jlchmura.lpc-*/out/server/src/server.js
+```
+
+### 3. Install Dependencies
+
+```bash
+cd /path/to/lpc-mcp
+npm install
+```
+
+### 4. Create `lpc-config.json` in Your Mudlib
+
+The language server needs this config file at your mudlib root to understand includes, simul_efuns, etc.
+
+Example `/path/to/your/mudlib/lpc-config.json`:
+
+```json
+{
+  "driver": {
+    "type": "fluffos"
+  },
+  "libFiles": {
+    "master": "adm/obj/master.c",
+    "simul_efun": "adm/obj/simul_efun.c",
+    "global_include": "include/global.h"
+  },
+  "libInclude": [
+    "include",
+    "include/driver",
+    "adm/include"
+  ],
+  "exclude": [
+    ".git/",
+    "tmp/"
+  ]
+}
+```
+
+## Setup for Different AI Tools
+
+### Warp (Terminal)
+
+Add to your Warp MCP configuration:
+
+**Location**: Settings → AI → Model Context Protocol
+
+```json
+{
+  "lpc": {
+    "command": "node",
+    "args": ["/absolute/path/to/lpc-mcp/index.js"],
+    "env": {
+      "LPC_WORKSPACE_ROOT": "/path/to/your/mudlib"
+    }
+  }
+}
+```
+
+**Important**: Use absolute paths! Replace:
+
+- `/absolute/path/to/lpc-mcp/index.js` with the actual path to this repo
+- `/path/to/your/mudlib` with the directory containing your `lpc-config.json`
+
+Restart Warp after adding the configuration.
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or equivalent:
+
+```json
+{
+  "mcpServers": {
+    "lpc": {
+      "command": "node",
+      "args": ["/absolute/path/to/lpc-mcp/index.js"],
+      "env": {
+        "LPC_WORKSPACE_ROOT": "/path/to/your/mudlib"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop after configuration.
+
+### Cline (VS Code Extension)
+
+Add to your Cline MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "lpc": {
+      "command": "node",
+      "args": ["/absolute/path/to/lpc-mcp/index.js"],
+      "env": {
+        "LPC_WORKSPACE_ROOT": "/path/to/your/mudlib"
+      }
+    }
+  }
+}
+```
+
+### GitHub Copilot (VS Code)
+
+**Prerequisites:**
+
+- Install the [Copilot MCP extension](https://marketplace.visualstudio.com/items?itemName=automatalabs.copilot-mcp): `code --install-extension automatalabs.copilot-mcp`
+
+**Configuration:**
+Add to `~/Library/Application Support/Code/User/mcp.json` (macOS) or equivalent:
+
+```json
+{
+  "servers": {
+    "lpc": {
+      "type": "node",
+      "command": "node",
+      "args": ["/absolute/path/to/lpc-mcp/index.js"],
+      "env": {
+        "LPC_WORKSPACE_ROOT": "/path/to/your/mudlib"
+      }
+    }
+  },
+  "inputs": []
+}
+```
+
+### Other MCP-Compatible Tools
+
+The configuration is the same for any MCP-compatible tool:
+
+1. Add the server to your MCP configuration
+2. Provide the Node.js command and path to `index.js`
+3. Set `LPC_WORKSPACE_ROOT` environment variable to your mudlib root
+
+## Usage Examples
+
+Once configured, you can ask your AI assistant natural language questions:
+
+**"What does the `query_short()` function do in room.c?"**
+→ AI uses `lpc_hover` to get documentation
+
+**"Where is `STD_OBJECT` defined?"**
+→ AI uses `lpc_definition` to find the file
+
+**"Find all places that call `set_room_size()`"**
+→ AI uses `lpc_references` to locate all callers
+
+**"Explain how the maze generation algorithm works"**
+→ AI reads code and uses hover info to understand functions
+
+**"What's the inheritance tree for rooms?"**
+→ AI traces `inherit` statements and jumps to definitions
+
+**"Check if this LPC file has any syntax errors"**
+→ AI uses `lpc_diagnostics` to validate the code
+
+**"Why won't this LPC code compile?"**
+→ AI checks diagnostics for errors like undeclared variables or type mismatches
+
+## Testing
+
+To verify the server works:
+
+```bash
+# Set workspace root for testing
+export LPC_WORKSPACE_ROOT=/path/to/your/mudlib
+
+# Start the server (it will wait for MCP protocol messages)
+node index.js
+```
+
+The server should output:
+
+```
+Starting LPC Language Server...
+Initializing LSP...
+LPC Language Server started successfully
+LPC MCP Server running on stdio
+```
+
+## Troubleshooting
+
+### Server won't start
+
+**Check the LPC extension is installed:**
+
+```bash
+code --list-extensions | grep jlchmura.lpc
+```
+
+**Check logs** (for Warp):
+
+```bash
+tail -f ~/.local/state/warp-terminal/mcp/*.log
+```
+
+### Language server not resolving symbols
+
+**Verify workspace root:**
+
+- Make sure `LPC_WORKSPACE_ROOT` points to the directory with `lpc-config.json`
+- Use absolute paths, not relative
+
+**Check your lpc-config.json:**
+
+```bash
+cat $LPC_WORKSPACE_ROOT/lpc-config.json
+```
+
+### Extension version mismatch
+
+If the extension path doesn't match, update line 40 in `index.js`:
+
+```javascript
+const lspPath = path.join(
+  process.env.HOME,
+  ".vscode/extensions/jlchmura.lpc-VERSION/out/server/src/server.js"
+);
+```
+
+Find your version:
+
+```bash
+ls ~/.vscode/extensions/ | grep jlchmura.lpc
+```
+
+## How It Works
+
+```
+AI Assistant
+    ↓ (natural language)
+  MCP Protocol
+    ↓ (tool calls: lpc_hover, lpc_definition, lpc_references)
+  This Server
+    ↓ (JSON-RPC: textDocument/hover, etc.)
+  LPC Language Server
+    ↓ (parses LPC, reads lpc-config.json)
+  Your Mudlib
+```
+
+1. AI assistant sends MCP tool requests
+2. Server reads the file and sends `textDocument/didOpen` to LSP
+3. Server translates MCP → LSP JSON-RPC requests
+4. LSP analyzes code using your `lpc-config.json`
+5. Server returns LSP response as MCP result
+6. AI understands your code structure!
+
+## Roadmap
+
+- [ ] Add completion support
+- [x] Add diagnostics (errors/warnings)
+- [ ] Support signature help
+- [ ] Cache opened documents
+- [ ] Support multiple workspace roots
+- [ ] Add rename symbol support
+- [ ] Add document symbols (outline)
+- [ ] Add workspace symbol search
+
+## Contributing
+
+PRs welcome! This is a proof-of-concept that can be extended with more LSP features.
+
+## Credits
+
+- **John (jlchmura)** - The INCOMPARABLY SKILLED MASTER PROGRAMMER whose [LPC language server](https://github.com/jlchmura/lpc-language-server) rescued LPC development from 1995. Without his greatness, kindness, and all-around hunk demeanour, we would still be `grep`-ing through mudlibs like cavemen. This cos theMCP server is merely a humble wrapper around his genius. 🙇
+- [Model Context Protocol](https://modelcontextprotocol.io/) - The protocol making this possible
+- Built in an hour of inspired hacking in 2025
+
+## ~~License~~
+
+Unlicense - Public Domain. Do whatever you want with this code.
+
+### Note
+
+The LPC language server itself [(jlchmura/lpc-language-server)](https://github.com/jlchmura/lpc-language-server) is under its own license.

package/UNLICENSE.txt

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/eslint.config.js

@@ -0,0 +1,167 @@
+import js from "@eslint/js"
+import jsdoc from "eslint-plugin-jsdoc"
+import stylistic from "@stylistic/eslint-plugin"
+import globals from "globals"
+
+export default [
+  js.configs.recommended,
+  jsdoc.configs['flat/recommended'], {
+    name: "gesslar/uglier/ignores",
+    ignores: [],
+  }, {
+    name: "gesslar/uglier/languageOptions",
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      globals: {
+        ...globals.node,
+        fetch: "readonly",
+        Headers: "readonly",
+      },
+    },
+  },
+  // Add override for webview files to include browser globals
+  {
+    name: "gesslar/uglier/webview-env",
+    files: ["src/webview/**/*.{js,mjs,cjs}"],
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        acquireVsCodeApi: "readonly"
+      }
+    }
+  },
+  // Add override for .cjs files to treat as CommonJS
+  {
+    name: "gesslar/uglier/cjs-override",
+    files: ["src/**/*.cjs"],
+    languageOptions: {
+      sourceType: "script",
+      ecmaVersion: 2021
+    },
+  },
+  // Add override for .mjs files to treat as ES modules
+  {
+    name: "gesslar/uglier/mjs-override",
+    files: ["src/**/*.mjs"],
+    languageOptions: {
+      sourceType: "module",
+      ecmaVersion: 2021
+    }
+  },
+  {
+    name: "gesslar/uglier/lints-js",
+    files: ["{work,src}/**/*.{mjs,cjs,js}"],
+    plugins: {
+      "@stylistic": stylistic,
+    },
+    rules: {
+      "@stylistic/arrow-parens": ["error", "as-needed"],
+      "@stylistic/arrow-spacing": ["error", { before: true, after: true }],
+      "@stylistic/brace-style": ["error", "1tbs", {allowSingleLine: false}],
+      "@stylistic/nonblock-statement-body-position": ["error", "below"],
+      "@stylistic/padding-line-between-statements": [
+        "error",
+        {blankLine: "always",   prev: "if", next: "*"},
+        {blankLine: "always",   prev: "*", next: "return"},
+        {blankLine: "always",   prev: "while", next: "*"},
+        {blankLine: "always",   prev: "for", next: "*"},
+        {blankLine: "always",   prev: "switch", next: "*"},
+        {blankLine: "always",   prev: "do", next: "*"},
+        // {blankLine: "always",   prev: ["const", "let", "var"], next: "*"},
+        // {blankLine: "any",      prev: ["const", "let", "var"], next: ["const", "let", "var"]},
+        {blankLine: "always",   prev: "directive", next: "*" },
+        {blankLine: "any",      prev: "directive", next: "directive" },
+      ],
+      "@stylistic/eol-last": ["error", "always"],
+      "@stylistic/indent": ["error", 2, {
+        SwitchCase: 1 // Indents `case` statements one level deeper than `switch`
+      }],
+      "@stylistic/key-spacing": ["error", { beforeColon: false, afterColon: true }],
+      "@stylistic/keyword-spacing": ["error", {
+        before: false,
+        after: true,
+        overrides: {
+          // Control statements
+          return:  { before: true, after: true },
+          if:      { after: false },
+          else:    { before: true, after: true },
+          for:     { after: false },
+          while:   { before: true, after: false },
+          do:      { after: true },
+          switch:  { after: false },
+          case:    { before: true, after: true },
+          throw:   { before: true, after: false } ,
+
+          // Keywords
+          as:      { before: true, after: true },
+          of:      { before: true, after: true },
+          from:    { before: true, after: true },
+          async:   { before: true, after: true },
+          await:   { before: true, after: false },
+          class:   { before: true, after: true },
+          const:   { before: true, after: true },
+          let:     { before: true, after: true },
+          var:     { before: true, after: true },
+
+          // Exception handling
+          catch:   { before: true, after: true },
+          finally: { before: true, after: true },
+        }
+      }],
+      // Blocks
+      "@stylistic/space-before-blocks": ["error", "always"],
+      "@stylistic/max-len": ["warn", {
+        code: 80,
+        ignoreComments: true,
+        ignoreUrls: true,
+        ignoreStrings: true,
+        ignoreTemplateLiterals: true,
+        ignoreRegExpLiterals: true,
+        tabWidth: 2
+      }],
+      "@stylistic/no-tabs": "error",
+      "@stylistic/no-trailing-spaces": ["error"],
+      "@stylistic/object-curly-spacing": ["error", "never", {
+        objectsInObjects: false,
+        arraysInObjects: false
+      }],
+      "@stylistic/quotes": ["error", "double", {
+        avoidEscape: true,
+        allowTemplateLiterals: "always"
+      }],
+      "@stylistic/semi": ["error", "never"],
+      "@stylistic/space-before-function-paren": ["error", "never"],
+      "@stylistic/yield-star-spacing": ["error", { before: true, after: false }],
+      "constructor-super": "error",
+      "no-unexpected-multiline": "error",
+      "no-unused-vars": ["error", {
+        caughtErrors: "all",
+        caughtErrorsIgnorePattern: "^_+",
+        argsIgnorePattern: "^_+",
+        destructuredArrayIgnorePattern: "^_+",
+        varsIgnorePattern: "^_+"
+      }],
+      "no-useless-assignment": "error",
+      "prefer-const": "error",
+      "@stylistic/no-multiple-empty-lines": ["error", { max: 1 }],
+      "@stylistic/array-bracket-spacing": ["error", "never"],
+    }
+  },
+  {
+    name: "gesslar/uglier/lints-jsdoc",
+    files: ["{work,src}/**/*.{mjs,cjs,js}"],
+    plugins: {
+      jsdoc,
+    },
+    rules: {
+      "jsdoc/require-description": "error",
+      "jsdoc/tag-lines": ["error", "any", {"startLines":1}],
+      "jsdoc/require-jsdoc": ["error", { publicOnly: true }],
+      "jsdoc/check-tag-names": "error",
+      "jsdoc/check-types": "error",
+      "jsdoc/require-param-type": "error",
+      "jsdoc/require-returns-type": "error"
+    }
+  }
+]

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@gesslar/lpc-mcp",
+  "version": "0.1.2",
+  "description": "MCP server for LPC language server",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "lpc-mcp": "./src/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "types:build": "tsc -p tsconfig.types.json",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "submit": "npm publish --access public",
+    "update": "npx npm-check-updates -u && npm install",
+    "pr": "gt submit --publish --restack --ai -m",
+    "patch": "npm version patch",
+    "minor": "npm version minor",
+    "major": "npm version major"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gesslar/lpc-mcp.git"
+  },
+  "keywords": [],
+  "author": "gesslar",
+  "license": "Unlicense",
+  "homepage": "https://github.com/gesslar/lpc-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.2",
+    "vscode-jsonrpc": "^8.2.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.0",
+    "@stylistic/eslint-plugin": "^5.5.0",
+    "eslint-plugin-jsdoc": "^61.1.11",
+    "globals": "^16.5.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+
+import {Server} from "@modelcontextprotocol/sdk/server/index.js"
+import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js"
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js"
+import {spawn} from "child_process"
+import * as rpc from "vscode-jsonrpc/node.js"
+import path from "path"
+// ...existing code...
+import {Transform} from "stream"
+
+class LPCMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: "lpc-mcp-server",
+        version: "0.1.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    )
+
+    this.lspProcess = null
+    this.lspConnection = null
+    this.diagnosticsCache = new Map() // Map of file URI -> diagnostics array
+    this.setupHandlers()
+  }
+
+  async startLSP() {
+    // Path to the LPC language server
+    const lspPath = path.join(
+      process.env.HOME,
+      ".vscode/extensions/jlchmura.lpc-1.1.42/out/server/src/server.js"
+    )
+
+    console.error("Starting LPC Language Server from:", lspPath)
+
+    // Spawn the LSP server
+    // Redirect stderr to /dev/null to prevent log messages from contaminating JSON-RPC
+    this.lspProcess = spawn("node", [lspPath, "--stdio"], {
+      stdio: ["pipe", "pipe", "ignore"],
+    })
+
+    this.lspProcess.on("error", err => {
+      console.error("LSP Process error:", err)
+    })
+
+    this.lspProcess.on("exit", code => {
+      console.error("LSP Process exited with code:", code)
+    })
+
+    // Create a transform stream to filter out non-JSON-RPC output
+    const cleanStream = new Transform({
+      transform(chunk, encoding, callback) {
+        const data = chunk.toString()
+        // Filter out lines that don't look like JSON-RPC
+        // JSON-RPC messages start with "Content-Length: "
+        const lines = data.split("\n")
+        const filtered = lines.filter(line => {
+          const trimmed = line.trim()
+
+          // Keep Content-Length headers and JSON lines
+          return trimmed.startsWith("Content-Length:") ||
+                 trimmed.startsWith("{") ||
+                 trimmed === ""
+        }).join("\n")
+
+        if(filtered) {
+          this.push(filtered)
+        }
+
+        callback()
+      }
+    })
+
+    // Pipe stdout through the cleaner
+    this.lspProcess.stdout.pipe(cleanStream)
+
+    // Create JSON-RPC connection
+    const reader = new rpc.StreamMessageReader(cleanStream)
+    const writer = new rpc.StreamMessageWriter(this.lspProcess.stdin)
+    this.lspConnection = rpc.createMessageConnection(reader, writer)
+
+    this.lspConnection.onError(error => {
+      console.error("LSP Connection error:", error)
+    })
+
+    this.lspConnection.onClose(() => {
+      console.error("LSP Connection closed")
+    })
+
+    // Listen for diagnostic notifications
+    this.lspConnection.onNotification("textDocument/publishDiagnostics", params => {
+      console.error(`Received diagnostics for ${params.uri}: ${params.diagnostics.length} issues`)
+      this.diagnosticsCache.set(params.uri, params.diagnostics)
+    })
+
+    // Start listening
+    this.lspConnection.listen()
+
+    console.error("Initializing LSP...")
+
+    // Get workspace root from environment variable
+    const workspaceRoot = process.env.LPC_WORKSPACE_ROOT || null
+    const rootUri = workspaceRoot ? `file://${workspaceRoot}` : null
+
+    console.error("Using workspace root:", rootUri)
+
+    // Initialize the LSP with timeout
+    try {
+      const initResult = await Promise.race([
+        this.lspConnection.sendRequest("initialize", {
+          processId: process.pid,
+          rootUri: rootUri,
+          capabilities: {
+            textDocument: {
+              hover: {dynamicRegistration: true},
+              definition: {dynamicRegistration: true},
+              references: {dynamicRegistration: true},
+            },
+          },
+        }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error("LSP init timeout")), 5000)
+        ),
+      ])
+
+      console.error("LSP initialized:", JSON.stringify(initResult, null, 2))
+
+      await this.lspConnection.sendNotification("initialized", {})
+
+      console.error("LPC Language Server started successfully")
+    } catch(error) {
+      console.error("Failed to initialize LSP:", error)
+      throw error
+    }
+  }
+
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async() => ({
+      tools: [
+        {
+          name: "lpc_hover",
+          description:
+            "Get hover information (documentation) for a symbol at a specific position in an LPC file",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: {
+                type: "string",
+                description: "Absolute path to the LPC file",
+              },
+              line: {
+                type: "number",
+                description: "Line number (0-indexed)",
+              },
+              character: {
+                type: "number",
+                description: "Character position (0-indexed)",
+              },
+            },
+            required: ["file", "line", "character"],
+          },
+        },
+        {
+          name: "lpc_definition",
+          description:
+            "Go to definition of a symbol at a specific position in an LPC file",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: {
+                type: "string",
+                description: "Absolute path to the LPC file",
+              },
+              line: {
+                type: "number",
+                description: "Line number (0-indexed)",
+              },
+              character: {
+                type: "number",
+                description: "Character position (0-indexed)",
+              },
+            },
+            required: ["file", "line", "character"],
+          },
+        },
+        {
+          name: "lpc_references",
+          description:
+            "Find all references to a symbol at a specific position in an LPC file",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: {
+                type: "string",
+                description: "Absolute path to the LPC file",
+              },
+              line: {
+                type: "number",
+                description: "Line number (0-indexed)",
+              },
+              character: {
+                type: "number",
+                description: "Character position (0-indexed)",
+              },
+            },
+            required: ["file", "line", "character"],
+          },
+        },
+        {
+          name: "lpc_diagnostics",
+          description:
+            "Get diagnostics (errors, warnings, hints) for an LPC file. This reveals LPC language rules and syntax errors.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: {
+                type: "string",
+                description: "Absolute path to the LPC file",
+              },
+            },
+            required: ["file"],
+          },
+        },
+      ],
+    }))
+
+    this.server.setRequestHandler(CallToolRequestSchema, async request => {
+      const {name, arguments: args} = request.params
+
+      if(!this.lspConnection) {
+        throw new Error("LSP not initialized")
+      }
+
+      const uri = `file://${args.file}`
+
+      try {
+        // Read the file and send didOpen notification
+        const fs = await import("fs/promises")
+        const fileContent = await fs.readFile(args.file, "utf-8")
+
+        await this.lspConnection.sendNotification("textDocument/didOpen", {
+          textDocument: {
+            uri,
+            languageId: "lpc",
+            version: 1,
+            text: fileContent,
+          },
+        })
+
+        switch(name) {
+          case "lpc_hover": {
+            const result = await this.lspConnection.sendRequest(
+              "textDocument/hover",
+              {
+                textDocument: {uri},
+                position: {line: args.line, character: args.character},
+              }
+            )
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(result, null, 2),
+                },
+              ],
+            }
+          }
+
+          case "lpc_definition": {
+            const result = await this.lspConnection.sendRequest(
+              "textDocument/definition",
+              {
+                textDocument: {uri},
+                position: {line: args.line, character: args.character},
+              }
+            )
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(result, null, 2),
+                },
+              ],
+            }
+          }
+
+          case "lpc_references": {
+            const result = await this.lspConnection.sendRequest(
+              "textDocument/references",
+              {
+                textDocument: {uri},
+                position: {line: args.line, character: args.character},
+                context: {includeDeclaration: true},
+              }
+            )
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(result, null, 2),
+                },
+              ],
+            }
+          }
+
+          case "lpc_diagnostics": {
+            // Just open the file to trigger diagnostics
+            // Wait a bit for diagnostics to come through
+            await new Promise(resolve => setTimeout(resolve, 500))
+
+            const diagnostics = this.diagnosticsCache.get(uri) || []
+
+            if(diagnostics.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "No diagnostics found for this file. The code appears to be valid.",
+                  },
+                ],
+              }
+            }
+
+            // Format diagnostics in a readable way
+            const formatted = diagnostics.map(d => {
+              const severity = ["Error", "Warning", "Information", "Hint"][d.severity - 1] || "Unknown"
+              const line = d.range.start.line + 1 // Convert to 1-indexed
+              const char = d.range.start.character + 1
+
+              return `[${severity}] Line ${line}:${char} - ${d.message}`
+            }).join("\n")
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${diagnostics.length} diagnostic(s):\n\n${formatted}\n\nRaw diagnostics:\n${JSON.stringify(diagnostics, null, 2)}`,
+                },
+              ],
+            }
+          }
+
+          default:
+            throw new Error(`Unknown tool: ${name}`)
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+  }
+
+  async run() {
+    await this.startLSP()
+
+    const transport = new StdioServerTransport()
+    await this.server.connect(transport)
+
+    console.error("LPC MCP Server running on stdio")
+  }
+}
+
+const server = new LPCMCPServer()
+server.run().catch(console.error)