archtracker-mcp 0.4.3 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/types/schema.ts
-var SCHEMA_VERSION = "1.0";
+var SCHEMA_VERSION = "1.1";
 
 // src/analyzer/analyze.ts
 import { resolve as resolve3 } from "path";
@@ -813,6 +813,25 @@ async function scanExtensions(dir, counts, maxDepth, currentDepth) {
 // src/analyzer/engines/languages.ts
 import { readFileSync } from "fs";
 import { join as join3, dirname, resolve as resolve2 } from "path";
+
+// src/analyzer/engines/types.ts
+var LANGUAGE_IDS = [
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "java",
+  "c-cpp",
+  "c-sharp",
+  "ruby",
+  "php",
+  "swift",
+  "kotlin",
+  "dart",
+  "scala"
+];
+
+// src/analyzer/engines/languages.ts
 var python = {
   id: "python",
   extensions: [".py"],
@@ -1064,6 +1083,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"]
@@ -1118,12 +1144,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);
@@ -1139,15 +1171,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;
@@ -1172,7 +1235,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 [
         "",
@@ -1186,6 +1250,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"]
@@ -1271,8 +1351,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);
@@ -1335,6 +1417,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"]
@@ -1522,6 +1613,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}",
@@ -1610,6 +1706,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}",
@@ -1686,56 +1787,511 @@ 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;
+}
+async function saveLayerConfig(projectRoot, config) {
+  const dirPath = join5(projectRoot, ARCHTRACKER_DIR);
+  const filePath = join5(dirPath, LAYERS_FILE);
+  await mkdir(dirPath, { recursive: true });
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// 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";
+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(
@@ -1762,7 +2318,7 @@ async function loadSnapshot(projectRoot) {
 }
 async function hasArchtrackerDir(projectRoot) {
   try {
-    await access(join4(projectRoot, ARCHTRACKER_DIR));
+    await access(join6(projectRoot, ARCHTRACKER_DIR2));
     return true;
   } catch {
     return false;
@@ -1774,7 +2330,7 @@ var StorageError = class extends Error {
     this.name = "StorageError";
   }
 };
-function isNodeError(error) {
+function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
 
@@ -1878,13 +2434,17 @@ export {
   AnalyzerError,
   SCHEMA_VERSION,
   StorageError,
+  analyzeMultiLayer,
   analyzeProject,
   computeDiff,
+  detectCrossLayerConnections,
   formatAnalysisReport,
   formatDiffReport,
   getLocale,
   hasArchtrackerDir,
+  loadLayerConfig,
   loadSnapshot,
+  saveLayerConfig,
   saveSnapshot,
   setLocale,
   t