@solid-stack/mason 1.0.21 → 1.0.23

package/dist/bin.cjs

@@ -4189,6 +4189,832 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
 }
+var DependencyRuleError = class extends Error {
+  violations;
+  isFailFast;
+  constructor(message, violations, isFailFast = false) {
+    super(message);
+    this.name = "DependencyRuleError";
+    this.violations = violations;
+    this.isFailFast = isFailFast;
+  }
+};
+function isTestFile2(filePath, projectRoot) {
+  const norm = (projectRoot ? path2__default.default.relative(projectRoot, filePath) : filePath).replace(/\\/g, "/");
+  const base = path2__default.default.basename(norm);
+  return base.endsWith(".test.ts") || base.endsWith(".test.js") || base.endsWith(".spec.ts") || base.endsWith(".spec.js") || base.endsWith(".d.ts") || norm.includes("/__tests__/") || norm.startsWith("__tests__/") || /(?:^|\/)tests?\//.test(norm);
+}
+function scanDirFiles(dir, projectRoot) {
+  if (!fs9__default.default.existsSync(dir)) return [];
+  const entries = fs9__default.default.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__" || entry.name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = path2__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...scanDirFiles(fullPath, projectRoot));
+    } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !isTestFile2(fullPath, projectRoot)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function classifyFile(fullPath, projectRoot) {
+  const rel = path2__default.default.relative(projectRoot, fullPath).replace(/\\/g, "/");
+  const featureMatch = rel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/.*)?$/);
+  if (!featureMatch || !featureMatch[1] || !featureMatch[2]) return {};
+  const feature = featureMatch[1];
+  const subfolder = featureMatch[2];
+  let layer;
+  if (subfolder === "domain" || subfolder === "errors") {
+    layer = "domain";
+  } else if (subfolder === "useCases" || subfolder === "usecases") {
+    layer = "useCases";
+  } else if (subfolder === "services") {
+    layer = "services";
+  } else if (subfolder === "infrastructure") {
+    layer = "infrastructure";
+  } else if (subfolder === "pxExpress" || subfolder === "presentation" || subfolder === "handlers" || subfolder.startsWith("px")) {
+    layer = "presentation";
+  }
+  return { feature, layer };
+}
+function classifyTarget(specifier, sourceFileAbs, projectRoot) {
+  if (specifier === "@solid-stack/di" || specifier.startsWith("@solid-stack/di/")) {
+    return { isExternal: true, isDiFramework: true };
+  }
+  if (specifier.startsWith("node:") || ["crypto", "fs", "path", "http", "https", "url", "os", "child_process", "stream", "express", "cors", "dotenv"].includes(specifier)) {
+    return { isExternal: true, isDiFramework: false };
+  }
+  let resolvedRel = null;
+  if (specifier.startsWith(".")) {
+    const abs = path2__default.default.resolve(path2__default.default.dirname(sourceFileAbs), specifier);
+    resolvedRel = path2__default.default.relative(projectRoot, abs).replace(/\\/g, "/");
+  } else if (specifier.startsWith("@/features/") || specifier.startsWith("~/features/")) {
+    resolvedRel = specifier.replace(/^[@~]\//, "src/");
+  } else if (specifier.startsWith("@features/")) {
+    resolvedRel = "src/" + specifier.slice(1);
+  } else if (specifier.startsWith("@/shared/") || specifier.startsWith("~/shared/")) {
+    resolvedRel = specifier.replace(/^[@~]\//, "src/");
+  } else if (specifier.startsWith("@shared/")) {
+    resolvedRel = "src/" + specifier.slice(1);
+  } else if (specifier.startsWith("@/") || specifier.startsWith("~/")) {
+    resolvedRel = "src/" + specifier.slice(2);
+  } else if (specifier.startsWith("features/") || specifier.startsWith("shared/")) {
+    resolvedRel = specifier;
+  }
+  if (!resolvedRel) {
+    return { isExternal: true, isDiFramework: false };
+  }
+  const featMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/(.*))?$/);
+  if (featMatch && featMatch[1] && featMatch[2]) {
+    const targetFeature = featMatch[1];
+    const targetSubfolder = featMatch[2];
+    const rest = featMatch[3] || "";
+    let targetLayer;
+    if (targetSubfolder === "domain" || targetSubfolder === "errors") {
+      targetLayer = "domain";
+    } else if (targetSubfolder === "useCases" || targetSubfolder === "usecases") {
+      targetLayer = "useCases";
+    } else if (targetSubfolder === "services") {
+      targetLayer = "services";
+    } else if (targetSubfolder === "infrastructure") {
+      targetLayer = "infrastructure";
+    } else if (targetSubfolder === "pxExpress" || targetSubfolder === "presentation" || targetSubfolder === "handlers" || targetSubfolder.startsWith("px")) {
+      targetLayer = "presentation";
+    }
+    const basePart = rest ? path2__default.default.basename(rest) : targetSubfolder;
+    const targetFileName = basePart.replace(/\.(js|ts|mjs|cjs)$/, "");
+    const isTargetPort = /^I[A-Z]/.test(targetFileName);
+    const isTargetRepo = isTargetPort && targetFileName.includes("Repo");
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      targetFeature,
+      targetLayer,
+      targetSubfolder,
+      targetFileName,
+      isTargetPort,
+      isTargetRepo
+    };
+  }
+  const sharedMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?shared\/([^/]+)(?:\/(.*))?$/);
+  if (sharedMatch) {
+    const targetSharedModule = sharedMatch[1];
+    const sharedRest = sharedMatch[2] || "";
+    const isSharedRoot = !sharedRest.includes("/");
+    const isSharedPorts = sharedRest.startsWith("ports/") || sharedRest === "ports";
+    const isSharedInfra = sharedRest.startsWith("infrastructure/") || sharedRest === "infrastructure";
+    const isSharedDomain = sharedRest.startsWith("domain/") || sharedRest === "domain";
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      targetSharedModule,
+      isSharedRoot,
+      isSharedPorts,
+      isSharedInfra,
+      isSharedDomain
+    };
+  }
+  return { isExternal: true, isDiFramework: false };
+}
+function extractImportStatements(content) {
+  const statements = [];
+  const lines = content.split(/\r?\n/);
+  const regex = /(?:import\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|export\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|import\s*\(|require\s*\()\s*["']([^"']+)["']/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const specifier = match[1];
+    const charIndex = match.index;
+    const lineNum = content.substring(0, charIndex).split("\n").length;
+    const rawCode = lines[lineNum - 1]?.trim() || match[0].trim();
+    statements.push({
+      specifier,
+      line: lineNum,
+      rawCode
+    });
+  }
+  return statements;
+}
+var FeatureDependencyGraph = class {
+  edges = /* @__PURE__ */ new Map();
+  addEdge(evidence) {
+    const { fromFeature, toFeature } = evidence;
+    if (fromFeature === toFeature) {
+      return { createsCycle: false };
+    }
+    if (!this.edges.has(fromFeature)) {
+      this.edges.set(fromFeature, /* @__PURE__ */ new Map());
+    }
+    this.edges.get(fromFeature).set(toFeature, evidence);
+    const reverse = this.edges.get(toFeature)?.get(fromFeature);
+    if (reverse) {
+      return { createsCycle: true, directPartner: reverse, cycleChain: [fromFeature, toFeature, fromFeature] };
+    }
+    const cycle = this.findCycleFrom(fromFeature);
+    if (cycle && cycle.length > 0) {
+      return { createsCycle: true, cycleChain: cycle };
+    }
+    return { createsCycle: false };
+  }
+  getEdges() {
+    const list = [];
+    for (const [from, toMap] of this.edges.entries()) {
+      for (const [to, ev] of toMap.entries()) {
+        list.push({ from, to, evidence: ev });
+      }
+    }
+    return list;
+  }
+  findDirectCycles() {
+    const cycles = [];
+    const checkedPairs = /* @__PURE__ */ new Set();
+    for (const [from, toMap] of this.edges.entries()) {
+      for (const [to, evAtoB] of toMap.entries()) {
+        const pairKey = [from, to].sort().join("<->");
+        if (checkedPairs.has(pairKey)) continue;
+        const evBtoA = this.edges.get(to)?.get(from);
+        if (evBtoA) {
+          checkedPairs.add(pairKey);
+          cycles.push({
+            featureA: from,
+            featureB: to,
+            cycle: [from, to, from],
+            evidenceAtoB: evAtoB,
+            evidenceBtoA: evBtoA
+          });
+        }
+      }
+    }
+    return cycles;
+  }
+  findCycleFrom(start) {
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const parent = /* @__PURE__ */ new Map();
+    const dfs = (curr) => {
+      visited.add(curr);
+      inStack.add(curr);
+      const neighbors = this.edges.get(curr);
+      if (neighbors) {
+        for (const next of neighbors.keys()) {
+          if (!visited.has(next)) {
+            parent.set(next, curr);
+            const cycle = dfs(next);
+            if (cycle) return cycle;
+          } else if (inStack.has(next)) {
+            const cycle = [next];
+            let p16 = curr;
+            while (p16 !== next) {
+              cycle.push(p16);
+              p16 = parent.get(p16) || next;
+            }
+            cycle.push(next);
+            cycle.reverse();
+            return cycle;
+          }
+        }
+      }
+      inStack.delete(curr);
+      return null;
+    };
+    return dfs(start);
+  }
+};
+function discoverAllFeatures(projectRoot) {
+  const featuresBase = resolveFeaturesDir(projectRoot);
+  if (!fs9__default.default.existsSync(featuresBase)) return [];
+  const entries = fs9__default.default.readdirSync(featuresBase, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
+    name: e.name,
+    dir: path2__default.default.join(featuresBase, e.name)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function lintCodebase(options = {}) {
+  const startTime = Date.now();
+  const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
+  const failFast = !options.complete;
+  const features = discoverAllFeatures(projectRoot);
+  const graph = new FeatureDependencyGraph();
+  const allViolations = [];
+  const results = [];
+  const detectedCycles = [];
+  const addViolation = (v) => {
+    allViolations.push(v);
+    const featureResult = results.find((r) => r.featureName === v.feature);
+    if (featureResult) {
+      featureResult.violations.push(v);
+      featureResult.passed = false;
+    }
+    if (failFast) {
+      const errorMsg = `Dependency rule violation detected in ${v.relativePath}:${v.line}:
+[${v.category}] ${v.advice}
+Code: ${v.code}`;
+      throw new DependencyRuleError(errorMsg, [v], true);
+    }
+  };
+  for (const feat of features) {
+    results.push({
+      featureName: feat.name,
+      featureDir: feat.dir,
+      scannedFilesCount: 0,
+      passed: true,
+      violations: [],
+      layersChecked: ["domain", "useCases", "services", "infrastructure", "presentation"]
+    });
+  }
+  for (const feat of features) {
+    const featResult = results.find((r) => r.featureName === feat.name);
+    const allFiles = scanDirFiles(feat.dir, projectRoot);
+    featResult.scannedFilesCount = allFiles.length;
+    for (const file of allFiles) {
+      const relPath = path2__default.default.relative(projectRoot, file).replace(/\\/g, "/");
+      const { layer } = classifyFile(file, projectRoot);
+      if (!layer) continue;
+      const content = fs9__default.default.readFileSync(file, "utf-8");
+      const statements = extractImportStatements(content);
+      if (layer === "domain") {
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+          const lineText = lines[i].trim();
+          if (lineText.includes("@MakeInjectable") || lineText.includes("public static deps =")) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: i + 1,
+              category: "Domain Dependence Violation",
+              code: lineText,
+              ruleId: "D2_DI_DEPENDENCE",
+              severity: "error",
+              advice: "Domain layer must have zero DI dependence. Remove @MakeInjectable decorators and static deps declarations.",
+              fixExample: {
+                bad: lineText,
+                good: "// Domain interfaces and value objects must remain plain TypeScript classes/interfaces."
+              }
+            });
+          }
+        }
+      }
+      for (const stmt of statements) {
+        const target = classifyTarget(stmt.specifier, file, projectRoot);
+        if (target.targetFeature && target.targetFeature !== feat.name) {
+          const evidence = {
+            fromFeature: feat.name,
+            toFeature: target.targetFeature,
+            file,
+            relativePath: relPath,
+            line: stmt.line,
+            code: stmt.rawCode
+          };
+          const cycleResult = graph.addEdge(evidence);
+          if (cycleResult.createsCycle) {
+            const partner = cycleResult.directPartner;
+            detectedCycles.push({
+              featureA: feat.name,
+              featureB: target.targetFeature,
+              cycle: cycleResult.cycleChain,
+              evidenceAtoB: evidence,
+              evidenceBtoA: partner || evidence
+            });
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Circular Feature Dependency Violation",
+              code: stmt.rawCode,
+              ruleId: "C1_CIRCULAR_FEATURE_DEPENDENCY",
+              severity: "error",
+              advice: `Circular feature dependency detected between '${feat.name}' and '${target.targetFeature}'. Dependency flow must be strictly one-way: for any two features, only one can know about the other exists. If '${feat.name}' needs to impose a side effect on '${target.targetFeature}' (or vice versa), it must do so via an event, never via a direct dependency.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Emit a Domain/Application Event (e.g. publish '${feat.name}Changed') instead of depending on '${target.targetFeature}'.`
+              }
+            });
+          }
+        }
+        if (layer === "domain") {
+          if (target.targetLayer && ["useCases", "services", "infrastructure", "presentation"].includes(target.targetLayer)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D1_OUTER_IMPORT",
+              severity: "error",
+              advice: `Domain layer must not import from outer layers (${target.targetLayer}). Keep the domain core pure.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Define interfaces, types, or value objects directly within the domain layer."
+              }
+            });
+          }
+          if (target.isDiFramework) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Dependence Violation",
+              code: stmt.rawCode,
+              ruleId: "D2_DI_DEPENDENCE",
+              severity: "error",
+              advice: "Domain layer must have zero DI dependence. Domain interfaces and value objects are plain classes/types.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Remove @solid-stack/di import. Domain entities are pure TypeScript."
+              }
+            });
+          }
+          if (target.targetSharedModule && !target.isSharedDomain) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D3_SHARED_NON_DOMAIN_IMPORT",
+              severity: "error",
+              advice: "Domain layer can only import pure value objects from shared/<module>/domain/*. Ports, infrastructure, and root classes must not be imported.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/domain/...";`
+              }
+            });
+          }
+          if (target.isExternal && !target.isDiFramework) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D4_EXTERNAL_LIBRARY",
+              severity: "error",
+              advice: `Domain layer must be pure and must not depend on external runtime libraries ('${stmt.specifier}').`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Model pure business interfaces without external libraries."
+              }
+            });
+          }
+        } else if (layer === "useCases") {
+          if (target.targetLayer === "useCases" && target.targetFeature === feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Intra-Feature Violation",
+              code: stmt.rawCode,
+              ruleId: "U1_INTRA_USE_CASE",
+              severity: "error",
+              advice: `Use cases cannot depend on other use cases of the same feature ('${feat.name}'). Extract shared business logic to a domain repository or domain service.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject a domain interface or domain service instead of another use case."
+              }
+            });
+          }
+          if (target.targetLayer === "useCases" && target.targetFeature && target.targetFeature !== feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Cross-Feature Use Case Violation",
+              code: stmt.rawCode,
+              ruleId: "U2_CROSS_FEATURE_USE_CASE",
+              severity: "error",
+              advice: `Use cases cannot depend directly on use cases of foreign feature '${target.targetFeature}'. Treat features as separate microservices: define an interface in '${feat.name}/domain/' specifying what is needed, and implement it in '${feat.name}/infrastructure/'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/ using '${target.targetFileName}'.`
+              }
+            });
+          }
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "U3_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Use cases cannot import concrete infrastructure directly. Depend on Domain Ports of the same feature via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend on the domain interface port declared in static deps."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && target.targetFeature && target.targetFeature !== feat.name && target.isTargetPort) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Cross-Feature Port Violation",
+              code: stmt.rawCode,
+              ruleId: "U4_CROSS_FEATURE_PORT",
+              severity: "error",
+              advice: `Use cases cannot depend on domain interfaces/ports of foreign feature '${target.targetFeature}'. Define an interface in '${feat.name}/domain/' (consumer-driven port) and implement it in '${feat.name}/infrastructure/'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define a local interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetLayer === "services" && target.targetFeature && target.targetFeature !== feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "U5_CROSS_FEATURE_SERVICE",
+              severity: "error",
+              advice: `Use cases cannot depend on services of foreign feature '${target.targetFeature}'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "U6_SHARED_NON_ROOT",
+              severity: "error",
+              advice: `Use cases can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "services") {
+          if (target.targetLayer === "useCases") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Intra-Feature Violation",
+              code: stmt.rawCode,
+              ruleId: "S1_USE_CASE_DEPENDENCY",
+              severity: "error",
+              advice: "Services cannot depend on use cases of any feature.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject domain repository ports directly instead of use cases."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && target.targetFeature && target.targetFeature !== feat.name && target.isTargetPort) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Cross-Feature Port Violation",
+              code: stmt.rawCode,
+              ruleId: "S2_CROSS_FEATURE_PORT",
+              severity: "error",
+              advice: `Services cannot depend on domain ports of foreign feature '${target.targetFeature}'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "S3_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Services cannot import concrete infrastructure directly. Depend on Domain Ports via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend on the domain interface port declared in static deps."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "S4_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Services can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "infrastructure") {
+          if (target.targetLayer === "useCases" && target.targetFeature === feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Adapter Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "I1_INTRA_USE_CASE",
+              severity: "error",
+              advice: `Infrastructure adapters cannot depend on use cases of the same feature ('${feat.name}'). Adapters implement domain ports.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Adapters implement domain ports and should not invoke local application use cases."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "I2_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Infrastructure adapters can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "presentation") {
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P1_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Presentation handlers must not import infrastructure directly. Inject Use Cases via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject the corresponding Use Case via static deps and invoke its execute() method."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && (target.isTargetRepo || target.isTargetPort)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P2_DIRECT_REPOSITORY",
+              severity: "error",
+              advice: "Presentation handlers must not depend on domain repositories or ports directly. Inject Use Cases via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Presentation layer must only orchestrate Use Cases."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "P3_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Presentation handlers can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  const directCycles = graph.findDirectCycles();
+  for (const c of directCycles) {
+    const existing = detectedCycles.find(
+      (dc) => dc.featureA === c.featureA && dc.featureB === c.featureB || dc.featureA === c.featureB && dc.featureB === c.featureA
+    );
+    if (!existing) {
+      detectedCycles.push(c);
+      addViolation({
+        feature: c.featureA,
+        file: c.evidenceAtoB.file,
+        relativePath: c.evidenceAtoB.relativePath,
+        line: c.evidenceAtoB.line,
+        category: "Circular Feature Dependency Violation",
+        code: c.evidenceAtoB.code,
+        ruleId: "C1_CIRCULAR_FEATURE_DEPENDENCY",
+        severity: "error",
+        advice: `Circular feature dependency detected between '${c.featureA}' and '${c.featureB}'. Dependency flow must be strictly one-way: for any two features, only one can know about the other exists. If the unaware feature needs to impose a side effect on the other, it must do so via an event, never via a direct dependency.`
+      });
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  const cleanFeatures = results.filter((r) => r.passed).length;
+  const violatedFeatures = results.filter((r) => !r.passed).length;
+  const summary = {
+    totalFeatures: results.length,
+    cleanFeatures,
+    violatedFeatures,
+    totalViolations: allViolations.length,
+    durationMs,
+    results,
+    allViolations,
+    circularDependencies: detectedCycles
+  };
+  if (allViolations.length > 0 && options.throwOnError !== false) {
+    const errorHeader = `Dependency rule audit failed with ${allViolations.length} violation(s) across ${violatedFeatures} feature(s):`;
+    const compiledDetails = allViolations.map(
+      (v, i) => `${i + 1}. [${v.category}] ${v.relativePath}:${v.line}
+   Rule:   ${v.ruleId}
+   Code:   ${v.code}
+   Advice: ${v.advice}`
+    ).join("\n\n");
+    throw new DependencyRuleError(`${errorHeader}
+
+${compiledDetails}
+`, allViolations, false);
+  }
+  return summary;
+}
+
+// src/commands/lint.ts
+function formatViolation(v) {
+  const lines = [];
+  lines.push(pc14__default.default.underline(pc14__default.default.cyan(v.relativePath)) + pc14__default.default.dim(":") + pc14__default.default.yellow(String(v.line)));
+  const gutter = `${String(v.line).padStart(4, " ")} | `;
+  lines.push(pc14__default.default.dim(gutter) + v.code);
+  const categoryShort = v.category.replace(" Violation", "");
+  lines.push(
+    "       " + pc14__default.default.red(pc14__default.default.bold("\u2716")) + " " + pc14__default.default.red(`[${categoryShort}]`) + " " + v.advice
+  );
+  if (v.fixExample?.good) {
+    lines.push("       " + pc14__default.default.dim("\u2192") + " " + pc14__default.default.dim(v.fixExample.good));
+  }
+  return lines.join("\n");
+}
+async function handleLint(flags = {}) {
+  const complete = Boolean(flags.complete);
+  const quiet = Boolean(flags.quiet);
+  const options = {
+    complete,
+    quiet,
+    targetDir: flags.targetDir || flags.target,
+    projectRoot: flags.projectRoot,
+    fixHint: flags.fixHint !== false,
+    throwOnError: false
+  };
+  try {
+    const summary = lintCodebase(options);
+    if (summary.totalViolations > 0) {
+      if (!quiet) {
+        console.log("");
+        for (const v of summary.allViolations) {
+          console.log(formatViolation(v));
+          console.log("");
+        }
+        console.log(
+          pc14__default.default.red(
+            `\u2716 Dependency rules check failed with ${summary.totalViolations} error${summary.totalViolations > 1 ? "s" : ""} across ${summary.violatedFeatures} feature${summary.violatedFeatures > 1 ? "s" : ""} (${summary.totalFeatures} features scanned).`
+          )
+        );
+        console.log("");
+      }
+      const errorHeader = `Dependency rule audit failed with ${summary.totalViolations} violation(s) across ${summary.violatedFeatures} feature(s):`;
+      const compiledDetails = summary.allViolations.map(
+        (v, i) => `${i + 1}. [${v.category}] ${v.relativePath}:${v.line}
+   Code:   ${v.code}
+   Advice: ${v.advice}`
+      ).join("\n\n");
+      throw new DependencyRuleError(`${errorHeader}
+
+${compiledDetails}
+`, summary.allViolations, false);
+    }
+    if (!quiet) {
+      console.log(
+        pc14__default.default.green(
+          `\u2714 Dependency rules verified across ${summary.totalFeatures} feature${summary.totalFeatures === 1 ? "" : "s"}.`
+        )
+      );
+    }
+    return summary;
+  } catch (err) {
+    if (err instanceof DependencyRuleError && err.isFailFast) {
+      if (!quiet) {
+        console.log("");
+        const v = err.violations[0];
+        if (v) {
+          console.log(formatViolation(v));
+          console.log("");
+        }
+        console.log(pc14__default.default.red(`\u2716 Dependency rules check failed (1 error).`));
+        console.log("");
+      }
+    }
+    throw err;
+  }
+}
 
 // src/cli.ts
 function createCli() {
@@ -4262,14 +5088,21 @@ function createCli() {
               value: "import",
               label: "Import from registry",
               hint: "Download and link pre-built shared modules or features from the registry"
+            },
+            {
+              value: "lint",
+              label: "Lint dependency rules",
+              hint: "Scan codebase and verify Clean Architecture dependency rules"
             }
           ]
         })
       );
       if (choice === "create") {
         await handleCreate(void 0, void 0, flags);
-      } else {
+      } else if (choice === "import") {
         await handleImport(void 0, void 0, flags);
+      } else if (choice === "lint") {
+        await handleLint(flags);
       }
     } catch (err) {
       handleCliError(err);
@@ -4295,6 +5128,28 @@ function createCli() {
       handleCliError(err);
     }
   });
+  cli.command(
+    "lint [target]",
+    "Scan codebase and verify Clean Architecture dependency rules"
+  ).option(
+    "-c, --complete",
+    "Scan entire codebase without failing fast, compiling all errors at the end"
+  ).option("-q, --quiet", "Suppress non-error output").example("mason lint").example("mason lint --complete").example("mason lint ./src").action(async (target, flags = {}) => {
+    try {
+      await handleLint({
+        ...flags,
+        targetDir: target || flags.target || flags.dest
+      });
+    } catch (err) {
+      if (err instanceof DependencyRuleError) {
+        if (process.env.VITEST) {
+          throw err;
+        }
+        process.exit(1);
+      }
+      handleCliError(err);
+    }
+  });
   const createSubtypes = [
     "feature",
     "shared",
@@ -4327,6 +5182,9 @@ function handleCliError(err) {
   }
   const message = err instanceof Error ? err.message : String(err);
   p14__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
+  if (process.env.VITEST) {
+    throw err;
+  }
   process.exit(1);
 }
 async function runCli(argv = process.argv) {