archtracker-mcp 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,7 +1,17 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/types/schema.ts
 var SCHEMA_VERSION = "1.0";
 
 // 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 = [
@@ -12,110 +22,630 @@ 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);
   }
-  const cruiseResult = result.output;
-  return buildGraph(absRootDir, cruiseResult);
+  for (const node of adj.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  return cycles;
 }
-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: []
+
+// src/analyzer/engines/regex-engine.ts
+var RegexEngine = class {
+  constructor(config) {
+    this.config = config;
+  }
+  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 = [];
+    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 imports = this.extractImports(content);
+      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;
+        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);
+  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]);
+        }
       }
-      if (files[dep.resolved]) {
-        files[dep.resolved].dependents.push(mod.source);
+    }
+    return imports;
+  }
+  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 (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 });
+      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;
   }
-  return {
-    rootDir,
-    files,
-    edges,
-    circularDependencies,
-    totalFiles: Object.keys(files).length,
-    totalEdges: edges.length
-  };
+};
+
+// 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 { join as join3, dirname, resolve as resolve3 } from "path";
+var python = {
+  id: "python",
+  extensions: [".py"],
+  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"],
+  importPatterns: [
+    // use crate::module::item;
+    { regex: /\buse\s+crate::(\w[\w:]*)/gm },
+    // mod child;
+    { regex: /\bmod\s+(\w+)\s*;/gm }
+  ],
+  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"]
+};
+var go = {
+  id: "go",
+  extensions: [".go"],
+  importPatterns: [
+    // import "path" or import ( "path" )
+    { regex: /\bimport\s+(?:\w+\s+)?"([^"]+)"/gm },
+    // import block entries
+    { regex: /^\s+(?:\w+\s+)?"([^"]+)"/gm }
+  ],
+  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 fs = __require("fs");
+    const content = fs.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"],
+  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"],
+  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"],
+  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"],
+  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"],
+  importPatterns: [
+    // import ModuleName
+    { regex: /^import\s+(?:class|struct|enum|protocol|func|var|let|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"],
+  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) {
@@ -382,8 +912,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";
 var ARCHTRACKER_DIR = ".archtracker";
 var SNAPSHOT_FILE = "snapshot.json";
@@ -412,8 +942,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(),
@@ -425,10 +955,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;
@@ -457,7 +987,7 @@ async function loadSnapshot(projectRoot) {
 }
 async function hasArchtrackerDir(projectRoot) {
   try {
-    await access(join(projectRoot, ARCHTRACKER_DIR));
+    await access(join4(projectRoot, ARCHTRACKER_DIR));
     return true;
   } catch {
     return false;