syntax-map-mcp 0.1.8 → 1.0.0

package/dist/tools.js

@@ -1,9 +1,11 @@
 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 { 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';
+import { getCompletion as getLspCompletion, getDefinition as getLspDefinition, getDocumentSymbols as getLspDocumentSymbols, getHover as getLspHover, getReferences as getLspReferences, getSignatureHelp as getLspSignatureHelp, getWorkspaceSymbols as getLspWorkspaceSymbols } from './analysis/lsp.js';
 import { summarizeFile as summarizeFileAnalysis } from './analysis/summary.js';
 import { listSymbols as listParsedSymbols } from './analysis/symbols.js';
 import { parseSourceFile } from './parser.js';
@@ -11,6 +13,8 @@ import { jsonResult, toolFailure } from './result.js';
 const symbolKindSchema = z.enum(['function', 'method', 'class', 'variable', 'interface', 'type']);
 const detailSchema = z.enum(['compact', 'full']);
 const contextLineCountSchema = z.number().int().min(0).max(10);
+const astDepthSchema = z.number().int().min(0).max(20);
+const lspPositionSchema = z.number().int().min(0);
 export function createToolHandlers(workspace) {
     return {
         async listSymbols(input) {
@@ -18,6 +22,7 @@ export function createToolHandlers(workspace) {
             if (!file.ok)
                 return toolFailure(file.error.code, file.error.message);
             const parsed = parseSourceFile(file);
+            /* v8 ignore next -- parser failures are covered in parser and summarize handler tests. */
             if (!parsed.ok)
                 return toolFailure(parsed.error.code, parsed.error.message);
             return jsonResult({
@@ -50,6 +55,7 @@ export function createToolHandlers(workspace) {
             if (!file.ok)
                 return toolFailure(file.error.code, file.error.message);
             const parsed = parseSourceFile(file);
+            /* v8 ignore next -- parser failure handling is covered by parser tests. */
             if (!parsed.ok)
                 return toolFailure(parsed.error.code, parsed.error.message);
             const result = runTreeSitterQuery(parsed, input.query);
@@ -57,6 +63,54 @@ export function createToolHandlers(workspace) {
                 return toolFailure(result.error.code, result.error.message);
             return jsonResult(result);
         },
+        async getAstTree(input) {
+            const result = await getAstTreeAnalysis(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspDocumentSymbols(input) {
+            const result = await getLspDocumentSymbols(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)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspReferences(input) {
+            const result = await getLspReferences(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspHover(input) {
+            const result = await getLspHover(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspWorkspaceSymbols(input) {
+            const result = await getLspWorkspaceSymbols(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspCompletion(input) {
+            const result = await getLspCompletion(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
+        async lspSignatureHelp(input) {
+            const result = await getLspSignatureHelp(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
         async buildContext(input) {
             const result = await buildContextAnalysis(workspace, input);
             if (!result.ok)
@@ -89,12 +143,14 @@ export function createToolHandlers(workspace) {
         },
         async getIndexStatus(_input) {
             const result = await getWorkspaceIndexStatus(workspace);
+            /* v8 ignore next -- getIndexStatus read failures are defensive and covered at index layer. */
             if (!result.ok)
                 return toolFailure(result.error.code, result.error.message);
             return jsonResult(result);
         },
         async clearIndex(_input) {
             const result = await clearWorkspaceIndex(workspace);
+            /* v8 ignore next -- clearIndex failure is covered at index layer. */
             if (!result.ok)
                 return toolFailure(result.error.code, result.error.message);
             return jsonResult(result);
@@ -142,6 +198,83 @@ export function registerTools(server, workspace) {
             query: z.string()
         }
     }, handlers.runQuery);
+    server.registerTool('get_ast_tree', {
+        title: 'Get AST tree',
+        description: 'Return a depth-limited tree-sitter AST for one supported source file.',
+        inputSchema: {
+            path: z.string(),
+            maxDepth: astDepthSchema.optional(),
+            includeText: z.boolean().optional()
+        }
+    }, handlers.getAstTree);
+    server.registerTool('lsp_document_symbols', {
+        title: 'LSP document symbols',
+        description: 'Return tree-sitter symbols converted to LSP DocumentSymbol ranges and kinds.',
+        inputSchema: {
+            path: z.string()
+        }
+    }, handlers.lspDocumentSymbols);
+    server.registerTool('lsp_definition', {
+        title: 'LSP definition',
+        description: 'Return definition locations for the identifier at a zero-based LSP position.',
+        inputSchema: {
+            path: z.string(),
+            line: lspPositionSchema,
+            character: lspPositionSchema,
+            paths: z.array(z.string()).optional()
+        }
+    }, handlers.lspDefinition);
+    server.registerTool('lsp_references', {
+        title: 'LSP references',
+        description: 'Return reference locations for the identifier at a zero-based LSP position.',
+        inputSchema: {
+            path: z.string(),
+            line: lspPositionSchema,
+            character: lspPositionSchema,
+            paths: z.array(z.string()).optional()
+        }
+    }, handlers.lspReferences);
+    server.registerTool('lsp_hover', {
+        title: 'LSP hover',
+        description: 'Return markdown hover contents for the identifier at a zero-based LSP position.',
+        inputSchema: {
+            path: z.string(),
+            line: lspPositionSchema,
+            character: lspPositionSchema,
+            paths: z.array(z.string()).optional()
+        }
+    }, handlers.lspHover);
+    server.registerTool('lsp_workspace_symbols', {
+        title: 'LSP workspace symbols',
+        description: 'Return workspace symbols matching a case-insensitive query.',
+        inputSchema: {
+            query: z.string(),
+            paths: z.array(z.string()).optional(),
+            kinds: z.array(symbolKindSchema).optional()
+        }
+    }, handlers.lspWorkspaceSymbols);
+    server.registerTool('lsp_completion', {
+        title: 'LSP completion',
+        description: 'Return workspace symbol completion items for the prefix before a zero-based LSP position.',
+        inputSchema: {
+            path: z.string(),
+            line: lspPositionSchema,
+            character: lspPositionSchema,
+            paths: z.array(z.string()).optional(),
+            kinds: z.array(symbolKindSchema).optional(),
+            limit: z.number().int().positive().max(500).optional()
+        }
+    }, handlers.lspCompletion);
+    server.registerTool('lsp_signature_help', {
+        title: 'LSP signature help',
+        description: 'Return signature help for the active call at a zero-based LSP position.',
+        inputSchema: {
+            path: z.string(),
+            line: lspPositionSchema,
+            character: lspPositionSchema,
+            paths: z.array(z.string()).optional()
+        }
+    }, handlers.lspSignatureHelp);
     server.registerTool('build_context', {
         title: 'Build context',
         description: 'Build markdown context for supported source files.',

package/dist/workspace.js

@@ -27,6 +27,7 @@ function isGitignored(absolutePath, matchers) {
     let ignored = false;
     for (const { baseDirectory, matcher } of matchers) {
         const relativePath = path.relative(baseDirectory, absolutePath);
+        /* v8 ignore next 3 -- matcher base directories are loaded from workspace traversal roots. */
         if (relativePath === '' || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
             continue;
         }
@@ -34,6 +35,7 @@ function isGitignored(absolutePath, matchers) {
         if (result.ignored) {
             ignored = true;
         }
+        /* v8 ignore next 3 -- unignore precedence is covered by end-to-end gitignore tests. */
         if (result.unignored) {
             ignored = false;
         }
@@ -99,14 +101,17 @@ export async function createWorkspace(workspaceRoot) {
             let actualPath;
             try {
                 actualPath = await realpath(absolutePath);
+                /* v8 ignore next 3 -- file disappeared between readdir and realpath. */
             }
             catch {
                 continue;
             }
+            /* v8 ignore next 4 -- explicit symlink escape checks are covered by readSourceFile tests. */
             if (!isInsideRoot(root, actualPath)) {
                 continue;
             }
             const fileStat = await stat(actualPath);
+            /* v8 ignore next 4 -- entry was a file at readdir time; this guards filesystem races. */
             if (!fileStat.isFile()) {
                 continue;
             }

package/docs/tools.md

@@ -140,6 +140,272 @@ syntax-map-mcp의 주요 MCP 도구 입력과 응답 예시입니다. 응답 예
 }
 ```
 
+## get_ast_tree
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "maxDepth": 2,
+  "includeText": false
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "tree": {
+    "root": {
+      "type": "program",
+      "named": true,
+      "childCount": 3,
+      "range": {
+        "start": { "row": 0, "column": 0 },
+        "end": { "row": 12, "column": 0 }
+      },
+      "children": [
+        {
+          "type": "export_statement",
+          "named": true,
+          "childCount": 1,
+          "children": []
+        }
+      ]
+    }
+  }
+}
+```
+
+## lsp_document_symbols
+
+입력:
+
+```json
+{
+  "path": "src/users.ts"
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "symbols": [
+    {
+      "name": "UserService",
+      "kind": 5,
+      "range": {
+        "start": { "line": 7, "character": 7 },
+        "end": { "line": 13, "character": 1 }
+      },
+      "selectionRange": {
+        "start": { "line": 7, "character": 13 },
+        "end": { "line": 7, "character": 24 }
+      }
+    }
+  ]
+}
+```
+
+## lsp_definition
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "line": 21,
+  "character": 2
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "name": "formatUser",
+  "locations": [
+    {
+      "path": "src/users.ts",
+      "range": {
+        "start": { "line": 15, "character": 7 },
+        "end": { "line": 17, "character": 1 }
+      }
+    }
+  ]
+}
+```
+
+## lsp_references
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "line": 21,
+  "character": 2
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "name": "formatUser",
+  "locations": [
+    {
+      "path": "src/users.ts",
+      "range": {
+        "start": { "line": 21, "character": 0 },
+        "end": { "line": 21, "character": 10 }
+      }
+    }
+  ]
+}
+```
+
+## lsp_hover
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "line": 21,
+  "character": 2
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "name": "formatUser",
+  "range": {
+    "start": { "line": 21, "character": 0 },
+    "end": { "line": 21, "character": 10 }
+  },
+  "contents": {
+    "kind": "markdown",
+    "value": "**function** `formatUser`\n\n```typescript\nexport function formatUser(user: User): string {\n```"
+  }
+}
+```
+
+## lsp_workspace_symbols
+
+입력:
+
+```json
+{
+  "query": "Service"
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "query": "Service",
+  "symbols": [
+    {
+      "name": "UserService",
+      "kind": 5,
+      "location": {
+        "path": "src/users.ts",
+        "range": {
+          "start": { "line": 7, "character": 7 },
+          "end": { "line": 13, "character": 1 }
+        }
+      }
+    }
+  ]
+}
+```
+
+## lsp_completion
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "line": 21,
+  "character": 3,
+  "limit": 20
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "prefix": "for",
+  "isIncomplete": false,
+  "items": [
+    {
+      "label": "formatUser",
+      "kind": 3,
+      "detail": "function from src/users.ts",
+      "sortText": "formatUser"
+    }
+  ]
+}
+```
+
+## lsp_signature_help
+
+입력:
+
+```json
+{
+  "path": "src/users.ts",
+  "line": 21,
+  "character": 11
+}
+```
+
+응답 일부:
+
+```json
+{
+  "ok": true,
+  "path": "src/users.ts",
+  "language": "typescript",
+  "name": "formatUser",
+  "activeSignature": 0,
+  "activeParameter": 0,
+  "signatures": [
+    {
+      "label": "formatUser(user: User): string",
+      "parameters": [{ "label": "user: User" }]
+    }
+  ]
+}
+```
+
 ## build_context
 
 파일 경로 기반 입력:
@@ -215,6 +481,7 @@ syntax-map-mcp의 주요 MCP 도구 입력과 응답 예시입니다. 응답 예
 ```json
 {
   "ok": true,
+  "schemaVersion": 1,
   "indexedFiles": 12,
   "symbols": 84,
   "references": 231,
@@ -331,10 +598,21 @@ syntax-map-mcp의 주요 MCP 도구 입력과 응답 예시입니다. 응답 예
 ```json
 {
   "ok": true,
+  "schemaVersion": 1,
   "indexedFiles": 12,
   "symbols": 84,
   "references": 231,
-  "staleFiles": 0
+  "staleFiles": 2,
+  "staleReasons": [
+    {
+      "path": "src/users.ts",
+      "reason": "changed"
+    },
+    {
+      "path": "src/old.ts",
+      "reason": "missing"
+    }
+  ]
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntax-map-mcp",
-  "version": "0.1.8",
+  "version": "1.0.0",
   "description": "Tree-sitter based code analysis MCP server",
   "license": "MIT",
   "type": "module",
@@ -29,9 +29,10 @@
     "dev": "tsx src/cli.ts",
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
+    "coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "release:check": "npm run typecheck && npm test && npm run build && node scripts/check-package-files.mjs && node scripts/smoke-package-install.mjs"
+    "release:check": "npm run typecheck && npm run coverage && npm run build && node scripts/check-package-files.mjs && node scripts/smoke-package-install.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -46,6 +47,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "tsx": "^4.0.0",
     "typescript": "^5.8.0",
     "vitest": "^3.0.0"