archtracker-mcp 0.3.2 → 0.4.1

package/dist/mcp/index.js

@@ -1,128 +1,17 @@
+#!/usr/bin/env node
+
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z2 } from "zod";
 
 // src/analyzer/analyze.ts
-import { resolve as resolve4 } from "path";
-
-// src/analyzer/engines/dependency-cruiser.ts
-import { resolve } from "path";
-import { cruise } from "dependency-cruiser";
-var DEFAULT_EXCLUDE = [
-  "node_modules",
-  "\\.d\\.ts$",
-  "dist",
-  "build",
-  "coverage",
-  "\\.archtracker"
-];
-var DependencyCruiserEngine = class {
-  async analyze(rootDir, options = {}) {
-    const {
-      exclude = [],
-      maxDepth = 0,
-      tsConfigPath,
-      includeTypeOnly = true
-    } = options;
-    const absRootDir = resolve(rootDir);
-    const allExclude = [...DEFAULT_EXCLUDE, ...exclude];
-    const excludePattern = allExclude.join("|");
-    const cruiseOptions = {
-      baseDir: absRootDir,
-      exclude: { path: excludePattern },
-      doNotFollow: { path: "node_modules" },
-      maxDepth,
-      tsPreCompilationDeps: includeTypeOnly ? true : false,
-      combinedDependencies: false
-    };
-    if (tsConfigPath) {
-      cruiseOptions.tsConfig = { fileName: tsConfigPath };
-    }
-    let result;
-    try {
-      result = await cruise(["."], cruiseOptions);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`dependency-cruiser failed: ${message}`, {
-        cause: error
-      });
-    }
-    if (result.exitCode !== 0 && !result.output) {
-      throw new Error(`Analysis exited with code ${result.exitCode}`);
-    }
-    const cruiseResult = result.output;
-    return this.buildGraph(absRootDir, cruiseResult);
-  }
-  buildGraph(rootDir, cruiseResult) {
-    const files = {};
-    const edges = [];
-    const circularSet = /* @__PURE__ */ new Set();
-    const circularDependencies = [];
-    for (const mod of cruiseResult.modules) {
-      if (this.isExternalModule(mod)) continue;
-      files[mod.source] = {
-        path: mod.source,
-        exists: !mod.couldNotResolve,
-        dependencies: [],
-        dependents: []
-      };
-    }
-    for (const mod of cruiseResult.modules) {
-      for (const dep of mod.dependencies) {
-        if (dep.couldNotResolve || dep.coreModule) continue;
-        if (!files[mod.source] || this.isExternalDep(dep)) continue;
-        const edgeType = dep.typeOnly ? "type-only" : dep.dynamic ? "dynamic" : "static";
-        edges.push({ source: mod.source, target: dep.resolved, type: edgeType });
-        if (files[mod.source]) {
-          files[mod.source].dependencies.push(dep.resolved);
-        }
-        if (files[dep.resolved]) {
-          files[dep.resolved].dependents.push(mod.source);
-        }
-        if (dep.circular && dep.cycle) {
-          const cyclePath = dep.cycle.map((c) => c.name);
-          const cycleKey = [...cyclePath].sort().join("\u2192");
-          if (!circularSet.has(cycleKey)) {
-            circularSet.add(cycleKey);
-            circularDependencies.push({ cycle: cyclePath });
-          }
-        }
-      }
-    }
-    return {
-      rootDir,
-      files,
-      edges,
-      circularDependencies,
-      totalFiles: Object.keys(files).length,
-      totalEdges: edges.length
-    };
-  }
-  isExternalModule(mod) {
-    if (mod.coreModule) return true;
-    const depTypes = mod.dependencyTypes ?? [];
-    if (depTypes.some((t2) => t2.startsWith("npm") || t2 === "core")) return true;
-    return isExternalPath(mod.source);
-  }
-  isExternalDep(dep) {
-    if (dep.coreModule) return true;
-    if (dep.dependencyTypes.some((t2) => t2.startsWith("npm") || t2 === "core"))
-      return true;
-    return isExternalPath(dep.resolved);
-  }
-};
-function isExternalPath(source) {
-  if (source.startsWith("@")) return true;
-  if (!source.includes("/") && !source.includes("\\") && !source.includes("."))
-    return true;
-  if (source.startsWith("node:")) return true;
-  return false;
-}
+import { resolve as resolve3 } from "path";
+import { stat as stat3 } from "fs/promises";
 
 // src/analyzer/engines/regex-engine.ts
 import { readdir, readFile } from "fs/promises";
