archtracker-mcp 0.4.3 → 0.6.0

package/dist/mcp/index.js

@@ -3,7 +3,7 @@
 // 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";
+import { z as z3 } from "zod";
 
 // src/analyzer/analyze.ts
 import { resolve as resolve3 } from "path";
@@ -1087,6 +1087,13 @@ var java = {
         if (projectFiles.has(full)) return full;
       }
     }
+    for (let i = 1; i < segments.length; i++) {
+      const filePath = segments.slice(i).join("/") + ".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"]
@@ -1141,12 +1148,18 @@ var php = {
   importPatterns: [
     // require/include/require_once/include_once 'path'
     { regex: /\b(?:require|include)(?:_once)?\s+['"]([^'"]+)['"]/gm },
+    // require_once __DIR__ . '/path' (common PHP pattern)
+    { regex: /\b(?:require|include)(?:_once)?\s+__DIR__\s*\.\s*['"]([^'"]+)['"]/gm },
     // Bug #9 fix: use Namespace\Class — skip `function` and `const` keywords
     { regex: /^use\s+(?:function\s+|const\s+)?([\w\\]+)/gm }
   ],
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
-    if (importPath.includes("/") || importPath.endsWith(".php")) {
-      const withExt = importPath.endsWith(".php") ? importPath : importPath + ".php";
+    let normalizedPath = importPath;
+    if (normalizedPath.startsWith("/")) {
+      normalizedPath = normalizedPath.slice(1);
+    }
+    if (normalizedPath.includes("/") || normalizedPath.endsWith(".php")) {
+      const withExt = normalizedPath.endsWith(".php") ? normalizedPath : normalizedPath + ".php";
       const fromSource = resolve2(dirname(sourceFile), withExt);
       if (projectFiles.has(fromSource)) return fromSource;
       const fromRoot2 = join3(rootDir, withExt);
@@ -1162,15 +1175,46 @@ var php = {
   },
   defaultExclude: ["vendor"]
 };
+var SWIFT_SKIP_FILES = /* @__PURE__ */ new Set(["Package", "main", "AppDelegate", "SceneDelegate"]);
 var swift = {
   id: "swift",
   extensions: [".swift"],
   commentStyle: "c-style",
-  importPatterns: [
-    // Bug #10 fix: import ModuleName and @testable import ModuleName
-    { regex: /^(?:@testable\s+)?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) {
+  importPatterns: [],
+  // handled by extractImports
+  extractImports(content, filePath, _rootDir, projectFiles) {
+    const imports = [];
+    const moduleRegex = /^(?:@testable\s+)?import\s+(?:class\s+|struct\s+|enum\s+|protocol\s+|func\s+|var\s+|let\s+|typealias\s+)?(\w+)/gm;
+    let match;
+    while ((match = moduleRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const typeMap = /* @__PURE__ */ new Map();
+    for (const f of projectFiles) {
+      if (f === filePath || !f.endsWith(".swift")) continue;
+      const basename = f.split("/").pop().replace(/\.swift$/, "");
+      if (!basename || SWIFT_SKIP_FILES.has(basename)) continue;
+      typeMap.set(basename, f);
+    }
+    if (typeMap.size > 0) {
+      const escaped = [...typeMap.keys()].map(
+        (n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+      );
+      const combined = new RegExp(`\\b(${escaped.join("|")})\\b`, "g");
+      const matched = /* @__PURE__ */ new Set();
+      while ((match = combined.exec(content)) !== null) {
+        const typeName = match[1];
+        const targetPath = typeMap.get(typeName);
+        if (targetPath && !matched.has(targetPath)) {
+          matched.add(targetPath);
+          imports.push(targetPath);
+        }
+      }
+    }
+    return imports;
+  },
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    if (projectFiles.has(importPath)) return importPath;
     const spmDir = join3(rootDir, "Sources", importPath);
     for (const f of projectFiles) {
       if (f.startsWith(spmDir + "/") && f.endsWith(".swift")) return f;
@@ -1195,7 +1239,8 @@ var kotlin = {
     if (cleanPath.endsWith(".")) {
       cleanPath = cleanPath.slice(0, -1);
     }
-    const filePath = cleanPath.replace(/\./g, "/");
+    const segments = cleanPath.split(".");
+    const filePath = segments.join("/");
     for (const ext of [".kt", ".kts"]) {
       for (const srcRoot of [
         "",
@@ -1209,6 +1254,22 @@ var kotlin = {
         if (projectFiles.has(full)) return full;
       }
     }
+    for (let i = 1; i < segments.length; i++) {
+      const suffixPath = segments.slice(i).join("/");
+      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, suffixPath + ext);
+          if (projectFiles.has(full)) return full;
+        }
+      }
+    }
     return null;
   },
   defaultExclude: ["build", "\\.gradle", "\\.idea"]
@@ -1294,8 +1355,10 @@ var dart = {
       const prefix = `package:${ownPackage}/`;
       if (!importPath.startsWith(prefix)) return null;
       const relPath = importPath.slice(prefix.length);
-      const full = join3(rootDir, "lib", relPath);
-      if (projectFiles.has(full)) return full;
+      const libPath = join3(rootDir, "lib", relPath);
+      if (projectFiles.has(libPath)) return libPath;
+      const rootPath = join3(rootDir, relPath);
+      if (projectFiles.has(rootPath)) return rootPath;
       return null;
     }
     const resolved = resolve2(dirname(sourceFile), importPath);
@@ -1358,6 +1421,15 @@ var scala = {
         }
       }
     }
+    for (let i = 1; i < segments.length; i++) {
+      const suffixPath = segments.slice(i).join("/");
+      for (const ext of [".scala", ".sc"]) {
+        for (const srcRoot of ["", "src/main/scala/", "src/", "app/"]) {
+          const full = join3(rootDir, srcRoot, suffixPath + ext);
+          if (projectFiles.has(full)) return full;
+        }
+      }
+    }
     return null;
   },
   defaultExclude: ["target", "\\.bsp", "\\.metals", "\\.bloop"]
@@ -1539,6 +1611,11 @@ var en = {
   "analyze.snapshotSaved": "\nSnapshot saved alongside analysis.",
   // CI
   "ci.generated": "GitHub Actions workflow generated: {path}",
+  // Layers
+  "layers.alreadyExists": "layers.json already exists. Edit it manually to modify.",
+  "layers.created": "Created .archtracker/layers.json \u2014 edit it to configure your layers.",
+  "layers.notFound": "No .archtracker/layers.json found. Run 'archtracker layers init' to create one.",
+  "layers.header": "Configured layers ({count}):",
   // Web viewer
   "web.starting": "Starting architecture viewer...",
   "web.listening": "Architecture graph available at: http://localhost:{port}",
@@ -1627,6 +1704,11 @@ var ja = {
   "analyze.snapshotSaved": "\n\u5206\u6790\u3068\u540C\u6642\u306B\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002",
   // CI
   "ci.generated": "GitHub Actions \u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u3092\u751F\u6210\u3057\u307E\u3057\u305F: {path}",
+  // Layers
+  "layers.alreadyExists": "layers.json \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059\u3002\u76F4\u63A5\u7DE8\u96C6\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "layers.created": ".archtracker/layers.json \u3092\u4F5C\u6210\u3057\u307E\u3057\u305F\u3002\u30EC\u30A4\u30E4\u30FC\u3092\u8A2D\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "layers.notFound": ".archtracker/layers.json \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002'archtracker layers init' \u3067\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "layers.header": "\u8A2D\u5B9A\u6E08\u307F\u30EC\u30A4\u30E4\u30FC ({count}\u4EF6):",
   // Web viewer
   "web.starting": "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u30D3\u30E5\u30FC\u30A2\u30FC\u3092\u8D77\u52D5\u4E2D...",
   "web.listening": "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u30B0\u30E9\u30D5: http://localhost:{port}",
@@ -1761,61 +1843,540 @@ function formatAnalysisReport(graph, options = {}) {
   return lines.join("\n");
 }
 
-// src/storage/snapshot.ts
-import { mkdir, writeFile, readFile as readFile2, access } from "fs/promises";
-import { join as join4 } from "path";
+// src/analyzer/multi-layer.ts
+import { resolve as resolve4, join as join4 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+var LAYER_COLORS = [
+  "#58a6ff",
+  "#3fb950",
+  "#d2a8ff",
+  "#f0883e",
+  "#79c0ff",
+  "#56d4dd",
+  "#db61a2",
+  "#f778ba",
+  "#ffa657",
+  "#7ee787"
+];
+async function analyzeMultiLayer(projectRoot, layerDefs) {
+  const layers = {};
+  const layerMetadata = [];
+  for (let idx = 0; idx < layerDefs.length; idx++) {
+    const def = layerDefs[idx];
+    const targetDir = resolve4(projectRoot, def.targetDir);
+    const graph = await analyzeProject(targetDir, {
+      exclude: def.exclude,
+      language: def.language
+    });
+    const language = def.language ?? await detectLanguage(targetDir) ?? "javascript";
+    layers[def.name] = graph;
+    layerMetadata.push({
+      name: def.name,
+      originalRootDir: graph.rootDir,
+      language,
+      color: def.color ?? LAYER_COLORS[idx % LAYER_COLORS.length],
+      description: def.description,
+      fileCount: graph.totalFiles,
+      edgeCount: graph.totalEdges
+    });
+  }
+  const merged = mergeLayerGraphs(projectRoot, layers);
+  return { layers, layerMetadata, merged };
+}
+function detectCrossLayerConnections(layers, layerDefs) {
+  const MIN_NAME_LENGTH = 6;
+  const MIN_SCORE_THRESHOLD = 10;
+  const layerIdentifiers = /* @__PURE__ */ new Map();
+  for (const [layerName, graph] of Object.entries(layers)) {
+    const identifiers = /* @__PURE__ */ new Map();
+    for (const filePath of Object.keys(graph.files)) {
+      const basename = filePath.split("/").pop();
+      const nameNoExt = basename.replace(/\.[^.]+$/, "");
+      if (nameNoExt.length < MIN_NAME_LENGTH || GENERIC_BASENAMES.has(nameNoExt.toLowerCase())) continue;
+      identifiers.set(nameNoExt, filePath);
+    }
+    layerIdentifiers.set(layerName, identifiers);
+  }
+  const nameLayerCount = /* @__PURE__ */ new Map();
+  for (const [, ids] of layerIdentifiers) {
+    for (const name of ids.keys()) {
+      nameLayerCount.set(name, (nameLayerCount.get(name) ?? 0) + 1);
+    }
+  }
+  const pairBest = /* @__PURE__ */ new Map();
+  function tryAdd(pairKey, conn, score) {
+    if (score < MIN_SCORE_THRESHOLD) return;
+    const existing = pairBest.get(pairKey);
+    if (!existing || score > existing.score) {
+      pairBest.set(pairKey, { conn, score });
+    }
+  }
+  function isSelfDefined(content, name) {
+    const defPatterns = [
+      new RegExp(`\\b(?:class|struct|enum|interface|protocol|type|object)\\s+${escapeRegex(name)}\\b`),
+      new RegExp(`\\b(?:def|func|fun|fn)\\s+${escapeRegex(name)}\\b`),
+      new RegExp(`\\b${escapeRegex(name)}\\s*=\\s*(?:class|struct|type|interface)\\b`)
+    ];
+    return defPatterns.some((re) => re.test(content));
+  }
+  function isLocalImportOnly(content, name) {
+    const regex = new RegExp(`\\b${escapeRegex(name)}\\b`, "g");
+    const lines = content.split("\n");
+    let crossLayerRef = false;
+    for (const line of lines) {
+      if (!regex.test(line)) continue;
+      regex.lastIndex = 0;
+      const isLocalImport = /^\s*(?:from\s+[.'"]|import\s+[.'"]|require\s*\(\s*['"][.\/]|#include\s*")/.test(line);
+      if (!isLocalImport) {
+        crossLayerRef = true;
+        break;
+      }
+    }
+    return !crossLayerRef;
+  }
+  for (const [sourceLayer, graph] of Object.entries(layers)) {
+    const ownNames = layerIdentifiers.get(sourceLayer) ?? /* @__PURE__ */ new Map();
+    for (const filePath of Object.keys(graph.files)) {
+      const absPath = join4(graph.rootDir, filePath);
+      let content;
+      try {
+        content = readFileSync2(absPath, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const [targetLayer, targetIds] of layerIdentifiers) {
+        if (targetLayer === sourceLayer) continue;
+        for (const [targetName, targetFile] of targetIds) {
+          if (ownNames.has(targetName)) continue;
+          if ((nameLayerCount.get(targetName) ?? 0) > 1) continue;
+          if (!content.includes(targetName)) continue;
+          const regex = new RegExp(`\\b${escapeRegex(targetName)}\\b`);
+          if (!regex.test(content)) continue;
+          if (isSelfDefined(content, targetName)) continue;
+          if (isLocalImportOnly(content, targetName)) continue;
+          const pairKey = `${sourceLayer}\u2192${targetLayer}`;
+          const isPascalCase = /^[A-Z][a-z]/.test(targetName);
+          const baseScore = targetName.length + (isPascalCase ? 5 : 0);
+          tryAdd(pairKey, {
+            fromLayer: sourceLayer,
+            fromFile: filePath,
+            toLayer: targetLayer,
+            toFile: targetFile,
+            type: "auto",
+            label: targetName
+          }, baseScore);
+        }
+      }
+      for (const def of layerDefs) {
+        if (def.name === sourceLayer) continue;
+        const pairKey = `${sourceLayer}\u2192${def.name}`;
+        const layerName = def.name;
+        const suffixes = ["Client", "Service", "API", "Handler", "Provider", "Manager", "Gateway", "Proxy", "Adapter", "Connector"];
+        const typedRe = new RegExp(`\\b${escapeRegex(layerName)}(?:${suffixes.join("|")})\\b`);
+        if (typedRe.test(content)) {
+          const targetGraph = layers[def.name];
+          if (!targetGraph) continue;
+          const entryFile = findEntryPoint(targetGraph);
+          if (entryFile) {
+            tryAdd(pairKey, {
+              fromLayer: sourceLayer,
+              fromFile: filePath,
+              toLayer: def.name,
+              toFile: entryFile,
+              type: "auto",
+              label: `${layerName}*`
+            }, 25);
+          }
+        }
+      }
+      for (const def of layerDefs) {
+        if (def.name === sourceLayer) continue;
+        const pairKey = `${sourceLayer}\u2192${def.name}`;
+        const dirName = def.targetDir.split("/").pop();
+        const isShortName = dirName.length <= 4;
+        const patterns = [];
+        if (!isShortName) {
+          patterns.push({ re: new RegExp(`(?:from|require|import)\\s+['"].*\\b${escapeRegex(dirName)}\\b`, "i"), score: 15 });
+          patterns.push({ re: new RegExp(`['"\`/]${escapeRegex(dirName)}/[\\w]`, "i"), score: 12 });
+        } else {
+          patterns.push({ re: new RegExp(`(?:from|require|import)\\s+['"].*/${escapeRegex(dirName)}/`, "i"), score: 13 });
+          patterns.push({ re: new RegExp(`['"\`]\\s*(?:https?://[^'"]*)?/${escapeRegex(dirName)}/[\\w]`, "i"), score: 11 });
+        }
+        for (const { re, score } of patterns) {
+          if (re.test(content)) {
+            const targetGraph = layers[def.name];
+            if (!targetGraph) continue;
+            const entryFile = findEntryPoint(targetGraph);
+            if (entryFile) {
+              tryAdd(pairKey, {
+                fromLayer: sourceLayer,
+                fromFile: filePath,
+                toLayer: def.name,
+                toFile: entryFile,
+                type: "auto",
+                label: `\u2192 ${def.name}`
+              }, score);
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  return [...pairBest.values()].map((v) => v.conn);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findEntryPoint(graph) {
+  const files = Object.values(graph.files);
+  if (files.length === 0) return null;
+  const sorted = files.sort((a, b) => b.dependents.length - a.dependents.length);
+  if (sorted[0].dependents.length > 0) return sorted[0].path;
+  const entryNames = ["main", "index", "app", "server", "lib", "mod"];
+  for (const name of entryNames) {
+    const entry = files.find((f) => {
+      const basename = f.path.split("/").pop().replace(/\.[^.]+$/, "").toLowerCase();
+      return basename === name;
+    });
+    if (entry) return entry.path;
+  }
+  return files[0].path;
+}
+var GENERIC_BASENAMES = /* @__PURE__ */ new Set([
+  // Build / project structure
+  "index",
+  "main",
+  "app",
+  "config",
+  "setup",
+  "init",
+  "mod",
+  "package",
+  "build",
+  "makefile",
+  "dockerfile",
+  "rakefile",
+  "gemfile",
+  "podfile",
+  // Common modules
+  "utils",
+  "helpers",
+  "types",
+  "models",
+  "views",
+  "controllers",
+  "services",
+  "lib",
+  "src",
+  "test",
+  "spec",
+  "tests",
+  "bench",
+  "example",
+  "examples",
+  // Infrastructure / patterns
+  "server",
+  "client",
+  "routes",
+  "middleware",
+  "database",
+  "engine",
+  "error",
+  "errors",
+  "logger",
+  "logging",
+  "constants",
+  "common",
+  "base",
+  "core",
+  "data",
+  "manager",
+  "handler",
+  "factory",
+  "context",
+  "state",
+  "store",
+  "cache",
+  "queue",
+  "task",
+  "worker",
+  "adapter",
+  "bridge",
+  // UI / presentation
+  "event",
+  "events",
+  "model",
+  "view",
+  "home",
+  "user",
+  "page",
+  "layout",
+  "router",
+  "provider",
+  "component",
+  "widget",
+  "screen",
+  "template",
+  "header",
+  "footer",
+  "sidebar",
+  "navbar",
+  "dialog",
+  "modal",
+  "panel",
+  // Data / IO
+  "reader",
+  "writer",
+  "parser",
+  "formatter",
+  "serializer",
+  "converter",
+  "loader",
+  "exporter",
+  "importer",
+  "transformer",
+  "mapper",
+  "reducer",
+  "filter",
+  "sorter",
+  "validator",
+  "checker",
+  "scanner",
+  "analyzer",
+  // Auth / Security (generic enough to exist in many layers)
+  "login",
+  "register",
+  "verify",
+  "token",
+  "session",
+  "credential",
+  "password",
+  "permission",
+  "profile",
+  "account",
+  "settings",
+  // Network / API
+  "request",
+  "response",
+  "endpoint",
+  "controller",
+  "service",
+  "gateway",
+  "proxy",
+  "connector",
+  "socket",
+  "channel",
+  "stream",
+  "pipeline",
+  // Storage / DB
+  "schema",
+  "migration",
+  "seed",
+  "fixture",
+  "record",
+  "entity",
+  "repository",
+  "storage",
+  "driver",
+  "connection",
+  "pool",
+  // Testing
+  "mock",
+  "stub",
+  "fake",
+  "helper",
+  "fixture",
+  "factory"
+]);
+function mergeLayerGraphs(projectRoot, layers) {
+  const mergedFiles = {};
+  const mergedEdges = [];
+  const mergedCircular = [];
+  for (const [layerName, graph] of Object.entries(layers)) {
+    for (const [origPath, node] of Object.entries(graph.files)) {
+      const prefixedPath = `${layerName}/${origPath}`;
+      mergedFiles[prefixedPath] = {
+        path: prefixedPath,
+        exists: node.exists,
+        dependencies: node.dependencies.map((d) => `${layerName}/${d}`),
+        dependents: node.dependents.map((d) => `${layerName}/${d}`)
+      };
+    }
+    for (const edge of graph.edges) {
+      mergedEdges.push({
+        source: `${layerName}/${edge.source}`,
+        target: `${layerName}/${edge.target}`,
+        type: edge.type
+      });
+    }
+    for (const circ of graph.circularDependencies) {
+      mergedCircular.push({
+        cycle: circ.cycle.map((f) => `${layerName}/${f}`)
+      });
+    }
+  }
+  return {
+    rootDir: resolve4(projectRoot),
+    files: mergedFiles,
+    edges: mergedEdges,
+    circularDependencies: mergedCircular,
+    totalFiles: Object.keys(mergedFiles).length,
+    totalEdges: mergedEdges.length
+  };
+}
+
+// src/storage/layers.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { join as join5 } from "path";
 import { z } from "zod";
+var ARCHTRACKER_DIR = ".archtracker";
+var LAYERS_FILE = "layers.json";
+var LayerDefinitionSchema = z.object({
+  name: z.string().min(1).regex(
+    /^[a-zA-Z0-9_-]+$/,
+    "Layer name must be alphanumeric (hyphens/underscores allowed)"
+  ),
+  targetDir: z.string().min(1),
+  language: z.enum(LANGUAGE_IDS).optional(),
+  exclude: z.array(z.string()).optional(),
+  color: z.string().optional(),
+  description: z.string().optional()
+});
+var CrossLayerConnectionSchema = z.object({
+  fromLayer: z.string(),
+  fromFile: z.string(),
+  toLayer: z.string(),
+  toFile: z.string(),
+  type: z.enum(["api-call", "event", "data-flow", "manual"]),
+  label: z.string().optional()
+});
+var LayerConfigSchema = z.object({
+  version: z.literal("1.0"),
+  layers: z.array(LayerDefinitionSchema).min(1).refine(
+    (layers) => {
+      const names = layers.map((l) => l.name);
+      return new Set(names).size === names.length;
+    },
+    { message: "Layer names must be unique" }
+  ),
+  connections: z.array(CrossLayerConnectionSchema).optional()
+});
+async function loadLayerConfig(projectRoot) {
+  const filePath = join5(projectRoot, ARCHTRACKER_DIR, LAYERS_FILE);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(`Failed to read ${filePath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${filePath}`);
+  }
+  const result = LayerConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).slice(0, 5).join("\n");
+    throw new Error(`layers.json validation failed:
+${issues}`);
+  }
+  return result.data;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/analyzer/resolve.ts
+async function resolveGraph(opts) {
+  const layerConfig = await loadLayerConfig(opts.projectRoot);
+  if (layerConfig) {
+    const multi = await analyzeMultiLayer(opts.projectRoot, layerConfig.layers);
+    const autoConnections = detectCrossLayerConnections(multi.layers, layerConfig.layers);
+    const manualConnections = layerConfig.connections ?? [];
+    const manualKeys = new Set(manualConnections.map(
+      (c) => `${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`
+    ));
+    const merged = [
+      ...manualConnections,
+      ...autoConnections.filter(
+        (c) => !manualKeys.has(`${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`)
+      )
+    ];
+    return {
+      graph: multi.merged,
+      multiLayer: multi,
+      layerMetadata: multi.layerMetadata,
+      crossLayerEdges: merged
+    };
+  }
+  const graph = await analyzeProject(opts.targetDir, {
+    exclude: opts.exclude,
+    language: opts.language
+  });
+  return { graph };
+}
+
+// src/storage/snapshot.ts
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, access } from "fs/promises";
+import { join as join6 } from "path";
+import { z as z2 } from "zod";
 
 // src/types/schema.ts
-var SCHEMA_VERSION = "1.0";
+var SCHEMA_VERSION = "1.1";
 
 // src/storage/snapshot.ts
-var ARCHTRACKER_DIR = ".archtracker";
+var ARCHTRACKER_DIR2 = ".archtracker";
 var SNAPSHOT_FILE = "snapshot.json";
-var FileNodeSchema = z.object({
-  path: z.string(),
-  exists: z.boolean(),
-  dependencies: z.array(z.string()),
-  dependents: z.array(z.string())
+var FileNodeSchema = z2.object({
+  path: z2.string(),
+  exists: z2.boolean(),
+  dependencies: z2.array(z2.string()),
+  dependents: z2.array(z2.string())
 });
-var DependencyGraphSchema = z.object({
-  rootDir: z.string(),
-  files: z.record(z.string(), FileNodeSchema),
-  edges: z.array(z.object({
-    source: z.string(),
-    target: z.string(),
-    type: z.enum(["static", "dynamic", "type-only"])
+var DependencyGraphSchema = z2.object({
+  rootDir: z2.string(),
+  files: z2.record(z2.string(), FileNodeSchema),
+  edges: z2.array(z2.object({
+    source: z2.string(),
+    target: z2.string(),
+    type: z2.enum(["static", "dynamic", "type-only"])
   })),
-  circularDependencies: z.array(z.object({ cycle: z.array(z.string()) })),
-  totalFiles: z.number(),
-  totalEdges: z.number()
+  circularDependencies: z2.array(z2.object({ cycle: z2.array(z2.string()) })),
+  totalFiles: z2.number(),
+  totalEdges: z2.number()
 });
-var SnapshotSchema = z.object({
-  version: z.literal(SCHEMA_VERSION),
-  timestamp: z.string(),
-  rootDir: z.string(),
+var SnapshotSchema = z2.object({
+  version: z2.enum([SCHEMA_VERSION, "1.0"]),
+  timestamp: z2.string(),
+  rootDir: z2.string(),
   graph: DependencyGraphSchema
 });
-async function saveSnapshot(projectRoot, graph) {
-  const dirPath = join4(projectRoot, ARCHTRACKER_DIR);
-  const filePath = join4(dirPath, SNAPSHOT_FILE);
+async function saveSnapshot(projectRoot, graph, multiLayer) {
+  const dirPath = join6(projectRoot, ARCHTRACKER_DIR2);
+  const filePath = join6(dirPath, SNAPSHOT_FILE);
   const snapshot = {
     version: SCHEMA_VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     rootDir: graph.rootDir,
-    graph
+    graph,
+    ...multiLayer ? { multiLayer } : {}
   };
-  await mkdir(dirPath, { recursive: true });
-  await writeFile(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
+  await mkdir2(dirPath, { recursive: true });
+  await writeFile2(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
   return snapshot;
 }
 async function loadSnapshot(projectRoot) {
-  const filePath = join4(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
+  const filePath = join6(projectRoot, ARCHTRACKER_DIR2, SNAPSHOT_FILE);
   let raw;
   try {
-    raw = await readFile2(filePath, "utf-8");
+    raw = await readFile3(filePath, "utf-8");
   } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
+    if (isNodeError2(error) && error.code === "ENOENT") {
       return null;
     }
     throw new StorageError(
@@ -1846,7 +2407,7 @@ var StorageError = class extends Error {
     this.name = "StorageError";
   }
 };
-function isNodeError(error) {
+function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
 
@@ -1948,10 +2509,10 @@ function arraysEqual(a, b) {
 }
 
 // src/utils/path-guard.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 function validatePath(inputPath, boundary) {
-  const resolved = resolve4(inputPath);
-  const root = boundary ? resolve4(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 })
@@ -1967,14 +2528,14 @@ var PathTraversalError = class extends Error {
 };
 
 // src/utils/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 function loadVersion() {
   let dir = dirname2(fileURLToPath(import.meta.url));
   for (let i = 0; i < 5; i++) {
     try {
-      const pkg = JSON.parse(readFileSync2(join5(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf-8"));
       return pkg.version;
     } catch {
       dir = dirname2(dir);
@@ -1989,34 +2550,58 @@ var server = new McpServer({
   name: "archtracker",
   version: VERSION
 });
-var languageEnum = z2.enum(LANGUAGE_IDS);
+var languageEnum = z3.enum(LANGUAGE_IDS);
 var LANG_DISPLAY = {
   javascript: "JS/TS",
   "c-cpp": "C/C++",
   "c-sharp": "C#"
 };
 var languageList = LANGUAGE_IDS.map((id) => LANG_DISPLAY[id] ?? id.charAt(0).toUpperCase() + id.slice(1)).join(", ");
+async function resolveGraphMcp(opts) {
+  return resolveGraph({
+    targetDir: opts.targetDir,
+    projectRoot: opts.projectRoot,
+    exclude: opts.exclude,
+    language: opts.language
+  });
+}
+function formatLayerSummary(metadata) {
+  return metadata.map(
+    (m) => `  [${m.name}] ${m.fileCount} files, ${m.edgeCount} edges (${m.language})`
+  ).join("\n");
+}
 server.tool(
   "generate_map",
-  `Analyze dependency graph of a directory and return file import/export structure as JSON. Supports ${languageList}.`,
+  `Analyze dependency graph and return raw JSON structure for programmatic use. For human-readable reports, use analyze_existing_architecture instead. Auto-detects multi-layer projects when .archtracker/layers.json exists. Supports ${languageList}.`,
   {
-    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)"),
+    targetDir: z3.string().default("src").describe("Target directory path (default: src). When layers.json exists and this is 'src', multi-layer analysis is used automatically."),
+    projectRoot: z3.string().default(".").describe("Project root (where .archtracker/ is located)"),
+    exclude: z3.array(z3.string()).optional().describe("Array of regex patterns to exclude (e.g. ['test', 'mock'])"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, exclude, maxDepth, language }) => {
+  async ({ targetDir, projectRoot, exclude, language }) => {
     try {
       validatePath(targetDir);
-      const graph = await analyzeProject(targetDir, { exclude, maxDepth, language });
+      validatePath(projectRoot);
+      const { graph, layerMetadata, crossLayerEdges } = await resolveGraphMcp({
+        targetDir,
+        projectRoot,
+        exclude,
+        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")
+        graph.circularDependencies.length > 0 ? t("mcp.circularFound", { count: graph.circularDependencies.length }) : t("mcp.circularNone"),
+        ...layerMetadata ? ["\nLayers:\n" + formatLayerSummary(layerMetadata)] : [],
+        ...crossLayerEdges?.length ? [`
+Cross-layer connections: ${crossLayerEdges.length}`] : []
       ].join("\n");
+      const result = { ...graph };
+      if (crossLayerEdges?.length) result.crossLayerConnections = crossLayerEdges;
       return {
         content: [
           { type: "text", text: summary },
-          { type: "text", text: JSON.stringify(graph, null, 2) }
+          { type: "text", text: JSON.stringify(result, null, 2) }
         ]
       };
     } catch (error) {
@@ -2026,26 +2611,42 @@ 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. Supports ${LANGUAGE_IDS.length} languages.`,
+  `Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown. Supports ${languageList}.`,
   {
-    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)"),
+    targetDir: z3.string().default("src").describe("Target directory path (default: src)"),
+    exclude: z3.array(z3.string()).optional().describe("Array of regex patterns to exclude"),
+    topN: z3.number().int().min(1).max(50).optional().describe("Number of top items to show in each section (default: 10)"),
+    saveSnapshot: z3.boolean().optional().describe("Also save a snapshot after analysis (default: false)"),
+    projectRoot: z3.string().default(".").describe("Project root (where .archtracker/ is located)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ targetDir, exclude, topN, saveSnapshot: doSave, projectRoot, language }) => {
     try {
       validatePath(targetDir);
-      const graph = await analyzeProject(targetDir, { exclude, language });
+      validatePath(projectRoot);
+      const { graph, multiLayer, layerMetadata, crossLayerEdges } = await resolveGraphMcp({
+        targetDir,
+        projectRoot,
+        exclude,
+        language
+      });
       const report = formatAnalysisReport(graph, { topN: topN ?? 10 });
       const content = [
         { type: "text", text: report }
       ];
+      if (layerMetadata) {
+        content.push({ type: "text", text: "\nLayers:\n" + formatLayerSummary(layerMetadata) });
+      }
+      if (crossLayerEdges?.length) {
+        const crossSummary = crossLayerEdges.map(
+          (c) => `  ${c.fromLayer}/${c.fromFile} \u2192 ${c.toLayer}/${c.toFile} [${c.type}] ${c.label ?? ""}`
+        ).join("\n");
+        content.push({ type: "text", text: `
+Cross-layer connections (${crossLayerEdges.length}):
+${crossSummary}` });
+      }
       if (doSave) {
-        validatePath(projectRoot);
-        await saveSnapshot(projectRoot, graph);
+        await saveSnapshot(projectRoot, graph, multiLayer);
         content.push({ type: "text", text: t("analyze.snapshotSaved") });
       }
       return { content };
@@ -2058,22 +2659,27 @@ server.tool(
   "save_architecture_snapshot",
   "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)"),
+    targetDir: z3.string().default("src").describe("Target directory path"),
+    projectRoot: z3.string().default(".").describe("Project root (where .archtracker is placed)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ targetDir, projectRoot, language }) => {
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
-      const graph = await analyzeProject(targetDir, { language });
-      const snapshot = await saveSnapshot(projectRoot, graph);
+      const { graph, multiLayer, layerMetadata } = await resolveGraphMcp({
+        targetDir,
+        projectRoot,
+        language
+      });
+      const snapshot = await saveSnapshot(projectRoot, graph, multiLayer);
       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 = [
         t("mcp.snapshotSaved"),
         t("cli.timestamp", { ts: snapshot.timestamp }),
         t("cli.fileCount", { count: graph.totalFiles }),
         t("cli.edgeCount", { count: graph.totalEdges }),
+        ...layerMetadata ? ["", "Layers:", formatLayerSummary(layerMetadata)] : [],
         "",
         t("cli.keyComponents"),
         ...keyComponents
@@ -2088,8 +2694,8 @@ server.tool(
   "check_architecture_diff",
   "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)"),
+    targetDir: z3.string().default("src").describe("Target directory path"),
+    projectRoot: z3.string().default(".").describe("Project root (where .archtracker is placed)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ targetDir, projectRoot, language }) => {
@@ -2098,8 +2704,12 @@ server.tool(
       validatePath(projectRoot);
       const existingSnapshot = await loadSnapshot(projectRoot);
       if (!existingSnapshot) {
-        const graph = await analyzeProject(targetDir, { language });
-        await saveSnapshot(projectRoot, graph);
+        const { graph, multiLayer } = await resolveGraphMcp({
+          targetDir,
+          projectRoot,
+          language
+        });
+        await saveSnapshot(projectRoot, graph, multiLayer);
         return {
           content: [
             {
@@ -2113,7 +2723,11 @@ server.tool(
           ]
         };
       }
-      const currentGraph = await analyzeProject(targetDir, { language });
+      const { graph: currentGraph } = await resolveGraphMcp({
+        targetDir,
+        projectRoot,
+        language
+      });
       const diff = computeDiff(existingSnapshot.graph, currentGraph);
       const report = formatDiffReport(diff);
       return { content: [{ type: "text", text: report }] };
@@ -2126,16 +2740,22 @@ server.tool(
   "get_current_context",
   "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"),
+    targetDir: z3.string().default("src").describe("Target directory path"),
+    projectRoot: z3.string().default(".").describe("Project root"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ targetDir, projectRoot, language }) => {
     try {
+      validatePath(targetDir);
+      validatePath(projectRoot);
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const graph2 = await analyzeProject(targetDir, { language });
-        snapshot = await saveSnapshot(projectRoot, graph2);
+        const { graph: graph2, multiLayer } = await resolveGraphMcp({
+          targetDir,
+          projectRoot,
+          language
+        });
+        snapshot = await saveSnapshot(projectRoot, graph2, multiLayer);
       }
       const graph = snapshot.graph;
       const keyComponents = Object.values(graph.files).filter((f) => f.dependents.length > 0 || f.dependencies.length > 0).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, 20).map((f) => ({
@@ -2181,13 +2801,13 @@ server.tool(
   "search_architecture",
   "Search architecture: file path search, impact analysis, critical component detection, orphan file detection",
   {
-    query: z2.string().optional().describe("Search query (required for path/affected modes, not needed for critical/orphans)"),
-    mode: z2.enum(["path", "affected", "critical", "orphans"]).default("path").describe(
+    query: z3.string().optional().describe("Search query (required for path/affected modes, not needed for critical/orphans)"),
+    mode: z3.enum(["path", "affected", "critical", "orphans"]).default("path").describe(
       "Search mode: path=search by path, affected=change impact, critical=key files, orphans=isolated files"
     ),
-    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)"),
+    targetDir: z3.string().default("src").describe("Target directory path"),
+    projectRoot: z3.string().default(".").describe("Project root"),
+    limit: z3.number().int().min(1).max(50).optional().describe("Max results (default: 10)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ query, mode, targetDir, projectRoot, limit, language }) => {
@@ -2196,8 +2816,12 @@ server.tool(
       validatePath(projectRoot);
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const graph2 = await analyzeProject(targetDir, { language });
-        snapshot = await saveSnapshot(projectRoot, graph2);
+        const { graph: graph2, multiLayer } = await resolveGraphMcp({
+          targetDir,
+          projectRoot,
+          language
+        });
+        snapshot = await saveSnapshot(projectRoot, graph2, multiLayer);
       }
       const graph = snapshot.graph;
       const maxResults = limit ?? 10;