@archlinter/eslint-plugin 0.11.0-canary.2

package/dist/index.cjs

@@ -0,0 +1,971 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  clearAllCaches: () => clearAllCaches,
+  default: () => index_default,
+  flatRecommended: () => flatRecommended,
+  flatStrict: () => flatStrict,
+  notifyFileChanged: () => notifyFileChanged,
+  recommended: () => recommended,
+  rules: () => rules,
+  strict: () => strict
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/cache.ts
+var import_core = require("@archlinter/core");
+
+// src/utils/project-root.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var PROJECT_ROOT_MARKERS = [
+  ".archlint.yaml",
+  // Explicit archlint config
+  ".archlint.yml",
+  "pnpm-workspace.yaml",
+  // pnpm monorepo
+  "lerna.json",
+  // Lerna monorepo
+  "nx.json",
+  // Nx monorepo
+  "rush.json",
+  // Rush monorepo
+  ".git"
+  // Git root (fallback)
+];
+var rootCache = /* @__PURE__ */ new Map();
+function findProjectRoot(filePath) {
+  const cached = rootCache.get(filePath);
+  if (cached) return cached;
+  let dir = (0, import_node_path.dirname)(filePath);
+  let foundRoot = null;
+  while (true) {
+    for (const marker of PROJECT_ROOT_MARKERS) {
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, marker))) {
+        foundRoot = dir;
+        break;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const result = foundRoot ?? process.cwd();
+  rootCache.set(filePath, result);
+  return result;
+}
+
+// src/utils/cache.ts
+var import_node_fs2 = require("fs");
+var crypto = __toESM(require("crypto"), 1);
+var import_xxhash_wasm = __toESM(require("xxhash-wasm"), 1);
+var { createHash } = crypto;
+var xxhash = null;
+(0, import_xxhash_wasm.default)().then((h) => {
+  xxhash = h;
+  diskFileCache.clear();
+}).catch(() => {
+});
+var DEBUG_PATTERN = process.env.DEBUG || "";
+var DEBUG = process.env.ARCHLINT_DEBUG === "1" || DEBUG_PATTERN.includes("archlint:") || DEBUG_PATTERN === "*";
+var FORCE_RESCAN = process.env.ARCHLINT_FORCE_RESCAN === "1";
+var NO_BUFFER_CHECK = process.env.ARCHLINT_NO_BUFFER_CHECK === "1";
+function debug(namespace, ...args) {
+  if (DEBUG) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].slice(0, 12);
+    console.error(`  ${ts} archlint:${namespace}`, ...args);
+  }
+}
+function computeHash(content) {
+  if (xxhash) {
+    return xxhash.h64(content).toString(16);
+  }
+  if (typeof crypto.hash === "function") {
+    return crypto.hash("md5", content, "hex");
+  }
+  return createHash("md5").update(content).digest("hex");
+}
+var diskFileCache = /* @__PURE__ */ new Map();
+function getDiskFileHash(filePath) {
+  try {
+    const stats = (0, import_node_fs2.statSync)(filePath);
+    const mtime = stats.mtimeMs;
+    const size = stats.size;
+    const cached = diskFileCache.get(filePath);
+    if (cached && cached.mtime === mtime && cached.size === size) {
+      return cached.hash;
+    }
+    const content = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+    const hash2 = computeHash(content);
+    diskFileCache.set(filePath, { hash: hash2, mtime, size });
+    return hash2;
+  } catch {
+    return null;
+  }
+}
+function isUnsavedFile(filename, bufferText) {
+  if (NO_BUFFER_CHECK) {
+    return false;
+  }
+  if (isVirtualFile(filename)) {
+    debug("cache", "Virtual file detected:", filename);
+    return true;
+  }
+  if (!bufferText) {
+    return false;
+  }
+  const diskHash = getDiskFileHash(filename);
+  if (diskHash === null) {
+    debug("cache", "New file (not on disk):", filename);
+    return true;
+  }
+  const cached = diskFileCache.get(filename);
+  if (cached && Buffer.byteLength(bufferText, "utf8") !== cached.size) {
+    debug("cache", "Size mismatch detected:", filename);
+    return true;
+  }
+  const bufferHash = computeHash(bufferText);
+  const isUnsaved = bufferHash !== diskHash;
+  if (isUnsaved) {
+    debug("cache", "Unsaved file detected (hash mismatch):", filename);
+  }
+  return isUnsaved;
+}
+function isVirtualFile(filename) {
+  return filename === "<input>" || filename === "<text>" || filename.startsWith("untitled:") || filename.includes("stdin");
+}
+var projectStates = /* @__PURE__ */ new Map();
+function getFileMtime(filePath) {
+  try {
+    return (0, import_node_fs2.statSync)(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function initializeProjectState(projectRoot, filePath, currentMtime) {
+  debug("cache", "First scan for project:", projectRoot);
+  const analyzer = new import_core.ArchlintAnalyzer(projectRoot, { cache: true, git: false });
+  const state = {
+    analyzer,
+    result: null,
+    state: "in_progress" /* InProgress */,
+    lastScanTime: 0,
+    fileMtimes: /* @__PURE__ */ new Map()
+  };
+  projectStates.set(projectRoot, state);
+  try {
+    const start = Date.now();
+    state.result = analyzer.scanSync();
+    state.state = "ready" /* Ready */;
+    state.lastScanTime = Date.now();
+    state.fileMtimes.set(filePath, currentMtime);
+    debug("cache", "Initial scan complete", {
+      duration: Date.now() - start,
+      smellCount: state.result?.smells?.length
+    });
+  } catch (error) {
+    state.state = "error" /* Error */;
+    console.error("[archlint] Analysis failed:", error instanceof Error ? error.message : error);
+  }
+  return state;
+}
+function performRescan(state, filePath) {
+  debug("cache", "Triggering rescan", { filePath });
+  try {
+    state.analyzer.invalidate([filePath]);
+    const start = Date.now();
+    state.result = state.analyzer.rescanSync();
+    state.lastScanTime = Date.now();
+    debug("cache", "Rescan complete", {
+      duration: Date.now() - start,
+      smellCount: state.result?.smells?.length
+    });
+  } catch (error) {
+    debug("cache", "Rescan error", error instanceof Error ? error.message : error);
+  }
+}
+function shouldRescanFile(state, filePath, currentMtime) {
+  const lastMtime = state.fileMtimes.get(filePath);
+  const fileChanged = lastMtime !== void 0 && currentMtime > lastMtime;
+  const isNewFile = lastMtime === void 0;
+  return fileChanged || FORCE_RESCAN && isNewFile;
+}
+function handleFileChange(state, filePath, currentMtime) {
+  const lastMtime = state.fileMtimes.get(filePath);
+  const fileChanged = lastMtime !== void 0 && currentMtime > lastMtime;
+  const needsRescan = shouldRescanFile(state, filePath, currentMtime);
+  state.fileMtimes.set(filePath, currentMtime);
+  if (needsRescan && state.state === "ready" /* Ready */) {
+    performRescan(state, filePath);
+  } else {
+    debug("cache", "Using cached", {
+      file: filePath.split("/").pop(),
+      lastMtime: lastMtime ?? "new",
+      fileChanged
+    });
+  }
+}
+function isAnalysisReady(filePath, options) {
+  const { projectRoot: projectRootOverride, bufferText } = options ?? {};
+  const projectRoot = projectRootOverride ?? findProjectRoot(filePath);
+  let state = projectStates.get(projectRoot);
+  const currentMtime = getFileMtime(filePath);
+  const unsaved = isUnsavedFile(filePath, bufferText);
+  debug("cache", "isAnalysisReady", {
+    filePath,
+    projectRoot,
+    currentMtime,
+    hasState: !!state,
+    unsaved
+  });
+  if (!state) {
+    state = initializeProjectState(projectRoot, filePath, currentMtime);
+    return state.state;
+  }
+  if (unsaved) {
+    debug("cache", "Unsaved file - using cached results", { file: filePath.split("/").pop() });
+    return state.state;
+  }
+  handleFileChange(state, filePath, currentMtime);
+  return state.state;
+}
+function notifyFileChanged(filePath, projectRootOverride) {
+  const projectRoot = projectRootOverride ?? findProjectRoot(filePath);
+  const state = projectStates.get(projectRoot);
+  if (state && state.state === "ready" /* Ready */) {
+    try {
+      state.result = state.analyzer.rescanSync();
+      state.lastScanTime = Date.now();
+    } catch {
+    }
+  }
+}
+function getAnalysis(filePath, projectRootOverride) {
+  const projectRoot = projectRootOverride ?? findProjectRoot(filePath);
+  const state = projectStates.get(projectRoot);
+  if (!state || state.state !== "ready" /* Ready */) {
+    return null;
+  }
+  return state.result;
+}
+function analyzeWithOverlay(filePath, content, projectRootOverride) {
+  const projectRoot = projectRootOverride ?? findProjectRoot(filePath);
+  const state = projectStates.get(projectRoot);
+  if (!state || state.state !== "ready" /* Ready */) {
+    debug("overlay", "Analysis not ready, skipping overlay analysis");
+    return [];
+  }
+  try {
+    const start = Date.now();
+    const result = state.analyzer.scanIncrementalWithOverlaySync([filePath], {
+      [filePath]: content
+    });
+    debug("overlay", "Overlay analysis complete", {
+      file: filePath.split("/").pop(),
+      duration: Date.now() - start,
+      smellCount: result.smells.length
+    });
+    return result.smells;
+  } catch (error) {
+    debug("overlay", "Overlay analysis failed", error instanceof Error ? error.message : error);
+    return [];
+  }
+}
+function matchesSmellType(smellType, detectorId) {
+  const words = detectorId.toLowerCase().split("_");
+  const baseType = smellType.split(/[\s{]/)[0].toLowerCase();
+  const mappings = {
+    dead_code: ["deadcode"],
+    dead_symbols: ["deadsymbol"],
+    cycles: ["cyclicdependency", "cyclicdependencycluster"],
+    high_coupling: ["highcoupling"],
+    high_complexity: ["highcomplexity"],
+    long_params: ["longparameterlist"],
+    deep_nesting: ["deepnesting"],
+    god_module: ["godmodule"],
+    barrel_file_abuse: ["barrelfileabuse"],
+    layer_violation: ["layerviolation"],
+    sdp_violation: ["sdpviolation"],
+    hub_module: ["hubmodule"]
+  };
+  const patterns = mappings[detectorId] || [words.join("")];
+  return patterns.some((p) => baseType.includes(p));
+}
+function getSmellsForFile(filePath, detectorId, projectRootOverride, bufferText) {
+  const projectRoot = projectRootOverride ?? findProjectRoot(filePath);
+  if (bufferText && isUnsavedFile(filePath, bufferText)) {
+    debug("smell", "Using overlay analysis for unsaved file", filePath.split("/").pop());
+    const allSmells = analyzeWithOverlay(filePath, bufferText, projectRoot);
+    return filterSmellsByDetector(allSmells, filePath, detectorId);
+  }
+  const result = getAnalysis(filePath, projectRoot);
+  if (!result) {
+    debug("smell", "no result for", filePath);
+    return [];
+  }
+  return filterSmellsByDetector(result.smells, filePath, detectorId);
+}
+function filterSmellsByDetector(smells, filePath, detectorId) {
+  const normalizedPath = filePath.replaceAll("\\", "/");
+  const filtered = smells.filter((s) => {
+    if (!matchesSmellType(s.smell.smellType, detectorId)) {
+      return false;
+    }
+    return s.smell.files.some((f) => f.replaceAll("\\", "/") === normalizedPath);
+  });
+  if (filtered.length > 0) {
+    debug("smell", `${detectorId}: ${filtered.length} smells for`, filePath.split("/").pop());
+  }
+  return filtered;
+}
+function clearAllCaches() {
+  projectStates.clear();
+  diskFileCache.clear();
+}
+
+// src/utils/smell-filter.ts
+var import_node_path2 = require("path");
+function getSmellLocationsForFile(smell, filePath, strategy, projectRoot) {
+  const normalized = filePath.replaceAll("\\", "/");
+  switch (strategy) {
+    case "critical-edges":
+      return getCriticalEdgeLocations(smell, normalized, projectRoot);
+    case "primary-file":
+      return getPrimaryFileLocation(smell, normalized);
+    case "source-file":
+      return getSourceFileLocation(smell, normalized);
+    case "all-files":
+    default:
+      return getAllFileLocations(smell, normalized);
+  }
+}
+function getCriticalEdgeLocations(smell, filePath, projectRoot) {
+  const cluster = smell.smell.cluster;
+  if (!cluster?.criticalEdges) return [];
+  return cluster.criticalEdges.filter((edge) => edge.from.replaceAll("\\", "/") === filePath).map((edge) => ({
+    line: edge.line,
+    column: edge.range?.startColumn ?? 0,
+    endLine: edge.range?.endLine,
+    endColumn: edge.range?.endColumn,
+    messageId: "cycle",
+    data: {
+      target: (0, import_node_path2.relative)(projectRoot, edge.to),
+      impact: edge.impact
+    }
+  }));
+}
+function createLocationFromSmell(loc, reason) {
+  return {
+    line: loc?.line ?? 1,
+    column: loc?.column ?? 0,
+    endLine: loc?.range?.endLine,
+    endColumn: loc?.range?.endColumn,
+    messageId: "smell",
+    data: { reason }
+  };
+}
+function getPrimaryFileLocation(smell, filePath) {
+  const firstFile = smell.smell.files[0];
+  if (!firstFile) return [];
+  const normalizedFirstFile = firstFile.replaceAll("\\", "/");
+  const normalizedPath = filePath.replaceAll("\\", "/");
+  if (normalizedFirstFile !== normalizedPath) return [];
+  const loc = smell.smell.locations[0];
+  return [createLocationFromSmell(loc, smell.explanation.reason)];
+}
+function getSourceFileLocation(smell, filePath) {
+  const sourceLoc = smell.smell.locations.find((l) => l.file.replaceAll("\\", "/") === filePath);
+  if (!sourceLoc) return [];
+  return [
+    {
+      line: sourceLoc.line,
+      column: sourceLoc.column ?? 0,
+      endLine: sourceLoc.range?.endLine,
+      endColumn: sourceLoc.range?.endColumn,
+      messageId: "violation",
+      data: { reason: smell.explanation.reason }
+    }
+  ];
+}
+function getAllFileLocations(smell, filePath) {
+  return smell.smell.locations.filter((l) => l.file.replaceAll("\\", "/") === filePath).map((l) => ({
+    line: l.line,
+    column: l.column ?? 0,
+    endLine: l.range?.endLine,
+    endColumn: l.range?.endColumn,
+    messageId: "smell",
+    data: { reason: l.description || smell.explanation.reason }
+  }));
+}
+
+// src/utils/rule-factory.ts
+function createRuleMeta(options) {
+  return {
+    type: "problem",
+    docs: {
+      description: options.description,
+      category: options.category,
+      recommended: options.recommended,
+      url: `https://archlinter.dev/rules/${options.detectorId.replaceAll("_", "-")}`
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          projectRoot: {
+            type: "string",
+            description: "Override project root detection"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      analyzing: "archlint: analyzing project architecture...",
+      ...options.messages
+    }
+  };
+}
+function reportSmellLocations(context, smell, filename, strategy, projectRoot) {
+  const locations = getSmellLocationsForFile(smell, filename, strategy, projectRoot);
+  for (const loc of locations) {
+    const reportLoc = {
+      start: { line: loc.line, column: Math.max(0, (loc.column ?? 1) - 1) }
+    };
+    if (loc.endLine !== void 0 && loc.endColumn !== void 0) {
+      reportLoc.end = { line: loc.endLine, column: Math.max(0, loc.endColumn - 1) };
+    }
+    context.report({
+      loc: reportLoc,
+      messageId: loc.messageId,
+      data: loc.data
+    });
+  }
+}
+function createArchlintRule(options) {
+  return {
+    meta: createRuleMeta(options),
+    create(context) {
+      const filename = context.filename;
+      const ruleOptions = context.options[0] ?? {};
+      const projectRoot = ruleOptions.projectRoot ?? findProjectRoot(filename);
+      const sourceCode = context.sourceCode;
+      const bufferText = sourceCode.text;
+      return {
+        Program(node) {
+          if (isVirtualFile(filename)) {
+            return;
+          }
+          const state = isAnalysisReady(filename, {
+            projectRoot: ruleOptions.projectRoot,
+            bufferText
+          });
+          if (state === "not_started" /* NotStarted */) {
+            context.report({ node, messageId: "analyzing" });
+            return;
+          }
+          if (state === "in_progress" /* InProgress */) {
+            return;
+          }
+          const smells = getSmellsForFile(
+            filename,
+            options.detectorId,
+            ruleOptions.projectRoot,
+            bufferText
+          );
+          for (const smell of smells) {
+            reportSmellLocations(context, smell, filename, options.strategy, projectRoot);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-cycles.ts
+var noCycles = createArchlintRule({
+  detectorId: "cycles",
+  messageId: "cycle",
+  description: "Disallow cyclic dependencies between files",
+  category: "Architecture",
+  recommended: true,
+  strategy: "critical-edges",
+  messages: {
+    cycle: "Cyclic import to '{{target}}' ({{impact}} impact)",
+    cycleCluster: "File is part of cyclic dependency cluster ({{size}} files)"
+  }
+});
+
+// src/rules/no-god-modules.ts
+var noGodModules = createArchlintRule({
+  detectorId: "god_module",
+  messageId: "smell",
+  description: "Disallow overly large and complex modules (God Modules)",
+  category: "Architecture",
+  recommended: true,
+  strategy: "primary-file",
+  messages: {
+    smell: "God Module detected: {{reason}}"
+  }
+});
+
+// src/rules/no-dead-code.ts
+var noDeadCode = createArchlintRule({
+  detectorId: "dead_code",
+  messageId: "smell",
+  description: "Disallow dead code and unused exports",
+  category: "Architecture",
+  recommended: true,
+  strategy: "primary-file",
+  messages: {
+    smell: "Dead code detected: {{reason}}"
+  }
+});
+
+// src/rules/no-dead-symbols.ts
+var noDeadSymbols = createArchlintRule({
+  detectorId: "dead_symbols",
+  messageId: "smell",
+  description: "Disallow unused functions, classes, and variables",
+  category: "Architecture",
+  recommended: true,
+  strategy: "all-files",
+  messages: {
+    smell: "Unused symbol detected: {{reason}}"
+  }
+});
+
+// src/rules/no-high-coupling.ts
+var noHighCoupling = createArchlintRule({
+  detectorId: "high_coupling",
+  messageId: "smell",
+  description: "Disallow modules with excessively high coupling",
+  category: "Architecture",
+  recommended: true,
+  strategy: "primary-file",
+  messages: {
+    smell: "High coupling detected: {{reason}}"
+  }
+});
+
+// src/rules/no-barrel-abuse.ts
+var noBarrelAbuse = createArchlintRule({
+  detectorId: "barrel_file_abuse",
+  messageId: "smell",
+  description: "Disallow abuse of barrel files",
+  category: "Architecture",
+  recommended: false,
+  strategy: "primary-file",
+  messages: {
+    smell: "Barrel file abuse: {{reason}}"
+  }
+});
+
+// src/rules/no-layer-violations.ts
+var noLayerViolations = createArchlintRule({
+  detectorId: "layer_violation",
+  messageId: "violation",
+  description: "Disallow violations of defined architecture layers",
+  category: "Architecture",
+  recommended: true,
+  strategy: "source-file",
+  messages: {
+    violation: "Layer violation: {{reason}}"
+  }
+});
+
+// src/rules/no-sdp-violations.ts
+var noSdpViolations = createArchlintRule({
+  detectorId: "sdp_violation",
+  messageId: "smell",
+  description: "Disallow violations of the Stable Dependencies Principle",
+  category: "Architecture",
+  recommended: false,
+  strategy: "primary-file",
+  messages: {
+    smell: "SDP violation: {{reason}}"
+  }
+});
+
+// src/rules/no-hub-modules.ts
+var noHubModules = createArchlintRule({
+  detectorId: "hub_module",
+  messageId: "smell",
+  description: "Disallow modules that act as too many dependencies",
+  category: "Architecture",
+  recommended: false,
+  strategy: "primary-file",
+  messages: {
+    smell: "Hub module detected: {{reason}}"
+  }
+});
+
+// src/rules/no-deep-nesting.ts
+var noDeepNesting = createArchlintRule({
+  detectorId: "deep_nesting",
+  messageId: "smell",
+  description: "Disallow excessively deep directory nesting",
+  category: "Architecture",
+  recommended: false,
+  strategy: "all-files",
+  messages: {
+    smell: "Deep nesting: {{reason}}"
+  }
+});
+
+// src/rules/no-long-params.ts
+var noLongParams = createArchlintRule({
+  detectorId: "long_params",
+  messageId: "smell",
+  description: "Disallow functions with too many parameters",
+  category: "Architecture",
+  recommended: false,
+  strategy: "all-files",
+  messages: {
+    smell: "Too many parameters: {{reason}}"
+  }
+});
+
+// src/rules/no-high-complexity.ts
+var noHighComplexity = createArchlintRule({
+  detectorId: "high_complexity",
+  messageId: "smell",
+  description: "Disallow functions with high cyclomatic complexity",
+  category: "Code Quality",
+  recommended: true,
+  strategy: "all-files",
+  messages: {
+    smell: "High complexity detected: {{reason}}"
+  }
+});
+
+// src/rules/no-code-clone.ts
+var noCodeClone = createArchlintRule({
+  detectorId: "code_clone",
+  messageId: "smell",
+  description: "Disallow duplicated code blocks (code clones)",
+  category: "Code Quality",
+  recommended: true,
+  strategy: "all-files",
+  messages: {
+    smell: "Code clone detected: {{reason}}"
+  }
+});
+
+// src/rules/no-regression.ts
+var import_core2 = require("@archlinter/core");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var diffCache = /* @__PURE__ */ new Map();
+var firstFiles = /* @__PURE__ */ new Set();
+var lastRunStamp = 0;
+var noRegression = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Detect architectural regressions compared to baseline",
+      recommended: false
+    },
+    messages: {
+      regression: "{{message}}",
+      noBaseline: "Baseline snapshot not found at {{path}}. Run: archlint snapshot -o {{path}}"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          baseline: {
+            type: "string",
+            description: "Path to baseline snapshot"
+          },
+          failOn: {
+            type: "string",
+            enum: ["low", "medium", "high", "critical"],
+            description: "Minimum severity to report"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const currentRunStamp = Date.now();
+    if (currentRunStamp - lastRunStamp > 5e3) {
+      diffCache.clear();
+      firstFiles.clear();
+    }
+    lastRunStamp = currentRunStamp;
+    const { baseline, failOn } = getOptions(context);
+    const projectRoot = findProjectRoot(context.filename);
+    if (!ensureDiffResult(context, projectRoot, baseline)) {
+      return {};
+    }
+    return reportFromCache(context, projectRoot, failOn);
+  }
+};
+function getOptions(context) {
+  const options = context.options[0] ?? {};
+  return {
+    baseline: options.baseline ?? ".archlint-snapshot.json",
+    failOn: options.failOn ?? "low"
+  };
+}
+function ensureDiffResult(context, projectRoot, baselinePath) {
+  if (diffCache.has(projectRoot)) {
+    return true;
+  }
+  const absoluteBaseline = path.resolve(projectRoot, baselinePath);
+  if (!fs.existsSync(absoluteBaseline)) {
+    if (isFirstFile(context, projectRoot)) {
+      context.report({
+        loc: { line: 1, column: 0 },
+        messageId: "noBaseline",
+        data: { path: baselinePath }
+      });
+    }
+    return false;
+  }
+  try {
+    const result = (0, import_core2.runDiff)({
+      baselinePath: absoluteBaseline,
+      projectPath: projectRoot
+    });
+    diffCache.set(projectRoot, result);
+    return true;
+  } catch (error) {
+    if (isFirstFile(context, projectRoot)) {
+      context.report({
+        loc: { line: 1, column: 0 },
+        messageId: "regression",
+        data: { message: `Diff failed: ${error instanceof Error ? error.message : String(error)}` }
+      });
+    }
+    return false;
+  }
+}
+var SEVERITY_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
+function getRegressionsToReport(result, failOn) {
+  const minSev = SEVERITY_ORDER[failOn] ?? 0;
+  return result.regressions.filter((r) => {
+    const sev = r.smell.severity.toLowerCase();
+    return (SEVERITY_ORDER[sev] ?? 0) >= minSev;
+  });
+}
+function reportFromCache(context, projectRoot, failOn) {
+  const result = diffCache.get(projectRoot);
+  if (!result?.hasRegressions) {
+    return {};
+  }
+  const regressions = getRegressionsToReport(result, failOn);
+  if (regressions.length === 0) {
+    return {};
+  }
+  return createVisitor(context, projectRoot, regressions);
+}
+function createVisitor(context, projectRoot, regressions) {
+  const filename = path.relative(projectRoot, context.filename);
+  const isFirst = isFirstFile(context, projectRoot);
+  return {
+    Program(node) {
+      for (const reg of regressions) {
+        if (shouldReportRegression(reg, filename, isFirst)) {
+          context.report({
+            node,
+            messageId: "regression",
+            data: { message: formatRegressionMessage(reg) }
+          });
+        }
+      }
+    }
+  };
+}
+function shouldReportRegression(reg, filename, isFirst) {
+  if (isFirst) {
+    return true;
+  }
+  const files = reg.smell?.files;
+  if (!files || !Array.isArray(files)) {
+    return false;
+  }
+  return files.some((f) => f === filename || filename.endsWith(f));
+}
+function formatRegressionMessage(reg) {
+  const smell = reg.smell;
+  const smellType = smell.smellType;
+  const files = smell.files.slice(0, 3).join(", ");
+  switch (reg.regressionType.type) {
+    case "NewSmell":
+      return `New architectural smell: ${smellType} in ${files}`;
+    case "SeverityIncrease":
+      return formatSeverityIncreaseMessage(reg.regressionType, smellType);
+    case "MetricWorsening":
+      return formatMetricWorseningMessage(reg.regressionType, smellType);
+    default:
+      return String(reg.message);
+  }
+}
+function formatSeverityIncreaseMessage(regType, smellType) {
+  return `Architectural smell ${smellType} worsened: severity increased from ${regType.from} to ${regType.to}`;
+}
+function formatMetricWorseningMessage(regType, smellType) {
+  const { metric, from, to, changePercent } = regType;
+  return `Architectural metric worsened: ${smellType} ${metric} ${from} \u2192 ${to} (+${(changePercent ?? 0).toFixed(0)}%)`;
+}
+function isFirstFile(context, projectRoot) {
+  if (!firstFiles.has(projectRoot)) {
+    firstFiles.add(projectRoot);
+    return true;
+  }
+  return false;
+}
+
+// src/rules/index.ts
+var rules = {
+  "no-cycles": noCycles,
+  "no-god-modules": noGodModules,
+  "no-dead-code": noDeadCode,
+  "no-dead-symbols": noDeadSymbols,
+  "no-high-coupling": noHighCoupling,
+  "no-barrel-abuse": noBarrelAbuse,
+  "no-layer-violations": noLayerViolations,
+  "no-sdp-violations": noSdpViolations,
+  "no-hub-modules": noHubModules,
+  "no-deep-nesting": noDeepNesting,
+  "no-long-params": noLongParams,
+  "no-high-complexity": noHighComplexity,
+  "no-code-clone": noCodeClone,
+  "no-regression": noRegression
+};
+
+// src/configs/recommended.ts
+var recommended = {
+  plugins: ["@archlinter"],
+  rules: {
+    "@archlinter/no-cycles": "error",
+    "@archlinter/no-god-modules": "warn",
+    "@archlinter/no-dead-code": "warn",
+    "@archlinter/no-dead-symbols": "warn",
+    "@archlinter/no-high-coupling": "warn",
+    "@archlinter/no-high-complexity": "error",
+    "@archlinter/no-layer-violations": "error",
+    "@archlinter/no-code-clone": "warn"
+  }
+};
+var strict = {
+  plugins: ["@archlinter"],
+  rules: {
+    "@archlinter/no-cycles": "error",
+    "@archlinter/no-god-modules": "error",
+    "@archlinter/no-dead-code": "error",
+    "@archlinter/no-dead-symbols": "error",
+    "@archlinter/no-high-coupling": "error",
+    "@archlinter/no-high-complexity": "error",
+    "@archlinter/no-barrel-abuse": "error",
+    "@archlinter/no-layer-violations": "error",
+    "@archlinter/no-sdp-violations": "error",
+    "@archlinter/no-hub-modules": "warn",
+    "@archlinter/no-deep-nesting": "error",
+    "@archlinter/no-long-params": "warn",
+    "@archlinter/no-code-clone": "error",
+    "@archlinter/no-regression": ["error", { failOn: "medium" }]
+  }
+};
+
+// src/configs/flat.ts
+var flatRecommended = {
+  plugins: {
+    "@archlinter": { rules }
+  },
+  rules: {
+    "@archlinter/no-cycles": "error",
+    "@archlinter/no-god-modules": "warn",
+    "@archlinter/no-dead-code": "warn",
+    "@archlinter/no-dead-symbols": "warn",
+    "@archlinter/no-high-coupling": "warn",
+    "@archlinter/no-high-complexity": "error",
+    "@archlinter/no-layer-violations": "error",
+    "@archlinter/no-code-clone": "warn"
+  }
+};
+var flatStrict = {
+  plugins: {
+    "@archlinter": { rules }
+  },
+  rules: {
+    "@archlinter/no-cycles": "error",
+    "@archlinter/no-god-modules": "error",
+    "@archlinter/no-dead-code": "error",
+    "@archlinter/no-dead-symbols": "error",
+    "@archlinter/no-high-coupling": "error",
+    "@archlinter/no-high-complexity": "error",
+    "@archlinter/no-barrel-abuse": "error",
+    "@archlinter/no-layer-violations": "error",
+    "@archlinter/no-sdp-violations": "error",
+    "@archlinter/no-hub-modules": "warn",
+    "@archlinter/no-deep-nesting": "error",
+    "@archlinter/no-long-params": "warn",
+    "@archlinter/no-code-clone": "error",
+    "@archlinter/no-regression": ["error", { failOn: "medium" }]
+  }
+};
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: "@archlinter/eslint-plugin",
+    version: "0.6.0-alpha.1"
+  },
+  rules,
+  configs: {
+    // Legacy configs (ESLint 8)
+    // @ts-expect-error - Legacy config format compatibility
+    recommended,
+    // @ts-expect-error - Legacy config format compatibility
+    strict,
+    // Flat configs (ESLint 9+)
+    "flat/recommended": flatRecommended,
+    "flat/strict": flatStrict
+  }
+};
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearAllCaches,
+  flatRecommended,
+  flatStrict,
+  notifyFileChanged,
+  recommended,
+  rules,
+  strict
+});
+if (module.exports.default) { Object.assign(module.exports.default, module.exports); module.exports = module.exports.default; }
+//# sourceMappingURL=index.cjs.map