syntax-map-mcp 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 1.2.0 - 2026-05-07
+
+- `lsp_diagnostics` 도구를 추가해 tree-sitter parse error 기반의 가벼운 문법 진단을 LSP Diagnostic 형태로 반환하도록 했습니다.
+- diagnostics 분석 계층에 provider 인터페이스를 추가해 이후 언어별 LSP 서버 진단 결과를 결합할 수 있게 했습니다.
+
+## 1.1.0 - 2026-05-07
+
+- Rust `.rs` 파일 파싱을 지원하고, `get_ast_tree`와 LSP document symbols, definition, references, hover, workspace symbols, completion, signature help에서 Rust 심볼을 처리하도록 했습니다.
+- Rust `struct`, `enum`, `trait`, `type`, `const`, `static`, `fn`, `impl` method, trait method signature를 심볼로 추출하도록 했습니다.
+
 ## 1.0.0 - 2026-05-07
 
 - AST tree 조회와 LSP document symbols, definition, references, hover, workspace symbols, completion, signature help 도구를 포함한 1.0.0 기준 기능 구성을 확정했습니다.

package/README.md

@@ -1,6 +1,6 @@
 # syntax-map-mcp
 
-Tree-sitter 기반 코드 분석 MCP 서버입니다. 지정한 `workspaceRoot` 아래의 JavaScript, TypeScript, TSX, Python 소스 파일을 읽고 심볼, 정의, 참조, 요약, tree-sitter query, 컨텍스트 markdown을 제공합니다.
+Tree-sitter 기반 코드 분석 MCP 서버입니다. 지정한 `workspaceRoot` 아래의 JavaScript, TypeScript, TSX, Python, Rust 소스 파일을 읽고 심볼, 정의, 참조, 요약, tree-sitter query, 컨텍스트 markdown을 제공합니다.
 
 ## 설치와 빌드
 
@@ -37,6 +37,7 @@ npx -y syntax-map-mcp --workspace-root /path/to/workspace
 - `run_query`: 파일 하나에 tree-sitter query 실행
 - `get_ast_tree`: 파일 하나의 tree-sitter AST를 depth 제한 JSON 트리로 반환
 - `lsp_document_symbols`: 파일 하나의 심볼을 LSP DocumentSymbol 형태로 반환
+- `lsp_diagnostics`: 파일 하나의 tree-sitter parse error를 LSP Diagnostic 형태로 반환
 - `lsp_definition`: 파일의 LSP 위치에 있는 식별자의 정의 위치를 반환
 - `lsp_references`: 파일의 LSP 위치에 있는 식별자의 참조 위치를 반환
 - `lsp_hover`: 파일의 LSP 위치에 있는 식별자의 hover markdown을 반환
@@ -53,7 +54,7 @@ npx -y syntax-map-mcp --workspace-root /path/to/workspace
 
 ## SQLite 인덱스
 
-`index_workspace`는 `workspaceRoot` 아래의 `.syntax-map-mcp/index.sqlite`에 인덱스를 저장합니다. 인덱싱 대상은 `.js`, `.jsx`, `.ts`, `.tsx`, `.py` 파일이며, `.git`, `.syntax-map-mcp`, `dist`, `node_modules` 디렉터리와 `workspaceRoot` 아래의 `.gitignore` 패턴에 매칭되는 파일은 제외합니다. 하위 디렉터리의 `.gitignore`는 해당 디렉터리 기준으로 적용합니다.
+`index_workspace`는 `workspaceRoot` 아래의 `.syntax-map-mcp/index.sqlite`에 인덱스를 저장합니다. 인덱싱 대상은 `.js`, `.jsx`, `.ts`, `.tsx`, `.py`, `.rs` 파일이며, `.git`, `.syntax-map-mcp`, `dist`, `node_modules` 디렉터리와 `workspaceRoot` 아래의 `.gitignore` 패턴에 매칭되는 파일은 제외합니다. 하위 디렉터리의 `.gitignore`는 해당 디렉터리 기준으로 적용합니다.
 
 파일 변경 여부는 `mtimeMs`와 `size`로 판단합니다. 다시 `index_workspace`를 호출하면 변경된 파일만 재파싱하고, 삭제된 파일은 인덱스에서 제거합니다. `search_symbols`, `find_indexed_definition`, `find_indexed_references`는 `isStale`, `staleFiles`, `refreshed`를 반환해 검색 결과가 최신 인덱스 기반인지 알려줍니다. 세 도구에 `refreshIfStale: true`를 전달하면 stale 파일이 있을 때 먼저 인덱스를 갱신한 뒤 검색합니다. 인덱스 검색 도구는 인덱스에 저장된 위치를 조회한 뒤 현재 파일에서 해당 줄 snippet을 읽어 반환합니다. `contextBefore`, `contextAfter`를 0-10 사이 정수로 전달하면 snippet 주변 라인도 함께 반환합니다. `includePreview: true`를 전달하면 `path:line` 헤더와 코드블록으로 구성된 `previewMarkdown`도 함께 반환합니다. 자동 watch 모드는 아직 포함하지 않았습니다.
 
