@treedy/pyright-mcp 1.1.1 → 1.1.3

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,28 +0,0 @@
-import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, fromPosition, uriToPath } 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)'),
-    includeDeclaration: z.boolean().optional().default(true).describe('Include the declaration in results'),
-};
-export async function references(args) {
-    const client = getLspClient();
-    const position = toPosition(args.line, args.column);
-    const result = await client.references(args.file, position, args.includeDeclaration ?? true);
-    if (!result || result.length === 0) {
-        return {
-            content: [{ type: 'text', text: 'No references found at this position.' }],
-        };
-    }
-    let output = `**References** for symbol at ${args.file}:${args.line}:${args.column}\n\n`;
-    output += `Found ${result.length} reference(s):\n\n`;
-    for (const loc of result) {
-        const pos = fromPosition(loc.range.start);
-        output += `- ${uriToPath(loc.uri)}:${pos.line}:${pos.column}\n`;
-    }
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}

package/dist/tools/rename.js

@@ -1,44 +0,0 @@
-import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, fromPosition, uriToPath } from '../utils/position.js';
-export const renameSchema = {
-    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)'),
-    newName: z.string().describe('New name for the symbol'),
-};
-export async function rename(args) {
-    const client = getLspClient();
-    const position = toPosition(args.line, args.column);
-    const result = await client.rename(args.file, position, args.newName);
-    if (!result) {
-        return {
-            content: [{ type: 'text', text: 'Cannot rename symbol at this position.' }],
-        };
-    }
-    let output = `**Rename Preview** for symbol at ${args.file}:${args.line}:${args.column}\n`;
-    output += `New name: **${args.newName}**\n\n`;
-    if (result.changes) {
-        let totalEdits = 0;
-        for (const [uri, edits] of Object.entries(result.changes)) {
-            const filePath = uriToPath(uri);
-            output += `**${filePath}**\n`;
-            for (const edit of edits) {
-                const start = fromPosition(edit.range.start);
-                const end = fromPosition(edit.range.end);
-                output += `  - Line ${start.line}:${start.column}-${end.line}:${end.column}: "${edit.newText}"\n`;
-                totalEdits++;
-            }
-            output += '\n';
-        }
-        output += `Total: ${totalEdits} edit(s) across ${Object.keys(result.changes).length} file(s)\n`;
-    }
-    else if (result.documentChanges) {
-        output += 'Document changes detected (complex rename operation)\n';
-        output += JSON.stringify(result.documentChanges, null, 2);
-    }
-    output += '\n**Note:** This is a preview. The actual rename has not been applied.';
-    return {
-        content: [{ type: 'text', text: output }],
-    };
-}

package/dist/tools/search.js

@@ -1,91 +0,0 @@
-import { z } from 'zod';
-import { execSync } from 'child_process';
-import * as path from 'path';
-export const searchSchema = {
-    pattern: z.string().describe('The regex pattern to search for'),
-    path: z.string().optional().describe('Directory or file to search in (defaults to current working directory)'),
-    glob: z.string().optional().describe('Glob pattern to filter files (e.g., "*.py", "**/*.ts")'),
-    caseSensitive: z.boolean().optional().default(true).describe('Whether the search is case sensitive'),
-    maxResults: z.number().int().positive().optional().default(50).describe('Maximum number of results to return'),
-};
-export async function search(args) {
-    const searchPath = args.path || process.cwd();
-    const caseSensitive = args.caseSensitive ?? true;
-    const maxResults = args.maxResults ?? 50;
-    // Build rg command
-    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 = execSync(`rg ${rgArgs.map(a => `'${a}'`).join(' ')}`, {
-            encoding: 'utf-8',
-            maxBuffer: 10 * 1024 * 1024, // 10MB
-        });
-        const results = [];
-        const lines = result.split('\n').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();
-                    // Get all matches in this line
-                    for (const submatch of data.submatches) {
-                        if (results.length >= maxResults)
-                            break;
-                        results.push({
-                            file: path.resolve(filePath),
-                            line: lineNumber,
-                            column: submatch.start + 1, // Convert to 1-based
-                            text: lineText,
-                            match: submatch.match.text,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Skip non-JSON lines
-            }
-        }
-        if (results.length === 0) {
-            return {
-                content: [{ type: 'text', text: `No matches found for pattern: ${args.pattern}` }],
-            };
-        }
-        let output = `**Search Results** for \`${args.pattern}\`\n\n`;
-        output += `Found ${results.length} match(es)${results.length >= maxResults ? ` (limited to ${maxResults})` : ''}:\n\n`;
-        for (const r of results) {
-            output += `**${r.file}:${r.line}:${r.column}**\n`;
-            output += `  \`${r.text}\`\n`;
-            output += `  Match: \`${r.match}\`\n\n`;
-        }
-        return {
-            content: [{ type: 'text', text: output }],
-        };
-    }
-    catch (err) {
-        const error = err;
-        if (error.status === 1) {
-            // rg returns 1 when no matches found
-            return {
-                content: [{ type: 'text', text: `No matches found for pattern: ${args.pattern}` }],
-            };
-        }
-        return {
-            content: [{ type: 'text', text: `Search error: ${error.message || 'Unknown error'}` }],
-        };
-    }
-}