@treedy/pyright-mcp 1.1.2 → 1.1.4

package/dist/index.js

@@ -1,49 +1,1617 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { hover, hoverSchema } from './tools/hover.js';
-import { definition, definitionSchema } from './tools/definition.js';
-import { references, referencesSchema } from './tools/references.js';
-import { completions, completionsSchema } from './tools/completions.js';
-import { diagnostics, diagnosticsSchema } from './tools/diagnostics.js';
-import { signatureHelp, signatureHelpSchema } from './tools/signature-help.js';
-import { rename, renameSchema } from './tools/rename.js';
-import { search, searchSchema } from './tools/search.js';
-import { status, statusSchema } from './tools/status.js';
-import { getLspClient } from './lsp-client.js';
-const server = new McpServer({
-    name: 'pyright-mcp',
-    version: '1.0.0',
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/hover.ts
+import { z } from "zod";
+
+// src/lsp-client.ts
+import * as fs2 from "fs";
+
+// src/utils/position.ts
+import { Position } from "vscode-languageserver-protocol";
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+function toPosition(line, column) {
+  return Position.create(line - 1, column - 1);
+}
+function fromPosition(pos) {
+  return {
+    line: pos.line + 1,
+    column: pos.character + 1
+  };
+}
+function formatRange(range) {
+  const start = fromPosition(range.start);
+  const end = fromPosition(range.end);
+  return `${start.line}:${start.column}-${end.line}:${end.column}`;
+}
+function uriToPath(uri) {
+  if (uri.startsWith("file://")) {
+    return uri.slice(7);
+  }
+  return uri;
+}
+function findProjectRoot(filePath) {
+  const configFiles = ["pyrightconfig.json", "pyproject.toml", ".git"];
+  let dir = dirname(resolve(filePath));
+  const root = "/";
+  while (dir !== root) {
+    for (const configFile of configFiles) {
+      if (existsSync(join(dir, configFile))) {
+        return dir;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return dirname(resolve(filePath));
+}
+
+// src/lsp/connection.ts
+import { spawn } from "child_process";
+import {
+  createMessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter
+} from "vscode-jsonrpc/node.js";
+
+// src/lsp/document-manager.ts
+import * as fs from "fs";
+import * as path from "path";
+
+class DocumentManager {
+  documents = new Map;
+  filePathToUri(filePath) {
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+    return `file://${absolutePath}`;
+  }
+  uriToFilePath(uri) {
+    if (uri.startsWith("file://")) {
+      return uri.slice(7);
+    }
+    return uri;
+  }
+  isDocumentOpen(filePath) {
+    const uri = this.filePathToUri(filePath);
+    return this.documents.has(uri);
+  }
+  getDocument(filePath) {
+    const uri = this.filePathToUri(filePath);
+    return this.documents.get(uri);
+  }
+  openDocument(filePath, content) {
+    const uri = this.filePathToUri(filePath);
+    const actualContent = content ?? fs.readFileSync(filePath, "utf-8");
+    const state = {
+      uri,
+      version: 1,
+      content: actualContent,
+      languageId: "python"
+    };
+    this.documents.set(uri, state);
+    return state;
+  }
+  updateDocument(filePath, newContent) {
+    const uri = this.filePathToUri(filePath);
+    const existing = this.documents.get(uri);
+    if (!existing) {
+      const state = this.openDocument(filePath, newContent);
+      return state.version;
+    }
+    existing.version += 1;
+    existing.content = newContent;
+    return existing.version;
+  }
+  closeDocument(filePath) {
+    const uri = this.filePathToUri(filePath);
+    return this.documents.delete(uri);
+  }
+  getAllOpenDocuments() {
+    return Array.from(this.documents.values());
+  }
+  closeAll() {
+    this.documents.clear();
+  }
+  getTextDocumentIdentifier(filePath) {
+    return { uri: this.filePathToUri(filePath) };
+  }
+  getTextDocumentItem(filePath) {
+    const state = this.getDocument(filePath);
+    if (!state) {
+      throw new Error(`Document not open: ${filePath}`);
+    }
+    return {
+      uri: state.uri,
+      languageId: state.languageId,
+      version: state.version,
+      text: state.content
+    };
+  }
+  getVersionedTextDocumentIdentifier(filePath) {
+    const state = this.getDocument(filePath);
+    if (!state) {
+      throw new Error(`Document not open: ${filePath}`);
+    }
+    return {
+      uri: state.uri,
+      version: state.version
+    };
+  }
+}
+
+// src/lsp/connection.ts
+class LspConnectionManager {
+  connections = new Map;
+  documentManagers = new Map;
+  initializationPromises = new Map;
+  static DEFAULT_INIT_TIMEOUT = 1e4;
+  static DOCUMENT_READY_DELAY = 500;
+  async getConnection(options) {
+    const { workspaceRoot } = options;
+    const existing = this.connections.get(workspaceRoot);
+    if (existing && existing.initialized) {
+      existing.lastUsed = Date.now();
+      return existing;
+    }
+    const pendingInit = this.initializationPromises.get(workspaceRoot);
+    if (pendingInit) {
+      return pendingInit;
+    }
+    const initPromise = this.createConnection(options);
+    this.initializationPromises.set(workspaceRoot, initPromise);
+    try {
+      const connection = await initPromise;
+      this.connections.set(workspaceRoot, connection);
+      return connection;
+    } finally {
+      this.initializationPromises.delete(workspaceRoot);
+    }
+  }
+  getDocumentManager(workspaceRoot) {
+    let manager = this.documentManagers.get(workspaceRoot);
+    if (!manager) {
+      manager = new DocumentManager;
+      this.documentManagers.set(workspaceRoot, manager);
+    }
+    return manager;
+  }
+  async createConnection(options) {
+    const { workspaceRoot, initTimeout = LspConnectionManager.DEFAULT_INIT_TIMEOUT } = options;
+    const pyrightProcess = spawn("pyright-langserver", ["--stdio"], {
+      stdio: ["pipe", "pipe", "ignore"],
+      cwd: workspaceRoot
+    });
+    pyrightProcess.on("error", (err) => {
+      console.error(`[LSP] Process error for ${workspaceRoot}:`, err);
+      this.closeConnection(workspaceRoot);
+    });
+    pyrightProcess.on("exit", (code, signal) => {
+      console.error(`[LSP] Process exited for ${workspaceRoot}: code=${code}, signal=${signal}`);
+      this.connections.delete(workspaceRoot);
+    });
+    console.error(`[LSP] Spawned pyright-langserver for ${workspaceRoot}`);
+    const connection = createMessageConnection(new StreamMessageReader(pyrightProcess.stdout), new StreamMessageWriter(pyrightProcess.stdin));
+    connection.onError((error) => {
+      console.error(`[LSP] Connection error for ${workspaceRoot}:`, error);
+    });
+    connection.onClose(() => {
+      console.error(`[LSP] Connection closed for ${workspaceRoot}`);
+    });
+    connection.listen();
+    const connectionId = Math.random().toString(36).slice(2, 8);
+    console.error(`[LSP] Created connection ${connectionId}`);
+    const lspConnection = {
+      connection,
+      process: pyrightProcess,
+      workspaceRoot,
+      initialized: false,
+      lastUsed: Date.now(),
+      id: connectionId
+    };
+    await this.initializeConnection(lspConnection, initTimeout);
+    return lspConnection;
+  }
+  async initializeConnection(lspConnection, timeout) {
+    const { connection, workspaceRoot } = lspConnection;
+    const initPromise = (async () => {
+      console.error(`[LSP] Sending initialize request...`);
+      const initResult = await connection.sendRequest("initialize", {
+        processId: process.pid,
+        rootUri: `file://${workspaceRoot}`,
+        capabilities: {
+          textDocument: {
+            hover: { contentFormat: ["markdown", "plaintext"] },
+            completion: {
+              completionItem: {
+                snippetSupport: true,
+                documentationFormat: ["markdown", "plaintext"]
+              }
+            },
+            signatureHelp: {
+              signatureInformation: {
+                documentationFormat: ["markdown", "plaintext"]
+              }
+            },
+            definition: { linkSupport: true },
+            references: {},
+            rename: { prepareSupport: true },
+            documentSymbol: {
+              hierarchicalDocumentSymbolSupport: true
+            },
+            publishDiagnostics: {}
+          }
+        },
+        workspaceFolders: [
+          {
+            uri: `file://${workspaceRoot}`,
+            name: workspaceRoot.split("/").pop() || "workspace"
+          }
+        ]
+      });
+      console.error(`[LSP] Sending initialized notification...`);
+      await connection.sendNotification("initialized", {});
+      console.error(`[LSP] Connection initialized successfully`);
+      lspConnection.initialized = true;
+    })();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`LSP initialization timed out after ${timeout}ms`)), timeout);
+    });
+    await Promise.race([initPromise, timeoutPromise]);
+  }
+  async openDocument(workspaceRoot, filePath, content) {
+    const lspConnection = this.connections.get(workspaceRoot);
+    if (!lspConnection || !lspConnection.initialized) {
+      throw new Error(`No initialized connection for workspace: ${workspaceRoot}`);
+    }
+    const docManager = this.getDocumentManager(workspaceRoot);
+    if (docManager.isDocumentOpen(filePath)) {
+      return;
+    }
+    const docState = docManager.openDocument(filePath, content);
+    console.error(`[LSP] Sending didOpen for ${filePath}...`);
+    await lspConnection.connection.sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri: docState.uri,
+        languageId: docState.languageId,
+        version: docState.version,
+        text: docState.content
+      }
+    });
+    console.error(`[LSP] Waiting for analysis...`);
+    await this.waitForAnalysis();
+    console.error(`[LSP] Document ready: ${filePath}`);
+  }
+  async updateDocument(workspaceRoot, filePath, newContent) {
+    const lspConnection = this.connections.get(workspaceRoot);
+    if (!lspConnection || !lspConnection.initialized) {
+      throw new Error(`No initialized connection for workspace: ${workspaceRoot}`);
+    }
+    const docManager = this.getDocumentManager(workspaceRoot);
+    if (!docManager.isDocumentOpen(filePath)) {
+      await this.openDocument(workspaceRoot, filePath, newContent);
+      return;
+    }
+    const newVersion = docManager.updateDocument(filePath, newContent);
+    const uri = docManager.filePathToUri(filePath);
+    await lspConnection.connection.sendNotification("textDocument/didChange", {
+      textDocument: {
+        uri,
+        version: newVersion
+      },
+      contentChanges: [{ text: newContent }]
+    });
+    await this.waitForAnalysis();
+  }
+  async closeDocument(workspaceRoot, filePath) {
+    const lspConnection = this.connections.get(workspaceRoot);
+    if (!lspConnection || !lspConnection.initialized) {
+      return;
+    }
+    const docManager = this.getDocumentManager(workspaceRoot);
+    if (!docManager.isDocumentOpen(filePath)) {
+      return;
+    }
+    const uri = docManager.filePathToUri(filePath);
+    await lspConnection.connection.sendNotification("textDocument/didClose", {
+      textDocument: { uri }
+    });
+    docManager.closeDocument(filePath);
+  }
+  async waitForAnalysis() {
+    await new Promise((resolve3) => setTimeout(resolve3, LspConnectionManager.DOCUMENT_READY_DELAY));
+  }
+  async sendRequest(workspaceRoot, method, params) {
+    const lspConnection = this.connections.get(workspaceRoot);
+    if (!lspConnection || !lspConnection.initialized) {
+      throw new Error(`No initialized connection for workspace: ${workspaceRoot}`);
+    }
+    lspConnection.lastUsed = Date.now();
+    console.error(`[LSP] sendRequest: ${method}`);
+    const result = await lspConnection.connection.sendRequest(method, params);
+    console.error(`[LSP] Request ${method} done`);
+    return result;
+  }
+  async closeConnection(workspaceRoot) {
+    const lspConnection = this.connections.get(workspaceRoot);
+    if (!lspConnection) {
+      return;
+    }
+    const docManager = this.documentManagers.get(workspaceRoot);
+    if (docManager) {
+      docManager.closeAll();
+      this.documentManagers.delete(workspaceRoot);
+    }
+    if (lspConnection.initialized) {
+      try {
+        await lspConnection.connection.sendRequest("shutdown");
+        await lspConnection.connection.sendNotification("exit");
+      } catch {}
+    }
+    lspConnection.connection.dispose();
+    if (!lspConnection.process.killed) {
+      lspConnection.process.kill();
+    }
+    this.connections.delete(workspaceRoot);
+  }
+  async closeAll() {
+    const workspaceRoots = Array.from(this.connections.keys());
+    await Promise.all(workspaceRoots.map((root) => this.closeConnection(root)));
+  }
+  getStatus() {
+    return Array.from(this.connections.entries()).map(([root, conn]) => ({
+      workspaceRoot: root,
+      initialized: conn.initialized,
+      lastUsed: new Date(conn.lastUsed)
+    }));
+  }
+}
+var connectionManagerInstance = null;
+function getConnectionManager() {
+  if (!connectionManagerInstance) {
+    connectionManagerInstance = new LspConnectionManager;
+  }
+  return connectionManagerInstance;
+}
+// src/lsp/types.ts
+var SymbolKindNames = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter"
+};
+// src/lsp-client.ts
+function log(message) {
+  console.error(`[LSP] ${message}`);
+}
+
+class LspClient {
+  connectionManager;
+  constructor() {
+    this.connectionManager = getConnectionManager();
+  }
+  async start() {}
+  async stop() {
+    await this.connectionManager.closeAll();
+  }
+  async ensureDocumentOpen(workspaceRoot, filePath) {
+    const docManager = this.connectionManager.getDocumentManager(workspaceRoot);
+    if (docManager.isDocumentOpen(filePath)) {
+      return;
+    }
+    const content = fs2.readFileSync(filePath, "utf-8");
+    await this.connectionManager.openDocument(workspaceRoot, filePath, content);
+  }
+  async prepareRequest(filePath) {
+    const workspaceRoot = findProjectRoot(filePath);
+    log(`Workspace root: ${workspaceRoot}`);
+    await this.connectionManager.getConnection({ workspaceRoot });
+    await this.ensureDocumentOpen(workspaceRoot, filePath);
+    return workspaceRoot;
+  }
+  getDocumentUri(workspaceRoot, filePath) {
+    return this.connectionManager.getDocumentManager(workspaceRoot).filePathToUri(filePath);
+  }
+  async hover(filePath, position) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending hover request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/hover", {
+      textDocument: { uri },
+      position
+    });
+  }
+  async definition(filePath, position) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending definition request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/definition", {
+      textDocument: { uri },
+      position
+    });
+  }
+  async references(filePath, position, includeDeclaration = true) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending references request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/references", {
+      textDocument: { uri },
+      position,
+      context: { includeDeclaration }
+    });
+  }
+  async completions(filePath, position) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending completions request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/completion", {
+      textDocument: { uri },
+      position
+    });
+  }
+  async signatureHelp(filePath, position) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending signatureHelp request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/signatureHelp", {
+      textDocument: { uri },
+      position
+    });
+  }
+  async rename(filePath, position, newName) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending rename request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/rename", {
+      textDocument: { uri },
+      position,
+      newName
+    });
+  }
+  async getDiagnostics(filePath) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const docManager = this.connectionManager.getDocumentManager(workspaceRoot);
+    if (docManager.isDocumentOpen(filePath)) {
+      await this.connectionManager.closeDocument(workspaceRoot, filePath);
+    }
+    await this.connectionManager.openDocument(workspaceRoot, filePath, content);
+    await new Promise((resolve3) => setTimeout(resolve3, 500));
+    log("Getting diagnostics via CLI");
+    return this.getDiagnosticsViaCli(filePath, workspaceRoot);
+  }
+  getDiagnosticsViaCli(filePath, workspaceRoot) {
+    const { execSync } = __require("child_process");
+    try {
+      const result = execSync(`pyright --outputjson "${filePath}"`, {
+        encoding: "utf-8",
+        cwd: workspaceRoot,
+        timeout: 30000,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const parsed = JSON.parse(result);
+      return this.convertPyrightDiagnostics(parsed);
+    } catch (error) {
+      if (error && typeof error === "object" && "stdout" in error) {
+        try {
+          const parsed = JSON.parse(error.stdout);
+          return this.convertPyrightDiagnostics(parsed);
+        } catch {}
+      }
+      return [];
+    }
+  }
+  convertPyrightDiagnostics(output) {
+    if (!output.generalDiagnostics) {
+      return [];
+    }
+    return output.generalDiagnostics.map((d) => ({
+      range: {
+        start: { line: d.range.start.line, character: d.range.start.character },
+        end: { line: d.range.end.line, character: d.range.end.character }
+      },
+      severity: d.severity,
+      message: d.message,
+      source: "pyright",
+      code: d.rule
+    }));
+  }
+  async documentSymbols(filePath) {
+    const workspaceRoot = await this.prepareRequest(filePath);
+    const uri = this.getDocumentUri(workspaceRoot, filePath);
+    log("Sending documentSymbol request");
+    return await this.connectionManager.sendRequest(workspaceRoot, "textDocument/documentSymbol", {
+      textDocument: { uri }
+    });
+  }
+  async updateDocument(filePath, content) {
+    const workspaceRoot = findProjectRoot(filePath);
+    await this.connectionManager.getConnection({ workspaceRoot });
+    await this.connectionManager.updateDocument(workspaceRoot, filePath, content);
+    log(`Updated document: ${filePath}`);
+  }
+  getStatus() {
+    return this.connectionManager.getStatus();
+  }
+}
+var client = null;
+function getLspClient() {
+  if (!client) {
+    client = new LspClient;
+  }
+  return client;
+}
+async function shutdownLspClient() {
+  if (client) {
+    await client.stop();
+    client = null;
+  }
+}
+
+// src/tools/hover.ts
+var hoverSchema = {
+  file: z.string().describe("Absolute path to the Python file"),
+  line: z.number().int().positive().describe("Line number (1-based)"),
+  column: z.number().int().positive().describe("Column number (1-based)")
+};
+async function hover(args) {
+  console.error(`[hover] Starting hover for ${args.file}:${args.line}:${args.column}`);
+  const client2 = getLspClient();
+  const position = toPosition(args.line, args.column);
+  console.error(`[hover] Calling LSP hover...`);
+  const result = await client2.hover(args.file, position);
+  console.error(`[hover] Got result: ${result ? "yes" : "no"}`);
+  if (!result) {
+    return {
+      content: [{ type: "text", text: "No hover information available at this position." }]
+    };
+  }
+  let hoverText = "";
+  if (typeof result.contents === "string") {
+    hoverText = result.contents;
+  } else if (Array.isArray(result.contents)) {
+    hoverText = result.contents.map((c) => typeof c === "string" ? c : c.value).join(`
+
+`);
+  } else if ("kind" in result.contents) {
+    hoverText = result.contents.value;
+  } else if ("value" in result.contents) {
+    hoverText = result.contents.value;
+  }
+  let output = `**Hover Info** at ${args.file}:${args.line}:${args.column}
+
+`;
+  output += hoverText;
+  if (result.range) {
+    output += `
+
+**Range:** ${formatRange(result.range)}`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/definition.ts
+import { z as z2 } from "zod";
+var definitionSchema = {
+  file: z2.string().describe("Absolute path to the Python file"),
+  line: z2.number().int().positive().describe("Line number (1-based)"),
+  column: z2.number().int().positive().describe("Column number (1-based)")
+};
+async function definition(args) {
+  const client2 = getLspClient();
+  const position = toPosition(args.line, args.column);
+  const result = await client2.definition(args.file, position);
+  if (!result) {
+    return {
+      content: [{ type: "text", text: "No definition found at this position." }]
+    };
+  }
+  const locations = [];
+  if (Array.isArray(result)) {
+    for (const item of result) {
+      if ("targetUri" in item) {
+        const link = item;
+        const pos = fromPosition(link.targetSelectionRange.start);
+        locations.push({
+          file: uriToPath(link.targetUri),
+          line: pos.line,
+          column: pos.column
+        });
+      } else {
+        const loc = item;
+        const pos = fromPosition(loc.range.start);
+        locations.push({
+          file: uriToPath(loc.uri),
+          line: pos.line,
+          column: pos.column
+        });
+      }
+    }
+  } else {
+    const loc = result;
+    const pos = fromPosition(loc.range.start);
+    locations.push({
+      file: uriToPath(loc.uri),
+      line: pos.line,
+      column: pos.column
+    });
+  }
+  if (locations.length === 0) {
+    return {
+      content: [{ type: "text", text: "No definition found at this position." }]
+    };
+  }
+  let output = `**Definition(s)** for symbol at ${args.file}:${args.line}:${args.column}
+
+`;
+  for (const loc of locations) {
+    output += `- ${loc.file}:${loc.line}:${loc.column}
+`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/references.ts
+import { z as z3 } from "zod";
+import { execSync } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+var referencesSchema = {
+  file: z3.string().describe("Absolute path to the Python file"),
+  line: z3.number().int().positive().describe("Line number (1-based)"),
+  column: z3.number().int().positive().describe("Column number (1-based)")
+};
+function getSymbolAtPosition(filePath, line, column) {
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    const targetLine = lines[line - 1];
+    if (!targetLine)
+      return null;
+    const col = column - 1;
+    let start = col;
+    let end = col;
+    while (start > 0 && /[\w_]/.test(targetLine[start - 1])) {
+      start--;
+    }
+    while (end < targetLine.length && /[\w_]/.test(targetLine[end])) {
+      end++;
+    }
+    const symbol = targetLine.slice(start, end);
+    return symbol.length > 0 ? symbol : null;
+  } catch {
+    return null;
+  }
+}
+async function references(args) {
+  const { file, line, column } = args;
+  const symbol = getSymbolAtPosition(file, line, column);
+  if (!symbol) {
+    return {
+      content: [{ type: "text", text: "Could not identify symbol at this position." }]
+    };
+  }
+  const projectRoot = findProjectRoot(file);
+  const pattern = `\\b${symbol}\\b`;
+  let rgOutput;
+  try {
+    rgOutput = execSync(`rg --no-heading --line-number --column --type py "${pattern}" "${projectRoot}"`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 30000
+    });
+  } catch (e) {
+    const error = e;
+    if (error.status === 1) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No references found for symbol \`${symbol}\``
+          }
+        ]
+      };
+    }
+    try {
+      rgOutput = execSync(`grep -rn --include="*.py" -w "${symbol}" "${projectRoot}"`, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 30000
+      });
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No references found for symbol \`${symbol}\``
+          }
+        ]
+      };
+    }
+  }
+  const refs = [];
+  const lines = rgOutput.trim().split(`
+`).filter(Boolean);
+  for (const outputLine of lines) {
+    const match = outputLine.match(/^(.+?):(\d+):(\d+):(.*)$/);
+    if (match) {
+      const [, filePath, lineNum, colNum, text] = match;
+      refs.push({
+        file: filePath,
+        line: parseInt(lineNum, 10),
+        column: parseInt(colNum, 10),
+        text: text.trim(),
+        isDefinition: filePath === file && parseInt(lineNum, 10) === line
+      });
+    } else {
+      const grepMatch = outputLine.match(/^(.+?):(\d+):(.*)$/);
+      if (grepMatch) {
+        const [, filePath, lineNum, text] = grepMatch;
+        refs.push({
+          file: filePath,
+          line: parseInt(lineNum, 10),
+          column: 1,
+          text: text.trim(),
+          isDefinition: filePath === file && parseInt(lineNum, 10) === line
+        });
+      }
+    }
+  }
+  if (refs.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No references found for symbol \`${symbol}\``
+        }
+      ]
+    };
+  }
+  refs.sort((a, b) => {
+    if (a.isDefinition && !b.isDefinition)
+      return -1;
+    if (!a.isDefinition && b.isDefinition)
+      return 1;
+    if (a.file !== b.file)
+      return a.file.localeCompare(b.file);
+    return a.line - b.line;
+  });
+  const byFile = new Map;
+  for (const ref of refs) {
+    const list = byFile.get(ref.file) || [];
+    list.push(ref);
+    byFile.set(ref.file, list);
+  }
+  let output = `**References** for \`${symbol}\`
+
+`;
+  output += `Found ${refs.length} reference(s) in ${byFile.size} file(s):
+
+`;
+  for (const [filePath, fileRefs] of byFile) {
+    output += `### ${filePath}
+
+`;
+    for (const ref of fileRefs) {
+      const marker = ref.isDefinition ? " (definition)" : "";
+      output += `- **${ref.line}:${ref.column}**${marker}: \`${ref.text}\`
+`;
+    }
+    output += `
+`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/completions.ts
+import { z as z4 } from "zod";
+import { CompletionItemKind } from "vscode-languageserver-protocol";
+var completionsSchema = {
+  file: z4.string().describe("Absolute path to the Python file"),
+  line: z4.number().int().positive().describe("Line number (1-based)"),
+  column: z4.number().int().positive().describe("Column number (1-based)"),
+  limit: z4.number().int().positive().optional().default(20).describe("Maximum number of completions to return")
+};
+var kindNames = {
+  [CompletionItemKind.Text]: "Text",
+  [CompletionItemKind.Method]: "Method",
+  [CompletionItemKind.Function]: "Function",
+  [CompletionItemKind.Constructor]: "Constructor",
+  [CompletionItemKind.Field]: "Field",
+  [CompletionItemKind.Variable]: "Variable",
+  [CompletionItemKind.Class]: "Class",
+  [CompletionItemKind.Interface]: "Interface",
+  [CompletionItemKind.Module]: "Module",
+  [CompletionItemKind.Property]: "Property",
+  [CompletionItemKind.Unit]: "Unit",
+  [CompletionItemKind.Value]: "Value",
+  [CompletionItemKind.Enum]: "Enum",
+  [CompletionItemKind.Keyword]: "Keyword",
+  [CompletionItemKind.Snippet]: "Snippet",
+  [CompletionItemKind.Color]: "Color",
+  [CompletionItemKind.File]: "File",
+  [CompletionItemKind.Reference]: "Reference",
+  [CompletionItemKind.Folder]: "Folder",
+  [CompletionItemKind.EnumMember]: "EnumMember",
+  [CompletionItemKind.Constant]: "Constant",
+  [CompletionItemKind.Struct]: "Struct",
+  [CompletionItemKind.Event]: "Event",
+  [CompletionItemKind.Operator]: "Operator",
+  [CompletionItemKind.TypeParameter]: "TypeParameter"
+};
+async function completions(args) {
+  const client2 = getLspClient();
+  const position = toPosition(args.line, args.column);
+  const limit = args.limit ?? 20;
+  const result = await client2.completions(args.file, position);
+  if (!result) {
+    return {
+      content: [{ type: "text", text: "No completions available at this position." }]
+    };
+  }
+  let items;
+  if (Array.isArray(result)) {
+    items = result;
+  } else {
+    items = result.items;
+  }
+  if (items.length === 0) {
+    return {
+      content: [{ type: "text", text: "No completions available at this position." }]
+    };
+  }
+  const limitedItems = items.slice(0, limit);
+  let output = `**Completions** at ${args.file}:${args.line}:${args.column}
+
+`;
+  output += `Showing ${limitedItems.length} of ${items.length} completion(s):
+
+`;
+  for (const item of limitedItems) {
+    const kind = item.kind ? kindNames[item.kind] || "Unknown" : "Unknown";
+    const detail = item.detail ? ` - ${item.detail}` : "";
+    output += `- **${item.label}** (${kind})${detail}
+`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/diagnostics.ts
+import { z as z5 } from "zod";
+import { execSync as execSync2 } from "child_process";
+var diagnosticsSchema = {
+  path: z5.string().describe("Path to a Python file or directory to check")
+};
+async function diagnostics(args) {
+  const { path: path2 } = args;
+  const projectRoot = findProjectRoot(path2);
+  const target = path2;
+  const cmd = `pyright "${target}" --outputjson`;
+  let output;
+  try {
+    const result = execSync2(cmd, {
+      encoding: "utf-8",
+      cwd: projectRoot,
+      timeout: 60000,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    output = JSON.parse(result);
+  } catch (e) {
+    const error = e;
+    if (error.stdout) {
+      try {
+        output = JSON.parse(error.stdout);
+      } catch {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error running pyright: ${error.message || "Unknown error"}`
+            }
+          ]
+        };
+      }
+    } else {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error running pyright: ${error.message || "Unknown error"}
+
+Make sure pyright is installed: npm install -g pyright`
+          }
+        ]
+      };
+    }
+  }
+  const diags = output.generalDiagnostics || [];
+  const summary = output.summary;
+  if (diags.length === 0) {
+    let text2 = `**No issues found**
+
+`;
+    text2 += `- Files analyzed: ${summary.filesAnalyzed}
+`;
+    text2 += `- Time: ${summary.timeInSec}s`;
+    return {
+      content: [{ type: "text", text: text2 }]
+    };
+  }
+  const byFile = new Map;
+  for (const diag of diags) {
+    const list = byFile.get(diag.file) || [];
+    list.push(diag);
+    byFile.set(diag.file, list);
+  }
+  let text = `**Diagnostics Summary**
+
+`;
+  text += `- Errors: ${summary.errorCount}
+`;
+  text += `- Warnings: ${summary.warningCount}
+`;
+  text += `- Information: ${summary.informationCount}
+`;
+  text += `- Files analyzed: ${summary.filesAnalyzed}
+`;
+  text += `- Time: ${summary.timeInSec}s
+
+`;
+  text += `---
+
+`;
+  for (const [filePath, fileDiags] of byFile) {
+    text += `### ${filePath}
+
+`;
+    for (const diag of fileDiags) {
+      const line = diag.range.start.line + 1;
+      const col = diag.range.start.character + 1;
+      const rule = diag.rule ? ` (${diag.rule})` : "";
+      const icon = diag.severity === "error" ? "❌" : diag.severity === "warning" ? "⚠️" : "ℹ️";
+      text += `- ${icon} **${diag.severity}** at ${line}:${col}${rule}
+`;
+      text += `  ${diag.message}
+
+`;
+    }
+  }
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+
+// src/tools/signature-help.ts
+import { z as z6 } from "zod";
+var signatureHelpSchema = {
+  file: z6.string().describe("Absolute path to the Python file"),
+  line: z6.number().int().positive().describe("Line number (1-based)"),
+  column: z6.number().int().positive().describe("Column number (1-based)")
+};
+async function signatureHelp(args) {
+  const client2 = getLspClient();
+  const position = toPosition(args.line, args.column);
+  const result = await client2.signatureHelp(args.file, position);
+  if (!result || result.signatures.length === 0) {
+    return {
+      content: [{ type: "text", text: "No signature help available at this position." }]
+    };
+  }
+  let output = `**Signature Help** at ${args.file}:${args.line}:${args.column}
+
+`;
+  const activeIndex = result.activeSignature ?? 0;
+  const activeParam = result.activeParameter ?? 0;
+  for (let i = 0;i < result.signatures.length; i++) {
+    const sig = result.signatures[i];
+    const isActive = i === activeIndex;
+    output += `${isActive ? "→ " : "  "}**${sig.label}**
+`;
+    if (sig.documentation) {
+      const doc = typeof sig.documentation === "string" ? sig.documentation : sig.documentation.value;
+      output += `  ${doc}
+`;
+    }
+    if (sig.parameters && sig.parameters.length > 0) {
+      output += `
+  Parameters:
+`;
+      for (let j = 0;j < sig.parameters.length; j++) {
+        const param = sig.parameters[j];
+        const isActiveParam = isActive && j === activeParam;
+        const label = typeof param.label === "string" ? param.label : sig.label.slice(param.label[0], param.label[1]);
+        output += `  ${isActiveParam ? "→ " : "  "}${label}`;
+        if (param.documentation) {
+          const paramDoc = typeof param.documentation === "string" ? param.documentation : param.documentation.value;
+          output += ` - ${paramDoc}`;
+        }
+        output += `
+`;
+      }
+    }
+    output += `
+`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/rename.ts
+import { z as z7 } from "zod";
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+var renameSchema = {
+  file: z7.string().describe("Absolute path to the Python file"),
+  line: z7.number().int().positive().describe("Line number (1-based)"),
+  column: z7.number().int().positive().describe("Column number (1-based)"),
+  newName: z7.string().describe("New name for the symbol")
+};
+function getSymbolAtPosition2(filePath, line, column) {
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    const targetLine = lines[line - 1];
+    if (!targetLine)
+      return null;
+    const col = column - 1;
+    let start = col;
+    let end = col;
+    while (start > 0 && /[\w_]/.test(targetLine[start - 1])) {
+      start--;
+    }
+    while (end < targetLine.length && /[\w_]/.test(targetLine[end])) {
+      end++;
+    }
+    const symbol = targetLine.slice(start, end);
+    return symbol.length > 0 ? { symbol, start: start + 1, end: end + 1 } : null;
+  } catch {
+    return null;
+  }
+}
+async function rename(args) {
+  const { file, line, column, newName } = args;
+  const symbolInfo = getSymbolAtPosition2(file, line, column);
+  if (!symbolInfo) {
+    return {
+      content: [{ type: "text", text: "Could not identify symbol at this position." }]
+    };
+  }
+  const { symbol: oldName } = symbolInfo;
+  if (oldName === newName) {
+    return {
+      content: [{ type: "text", text: "New name is the same as the old name." }]
+    };
+  }
+  const projectRoot = findProjectRoot(file);
+  const pattern = `\\b${oldName}\\b`;
+  let rgOutput;
+  try {
+    rgOutput = execSync3(`rg --no-heading --line-number --column --type py "${pattern}" "${projectRoot}"`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 30000
+    });
+  } catch (e) {
+    const error = e;
+    if (error.status === 1) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No references found for symbol \`${oldName}\``
+          }
+        ]
+      };
+    }
+    try {
+      rgOutput = execSync3(`grep -rn --include="*.py" -w "${oldName}" "${projectRoot}"`, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 30000
+      });
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No references found for symbol \`${oldName}\``
+          }
+        ]
+      };
+    }
+  }
+  const edits = [];
+  const outputLines = rgOutput.trim().split(`
+`).filter(Boolean);
+  for (const outputLine of outputLines) {
+    const match = outputLine.match(/^(.+?):(\d+):(\d+):(.*)$/);
+    if (match) {
+      const [, filePath, lineNum, colNum, lineContent] = match;
+      const col = parseInt(colNum, 10);
+      edits.push({
+        file: filePath,
+        line: parseInt(lineNum, 10),
+        column: col,
+        endColumn: col + oldName.length,
+        oldText: oldName,
+        newText: newName,
+        lineContent: lineContent.trim()
+      });
+    }
+  }
+  if (edits.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No references found for symbol \`${oldName}\``
+        }
+      ]
+    };
+  }
+  const byFile = new Map;
+  for (const edit of edits) {
+    const list = byFile.get(edit.file) || [];
+    list.push(edit);
+    byFile.set(edit.file, list);
+  }
+  let output = `**Rename Preview**
+
+`;
+  output += `- Symbol: \`${oldName}\` → \`${newName}\`
+`;
+  output += `- Found ${edits.length} occurrence(s) in ${byFile.size} file(s)
+
+`;
+  output += `---
+
+`;
+  for (const [filePath, fileEdits] of byFile) {
+    output += `### ${filePath}
+
+`;
+    for (const edit of fileEdits) {
+      const preview = edit.lineContent.replace(new RegExp(`\\b${oldName}\\b`), `~~${oldName}~~ **${newName}**`);
+      output += `- Line ${edit.line}: ${preview}
+`;
+    }
+    output += `
+`;
+  }
+  output += `---
+
+`;
+  output += `**Note:** This is a preview only. To apply the rename, use your editor's rename feature or run:
+`;
+  output += `\`\`\`bash
+`;
+  output += `# Using sed (backup recommended)
+`;
+  output += `find "${projectRoot}" -name "*.py" -exec sed -i '' 's/\\b${oldName}\\b/${newName}/g' {} +
+`;
+  output += `\`\`\``;
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/search.ts
+import { z as z8 } from "zod";
+import { execSync as execSync4 } from "child_process";
+import * as path2 from "path";
+var searchSchema = {
+  pattern: z8.string().describe("The regex pattern to search for"),
+  path: z8.string().optional().describe("Directory or file to search in (defaults to current working directory)"),
+  glob: z8.string().optional().describe('Glob pattern to filter files (e.g., "*.py", "**/*.ts")'),
+  caseSensitive: z8.boolean().optional().default(true).describe("Whether the search is case sensitive"),
+  maxResults: z8.number().int().positive().optional().default(50).describe("Maximum number of results to return")
+};
+async function search(args) {
+  const searchPath = args.path || process.cwd();
+  const caseSensitive = args.caseSensitive ?? true;
+  const maxResults = args.maxResults ?? 50;
+  const rgArgs = [
+    "--json",
+    "--line-number",
+    "--column"
+  ];
+  if (!caseSensitive) {
+    rgArgs.push("--ignore-case");
+  }
+  if (args.glob) {
+    rgArgs.push("--glob", args.glob);
+  }
+  rgArgs.push("--", args.pattern, searchPath);
+  try {
+    const result = execSync4(`rg ${rgArgs.map((a) => `'${a}'`).join(" ")}`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const results = [];
+    const lines = result.split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      if (results.length >= maxResults)
+        break;
+      try {
+        const json = JSON.parse(line);
+        if (json.type === "match") {
+          const data = json.data;
+          const filePath = data.path.text;
+          const lineNumber = data.line_number;
+          const lineText = data.lines.text.trimEnd();
+          for (const submatch of data.submatches) {
+            if (results.length >= maxResults)
+              break;
+            results.push({
+              file: path2.resolve(filePath),
+              line: lineNumber,
+              column: submatch.start + 1,
+              text: lineText,
+              match: submatch.match.text
+            });
+          }
+        }
+      } catch {}
+    }
+    if (results.length === 0) {
+      return {
+        content: [{ type: "text", text: `No matches found for pattern: ${args.pattern}` }]
+      };
+    }
+    let output = `**Search Results** for \`${args.pattern}\`
+
+`;
+    output += `Found ${results.length} match(es)${results.length >= maxResults ? ` (limited to ${maxResults})` : ""}:
+
+`;
+    for (const r of results) {
+      output += `**${r.file}:${r.line}:${r.column}**
+`;
+      output += `  \`${r.text}\`
+`;
+      output += `  Match: \`${r.match}\`
+
+`;
+    }
+    return {
+      content: [{ type: "text", text: output }]
+    };
+  } catch (err) {
+    const error = err;
+    if (error.status === 1) {
+      return {
+        content: [{ type: "text", text: `No matches found for pattern: ${args.pattern}` }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Search error: ${error.message || "Unknown error"}` }]
+    };
+  }
+}
+
+// src/tools/status.ts
+import { z as z9 } from "zod";
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join2 } from "path";
+var statusSchema = {
+  file: z9.string().describe("A Python file path to check the project status for")
+};
+async function status(args) {
+  const { file } = args;
+  const lines = [];
+  const projectRoot = findProjectRoot(file);
+  lines.push(`## Project Root`);
+  lines.push(`\`${projectRoot}\``);
+  lines.push("");
+  lines.push(`## Pyright`);
+  try {
+    const pyrightVersion = execSync5("pyright --version", { encoding: "utf-8" }).trim();
+    lines.push(`- Version: ${pyrightVersion}`);
+  } catch {
+    lines.push(`- ⚠️ **Not installed or not in PATH**`);
+    lines.push(`  Install with: \`npm install -g pyright\``);
+  }
+  lines.push("");
+  lines.push(`## Pyright Config`);
+  const pyrightConfigPath = join2(projectRoot, "pyrightconfig.json");
+  const pyprojectPath = join2(projectRoot, "pyproject.toml");
+  if (existsSync2(pyrightConfigPath)) {
+    lines.push(`- Config file: \`pyrightconfig.json\``);
+    try {
+      const config = JSON.parse(readFileSync5(pyrightConfigPath, "utf-8"));
+      if (config.pythonVersion) {
+        lines.push(`- Python version: ${config.pythonVersion}`);
+      }
+      if (config.pythonPlatform) {
+        lines.push(`- Platform: ${config.pythonPlatform}`);
+      }
+      if (config.venvPath) {
+        lines.push(`- Venv path: ${config.venvPath}`);
+      }
+      if (config.venv) {
+        lines.push(`- Venv: ${config.venv}`);
+      }
+      if (config.typeCheckingMode) {
+        lines.push(`- Type checking mode: ${config.typeCheckingMode}`);
+      }
+      if (config.include) {
+        lines.push(`- Include: ${JSON.stringify(config.include)}`);
+      }
+      if (config.exclude) {
+        lines.push(`- Exclude: ${JSON.stringify(config.exclude)}`);
+      }
+    } catch (e) {
+      lines.push(`- ⚠️ Failed to parse config: ${e}`);
+    }
+  } else if (existsSync2(pyprojectPath)) {
+    lines.push(`- Config file: \`pyproject.toml\` (may contain [tool.pyright] section)`);
+  } else {
+    lines.push(`- ⚠️ No pyrightconfig.json or pyproject.toml found`);
+    lines.push(`  Pyright will use default settings`);
+  }
+  lines.push("");
+  lines.push(`## Python Environment`);
+  try {
+    const pythonVersion = execSync5("python3 --version", { encoding: "utf-8" }).trim();
+    lines.push(`- System Python: ${pythonVersion}`);
+  } catch {
+    try {
+      const pythonVersion = execSync5("python --version", { encoding: "utf-8" }).trim();
+      lines.push(`- System Python: ${pythonVersion}`);
+    } catch {
+      lines.push(`- ⚠️ Python not found in PATH`);
+    }
+  }
+  const venvPaths = [".venv", "venv", ".env", "env"];
+  for (const venv of venvPaths) {
+    const venvPath = join2(projectRoot, venv);
+    if (existsSync2(venvPath)) {
+      lines.push(`- Virtual env found: \`${venv}/\``);
+      const venvPython = join2(venvPath, "bin", "python");
+      if (existsSync2(venvPython)) {
+        try {
+          const venvVersion = execSync5(`"${venvPython}" --version`, { encoding: "utf-8" }).trim();
+          lines.push(`  - ${venvVersion}`);
+        } catch {}
+      }
+      break;
+    }
+  }
+  lines.push("");
+  lines.push(`## File Check`);
+  lines.push(`- File: \`${file}\``);
+  if (existsSync2(file)) {
+    lines.push(`- Exists: ✅`);
+    try {
+      const result = execSync5(`pyright "${file}" --outputjson`, {
+        encoding: "utf-8",
+        cwd: projectRoot,
+        timeout: 30000
+      });
+      const output = JSON.parse(result);
+      const errors = output.generalDiagnostics?.filter((d) => d.severity === "error")?.length || 0;
+      const warnings = output.generalDiagnostics?.filter((d) => d.severity === "warning")?.length || 0;
+      lines.push(`- Diagnostics: ${errors} errors, ${warnings} warnings`);
+    } catch (e) {
+      const error = e;
+      if (error.stdout) {
+        try {
+          const output = JSON.parse(error.stdout);
+          const errors = output.generalDiagnostics?.filter((d) => d.severity === "error")?.length || 0;
+          const warnings = output.generalDiagnostics?.filter((d) => d.severity === "warning")?.length || 0;
+          lines.push(`- Diagnostics: ${errors} errors, ${warnings} warnings`);
+        } catch {
+          lines.push(`- ⚠️ Could not run pyright check`);
+        }
+      } else {
+        lines.push(`- ⚠️ Could not run pyright check`);
+      }
+    }
+  } else {
+    lines.push(`- Exists: ❌ File not found`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join(`
+`) }]
+  };
+}
+
+// src/tools/symbols.ts
+import { z as z10 } from "zod";
+import { SymbolKind } from "vscode-languageserver-protocol";
+var symbolsSchema = {
+  file: z10.string().describe("Absolute path to the Python file"),
+  filter: z10.enum(["all", "classes", "functions", "methods", "variables"]).optional().default("all").describe("Filter symbols by type"),
+  includeChildren: z10.boolean().optional().default(true).describe("Include nested symbols (e.g., methods inside classes)")
+};
+function getSymbolKindName(kind) {
+  return SymbolKindNames[kind] || "Unknown";
+}
+function matchesFilter(kind, filter) {
+  if (filter === "all") {
+    return true;
+  }
+  switch (filter) {
+    case "classes":
+      return kind === SymbolKind.Class;
+    case "functions":
+      return kind === SymbolKind.Function;
+    case "methods":
+      return kind === SymbolKind.Method;
+    case "variables":
+      return kind === SymbolKind.Variable || kind === SymbolKind.Constant;
+    default:
+      return true;
+  }
+}
+function formatSymbol(symbol, filter, includeChildren, indent = 0) {
+  const lines = [];
+  const indentStr = "  ".repeat(indent);
+  const kindName = getSymbolKindName(symbol.kind);
+  const line = symbol.range.start.line + 1;
+  const symbolMatches = matchesFilter(symbol.kind, filter);
+  if (symbolMatches) {
+    lines.push(`${indentStr}- **${symbol.name}** (${kindName}) at line ${line}`);
+  }
+  if (includeChildren && symbol.children && symbol.children.length > 0) {
+    for (const child of symbol.children) {
+      const childLines = formatSymbol(child, filter, includeChildren, symbolMatches ? indent + 1 : indent);
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+function isDocumentSymbolArray(result) {
+  return Array.isArray(result) && result.length > 0 && "range" in result[0];
+}
+async function symbols(args) {
+  const filter = args.filter || "all";
+  const includeChildren = args.includeChildren !== false;
+  console.error(`[symbols] Getting symbols for ${args.file} (filter: ${filter})`);
+  const client2 = getLspClient();
+  const result = await client2.documentSymbols(args.file);
+  console.error(`[symbols] Got result: ${result ? `${result.length} symbols` : "no"}`);
+  if (!result || Array.isArray(result) && result.length === 0) {
+    return {
+      content: [{ type: "text", text: `No symbols found in ${args.file}` }]
+    };
+  }
+  let output = `**Symbols** in ${args.file}
+
+`;
+  if (isDocumentSymbolArray(result)) {
+    const lines = [];
+    for (const symbol of result) {
+      lines.push(...formatSymbol(symbol, filter, includeChildren));
+    }
+    if (lines.length === 0) {
+      output += `No ${filter} symbols found.`;
+    } else {
+      output += lines.join(`
+`);
+    }
+  } else {
+    const filteredSymbols = result.filter((s) => matchesFilter(s.kind, filter));
+    if (filteredSymbols.length === 0) {
+      output += `No ${filter} symbols found.`;
+    } else {
+      for (const symbol of filteredSymbols) {
+        const kindName = getSymbolKindName(symbol.kind);
+        const line = symbol.location.range.start.line + 1;
+        output += `- **${symbol.name}** (${kindName}) at line ${line}
+`;
+      }
+    }
+  }
+  return {
+    content: [{ type: "text", text: output.trim() }]
+  };
+}
+
+// src/tools/update-document.ts
+import { z as z11 } from "zod";
+var updateDocumentSchema = {
+  file: z11.string().describe("Absolute path to the Python file"),
+  content: z11.string().describe("New content for the file")
+};
+async function updateDocument(args) {
+  console.error(`[updateDocument] Updating ${args.file}`);
+  const client2 = getLspClient();
+  await client2.updateDocument(args.file, args.content);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Document updated: ${args.file}`
+      }
+    ]
+  };
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "pyright-mcp",
+  version: "1.0.0"
 });
-// Register hover tool
-server.tool('hover', 'Get type information and documentation at a specific position in a Python file', hoverSchema, async (args) => hover(args));
-// Register definition tool
-server.tool('definition', 'Go to definition of a symbol at a specific position in a Python file', definitionSchema, async (args) => definition(args));
-// Register references tool
-server.tool('references', 'Find all references to a symbol at a specific position in a Python file', referencesSchema, async (args) => references(args));
-// Register completions tool
-server.tool('completions', 'Get code completion suggestions at a specific position in a Python file', completionsSchema, async (args) => completions(args));
-// Register diagnostics tool
-server.tool('diagnostics', 'Get diagnostics (errors, warnings) for a Python file', diagnosticsSchema, async (args) => diagnostics(args));
-// Register signature help tool
-server.tool('signature_help', 'Get function signature help at a specific position in a Python file', signatureHelpSchema, async (args) => signatureHelp(args));
-// Register rename tool
-server.tool('rename', 'Preview renaming a symbol at a specific position in a Python file', renameSchema, async (args) => rename(args));
-// Register search tool
-server.tool('search', 'Search for a pattern in files and return file:line:column locations', searchSchema, async (args) => search(args));
-// Register status tool
-server.tool('status', 'Check Python/Pyright environment status for a project', statusSchema, async (args) => status(args));
-// Start the server
+server.tool("hover", "Get type information and documentation at a specific position in a Python file", hoverSchema, async (args) => hover(args));
+server.tool("definition", "Go to definition of a symbol at a specific position in a Python file", definitionSchema, async (args) => definition(args));
+server.tool("references", "Find all references to a symbol at a specific position in a Python file", referencesSchema, async (args) => references(args));
+server.tool("completions", "Get code completion suggestions at a specific position in a Python file", completionsSchema, async (args) => completions(args));
+server.tool("diagnostics", "Get diagnostics (errors, warnings) for a Python file", diagnosticsSchema, async (args) => diagnostics(args));
+server.tool("signature_help", "Get function signature help at a specific position in a Python file", signatureHelpSchema, async (args) => signatureHelp(args));
+server.tool("rename", "Preview renaming a symbol at a specific position in a Python file", renameSchema, async (args) => rename(args));
+server.tool("search", "Search for a pattern in files and return file:line:column locations", searchSchema, async (args) => search(args));
+server.tool("status", "Check Python/Pyright environment status for a project", statusSchema, async (args) => status(args));
+server.tool("symbols", "Extract symbols (classes, functions, methods, variables) from a Python file", symbolsSchema, async (args) => symbols(args));
+server.tool("update_document", "Update the content of an open Python file for incremental analysis", updateDocumentSchema, async (args) => updateDocument(args));
+async function gracefulShutdown(signal) {
+  console.error(`
+[Server] Received ${signal}, shutting down gracefully...`);
+  try {
+    await shutdownLspClient();
+    console.error("[Server] LSP connections closed");
+    await server.close();
+    console.error("[Server] MCP server closed");
+    process.exit(0);
+  } catch (error) {
+    console.error("[Server] Error during shutdown:", error);
+    process.exit(1);
+  }
+}
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
 async function main() {
-    console.error(`Pyright MCP server`);
-    console.error(`  Workspace: auto-detected from file path`);
-    // Initialize LSP client (lazy start on first request)
-    getLspClient();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`  Ready`);
+  console.error(`Pyright MCP server`);
+  console.error(`  Workspace: auto-detected from file path`);
+  getLspClient();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  console.error(`  Ready`);
 }
 main().catch((error) => {
-    console.error('Failed to start server:', error);
-    process.exit(1);
+  console.error("Failed to start server:", error);
+  process.exit(1);
 });
+
+//# debugId=6646DB737E47BEFC64756E2164756E21