@lifesavertech/archguard-core 2.0.0

package/README.md

@@ -0,0 +1,7 @@
+# @lifesavertech/archguard-core
+
+Core engine for ArchGuard: configuration loading, TypeScript parsing, import resolution, workspace discovery, and shared layer helpers.
+
+Most users should install `@lifesavertech/archguard-cli` rather than depending on this package directly.
+
+Documentation: [github.com/lindseystead/ArchGuard](https://github.com/lindseystead/ArchGuard)

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+/** Configuration loading and validation. */
+import { ArchitectureConfig } from "./index";
+export declare function loadArchitectureConfig(configPath: string): ArchitectureConfig;
+export declare function validateArchitectureConfig(config: unknown): ArchitectureConfig;
+export declare function findArchitectureConfig(startPath: string): string | null;

package/dist/config.js

@@ -0,0 +1,138 @@
+"use strict";
+/** Configuration loading and validation. */
+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.loadArchitectureConfig = loadArchitectureConfig;
+exports.validateArchitectureConfig = validateArchitectureConfig;
+exports.findArchitectureConfig = findArchitectureConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+function loadArchitectureConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Architecture config not found: ${configPath}`);
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    const parsed = (0, yaml_1.parse)(content);
+    return validateArchitectureConfig(parsed);
+}
+function validateArchitectureConfig(config) {
+    if (!config || typeof config !== "object") {
+        throw new Error("Invalid architecture config: must be an object");
+    }
+    const rawConfig = config;
+    if (!rawConfig.layers || typeof rawConfig.layers !== "object") {
+        throw new Error("Invalid architecture config: 'layers' must be an object");
+    }
+    const layers = {};
+    for (const [layerName, layerConfig] of Object.entries(rawConfig.layers)) {
+        if (!layerConfig || typeof layerConfig !== "object") {
+            throw new Error(`Invalid layer config for '${layerName}': must be an object`);
+        }
+        const layer = layerConfig;
+        if (!Array.isArray(layer.allowedImports)) {
+            throw new Error(`Invalid layer config for '${layerName}': 'allowedImports' must be an array`);
+        }
+        if (!layer.allowedImports.every((entry) => typeof entry === "string")) {
+            throw new Error(`Invalid layer config for '${layerName}': 'allowedImports' must contain strings`);
+        }
+        layers[layerName] = {
+            allowedImports: layer.allowedImports,
+        };
+    }
+    if (Object.keys(layers).length === 0) {
+        throw new Error("Invalid architecture config: at least one layer is required");
+    }
+    const layerNames = new Set(Object.keys(layers));
+    for (const [layerName, layerConfig] of Object.entries(layers)) {
+        for (const allowedLayer of layerConfig.allowedImports) {
+            if (!layerNames.has(allowedLayer)) {
+                throw new Error(`Invalid architecture config: layer '${layerName}' allows imports from undefined layer '${allowedLayer}'`);
+            }
+        }
+    }
+    let uiLayers;
+    if (rawConfig.uiLayers !== undefined) {
+        if (!Array.isArray(rawConfig.uiLayers)) {
+            throw new Error("Invalid architecture config: 'uiLayers' must be an array of layer names");
+        }
+        uiLayers = rawConfig.uiLayers.map((entry, index) => {
+            if (typeof entry !== "string" || entry.trim().length === 0) {
+                throw new Error(`Invalid architecture config: 'uiLayers[${index}]' must be a non-empty string`);
+            }
+            if (!layerNames.has(entry)) {
+                throw new Error(`Invalid architecture config: uiLayers references undefined layer '${entry}'`);
+            }
+            return entry;
+        });
+    }
+    const rules = (rawConfig.rules ?? {});
+    const unknownRuleKeys = Object.keys(rules).filter((key) => ![
+        "noBusinessLogicInComponents",
+        "noDataFetchingInUI",
+        "enforceLayerBoundaries",
+        "enforceFeatureBoundaries",
+        "noCircularLayerDeps",
+    ].includes(key));
+    if (unknownRuleKeys.length > 0) {
+        throw new Error(`Invalid architecture config: unknown rule(s): ${unknownRuleKeys.join(", ")}`);
+    }
+    const enforceLayerBoundaries = Boolean(rules.enforceLayerBoundaries ?? rules.enforceFeatureBoundaries);
+    return {
+        layers,
+        uiLayers,
+        rules: {
+            noBusinessLogicInComponents: Boolean(rules.noBusinessLogicInComponents),
+            noDataFetchingInUI: Boolean(rules.noDataFetchingInUI),
+            enforceLayerBoundaries,
+            enforceFeatureBoundaries: Boolean(rules.enforceFeatureBoundaries),
+            noCircularLayerDeps: Boolean(rules.noCircularLayerDeps),
+        },
+    };
+}
+function findArchitectureConfig(startPath) {
+    let currentPath = path.resolve(startPath);
+    while (true) {
+        const configPath = path.join(currentPath, "architecture.yaml");
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+        const parentPath = path.dirname(currentPath);
+        if (currentPath === parentPath) {
+            return null;
+        }
+        currentPath = parentPath;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+/** Core rule engine types and abstractions. */
+export interface Violation {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    rule: string;
+}
+export interface ImportGraph {
+    [filePath: string]: string[];
+}
+export interface RuleContext {
+    filePath: string;
+    sourceCode: string;
+    ast: any;
+    imports: ImportInfo[];
+    architecture: ArchitectureConfig;
+    importGraph?: ImportGraph;
+    projectRoot?: string;
+}
+export interface ImportInfo {
+    from: string;
+    specifiers: string[];
+    isTypeOnly: boolean;
+    resolvedPath?: string | null;
+}
+export interface RuleResult {
+    violations: Violation[];
+    passed: boolean;
+}
+export interface Rule {
+    name: string;
+    description: string;
+    execute(context: RuleContext): RuleResult;
+}
+export interface ArchitectureConfig {
+    layers: Record<string, LayerConfig>;
+    /** Layer folder names that receive React UI behavior rules. Defaults to `ui` when present. */
+    uiLayers?: string[];
+    rules: {
+        noBusinessLogicInComponents?: boolean;
+        noDataFetchingInUI?: boolean;
+        /** Preferred name for layer import boundary enforcement. */
+        enforceLayerBoundaries?: boolean;
+        /** @deprecated Use `enforceLayerBoundaries`. Kept for backward compatibility. */
+        enforceFeatureBoundaries?: boolean;
+        noCircularLayerDeps?: boolean;
+    };
+}
+export interface LayerConfig {
+    allowedImports: string[];
+}
+export declare class RuleEngine {
+    private rules;
+    registerRule(rule: Rule): void;
+    executeRules(context: RuleContext): RuleResult;
+    getRegisteredRules(): Rule[];
+}
+export { parseTypeScript, extractImports } 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 { discoverWorkspacePackages, resolveWorkspacePackageEntry } from "./workspace";
+export type { WorkspacePackage } from "./workspace";

package/dist/index.js

@@ -0,0 +1,44 @@
+"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;
+class RuleEngine {
+    constructor() {
+        this.rules = [];
+    }
+    registerRule(rule) {
+        this.rules.push(rule);
+    }
+    executeRules(context) {
+        const allViolations = [];
+        for (const rule of this.rules) {
+            const result = rule.execute(context);
+            allViolations.push(...result.violations);
+        }
+        return {
+            violations: allViolations,
+            passed: allViolations.length === 0,
+        };
+    }
+    getRegisteredRules() {
+        return [...this.rules];
+    }
+}
+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; } });
+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; } });
+Object.defineProperty(exports, "findArchitectureConfig", { enumerable: true, get: function () { return config_1.findArchitectureConfig; } });
+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, "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; } });
+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; } });

package/dist/layers.d.ts

@@ -0,0 +1,6 @@
+/** 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;
+export declare function resolveUiLayers(config: ArchitectureConfig): Set<string>;
+export declare function fileBelongsToUiLayer(filePath: string, config: ArchitectureConfig): boolean;
+export declare function isLayerBoundaryEnforcementEnabled(rules: ArchitectureConfig["rules"]): boolean;

package/dist/layers.js

@@ -0,0 +1,39 @@
+"use strict";
+/** Layer detection and UI targeting helpers shared across rule packs. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLayerFromPath = detectLayerFromPath;
+exports.resolveUiLayers = resolveUiLayers;
+exports.fileBelongsToUiLayer = fileBelongsToUiLayer;
+exports.isLayerBoundaryEnforcementEnabled = isLayerBoundaryEnforcementEnabled;
+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));
+    for (const segment of segments) {
+        if (layerNames.has(segment)) {
+            return segment;
+        }
+    }
+    return null;
+}
+function resolveUiLayers(config) {
+    if (config.uiLayers && config.uiLayers.length > 0) {
+        return new Set(config.uiLayers);
+    }
+    if (config.layers[DEFAULT_UI_LAYER]) {
+        return new Set([DEFAULT_UI_LAYER]);
+    }
+    return new Set();
+}
+function fileBelongsToUiLayer(filePath, config) {
+    const uiLayers = resolveUiLayers(config);
+    if (uiLayers.size === 0) {
+        return false;
+    }
+    const layerName = detectLayerFromPath(filePath, config.layers);
+    return layerName !== null && uiLayers.has(layerName);
+}
+function isLayerBoundaryEnforcementEnabled(rules) {
+    return Boolean(rules.enforceLayerBoundaries || rules.enforceFeatureBoundaries);
+}

package/dist/parser.d.ts

@@ -0,0 +1,5 @@
+/** TypeScript parsing helpers. */
+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[];

package/dist/parser.js

@@ -0,0 +1,79 @@
+"use strict";
+/** TypeScript parsing helpers. */
+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.parseTypeScript = parseTypeScript;
+exports.extractImports = extractImports;
+const ts = __importStar(require("typescript"));
+function parseTypeScript(sourceCode, fileName) {
+    return ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+function extractImports(sourceFile) {
+    const imports = [];
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                const from = moduleSpecifier.text;
+                const specifiers = [];
+                let isTypeOnly = false;
+                if (node.importClause) {
+                    isTypeOnly = node.importClause.isTypeOnly || false;
+                    if (node.importClause.namedBindings) {
+                        if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                            specifiers.push(node.importClause.namedBindings.name.text);
+                        }
+                        else if (ts.isNamedImports(node.importClause.namedBindings)) {
+                            for (const element of node.importClause.namedBindings.elements) {
+                                specifiers.push(element.name.text);
+                            }
+                        }
+                    }
+                    if (node.importClause.name) {
+                        specifiers.push(node.importClause.name.text);
+                    }
+                }
+                imports.push({
+                    from,
+                    specifiers,
+                    isTypeOnly,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return imports;
+}

package/dist/resolver.d.ts

@@ -0,0 +1,6 @@
+export interface ImportResolver {
+    projectRoot: string;
+    tsConfigPath: string | null;
+    resolve(importPath: string, fromFile: string): string | null;
+}
+export declare function createImportResolver(projectRoot: string): ImportResolver;

package/dist/resolver.js

@@ -0,0 +1,205 @@
+"use strict";
+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.createImportResolver = createImportResolver;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const workspace_1 = require("./workspace");
+function createImportResolver(projectRoot) {
+    const normalizedProjectRoot = path.resolve(projectRoot);
+    const tsConfigPath = findTypeScriptConfig(normalizedProjectRoot);
+    const compilerOptions = loadCompilerOptions(tsConfigPath);
+    const referencedProjects = collectReferencedProjects(tsConfigPath);
+    const workspacePackages = (0, workspace_1.discoverWorkspacePackages)(normalizedProjectRoot);
+    const moduleResolutionCache = ts.createModuleResolutionCache(normalizedProjectRoot, (value) => path.normalize(value), compilerOptions ?? {});
+    return {
+        projectRoot: normalizedProjectRoot,
+        tsConfigPath,
+        resolve(importPath, fromFile) {
+            if (isRelativeOrAbsoluteImport(importPath)) {
+                return resolveRelativeImport(importPath, fromFile, normalizedProjectRoot);
+            }
+            const workspaceMatch = resolveWorkspaceImport(importPath, workspacePackages, normalizedProjectRoot);
+            if (workspaceMatch) {
+                return workspaceMatch;
+            }
+            if (compilerOptions) {
+                const resolution = ts.resolveModuleName(importPath, fromFile, compilerOptions, ts.sys, moduleResolutionCache).resolvedModule;
+                if (resolution) {
+                    const resolved = normalizeResolvedPath(resolution.resolvedFileName, normalizedProjectRoot);
+                    if (resolved) {
+                        return resolved;
+                    }
+                }
+            }
+            for (const referencedProject of referencedProjects) {
+                const resolution = ts.resolveModuleName(importPath, fromFile, referencedProject.options, ts.sys, referencedProject.cache).resolvedModule;
+                if (resolution) {
+                    const resolved = normalizeResolvedPath(resolution.resolvedFileName, normalizedProjectRoot, true);
+                    if (resolved) {
+                        return resolved;
+                    }
+                }
+            }
+            return null;
+        },
+    };
+}
+function resolveWorkspaceImport(importPath, workspacePackages, projectRoot) {
+    const packageNames = Array.from(workspacePackages.keys()).sort((left, right) => right.length - left.length);
+    for (const packageName of packageNames) {
+        if (importPath === packageName || importPath.startsWith(`${packageName}/`)) {
+            const packageRoot = workspacePackages.get(packageName);
+            if (!packageRoot) {
+                continue;
+            }
+            return (0, workspace_1.resolveWorkspacePackageEntry)(packageRoot, importPath, projectRoot);
+        }
+    }
+    return null;
+}
+function collectReferencedProjects(tsConfigPath, visited = new Set()) {
+    if (!tsConfigPath || visited.has(tsConfigPath)) {
+        return [];
+    }
+    visited.add(tsConfigPath);
+    const readResult = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    if (readResult.error) {
+        return [];
+    }
+    const config = readResult.config;
+    if (!Array.isArray(config.references)) {
+        return [];
+    }
+    const projects = [];
+    const tsConfigDir = path.dirname(tsConfigPath);
+    for (const reference of config.references) {
+        if (!reference?.path) {
+            continue;
+        }
+        const referenceRoot = path.resolve(tsConfigDir, reference.path);
+        const referenceConfigPath = fs.existsSync(path.join(referenceRoot, "tsconfig.json"))
+            ? path.join(referenceRoot, "tsconfig.json")
+            : referenceRoot.endsWith(".json")
+                ? referenceRoot
+                : null;
+        if (!referenceConfigPath) {
+            continue;
+        }
+        const options = loadCompilerOptions(referenceConfigPath);
+        if (!options) {
+            continue;
+        }
+        projects.push({
+            rootDir: path.dirname(referenceConfigPath),
+            options,
+            cache: ts.createModuleResolutionCache(path.dirname(referenceConfigPath), (value) => path.normalize(value), options),
+        });
+        projects.push(...collectReferencedProjects(referenceConfigPath, visited));
+    }
+    return projects;
+}
+function findTypeScriptConfig(startPath) {
+    return ts.findConfigFile(startPath, ts.sys.fileExists, "tsconfig.json") ?? null;
+}
+function loadCompilerOptions(tsConfigPath) {
+    if (!tsConfigPath) {
+        return null;
+    }
+    const readResult = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    if (readResult.error) {
+        throw new Error(`Failed to read tsconfig: ${formatDiagnostic(readResult.error)}`);
+    }
+    const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, path.dirname(tsConfigPath), undefined, tsConfigPath);
+    const blockingDiagnostic = parsed.errors.find((diagnostic) => !isIgnorableConfigDiagnostic(diagnostic));
+    if (blockingDiagnostic) {
+        throw new Error(`Failed to parse tsconfig: ${formatDiagnostic(blockingDiagnostic)}`);
+    }
+    return parsed.options;
+}
+function isIgnorableConfigDiagnostic(diagnostic) {
+    return diagnostic.code === 18003;
+}
+function formatDiagnostic(diagnostic) {
+    return ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+function isRelativeOrAbsoluteImport(importPath) {
+    return importPath.startsWith(".") || importPath.startsWith("/");
+}
+function resolveRelativeImport(importPath, fromFile, projectRoot) {
+    return resolveFileCandidate(path.resolve(path.dirname(fromFile), importPath), projectRoot);
+}
+function resolveFileCandidate(candidatePath, projectRoot) {
+    const normalizedCandidate = path.resolve(candidatePath);
+    if (fs.existsSync(normalizedCandidate) && fs.statSync(normalizedCandidate).isFile()) {
+        return normalizeResolvedPath(normalizedCandidate, projectRoot);
+    }
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
+    for (const extension of extensions) {
+        const candidateWithExtension = normalizedCandidate + extension;
+        if (fs.existsSync(candidateWithExtension)) {
+            return normalizeResolvedPath(candidateWithExtension, projectRoot);
+        }
+    }
+    const indexExtensions = [
+        "/index.ts",
+        "/index.tsx",
+        "/index.js",
+        "/index.jsx",
+        "/index.d.ts",
+    ];
+    for (const extension of indexExtensions) {
+        const candidateWithIndex = normalizedCandidate + extension;
+        if (fs.existsSync(candidateWithIndex)) {
+            return normalizeResolvedPath(candidateWithIndex, projectRoot);
+        }
+    }
+    return null;
+}
+function normalizeResolvedPath(resolvedPath, projectRoot, allowOutsideProjectRoot = false) {
+    const normalizedPath = path.resolve(resolvedPath);
+    if (!allowOutsideProjectRoot && !isPathInsideRoot(normalizedPath, projectRoot)) {
+        return null;
+    }
+    if (normalizedPath.includes(`${path.sep}node_modules${path.sep}`)) {
+        return null;
+    }
+    return normalizedPath;
+}
+function isPathInsideRoot(targetPath, rootPath) {
+    const relativePath = path.relative(rootPath, targetPath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}

package/dist/workspace.d.ts

@@ -0,0 +1,7 @@
+/** Workspace package discovery for monorepo import resolution. */
+export interface WorkspacePackage {
+    name: string;
+    rootDir: string;
+}
+export declare function discoverWorkspacePackages(projectRoot: string): Map<string, string>;
+export declare function resolveWorkspacePackageEntry(packageRoot: string, importPath: string, projectRoot: string): string | null;

package/dist/workspace.js

@@ -0,0 +1,252 @@
+"use strict";
+/** Workspace package discovery for monorepo import resolution. */
+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.discoverWorkspacePackages = discoverWorkspacePackages;
+exports.resolveWorkspacePackageEntry = resolveWorkspacePackageEntry;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function discoverWorkspacePackages(projectRoot) {
+    const packages = new Map();
+    const workspaceRoots = findWorkspaceRoots(projectRoot);
+    for (const workspaceRoot of workspaceRoots) {
+        for (const packageInfo of listWorkspacePackages(workspaceRoot)) {
+            packages.set(packageInfo.name, packageInfo.rootDir);
+        }
+    }
+    return packages;
+}
+function findWorkspaceRoots(startPath) {
+    const roots = [];
+    let currentPath = path.resolve(startPath);
+    while (true) {
+        const packageJsonPath = path.join(currentPath, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                if (packageJson.workspaces) {
+                    roots.push(currentPath);
+                }
+            }
+            catch {
+                // Ignore malformed package.json files while walking parents.
+            }
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            break;
+        }
+        currentPath = parentPath;
+    }
+    return roots;
+}
+function listWorkspacePackages(workspaceRoot) {
+    const packageJsonPath = path.join(workspaceRoot, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return [];
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const patterns = normalizeWorkspacePatterns(packageJson.workspaces);
+    const discovered = new Map();
+    for (const pattern of patterns) {
+        for (const packageDir of expandWorkspacePattern(workspaceRoot, pattern)) {
+            const childPackageJsonPath = path.join(packageDir, "package.json");
+            if (!fs.existsSync(childPackageJsonPath)) {
+                continue;
+            }
+            try {
+                const childPackageJson = JSON.parse(fs.readFileSync(childPackageJsonPath, "utf-8"));
+                if (typeof childPackageJson.name === "string" && childPackageJson.name.length > 0) {
+                    discovered.set(childPackageJson.name, {
+                        name: childPackageJson.name,
+                        rootDir: packageDir,
+                    });
+                }
+            }
+            catch {
+                // Skip unreadable workspace packages.
+            }
+        }
+    }
+    return Array.from(discovered.values());
+}
+function normalizeWorkspacePatterns(workspaces) {
+    if (!workspaces) {
+        return [];
+    }
+    if (Array.isArray(workspaces)) {
+        return workspaces;
+    }
+    return workspaces.packages ?? [];
+}
+function expandWorkspacePattern(workspaceRoot, pattern) {
+    if (!pattern.includes("*")) {
+        const candidate = path.resolve(workspaceRoot, pattern);
+        return fs.existsSync(candidate) ? [candidate] : [];
+    }
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    const wildcardIndex = normalizedPattern.indexOf("*");
+    const prefix = normalizedPattern.slice(0, wildcardIndex);
+    const suffix = normalizedPattern.slice(wildcardIndex + 1);
+    const searchRoot = path.resolve(workspaceRoot, prefix);
+    if (!fs.existsSync(searchRoot)) {
+        return [];
+    }
+    const results = [];
+    walkForWorkspaceMatches(searchRoot, suffix, results);
+    return results;
+}
+function walkForWorkspaceMatches(currentDir, suffix, results) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) {
+            continue;
+        }
+        const fullPath = path.join(currentDir, entry.name);
+        const relativeSuffix = suffix.replace(/^\//, "");
+        if (relativeSuffix.length === 0) {
+            results.push(fullPath);
+            continue;
+        }
+        if (relativeSuffix.startsWith("*/")) {
+            walkForWorkspaceMatches(fullPath, relativeSuffix.slice(2), results);
+            continue;
+        }
+        if (relativeSuffix === "*") {
+            results.push(fullPath);
+            continue;
+        }
+        const nextSegment = relativeSuffix.split("/")[0];
+        if (entry.name === nextSegment) {
+            const remainingSuffix = relativeSuffix.slice(nextSegment.length);
+            if (remainingSuffix.length === 0 || remainingSuffix.startsWith("/")) {
+                walkForWorkspaceMatches(fullPath, remainingSuffix.replace(/^\//, ""), results);
+            }
+        }
+    }
+}
+function resolveWorkspacePackageEntry(packageRoot, importPath, projectRoot) {
+    const packageJsonPath = path.join(packageRoot, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const packageName = packageJson.name;
+    if (!packageName) {
+        return null;
+    }
+    let subpath;
+    if (importPath === packageName) {
+        subpath = undefined;
+    }
+    else if (importPath.startsWith(`${packageName}/`)) {
+        subpath = importPath.slice(packageName.length + 1);
+    }
+    else {
+        return null;
+    }
+    const entryPath = resolvePackageExportTarget(packageJson, subpath);
+    if (!entryPath) {
+        return null;
+    }
+    const resolvedCandidate = path.resolve(packageRoot, entryPath);
+    return resolveSourceFileCandidate(resolvedCandidate, projectRoot);
+}
+function resolvePackageExportTarget(packageJson, subpath) {
+    if (subpath && packageJson.exports && typeof packageJson.exports === "object") {
+        const exportKey = `./${subpath}`;
+        const exportValue = packageJson.exports[exportKey] ?? packageJson.exports[subpath];
+        const resolvedExport = pickExportTarget(exportValue);
+        if (resolvedExport) {
+            return resolvedExport;
+        }
+    }
+    if (!subpath) {
+        const exportRoot = pickExportTarget(packageJson.exports);
+        if (exportRoot) {
+            return exportRoot;
+        }
+        return packageJson.types ?? packageJson.module ?? packageJson.main ?? "index.ts";
+    }
+    return path.join(subpath, "index.ts");
+}
+function pickExportTarget(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const record = value;
+    const preferredKeys = ["types", "import", "default", "require"];
+    for (const key of preferredKeys) {
+        const candidate = record[key];
+        if (typeof candidate === "string") {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveSourceFileCandidate(candidatePath, projectRoot) {
+    const normalizedCandidate = path.resolve(candidatePath);
+    if (fs.existsSync(normalizedCandidate) && fs.statSync(normalizedCandidate).isFile()) {
+        return normalizePathInsideProject(normalizedCandidate, projectRoot);
+    }
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
+    for (const extension of extensions) {
+        const candidateWithExtension = normalizedCandidate + extension;
+        if (fs.existsSync(candidateWithExtension)) {
+            return normalizePathInsideProject(candidateWithExtension, projectRoot);
+        }
+    }
+    for (const extension of ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
+        const candidateWithIndex = normalizedCandidate + extension;
+        if (fs.existsSync(candidateWithIndex)) {
+            return normalizePathInsideProject(candidateWithIndex, projectRoot);
+        }
+    }
+    return null;
+}
+function normalizePathInsideProject(targetPath, projectRoot) {
+    const normalizedPath = path.resolve(targetPath);
+    const relativePath = path.relative(projectRoot, normalizedPath);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return normalizedPath;
+    }
+    if (normalizedPath.includes(`${path.sep}node_modules${path.sep}`)) {
+        return null;
+    }
+    return normalizedPath;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lifesavertech/archguard-core",
+  "version": "2.0.0",
+  "description": "Core rule engine for ArchGuard",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "archguard",
+    "architecture",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "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"
+  },
+  "dependencies": {
+    "typescript": "^5.0.0",
+    "yaml": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  },
+  "author": "Lindsey Stead",
+  "homepage": "https://github.com/lindseystead/ArchGuard#readme",
+  "bugs": {
+    "url": "https://github.com/lindseystead/ArchGuard/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lindseystead/ArchGuard.git",
+    "directory": "packages/core"
+  }
+}