syntax-map-mcp 0.1.0 → 0.1.1

package/README.md

@@ -19,7 +19,7 @@ npm run typecheck
 ## 실행
 
 ```bash
-node dist/cli.js --workspace-root /path/to/workspace
+npx -y syntax-map-mcp --workspace-root /path/to/workspace
 ```
 
 `workspaceRoot` 결정 순서:
@@ -38,6 +38,7 @@ node dist/cli.js --workspace-root /path/to/workspace
 - `build_context`: 여러 파일 요약을 markdown 컨텍스트로 구성
 - `index_workspace`: 지원 소스 파일을 파싱해 SQLite 심볼 인덱스 생성 또는 갱신
 - `search_symbols`: SQLite 인덱스에서 심볼 이름 검색
+- `find_indexed_definition`: SQLite 인덱스에서 정확한 심볼 정의 검색 및 snippet 반환
 - `get_index_status`: 인덱스 경로, 인덱싱된 파일 수, 심볼 수, stale 파일 수 반환
 - `clear_index`: SQLite 인덱스 파일 삭제
 
@@ -45,7 +46,7 @@ node dist/cli.js --workspace-root /path/to/workspace
 
 `index_workspace`는 `workspaceRoot` 아래의 `.syntax-map-mcp/index.sqlite`에 인덱스를 저장합니다. 인덱싱 대상은 `.js`, `.jsx`, `.ts`, `.tsx`, `.py` 파일이며, `.git`, `.syntax-map-mcp`, `dist`, `node_modules` 디렉터리는 제외합니다.
 
-파일 변경 여부는 `mtimeMs`와 `size`로 판단합니다. 다시 `index_workspace`를 호출하면 변경된 파일만 재파싱하고, 삭제된 파일은 인덱스에서 제거합니다. 자동 watch 모드는 아직 포함하지 않았습니다.
+파일 변경 여부는 `mtimeMs`와 `size`로 판단합니다. 다시 `index_workspace`를 호출하면 변경된 파일만 재파싱하고, 삭제된 파일은 인덱스에서 제거합니다. `find_indexed_definition`은 인덱스에 저장된 정의 위치를 조회한 뒤 현재 파일에서 해당 줄 snippet을 읽어 반환합니다. 자동 watch 모드는 아직 포함하지 않았습니다.
 
 ## MCP 설정 예시
 
