archtracker-mcp 0.1.1 → 0.2.1

package/dist/mcp/index.js

@@ -4,6 +4,9 @@ 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 = [
@@ -14,110 +17,1026 @@ var DEFAULT_EXCLUDE = [
   "coverage",
   "\\.archtracker"
 ];
-async function analyzeProject(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 };
+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);
   }
-  let result;
-  try {
-    result = await cruise(["."], cruiseOptions);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new AnalyzerError(
-      `dependency-cruiser \u306E\u5B9F\u884C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${message}`,
-      { cause: error }
-    );
+  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
+    };
   }
-  if (result.exitCode !== 0 && !result.output) {
-    throw new AnalyzerError(
-      `\u89E3\u6790\u304C\u30A8\u30E9\u30FC\u30B3\u30FC\u30C9 ${result.exitCode} \u3067\u7D42\u4E86\u3057\u307E\u3057\u305F`
-    );
+  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;
+}
+
+// src/analyzer/engines/regex-engine.ts
+import { readdir, readFile } from "fs/promises";
+import { join, relative, resolve as resolve2 } from "path";
+
+// src/analyzer/engines/cycle.ts
+function detectCycles(edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!adj.has(edge.source)) adj.set(edge.source, []);
+    adj.get(edge.source).push(edge.target);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const cycleKeys = /* @__PURE__ */ new Set();
+  function dfs(node, path) {
+    if (inStack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      if (cycleStart !== -1) {
+        const cycle = path.slice(cycleStart);
+        const key = [...cycle].sort().join("\u2192");
+        if (!cycleKeys.has(key)) {
+          cycleKeys.add(key);
+          cycles.push({ cycle });
+        }
+      }
+      return;
+    }
+    if (visited.has(node)) return;
+    visited.add(node);
+    inStack.add(node);
+    path.push(node);
+    for (const neighbor of adj.get(node) ?? []) {
+      dfs(neighbor, path);
+    }
+    path.pop();
+    inStack.delete(node);
+  }
+  for (const node of adj.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  return cycles;
+}
+
+// src/analyzer/engines/strip-comments.ts
+function stripComments(content, style) {
+  switch (style) {
+    case "c-style":
+      return stripCStyle(content);
+    case "hash":
+      return stripHash(content);
+    case "python":
+      return stripPython(content);
+    case "ruby":
+      return stripRuby(content);
+    case "php":
+      return stripPhp(content);
+  }
+}
+function stripCStyle(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "/" && content[i + 1] === "/") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === "/" && content[i + 1] === "*") {
+      result += " ";
+      i++;
+      result += " ";
+      i++;
+      while (i < content.length) {
+        if (content[i] === "*" && content[i + 1] === "/") {
+          result += " ";
+          i++;
+          result += " ";
+          i++;
+          break;
+        }
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i];
+          i++;
+          result += content[i];
+          i++;
+        } else if (content[i] === "\n") {
+          result += "\n";
+          i++;
+        } else {
+          result += content[i];
+          i++;
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "`") {
+      result += " ";
+      i++;
+      while (i < content.length && content[i] !== "`") {
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      if (i < content.length) {
+        result += " ";
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripHash(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "'") {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== "'") {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripPython(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === '"' && content[i + 1] === '"' && content[i + 2] === '"' || content[i] === "'" && content[i + 1] === "'" && content[i + 2] === "'") {
+      const quote = content[i];
+      const tripleQuote = quote + quote + quote;
+      result += "   ";
+      i += 3;
+      while (i < content.length) {
+        if (content[i] === quote && content[i + 1] === quote && content[i + 2] === quote) {
+          result += "   ";
+          i += 3;
+          break;
+        }
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+    } else if (content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === '"' || content[i] === "'") {
+      const quote = content[i];
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== quote) {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else if (content[i] === "\n") {
+          result += "\n";
+          i++;
+          break;
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length && content[i] === quote) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripRuby(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inBlock = false;
+  for (const line of lines) {
+    if (!inBlock && line.startsWith("=begin")) {
+      inBlock = true;
+      result.push(" ".repeat(line.length));
+      continue;
+    }
+    if (inBlock) {
+      if (line.startsWith("=end")) {
+        inBlock = false;
+      }
+      result.push(" ".repeat(line.length));
+      continue;
+    }
+    let processed = "";
+    let i = 0;
+    while (i < line.length) {
+      if (line[i] === "#") {
+        processed += " ".repeat(line.length - i);
+        break;
+      } else if (line[i] === '"') {
+        processed += line[i];
+        i++;
+        while (i < line.length && line[i] !== '"') {
+          if (line[i] === "\\" && i + 1 < line.length) {
+            processed += line[i++];
+            processed += line[i++];
+          } else {
+            processed += line[i++];
+          }
+        }
+        if (i < line.length) {
+          processed += line[i];
+          i++;
+        }
+      } else if (line[i] === "'") {
+        processed += line[i];
+        i++;
+        while (i < line.length && line[i] !== "'") {
+          if (line[i] === "\\" && i + 1 < line.length) {
+            processed += line[i++];
+            processed += line[i++];
+          } else {
+            processed += line[i++];
+          }
+        }
+        if (i < line.length) {
+          processed += line[i];
+          i++;
+        }
+      } else {
+        processed += line[i];
+        i++;
+      }
+    }
+    result.push(processed);
+  }
+  return result.join("\n");
+}
+function stripPhp(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "/" && content[i + 1] === "/" || content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === "/" && content[i + 1] === "*") {
+      result += " ";
+      i++;
+      result += " ";
+      i++;
+      while (i < content.length) {
+        if (content[i] === "*" && content[i + 1] === "/") {
+          result += " ";
+          i++;
+          result += " ";
+          i++;
+          break;
+        }
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "'") {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== "'") {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+
+// src/analyzer/engines/regex-engine.ts
+var RegexEngine = class {
+  constructor(config) {
+    this.config = config;
   }
-  const cruiseResult = result.output;
-  return buildGraph(absRootDir, cruiseResult);
-}
-function buildGraph(rootDir, cruiseResult) {
-  const files = {};
-  const edges = [];
-  const circularSet = /* @__PURE__ */ new Set();
-  const circularDependencies = [];
-  for (const mod of cruiseResult.modules) {
-    if (isExternalModule(mod)) continue;
-    files[mod.source] = {
-      path: mod.source,
-      exists: !mod.couldNotResolve,
-      dependencies: [],
-      dependents: []
+  async analyze(rootDir, options = {}) {
+    const absRootDir = resolve2(rootDir);
+    const excludePatterns = [
+      ...this.config.defaultExclude ?? [],
+      ...options.exclude ?? [],
+      "\\.archtracker"
+    ].map((p) => new RegExp(p));
+    const projectFiles = await this.collectFiles(
+      absRootDir,
+      excludePatterns,
+      options.maxDepth ?? 0
+    );
+    const projectFileSet = new Set(projectFiles);
+    const files = {};
+    const edges = [];
+    const edgeSet = /* @__PURE__ */ new Set();
+    for (const filePath of projectFiles) {
+      const relPath = relative(absRootDir, filePath);
+      files[relPath] = {
+        path: relPath,
+        exists: true,
+        dependencies: [],
+        dependents: []
+      };
+    }
+    for (const filePath of projectFiles) {
+      const relSource = relative(absRootDir, filePath);
+      let content;
+      try {
+        content = await readFile(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const stripped = stripComments(content, this.config.commentStyle);
+      const imports = this.extractImports(stripped);
+      for (const importPath of imports) {
+        const resolved = this.config.resolveImport(
+          importPath,
+          filePath,
+          absRootDir,
+          projectFileSet
+        );
+        if (!resolved) continue;
+        const relTarget = relative(absRootDir, resolved);
+        if (!files[relTarget]) continue;
+        if (relSource === relTarget) continue;
+        const edgeKey = `${relSource}\0${relTarget}`;
+        if (edgeSet.has(edgeKey)) continue;
+        edgeSet.add(edgeKey);
+        edges.push({
+          source: relSource,
+          target: relTarget,
+          type: "static"
+        });
+        files[relSource].dependencies.push(relTarget);
+        files[relTarget].dependents.push(relSource);
+      }
+    }
+    const circularDependencies = detectCycles(edges);
+    return {
+      rootDir: absRootDir,
+      files,
+      edges,
+      circularDependencies,
+      totalFiles: Object.keys(files).length,
+      totalEdges: edges.length
     };
   }
-  for (const mod of cruiseResult.modules) {
-    for (const dep of mod.dependencies) {
-      if (dep.couldNotResolve || dep.coreModule) continue;
-      if (!files[mod.source] || 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 });
+  extractImports(content) {
+    if (this.config.extractImports) {
+      return this.config.extractImports(content);
+    }
+    const imports = [];
+    for (const pattern of this.config.importPatterns) {
+      const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        if (match[1]) {
+          imports.push(match[1]);
         }
       }
     }
+    return imports;
   }
-  return {
-    rootDir,
-    files,
-    edges,
-    circularDependencies,
-    totalFiles: Object.keys(files).length,
-    totalEdges: edges.length
-  };
+  async collectFiles(dir, excludePatterns, maxDepth, currentDepth = 0) {
+    if (maxDepth > 0 && currentDepth >= maxDepth) return [];
+    const results = [];
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(dir, fullPath);
+      if (excludePatterns.some(
+        (p) => p.test(entry.name) || p.test(relPath) || p.test(fullPath)
+      )) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".")) continue;
+        const sub = await this.collectFiles(
+          fullPath,
+          excludePatterns,
+          maxDepth,
+          currentDepth + 1
+        );
+        results.push(...sub);
+      } else if (entry.isFile()) {
+        const dotIdx = entry.name.lastIndexOf(".");
+        if (dotIdx > 0) {
+          const ext = entry.name.slice(dotIdx);
+          if (this.config.extensions.includes(ext)) {
+            results.push(fullPath);
+          }
+        }
+      }
+    }
+    return results;
+  }
+};
+
+// src/analyzer/engines/detect.ts
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
+var MARKERS = [
+  { file: "Cargo.toml", language: "rust" },
+  { file: "go.mod", language: "go" },
+  { file: "pyproject.toml", language: "python" },
+  { file: "setup.py", language: "python" },
+  { file: "requirements.txt", language: "python" },
+  { file: "Pipfile", language: "python" },
+  { file: "pom.xml", language: "java" },
+  { file: "build.gradle", language: "java" },
+  { file: "build.gradle.kts", language: "kotlin" },
+  { file: "Package.swift", language: "swift" },
+  { file: "Gemfile", language: "ruby" },
+  { file: "composer.json", language: "php" },
+  { file: "CMakeLists.txt", language: "c-cpp" },
+  { file: "Makefile", language: "c-cpp" },
+  { file: "package.json", language: "javascript" },
+  { file: "tsconfig.json", language: "javascript" }
+];
+var EXT_MAP = {
+  ".ts": "javascript",
+  ".tsx": "javascript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".c": "c-cpp",
+  ".cpp": "c-cpp",
+  ".cc": "c-cpp",
+  ".cxx": "c-cpp",
+  ".h": "c-cpp",
+  ".hpp": "c-cpp",
+  ".rb": "ruby",
+  ".php": "php",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".kts": "kotlin"
+};
+async function detectLanguage(rootDir) {
+  for (const marker of MARKERS) {
+    try {
+      const s = await stat2(join2(rootDir, marker.file));
+      if (s.isFile() || s.isDirectory()) {
+        return marker.language;
+      }
+    } catch {
+    }
+  }
+  const counts = /* @__PURE__ */ new Map();
+  try {
+    await scanExtensions(rootDir, counts, 2, 0);
+  } catch {
+  }
+  if (counts.size > 0) {
+    let maxLang = "javascript";
+    let maxCount = 0;
+    for (const [lang, count] of counts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxLang = lang;
+      }
+    }
+    return maxLang;
+  }
+  return "javascript";
 }
-function 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);
+async function scanExtensions(dir, counts, maxDepth, currentDepth) {
+  if (currentDepth >= maxDepth) return;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+      await scanExtensions(
+        join2(dir, entry.name),
+        counts,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else if (entry.isFile()) {
+      const dotIdx = entry.name.lastIndexOf(".");
+      if (dotIdx > 0) {
+        const ext = entry.name.slice(dotIdx);
+        const lang = EXT_MAP[ext];
+        if (lang) {
+          counts.set(lang, (counts.get(lang) ?? 0) + 1);
+        }
+      }
+    }
+  }
 }
-function isExternalDep(dep) {
-  if (dep.coreModule) return true;
-  if (dep.dependencyTypes.some((t2) => t2.startsWith("npm") || t2 === "core")) return true;
-  return isExternalPath(dep.resolved);
+
+// src/analyzer/engines/languages.ts
+import { readFileSync } from "fs";
+import { join as join3, dirname, resolve as resolve3 } from "path";
+var python = {
+  id: "python",
+  extensions: [".py"],
+  commentStyle: "python",
+  importPatterns: [
+    // from package.module import something
+    { regex: /^from\s+(\.[\w.]*|\w[\w.]*)\s+import\b/gm },
+    // import package.module
+    { regex: /^import\s+([\w.]+)/gm }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    if (importPath.startsWith(".")) {
+      const dots = importPath.match(/^\.+/)?.[0].length ?? 1;
+      let base = dirname(sourceFile);
+      for (let i = 1; i < dots; i++) base = dirname(base);
+      const rest = importPath.slice(dots).replace(/\./g, "/");
+      return tryPythonResolve(join3(base, rest), projectFiles);
+    }
+    const parts = importPath.replace(/\./g, "/");
+    return tryPythonResolve(join3(rootDir, parts), projectFiles);
+  },
+  defaultExclude: ["__pycache__", "\\.venv", "venv", "\\.egg-info", "dist", "build"]
+};
+function tryPythonResolve(base, projectFiles) {
+  if (projectFiles.has(base + ".py")) return base + ".py";
+  if (projectFiles.has(join3(base, "__init__.py"))) return join3(base, "__init__.py");
+  return null;
 }
-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;
+var rust = {
+  id: "rust",
+  extensions: [".rs"],
+  commentStyle: "c-style",
+  importPatterns: [],
+  // handled by extractImports
+  extractImports(content) {
+    const imports = [];
+    const modRegex = /\bmod\s+(\w+)\s*;/gm;
+    let match;
+    while ((match = modRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const useRegex = /\buse\s+crate::([\s\S]*?);/gm;
+    while ((match = useRegex.exec(content)) !== null) {
+      const body = match[1].trim();
+      extractRustUsePaths(body, "", imports);
+    }
+    return imports;
+  },
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    const srcDir = join3(rootDir, "src");
+    if (!importPath.includes("::")) {
+      const parentDir = dirname(sourceFile);
+      const asFile = join3(parentDir, importPath + ".rs");
+      if (projectFiles.has(asFile)) return asFile;
+      const asDir = join3(parentDir, importPath, "mod.rs");
+      if (projectFiles.has(asDir)) return asDir;
+      return null;
+    }
+    const segments = importPath.split("::");
+    for (let i = segments.length; i > 0; i--) {
+      const path = segments.slice(0, i).join("/");
+      const asFile = join3(srcDir, path + ".rs");
+      if (projectFiles.has(asFile)) return asFile;
+      const asDir = join3(srcDir, path, "mod.rs");
+      if (projectFiles.has(asDir)) return asDir;
+    }
+    return null;
+  },
+  defaultExclude: ["target"]
+};
+function extractRustUsePaths(body, prefix, results) {
+  const trimmed = body.trim();
+  const braceStart = trimmed.indexOf("{");
+  if (braceStart === -1) {
+    const path = prefix ? `${prefix}::${trimmed}` : trimmed;
+    if (path && !path.includes("{")) {
+      results.push(path);
+    }
+    return;
+  }
+  let pathPrefix = trimmed.slice(0, braceStart).trim();
+  if (pathPrefix.endsWith("::")) {
+    pathPrefix = pathPrefix.slice(0, -2);
+  }
+  const fullPrefix = prefix ? `${prefix}::${pathPrefix}` : pathPrefix;
+  let depth = 0;
+  let braceEnd = -1;
+  for (let i = braceStart; i < trimmed.length; i++) {
+    if (trimmed[i] === "{") depth++;
+    else if (trimmed[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        braceEnd = i;
+        break;
+      }
+    }
+  }
+  if (braceEnd === -1) return;
+  const inner = trimmed.slice(braceStart + 1, braceEnd).trim();
+  const items = splitByTopLevelComma(inner);
+  for (const item of items) {
+    const cleaned = item.trim();
+    if (cleaned === "self") {
+      results.push(fullPrefix);
+    } else if (cleaned) {
+      extractRustUsePaths(cleaned, fullPrefix, results);
+    }
+  }
+}
+function splitByTopLevelComma(s) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}") depth--;
+    else if (s[i] === "," && depth === 0) {
+      parts.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(s.slice(start));
+  return parts;
+}
+var go = {
+  id: "go",
+  extensions: [".go"],
+  commentStyle: "c-style",
+  importPatterns: [],
+  // handled by extractImports
+  extractImports(content) {
+    const imports = [];
+    const singleRegex = /\bimport\s+(?:\w+\s+)?"([^"]+)"/gm;
+    let match;
+    while ((match = singleRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const blockRegex = /\bimport\s*\(([^)]*)\)/gms;
+    while ((match = blockRegex.exec(content)) !== null) {
+      const block = match[1];
+      const entryRegex = /(?:\w+\s+)?"([^"]+)"/g;
+      let entry;
+      while ((entry = entryRegex.exec(block)) !== null) {
+        imports.push(entry[1]);
+      }
+    }
+    return imports;
+  },
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    const modPrefix = goModulePrefix(rootDir);
+    if (!modPrefix || !importPath.startsWith(modPrefix)) return null;
+    const relPath = importPath.slice(modPrefix.length + 1);
+    const pkgDir = join3(rootDir, relPath);
+    for (const f of projectFiles) {
+      if (f.startsWith(pkgDir + "/") && f.endsWith(".go")) return f;
+    }
+    return null;
+  },
+  defaultExclude: ["vendor"]
+};
+var goModCache = /* @__PURE__ */ new Map();
+function goModulePrefix(rootDir) {
+  if (goModCache.has(rootDir)) return goModCache.get(rootDir);
+  try {
+    const content = readFileSync(join3(rootDir, "go.mod"), "utf-8");
+    const match = content.match(/^module\s+(.+)$/m);
+    const prefix = match ? match[1].trim() : null;
+    goModCache.set(rootDir, prefix);
+    return prefix;
+  } catch {
+    goModCache.set(rootDir, null);
+    return null;
+  }
+}
+var java = {
+  id: "java",
+  extensions: [".java"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // import com.example.ClassName;
+    { regex: /^import\s+(?:static\s+)?([\w.]+);/gm }
+  ],
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    const filePath = importPath.replace(/\./g, "/") + ".java";
+    for (const srcRoot of ["", "src/main/java/", "src/", "app/src/main/java/"]) {
+      const full = join3(rootDir, srcRoot, filePath);
+      if (projectFiles.has(full)) return full;
+    }
+    return null;
+  },
+  defaultExclude: ["build", "target", "\\.gradle", "\\.idea"]
+};
+var cCpp = {
+  id: "c-cpp",
+  extensions: [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // #include "file.h" (skip <system> includes)
+    { regex: /^#include\s+"([^"]+)"/gm }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    const fromSource = resolve3(dirname(sourceFile), importPath);
+    if (projectFiles.has(fromSource)) return fromSource;
+    const fromRoot = join3(rootDir, importPath);
+    if (projectFiles.has(fromRoot)) return fromRoot;
+    for (const incDir of ["include", "src"]) {
+      const full = join3(rootDir, incDir, importPath);
+      if (projectFiles.has(full)) return full;
+    }
+    return null;
+  },
+  defaultExclude: ["build", "cmake-build", "\\.o$", "\\.obj$"]
+};
+var ruby = {
+  id: "ruby",
+  extensions: [".rb"],
+  commentStyle: "ruby",
+  importPatterns: [
+    // require_relative 'path'
+    { regex: /\brequire_relative\s+['"]([^'"]+)['"]/gm },
+    // require 'path' (for project-internal requires)
+    { regex: /\brequire\s+['"]([^'"]+)['"]/gm }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    const withExt = importPath.endsWith(".rb") ? importPath : importPath + ".rb";
+    const fromSource = resolve3(dirname(sourceFile), withExt);
+    if (projectFiles.has(fromSource)) return fromSource;
+    const fromRoot = join3(rootDir, withExt);
+    if (projectFiles.has(fromRoot)) return fromRoot;
+    const fromLib = join3(rootDir, "lib", withExt);
+    if (projectFiles.has(fromLib)) return fromLib;
+    return null;
+  },
+  defaultExclude: ["vendor", "\\.bundle"]
+};
+var php = {
+  id: "php",
+  extensions: [".php"],
+  commentStyle: "php",
+  importPatterns: [
+    // require/include/require_once/include_once 'path'
+    { regex: /\b(?:require|include)(?:_once)?\s+['"]([^'"]+)['"]/gm },
+    // use Namespace\Class (PSR-4 style)
+    { regex: /^use\s+([\w\\]+)/gm }
+  ],
+  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);
+      if (projectFiles.has(fromSource)) return fromSource;
+      const fromRoot2 = join3(rootDir, withExt);
+      if (projectFiles.has(fromRoot2)) return fromRoot2;
+      return null;
+    }
+    const filePath = importPath.replace(/\\/g, "/") + ".php";
+    const fromRoot = join3(rootDir, filePath);
+    if (projectFiles.has(fromRoot)) return fromRoot;
+    const fromSrc = join3(rootDir, "src", filePath);
+    if (projectFiles.has(fromSrc)) return fromSrc;
+    return null;
+  },
+  defaultExclude: ["vendor"]
+};
+var swift = {
+  id: "swift",
+  extensions: [".swift"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // import ModuleName (for cross-module dependencies)
+    { regex: /^import\s+(?:class\s+|struct\s+|enum\s+|protocol\s+|func\s+|var\s+|let\s+|typealias\s+)?(\w+)/gm }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    const spmDir = join3(rootDir, "Sources", importPath);
+    for (const f of projectFiles) {
+      if (f.startsWith(spmDir + "/") && f.endsWith(".swift")) return f;
+    }
+    return null;
+  },
+  defaultExclude: ["\\.build", "DerivedData"]
+};
+var kotlin = {
+  id: "kotlin",
+  extensions: [".kt", ".kts"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // import com.example.ClassName
+    { regex: /^import\s+([\w.]+)/gm }
+  ],
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    const filePath = importPath.replace(/\./g, "/");
+    for (const ext of [".kt", ".kts"]) {
+      for (const srcRoot of [
+        "",
+        "src/main/kotlin/",
+        "src/main/java/",
+        "src/",
+        "app/src/main/kotlin/",
+        "app/src/main/java/"
+      ]) {
+        const full = join3(rootDir, srcRoot, filePath + ext);
+        if (projectFiles.has(full)) return full;
+      }
+    }
+    return null;
+  },
+  defaultExclude: ["build", "\\.gradle", "\\.idea"]
+};
+var LANGUAGE_CONFIGS = {
+  javascript: null,
+  // handled by DependencyCruiserEngine
+  python,
+  rust,
+  go,
+  java,
+  "c-cpp": cCpp,
+  ruby,
+  php,
+  swift,
+  kotlin
+};
+function getLanguageConfig(id) {
+  return LANGUAGE_CONFIGS[id] ?? null;
+}
+
+// src/analyzer/analyze.ts
+async function analyzeProject(rootDir, options = {}) {
+  const absRootDir = resolve4(rootDir);
+  const language = options.language ?? await detectLanguage(absRootDir);
+  try {
+    if (language === "javascript") {
+      return await new DependencyCruiserEngine().analyze(absRootDir, options);
+    }
+    const config = getLanguageConfig(language);
+    if (!config) {
+      throw new AnalyzerError(`No analyzer config for language: ${language}`);
+    }
+    return await new RegexEngine(config).analyze(absRootDir, options);
+  } catch (error) {
+    if (error instanceof AnalyzerError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new AnalyzerError(message, { cause: error });
+  }
 }
 var AnalyzerError = class extends Error {
   constructor(message, options) {
@@ -436,8 +1355,8 @@ function formatAnalysisReport(graph, options = {}) {
 }
 
 // src/storage/snapshot.ts
-import { mkdir, writeFile, readFile, access } from "fs/promises";
-import { join } from "path";
+import { mkdir, writeFile, readFile as readFile2, access } from "fs/promises";
+import { join as join4 } from "path";
 import { z } from "zod";
 
 // src/types/schema.ts
@@ -471,8 +1390,8 @@ var SnapshotSchema = z.object({
   graph: DependencyGraphSchema
 });
 async function saveSnapshot(projectRoot, graph) {
-  const dirPath = join(projectRoot, ARCHTRACKER_DIR);
-  const filePath = join(dirPath, SNAPSHOT_FILE);
+  const dirPath = join4(projectRoot, ARCHTRACKER_DIR);
+  const filePath = join4(dirPath, SNAPSHOT_FILE);
   const snapshot = {
     version: SCHEMA_VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -484,10 +1403,10 @@ async function saveSnapshot(projectRoot, graph) {
   return snapshot;
 }
 async function loadSnapshot(projectRoot) {
-  const filePath = join(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
+  const filePath = join4(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
   let raw;
   try {
-    raw = await readFile(filePath, "utf-8");
+    raw = await readFile2(filePath, "utf-8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return null;
@@ -622,10 +1541,10 @@ function arraysEqual(a, b) {
 }
 
 // src/utils/path-guard.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve5 } from "path";
 function validatePath(inputPath, boundary) {
-  const resolved = resolve2(inputPath);
-  const root = boundary ? resolve2(boundary) : process.cwd();
+  const resolved = resolve5(inputPath);
+  const root = boundary ? resolve5(boundary) : process.cwd();
   if (!resolved.startsWith(root)) {
     throw new PathTraversalError(
       t("pathGuard.traversal", { input: inputPath, resolved, boundary: root })
@@ -643,20 +1562,21 @@ var PathTraversalError = class extends Error {
 // src/mcp/index.ts
 var server = new McpServer({
   name: "archtracker",
-  version: "0.1.0"
+  version: "0.2.0"
 });
 server.tool(
   "generate_map",
-  "Analyze dependency graph of a directory and return file import/export structure as JSON",
+  "Analyze dependency graph of a directory and return file import/export structure as JSON. Supports JS/TS, Python, Rust, Go, Java, C/C++, Ruby, PHP, Swift, Kotlin.",
   {
     targetDir: z2.string().default("src").describe("Target directory path (default: src)"),
     exclude: z2.array(z2.string()).optional().describe("Array of regex patterns to exclude (e.g. ['test', 'mock'])"),
-    maxDepth: z2.number().int().min(0).optional().describe("Max analysis depth (0 = unlimited)")
+    maxDepth: z2.number().int().min(0).optional().describe("Max analysis depth (0 = unlimited)"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, exclude, maxDepth }) => {
+  async ({ targetDir, exclude, maxDepth, language }) => {
     try {
       validatePath(targetDir);
-      const graph = await analyzeProject(targetDir, { exclude, maxDepth });
+      const graph = await analyzeProject(targetDir, { exclude, maxDepth, language });
       const summary = [
         t("mcp.analyzeComplete", { files: graph.totalFiles, edges: graph.totalEdges }),
         graph.circularDependencies.length > 0 ? t("mcp.circularFound", { count: graph.circularDependencies.length }) : t("mcp.circularNone")
@@ -674,18 +1594,19 @@ server.tool(
 );
 server.tool(
   "analyze_existing_architecture",
-  "Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown.",
+  "Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown. Supports 10 languages.",
   {
     targetDir: z2.string().default("src").describe("Target directory path (default: src)"),
     exclude: z2.array(z2.string()).optional().describe("Array of regex patterns to exclude"),
     topN: z2.number().int().min(1).max(50).optional().describe("Number of top items to show in each section (default: 10)"),
     saveSnapshot: z2.boolean().optional().describe("Also save a snapshot after analysis (default: false)"),
-    projectRoot: z2.string().default(".").describe("Project root (needed only when saveSnapshot is true)")
+    projectRoot: z2.string().default(".").describe("Project root (needed only when saveSnapshot is true)"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, exclude, topN, saveSnapshot: doSave, projectRoot }) => {
+  async ({ targetDir, exclude, topN, saveSnapshot: doSave, projectRoot, language }) => {
     try {
       validatePath(targetDir);
-      const graph = await analyzeProject(targetDir, { exclude });
+      const graph = await analyzeProject(targetDir, { exclude, language });
       const report = formatAnalysisReport(graph, { topN: topN ?? 10 });
       const content = [
         { type: "text", text: report }
@@ -706,13 +1627,14 @@ server.tool(
   "Save the current dependency graph as a snapshot to .archtracker/snapshot.json",
   {
     targetDir: z2.string().default("src").describe("Target directory path"),
-    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)")
+    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, projectRoot }) => {
+  async ({ targetDir, projectRoot, language }) => {
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
-      const graph = await analyzeProject(targetDir);
+      const graph = await analyzeProject(targetDir, { language });
       const snapshot = await saveSnapshot(projectRoot, graph);
       const keyComponents = Object.values(graph.files).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, 5).map((f) => `  ${t("cli.dependedBy", { path: f.path, count: f.dependents.length })}`);
       const report = [
@@ -735,15 +1657,16 @@ server.tool(
   "Compare saved snapshot with current code dependencies and warn about files that may need updates",
   {
     targetDir: z2.string().default("src").describe("Target directory path"),
-    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)")
+    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, projectRoot }) => {
+  async ({ targetDir, projectRoot, language }) => {
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
       const existingSnapshot = await loadSnapshot(projectRoot);
       if (!existingSnapshot) {
-        const graph = await analyzeProject(targetDir);
+        const graph = await analyzeProject(targetDir, { language });
         await saveSnapshot(projectRoot, graph);
         return {
           content: [
@@ -758,7 +1681,7 @@ server.tool(
           ]
         };
       }
-      const currentGraph = await analyzeProject(targetDir);
+      const currentGraph = await analyzeProject(targetDir, { language });
       const diff = computeDiff(existingSnapshot.graph, currentGraph);
       const report = formatDiffReport(diff);
       return { content: [{ type: "text", text: report }] };
@@ -772,13 +1695,14 @@ server.tool(
   "Get current valid file paths and architecture summary for AI session initialization",
   {
     targetDir: z2.string().default("src").describe("Target directory path"),
-    projectRoot: z2.string().default(".").describe("Project root")
+    projectRoot: z2.string().default(".").describe("Project root"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, projectRoot }) => {
+  async ({ targetDir, projectRoot, language }) => {
     try {
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const graph2 = await analyzeProject(targetDir);
+        const graph2 = await analyzeProject(targetDir, { language });
         snapshot = await saveSnapshot(projectRoot, graph2);
       }
       const graph = snapshot.graph;
@@ -831,15 +1755,16 @@ server.tool(
     ),
     targetDir: z2.string().default("src").describe("Target directory path"),
     projectRoot: z2.string().default(".").describe("Project root"),
-    limit: z2.number().int().min(1).max(50).optional().describe("Max results (default: 10)")
+    limit: z2.number().int().min(1).max(50).optional().describe("Max results (default: 10)"),
+    language: z2.enum(["javascript", "python", "rust", "go", "java", "c-cpp", "ruby", "php", "swift", "kotlin"]).optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ query, mode, targetDir, projectRoot, limit }) => {
+  async ({ query, mode, targetDir, projectRoot, limit, language }) => {
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const graph2 = await analyzeProject(targetDir);
+        const graph2 = await analyzeProject(targetDir, { language });
         snapshot = await saveSnapshot(projectRoot, graph2);
       }
       const graph = snapshot.graph;