@treedy/pyright-mcp 1.1.2 → 1.1.4

package/dist/lsp-client.js

@@ -1,80 +0,0 @@
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { findProjectRoot } from './utils/position.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const workerScript = resolve(__dirname, 'pyright-worker.mjs');
-function log(message) {
-    console.error(`[LSP] ${message}`);
-}
-export class LspClient {
-    constructor() {
-        // No longer stores workspace root - it's determined per-file
-    }
-    async start() {
-        // No-op, worker starts fresh for each request
-    }
-    async stop() {
-        // No-op
-    }
-    runWorker(method, filePath, args) {
-        // Automatically find project root from file path
-        const workspaceRoot = findProjectRoot(filePath);
-        log(`Workspace root: ${workspaceRoot}`);
-        const params = JSON.stringify({
-            workspaceRoot,
-            method,
-            filePath,
-            ...args,
-        });
-        log(`Running worker: ${method}`);
-        try {
-            const result = execSync(`node "${workerScript}" '${params.replace(/'/g, "'\\''")}'`, {
-                encoding: 'utf-8',
-                timeout: 30000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            const parsed = JSON.parse(result.trim());
-            if (parsed.success) {
-                log(`Worker success: ${method}`);
-                return parsed.result;
-            }
-            else {
-                throw new Error(parsed.error);
-            }
-        }
-        catch (error) {
-            log(`Worker error: ${error}`);
-            throw error;
-        }
-    }
-    async hover(filePath, position) {
-        return this.runWorker('hover', filePath, { position });
-    }
-    async definition(filePath, position) {
-        return this.runWorker('definition', filePath, { position });
-    }
-    async references(filePath, position, includeDeclaration = true) {
-        return this.runWorker('references', filePath, { position, includeDeclaration });
-    }
-    async completions(filePath, position) {
-        return this.runWorker('completions', filePath, { position });
-    }
-    async signatureHelp(filePath, position) {
-        return this.runWorker('signatureHelp', filePath, { position });
-    }
-    async rename(filePath, position, newName) {
-        return this.runWorker('rename', filePath, { position, newName });
-    }
-    async getDiagnostics(filePath) {
-        return this.runWorker('diagnostics', filePath, {});
-    }
-}
-let client = null;
-export function getLspClient() {
-    if (!client) {
-        client = new LspClient();
-    }
-    return client;
-}

package/dist/pyright-worker.mjs

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-// Standalone worker script that communicates with pyright-langserver
-// Uses vscode-jsonrpc for reliable LSP communication
-
-import { spawn } from 'child_process';
-import * as rpc from 'vscode-jsonrpc/node.js';
-import * as fs from 'fs';
-
-const args = JSON.parse(process.argv[2]);
-const { workspaceRoot, method, filePath, position, newName, includeDeclaration } = args;
-
-function log(msg) {
-  console.error(`[worker] ${msg}`);
-}
-
-function pathToUri(p) {
-  return p.startsWith('file://') ? p : `file://${p}`;
-}
-
-// Create process and connection at module level like the working test script
-const proc = spawn('pyright-langserver', ['--stdio'], {
-  stdio: ['pipe', 'pipe', 'pipe'],
-});
-
-proc.stderr.on('data', (data) => {
-  log(`stderr: ${data.toString().trim()}`);
-});
-
-const connection = rpc.createMessageConnection(
-  new rpc.StreamMessageReader(proc.stdout),
-  new rpc.StreamMessageWriter(proc.stdin)
-);
-
-connection.onError((err) => log(`Connection error: ${err}`));
-connection.onClose(() => log('Connection closed'));
-connection.listen();
-
-async function main() {
-  try {
-    // Initialize with simpler capabilities like the working test
-    log('Sending initialize...');
-    await connection.sendRequest('initialize', {
-      processId: process.pid,
-      rootUri: pathToUri(workspaceRoot),
-      capabilities: {
-        textDocument: {
-          hover: { contentFormat: ['markdown', 'plaintext'] },
-        },
-      },
-    });
-    log('Initialize done');
-
-    await connection.sendNotification('initialized', {});
-    log('Sent initialized notification');
-
-    // Open document
-    let uri = null;
-    if (filePath) {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      uri = pathToUri(filePath);
-
-      log(`Opening document: ${uri}`);
-      await connection.sendNotification('textDocument/didOpen', {
-        textDocument: {
-          uri,
-          languageId: 'python',
-          version: 1,
-          text: content,
-        },
-      });
-
-      // Wait for analysis
-      log('Waiting for analysis...');
-      await new Promise((r) => setTimeout(r, 2000));
-    }
-
-    let result;
-
-    switch (method) {
-      case 'hover':
-        log(`Sending hover request at ${JSON.stringify(position)}`);
-        result = await connection.sendRequest('textDocument/hover', {
-          textDocument: { uri },
-          position,
-        });
-        break;
-
-      case 'definition':
-        log('Sending definition request');
-        result = await connection.sendRequest('textDocument/definition', {
-          textDocument: { uri },
-          position,
-        });
-        break;
-
-      case 'references':
-        log('Sending references request');
-        result = await connection.sendRequest('textDocument/references', {
-          textDocument: { uri },
-          position,
-          context: { includeDeclaration: includeDeclaration !== false },
-        });
-        break;
-
-      case 'completions':
-        log('Sending completions request');
-        result = await connection.sendRequest('textDocument/completion', {
-          textDocument: { uri },
-          position,
-        });
-        break;
-
-      case 'signatureHelp':
-        log('Sending signatureHelp request');
-        result = await connection.sendRequest('textDocument/signatureHelp', {
-          textDocument: { uri },
-          position,
-        });
-        break;
-
-      case 'rename':
-        log('Sending rename request');
-        result = await connection.sendRequest('textDocument/rename', {
-          textDocument: { uri },
-          position,
-          newName,
-        });
-        break;
-
-      case 'diagnostics':
-        result = [];
-        break;
-
-      default:
-        throw new Error(`Unknown method: ${method}`);
-    }
-
-    console.log(JSON.stringify({ success: true, result }));
-  } catch (error) {
-    console.log(JSON.stringify({ success: false, error: error.message }));
-  } finally {
-    connection.dispose();
-    proc.kill();
-    process.exit(0);
-  }
-}
-
-main();

package/dist/tools/completions.js

@@ -1,71 +0,0 @@
-import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition } from '../utils/position.js';
-import { CompletionItemKind } from 'vscode-languageserver-protocol';
-export const completionsSchema = {
-    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)'),
-    limit: z.number().int().positive().optional().default(20).describe('Maximum number of completions to return'),
-};
-const 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',
-};
-export async function completions(args) {
-    const client = getLspClient();
-    const position = toPosition(args.line, args.column);
-    const limit = args.limit ?? 20;
-    const result = await client.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}\n\n`;
-    output += `Showing ${limitedItems.length} of ${items.length} completion(s):\n\n`;
-    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}\n`;
-    }
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}