@@ -89,4 +90,4 @@ Python은 JavaScript/TypeScript처럼 명시적인 `export` 문법이 없으므
 
 ## 보안 경계
 
-서버는 `workspaceRoot` 내부 파일만 읽습니다. 지원 확장자는 `.js`, `.jsx`, `.ts`, `.tsx`, `.py`뿐이며, workspace 밖으로 나가는 경로나 지원하지 않는 확장자는 오류로 처리합니다.
+서버는 `workspaceRoot` 내부 파일만 읽습니다. 지원 확장자는 `.js`, `.jsx`, `.ts`, `.tsx`, `.py`, `.rs`뿐이며, workspace 밖으로 나가는 경로나 지원하지 않는 확장자는 오류로 처리합니다.

package/dist/analysis/diagnostics.js

@@ -0,0 +1,73 @@
+import { parseSourceFile } from '../parser.js';
+export const treeSitterDiagnosticProvider = {
+    name: 'tree-sitter',
+    getDiagnostics(context) {
+        return collectTreeSitterDiagnostics(context.tree.rootNode);
+    }
+};
+const defaultDiagnosticProviders = [treeSitterDiagnosticProvider];
+export async function getDiagnostics(workspace, input, providers = defaultDiagnosticProviders) {
+    const file = await workspace.readSourceFile(input.path);
+    if (!file.ok)
+        return file;
+    const parsed = parseSourceFile(file);
+    /* v8 ignore next -- parser failures are covered by parser tests. */
+    if (!parsed.ok)
+        return parsed;
+    const context = diagnosticContext(parsed);
+    const diagnostics = (await Promise.all(providers.map(provider => Promise.resolve(provider.getDiagnostics(context))))).flat();
+    return {
+        ok: true,
+        path: file.relativePath,
+        language: parsed.language,
+        diagnostics
+    };
+}
+function diagnosticContext(parsed) {
+    return {
+        path: parsed.file.relativePath,
+        language: parsed.language,
+        text: parsed.file.text,
+        tree: parsed.tree
+    };
+}
+function collectTreeSitterDiagnostics(root) {
+    if (!root.hasError)
+        return [];
+    const diagnostics = [];
+    collectErrorNodes(root, diagnostics);
+    return diagnostics;
+}
+function collectErrorNodes(node, diagnostics) {
+    if (node.isError || node.isMissing) {
+        diagnostics.push({
+            range: lspRange(rangeForNode(node)),
+            severity: 1,
+            source: 'tree-sitter',
+            message: node.isMissing ? `Syntax error: missing ${node.type}` : 'Syntax error'
+        });
+    }
+    if (!node.hasError)
+        return;
+    for (const child of node.children) {
+        collectErrorNodes(child, diagnostics);
+    }
+}
+function lspRange(range) {
+    return {
+        start: {
+            line: range.start.row,
+            character: range.start.column
+        },
+        end: {
+            line: range.end.row,
+            character: range.end.column
+        }
+    };
+}
+function rangeForNode(node) {
+    return {
+        start: node.startPosition,
+        end: node.endPosition
+    };
+}

package/dist/analysis/lsp.js

