@lifesavertech/archguard-core 2.0.0 → 2.2.0

package/dist/config.js

@@ -68,8 +68,10 @@ function validateArchitectureConfig(config) {
         if (!layer.allowedImports.every((entry) => typeof entry === "string")) {
             throw new Error(`Invalid layer config for '${layerName}': 'allowedImports' must contain strings`);
         }
+        const paths = parseLayerPaths(layer, layerName);
         layers[layerName] = {
             allowedImports: layer.allowedImports,
+            ...(paths ? { paths } : {}),
         };
     }
     if (Object.keys(layers).length === 0) {
@@ -105,12 +107,15 @@ function validateArchitectureConfig(config) {
         "enforceLayerBoundaries",
         "enforceFeatureBoundaries",
         "noCircularLayerDeps",
+        "noBarrelBoundaryBypass",
     ].includes(key));
     if (unknownRuleKeys.length > 0) {
         throw new Error(`Invalid architecture config: unknown rule(s): ${unknownRuleKeys.join(", ")}`);
     }
     const enforceLayerBoundaries = Boolean(rules.enforceLayerBoundaries ?? rules.enforceFeatureBoundaries);
+    const patterns = parsePatternsConfig(rawConfig.patterns, layerNames);
     return {
+        patterns,
         layers,
         uiLayers,
         rules: {
@@ -119,9 +124,97 @@ function validateArchitectureConfig(config) {
             enforceLayerBoundaries,
             enforceFeatureBoundaries: Boolean(rules.enforceFeatureBoundaries),
             noCircularLayerDeps: Boolean(rules.noCircularLayerDeps),
+            noBarrelBoundaryBypass: rules.noBarrelBoundaryBypass === undefined
+                ? enforceLayerBoundaries
+                : Boolean(rules.noBarrelBoundaryBypass),
         },
     };
 }
