typegraph-mcp 0.9.37 → 0.9.39

package/dist/module-graph.js

@@ -117,7 +117,7 @@ function distToSource(resolvedPath, projectRoot) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -168,7 +168,7 @@ function buildForwardEdges(files, resolver, projectRoot) {
     const edges = [];
     const fromDir = path.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
       if (target) {
         edges.push({
           target,
@@ -249,7 +249,7 @@ function updateFile(graph, filePath, resolver, projectRoot) {
   const fromDir = path.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+    const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
     if (target) {
       newEdges.push({
         target,
@@ -331,6 +331,7 @@ export {
   createResolver,
   discoverFiles,
   removeFile,
+  resolveProjectImport,
   startWatcher,
   updateFile
 };

package/dist/server.js

@@ -2,6 +2,7 @@
 // server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { parseSync as parseSync2 } from "oxc-parser";
 import { z } from "zod";
 
 // tsserver-client.ts
@@ -387,7 +388,7 @@ function distToSource(resolvedPath, projectRoot2) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot2) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot2) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -438,7 +439,7 @@ function buildForwardEdges(files, resolver, projectRoot2) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot2);
       if (target) {
         edges.push({
           target,
@@ -519,7 +520,7 @@ function updateFile(graph, filePath, resolver, projectRoot2) {
   const fromDir = path2.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+    const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot2);
     if (target) {
       newEdges.push({
         target,
@@ -889,6 +890,7 @@ var { projectRoot, tsconfigPath } = resolveConfig(import.meta.dirname);
 var log3 = (...args) => console.error("[typegraph]", ...args);
 var client = new TsServerClient(projectRoot, tsconfigPath);
 var moduleGraph;
+var moduleResolver;
 var mcpServer = new McpServer({
   name: "typegraph",
   version: "1.0.0"
@@ -960,6 +962,237 @@ async function resolveParams(params) {
   }
   return { error: "Either line+column or symbol must be provided" };
 }
+var exportKinds = /* @__PURE__ */ new Set([
+  "function",
+  "const",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "var",
+  "let",
+  "method"
+]);
+function exportPriority(source) {
+  switch (source) {
+    case "local":
+      return 3;
+    case "re-export":
+      return 2;
+    case "star-re-export":
+      return 1;
+  }
+}
+function exportKey(item) {
+  return `${item.symbol}:${item.exportKind}`;
+}
+function sameExportOrigin(a, b) {
+  return a.symbol === b.symbol && a.exportKind === b.exportKind && a.from === b.from && a.definedIn === b.definedIn && a.definedLine === b.definedLine;
+}
+function kindImpliesTypeOnly(kind) {
+  return kind === "type" || kind === "interface";
+}
+function normalizeExportKindLabel(kind, exportKind) {
+  if (exportKind === "type" && !kindImpliesTypeOnly(kind)) {
+    return "type";
+  }
+  return kind;
+}
+function upsertExport(map, conflicts, nextExport) {
+  const key = exportKey(nextExport);
+  if (conflicts.has(key)) {
+    if (nextExport.source === "star-re-export") return;
+    conflicts.delete(key);
+    map.set(key, nextExport);
+    return;
+  }
+  const existing = map.get(key);
+  if (existing && existing.source === "star-re-export" && nextExport.source === "star-re-export" && !sameExportOrigin(existing, nextExport)) {
+    map.delete(key);
+    conflicts.add(key);
+    return;
+  }
+  if (!existing || exportPriority(nextExport.source) > exportPriority(existing.source)) {
+    map.set(key, nextExport);
+  }
+}
+function offsetToLineColumn(source, offset) {
+  const safeOffset = Math.max(0, Math.min(offset ?? 0, source.length));
+  const prefix = source.slice(0, safeOffset);
+  const lines = prefix.split("\n");
+  return {
+    line: lines.length,
+    column: (lines.at(-1)?.length ?? 0) + 1
+  };
+}
+function normalizeExistingPath(filePath) {
+  const resolved = path5.resolve(filePath);
+  try {
+    return fs4.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+var normalizedProjectRoot = normalizeExistingPath(projectRoot);
+function projectPath(file) {
+  return path5.isAbsolute(file) ? relPath(file) : file;
+}
+function exportSymbol(entry) {
+  if (entry.exportName.kind === "Default") return "default";
+  return entry.exportName.name ?? entry.localName.name ?? entry.importName.name;
+}
+function exportLookupOffset(entry) {
+  if (entry.moduleRequest) {
+    return entry.importName.start ?? entry.exportName.start ?? entry.start;
+  }
+  if (entry.exportName.kind === "Default") {
+    return entry.localName.start ?? entry.exportName.start ?? entry.start;
+  }
+  return entry.exportName.start ?? entry.localName.start ?? entry.start;
+}
+async function resolveExportMetadata(file, line, column, fallbackKind) {
+  const defs = await client.definition(file, line, column);
+  const def = defs[0] ?? null;
+  let info = await client.quickinfo(file, line, column);
+  if ((!info || info.kind === "alias") && def) {
+    info = await client.quickinfo(def.file, def.start.line, def.start.offset) ?? info;
+  }
+  return {
+    kind: info?.kind ?? fallbackKind,
+    type: info?.displayString ?? null,
+    definedIn: projectPath(def?.file ?? file),
+    definedLine: def?.start.line ?? null
+  };
+}
+async function getModuleExports(file, visited = /* @__PURE__ */ new Set()) {
+  const relFile = path5.isAbsolute(file) ? relPath(file) : file;
+  const absFile = normalizeExistingPath(client.resolvePath(relFile));
+  if (visited.has(absFile)) return [];
+  const nextVisited = new Set(visited);
+  nextVisited.add(absFile);
+  const exportMap = /* @__PURE__ */ new Map();
+  const conflictingStarExports = /* @__PURE__ */ new Set();
+  let source;
+  try {
+    source = fs4.readFileSync(absFile, "utf-8");
+  } catch {
+    return [...exportMap.values()];
+  }
+  let parsed;
+  try {
+    parsed = parseSync2(absFile, source);
+  } catch {
+    return [...exportMap.values()];
+  }
+  for (const exp of parsed.module.staticExports) {
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (!moduleRequest) continue;
+      const targetFile = resolveProjectImport(
+        moduleResolver,
+        path5.dirname(absFile),
+        moduleRequest.value,
+        projectRoot
+      );
+      const exportLoc = offsetToLineColumn(
+        source,
+        entry.exportName.start ?? entry.localName.start ?? entry.importName.start ?? entry.start
+      );
+      const importKind = entry.importName.kind;
+      const exportKind = entry.exportName.kind;
+      if (importKind === "AllButDefault" && exportKind === "None") {
+        if (!targetFile) continue;
+        const nestedExports = await getModuleExports(targetFile, nextVisited);
+        for (const nested of nestedExports) {
+          if (nested.symbol === "default") continue;
+          const starExportKind = entry.isType ? "type" : nested.exportKind;
+          upsertExport(exportMap, conflictingStarExports, {
+            ...nested,
+            line: exportLoc.line,
+            exportKind: starExportKind,
+            isTypeOnly: starExportKind === "type",
+            source: "star-re-export",
+            from: relPath(targetFile)
+          });
+        }
+        continue;
+      }
+      const symbol = exportSymbol(entry);
+      if (!symbol) continue;
+      const importedSymbol = importKind === "Default" ? "default" : importKind === "Name" ? entry.importName.name : null;
+      const nestedMatch = targetFile && importedSymbol ? (await getModuleExports(targetFile, nextVisited)).find(
+        (item) => item.symbol === importedSymbol
+      ) ?? null : null;
+      const lookupLoc = offsetToLineColumn(
+        source,
+        exportLookupOffset(entry)
+      );
+      const metadata = await resolveExportMetadata(
+        relFile,
+        lookupLoc.line,
+        lookupLoc.column,
+        importKind === "All" ? "namespace" : "alias"
+      );
+      const resolvedExportKind = entry.isType || nestedMatch?.exportKind === "type" || kindImpliesTypeOnly(nestedMatch?.kind ?? metadata.kind) ? "type" : "value";
+      const resolvedKind = normalizeExportKindLabel(
+        nestedMatch?.kind ?? metadata.kind,
+        resolvedExportKind
+      );
+      upsertExport(exportMap, conflictingStarExports, {
+        symbol,
+        kind: resolvedKind,
+        line: exportLoc.line,
+        type: nestedMatch?.type ?? metadata.type,
+        exportKind: resolvedExportKind,
+        isTypeOnly: resolvedExportKind === "type",
+        isNamespace: importKind === "All",
+        source: "re-export",
+        from: targetFile ? relPath(targetFile) : moduleRequest.value,
+        definedIn: nestedMatch?.definedIn ?? metadata.definedIn,
+        definedLine: nestedMatch?.definedLine ?? metadata.definedLine
+      });
+      continue;
+    }
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (moduleRequest) continue;
+      const symbol = exportSymbol(entry);
+      if (!symbol) continue;
+      const exportLoc = offsetToLineColumn(
+        source,
+        entry.exportName.start ?? entry.localName.start ?? entry.start
+      );
+      const lookupLoc = offsetToLineColumn(source, exportLookupOffset(entry));
+      const metadata = await resolveExportMetadata(
+        relFile,
+        lookupLoc.line,
+        lookupLoc.column,
+        entry.isType ? "type" : "value"
+      );
+      const resolvedExportKind = entry.isType || kindImpliesTypeOnly(metadata.kind) ? "type" : "value";
+      const resolvedKind = normalizeExportKindLabel(metadata.kind, resolvedExportKind);
+      if (resolvedExportKind === "value" && symbol !== "default" && !exportKinds.has(resolvedKind) && resolvedKind !== "namespace" && resolvedKind !== "class") {
+        continue;
+      }
+      upsertExport(exportMap, conflictingStarExports, {
+        symbol,
+        kind: resolvedKind,
+        line: exportLoc.line,
+        type: metadata.type,
+        exportKind: resolvedExportKind,
+        isTypeOnly: resolvedExportKind === "type",
+        isNamespace: false,
+        source: "local",
+        from: null,
+        definedIn: relFile,
+        definedLine: resolvedExportKind === "type" ? exportLoc.line : metadata.definedLine
+      });
+    }
+  }
+  return [...exportMap.values()].sort(
+    (a, b) => a.line - b.line || a.symbol.localeCompare(b.symbol)
+  );
+}
 mcpServer.tool(
   "ts_find_symbol",
   "Find a symbol's location in a file by name. Entry point for navigating without exact coordinates.",
@@ -1225,60 +1458,44 @@ mcpServer.tool(
 );
 mcpServer.tool(
   "ts_module_exports",
-  "List all exported symbols from a module with their resolved types. Gives an at-a-glance understanding of what a file provides.",
+  "List all exported symbols from a module with their resolved types, including re-exports when possible. Gives an at-a-glance understanding of what a file provides.",
   {
     file: z.string().describe("File to inspect")
   },
   async ({ file }) => {
-    const bar = await client.navbar(file);
-    if (bar.length === 0) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ error: `No symbols found in ${file}` })
-          }
-        ]
-      };
-    }
-    const moduleItem = bar.find((item) => item.kind === "module");
-    const topItems = moduleItem?.childItems ?? bar;
-    const exportKinds = /* @__PURE__ */ new Set([
-      "function",
-      "const",
-      "class",
-      "interface",
-      "type",
-      "enum",
-      "var",
-      "let",
-      "method"
-    ]);
-    const candidates = topItems.filter((item) => exportKinds.has(item.kind));
-    const exports = [];
-    for (const item of candidates) {
-      if (!item.spans[0]) continue;
-      const span = item.spans[0];
-      const info = await client.quickinfo(file, span.start.line, span.start.offset);
-      exports.push({
-        symbol: item.text,
-        kind: item.kind,
-        line: span.start.line,
-        type: info?.displayString ?? null
-      });
-    }
+    const exports = await getModuleExports(file);
+    const localCount = exports.filter((item) => item.source === "local").length;
+    const reExportCount = exports.length - localCount;
+    const typeOnlyCount = exports.filter((item) => item.isTypeOnly).length;
+    const valueCount = exports.length - typeOnlyCount;
+    const namespaceExportCount = exports.filter((item) => item.isNamespace).length;
+    const hasLocalRuntimeExports = exports.some(
+      (item) => item.source === "local" && !item.isTypeOnly
+    );
+    const isPrimarilyBarrel = exports.length > 0 && localCount < reExportCount;
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({ file, exports, count: exports.length })
+          text: JSON.stringify({
+            file,
+            exports,
+            count: exports.length,
+            localCount,
+            reExportCount,
+            typeOnlyCount,
+            valueCount,
+            namespaceExportCount,
+            hasLocalRuntimeExports,
+            isPrimarilyBarrel
+          })
         }
       ]
     };
   }
 );
 function relPath(absPath2) {
-  return path5.relative(projectRoot, absPath2);
+  return path5.relative(normalizedProjectRoot, normalizeExistingPath(absPath2));
 }
 function absPath(file) {
   return path5.isAbsolute(file) ? file : path5.resolve(projectRoot, file);
@@ -1459,6 +1676,7 @@ async function main() {
     buildGraph(projectRoot, tsconfigPath)
   ]);
   moduleGraph = graphResult.graph;
+  moduleResolver = graphResult.resolver;
   startWatcher(projectRoot, moduleGraph, graphResult.resolver);
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);

package/dist/smoke-test.js

@@ -386,7 +386,7 @@ function distToSource(resolvedPath, projectRoot) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -437,7 +437,7 @@ function buildForwardEdges(files, resolver, projectRoot) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
       if (target) {
         edges.push({
           target,

package/export-surface-test.ts

@@ -0,0 +1,202 @@
+#!/usr/bin/env npx tsx
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+type ModuleExportRecord = {
+  symbol: string;
+  kind: string;
+  line: number;
+  type: string | null;
+  exportKind: "value" | "type";
+  isTypeOnly: boolean;
+  isNamespace: boolean;
+  source: "local" | "re-export" | "star-re-export";
+  from: string | null;
+  definedIn: string;
+  definedLine: number | null;
+};
+
+type ModuleExportsResult = {
+  file: string;
+  exports: ModuleExportRecord[];
+  count: number;
+  localCount: number;
+  reExportCount: number;
+  typeOnlyCount: number;
+  valueCount: number;
+  namespaceExportCount: number;
+  hasLocalRuntimeExports: boolean;
+  isPrimarilyBarrel: boolean;
+};
+
+function copyDir(src: string, dest: string): void {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function findExport(
+  result: ModuleExportsResult,
+  symbol: string,
+  exportKind: "value" | "type"
+): ModuleExportRecord {
+  const found = result.exports.find(
+    (item) => item.symbol === symbol && item.exportKind === exportKind
+  );
+  assert.ok(found, `Expected ${symbol}:${exportKind} in ${result.file}`);
+  return found;
+}
+
+function assertProjectPath(actual: string | null, expected: string): void {
+  assert.ok(actual, `Expected path ${expected}`);
+  const normalized = actual.replaceAll("\\", "/");
+  assert.equal(normalized, expected, `Expected ${normalized} to equal ${expected}`);
+}
+
+async function main(): Promise<void> {
+  const repoRoot = import.meta.dirname;
+  const fixtureRoot = path.join(repoRoot, ".fixtures/export-surface");
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "typegraph-export-surface-"));
+  const projectRoot = path.join(tempRoot, "project");
+
+  copyDir(fixtureRoot, projectRoot);
+  fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules/typescript"),
+    path.join(projectRoot, "node_modules/typescript"),
+    "dir"
+  );
+
+  const client = new Client({ name: "export-surface-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: path.join(repoRoot, "node_modules/.bin/tsx"),
+    args: [path.join(repoRoot, "server.ts")],
+    cwd: projectRoot,
+    env: {
+      TYPEGRAPH_PROJECT_ROOT: projectRoot,
+      TYPEGRAPH_TSCONFIG: path.join(projectRoot, "tsconfig.json"),
+    },
+  });
+
+  try {
+    await client.connect(transport);
+
+    async function moduleExports(file: string): Promise<ModuleExportsResult> {
+      const result = await client.request(
+        {
+          method: "tools/call",
+          params: {
+            name: "ts_module_exports",
+            arguments: { file },
+          },
+        },
+        CallToolResultSchema
+      );
+
+      const content = result.content[0];
+      assert.ok(content?.type === "text", `Expected text response for ${file}`);
+      return JSON.parse(content.text) as ModuleExportsResult;
+    }
+
+    const source = await moduleExports("src/source.ts");
+    const defaultExport = findExport(source, "default", "value");
+    assert.equal(defaultExport.source, "local");
+    assert.equal(defaultExport.kind, "function");
+    assert.equal(defaultExport.definedIn, "src/source.ts");
+    assert.equal(defaultExport.definedLine, 1);
+
+    const defaultExpression = await moduleExports("src/default-expression.ts");
+    const expressionDefault = findExport(defaultExpression, "default", "value");
+    assert.equal(expressionDefault.source, "local");
+    assert.equal(expressionDefault.definedIn, "src/default-expression.ts");
+
+    const barrel = await moduleExports("src/barrel.ts");
+    const barrelValue = findExport(barrel, "value", "value");
+    const barrelUserShape = findExport(barrel, "UserShape", "type");
+    assert.equal(barrelValue.source, "star-re-export");
+    assert.equal(barrelUserShape.source, "star-re-export");
+    assert.equal(barrel.exports.some((item) => item.symbol === "default"), false);
+    assert.equal(barrel.exports.some((item) => item.symbol === "buildUser"), false);
+    assert.equal(barrelUserShape.isTypeOnly, true);
+    assert.equal(barrel.typeOnlyCount, 2);
+    assert.equal(barrel.isPrimarilyBarrel, true);
+    assert.equal(barrel.hasLocalRuntimeExports, false);
+
+    const typeReExport = await moduleExports("src/reexport-type.ts");
+    const userShape = findExport(typeReExport, "UserShape", "type");
+    assert.equal(userShape.source, "re-export");
+    assert.equal(userShape.isTypeOnly, true);
+    assert.equal(userShape.exportKind, "type");
+    assert.equal(typeReExport.typeOnlyCount, 1);
+    assert.equal(typeReExport.valueCount, 0);
+
+    const namedReExport = await moduleExports("src/named-reexport.ts");
+    const aliasedValue = findExport(namedReExport, "aliasedValue", "value");
+    assert.equal(aliasedValue.source, "re-export");
+    assertProjectPath(aliasedValue.from, "src/source.ts");
+    assert.equal(aliasedValue.definedIn, "src/source.ts");
+    assert.equal(namedReExport.namespaceExportCount, 0);
+
+    const namespaceReExport = await moduleExports("src/namespace-reexport.ts");
+    const models = findExport(namespaceReExport, "Models", "value");
+    assert.equal(models.source, "re-export");
+    assert.equal(models.isNamespace, true);
+    assert.equal(namespaceReExport.namespaceExportCount, 1);
+
+    const mixed = await moduleExports("src/mixed.ts");
+    const localValue = findExport(mixed, "SessionId", "value");
+    const localType = findExport(mixed, "SessionId", "type");
+    const externalValue = findExport(mixed, "externalValue", "value");
+    const externalUserShape = findExport(mixed, "ExternalUserShape", "type");
+    assert.equal(localValue.source, "local");
+    assert.equal(localType.source, "local");
+    assert.equal(localType.kind, "type");
+    assert.equal(localType.definedLine, 2);
+    assert.equal(externalValue.source, "re-export");
+    assert.equal(externalUserShape.source, "re-export");
+    assert.equal(externalUserShape.isTypeOnly, true);
+    assert.equal(mixed.localCount, 2);
+    assert.equal(mixed.reExportCount, 2);
+    assert.equal(mixed.typeOnlyCount, 2);
+    assert.equal(mixed.hasLocalRuntimeExports, true);
+    assert.equal(mixed.isPrimarilyBarrel, false);
+
+    const collision = await moduleExports("src/collision-barrel.ts");
+    assert.equal(collision.exports.some((item) => item.symbol === "dup"), false);
+    assert.equal(collision.count, 0);
+
+    console.log("");
+    console.log("typegraph-mcp Export Surface Test");
+    console.log("=================================");
+    console.log("  ✓ local default exports are reported as default");
+    console.log("  ✓ anonymous default exports stay visible");
+    console.log("  ✓ barrel star re-exports");
+    console.log("  ✓ barrel star re-exports exclude default exports");
+    console.log("  ✓ type-only named re-exports");
+    console.log("  ✓ named alias re-exports");
+    console.log("  ✓ namespace re-exports");
+    console.log("  ✓ mixed local + re-export modules");
+    console.log("  ✓ conflicting star re-exports stay hidden");
+  } finally {
+    await transport.close().catch(() => {});
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});