@treedy/pyright-mcp 1.0.0 → 1.1.2

package/dist/tools/diagnostics.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const diagnosticsSchema: {
-    file: z.ZodString;
+    path: z.ZodString;
 };
 export declare function diagnostics(args: {
-    file: string;
+    path: string;
 }): Promise<{
     content: {
         type: "text";

package/dist/tools/diagnostics.js

@@ -1,35 +1,93 @@
 import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { fromPosition } from '../utils/position.js';
-import { DiagnosticSeverity } from 'vscode-languageserver-protocol';
+import { execSync } from 'child_process';
+import { findProjectRoot } from '../utils/position.js';
 export const diagnosticsSchema = {
-    file: z.string().describe('Absolute path to the Python file'),
-};
-const severityNames = {
-    [DiagnosticSeverity.Error]: 'Error',
-    [DiagnosticSeverity.Warning]: 'Warning',
-    [DiagnosticSeverity.Information]: 'Information',
-    [DiagnosticSeverity.Hint]: 'Hint',
+    path: z
+        .string()
+        .describe('Path to a Python file or directory to check'),
 };
 export async function diagnostics(args) {
-    const client = getLspClient();
-    const result = await client.getDiagnostics(args.file);
-    if (result.length === 0) {
+    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: `No diagnostics for ${args.file}` }],
+            content: [{ type: 'text', text }],
         };
     }
-    let output = `**Diagnostics** for ${args.file}\n\n`;
-    output += `Found ${result.length} issue(s):\n\n`;
-    for (const diag of result) {
-        const pos = fromPosition(diag.range.start);
-        const severity = diag.severity ? severityNames[diag.severity] || 'Unknown' : 'Unknown';
-        const source = diag.source ? `[${diag.source}] ` : '';
-        const code = diag.code ? ` (${diag.code})` : '';
-        output += `- **${severity}** at line ${pos.line}:${pos.column}${code}\n`;
-        output += `  ${source}${diag.message}\n\n`;
+    // 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: output }],
+        content: [{ type: 'text', text }],
     };
 }

package/dist/tools/references.d.ts

@@ -3,13 +3,11 @@ export declare const referencesSchema: {
     file: z.ZodString;
     line: z.ZodNumber;
     column: z.ZodNumber;
-    includeDeclaration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 };
 export declare function references(args: {
     file: string;
     line: number;
     column: number;
-    includeDeclaration?: boolean;
 }): Promise<{
     content: {
         type: "text";

package/dist/tools/references.js

@@ -1,26 +1,160 @@
 import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, fromPosition, uriToPath } from '../utils/position.js';
+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)'),
-    includeDeclaration: z.boolean().optional().default(true).describe('Include the declaration in results'),
 };
+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 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) {
+    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 at this position.' }],
+            content: [
+                {
+                    type: 'text',
+                    text: `No references found for symbol \`${symbol}\``,
+                },
+            ],
         };
     }
-    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`;
+    // 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 }],

package/dist/tools/rename.js

@@ -1,43 +1,152 @@
 import { z } from 'zod';
-import { getLspClient } from '../lsp-client.js';
-import { toPosition, fromPosition, uriToPath } from '../utils/position.js';
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { findProjectRoot } 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'),
 };
+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, start: start + 1, end: end + 1 } : null;
+    }
+    catch {
+        return null;
+    }
+}
 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) {
+    const { file, line, column, newName } = args;
+    // Get symbol name at position
+    const symbolInfo = getSymbolAtPosition(file, line, column);
+    if (!symbolInfo) {
         return {
-            content: [{ type: 'text', text: 'Cannot rename symbol at this position.' }],
+            content: [{ type: 'text', text: 'Could not identify 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';
+    const { symbol: oldName } = symbolInfo;
+    if (oldName === newName) {
+        return {
+            content: [{ type: 'text', text: 'New name is the same as the old name.' }],
+        };
+    }
+    // Find project root
+    const projectRoot = findProjectRoot(file);
+    // Use ripgrep to find all references in Python files
+    const pattern = `\\b${oldName}\\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 \`${oldName}\``,
+                    },
+                ],
+            };
+        }
+        // Try grep as fallback
+        try {
+            rgOutput = execSync(`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}\``,
+                    },
+                ],
+            };
         }
-        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);
+    // Parse output and create edits
+    const edits = [];
+    const outputLines = rgOutput.trim().split('\n').filter(Boolean);
+    for (const outputLine of outputLines) {
+        // Format: /path/to/file.py:10:5:    some code here
+        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}\``,
+                },
+            ],
+        };
+    }
+    // Group by file
+    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**\n\n`;
+    output += `- Symbol: \`${oldName}\` → \`${newName}\`\n`;
+    output += `- Found ${edits.length} occurrence(s) in ${byFile.size} file(s)\n\n`;
+    output += `---\n\n`;
+    for (const [filePath, fileEdits] of byFile) {
+        output += `### ${filePath}\n\n`;
+        for (const edit of fileEdits) {
+            const preview = edit.lineContent.replace(new RegExp(`\\b${oldName}\\b`), `~~${oldName}~~ **${newName}**`);
+            output += `- Line ${edit.line}: ${preview}\n`;
+        }
+        output += '\n';
     }
-    output += '\n**Note:** This is a preview. The actual rename has not been applied.';
+    output += `---\n\n`;
+    output += `**Note:** This is a preview only. To apply the rename, use your editor's rename feature or run:\n`;
+    output += `\`\`\`bash\n`;
+    output += `# Using sed (backup recommended)\n`;
+    output += `find "${projectRoot}" -name "*.py" -exec sed -i '' 's/\\b${oldName}\\b/${newName}/g' {} +\n`;
+    output += `\`\`\``;
     return {
         content: [{ type: 'text', text: output }],
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treedy/pyright-mcp",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "description": "MCP server exposing Pyright LSP features for Python code intelligence",
   "type": "module",
   "main": "dist/index.js",