jsc-typescript-ast-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,34 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerComponentTreeTool } from './ts-morph/componentTree.js';
+import { registerFindDependencyTool } from './ts-morph/dependency.js';
+import { registerFindReferenceTool } from './ts-morph/references.js';
+// Create server instance
+const jscServer = new McpServer({
+    name: 'typescript-ast',
+    version: '1.0.0',
+});
+const server = new Proxy(jscServer, {
+    get(target, prop) {
+        if (prop === 'registerTool') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return (name, options, handler) => {
+                console.error(`Registering tool: ${name}`);
+                return target.registerTool(name, options, handler);
+            };
+        }
+        return Reflect.get(target, prop);
+    },
+});
+registerFindReferenceTool(server);
+registerFindDependencyTool(server);
+registerComponentTreeTool(server);
+const main = async () => {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('TypeScript AST MCP Server running on stdio');
+};
+main().catch((error) => {
+    console.error('Error starting TypeScript AST MCP Server:', error);
+    process.exit(1);
+});

package/dist/ts-morph/componentTree.js

@@ -0,0 +1,37 @@
+import z from 'zod';
+import { createProject } from './project.js';
+import { analyzeComponent } from './utils/analyzeComponent.js';
+import { getComponent } from './utils/component.js';
+export const registerComponentTreeTool = (server) => {
+    server.registerTool('component_tree', {
+        description: 'Get the component tree for a given entry file and maximum depth',
+        inputSchema: {
+            entryFilePath: z.string().describe('Path to the entry file'),
+            maxDepth: z
+                .number()
+                .default(3)
+                .describe('Maximum depth of the component tree (default: 3)'),
+        },
+    }, async ({ entryFilePath, maxDepth }) => {
+        const tree = getComponentTree(entryFilePath, maxDepth);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(tree, null, 2),
+                },
+            ],
+        };
+    });
+};
+const getComponentTree = (entryFilePath, maxDepth) => {
+    const project = createProject();
+    const sourceFile = project.getSourceFile(entryFilePath);
+    if (!sourceFile) {
+        throw new Error(`File not found: ${entryFilePath}`);
+    }
+    const component = getComponent(sourceFile);
+    return analyzeComponent(component, project, {
+        maxDepth,
+    }, 0);
+};

package/dist/ts-morph/dependency.js

@@ -0,0 +1,42 @@
+import z from 'zod';
+import { createProject } from './project.js';
+export const registerFindDependencyTool = (server) => {
+    server.registerTool('find_dependency', {
+        description: 'Find files with a given dependency',
+        inputSchema: {
+            dependencyName: z
+                .string()
+                .describe('Name of the dependency to search for'),
+        },
+    }, async ({ dependencyName }) => {
+        const project = createProject();
+        const files = getFilesWithDependency(project, dependencyName);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: files.join('\n'),
+                },
+            ],
+        };
+    });
+};
+const getFilesWithDependency = (project, dependencyName) => {
+    const sourceFiles = project.getSourceFiles();
+    const filesWithDependency = [];
+    sourceFiles.forEach((sourceFile) => {
+        const importDeclarations = sourceFile.getImportDeclarations();
+        importDeclarations.forEach((importDeclaration) => {
+            const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+            if (moduleSpecifier === dependencyName ||
+                moduleSpecifier.includes(`${dependencyName}/`)) {
+                filesWithDependency.push(sourceFile.getFilePath());
+            }
+        });
+    });
+    return filesWithDependency;
+};
+export const findFilesWithDependency = (dependencyName) => {
+    const project = createProject();
+    return getFilesWithDependency(project, dependencyName);
+};

package/dist/ts-morph/index.js

