typegraph-mcp 0.9.1 → 0.9.2

package/dist/config.js

@@ -0,0 +1,13 @@
+// config.ts
+import * as path from "path";
+function resolveConfig(toolDir) {
+  const cwd = process.cwd();
+  const projectRoot = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir)) === "plugins" ? path.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot + path.sep);
+  const toolRelPath = toolIsEmbedded ? path.relative(projectRoot, toolDir) : toolDir;
+  return { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath };
+}
+export {
+  resolveConfig
+};

package/dist/graph-queries.js

@@ -0,0 +1,279 @@
+// graph-queries.ts
+import * as fs from "fs";
+import * as path from "path";
+function shouldIncludeEdge(edge, includeTypeOnly) {
+  if (!includeTypeOnly && edge.isTypeOnly) return false;
+  return true;
+}
+function dependencyTree(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  return { root: file, nodes: result.length, files: result };
+}
+var packageNameCache = /* @__PURE__ */ new Map();
+function findPackageName(filePath) {
+  let dir = path.dirname(filePath);
+  while (dir !== path.dirname(dir)) {
+    if (packageNameCache.has(dir)) return packageNameCache.get(dir);
+    const pkgJsonPath = path.join(dir, "package.json");
+    try {
+      if (fs.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkg.name ?? path.basename(dir);
+        packageNameCache.set(dir, name);
+        return name;
+      }
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return "<root>";
+}
+function dependents(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let directCount = 0;
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.reverse.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        if (currentDepth === 0) directCount++;
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  const byPackage = {};
+  for (const f of result) {
+    const pkgName = findPackageName(f);
+    if (!byPackage[pkgName]) byPackage[pkgName] = [];
+    byPackage[pkgName].push(f);
+  }
+  return { root: file, nodes: result.length, directCount, files: result, byPackage };
+}
+function importCycles(graph, opts = {}) {
+  const { file, package: pkgDir } = opts;
+  let index = 0;
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const indices = /* @__PURE__ */ new Map();
+  const lowlinks = /* @__PURE__ */ new Map();
+  const sccs = [];
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    const edges = graph.forward.get(v) ?? [];
+    for (const edge of edges) {
+      const w = edge.target;
+      if (!graph.files.has(w)) continue;
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) {
+        sccs.push(scc);
+      }
+    }
+  }
+  for (const f of graph.files) {
+    if (!indices.has(f)) {
+      strongconnect(f);
+    }
+  }
+  let cycles = sccs;
+  if (file) {
+    cycles = cycles.filter((scc) => scc.includes(file));
+  }
+  if (pkgDir) {
+    const absPkgDir = path.resolve(pkgDir);
+    cycles = cycles.filter(
+      (scc) => scc.every((f) => f.startsWith(absPkgDir))
+    );
+  }
+  return { count: cycles.length, cycles };
+}
+function shortestPath(graph, from, to, opts = {}) {
+  const { includeTypeOnly = false } = opts;
+  if (from === to) {
+    return { path: [from], hops: 0, chain: [{ file: from, imports: [] }] };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  visited.add(from);
+  let frontier = [from];
+  while (frontier.length > 0) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        parent.set(edge.target, { from: f, specifiers: edge.specifiers });
+        if (edge.target === to) {
+          const filePath = [to];
+          let current = to;
+          while (parent.has(current)) {
+            current = parent.get(current).from;
+            filePath.unshift(current);
+          }
+          const chain = [];
+          for (let i = 0; i < filePath.length; i++) {
+            const p = parent.get(filePath[i]);
+            chain.push({
+              file: filePath[i],
+              imports: p?.specifiers ?? []
+            });
+          }
+          return { path: filePath, hops: filePath.length - 1, chain };
+        }
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return { path: null, hops: -1, chain: [] };
+}
+function subgraph(graph, files, opts = {}) {
+  const { depth = 1, direction = "both" } = opts;
+  const visited = new Set(files);
+  let frontier = [...files];
+  for (let d = 0; d < depth && frontier.length > 0; d++) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      if (direction === "imports" || direction === "both") {
+        for (const edge of graph.forward.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+      if (direction === "dependents" || direction === "both") {
+        for (const edge of graph.reverse.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  const nodes = [...visited];
+  const edges = [];
+  for (const f of nodes) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (visited.has(edge.target)) {
+        edges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers,
+          isTypeOnly: edge.isTypeOnly
+        });
+      }
+    }
+  }
+  return { nodes, edges, stats: { nodeCount: nodes.length, edgeCount: edges.length } };
+}
+function moduleBoundary(graph, files) {
+  const fileSet = new Set(files);
+  let internalEdges = 0;
+  const incomingEdges = [];
+  const outgoingEdges = [];
+  const outgoingTargets = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (fileSet.has(edge.target)) {
+        internalEdges++;
+      } else {
+        outgoingEdges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers
+        });
+        outgoingTargets.add(edge.target);
+      }
+    }
+  }
+  for (const f of files) {
+    for (const edge of graph.reverse.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        incomingEdges.push({
+          from: edge.target,
+          to: f,
+          specifiers: edge.specifiers
+        });
+      }
+    }
+  }
+  const depCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        depCounts.set(edge.target, (depCounts.get(edge.target) ?? 0) + 1);
+      }
+    }
+  }
+  const sharedDependencies = [...depCounts.entries()].filter(([, count]) => count > 1).map(([dep]) => dep);
+  const total = internalEdges + incomingEdges.length + outgoingEdges.length;
+  const isolationScore = total === 0 ? 1 : internalEdges / total;
+  return {
+    internalEdges,
+    incomingEdges,
+    outgoingEdges,
+    sharedDependencies,
+    isolationScore
+  };
+}
+export {
+  dependencyTree,
+  dependents,
+  importCycles,
+  moduleBoundary,
+  shortestPath,
+  subgraph
+};

