@antoniocorraliza/foundry-arch-scanner 0.0.0-stage → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antonio Corraliza León
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,192 @@
-# Temporary Holding Version
+# 🔎 Foundry arch scanner
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An ultra-fast, static enterprise architecture analysis and governance engine for modern Angular applications.
+
+[![npm version](https://img.shields.io/npm/v/@antoniocorraliza/foundry-arch-scanner?color=a3e635&style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@antoniocorraliza/foundry-arch-scanner)
+[![Node.js](https://img.shields.io/badge/Node.js-18+-339933?style=for-the-badge&logo=nodedotjs)](#)
+[![Angular](https://img.shields.io/badge/Angular-19.2+-DD0031?style=for-the-badge&logo=angular)](#)
+[![License](https://img.shields.io/badge/License-Proprietary-0f172a?style=for-the-badge)](#license)
+
+> **[🚀 Explore the live application](https://foundry-sandbox.vercel.app/)**  
+> _Interactive execution, real-time component evaluation, and live technical specifications for the entire Foundry suite._
+
+## 🌐 Overview
+
+**Foundry arch scanner** is an enterprise-grade static code analysis engine designed to enforce clean architecture, modern reactivity, strict memory management in RxJS, and prevent performance bottlenecks in Angular applications.
+
+Built on top of `ts-morph`, it is highly optimized for CI/CD pipelines, providing ultra-fast, deep AST navigation and real-time generation of corporate audit reports in multiple formats (JSON, CSV, SARIF 2.1.0).
+
+## 🏗️ Key features & architecture design
+
+- **AST bnavigation & performance:** Leverages intelligent `WeakMap`-based caching and `Proxy` pattern acceleration to ensure amortized O(1) performance without V8 heap leaks, enabling lightning-fast scans even in massive enterprise monorepos.
+
+- **Zero-CFG Pragmatism:** Employs a hybrid approach combining local AST navigation and 1-hop type resolution, bypassing heavy Control Flow Graphs (CFG). This strikes the perfect balance between high-speed CI/CD execution and deep diagnostic capabilities.
+
+- **Enterprise quality gates:** Features a sophisticated statistical scoring engine (`ScoringEngine`) with configurable criticality thresholds capable of automatically blocking pipelines (`process.exit(1)`) upon architectural non-compliance.
+
+- **Multi-format reporting:** Natively generates structured corporate reports in **SARIF 2.1.0**, **JSON**, and **CSV** for comprehensive auditing and analytics.
+
+## 🔬 Core analysis domains & rules
+
+The scanner evaluates codebases across four specialized analytical blocks:
+
+### 1. RxJS & Memory Management
+
+- **Infinite stream leak detection:** Audits safe completion operators (e.g., `takeUntilDestroyed`) to prevent memory leaks in infinite observables.
+
+- **Subject lifecycle governance:** Detects uncompleted Subjects in root services that can persist eternally.
+
+- **Eternal context exclusion:** Intelligently bypasses long-lived contexts (like `AppComponent`) where subscriptions do not require teardown.
+
+### 2. Clean architecture & coupling
+
+- **Standalone governance:** Enforces structural limits (`maxDependencies`, `maxComponentLines`, `maxStandaloneImports`) to prevent monolithic "God Components".
+
+- **Domain isolation:** Detects domain leaks and unauthorized logic crossing boundaries.
+
+- **Strict singleton encapsulation:** Enforces the `ServiceSignalEncapsulationRule`, requiring public mutable state in global root services to be exposed safely via `.asReadonly()`.
+- **SSR Safety:** Validates Server-Side Rendering compliance (`HydrationSafetyRule`) by blocking unauthorized access to native browser globals.
+
+### 3. Angular signals & modern reactivity
+
+- **Computed purity strictness:** Validates absolute purity within `computed()`, flagging any side effects or mutations.
+
+- **Effect infinite loop prevention:** Statically detects circular dependency loops inside `effect()` blocks.
+
+- **Zone mixing detection:** Flags legacy manual change detection triggers (`detectChanges`, `markForCheck`) in modernized reactive zones.
+
+- **Migration suggestions:** Identifies legacy patterns and suggests modern primitive upgrades (`toSignal`, `resource`, `linkedSignal`).
+
+### 4. Optimization & performance
+
+- **Change detection strategy audit:** Enforces `MissingOnPushRule` to ensure UI components are not eagerly re-rendered.
+
+- **Event listener frequency:** Audits high-frequency DOM events bound via `@HostListener` that trigger excessive change detection cycles.
+
+- **Heavy initialization:** Flags expensive synchronous operations within class property initializers.
+
+## 🚀 Installation & usage
+
+The `foundry-arch-scanner` is distributed via NPM and can be executed directly or installed globally/locally within your Angular workspace.
+
+### Direct execution (npx)
+
+Execute the scanner directly against your Angular project path without prior installation:
+
+```bash
+npx @antoniocorraliza/foundry-arch-scanner ./src/app
+```
+
+### Global installation
+
+Install the scanner globally for system-wide availability:
+
+```bash
+npm install -g @antoniocorraliza/foundry-arch-scanner
+foundry-arch-scanner ./src/app
+```
+
+### Local workspace installation (Dev dependency)
+
+Install the scanner as a development dependency for CI/CD pipeline integration:
+
+```bash
+npm install -D @antoniocorraliza/foundry-arch-scanner
+npx foundry-arch-scanner ./src/app
+```
+
+### CI/CD pipeline flags
+
+Use the `--warn-only` flag to generate reports and calculate scores without intentionally blocking the pipeline (bypasses `process.exit(1)` on failure).
+
+```bash
+npx foundry-arch-scanner ./src/app --warn-only
+```
+
+## ⚙️ Configuration
+
+The engine relies on a centralized governance file (`foundry-arch-scanner.json`) located at the root of your Angular workspace. This file dictates the strict architectural thresholds, boundary rules, and CI/CD quality gates under which the application is audited.
+
+If the file is not present, the engine will fallback to its internal default enterprise thresholds.
+
+### Configuration File (`foundry-arch-scanner.json`)
+
+```json
+{
+  "architecture": {
+    "uiComponentPaths": ["src/app/shared/components/"],
+    "maxDependencies": 20,
+    "maxComponentLines": 500,
+    "allowedUiServices": [
+      "FoundryRouterService",
+      "FoundryDialogWindowService",
+      "NetworkStatusService",
+      "ThemeService",
+      "TranslationService",
+      "IconRegistryService",
+      "I18nService"
+    ],
+    "domainRoots": [],
+    "forbiddenGlobals": [
+      "window",
+      "document",
+      "localStorage",
+      "sessionStorage"
+    ],
+    "dataLayerSuffixes": ["Repository", "DataService", "ApiClient"],
+    "serviceSuffixes": ["Service", "Store", "Facade", "Repository"]
+  },
+  "qualityGate": {
+    "maxCriticalIssues": 0,
+    "minOverallScore": 90
+  }
+}
+```
+
+### Governance parameters breakdown
+
+The configuration schema is divided into two primary domains: **Architecture** and the **Quality gate**.
+
+- **`architecture.uiComponentPaths`**: Target directories monitored for strict UI component governance. Components inside these paths are heavily audited to ensure they implement `ChangeDetectionStrategy.OnPush` and do not contain leaked domain logic.
+
+- **`architecture.maxDependencies` & `architecture.maxComponentLines`**: Coupling thresholds and maximum size constraints designed to prevent the emergence of monolithic "God Components". Exceeding these limits triggers coupling warnings.
+
+- **`architecture.allowedUiServices`**: An explicit whitelist of acceptable services that can be injected into presentation layers or UI components. Any attempt to inject unauthorized services (e.g., business logic or HTTP repositories) will be flagged as a boundary leak.
+
+- **`architecture.forbiddenGlobals`**: Strict prohibition of native browser global objects. Accessing these globals directly without Angular's `DOCUMENT` token or `isPlatformBrowser` guards will result in a critical violation to guarantee strict Server-Side Rendering (SSR) safety and prevent memory leaks.
+
+- **`architecture.dataLayerSuffixes` & `architecture.serviceSuffixes`**: Naming conventions utilized by the AST engine to identify, isolate, and audit data layers, state stores, and singleton services (e.g., verifying that a `*Repository` does not manually subscribe to an observable).
+
+- **`qualityGate.maxCriticalIssues` & `qualityGate.minOverallScore`**: Execution thresholds that dictate the CI/CD pipeline blocking behavior. If the global audit grade drops below the defined minimum score (`minOverallScore`), or if the total number of critical issues exceeds `maxCriticalIssues`, the scanner will intentionally halt the pipeline with `process.exit(1)`.
+
+## 🤫 Developer suppression layer
+
+In scenarios where an architectural exception is necessary, developers can selectively suppress rules using inline control comments.
+
+Suppress a rule on the same line:
+
+```ts
+// arch-scanner-disable architecture-direct-dom-manipulation
+const element = this.el.nativeElement;
+```
+
+Suppress a rule on the next line:
+
+```ts
+// arch-scanner-disable-next-line rxjs-memory-leak
+this.infiniteStream$.subscribe();
+```
+
+## 📦 Peer dependencies
+
+This suite is built on top of the latest Angular features and Node environments. Make sure your environment satisfies the following:
+
+| PACKAGE        | REQ. VERSION     | PURPOSE IN THE SUITE                                     |
+| :------------- | :--------------- | :------------------------------------------------------- |
+| **Node.js**    | `v18.13+ / v20+` | Compatible with the LTS versions required by Angular 19. |
+| **TypeScript** | `>=5.4.0`        | Required for AST compilation and parsing.                |
+| **Angular**    | `>=19.0.0`       | Required for modern reactivity and signals architecture. |
+
+## ⚖️ License
+
+Property of **Antonio Corraliza León** as part of the Foundry development suite. All rights reserved.

package/dist/analyzers/architecture/clean-architecture.analyzer.js

@@ -0,0 +1,68 @@
+import { PresentationLeakRule } from "./rules/presentation-leak.rule.js";
+import { GodComponentRule } from "./rules/god-component.rule.js";
+import { DirectDomManipulationRule } from "./rules/direct-dom-manipulation.rule.js";
+import { UiComponentLeakRule } from "./rules/ui-component-leak.rule.js";
+import { BoundaryLeakRule } from "./rules/boundary-leak.rule.js";
+import { HydrationSafetyRule } from "./rules/hydration-safety.rule.js";
+import { DataLayerGovernanceRule } from "./rules/data-layer-governance.rule.js";
+import { ScoringEngine } from "../../scoring/scoring.engine.js";
+import { dimText, whiteText, successText, warningText, errorText, cyanText, formatStatus } from "../../shared/constants/brand.constants.js";
+import { CircularDependencyRule } from "./rules/circular-dependency.rule.js";
+import { DATA_LAYER_SUFFIXES, FORBIDDEN_GLOBALS_LIST, SERVICE_SUFFIXES } from "../../shared/constants/architecture.constants.js";
+import { SuppressionHandler } from "../../core/suppression.handler.js";
+import { ServiceSignalEncapsulationRule } from "./rules/service-signal-encapsulation.rule.js";
+export class CleanArchitectureAnalyzer {
+    scoringEngine = new ScoringEngine();
+    projectRules = [new CircularDependencyRule()];
+    fileRules;
+    classRules = [];
+    constructor(scannerConfig) {
+        const ssrEnabled = scannerConfig.architecture.ssrEnabled ?? false;
+        this.fileRules = [new BoundaryLeakRule(scannerConfig.architecture.domainRoots)];
+        this.classRules = [
+            new PresentationLeakRule(),
+            new GodComponentRule(scannerConfig.architecture.maxDependencies, scannerConfig.architecture.maxComponentLines, scannerConfig.architecture.maxStandaloneImports ?? 10),
+            new DirectDomManipulationRule(),
+            new UiComponentLeakRule(scannerConfig.architecture.uiComponentPaths, scannerConfig.architecture.allowedUiServices),
+            new HydrationSafetyRule(ssrEnabled, scannerConfig.architecture.forbiddenGlobals ?? FORBIDDEN_GLOBALS_LIST),
+            new DataLayerGovernanceRule(scannerConfig.architecture.dataLayerSuffixes ?? DATA_LAYER_SUFFIXES),
+            new ServiceSignalEncapsulationRule(scannerConfig.architecture.serviceSuffixes ?? SERVICE_SUFFIXES)
+        ];
+    }
+    analyzeSourceFiles(sourceFiles, scanContext) {
+        console.log(`    ▸ ${cyanText('clean architecture & coupling')}`);
+        let discoveredIssues = [];
+        this.projectRules.forEach((rule) => discoveredIssues.push(...rule.check(sourceFiles, scanContext)));
+        sourceFiles.forEach((sourceFile) => {
+            const filePath = sourceFile.getFilePath().replace(/\\/g, '/');
+            this.fileRules.forEach((rule) => discoveredIssues.push(...rule.check(sourceFile, scanContext)));
+            const classesInFile = sourceFile.getClasses();
+            classesInFile.forEach((classDeclaration) => {
+                const cachedClass = scanContext.applyAstCacheProxy(classDeclaration);
+                const className = cachedClass.getName() || 'AnonymousClass';
+                this.classRules.forEach((rule) => discoveredIssues.push(...rule.check(cachedClass, filePath, className, scanContext)));
+            });
+        });
+        discoveredIssues = SuppressionHandler.filterSuppressedIssues(discoveredIssues, sourceFiles);
+        const blockScore = this.scoringEngine.evaluateBlock('Clean architecture & coupling', discoveredIssues, sourceFiles.length);
+        this.printExecutionReport(discoveredIssues);
+        return { issues: discoveredIssues, blockScore };
+    }
+    printExecutionReport(issues) {
+        if (issues.length === 0) {
+            console.log(`        ${successText(formatStatus('[SUCCESS]'))}${whiteText('No architectural boundary violations detected.')}`);
+            console.log('');
+        }
+        else {
+            issues.forEach(issue => {
+                const severityHeader = issue.severity === 'CRITICAL' ? errorText(formatStatus(`[${issue.severity}]`)) : issue.severity === 'WARNING' ? warningText(formatStatus(`[${issue.severity}]`)) : cyanText(formatStatus(`[${issue.severity}]`));
+                console.log(`        ${severityHeader}${whiteText.bold(issue.ruleId)}`);
+                console.log(`            ${dimText('File:    ')} ${whiteText(issue.filePath)}`);
+                console.log(`            ${dimText('Line:    ')} ${whiteText(issue.line.toString())}`);
+                console.log(`            ${dimText('Context: ')} ${whiteText(issue.className)}`);
+                console.log(`            ${dimText('Reason:  ')} ${whiteText(issue.message)}`);
+                console.log('');
+            });
+        }
+    }
+}

package/dist/analyzers/architecture/rules/boundary-leak.rule.js

@@ -0,0 +1,49 @@
+import { SyntaxKind } from "ts-morph";
+export class BoundaryLeakRule {
+    domainRoots;
+    constructor(domainRoots) {
+        this.domainRoots = domainRoots;
+    }
+    check(sourceFile, scanContext) {
+        const discoveredIssues = [];
+        const filePath = sourceFile.getFilePath().replace(/\\/g, '/');
+        const className = sourceFile.getClasses()[0]?.getName() || 'Global file';
+        const pathParts = filePath.split('/');
+        const currentDomain = this.extractDomain(pathParts);
+        if (!currentDomain)
+            return [];
+        const imports = sourceFile.getDescendantsOfKind(SyntaxKind.ImportDeclaration);
+        imports.forEach((importDeclaration) => {
+            const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+            if (moduleSpecifier.includes('index') || moduleSpecifier.includes('public-api'))
+                return;
+            const importedFile = importDeclaration.getModuleSpecifierSourceFile();
+            if (importedFile) {
+                const importedPath = importedFile.getFilePath().replace(/\\/g, '/');
+                if (importedPath.includes('node_modules') || importedPath.includes('shared') || importedPath.endsWith('/index.ts') || importedPath.endsWith('/public-api.ts'))
+                    return;
+                const importedParts = importedPath.split('/');
+                const importedDomain = this.extractDomain(importedParts);
+                if (!importedDomain || currentDomain === importedDomain)
+                    return;
+                discoveredIssues.push({
+                    ruleId: 'architecture-boundary-leak',
+                    severity: 'WARNING',
+                    message: `Deep domain boundary leak detected: '${currentDomain}' is illegally importing internal files from '${importedDomain}'. Modules should communicate through public APIs (index.ts) rather than deep relative imports.`,
+                    filePath,
+                    className,
+                    line: importDeclaration.getStartLineNumber()
+                });
+            }
+        });
+        return discoveredIssues;
+    }
+    extractDomain(pathParts) {
+        for (const root of this.domainRoots) {
+            const index = pathParts.indexOf(root);
+            if (index !== -1 && pathParts.length > index + 2)
+                return pathParts[index + 1];
+        }
+        return null;
+    }
+}

package/dist/analyzers/architecture/rules/circular-dependency.rule.js

@@ -0,0 +1,63 @@
+export class CircularDependencyRule {
+    check(sourceFiles, scanContext) {
+        const graph = new Map();
+        const fileMap = new Map();
+        sourceFiles.forEach((sourceFile) => {
+            const filePath = sourceFile.getFilePath().replace(/\\/g, '/');
+            fileMap.set(filePath, sourceFile);
+            if (!graph.has(filePath))
+                graph.set(filePath, []);
+            const imports = sourceFile.getImportDeclarations();
+            imports.forEach((imp) => {
+                const importedFile = imp.getModuleSpecifierSourceFile();
+                if (importedFile) {
+                    const importedPath = importedFile.getFilePath().replace(/\\/g, '/');
+                    if (!importedPath.includes('node_modules') && !importedPath.includes('/dist/') && !importedPath.includes('/.angular/'))
+                        graph.get(filePath).push(importedPath);
+                }
+            });
+        });
+        const discoveredIssues = [];
+        const visited = new Map();
+        const pathTracker = [];
+        const reportedCycles = [];
+        const depthFirstSearch = (node) => {
+            visited.set(node, 1);
+            pathTracker.push(node);
+            const neighbors = graph.get(node) || [];
+            for (const neighbor of neighbors) {
+                const state = visited.get(neighbor) || 0;
+                if (state === 1) {
+                    const cycleStartIndex = pathTracker.indexOf(neighbor);
+                    const cyclePath = pathTracker.slice(cycleStartIndex);
+                    cyclePath.push(neighbor);
+                    const cycleKey = [...cyclePath].sort().join('->');
+                    if (!reportedCycles.includes(cycleKey)) {
+                        reportedCycles.push(cycleKey);
+                        const sourceFile = fileMap.get(node);
+                        const className = sourceFile?.getClasses()[0]?.getName() || 'ModuleGraphContext';
+                        const shortNames = cyclePath.map((path) => path.split('/').pop()).join(' -> ');
+                        discoveredIssues.push({
+                            ruleId: 'architecture-circular-dependency',
+                            severity: 'CRITICAL',
+                            message: `Circular dependency chain detected: [${shortNames}]. This breaks Angular's initialization order and causes silent DI initialization bugs.`,
+                            filePath: node,
+                            className,
+                            line: 1
+                        });
+                    }
+                }
+                else if (state === 0) {
+                    depthFirstSearch(neighbor);
+                }
+            }
+            pathTracker.pop();
+            visited.set(node, 2);
+        };
+        for (const node of graph.keys()) {
+            if ((visited.get(node) || 0) === 0)
+                depthFirstSearch(node);
+        }
+        return discoveredIssues;
+    }
+}

package/dist/analyzers/architecture/rules/data-layer-governance.rule.js

@@ -0,0 +1,33 @@
+import { SyntaxKind } from "ts-morph";
+export class DataLayerGovernanceRule {
+    dataLayerSuffixes;
+    constructor(dataLayerSuffixes) {
+        this.dataLayerSuffixes = dataLayerSuffixes;
+    }
+    check(classDeclaration, filePath, className, scanContext) {
+        if (!classDeclaration)
+            return [];
+        const isDataLayerClass = this.dataLayerSuffixes.some(suffix => className.endsWith(suffix));
+        if (!isDataLayerClass)
+            return [];
+        const discoveredIssues = [];
+        const callExpressions = classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression);
+        callExpressions.forEach((call) => {
+            const expression = call.getExpression();
+            if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+                const propertyAccess = expression;
+                if (propertyAccess.getName() === 'subscribe') {
+                    discoveredIssues.push({
+                        ruleId: 'architecture-data-layer-governance',
+                        severity: 'CRITICAL',
+                        message: `An isolated side effect has been detected. Data classes ('${className}') must not call '.subscribe()'. Return pure streams (Observables/Signals) and delegate subscription and side effects to UI components or state stores.`,
+                        filePath,
+                        className,
+                        line: call.getStartLineNumber()
+                    });
+                }
+            }
+        });
+        return discoveredIssues;
+    }
+}

package/dist/analyzers/architecture/rules/direct-dom-manipulation.rule.js

@@ -0,0 +1,29 @@
+import { SyntaxKind } from "ts-morph";
+export class DirectDomManipulationRule {
+    check(classDeclaration, filePath, className, scanContext) {
+        if (!classDeclaration)
+            return [];
+        const discoveredIssues = [];
+        const propertyAccesses = classDeclaration.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+        propertyAccesses.forEach((access) => {
+            if (access.getName() === 'nativeElement') {
+                let isElementRef = false;
+                const typeText = scanContext.getTypeTextSafe(access.getExpression(), className);
+                if (typeText.includes('ElementRef'))
+                    isElementRef = true;
+                const parent = access.getParent();
+                if (isElementRef && parent && parent.getKind() === SyntaxKind.PropertyAccessExpression) {
+                    discoveredIssues.push({
+                        ruleId: 'architecture-direct-dom-manipulation',
+                        severity: 'CRITICAL',
+                        message: `Direct DOM manipulation detected via 'nativeElement.${parent.asKind(SyntaxKind.PropertyAccessExpression)?.getName()}'. Use Angular's 'Renderer2' or HostBindings.`,
+                        filePath,
+                        className,
+                        line: access.getStartLineNumber()
+                    });
+                }
+            }
+        });
+        return discoveredIssues;
+    }
+}

package/dist/analyzers/architecture/rules/god-component.rule.js

@@ -0,0 +1,72 @@
+import { SyntaxKind } from "ts-morph";
+export class GodComponentRule {
+    maxDependencies;
+    maxLines;
+    maxStandaloneImports;
+    constructor(maxDependencies, maxLines, maxStandaloneImports) {
+        this.maxDependencies = maxDependencies;
+        this.maxLines = maxLines;
+        this.maxStandaloneImports = maxStandaloneImports;
+    }
+    check(classDeclaration, filePath, className, scanContext) {
+        if (!classDeclaration)
+            return [];
+        const componentDecorator = classDeclaration.getDecorator('Component');
+        if (!componentDecorator)
+            return [];
+        const discoveredIssues = [];
+        let dependencyCount = 0;
+        let maxCtorParams = 0;
+        classDeclaration.getConstructors().forEach((ctor) => {
+            if (ctor.getParameters().length > maxCtorParams)
+                maxCtorParams = ctor.getParameters().length;
+        });
+        dependencyCount += maxCtorParams;
+        const injectCalls = classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === 'inject');
+        dependencyCount += injectCalls.length;
+        if (dependencyCount > this.maxDependencies) {
+            discoveredIssues.push({
+                ruleId: 'architecture-god-component-dependencies',
+                severity: 'WARNING',
+                message: `Excessive coupling: Component injects ${dependencyCount} dependencies (Max allowed: ${this.maxDependencies}).`,
+                filePath,
+                className,
+                line: classDeclaration.getStartLineNumber()
+            });
+        }
+        const totalLines = classDeclaration.getEndLineNumber() - classDeclaration.getStartLineNumber();
+        if (totalLines > this.maxLines) {
+            discoveredIssues.push({
+                ruleId: 'architecture-god-component-size',
+                severity: 'WARNING',
+                message: `Oversized component: Class spans ${totalLines} lines (Max allowed: ${this.maxLines}).`,
+                filePath,
+                className,
+                line: classDeclaration.getStartLineNumber()
+            });
+        }
+        const decoratorArgs = componentDecorator.getArguments();
+        if (decoratorArgs.length > 0 && decoratorArgs[0].getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const config = decoratorArgs[0];
+            const importsProperty = config.getProperty('imports');
+            if (importsProperty && importsProperty.getKind() === SyntaxKind.PropertyAssignment) {
+                const initializer = importsProperty.getInitializer();
+                if (initializer && initializer.getKind() === SyntaxKind.ArrayLiteralExpression) {
+                    const importsArray = initializer;
+                    const elementsCount = importsArray.getElements().length;
+                    if (elementsCount > this.maxStandaloneImports) {
+                        discoveredIssues.push({
+                            ruleId: 'architecture-god-component-standalone-imports',
+                            severity: 'WARNING',
+                            message: `Coupling god component: The Standalone component directly imports ${elementsCount} modules/components in its metadata (Limit: ${this.maxStandaloneImports}). Consider refactoring by grouping imports into shared modules or splitting the component responsibilities.`,
+                            filePath,
+                            className,
+                            line: importsProperty.getStartLineNumber()
+                        });
+                    }
+                }
+            }
+        }
+        return discoveredIssues;
+    }
+}

package/dist/analyzers/architecture/rules/hydration-safety.rule.js

@@ -0,0 +1,79 @@
+import { SyntaxKind, Node } from "ts-morph";
+import { SSR_SAFE_HOOKS } from "../../../shared/constants/architecture.constants.js";
+export class HydrationSafetyRule {
+    ssrEnabled;
+    forbiddenGlobals;
+    constructor(ssrEnabled, forbiddenGlobals) {
+        this.ssrEnabled = ssrEnabled;
+        this.forbiddenGlobals = forbiddenGlobals;
+    }
+    check(classDeclaration, filePath, className, scanContext) {
+        if (!this.ssrEnabled || !classDeclaration)
+            return [];
+        const discoveredIssues = [];
+        const identifiers = classDeclaration.getDescendantsOfKind(SyntaxKind.Identifier);
+        identifiers.forEach((identifier) => {
+            const text = identifier.getText();
+            if (this.forbiddenGlobals.includes(text)) {
+                const parent = identifier.getParent();
+                if (parent) {
+                    const kind = parent.getKind();
+                    if (kind === SyntaxKind.PropertyDeclaration ||
+                        kind === SyntaxKind.MethodDeclaration ||
+                        kind === SyntaxKind.Parameter ||
+                        (kind === SyntaxKind.VariableDeclaration && parent.getNameNode() === identifier)) {
+                        return;
+                    }
+                    if (kind === SyntaxKind.PropertyAccessExpression) {
+                        const propertyAccess = parent;
+                        const expressionText = propertyAccess.getExpression().getText();
+                        if (propertyAccess.getNameNode() === identifier && expressionText !== 'globalThis' && expressionText !== 'window')
+                            return;
+                    }
+                }
+                if (this.isProtectedBySsrGuardOrHook(identifier, classDeclaration))
+                    return;
+                discoveredIssues.push({
+                    ruleId: 'hydration-safety-global-access',
+                    severity: 'CRITICAL',
+                    message: `Direct access to the global browser API ('${text}') detected without validation. This will cause memory leaks or fatal errors in SSR (Server-Side Rendering). Use Angular's 'DOCUMENT' token, 'afterNextRender', or wrap the code with 'isPlatformBrowser'.`,
+                    filePath,
+                    className,
+                    line: identifier.getStartLineNumber()
+                });
+            }
+        });
+        return discoveredIssues.filter((issue, index, self) => index === self.findIndex((token) => token.line === issue.line && token.message === issue.message));
+    }
+    isProtectedBySsrGuardOrHook(identifier, classDeclaration) {
+        let current = identifier.getParent();
+        while (current && current !== classDeclaration) {
+            if (Node.isCallExpression(current)) {
+                const callerName = current.getExpression().getText();
+                if (SSR_SAFE_HOOKS.includes(callerName))
+                    return true;
+            }
+            if (Node.isIfStatement(current)) {
+                const conditionText = current.getExpression().getText();
+                if (conditionText.includes('isPlatformBrowser') && !conditionText.trim().startsWith('!')) {
+                    if (current.getThenStatement().containsRange(identifier.getPos(), identifier.getEnd()))
+                        return true;
+                }
+            }
+            if (Node.isMethodDeclaration(current) || Node.isConstructorDeclaration(current) || Node.isFunctionExpression(current) || Node.isArrowFunction(current)) {
+                const ifStatements = current.getDescendantsOfKind(SyntaxKind.IfStatement);
+                const hasEarlyReturnGuard = ifStatements.some((ifStatement) => {
+                    const condition = ifStatement.getExpression().getText().trim();
+                    const thenText = ifStatement.getThenStatement().getText();
+                    const isNegatedBrowserCheck = condition.startsWith('!') && condition.includes('isPlatformBrowser');
+                    const hasReturn = thenText.includes('return');
+                    return isNegatedBrowserCheck && hasReturn && ifStatement.getEnd() < identifier.getPos();
+                });
+                if (hasEarlyReturnGuard)
+                    return true;
+            }
+            current = current.getParent();
+        }
+        return false;
+    }
+}

package/dist/analyzers/architecture/rules/presentation-leak.rule.js

@@ -0,0 +1,43 @@
+import { SyntaxKind } from "ts-morph";
+export class PresentationLeakRule {
+    check(classDeclaration, filePath, className, scanContext) {
+        if (!classDeclaration)
+            return [];
+        const isComponent = classDeclaration.getDecorator('Component');
+        if (!isComponent)
+            return [];
+        let hasHttpClient = false;
+        let violationLine = classDeclaration.getStartLineNumber();
+        const constructors = classDeclaration.getConstructors();
+        constructors.forEach((ctor) => {
+            ctor.getParameters().forEach((parameter) => {
+                const sourcePath = scanContext.getSymbolSourceSafe(parameter, className);
+                if (sourcePath.includes('@angular/common/http')) {
+                    hasHttpClient = true;
+                    violationLine = parameter.getStartLineNumber();
+                }
+            });
+        });
+        const callExpressions = classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression);
+        callExpressions.forEach((call) => {
+            if (call.getExpression().getText() === 'inject') {
+                const sourcePath = scanContext.getSymbolSourceSafe(call, className);
+                if (sourcePath.includes('@angular/common/http')) {
+                    hasHttpClient = true;
+                    violationLine = call.getStartLineNumber();
+                }
+            }
+        });
+        if (hasHttpClient) {
+            return [{
+                    ruleId: 'architecture-presentation-leak',
+                    severity: 'CRITICAL',
+                    message: `Direct '@angular/common/http' injection detected in UI Component. Network requests must be strictly delegated to Services or Repositories.`,
+                    filePath,
+                    className,
+                    line: violationLine,
+                }];
+        }
+        return [];
+    }
+}