@@ -0,0 +1,51 @@
+import * as dotenv from 'dotenv'
+import { Project } from 'ts-morph'
+import { z } from 'zod'
+dotenv.config()
+export const registerTsMorphTools = (server) => {
+  server.registerTool(
+    'find_reference',
+    {
+      description: 'Find references for a given class and method',
+      inputSchema: {
+        filePath: z.string().describe('Path to the file'),
+        className: z.string().describe('Name of the class'),
+        methodName: z.string().describe('Name of the method'),
+      },
+    },
+    async ({ filePath, className, methodName }) => {
+      const project = createProject()
+      const references = getReferences(project, filePath, className, methodName)
+      return {
+        content: [
+          {
+            type: 'text',
+            text: references.join('\n'),
+          },
+        ],
+      }
+    },
+  )
+}
+const createProject = () => {
+  const tsConfigFilePath = process.env.PROJECT_TSCONFIG_PATH || 'tsconfig.json'
+  console.error(`Using tsconfig file at: ${tsConfigFilePath}`)
+  return new Project({
+    tsConfigFilePath,
+  })
+}
+const getReferences = (project, fileName, className, methodName) => {
+  const source = project.getSourceFileOrThrow(fileName)
+  const method = source.getClass(className).getMethod(methodName)
+  const references = method.findReferences()
+  const referencePaths = []
+  references.forEach((reference) => {
+    reference.getReferences().forEach((currentReference) => {
+      const referenceNode = currentReference.getNode()
+      const lineNumber = referenceNode.getStartLineNumber()
+      const filePath = referenceNode.getSourceFile().getFilePath()
+      referencePaths.push(`${filePath}:${lineNumber}`)
+    })
+  })
+  return referencePaths
+}

package/dist/ts-morph/project.js

@@ -0,0 +1,10 @@
+import * as dotenv from 'dotenv';
+import { Project } from 'ts-morph';
+dotenv.config({ quiet: true });
+export const createProject = () => {
+    const tsConfigFilePath = process.env.PROJECT_TSCONFIG_PATH || 'tsconfig.json';
+    console.error(`Using tsconfig file at: ${tsConfigFilePath}`);
+    return new Project({
+        tsConfigFilePath,
+    });
+};

package/dist/ts-morph/references.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { createProject } from './project.js';
+export const registerFindReferenceTool = (server) => {
+    server.registerTool('find_reference', {
+        description: 'Find references for a given class and method',
+        inputSchema: {
+            filePath: z.string().describe('Path to the file'),
+            className: z.string().describe('Name of the class'),
+            methodName: z.string().describe('Name of the method'),
+        },
+    }, async ({ filePath, className, methodName }) => {
+        const project = createProject();
+        const references = getReferences(project, filePath, className, methodName);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: references.join('\n'),
+                },
+            ],
+        };
+    });
+};
+const getReferences = (project, fileName, className, methodName) => {
+    const source = project.getSourceFileOrThrow(fileName);
+    const method = source.getClass(className).getMethod(methodName);
+    const references = method.findReferences();
+    const referencePaths = [];
+    references.forEach((reference) => {
+        reference.getReferences().forEach((currentReference) => {
+            const referenceNode = currentReference.getNode();
+            const lineNumber = referenceNode.getStartLineNumber();
+            const filePath = referenceNode.getSourceFile().getFilePath();
+            referencePaths.push(`${filePath}:${lineNumber}`);
+        });
+    });
+    return referencePaths;
+};

package/dist/ts-morph/utils/analyzeComponent.js

@@ -0,0 +1,19 @@
+import { extractJSX, findReturnedJSX } from './extractJsx.js';
+import { getComponentName } from './nameHelper.js';
+export const analyzeComponent = (node, project, options, currentDepth) => {
+    const name = getComponentName(node);
+    console.error(`Analyzing component: ${name}, depth: ${currentDepth}`);
+    const root = {
+        name,
+        type: 'component',
+        children: [],
+    };
+    if (currentDepth >= options.maxDepth) {
+        return root;
+    }
+    const jsx = findReturnedJSX(node);
+    if (!jsx)
+        return root;
+    root.children = extractJSX(jsx, project, options, currentDepth + 1);
+    return root;
+};

package/dist/ts-morph/utils/component.js