package/dist/module-graph.js

@@ -0,0 +1,336 @@
+// module-graph.ts
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
+import * as fs from "fs";
+import * as path from "path";
+var log = (...args) => console.error("[typegraph/graph]", ...args);
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".wrangler",
+  ".mf",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+function discoverFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && dir !== rootDir) continue;
+        walk(path.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (SKIP_FILES.has(name)) continue;
+        if (name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts")) continue;
+        const ext = path.extname(name);
+        if (TS_EXTENSIONS.has(ext)) {
+          files.push(path.join(dir, name));
+        }
+      }
+    }
+  }
+  walk(rootDir);
+  return files;
+}
+function parseFileImports(filePath, source) {
+  const result = parseSync(filePath, source);
+  const imports = [];
+  for (const imp of result.module.staticImports) {
+    const specifier = imp.moduleRequest.value;
+    const names = [];
+    let allTypeOnly = true;
+    for (const entry of imp.entries) {
+      const kind = entry.importName.kind;
+      const name = kind === "Default" ? "default" : kind === "All" || kind === "AllButDefault" || kind === "NamespaceObject" ? "*" : entry.importName.name ?? entry.localName.value;
+      names.push(name);
+      if (!entry.isType) allTypeOnly = false;
+    }
+    if (names.length === 0) {
+      imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: false });
+    } else {
+      imports.push({ specifier, names, isTypeOnly: allTypeOnly, isDynamic: false });
+    }
+  }
+  for (const exp of result.module.staticExports) {
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (!moduleRequest) continue;
+      const specifier = moduleRequest.value;
+      const entryKind = entry.importName.kind;
+      const name = entryKind === "AllButDefault" || entryKind === "All" || entryKind === "NamespaceObject" ? "*" : entry.importName.name ?? "*";
+      const existing = imports.find((i) => i.specifier === specifier && !i.isDynamic);
+      if (existing) {
+        if (!existing.names.includes(name)) existing.names.push(name);
+      } else {
+        imports.push({ specifier, names: [name], isTypeOnly: false, isDynamic: false });
+      }
+    }
+  }
+  for (const di of result.module.dynamicImports) {
+    if (di.moduleRequest) {
+      const sliced = source.slice(di.moduleRequest.start, di.moduleRequest.end);
+      if (sliced.startsWith("'") || sliced.startsWith('"')) {
+        const specifier = sliced.slice(1, -1);
+        imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: true });
+      }
+    }
+  }
+  return imports;
+}
+var SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+function distToSource(resolvedPath, projectRoot) {
+  if (!resolvedPath.startsWith(projectRoot)) return resolvedPath;
+  const rel = path.relative(projectRoot, resolvedPath);
+  const distIdx = rel.indexOf("dist" + path.sep);
+  if (distIdx === -1) return resolvedPath;
+  const prefix = rel.slice(0, distIdx);
+  const afterDist = rel.slice(distIdx + 5);
+  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path.resolve(projectRoot, prefix, "src", withoutExt + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path.resolve(projectRoot, prefix, withoutExt + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path.resolve(projectRoot, prefix, "src", dirPath + ext);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return resolvedPath;
+}
+function resolveImport(resolver, fromDir, specifier, projectRoot) {
+  try {
+    const result = resolver.sync(fromDir, specifier);
+    if (result.path && !result.path.includes("node_modules")) {
+      const mapped = distToSource(result.path, projectRoot);
+      const ext = path.extname(mapped);
+      if (!TS_EXTENSIONS.has(ext)) return null;
+      if (SKIP_FILES.has(path.basename(mapped))) return null;
+      return mapped;
+    }
+  } catch {
+  }
+  return null;
+}
+function createResolver(projectRoot, tsconfigPath) {
+  return new ResolverFactory({
+    tsconfig: {
+      configFile: path.resolve(projectRoot, tsconfigPath),
+      references: "auto"
+    },
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    extensionAlias: {
+      ".js": [".ts", ".tsx", ".js"],
+      ".jsx": [".tsx", ".jsx"],
+      ".mjs": [".mts", ".mjs"],
+      ".cjs": [".cts", ".cjs"]
+    },
+    conditionNames: ["import", "require"],
+    mainFields: ["module", "main"]
+  });
+}
+function buildForwardEdges(files, resolver, projectRoot) {
+  const forward = /* @__PURE__ */ new Map();
+  const parseFailures = [];
+  for (const filePath of files) {
+    let source;
+    try {
+      source = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    let rawImports;
+    try {
+      rawImports = parseFileImports(filePath, source);
+    } catch (err) {
+      parseFailures.push(filePath);
+      continue;
+    }
+    const edges = [];
+    const fromDir = path.dirname(filePath);
+    for (const raw of rawImports) {
+      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+      if (target) {
+        edges.push({
+          target,
+          specifiers: raw.names,
+          isTypeOnly: raw.isTypeOnly,
+          isDynamic: raw.isDynamic
+        });
+      }
+    }
+    forward.set(filePath, edges);
+  }
+  return { forward, parseFailures };
+}
+function buildReverseMap(forward) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [source, edges] of forward) {
+    for (const edge of edges) {
+      let revEdges = reverse.get(edge.target);
+      if (!revEdges) {
+        revEdges = [];
+        reverse.set(edge.target, revEdges);
+      }
+      revEdges.push({
+        target: source,
+        // reverse: the "target" is the file that imports
+        specifiers: edge.specifiers,
+        isTypeOnly: edge.isTypeOnly,
+        isDynamic: edge.isDynamic
+      });
+    }
+  }
+  return reverse;
+}
+async function buildGraph(projectRoot, tsconfigPath) {
+  const startTime = performance.now();
+  const resolver = createResolver(projectRoot, tsconfigPath);
+  const fileList = discoverFiles(projectRoot);
+  log(`Discovered ${fileList.length} source files`);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot);
+  const reverse = buildReverseMap(forward);
+  const files = new Set(fileList);
+  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
+  const elapsed = (performance.now() - startTime).toFixed(0);
+  log(`Graph built: ${files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+  if (parseFailures.length > 0) {
+    log(`Parse failures: ${parseFailures.length} files`);
+  }
+  return {
+    graph: { forward, reverse, files },
+    resolver
+  };
+}
+function updateFile(graph, filePath, resolver, projectRoot) {
+  const oldEdges = graph.forward.get(filePath) ?? [];
+  for (const edge of oldEdges) {
+    const revEdges = graph.reverse.get(edge.target);
+    if (revEdges) {
+      const idx = revEdges.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges.splice(idx, 1);
+      if (revEdges.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  let source;
+  try {
+    source = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    removeFile(graph, filePath);
+    return;
+  }
+  let rawImports;
+  try {
+    rawImports = parseFileImports(filePath, source);
+  } catch {
+    log(`Parse error on update: ${filePath}`);
+    graph.forward.set(filePath, []);
+    return;
+  }
+  const fromDir = path.dirname(filePath);
+  const newEdges = [];
+  for (const raw of rawImports) {
+    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+    if (target) {
+      newEdges.push({
+        target,
+        specifiers: raw.names,
+        isTypeOnly: raw.isTypeOnly,
+        isDynamic: raw.isDynamic
+      });
+    }
+  }
+  graph.forward.set(filePath, newEdges);
+  graph.files.add(filePath);
+  for (const edge of newEdges) {
+    let revEdges = graph.reverse.get(edge.target);
+    if (!revEdges) {
+      revEdges = [];
+      graph.reverse.set(edge.target, revEdges);
+    }
+    revEdges.push({
+      target: filePath,
+      specifiers: edge.specifiers,
+      isTypeOnly: edge.isTypeOnly,
+      isDynamic: edge.isDynamic
+    });
+  }
+}
+function removeFile(graph, filePath) {
+  const edges = graph.forward.get(filePath) ?? [];
+  for (const edge of edges) {
+    const revEdges2 = graph.reverse.get(edge.target);
+    if (revEdges2) {
+      const idx = revEdges2.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges2.splice(idx, 1);
+      if (revEdges2.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  const revEdges = graph.reverse.get(filePath) ?? [];
+  for (const revEdge of revEdges) {
+    const fwdEdges = graph.forward.get(revEdge.target);
+    if (fwdEdges) {
+      const idx = fwdEdges.findIndex((e) => e.target === filePath);
+      if (idx !== -1) fwdEdges.splice(idx, 1);
+    }
+  }
+  graph.forward.delete(filePath);
+  graph.reverse.delete(filePath);
+  graph.files.delete(filePath);
+}
+function startWatcher(projectRoot, graph, resolver) {
+  try {
+    const watcher = fs.watch(
+      projectRoot,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (!filename) return;
+        const ext = path.extname(filename);
+        if (!TS_EXTENSIONS.has(ext)) return;
+        const parts = filename.split(path.sep);
+        if (parts.some((p) => SKIP_DIRS.has(p))) return;
+        if (SKIP_FILES.has(path.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath = path.resolve(projectRoot, filename);
+        if (fs.existsSync(absPath)) {
+          updateFile(graph, absPath, resolver, projectRoot);
+        } else {
+          removeFile(graph, absPath);
+        }
+      }
+    );
+    process.on("SIGINT", () => watcher.close());
+    process.on("SIGTERM", () => watcher.close());
+    log("File watcher started");
+  } catch (err) {
+    log("Failed to start file watcher:", err);
+  }
+}
+export {
+  buildGraph,
+  createResolver,
+  discoverFiles,
+  removeFile,
+  startWatcher,
+  updateFile
+};