+function parsePatternsConfig(rawPatterns, layerNames) {
+    if (rawPatterns === undefined) {
+        return undefined;
+    }
+    if (!rawPatterns || typeof rawPatterns !== "object") {
+        throw new Error("Invalid architecture config: 'patterns' must be an object");
+    }
+    const patterns = rawPatterns;
+    const result = {};
+    if (patterns.root !== undefined) {
+        if (typeof patterns.root !== "string" || patterns.root.trim().length === 0) {
+            throw new Error("Invalid architecture config: 'patterns.root' must be a non-empty string");
+        }
+        result.root = patterns.root.trim();
+    }
+    if (patterns.ignore !== undefined) {
+        if (!Array.isArray(patterns.ignore)) {
+            throw new Error("Invalid architecture config: 'patterns.ignore' must be an array of strings");
+        }
+        result.ignore = patterns.ignore.map((entry, index) => {
+            if (typeof entry !== "string" || entry.trim().length === 0) {
+                throw new Error(`Invalid architecture config: 'patterns.ignore[${index}]' must be a non-empty string`);
+            }
+            return entry.trim();
+        });
+    }
+    if (patterns.layers !== undefined) {
+        if (!patterns.layers || typeof patterns.layers !== "object") {
+            throw new Error("Invalid architecture config: 'patterns.layers' must be an object");
+        }
+        result.layers = {};
+        for (const [layerName, layerPatterns] of Object.entries(patterns.layers)) {
+            if (!layerNames.has(layerName)) {
+                throw new Error(`Invalid architecture config: patterns.layers references undefined layer '${layerName}'`);
+            }
+            if (!layerPatterns || typeof layerPatterns !== "object") {
+                throw new Error(`Invalid architecture config: patterns.layers.${layerName} must be an object`);
+            }
+            const rawLayerPatterns = layerPatterns;
+            const parsed = {};
+            if (rawLayerPatterns.include !== undefined) {
+                parsed.include = parsePatternList(rawLayerPatterns.include, `patterns.layers.${layerName}.include`);
+            }
+            if (rawLayerPatterns.exclude !== undefined) {
+                parsed.exclude = parsePatternList(rawLayerPatterns.exclude, `patterns.layers.${layerName}.exclude`);
+            }
+            result.layers[layerName] = parsed;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function parsePatternList(raw, fieldName) {
+    if (!Array.isArray(raw)) {
+        throw new Error(`Invalid architecture config: '${fieldName}' must be an array of strings`);
+    }
+    return raw.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`Invalid architecture config: '${fieldName}[${index}]' must be a non-empty string`);
+        }
+        return entry.trim();
+    });
+}
+function parseLayerPaths(layer, layerName) {
+    const raw = layer.paths ?? layer.path;
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            throw new Error(`Invalid layer config for '${layerName}': 'path' must be a non-empty string`);
+        }
+        return [trimmed];
+    }
+    if (Array.isArray(raw)) {
+        const paths = raw.map((entry, index) => {
+            if (typeof entry !== "string" || entry.trim().length === 0) {
+                throw new Error(`Invalid layer config for '${layerName}': 'paths[${index}]' must be a non-empty string`);
+            }
+            return entry.trim();
+        });
+        return paths;
+    }
+    throw new Error(`Invalid layer config for '${layerName}': 'path'/'paths' must be a string or array of strings`);
+}
 function findArchitectureConfig(startPath) {
     let currentPath = path.resolve(startPath);
     while (true) {

package/dist/diff.d.ts

@@ -0,0 +1,19 @@
+/** Git diff helpers and import-graph expansion for PR-scoped scans. */
+import type { ImportGraph } from "./index";
+import type { Violation } from "./violation";
+export interface DiffScanOptions {
+    cwd: string;
+    scanRoot: string;
+    baseRef?: string;
+    /** Test hook: skip git and use explicit changed paths (absolute or scan-root relative). */
+    changedFiles?: string[];
+}
+export declare function findGitRoot(startDir: string): string | null;
+export declare function resolveDiffBaseRef(cwd: string, requested?: string): string;
+export declare function getChangedFiles(options: DiffScanOptions): string[];
+export declare function expandAffectedFiles(changedFiles: string[], importGraph: ImportGraph): Set<string>;
+export declare function filterViolationsForDiff(violations: Violation[], affectedFiles: Set<string>): Violation[];
+export declare function resolveDiffAffectedFiles(options: DiffScanOptions, importGraph: ImportGraph): {
+    changedFiles: string[];
+    affectedFiles: Set<string>;
+};

package/dist/diff.js

@@ -0,0 +1,199 @@
+"use strict";
+/** Git diff helpers and import-graph expansion for PR-scoped scans. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findGitRoot = findGitRoot;
+exports.resolveDiffBaseRef = resolveDiffBaseRef;
+exports.getChangedFiles = getChangedFiles;
+exports.expandAffectedFiles = expandAffectedFiles;
+exports.filterViolationsForDiff = filterViolationsForDiff;
+exports.resolveDiffAffectedFiles = resolveDiffAffectedFiles;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const TYPESCRIPT_EXTENSIONS = new Set([".ts", ".tsx"]);
+function findGitRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, ".git"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function resolveDiffBaseRef(cwd, requested) {
+    if (requested && requested.trim().length > 0) {
+        return requested.trim();
+    }
+    const candidates = ["origin/main", "main", "origin/master", "master"];
+    for (const candidate of candidates) {
+        if (gitRefExists(cwd, candidate)) {
+            return candidate;
+        }
+    }
+    return "HEAD~1";
+}
+function gitRefExists(cwd, ref) {
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--verify", ref], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getChangedFiles(options) {
+    if (options.changedFiles && options.changedFiles.length > 0) {
+        return normalizeChangedPaths(options.changedFiles, options.scanRoot);
+    }
+    const gitRoot = findGitRoot(options.cwd);
+    if (!gitRoot) {
+        throw new Error("Diff mode requires a git repository. Run without --diff for a full scan, or initialize git first.");
+    }
+    const baseRef = resolveDiffBaseRef(gitRoot, options.baseRef);
+    const relativeScanRoot = path.relative(gitRoot, options.scanRoot);
+    const scanPrefix = relativeScanRoot === "" || relativeScanRoot === "." ? "" : `${relativeScanRoot}${path.sep}`;
+    const rawPaths = runGitDiffNameOnly(gitRoot, baseRef);
+    const absolutePaths = [];
+    for (const rawPath of rawPaths) {
+        if (scanPrefix && !rawPath.startsWith(scanPrefix)) {
+            continue;
+        }
+        const absolutePath = path.resolve(gitRoot, rawPath);
+        if (!absolutePath.startsWith(path.resolve(options.scanRoot))) {
+            continue;
+        }
+        if (!isTypeScriptSource(absolutePath)) {
+            continue;
+        }
+        if (!fs.existsSync(absolutePath)) {
+            continue;
+        }
+        absolutePaths.push(absolutePath);
+    }
+    return absolutePaths;
+}
+function runGitDiffNameOnly(gitRoot, baseRef) {
+    const attempts = [
+        ["diff", "--name-only", "--diff-filter=ACMR", `${baseRef}...HEAD`],
+        ["diff", "--name-only", "--diff-filter=ACMR", baseRef, "HEAD"],
+        ["diff", "--name-only", "--diff-filter=ACMR", "HEAD"],
+        ["diff", "--name-only", "--diff-filter=ACMR", "--cached"],
+    ];
+    for (const args of attempts) {
+        try {
+            const output = (0, node_child_process_1.execFileSync)("git", args, {
+                cwd: gitRoot,
+                encoding: "utf-8",
+            }).trim();
+            if (output.length === 0) {
+                continue;
+            }
+            return output.split("\n").map((line) => line.trim()).filter(Boolean);
+        }
+        catch {
+            continue;
+        }
+    }
+    return [];
+}
+function normalizeChangedPaths(changedFiles, scanRoot) {
+    const resolvedScanRoot = path.resolve(scanRoot);
+    return changedFiles
+        .map((filePath) => (path.isAbsolute(filePath) ? filePath : path.resolve(resolvedScanRoot, filePath)))
+        .filter((filePath) => filePath.startsWith(resolvedScanRoot))
+        .filter((filePath) => isTypeScriptSource(filePath) && fs.existsSync(filePath));
+}
+function isTypeScriptSource(filePath) {
+    return TYPESCRIPT_EXTENSIONS.has(path.extname(filePath));
+}
+function expandAffectedFiles(changedFiles, importGraph) {
+    const affected = new Set(changedFiles);
+    const reverseImporters = buildReverseImportIndex(importGraph);
+    for (const file of changedFiles) {
+        for (const imported of importGraph[file] ?? []) {
+            affected.add(imported);
+        }
+        for (const importer of reverseImporters.get(file) ?? []) {
+            affected.add(importer);
+        }
+    }
+    return affected;
+}
+function buildReverseImportIndex(importGraph) {
+    const reverse = new Map();
+    for (const [source, imports] of Object.entries(importGraph)) {
+        for (const target of imports) {
+            const existing = reverse.get(target) ?? [];
+            existing.push(source);
+            reverse.set(target, existing);
+        }
+    }
+    return reverse;
+}
+function filterViolationsForDiff(violations, affectedFiles) {
+    return violations.filter((violation) => {
+        if (affectedFiles.has(violation.file)) {
+            return true;
+        }
+        if (violation.rule === "no-circular-layer-deps") {
+            return violationTouchesAffectedFiles(violation.message, affectedFiles);
+        }
+        return false;
+    });
+}
+function violationTouchesAffectedFiles(message, affectedFiles) {
+    for (const file of affectedFiles) {
+        const relative = file.split(path.sep).join("/");
+        const basename = path.basename(file);
+        if (message.includes(relative) || message.includes(basename)) {
+            return true;
+        }
+    }
+    return false;
+}
+function resolveDiffAffectedFiles(options, importGraph) {
+    const changedFiles = getChangedFiles(options);
+    const affectedFiles = expandAffectedFiles(changedFiles, importGraph);
+    return { changedFiles, affectedFiles };
+}

package/dist/exports.d.ts

@@ -0,0 +1,19 @@
+/** Trace barrel re-exports to detect layer boundary bypasses. */
+import type { ArchitectureConfig } from "./index";
+import type { ImportResolver } from "./resolver";
+export interface BarrelLeak {
+    leakedLayer: string;
+    reexportFile: string;
+    chain: string[];
+}
+export declare function isBarrelBoundaryBypassEnabled(rules: ArchitectureConfig["rules"]): boolean;
+export declare function collectBarrelLeaks(options: {
+    barrelPath: string;
+    importerLayer: string;
+    allowedLayers: Set<string>;
+    architecture: ArchitectureConfig;
+    projectRoot: string;
+    resolver: ImportResolver;
+    visited?: Set<string>;
+}): BarrelLeak[];
+export declare function formatBarrelChain(chain: string[], projectRoot?: string): string;

package/dist/exports.js

@@ -0,0 +1,120 @@
+"use strict";
+/** Trace barrel re-exports to detect layer boundary bypasses. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBarrelBoundaryBypassEnabled = isBarrelBoundaryBypassEnabled;
+exports.collectBarrelLeaks = collectBarrelLeaks;
+exports.formatBarrelChain = formatBarrelChain;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const layers_1 = require("./layers");
+const parser_1 = require("./parser");
+function isBarrelBoundaryBypassEnabled(rules) {
+    if (!rules.enforceLayerBoundaries && !rules.enforceFeatureBoundaries) {
+        return false;
+    }
+    if (rules.noBarrelBoundaryBypass === false) {
+        return false;
+    }
+    return rules.noBarrelBoundaryBypass ?? true;
+}
+function collectBarrelLeaks(options) {
+    const visited = options.visited ?? new Set();
+    if (visited.has(options.barrelPath)) {
+        return [];
+    }
+    visited.add(options.barrelPath);
+    if (!fs.existsSync(options.barrelPath)) {
+        return [];
+    }
+    const source = fs.readFileSync(options.barrelPath, "utf-8");
+    const ast = (0, parser_1.parseTypeScript)(source, options.barrelPath);
+    const reexports = (0, parser_1.extractReexports)(ast);
+    const leaks = [];
+    for (const reexport of reexports) {
+        if (reexport.isTypeOnly) {
+            continue;
+        }
+        const resolved = options.resolver.resolve(reexport.from, options.barrelPath);
+        if (!resolved) {
+            continue;
+        }
+        const targetLayer = (0, layers_1.detectLayerFromPath)(resolved, options.architecture, options.projectRoot);
+        if (targetLayer &&
+            targetLayer !== options.importerLayer &&
+            !options.allowedLayers.has(targetLayer)) {
+            leaks.push({
+                leakedLayer: targetLayer,
+                reexportFile: resolved,
+                chain: [options.barrelPath, resolved],
+            });
+        }
+        const nested = collectBarrelLeaks({
+            ...options,
+            barrelPath: resolved,
+            visited,
+        });
+        leaks.push(...nested);
+    }
+    return dedupeLeaks(leaks);
+}
+function dedupeLeaks(leaks) {
+    const seen = new Set();
+    const unique = [];
+    for (const leak of leaks) {
+        const key = `${leak.leakedLayer}:${leak.reexportFile}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(leak);
+    }
+    return unique;
+}
+function formatBarrelChain(chain, projectRoot) {
+    return chain
+        .map((filePath) => formatProjectRelativePath(filePath, projectRoot))
+        .join(" → ");
+}
+function formatProjectRelativePath(filePath, projectRoot) {
+    if (!projectRoot) {
+        return filePath.replace(/\\/g, "/");
+    }
+    const relativePath = path.relative(projectRoot, filePath);
+    if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+        return relativePath.replace(/\\/g, "/");
+    }
+    return filePath.replace(/\\/g, "/");
+}

package/dist/index.d.ts

@@ -1,11 +1,7 @@
 /** Core rule engine types and abstractions. */
-export interface Violation {
-    file: string;
-    line: number;
-    column: number;
-    message: string;
-    rule: string;
-}
+import type { Violation } from "./violation";
+export type { Violation, ViolationContext } from "./violation";
+export { createViolationId, enrichViolation, enrichViolations } from "./violation";
 export interface ImportGraph {
     [filePath: string]: string[];
 }
@@ -33,7 +29,20 @@ export interface Rule {
     description: string;
     execute(context: RuleContext): RuleResult;
 }
+export interface LayerPatternConfig {
+    include?: string[];
+    exclude?: string[];
+}
+export interface PatternsConfig {
+    /** Base directory for pattern matching (relative to scan root). Default: "." */
+    root?: string;
+    /** Glob patterns skipped during scans (e.g. tests, mocks). */
+    ignore?: string[];
+    /** Per-layer include/exclude globs (relative to patterns.root). */
+    layers?: Record<string, LayerPatternConfig>;
+}
 export interface ArchitectureConfig {
+    patterns?: PatternsConfig;
     layers: Record<string, LayerConfig>;
     /** Layer folder names that receive React UI behavior rules. Defaults to `ui` when present. */
     uiLayers?: string[];
@@ -45,10 +54,14 @@ export interface ArchitectureConfig {
         /** @deprecated Use `enforceLayerBoundaries`. Kept for backward compatibility. */
         enforceFeatureBoundaries?: boolean;
         noCircularLayerDeps?: boolean;
+        /** Detect illegal layer access through barrel re-exports. Default: on when boundaries are enforced. */
+        noBarrelBoundaryBypass?: boolean;
     };
 }
 export interface LayerConfig {
     allowedImports: string[];
+    /** Folder paths or globs relative to the scan root (e.g. src/components, src/db/**). */
+    paths?: string[];
 }
 export declare class RuleEngine {
     private rules;
@@ -56,10 +69,15 @@ export declare class RuleEngine {
     executeRules(context: RuleContext): RuleResult;
     getRegisteredRules(): Rule[];
 }
-export { parseTypeScript, extractImports } from "./parser";
+export { parseTypeScript, extractImports, extractReexports } from "./parser";
+export type { ReexportDeclaration } from "./parser";
 export { loadArchitectureConfig, validateArchitectureConfig, findArchitectureConfig } from "./config";
 export { createImportResolver } from "./resolver";
 export type { ImportResolver } from "./resolver";
-export { detectLayerFromPath, fileBelongsToUiLayer, isLayerBoundaryEnforcementEnabled, resolveUiLayers, } from "./layers";
+export { countFilesMatchingLayers, detectLayerFromPath, fileBelongsToUiLayer, isLayerBoundaryEnforcementEnabled, resolveUiLayers, shouldIgnorePath, } from "./layers";
 export { discoverWorkspacePackages, resolveWorkspacePackageEntry } from "./workspace";
 export type { WorkspacePackage } from "./workspace";
+export { expandAffectedFiles, filterViolationsForDiff, findGitRoot, getChangedFiles, resolveDiffAffectedFiles, resolveDiffBaseRef, } from "./diff";
+export type { DiffScanOptions } from "./diff";
+export { collectBarrelLeaks, formatBarrelChain, isBarrelBoundaryBypassEnabled, } from "./exports";
+export type { BarrelLeak } from "./exports";

package/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 /** Core rule engine types and abstractions. */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveWorkspacePackageEntry = exports.discoverWorkspacePackages = exports.resolveUiLayers = exports.isLayerBoundaryEnforcementEnabled = exports.fileBelongsToUiLayer = exports.detectLayerFromPath = exports.createImportResolver = exports.findArchitectureConfig = exports.validateArchitectureConfig = exports.loadArchitectureConfig = exports.extractImports = exports.parseTypeScript = exports.RuleEngine = void 0;
+exports.isBarrelBoundaryBypassEnabled = exports.formatBarrelChain = exports.collectBarrelLeaks = exports.resolveDiffBaseRef = exports.resolveDiffAffectedFiles = exports.getChangedFiles = exports.findGitRoot = exports.filterViolationsForDiff = exports.expandAffectedFiles = exports.resolveWorkspacePackageEntry = exports.discoverWorkspacePackages = exports.shouldIgnorePath = exports.resolveUiLayers = exports.isLayerBoundaryEnforcementEnabled = exports.fileBelongsToUiLayer = exports.detectLayerFromPath = exports.countFilesMatchingLayers = exports.createImportResolver = exports.findArchitectureConfig = exports.validateArchitectureConfig = exports.loadArchitectureConfig = exports.extractReexports = exports.extractImports = exports.parseTypeScript = exports.RuleEngine = exports.enrichViolations = exports.enrichViolation = exports.createViolationId = void 0;
+var violation_1 = require("./violation");
+Object.defineProperty(exports, "createViolationId", { enumerable: true, get: function () { return violation_1.createViolationId; } });
+Object.defineProperty(exports, "enrichViolation", { enumerable: true, get: function () { return violation_1.enrichViolation; } });
+Object.defineProperty(exports, "enrichViolations", { enumerable: true, get: function () { return violation_1.enrichViolations; } });
 class RuleEngine {
     constructor() {
         this.rules = [];
@@ -28,6 +32,7 @@ exports.RuleEngine = RuleEngine;
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "parseTypeScript", { enumerable: true, get: function () { return parser_1.parseTypeScript; } });
 Object.defineProperty(exports, "extractImports", { enumerable: true, get: function () { return parser_1.extractImports; } });
+Object.defineProperty(exports, "extractReexports", { enumerable: true, get: function () { return parser_1.extractReexports; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "loadArchitectureConfig", { enumerable: true, get: function () { return config_1.loadArchitectureConfig; } });
 Object.defineProperty(exports, "validateArchitectureConfig", { enumerable: true, get: function () { return config_1.validateArchitectureConfig; } });
@@ -35,10 +40,23 @@ Object.defineProperty(exports, "findArchitectureConfig", { enumerable: true, get
 var resolver_1 = require("./resolver");
 Object.defineProperty(exports, "createImportResolver", { enumerable: true, get: function () { return resolver_1.createImportResolver; } });
 var layers_1 = require("./layers");
+Object.defineProperty(exports, "countFilesMatchingLayers", { enumerable: true, get: function () { return layers_1.countFilesMatchingLayers; } });
 Object.defineProperty(exports, "detectLayerFromPath", { enumerable: true, get: function () { return layers_1.detectLayerFromPath; } });
 Object.defineProperty(exports, "fileBelongsToUiLayer", { enumerable: true, get: function () { return layers_1.fileBelongsToUiLayer; } });
 Object.defineProperty(exports, "isLayerBoundaryEnforcementEnabled", { enumerable: true, get: function () { return layers_1.isLayerBoundaryEnforcementEnabled; } });
 Object.defineProperty(exports, "resolveUiLayers", { enumerable: true, get: function () { return layers_1.resolveUiLayers; } });
+Object.defineProperty(exports, "shouldIgnorePath", { enumerable: true, get: function () { return layers_1.shouldIgnorePath; } });
 var workspace_1 = require("./workspace");
 Object.defineProperty(exports, "discoverWorkspacePackages", { enumerable: true, get: function () { return workspace_1.discoverWorkspacePackages; } });
 Object.defineProperty(exports, "resolveWorkspacePackageEntry", { enumerable: true, get: function () { return workspace_1.resolveWorkspacePackageEntry; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "expandAffectedFiles", { enumerable: true, get: function () { return diff_1.expandAffectedFiles; } });
+Object.defineProperty(exports, "filterViolationsForDiff", { enumerable: true, get: function () { return diff_1.filterViolationsForDiff; } });
+Object.defineProperty(exports, "findGitRoot", { enumerable: true, get: function () { return diff_1.findGitRoot; } });
+Object.defineProperty(exports, "getChangedFiles", { enumerable: true, get: function () { return diff_1.getChangedFiles; } });
+Object.defineProperty(exports, "resolveDiffAffectedFiles", { enumerable: true, get: function () { return diff_1.resolveDiffAffectedFiles; } });
+Object.defineProperty(exports, "resolveDiffBaseRef", { enumerable: true, get: function () { return diff_1.resolveDiffBaseRef; } });
+var exports_1 = require("./exports");
+Object.defineProperty(exports, "collectBarrelLeaks", { enumerable: true, get: function () { return exports_1.collectBarrelLeaks; } });
+Object.defineProperty(exports, "formatBarrelChain", { enumerable: true, get: function () { return exports_1.formatBarrelChain; } });
+Object.defineProperty(exports, "isBarrelBoundaryBypassEnabled", { enumerable: true, get: function () { return exports_1.isBarrelBoundaryBypassEnabled; } });

package/dist/layers.d.ts

@@ -1,6 +1,8 @@
 /** Layer detection and UI targeting helpers shared across rule packs. */
-import { ArchitectureConfig, LayerConfig } from "./index";
-export declare function detectLayerFromPath(filePath: string, layers: Record<string, LayerConfig>): string | null;
+import { ArchitectureConfig } from "./index";
+export declare function detectLayerFromPath(filePath: string, architecture: ArchitectureConfig, projectRoot?: string): string | null;
+export declare function countFilesMatchingLayers(filePaths: string[], architecture: ArchitectureConfig, projectRoot: string): number;
+export declare function shouldIgnorePath(filePath: string, architecture: ArchitectureConfig, projectRoot: string): boolean;
 export declare function resolveUiLayers(config: ArchitectureConfig): Set<string>;
-export declare function fileBelongsToUiLayer(filePath: string, config: ArchitectureConfig): boolean;
+export declare function fileBelongsToUiLayer(filePath: string, config: ArchitectureConfig, projectRoot?: string): boolean;
 export declare function isLayerBoundaryEnforcementEnabled(rules: ArchitectureConfig["rules"]): boolean;

package/dist/layers.js

@@ -1,22 +1,110 @@
 "use strict";
 /** Layer detection and UI targeting helpers shared across rule packs. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectLayerFromPath = detectLayerFromPath;
+exports.countFilesMatchingLayers = countFilesMatchingLayers;
+exports.shouldIgnorePath = shouldIgnorePath;
 exports.resolveUiLayers = resolveUiLayers;
 exports.fileBelongsToUiLayer = fileBelongsToUiLayer;
 exports.isLayerBoundaryEnforcementEnabled = isLayerBoundaryEnforcementEnabled;
+const path = __importStar(require("path"));
 const DEFAULT_UI_LAYER = "ui";
-function detectLayerFromPath(filePath, layers) {
-    const normalizedPath = filePath.replace(/\\/g, "/");
-    const segments = normalizedPath.split("/").filter(Boolean);
-    const layerNames = new Set(Object.keys(layers));
+function detectLayerFromPath(filePath, architecture, projectRoot) {
+    const patternsRoot = resolvePatternsRoot(projectRoot, architecture.patterns);
+    const relativePath = projectRoot
+        ? normalizeRelativePath(patternsRoot, filePath)
+        : filePath.replace(/\\/g, "/");
+    const absoluteNormalized = filePath.replace(/\\/g, "/");
+    const layerPatterns = resolveLayerPatterns(architecture);
+    let bestPathMatch = null;
+    for (const [layerName, patternConfig] of Object.entries(layerPatterns)) {
+        if (patternConfig.include.length === 0) {
+            continue;
+        }
+        if (patternConfig.exclude.some((pattern) => pathMatchesPattern(relativePath, absoluteNormalized, pattern))) {
+            continue;
+        }
+        for (const pattern of patternConfig.include) {
+            if (pathMatchesPattern(relativePath, absoluteNormalized, pattern)) {
+                const specificity = pattern.length;
+                if (!bestPathMatch || specificity > bestPathMatch.specificity) {
+                    bestPathMatch = { layer: layerName, specificity };
+                }
+            }
+        }
+    }
+    if (bestPathMatch) {
+        return bestPathMatch.layer;
+    }
+    const layerNames = new Set(Object.keys(architecture.layers));
+    const segments = absoluteNormalized.split("/").filter(Boolean);
     for (const segment of segments) {
-        if (layerNames.has(segment)) {
-            return segment;
+        if (!layerNames.has(segment)) {
+            continue;
         }
+        const patternConfig = layerPatterns[segment];
+        if (patternConfig?.exclude.length) {
+            const excluded = patternConfig.exclude.some((pattern) => pathMatchesPattern(relativePath, absoluteNormalized, pattern));
+            if (excluded) {
+                continue;
+            }
+        }
+        return segment;
     }
     return null;
 }
+function countFilesMatchingLayers(filePaths, architecture, projectRoot) {
+    let count = 0;
+    for (const filePath of filePaths) {
+        if (detectLayerFromPath(filePath, architecture, projectRoot)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function shouldIgnorePath(filePath, architecture, projectRoot) {
+    const patterns = architecture.patterns?.ignore;
+    if (!patterns?.length) {
+        return false;
+    }
+    const patternsRoot = resolvePatternsRoot(projectRoot, architecture.patterns);
+    const relativePath = normalizeRelativePath(patternsRoot, filePath);
+    const absoluteNormalized = filePath.replace(/\\/g, "/");
+    return patterns.some((pattern) => pathMatchesPattern(relativePath, absoluteNormalized, pattern));
+}
 function resolveUiLayers(config) {
     if (config.uiLayers && config.uiLayers.length > 0) {
         return new Set(config.uiLayers);
@@ -26,14 +114,85 @@ function resolveUiLayers(config) {
     }
     return new Set();
 }
-function fileBelongsToUiLayer(filePath, config) {
+function fileBelongsToUiLayer(filePath, config, projectRoot) {
     const uiLayers = resolveUiLayers(config);
     if (uiLayers.size === 0) {
         return false;
     }
-    const layerName = detectLayerFromPath(filePath, config.layers);
+    const layerName = detectLayerFromPath(filePath, config, projectRoot);
     return layerName !== null && uiLayers.has(layerName);
 }
 function isLayerBoundaryEnforcementEnabled(rules) {
     return Boolean(rules.enforceLayerBoundaries || rules.enforceFeatureBoundaries);
 }
+function resolvePatternsRoot(projectRoot, patterns) {
+    if (!projectRoot) {
+        return ".";
+    }
+    const root = patterns?.root?.trim();
+    if (!root || root === ".") {
+        return projectRoot;
+    }
+    return path.resolve(projectRoot, root);
+}
+function resolveLayerPatterns(architecture) {
+    const resolved = {};
+    for (const layerName of Object.keys(architecture.layers)) {
+        resolved[layerName] = { include: [], exclude: [] };
+    }
+    if (architecture.patterns?.layers) {
+        for (const [layerName, patternConfig] of Object.entries(architecture.patterns.layers)) {
+            if (!resolved[layerName]) {
+                continue;
+            }
+            resolved[layerName].include.push(...(patternConfig.include ?? []).map(normalizePattern));
+            resolved[layerName].exclude.push(...(patternConfig.exclude ?? []).map(normalizePattern));
+        }
+    }
+    for (const [layerName, layerConfig] of Object.entries(architecture.layers)) {
+        if (!layerConfig.paths?.length) {
+            continue;
+        }
+        resolved[layerName].include.push(...layerConfig.paths.map(normalizePattern));
+    }
+    return resolved;
+}
+function normalizePattern(pattern) {
+    const trimmed = pattern.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (trimmed.includes("*")) {
+        return trimmed;
+    }
+    if (trimmed.includes("/")) {
+        return `${trimmed}/**`;
+    }
+    return trimmed;
+}
+function normalizeRelativePath(projectRoot, filePath) {
+    const relative = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+    if (!relative || relative.startsWith("..")) {
+        return filePath.replace(/\\/g, "/");
+    }
+    return relative;
+}
+function pathMatchesPattern(relativePath, absoluteNormalized, pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized.includes("*")) {
+        const regexSource = "^" +
+            normalized
+                .split("/")
+                .map((segment) => {
+                if (segment === "**") {
+                    return ".*";
+                }
+                return segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+            })
+                .join("/") +
+            "(/.*)?$";
+        return new RegExp(regexSource).test(relativePath);
+    }
+    if (normalized.includes("/")) {
+        return relativePath === normalized || relativePath.startsWith(`${normalized}/`);
+    }
+    const segments = absoluteNormalized.split("/").filter(Boolean);
+    return segments.includes(normalized);
+}

package/dist/parser.d.ts

@@ -3,3 +3,10 @@ import * as ts from "typescript";
 import { ImportInfo } from "./index";
 export declare function parseTypeScript(sourceCode: string, fileName: string): ts.SourceFile;
 export declare function extractImports(sourceFile: ts.SourceFile): ImportInfo[];
+export interface ReexportDeclaration {
+    from: string;
+    exportAll: boolean;
+    namedSpecifiers: string[];
+    isTypeOnly: boolean;
+}
+export declare function extractReexports(sourceFile: ts.SourceFile): ReexportDeclaration[];

package/dist/parser.js

@@ -36,6 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTypeScript = parseTypeScript;
 exports.extractImports = extractImports;
+exports.extractReexports = extractReexports;
 const ts = __importStar(require("typescript"));
 function parseTypeScript(sourceCode, fileName) {
     return ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
@@ -77,3 +78,39 @@ function extractImports(sourceFile) {
     visit(sourceFile);
     return imports;
 }
+function extractReexports(sourceFile) {
+    const reexports = [];
+    function visit(node) {
+        if (!ts.isExportDeclaration(node) || !node.moduleSpecifier) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        if (!ts.isStringLiteral(node.moduleSpecifier)) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        const namedSpecifiers = [];
+        let exportAll = false;
+        if (!node.exportClause) {
+            exportAll = true;
+        }
+        else if (ts.isNamespaceExport(node.exportClause)) {
+            exportAll = true;
+            namedSpecifiers.push(node.exportClause.name.text);
+        }
+        else if (ts.isNamedExports(node.exportClause)) {
+            for (const element of node.exportClause.elements) {
+                namedSpecifiers.push(element.name.text);
+            }
+        }
+        reexports.push({
+            from: node.moduleSpecifier.text,
+            exportAll,
+            namedSpecifiers,
+            isTypeOnly: node.isTypeOnly ?? false,
+        });
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return reexports;
+}

package/dist/violation.d.ts

@@ -0,0 +1,23 @@
+/** Violation helpers — stable IDs and enrichment for agent/CI output. */
+export interface ViolationContext {
+    sourceLayer?: string;
+    targetLayer?: string;
+    importPath?: string;
+    reexportChain?: string;
+}
+export interface Violation {
+    /** Stable hash for baselines, SARIF, and agent tooling. */
+    id?: string;
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    rule: string;
+    severity?: "error" | "warning";
+    /** Actionable repair hint for humans and agents. */
+    fix?: string;
+    context?: ViolationContext;
+}
+export declare function createViolationId(violation: Pick<Violation, "rule" | "file" | "line" | "column" | "message">): string;
+export declare function enrichViolation(violation: Violation): Violation;
+export declare function enrichViolations(violations: Violation[]): Violation[];

package/dist/violation.js

@@ -0,0 +1,60 @@
+"use strict";
+/** Violation helpers — stable IDs and enrichment for agent/CI output. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createViolationId = createViolationId;
+exports.enrichViolation = enrichViolation;
+exports.enrichViolations = enrichViolations;
+const crypto = __importStar(require("crypto"));
+function createViolationId(violation) {
+    const payload = [
+        violation.rule,
+        violation.file,
+        String(violation.line),
+        String(violation.column),
+        violation.message,
+    ].join("|");
+    return crypto.createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+function enrichViolation(violation) {
+    return {
+        ...violation,
+        id: violation.id ?? createViolationId(violation),
+        severity: violation.severity ?? "error",
+    };
+}
+function enrichViolations(violations) {
+    return violations.map(enrichViolation);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifesavertech/archguard-core",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Core rule engine for ArchGuard",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -b --force",
     "prepack": "npm run build",
     "build:test": "node -e \"require('fs').rmSync('dist-test',{recursive:true,force:true})\" && tsc -p tsconfig.test.json",
-    "test": "npm run build:test && node --test dist-test/index.test.js"
+    "test": "npm run build:test && node --test dist-test/index.test.js dist-test/diff.test.js dist-test/exports.test.js"
   },
   "dependencies": {
     "typescript": "^5.0.0",