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

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,265 @@
-# 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)
+
+## 🌐 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.
+
+## 📊 Architecture scoring engine & quality gates
+
+The **Foundry arch scanner** engine goes beyond simple vulnerability detection; it implements a statistical and deterministic model designed to quantify technical debt and evaluate the structural health of Angular applications. This approach allows Enterprise teams to establish strict, automated, and measurable **quality gates** in their continuous integration (CI/CD) cycles.
+
+The internal mechanics of the _scoring engine_ for calculating architectural metrics are detailed below.
+
+### 1. Violation severity weighting
+
+Each violation detected in the source code is classified and penalized based on its direct impact on system stability, performance, or maintainability.
+
+| Severity     | Weight (Points) | Architectural Criterion                                                                                                        |
+| ------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| **CRITICAL** | $10$            | Severe violations (e.g., memory leaks, uncontrolled state mutations, circular dependencies). Potential system blockage.        |
+| **WARNING**  | $3$             | Anti-patterns and excessive coupling. They don't break the app immediately but generate significant short-term technical debt. |
+| **INFO**     | $1$             | Refactoring opportunities and minor deviations from code conventions (e.g., missing use of modern primitives).                 |
+
+### 2. Defect density calculation
+
+To ensure fair evaluations regardless of repository size, the engine calculates a **defect density** for each analytical block.
+
+To prevent a single error from disproportionately penalizing isolated components or very small projects, the engine implements a smoothing threshold (`SMALL_PROJECT_SMOOTHING_THRESHOLD = 15`). This ensures that the minimum divisor of evaluated files is always $15$.
+
+$$
+\text{Defect density} = \frac{\sum \text{Weights}}{\max(\text{Scanned files}, 15)}
+$$
+
+### 3. Block score formula
+
+Each analytical block starts from a base score of 100 perfect points. A penalty proportional to the defect density multiplied by a strict severity factor (`DENSITY_PENALTY_MULTIPLIER = 15`) is applied. The final value is rounded and floored to avoid negative scores.
+
+$$
+\text{Block score} = \max\left(0, \text{round}\left(100 - (\text{Defect density} \times 15)\right)\right)
+$$
+
+### 4. Grade assignment
+
+The obtained numeric score is translated into a standardized letter grade, providing an immediate reading of the project's risk level:
+
+- **A (**$\ge 90$ **points):** Excellent architectural compliance. Clean, reactive, and highly optimized code.
+
+- **B (**$\ge 80$ **points):** Good structural condition with minor observations.
+
+- **C (**$\ge 70$ **points):** Moderate warnings. Technical debt detected that should be scheduled for refactoring.
+
+- **D (**$\ge 60$ **points):** Significant architectural risk. Strongly discouraged practices present in the code.
+
+- **F (**$< 60$ **points):** Critical non-compliance. Project integrity is compromised.
+
+### 5. Overall project score
+
+The overall state of the application is determined by the strict arithmetic mean of the scores obtained in the four analysis domains:
+
+1. RxJS & Memory management
+
+2. Clean architecture & Coupling
+
+3. Angular signals & Modern reactivity
+
+4. Optimization & Performance
+
+$$
+\text{Overall score} = \frac{\text{Score}_{\text{RxJS}} + \text{Score}_{\text{Arch}} + \text{Score}_{\text{Signals}} + \text{Score}_{\text{Perf}}}{4}
+$$
+
+### 🛑 CI/CD Pipeline & Quality Gate Impact
+
+The _scorign engine_ is designed to act as an automated guardian in DevSecOps environments. The engine will automatically block the pipeline (via `process.exit(1)`) if any of the following _quality gate_ failure conditions are met:
+
+- **Critical grade:** The overall project score drops below 60 points (Grade **F**).
+
+- **Critical overflow:** The total number of issues categorized as `CRITICAL` exceeds the maximum limit configured in `foundry-arch-scanner.json` (`maxCriticalIssues`).
+
+- **Warning overflow:** (Optional) If a limit for `maxWarnings` is defined and exceeded.
+
+> **💡 CI/CD tip:** During early adoption phases or legacy code migrations, you can run the scanner with the `--warn-only` flag to generate full analytical reports without interrupting the deployment.
+
+## 🚀 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;
+    }
+}