@@ -123,7 +123,8 @@ function signatureFromSnippet(name, snippet) {
     const functionMatch = firstLine.match(/^(?:export\s+)?(?:async\s+)?function\s+[A-Za-z_$][A-Za-z0-9_$]*\s*\(([^)]*)\)\s*([^{:]*(?::\s*[^{]+)?)[{:]?/);
     const methodMatch = firstLine.match(/^(?:public\s+|private\s+|protected\s+|static\s+|async\s+)*[A-Za-z_$][A-Za-z0-9_$]*\s*\(([^)]*)\)\s*([^{:]*(?::\s*[^{]+)?)[{:]?/);
     const pythonMatch = firstLine.match(/^def\s+[A-Za-z_$][A-Za-z0-9_$]*\s*\(([^)]*)\)\s*([^:]*)/);
-    const match = functionMatch ?? pythonMatch ?? methodMatch;
+    const rustMatch = firstLine.match(/^(?:pub\s+)?(?:async\s+)?fn\s+[A-Za-z_$][A-Za-z0-9_$]*\s*\(([^)]*)\)\s*([^{]*)/);
+    const match = functionMatch ?? pythonMatch ?? rustMatch ?? methodMatch;
     /* v8 ignore next 6 -- indexed function and method definitions provide recognizable signature snippets. */
     if (!match) {
         return {

package/dist/analysis/references.js

@@ -34,6 +34,8 @@ export function referenceQueryForLanguage(language) {
             return '[(identifier) (type_identifier) (property_identifier)] @reference';
         case 'javascript':
             return '[(identifier) (property_identifier)] @reference';
+        case 'rust':
+            return '[(identifier) (type_identifier)] @reference';
         case 'python':
         default:
             return '(identifier) @reference';

package/dist/analysis/summary.js

@@ -43,6 +43,8 @@ function isImportNode(language, nodeType) {
         case 'typescript':
         case 'tsx':
             return nodeType === 'import_statement';
+        case 'rust':
+            return false;
     }
 }
 function findExports(parsed) {
@@ -61,6 +63,7 @@ function isExportNode(language, nodeType) {
             return nodeType === 'export_statement';
         /* v8 ignore next 2 -- Python exports are handled by findPythonAllExports before this switch. */
         case 'python':
+        case 'rust':
             return false;
     }
 }

package/dist/analysis/symbols.js

@@ -21,6 +21,16 @@ const pythonSymbolPatterns = [
     { kind: 'function', query: '(function_definition name: (identifier) @name) @definition' },
     { kind: 'variable', query: '(module (expression_statement (assignment left: (identifier) @name) @definition))' }
 ];
+const rustSymbolPatterns = [
+    { kind: 'class', query: '(struct_item name: (type_identifier) @name) @definition' },
+    { kind: 'class', query: '(enum_item name: (type_identifier) @name) @definition' },
+    { kind: 'interface', query: '(trait_item name: (type_identifier) @name) @definition' },
+    { kind: 'type', query: '(type_item name: (type_identifier) @name) @definition' },
+    { kind: 'function', query: '(function_item name: (identifier) @name) @definition' },
+    { kind: 'method', query: '(function_signature_item name: (identifier) @name) @definition' },
+    { kind: 'variable', query: '(const_item name: (identifier) @name) @definition' },
+    { kind: 'variable', query: '(static_item name: (identifier) @name) @definition' }
+];
 export function listSymbols(parsed) {
     return patternsForLanguage(parsed).flatMap(pattern => querySymbols(parsed, pattern));
 }
@@ -33,6 +43,8 @@ function patternsForLanguage(parsed) {
             return typeScriptSymbolPatterns;
         case 'python':
             return pythonSymbolPatterns;
+        case 'rust':
+            return rustSymbolPatterns;
     }
 }
 function querySymbols(parsed, pattern) {
@@ -51,6 +63,9 @@ function querySymbols(parsed, pattern) {
             !directJavaScriptLikeMethodClass(definition)) {
             return [];
         }
+        if (pattern.kind === 'method' && parsed.language === 'rust' && !directRustMethodParentName(definition)) {
+            return [];
+        }
         if (pattern.kind === 'method' && name.text === 'constructor')
             return [];
         const kind = symbolKind(parsed, pattern.kind, definition);
@@ -69,15 +84,20 @@ function symbolKind(parsed, kind, definition) {
     if (parsed.language === 'python' && kind === 'function' && isDirectPythonMethod(definition)) {
         return 'method';
     }
+    if (parsed.language === 'rust' && kind === 'function' && directRustMethodParentName(definition)) {
+        return 'method';
+    }
     return kind;
 }
 function parentNameForSymbol(parsed, kind, definition) {
     if (kind !== 'method')
         return undefined;
-    const classNode = parsed.language === 'python'
-        ? directPythonMethodClass(definition)
-        : directJavaScriptLikeMethodClass(definition);
-    return classNode?.childForFieldName('name')?.text;
+    const classNode = parsed.language === 'python' ? directPythonMethodClass(definition) : undefined;
+    if (classNode)
+        return classNode.childForFieldName('name')?.text;
+    if (parsed.language === 'rust')
+        return directRustMethodParentName(definition);
+    return directJavaScriptLikeMethodClass(definition)?.childForFieldName('name')?.text;
 }
 function isJavaScriptLikeLanguage(parsed) {
     /* v8 ignore next 5 -- language dispatch is covered by JS/TS/TSX/Python fixture tests. */
@@ -86,6 +106,8 @@ function isJavaScriptLikeLanguage(parsed) {
         parsed.language === 'tsx');
 }
 function isTopLevelVariableDefinition(definition) {
+    if (definition.parent?.type === 'source_file')
+        return true;
     const statement = definition.parent;
     /* v8 ignore next -- tree-sitter variable definitions always have a parent statement. */
     if (!statement)
@@ -117,6 +139,17 @@ function directJavaScriptLikeMethodClass(definition) {
     }
     return classNode;
 }
+function directRustMethodParentName(definition) {
+    const declarationList = definition.parent;
+    const parentNode = declarationList?.parent;
+    if (declarationList?.type !== 'declaration_list')
+        return undefined;
+    if (parentNode?.type === 'trait_item')
+        return parentNode.childForFieldName('name')?.text;
+    if (parentNode?.type !== 'impl_item')
+        return undefined;
+    return parentNode.namedChildren.find(child => child.type === 'type_identifier')?.text;
+}
 function rangeForNode(node) {
     return {
         start: node.startPosition,

package/dist/languages.js

@@ -2,12 +2,14 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const javascript = require('tree-sitter-javascript');
 const python = require('tree-sitter-python');
+const rust = require('tree-sitter-rust');
 const typescript = require('tree-sitter-typescript');
 const languages = {
     javascript,
     typescript: typescript.typescript,
     tsx: typescript.tsx,
-    python
+    python,
+    rust
 };
 export function languageForName(language) {
     return languages[language];

package/dist/parser.js

@@ -13,6 +13,8 @@ export function detectLanguage(filePath) {
             return { ok: true, language: 'tsx' };
         case '.py':
             return { ok: true, language: 'python' };
+        case '.rs':
+            return { ok: true, language: 'rust' };
         default:
             return {
                 ok: false,

package/dist/server.js

@@ -21,7 +21,7 @@ export async function createServerInfo(packageJsonPath = defaultPackageJsonPath(
 export async function createServer(options) {
     const workspace = await createWorkspace(options.workspaceRoot);
     const server = new McpServer(await createServerInfo(), {
-        instructions: 'Analyze JavaScript, TypeScript, and Python source files under the configured workspaceRoot only.'
+        instructions: 'Analyze JavaScript, TypeScript, Python, and Rust source files under the configured workspaceRoot only.'
     });
     registerTools(server, workspace);
     return server;

package/dist/tools.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { getAstTree as getAstTreeAnalysis } from './analysis/ast-tree.js';
 import { buildContext as buildContextAnalysis } from './analysis/context.js';
 import { findDefinitions } from './analysis/definitions.js';
+import { getDiagnostics as getLspDiagnostics } from './analysis/diagnostics.js';
 import { clearIndex as clearWorkspaceIndex, findIndexedDefinitions, findIndexedReferences, getIndexStatus as getWorkspaceIndexStatus, indexWorkspace as indexWorkspaceAnalysis, searchSymbols as searchIndexedSymbols } from './analysis/index.js';
 import { runTreeSitterQuery } from './analysis/query.js';
 import { findReferences as findReferencesAnalysis } from './analysis/references.js';
@@ -75,6 +76,12 @@ export function createToolHandlers(workspace) {
                 return toolFailure(result.error.code, result.error.message);
             return jsonResult(result);
         },
+        async lspDiagnostics(input) {
+            const result = await getLspDiagnostics(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
         async lspDefinition(input) {
             const result = await getLspDefinition(workspace, input);
             if (!result.ok)
@@ -214,6 +221,13 @@ export function registerTools(server, workspace) {
             path: z.string()
         }
     }, handlers.lspDocumentSymbols);
+    server.registerTool('lsp_diagnostics', {
+        title: 'LSP diagnostics',
+        description: 'Return lightweight syntax diagnostics from tree-sitter parse errors.',
+        inputSchema: {
+            path: z.string()
+        }
+    }, handlers.lspDiagnostics);
     server.registerTool('lsp_definition', {
         title: 'LSP definition',
         description: 'Return definition locations for the identifier at a zero-based LSP position.',

package/dist/workspace.js

@@ -1,7 +1,7 @@
 import { readdir, readFile, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import ignore from 'ignore';
-const SUPPORTED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.py']);
+const SUPPORTED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.py', '.rs']);
 const EXCLUDED_DIRECTORIES = new Set(['.git', '.syntax-map-mcp', 'dist', 'node_modules']);
 function isInsideRoot(root, candidate) {
     const relative = path.relative(root, candidate);

package/docs/tools.md

@@ -215,6 +215,37 @@ syntax-map-mcp의 주요 MCP 도구 입력과 응답 예시입니다. 응답 예
 }
 ```
 
+## lsp_diagnostics
+
+입력:
+
+```json
+{
+  "path": "src/users.ts"
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "diagnostics": [
+    {
+      "range": {
+        "start": { "line": 10, "character": 4 },
+        "end": { "line": 10, "character": 12 }
+      },
+      "severity": 1,
+      "source": "tree-sitter",
+      "message": "Syntax error"
+    }
+  ]
+}
+```
+
 ## lsp_definition
 
 입력:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntax-map-mcp",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Tree-sitter based code analysis MCP server",
   "license": "MIT",
   "type": "module",
@@ -42,6 +42,7 @@
     "tree-sitter": "^0.21.1",
     "tree-sitter-javascript": "^0.21.4",
     "tree-sitter-python": "^0.21.0",
+    "tree-sitter-rust": "^0.21.0",
     "tree-sitter-typescript": "^0.21.2",
     "zod": "^4.0.0"
   },