@evolith/smart-cli 0.0.1-beta → 0.0.2-beta

package/dist/core/validators/ruleset-validator-architecture.spec.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ruleset_validator_service_1 = require("./ruleset-validator.service");
+const abstractions_1 = require("../abstractions");
+const createMockFileSystem = (overrides) => {
+    const mock = {
+        exists: jest.fn().mockResolvedValue(true),
+        existsSync: jest.fn().mockReturnValue(true),
+        readFile: jest.fn().mockResolvedValue(''),
+        readJson: jest.fn().mockResolvedValue({}),
+        readdirNames: jest.fn().mockResolvedValue([]),
+        writeFile: jest.fn().mockResolvedValue(undefined),
+        writeJson: jest.fn().mockResolvedValue(undefined),
+        ensureDir: jest.fn().mockResolvedValue(undefined),
+        remove: jest.fn().mockResolvedValue(undefined),
+        stat: jest.fn().mockResolvedValue({ isDirectory: () => true, isFile: () => false }),
+        ...overrides,
+    };
+    return mock;
+};
+const mockF1Ruleset = {
+    rules: [
+        {
+            id: 'F1-R01',
+            severity: 'MUST',
+            category: 'topology',
+            title: 'Single Deployment Unit',
+            description: 'All bounded contexts MUST be deployed as a single artifact',
+            blocking: true,
+        },
+        {
+            id: 'F1-R02',
+            severity: 'MUST',
+            category: 'bounded-contexts',
+            title: 'Explicit Bounded Context Boundaries',
+            description: 'Each bounded context MUST be clearly separated',
+            blocking: true,
+        },
+        {
+            id: 'F1-R03',
+            severity: 'MUST',
+            category: 'hexagonal-architecture',
+            title: 'Ports and Adapters Boundary',
+            description: 'All bounded contexts MUST implement hexagonal architecture',
+            blocking: true,
+        },
+    ],
+};
+describe('RulesetValidatorService - Architecture Validation', () => {
+    let service;
+    let mockFs;
+    beforeEach(() => {
+        (0, abstractions_1.resetContainer)();
+        jest.clearAllMocks();
+        mockFs = createMockFileSystem({
+            readFile: jest.fn().mockImplementation((p) => {
+                if (p.includes('f1-modular-monolith'))
+                    return Promise.resolve(JSON.stringify(mockF1Ruleset));
+                if (p.includes('f2-distributed-modules'))
+                    return Promise.resolve(JSON.stringify({ rules: [] }));
+                if (p.includes('f3-microservices'))
+                    return Promise.resolve(JSON.stringify({ rules: [] }));
+                return Promise.resolve('');
+            }),
+        });
+        const mockProvider = {
+            createFileSystem: () => mockFs,
+        };
+        (0, abstractions_1.getContainer)().setFileSystemProvider(mockProvider);
+        service = new ruleset_validator_service_1.RulesetValidatorService();
+    });
+    afterEach(() => {
+        (0, abstractions_1.resetContainer)();
+    });
+    describe('validateArchitecture', () => {
+        it('should validate F1 architecture level', async () => {
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result).toHaveProperty('status');
+            expect(result).toHaveProperty('levels');
+            expect(result).toHaveProperty('rulesChecked');
+            expect(result).toHaveProperty('issues');
+            expect(result).toHaveProperty('timestamp');
+            expect(result.levels).toContain('F1');
+        });
+        it('should validate ALL architecture levels by default', async () => {
+            const result = await service.validateArchitecture('/project', '/core');
+            expect(result.levels).toContain('F1');
+            expect(result.levels).toContain('F2');
+            expect(result.levels).toContain('F3');
+        });
+        it('should validate specific level when specified', async () => {
+            const result = await service.validateArchitecture('/project', '/core', 'F2');
+            expect(result.levels).toEqual(['F2']);
+        });
+        it('should return passed status when no blocking issues', async () => {
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.status).toBe('passed');
+        });
+        it('should return issues array even when validation passes', async () => {
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(Array.isArray(result.issues)).toBe(true);
+        });
+        it('should count rules checked', async () => {
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.rulesChecked).toBeGreaterThan(0);
+        });
+        it('should handle missing ruleset gracefully', async () => {
+            mockFs.exists.mockResolvedValue(false);
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.issues.some((i) => i.ruleId.includes('MISSING'))).toBe(true);
+        });
+    });
+    describe('validateArchitectureRule - topology', () => {
+        it('should validate topology rules for F1', async () => {
+            mockFs.readFile.mockImplementation((p) => {
+                if (p.includes('f1-modular-monolith')) {
+                    return Promise.resolve(JSON.stringify({
+                        rules: [{
+                                id: 'F1-R01',
+                                severity: 'MUST',
+                                category: 'topology',
+                                title: 'Single Deployment Unit',
+                                description: 'All bounded contexts MUST be deployed as a single artifact',
+                                blocking: true,
+                            }],
+                    }));
+                }
+                return Promise.resolve(JSON.stringify({ rules: [] }));
+            });
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.rulesChecked).toBeGreaterThan(0);
+        });
+    });
+    describe('validateArchitectureRule - bounded-contexts', () => {
+        it('should validate bounded contexts rules', async () => {
+            mockFs.readFile.mockImplementation((p) => {
+                if (p.includes('f1-modular-monolith')) {
+                    return Promise.resolve(JSON.stringify({
+                        rules: [{
+                                id: 'F1-R02',
+                                severity: 'MUST',
+                                category: 'bounded-contexts',
+                                title: 'Explicit Bounded Context Boundaries',
+                                description: 'Each bounded context MUST be clearly separated',
+                                blocking: true,
+                            }],
+                    }));
+                }
+                return Promise.resolve(JSON.stringify({ rules: [] }));
+            });
+            mockFs.readdirNames.mockResolvedValue(['context-a', 'context-b']);
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.rulesChecked).toBeGreaterThan(0);
+        });
+    });
+    describe('validateArchitectureRule - hexagonal-architecture', () => {
+        it('should validate hexagonal architecture rules', async () => {
+            mockFs.readFile.mockImplementation((p) => {
+                if (p.includes('f1-modular-monolith')) {
+                    return Promise.resolve(JSON.stringify({
+                        rules: [{
+                                id: 'F1-R03',
+                                severity: 'MUST',
+                                category: 'hexagonal-architecture',
+                                title: 'Ports and Adapters Boundary',
+                                description: 'All bounded contexts MUST implement hexagonal architecture',
+                                blocking: true,
+                            }],
+                    }));
+                }
+                return Promise.resolve(JSON.stringify({ rules: [] }));
+            });
+            const result = await service.validateArchitecture('/project', '/core', 'F1');
+            expect(result.rulesChecked).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=ruleset-validator-architecture.spec.js.map

package/dist/core/validators/ruleset-validator-architecture.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruleset-validator-architecture.spec.js","sourceRoot":"","sources":["../../../src/core/validators/ruleset-validator-architecture.spec.ts"],"names":[],"mappings":"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"}

package/dist/core/validators/ruleset-validator.service.d.ts

@@ -53,4 +53,28 @@ export declare class RulesetValidatorService {
     private findCorePath;
     private isValidSemver;
     loadRulesetById(corePath: string, rulesetId: string): Promise<ValidationIssue[]>;
+    validateArchitecture(satellitePath: string, corePath?: string, level?: 'F1' | 'F2' | 'F3' | 'ALL'): Promise<ArchitectureValidationResult>;
+    private validateArchitectureRule;
+    private validateTopologyRule;
+    private validateBoundedContextsRule;
+    private validateHexagonalRule;
+    private validateCommunicationRule;
+    private validatePersistenceRule;
+    private validateAsyncRule;
+    private validateExtractionReadinessRule;
+    private validateObservabilityRule;
+    private validateModuleAutonomyRule;
+    private validateContractStabilityRule;
+    private validateDataOwnershipRule;
+    private validateAsyncCommunicationRule;
+    private validateDistributedTracingRule;
+    private validateContainerizationRule;
+    private validateServiceBoundariesRule;
+}
+export interface ArchitectureValidationResult {
+    status: 'passed' | 'failed' | 'warning';
+    levels: string[];
+    rulesChecked: number;
+    issues: ValidationIssue[];
+    timestamp: string;
 }

package/dist/core/validators/ruleset-validator.service.js

@@ -258,6 +258,400 @@ class RulesetValidatorService {
         }
         return issues;
     }
+    async validateArchitecture(satellitePath, corePath, level) {
+        const resolvedCorePath = corePath || this.findCorePath(satellitePath);
+        const issues = [];
+        let rulesChecked = 0;
+        const levels = level === 'ALL' || !level
+            ? ['F1', 'F2', 'F3']
+            : [level];
+        for (const lvl of levels) {
+            const rulesetPath = path.join(resolvedCorePath, 'rulesets', 'architecture', `f${lvl.toLowerCase()}-${lvl === 'F1' ? 'modular-monolith' : lvl === 'F2' ? 'distributed-modules' : 'microservices'}.rules.json`);
+            if (!await this.fs.exists(rulesetPath)) {
+                issues.push({
+                    ruleId: `ARCH-${lvl}-MISSING`,
+                    severity: 'SHOULD',
+                    category: 'architecture',
+                    title: `${lvl} ruleset not found`,
+                    description: `Could not find ${lvl} architecture rules at ${rulesetPath}`,
+                    blocking: false,
+                });
+                continue;
+            }
+            const content = await this.fs.readFile(rulesetPath);
+            const ruleset = JSON.parse(content);
+            const rules = ruleset.rules || [];
+            rulesChecked += rules.length;
+            for (const rule of rules) {
+                const validationResult = await this.validateArchitectureRule(satellitePath, rule, lvl);
+                if (validationResult) {
+                    issues.push(...validationResult);
+                }
+            }
+        }
+        const blockingCount = issues.filter(i => i.blocking).length;
+        return {
+            status: blockingCount > 0 ? 'failed' : 'passed',
+            levels: levels,
+            rulesChecked,
+            issues,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    async validateArchitectureRule(satellitePath, rule, level) {
+        const issues = [];
+        switch (rule.category) {
+            case 'topology':
+                this.validateTopologyRule(satellitePath, rule, issues);
+                break;
+            case 'bounded-contexts':
+                this.validateBoundedContextsRule(satellitePath, rule, issues);
+                break;
+            case 'hexagonal-architecture':
+                await this.validateHexagonalRule(satellitePath, rule, issues);
+                break;
+            case 'communication':
+                await this.validateCommunicationRule(satellitePath, rule, issues);
+                break;
+            case 'persistence':
+                this.validatePersistenceRule(satellitePath, rule, issues);
+                break;
+            case 'async-boundaries':
+                await this.validateAsyncRule(satellitePath, rule, issues);
+                break;
+            case 'extraction-readiness':
+                this.validateExtractionReadinessRule(satellitePath, rule, issues);
+                break;
+            case 'observability':
+                this.validateObservabilityRule(satellitePath, rule, issues);
+                break;
+            case 'module-autonomy':
+                await this.validateModuleAutonomyRule(satellitePath, rule, issues);
+                break;
+            case 'contract-stability':
+                await this.validateContractStabilityRule(satellitePath, rule, issues);
+                break;
+            case 'data-ownership':
+                this.validateDataOwnershipRule(satellitePath, rule, issues);
+                break;
+            case 'async-communication':
+                await this.validateAsyncCommunicationRule(satellitePath, rule, issues);
+                break;
+            case 'distributed-tracing':
+                this.validateDistributedTracingRule(satellitePath, rule, issues);
+                break;
+            case 'containerization':
+                this.validateContainerizationRule(satellitePath, rule, issues);
+                break;
+            case 'service-boundaries':
+                await this.validateServiceBoundariesRule(satellitePath, rule, issues);
+                break;
+            default:
+                break;
+        }
+        return issues.length > 0 ? issues : null;
+    }
+    async validateTopologyRule(satellitePath, rule, issues) {
+        const packageJsonPath = path.join(satellitePath, 'package.json');
+        if (rule.id === 'F1-R01') {
+            if (await this.fs.exists(packageJsonPath)) {
+                const pkg = await this.fs.readJson(packageJsonPath);
+                if (pkg.workspaces) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - Monorepo workspace detected`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    async validateBoundedContextsRule(satellitePath, rule, issues) {
+        const srcPath = path.join(satellitePath, 'src');
+        if (await this.fs.exists(srcPath)) {
+            const entries = await this.fs.readdirNames(srcPath);
+            const moduleCount = entries.filter(e => !e.startsWith('.')).length;
+            if (rule.id === 'F1-R02') {
+                if (moduleCount < 2) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - Found only ${moduleCount} module(s) in src/`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    async validateHexagonalRule(satellitePath, rule, issues) {
+        if (rule.id === 'F1-R03') {
+            const srcPath = path.join(satellitePath, 'src');
+            const hasPorts = await this.fs.exists(path.join(srcPath, 'ports')) ||
+                await this.fs.exists(path.join(srcPath, 'Ports')) ||
+                await this.fs.exists(path.join(srcPath, 'application/ports'));
+            if (!hasPorts) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No ports directory found (expected: src/ports or src/application/ports)`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
+    async validateCommunicationRule(satellitePath, rule, issues) {
+        if (rule.id === 'F1-R04' || rule.id === 'F2-R03') {
+            const contractsPath = path.join(satellitePath, 'contracts');
+            const hasContracts = await this.fs.exists(contractsPath);
+            if (!hasContracts) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No contracts/ directory found for inter-module contracts`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
+    async validatePersistenceRule(satellitePath, rule, issues) {
+        if (rule.id === 'F1-R05') {
+            const aclPath = path.join(satellitePath, 'acl');
+            if (!await this.fs.exists(aclPath)) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No acl/ directory found (should contain one subdirectory per bounded context)`,
+                    blocking: rule.blocking,
+                });
+            }
+            else {
+                const entries = await this.fs.readdirNames(aclPath);
+                if (entries.length < 2) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - Found ${entries.length} bounded context(s) in acl/ (expected multiple)`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    async validateAsyncRule(satellitePath, rule, issues) {
+        if (rule.id === 'F1-R06') {
+            const eventsPath = path.join(satellitePath, 'events') ||
+                path.join(satellitePath, 'src', 'events') ||
+                path.join(satellitePath, 'src', 'domain', 'events');
+            const hasEvents = await this.fs.exists(eventsPath);
+            if (!hasEvents) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No events directory found`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
+    async validateExtractionReadinessRule(satellitePath, rule, issues) {
+        const extractionReadinessPath = path.join(satellitePath, 'docs', 'extraction-readiness.md');
+        const hasExtractionReadiness = await this.fs.exists(extractionReadinessPath);
+        if (!hasExtractionReadiness) {
+            issues.push({
+                ruleId: rule.id,
+                severity: rule.severity,
+                category: rule.category,
+                title: rule.title,
+                description: `${rule.description} - No extraction-readiness.md found in docs/`,
+                blocking: rule.blocking,
+            });
+        }
+    }
+    async validateObservabilityRule(satellitePath, rule, issues) {
+        const hasPkgJson = await this.fs.exists(path.join(satellitePath, 'package.json'));
+        if (hasPkgJson) {
+            const otelConfigPath = path.join(satellitePath, 'otel.config.js') ||
+                path.join(satellitePath, 'opentelemetry.config.js') ||
+                path.join(satellitePath, 'src', 'instrumentation.ts');
+            let hasOtel = false;
+            for (const p of [otelConfigPath]) {
+                if (await this.fs.exists(p)) {
+                    hasOtel = true;
+                    break;
+                }
+            }
+            if (!hasOtel) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No OpenTelemetry instrumentation found`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
+    async validateModuleAutonomyRule(satellitePath, rule, issues) {
+        if (rule.id === 'F2-R01') {
+            const srcPath = path.join(satellitePath, 'src');
+            if (await this.fs.exists(srcPath)) {
+                const entries = await this.fs.readdirNames(srcPath);
+                let hasIndependentModules = false;
+                for (const entry of entries) {
+                    if (await this.fs.exists(path.join(srcPath, entry, 'package.json'))) {
+                        hasIndependentModules = true;
+                        break;
+                    }
+                }
+                if (!hasIndependentModules && entries.length > 1) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - No independent module package.json files found`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    async validateContractStabilityRule(satellitePath, rule, issues) {
+        if (rule.id === 'F2-R02') {
+            const contractsPath = path.join(satellitePath, 'contracts');
+            const hasContracts = await this.fs.exists(contractsPath);
+            if (!hasContracts) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No contracts directory found`,
+                    blocking: rule.blocking,
+                });
+            }
+            else {
+                const contractFiles = (await this.fs.readdirNames(contractsPath)).filter(f => f.endsWith('.proto') || f.endsWith('.avsc') || f.endsWith('.json'));
+                if (contractFiles.length === 0) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - No contract definition files (.proto, .avsc, .json schema) found`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    validateDataOwnershipRule(satellitePath, rule, issues) {
+        if (rule.id === 'F2-R03') {
+            const aclPath = path.join(satellitePath, 'acl');
+            if (!this.fs.existsSync(aclPath)) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - No acl directory for data ownership enforcement`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
+    async validateAsyncCommunicationRule(satellitePath, rule, issues) {
+        if (rule.id === 'F2-R04') {
+            const eventsPath = path.join(satellitePath, 'events') || path.join(satellitePath, 'src', 'events');
+            const hasEvents = await this.fs.exists(eventsPath);
+            if (hasEvents) {
+                const eventFiles = (await this.fs.readdirNames(eventsPath)).filter(f => f.endsWith('.json') || f.endsWith('.schema.json'));
+                if (eventFiles.length === 0) {
+                    issues.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        category: rule.category,
+                        title: rule.title,
+                        description: `${rule.description} - No schema-validated event files found`,
+                        blocking: rule.blocking,
+                    });
+                }
+            }
+        }
+    }
+    async validateDistributedTracingRule(satellitePath, rule, issues) {
+        const tracerSetupFiles = [
+            path.join(satellitePath, 'src', 'tracing.ts'),
+            path.join(satellitePath, 'src', 'instrumentation.ts'),
+            path.join(satellitePath, 'opentelemetry.config.js'),
+        ];
+        const existsResults = await Promise.all(tracerSetupFiles.map(f => this.fs.exists(f)));
+        const hasTracerSetup = existsResults.some(Boolean);
+        if (!hasTracerSetup) {
+            issues.push({
+                ruleId: rule.id,
+                severity: rule.severity,
+                category: rule.category,
+                title: rule.title,
+                description: `${rule.description} - No distributed tracing setup found`,
+                blocking: rule.blocking,
+            });
+        }
+    }
+    async validateContainerizationRule(satellitePath, rule, issues) {
+        const dockerfilePath = path.join(satellitePath, 'Dockerfile');
+        const dockerfileExists = await this.fs.exists(dockerfilePath);
+        if (rule.id === 'F3-R01' && !dockerfileExists) {
+            issues.push({
+                ruleId: rule.id,
+                severity: rule.severity,
+                category: rule.category,
+                title: rule.title,
+                description: `${rule.description} - No Dockerfile found at repository root`,
+                blocking: rule.blocking,
+            });
+        }
+    }
+    async validateServiceBoundariesRule(satellitePath, rule, issues) {
+        const srcPath = path.join(satellitePath, 'src');
+        if (await this.fs.exists(srcPath)) {
+            const entries = await this.fs.readdirNames(srcPath);
+            const dirEntries = [];
+            for (const entry of entries) {
+                const entryPath = path.join(srcPath, entry);
+                const stat = await this.fs.stat(entryPath);
+                if (stat.isDirectory && stat.isDirectory()) {
+                    dirEntries.push(entry);
+                }
+            }
+            if (rule.id === 'F3-R02' && dirEntries.length < 2) {
+                issues.push({
+                    ruleId: rule.id,
+                    severity: rule.severity,
+                    category: rule.category,
+                    title: rule.title,
+                    description: `${rule.description} - Only ${dirEntries.length} service(s) found (expected multiple independent services)`,
+                    blocking: rule.blocking,
+                });
+            }
+        }
+    }
 }
 exports.RulesetValidatorService = RulesetValidatorService;
 //# sourceMappingURL=ruleset-validator.service.js.map