@@ -53,9 +54,10 @@ node dist/cli.js --workspace-root /path/to/workspace
 {
   "mcpServers": {
     "syntax-map-mcp": {
-      "command": "node",
+      "command": "npx",
       "args": [
-        "/Users/hantaekim/my-project/tree-sitter/dist/cli.js",
+        "-y",
+        "syntax-map-mcp",
         "--workspace-root",
         "/path/to/workspace"
       ]

package/dist/analysis/index.js

@@ -163,6 +163,9 @@ function sqlLikePattern(query) {
 function rowValue(row, key) {
     return row[key];
 }
+function lineAt(text, row) {
+    return text.split(/\r?\n/)[row] ?? '';
+}
 export async function indexWorkspace(workspace) {
     const indexPath = indexPathForWorkspace(workspace);
     const database = await openDatabase(indexPath);
@@ -242,6 +245,102 @@ export async function indexWorkspace(workspace) {
         database.close();
     }
 }
+export async function findIndexedDefinitions(workspace, input) {
+    const indexPath = indexPathForWorkspace(workspace);
+    const database = await openDatabase(indexPath);
+    try {
+        initSchema(database);
+        const where = ['name = ?'];
+        const params = [input.name];
+        if (input.kinds && input.kinds.length > 0) {
+            where.push(`kind IN (${input.kinds.map(() => '?').join(', ')})`);
+            params.push(...input.kinds);
+        }
+        const limit = input.limit ?? 50;
+        params.push(limit);
+        const statement = database.prepare(`
+        SELECT
+          file_path,
+          language,
+          name,
+          kind,
+          parent_name,
+          start_row,
+          start_column,
+          end_row,
+          end_column,
+          selection_start_row,
+          selection_start_column,
+          selection_end_row,
+          selection_end_column
+        FROM symbols
+        WHERE ${where.join(' AND ')}
+        ORDER BY file_path ASC, start_row ASC, name ASC
+        LIMIT ?
+      `, params);
+        const definitions = [];
+        try {
+            while (statement.step()) {
+                const row = statement.getAsObject();
+                const selectionStartRow = rowValue(row, 'selection_start_row');
+                const selectionStartColumn = rowValue(row, 'selection_start_column');
+                const selectionEndRow = rowValue(row, 'selection_end_row');
+                const selectionEndColumn = rowValue(row, 'selection_end_column');
+                const filePath = String(rowValue(row, 'file_path'));
+                const startRow = Number(rowValue(row, 'start_row'));
+                const file = await workspace.readSourceFile(filePath);
+                definitions.push({
+                    path: filePath,
+                    language: rowValue(row, 'language'),
+                    name: String(rowValue(row, 'name')),
+                    kind: rowValue(row, 'kind'),
+                    parentName: rowValue(row, 'parent_name') === null ? undefined : String(rowValue(row, 'parent_name')),
+                    range: {
+                        start: {
+                            row: startRow,
+                            column: Number(rowValue(row, 'start_column'))
+                        },
+                        end: {
+                            row: Number(rowValue(row, 'end_row')),
+                            column: Number(rowValue(row, 'end_column'))
+                        }
+                    },
+                    selectionRange: selectionStartRow === null ||
+                        selectionStartColumn === null ||
+                        selectionEndRow === null ||
+                        selectionEndColumn === null
+                        ? undefined
+                        : {
+                            start: {
+                                row: Number(selectionStartRow),
+                                column: Number(selectionStartColumn)
+                            },
+                            end: {
+                                row: Number(selectionEndRow),
+                                column: Number(selectionEndColumn)
+                            }
+                        },
+                    snippet: file.ok ? lineAt(file.text, startRow) : ''
+                });
+            }
+        }
+        finally {
+            statement.free();
+        }
+        return {
+            ok: true,
+            indexPath,
+            total: definitions.length,
+            definitions
+        };
+    }
+    catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        database.close();
+    }
+}
 export async function searchSymbols(workspace, input) {
     const indexPath = indexPathForWorkspace(workspace);
     const database = await openDatabase(indexPath);

package/dist/tools.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { buildContext as buildContextAnalysis } from './analysis/context.js';
 import { findDefinitions } from './analysis/definitions.js';
-import { clearIndex as clearWorkspaceIndex, getIndexStatus as getWorkspaceIndexStatus, indexWorkspace as indexWorkspaceAnalysis, searchSymbols as searchIndexedSymbols } from './analysis/index.js';
+import { clearIndex as clearWorkspaceIndex, findIndexedDefinitions, 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 { summarizeFile as summarizeFileAnalysis } from './analysis/summary.js';
@@ -74,6 +74,12 @@ export function createToolHandlers(workspace) {
                 return toolFailure(result.error.code, result.error.message);
             return jsonResult(result);
         },
+        async findIndexedDefinition(input) {
+            const result = await findIndexedDefinitions(workspace, input);
+            if (!result.ok)
+                return toolFailure(result.error.code, result.error.message);
+            return jsonResult(result);
+        },
         async getIndexStatus(_input) {
             const result = await getWorkspaceIndexStatus(workspace);
             if (!result.ok)
@@ -151,6 +157,15 @@ export function registerTools(server, workspace) {
             limit: z.number().int().positive().max(500).optional()
         }
     }, handlers.searchSymbols);
+    server.registerTool('find_indexed_definition', {
+        title: 'Find indexed definition',
+        description: 'Find exact symbol definitions from the SQLite workspace index with snippets.',
+        inputSchema: {
+            name: z.string(),
+            kinds: z.array(symbolKindSchema).optional(),
+            limit: z.number().int().positive().max(500).optional()
+        }
+    }, handlers.findIndexedDefinition);
     server.registerTool('get_index_status', {
         title: 'Get index status',
         description: 'Return SQLite index path, indexed file count, symbol count, and stale file count.',

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "syntax-map-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Tree-sitter based code analysis MCP server",
+  "license": "MIT",
   "type": "module",
   "bin": {
-    "syntax-map-mcp": "./dist/cli.js"
+    "syntax-map-mcp": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kht6163/syntax-map-mcp.git"
+  },
+  "homepage": "https://github.com/kht6163/syntax-map-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/kht6163/syntax-map-mcp/issues"
   },
   "files": [
     "dist",