@@ -0,0 +1,16 @@
+import { SyntaxKind } from 'ts-morph';
+import { getComponentName } from './nameHelper.js';
+export const getComponent = (sourceFile) => {
+    const component = sourceFile.getDefaultExportSymbol()?.getDeclarations()?.[0];
+    if (!component) {
+        throw new Error(`Component not found in ${sourceFile.getFilePath()}`);
+    }
+    const componentName = getComponentName(component);
+    if (componentName !== 'AnonymousComponent')
+        return component;
+    const components = sourceFile.getVariableDeclarations().filter((v) => {
+        const initializer = v.getInitializer();
+        return initializer?.getKind() === SyntaxKind.ArrowFunction;
+    });
+    return components[0];
+};

package/dist/ts-morph/utils/extractJsx.js

@@ -0,0 +1,164 @@
+import { Node, SyntaxKind, } from 'ts-morph';
+import { analyzeComponent } from './analyzeComponent.js';
+import { getComponent } from './component.js';
+import { getTagName } from './nameHelper.js';
+import { handleTernary } from './ternary.js';
+const extractFromExpression = (expression, project, options, depth) => {
+    if (Node.isConditionalExpression(expression)) {
+        return handleTernary(expression, project, options, depth);
+    }
+    if (Node.isBinaryExpression(expression)) {
+        return handleLogicalAnd(expression, project, options, depth);
+    }
+    if (Node.isIdentifier(expression)) {
+        return extractFromIdentifier(expression, project, options, depth);
+    }
+    return extractJSX(expression, project, options, depth);
+};
+const handleLogicalAnd = (expression, project, options, depth) => {
+    if (expression.getOperatorToken().getText() !== '&&') {
+        return [];
+    }
+    const condition = expression.getLeft().getText();
+    const right = expression.getRight();
+    const nodes = extractJSX(right, project, options, depth);
+    nodes.forEach((n) => {
+        n.condition = { expression: condition };
+    });
+    return nodes;
+};
+const extractFromIdentifier = (expression, project, options, depth) => {
+    const declaration = expression.getSymbol()?.getDeclarations()?.[0];
+    if (!declaration || !Node.isVariableDeclaration(declaration)) {
+        return [];
+    }
+    const initializer = declaration.getInitializer();
+    if (!initializer) {
+        return [];
+    }
+    return extractFromExpression(initializer, project, options, depth);
+};
+const buildNodeFromJsxFragment = (node, project, options, depth) => ({
+    name: 'Fragment',
+    type: 'fragment',
+    children: extractJSX(node, project, options, depth),
+});
+export const extractJSX = (node, project, options, depth) => {
+    const results = [];
+    node.forEachChild((child) => {
+        // 1. JSX Elements
+        if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+            const element = buildNodeFromJSX(child, project, options, depth);
+            if (element)
+                results.push(element);
+            return;
+        }
+        // 2. Fragment
+        if (Node.isJsxFragment(child)) {
+            results.push(buildNodeFromJsxFragment(child, project, options, depth));
+            return;
+        }
+        // 3. JSX Expression container
+        if (Node.isJsxExpression(child)) {
+            const expression = child.getExpression();
+            if (!expression) {
+                return;
+            }
+            results.push(...extractFromExpression(expression, project, options, depth));
+            return;
+        }
+        // 4. Ternary
+        if (Node.isConditionalExpression(child)) {
+            results.push(...handleTernary(child, project, options, depth));
+            return;
+        }
+        // 5. Logical AND
+        if (Node.isBinaryExpression(child)) {
+            results.push(...handleLogicalAnd(child, project, options, depth));
+            return;
+        }
+        results.push(...extractJSX(child, project, options, depth));
+    });
+    return results;
+};
+const resolveComponentFile = (node) => {
+    const tagName = getTagName(node);
+    const sourceFile = node.getSourceFile();
+    const importDecls = sourceFile.getImportDeclarations();
+    for (const imp of importDecls) {
+        const named = imp.getNamedImports();
+        const defaultImport = imp.getDefaultImport();
+        if (defaultImport?.getText() === tagName) {
+            const file = imp.getModuleSpecifierSourceFile();
+            const component = getComponent(file);
+            return component ?? null;
+        }
+        for (const n of named) {
+            if (n.getName() === tagName) {
+                const file = imp.getModuleSpecifierSourceFile();
+                const component = getComponent(file);
+                return component ?? null;
+            }
+        }
+    }
+    return null;
+};
+function buildNodeFromJSX(node, project, options, depth) {
+    const tagName = getTagName(node);
+    const isHtml = tagName[0] === tagName[0].toLowerCase();
+    const treeNode = {
+        name: tagName,
+        type: isHtml ? 'html' : 'component',
+        children: [],
+    };
+    // Recurse into children
+    if (Node.isJsxElement(node)) {
+        const children = node.getJsxChildren();
+        children.forEach((child) => {
+            if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+                const childNode = buildNodeFromJSX(child, project, options, depth);
+                if (childNode) {
+                    treeNode.children.push(childNode);
+                }
+                return;
+            }
+            if (Node.isJsxFragment(child)) {
+                treeNode.children.push(buildNodeFromJsxFragment(child, project, options, depth));
+                return;
+            }
+            if (Node.isJsxExpression(child)) {
+                const expression = child.getExpression();
+                if (expression) {
+                    treeNode.children.push(...extractFromExpression(expression, project, options, depth));
+                }
+                return;
+            }
+            treeNode.children.push(...extractJSX(child, project, options, depth));
+        });
+    }
+    // Resolve component if custom
+    if (!isHtml && depth < options.maxDepth) {
+        const resolved = resolveComponentFile(node);
+        if (resolved) {
+            const subTree = analyzeComponent(resolved, project, options, depth);
+            treeNode.children.push(...subTree.children);
+        }
+    }
+    return treeNode;
+}
+export const findReturnedJSX = (node) => {
+    const returnStmt = node.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
+    if (returnStmt) {
+        return returnStmt.getExpression() ?? null;
+    }
+    // Arrow function implicit return
+    if (Node.isArrowFunction(node)) {
+        const body = node.getBody();
+        if (Node.isJsxElement(body) ||
+            Node.isJsxSelfClosingElement(body) ||
+            Node.isJsxFragment(body)) {
+            return body;
+        }
+    }
+    return null;
+};