package/dist/tools/definition.js

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, fromPosition, uriToPath } from '../utils/position.js';
-export const definitionSchema = {
-    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)'),
-};
-export async function definition(args) {
-    const client = getLspClient();
-    const position = toPosition(args.line, args.column);
-    const result = await client.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) {
-                // LocationLink
-                const link = item;
-                const pos = fromPosition(link.targetSelectionRange.start);
-                locations.push({
-                    file: uriToPath(link.targetUri),
-                    line: pos.line,
-                    column: pos.column,
-                });
-            }
-            else {
-                // Location
-                const loc = item;
-                const pos = fromPosition(loc.range.start);
-                locations.push({
-                    file: uriToPath(loc.uri),
-                    line: pos.line,
-                    column: pos.column,
-                });
-            }
-        }
-    }
-    else {
-        // Single Location
-        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}\n\n`;
-    for (const loc of locations) {
-        output += `- ${loc.file}:${loc.line}:${loc.column}\n`;
-    }
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}

package/dist/tools/diagnostics.js

@@ -1,93 +0,0 @@
-import { z } from 'zod';
-import { execSync } from 'child_process';
-import { findProjectRoot } from '../utils/position.js';
-export const diagnosticsSchema = {
-    path: z
-        .string()
-        .describe('Path to a Python file or directory to check'),
-};
-export async function diagnostics(args) {
-    const { path } = args;
-    // Determine project root from path
-    const projectRoot = findProjectRoot(path);
-    // Build pyright command - path can be file or directory
-    const target = path;
-    const cmd = `pyright "${target}" --outputjson`;
-    let output;
-    try {
-        const result = execSync(cmd, {
-            encoding: 'utf-8',
-            cwd: projectRoot,
-            timeout: 60000,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        output = JSON.parse(result);
-    }
-    catch (e) {
-        const error = e;
-        // pyright returns non-zero exit code if there are errors
-        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'}\n\nMake sure pyright is installed: npm install -g pyright`,
-                    },
-                ],
-            };
-        }
-    }
-    const diags = output.generalDiagnostics || [];
-    const summary = output.summary;
-    if (diags.length === 0) {
-        let text = `**No issues found**\n\n`;
-        text += `- Files analyzed: ${summary.filesAnalyzed}\n`;
-        text += `- Time: ${summary.timeInSec}s`;
-        return {
-            content: [{ type: 'text', text }],
-        };
-    }
-    // Group by file
-    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**\n\n`;
-    text += `- Errors: ${summary.errorCount}\n`;
-    text += `- Warnings: ${summary.warningCount}\n`;
-    text += `- Information: ${summary.informationCount}\n`;
-    text += `- Files analyzed: ${summary.filesAnalyzed}\n`;
-    text += `- Time: ${summary.timeInSec}s\n\n`;
-    text += `---\n\n`;
-    for (const [filePath, fileDiags] of byFile) {
-        text += `### ${filePath}\n\n`;
-        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}\n`;
-            text += `  ${diag.message}\n\n`;
-        }
-    }
-    return {
-        content: [{ type: 'text', text }],
-    };
-}

package/dist/tools/hover.js

@@ -1,44 +0,0 @@
-import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, formatRange } from '../utils/position.js';
-export const 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)'),
-};
-export async function hover(args) {
-    console.error(`[hover] Starting hover for ${args.file}:${args.line}:${args.column}`);
-    const client = getLspClient();
-    const position = toPosition(args.line, args.column);
-    console.error(`[hover] Calling LSP hover...`);
-    const result = await client.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('\n\n');
-    }
-    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}\n\n`;
-    output += hoverText;
-    if (result.range) {
-        output += `\n\n**Range:** ${formatRange(result.range)}`;
-    }
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}