-import { join, relative, resolve as resolve2 } from "path";
+import { join, relative, resolve } from "path";
 
 // src/analyzer/engines/cycle.ts
 function detectCycles(edges) {
@@ -680,7 +569,7 @@ var RegexEngine = class {
     this.config = config;
   }
   async analyze(rootDir, options = {}) {
-    const absRootDir = resolve2(rootDir);
+    const absRootDir = resolve(rootDir);
     const excludePatterns = [
       ...this.config.defaultExclude ?? [],
       ...options.exclude ?? [],
@@ -927,7 +816,7 @@ async function scanExtensions(dir, counts, maxDepth, currentDepth) {
 
 // src/analyzer/engines/languages.ts
 import { readFileSync } from "fs";
-import { join as join3, dirname, resolve as resolve3 } from "path";
+import { join as join3, dirname, resolve as resolve2 } from "path";
 
 // src/analyzer/engines/types.ts
 var LANGUAGE_IDS = [
@@ -1210,7 +1099,7 @@ var cCpp = {
     { regex: /^#include\s+"([^"]+)"/gm }
   ],
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
-    const fromSource = resolve3(dirname(sourceFile), importPath);
+    const fromSource = resolve2(dirname(sourceFile), importPath);
     if (projectFiles.has(fromSource)) return fromSource;
     const fromRoot = join3(rootDir, importPath);
     if (projectFiles.has(fromRoot)) return fromRoot;
@@ -1234,7 +1123,7 @@ var ruby = {
   ],
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     const withExt = importPath.endsWith(".rb") ? importPath : importPath + ".rb";
-    const fromSource = resolve3(dirname(sourceFile), withExt);
+    const fromSource = resolve2(dirname(sourceFile), withExt);
     if (projectFiles.has(fromSource)) return fromSource;
     const fromRoot = join3(rootDir, withExt);
     if (projectFiles.has(fromRoot)) return fromRoot;
@@ -1257,7 +1146,7 @@ var php = {
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     if (importPath.includes("/") || importPath.endsWith(".php")) {
       const withExt = importPath.endsWith(".php") ? importPath : importPath + ".php";
-      const fromSource = resolve3(dirname(sourceFile), withExt);
+      const fromSource = resolve2(dirname(sourceFile), withExt);
       if (projectFiles.has(fromSource)) return fromSource;
       const fromRoot2 = join3(rootDir, withExt);
       if (projectFiles.has(fromRoot2)) return fromRoot2;
@@ -1377,7 +1266,7 @@ var dart = {
       if (projectFiles.has(full)) return full;
       return null;
     }
-    const resolved = resolve3(dirname(sourceFile), importPath);
+    const resolved = resolve2(dirname(sourceFile), importPath);
     if (projectFiles.has(resolved)) return resolved;
     return null;
   },
@@ -1441,9 +1330,47 @@ var scala = {
   },
   defaultExclude: ["target", "\\.bsp", "\\.metals", "\\.bloop"]
 };
+var javascript = {
+  id: "javascript",
+  extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // ES6: import [type] [stuff from] "path"
+    { regex: /import\s+(?:type\s+)?(?:[\w*{}\s,]+\s+from\s+)?["']([^"']+)["']/g },
+    // Dynamic: import("path")
+    { regex: /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g },
+    // Re-export: export [type] { stuff } from "path" / export * from "path"
+    { regex: /export\s+(?:type\s+)?(?:\{[^}]*\}|\*(?:\s+as\s+\w+)?)\s+from\s+["']([^"']+)["']/g },
+    // CommonJS: require("path")
+    { regex: /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    if (importPath.startsWith("node:")) return null;
+    if (!importPath.startsWith(".")) return null;
+    const resolved = resolve2(dirname(sourceFile), importPath);
+    if (projectFiles.has(resolved)) return resolved;
+    if (resolved.endsWith(".js")) {
+      const tsPath = resolved.slice(0, -3) + ".ts";
+      if (projectFiles.has(tsPath)) return tsPath;
+      const tsxPath = resolved.slice(0, -3) + ".tsx";
+      if (projectFiles.has(tsxPath)) return tsxPath;
+    }
+    if (resolved.endsWith(".jsx")) {
+      const tsxPath = resolved.slice(0, -4) + ".tsx";
+      if (projectFiles.has(tsxPath)) return tsxPath;
+    }
+    for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]) {
+      if (projectFiles.has(resolved + ext)) return resolved + ext;
+    }
+    for (const idx of ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
+      if (projectFiles.has(resolved + idx)) return resolved + idx;
+    }
+    return null;
+  },
+  defaultExclude: ["node_modules", "\\.d\\.ts$", "dist", "build", "coverage"]
+};
 var LANGUAGE_CONFIGS = {
-  javascript: null,
-  // handled by DependencyCruiserEngine
+  javascript,
   python,
   rust,
   go,
@@ -1463,12 +1390,18 @@ function getLanguageConfig(id) {
 
 // src/analyzer/analyze.ts
 async function analyzeProject(rootDir, options = {}) {
-  const absRootDir = resolve4(rootDir);
-  const language = options.language ?? await detectLanguage(absRootDir);
+  const absRootDir = resolve3(rootDir);
   try {
-    if (language === "javascript") {
-      return await new DependencyCruiserEngine().analyze(absRootDir, options);
+    const s = await stat3(absRootDir);
+    if (!s.isDirectory()) {
+      throw new AnalyzerError(`Not a directory: ${absRootDir}`);
     }
+  } catch (error) {
+    if (error instanceof AnalyzerError) throw error;
+    throw new AnalyzerError(`Directory not found: ${absRootDir}`, { cause: error });
+  }
+  const language = options.language ?? await detectLanguage(absRootDir);
+  try {
     const config = getLanguageConfig(language);
     if (!config) {
       throw new AnalyzerError(`No analyzer config for language: ${language}`);
@@ -1983,10 +1916,10 @@ function arraysEqual(a, b) {
 }
 
 // src/utils/path-guard.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve4 } from "path";
 function validatePath(inputPath, boundary) {
-  const resolved = resolve5(inputPath);
-  const root = boundary ? resolve5(boundary) : process.cwd();
+  const resolved = resolve4(inputPath);
+  const root = boundary ? resolve4(boundary) : process.cwd();
   if (!resolved.startsWith(root)) {
     throw new PathTraversalError(
       t("pathGuard.traversal", { input: inputPath, resolved, boundary: root })