package/dist/ts-morph/utils/nameHelper.js

@@ -0,0 +1,16 @@
+import { Node } from 'ts-morph';
+export const getTagName = (node) => {
+    if (Node.isJsxElement(node)) {
+        return node.getOpeningElement().getTagNameNode().getText();
+    }
+    return node.getTagNameNode().getText();
+};
+export const getComponentName = (node) => {
+    if (Node.isFunctionDeclaration(node) && node.getName()) {
+        return node.getName();
+    }
+    if (Node.isVariableDeclaration(node)) {
+        return node.getName();
+    }
+    return 'AnonymousComponent';
+};

package/dist/ts-morph/utils/ternary.js

@@ -0,0 +1,13 @@
+import { extractJSX } from './extractJsx.js';
+export const handleTernary = (node, project, options, depth) => {
+    const condition = node.getCondition().getText();
+    const whenTrue = extractJSX(node.getWhenTrue(), project, options, depth);
+    const whenFalse = extractJSX(node.getWhenFalse(), project, options, depth);
+    whenTrue.forEach((n) => {
+        n.condition = { expression: condition };
+    });
+    whenFalse.forEach((n) => {
+        n.condition = { expression: `!(${condition})` };
+    });
+    return [...whenTrue, ...whenFalse];
+};

package/dist/ts-morph/utils/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "jsc-typescript-ast-mcp",
+  "version": "1.0.0",
+  "description": "A Model Context Protocol (MCP) server that provides an abstract syntax tree (AST) representation of TypeScript code using the ts-morph library.",
+  "main": "dist/index.js",
+  "scripts": {
+    "format": "prettier --write .",
+    "build": "tsc",
+    "test:mcp": "npx @modelcontextprotocol/inspector node dist/index.js"
+  },
+  "bin": {
+    "typescript-ast": "./dist/index.js"
+  },
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.5",
+    "eslint": "^10.0.2",
+    "prettier": "^3.8.1",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "dotenv": "^17.3.1",
+    "ts-morph": "^27.0.2",
+    "zod": "^4.3.6"
+  }
+}