package/dist/tools/references.js

@@ -1,162 +0,0 @@
-import { z } from 'zod';
-import { execSync } from 'child_process';
-import { readFileSync } from 'fs';
-import { findProjectRoot } from '../utils/position.js';
-export const referencesSchema = {
-    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)'),
-};
-function getSymbolAtPosition(filePath, line, column) {
-    try {
-        const content = readFileSync(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const targetLine = lines[line - 1];
-        if (!targetLine)
-            return null;
-        // Find word at position
-        const col = column - 1;
-        let start = col;
-        let end = col;
-        // Expand left
-        while (start > 0 && /[\w_]/.test(targetLine[start - 1])) {
-            start--;
-        }
-        // Expand right
-        while (end < targetLine.length && /[\w_]/.test(targetLine[end])) {
-            end++;
-        }
-        const symbol = targetLine.slice(start, end);
-        return symbol.length > 0 ? symbol : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function references(args) {
-    const { file, line, column } = args;
-    // Get symbol name at position
-    const symbol = getSymbolAtPosition(file, line, column);
-    if (!symbol) {
-        return {
-            content: [{ type: 'text', text: 'Could not identify symbol at this position.' }],
-        };
-    }
-    // Find project root
-    const projectRoot = findProjectRoot(file);
-    // Use ripgrep to find all references in Python files
-    // Match word boundaries to avoid partial matches
-    const pattern = `\\b${symbol}\\b`;
-    let rgOutput;
-    try {
-        // Try ripgrep first
-        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) {
-            // No matches found
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No references found for symbol \`${symbol}\``,
-                    },
-                ],
-            };
-        }
-        // Try grep as fallback
-        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}\``,
-                    },
-                ],
-            };
-        }
-    }
-    // Parse ripgrep output: file:line:column:text
-    const refs = [];
-    const lines = rgOutput.trim().split('\n').filter(Boolean);
-    for (const outputLine of lines) {
-        // Format: /path/to/file.py:10:5:    some code here
-        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 {
-            // Fallback for grep format: /path/to/file.py:10:    some code here
-            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}\``,
-                },
-            ],
-        };
-    }
-    // Sort: definition first, then by file and line
-    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;
-    });
-    // Group by file
-    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}\`\n\n`;
-    output += `Found ${refs.length} reference(s) in ${byFile.size} file(s):\n\n`;
-    for (const [filePath, fileRefs] of byFile) {
-        output += `### ${filePath}\n\n`;
-        for (const ref of fileRefs) {
-            const marker = ref.isDefinition ? ' (definition)' : '';
-            output += `- **${ref.line}:${ref.column}**${marker}: \`${ref.text}\`\n`;
-        }
-        output += '\n';
-    }
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}