@girardelli/architect 1.1.0

package/src/types.ts

@@ -0,0 +1,114 @@
+export interface FileNode {
+  path: string;
+  name: string;
+  type: 'file' | 'directory';
+  extension?: string;
+  lines?: number;
+  language?: string;
+  children?: FileNode[];
+  imports?: string[];
+  exports?: string[];
+}
+
+export interface DependencyEdge {
+  from: string;
+  to: string;
+  type: 'import' | 'export' | 'inheritance' | 'composition';
+  weight: number;
+}
+
+export interface Layer {
+  name: 'API' | 'Service' | 'Data' | 'UI' | 'Infrastructure';
+  files: string[];
+  description: string;
+}
+
+export interface AntiPattern {
+  name: string;
+  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+  location: string;
+  description: string;
+  suggestion: string;
+  affectedFiles?: string[];
+  metrics?: Record<string, number | string>;
+}
+
+export interface ScoreComponent {
+  name: string;
+  score: number;
+  maxScore: number;
+  weight: number;
+  explanation: string;
+}
+
+export interface ArchitectureScore {
+  overall: number;
+  components: ScoreComponent[];
+  breakdown: {
+    modularity: number;
+    coupling: number;
+    cohesion: number;
+    layering: number;
+  };
+}
+
+export interface ProjectInfo {
+  path: string;
+  name: string;
+  frameworks: string[];
+  totalFiles: number;
+  totalLines: number;
+  primaryLanguages: string[];
+  fileTree?: FileNode;
+}
+
+export interface AnalysisReport {
+  timestamp: string;
+  projectInfo: ProjectInfo;
+  score: ArchitectureScore;
+  antiPatterns: AntiPattern[];
+  layers: Layer[];
+  dependencyGraph: {
+    nodes: string[];
+    edges: DependencyEdge[];
+  };
+  suggestions: {
+    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    title: string;
+    description: string;
+    impact: string;
+  }[];
+  diagram: {
+    mermaid: string;
+    type: 'component' | 'layer' | 'dependency';
+  };
+}
+
+export interface ArchitectConfig {
+  ignore?: string[];
+  frameworks?: {
+    detect?: boolean;
+  };
+  antiPatterns?: {
+    godClass?: {
+      linesThreshold?: number;
+      methodsThreshold?: number;
+    };
+    shotgunSurgery?: {
+      changePropagationThreshold?: number;
+    };
+  };
+  score?: {
+    modularity?: number;
+    coupling?: number;
+    cohesion?: number;
+    layering?: number;
+  };
+}
+
+export interface ParsedImport {
+  source: string;
+  names: string[];
+  isDefault: boolean;
+  isNamespace: boolean;
+}

package/tests/anti-patterns.test.ts

@@ -0,0 +1,94 @@
+import { AntiPatternDetector } from '../src/anti-patterns.js';
+import { ArchitectConfig, FileNode, AntiPattern } from '../src/types.js';
+
+describe('AntiPatternDetector', () => {
+  const mockConfig: ArchitectConfig = {
+    antiPatterns: {
+      godClass: {
+        linesThreshold: 500,
+        methodsThreshold: 10,
+      },
+      shotgunSurgery: {
+        changePropagationThreshold: 5,
+      },
+    },
+  };
+
+  const mockFileTree: FileNode = {
+    path: '/project',
+    name: 'project',
+    type: 'directory',
+    children: [
+      {
+        path: '/project/src/services/UserManager.ts',
+        name: 'UserManager.ts',
+        type: 'file',
+        extension: '.ts',
+        lines: 850,
+      },
+      {
+        path: '/project/src/utils/helper.ts',
+        name: 'helper.ts',
+        type: 'file',
+        extension: '.ts',
+        lines: 200,
+      },
+    ],
+  };
+
+  const mockDependencies = new Map<string, Set<string>>([
+    ['/project/src/services/UserManager.ts', new Set(['/project/src/utils/helper.ts'])],
+    ['/project/src/utils/helper.ts', new Set(['/project/src/services/UserManager.ts'])],
+  ]);
+
+  describe('detect', () => {
+    it('should detect anti-patterns in code', () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = detector.detect(mockFileTree, mockDependencies);
+
+      expect(Array.isArray(patterns)).toBe(true);
+    });
+
+    it('should identify God Classes', () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = detector.detect(mockFileTree, mockDependencies);
+
+      const godClasses = patterns.filter((p) => p.name === 'God Class');
+      expect(godClasses.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should sort patterns by severity', () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = detector.detect(mockFileTree, mockDependencies);
+
+      if (patterns.length > 1) {
+        const severityOrder: Record<string, number> = {
+          CRITICAL: 0,
+          HIGH: 1,
+          MEDIUM: 2,
+          LOW: 3,
+        };
+
+        for (let i = 0; i < patterns.length - 1; i++) {
+          const current = severityOrder[patterns[i].severity];
+          const next = severityOrder[patterns[i + 1].severity];
+          expect(current).toBeLessThanOrEqual(next);
+        }
+      }
+    });
+  });
+
+  describe('circular dependency detection', () => {
+    it('should detect circular dependencies', () => {
+      const circularDeps = new Map<string, Set<string>>([
+        ['src/auth.ts', new Set(['src/cache.ts'])],
+        ['src/cache.ts', new Set(['src/auth.ts'])],
+      ]);
+
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = detector.detect(mockFileTree, circularDeps);
+
+      expect(patterns.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+});

package/tests/scanner.test.ts

@@ -0,0 +1,55 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { ProjectScanner } from '../src/scanner.js';
+import { ArchitectConfig } from '../src/types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('ProjectScanner', () => {
+  const mockConfig: ArchitectConfig = {
+    ignore: ['node_modules', 'dist', 'coverage'],
+    frameworks: { detect: true },
+  };
+
+  describe('scan', () => {
+    it('should scan a project directory and return project info', () => {
+      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const info = scanner.scan();
+
+      expect(info).toBeDefined();
+      expect(info.path).toBe(__dirname);
+      expect(info.totalFiles).toBeGreaterThanOrEqual(0);
+      expect(info.totalLines).toBeGreaterThanOrEqual(0);
+      expect(Array.isArray(info.primaryLanguages)).toBe(true);
+      expect(Array.isArray(info.frameworks)).toBe(true);
+    });
+
+    it('should detect TypeScript files', () => {
+      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const info = scanner.scan();
+
+      if (info.totalFiles > 0) {
+        expect(info.primaryLanguages.length).toBeGreaterThanOrEqual(0);
+      }
+    });
+
+    it('should build a file tree structure', () => {
+      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const info = scanner.scan();
+
+      expect(info.fileTree).toBeDefined();
+      expect(info.fileTree?.type).toBe('directory');
+      expect(info.fileTree?.children).toBeDefined();
+    });
+  });
+
+  describe('framework detection', () => {
+    it('should detect frameworks from configuration files', () => {
+      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const info = scanner.scan();
+
+      expect(Array.isArray(info.frameworks)).toBe(true);
+    });
+  });
+});

package/tests/scorer.test.ts

@@ -0,0 +1,80 @@
+import { ArchitectureScorer } from '../src/scorer.js';
+import { DependencyEdge, AntiPattern } from '../src/types.js';
+
+describe('ArchitectureScorer', () => {
+  const scorer = new ArchitectureScorer();
+
+  const mockEdges: DependencyEdge[] = [
+    { from: 'src/a.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+    { from: 'src/b.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+    { from: 'src/c.ts', to: 'src/d.ts', type: 'import', weight: 1 },
+  ];
+
+  const mockAntiPatterns: AntiPattern[] = [
+    {
+      name: 'God Class',
+      severity: 'CRITICAL',
+      location: 'src/Manager.ts',
+      description: 'Test',
+      suggestion: 'Test',
+    },
+  ];
+
+  describe('score', () => {
+    it('should return a score between 0 and 100', () => {
+      const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+
+      expect(result.overall).toBeGreaterThanOrEqual(0);
+      expect(result.overall).toBeLessThanOrEqual(100);
+    });
+
+    it('should calculate component scores', () => {
+      const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+
+      expect(result.components).toBeDefined();
+      expect(result.components.length).toBeGreaterThan(0);
+
+      for (const component of result.components) {
+        expect(component.score).toBeGreaterThanOrEqual(0);
+        expect(component.score).toBeLessThanOrEqual(100);
+        expect(component.weight).toBeGreaterThan(0);
+      }
+    });
+
+    it('should provide breakdown of component scores', () => {
+      const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+
+      expect(result.breakdown).toBeDefined();
+      expect(result.breakdown.modularity).toBeGreaterThanOrEqual(0);
+      expect(result.breakdown.coupling).toBeGreaterThanOrEqual(0);
+      expect(result.breakdown.cohesion).toBeGreaterThanOrEqual(0);
+      expect(result.breakdown.layering).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should handle empty edges', () => {
+      const result = scorer.score([], mockAntiPatterns, 10);
+
+      expect(result.overall).toBeGreaterThanOrEqual(0);
+      expect(result.overall).toBeLessThanOrEqual(100);
+    });
+
+    it('should penalize anti-patterns in layering score', () => {
+      const lotsOfPatterns: AntiPattern[] = Array(10)
+        .fill(null)
+        .map((_, i) => ({
+          name: 'Test Pattern',
+          severity: 'HIGH',
+          location: `src/file${i}.ts`,
+          description: 'Test',
+          suggestion: 'Test',
+        }));
+
+      const resultWithPatterns = scorer.score(mockEdges, lotsOfPatterns, 50);
+      const resultWithoutPatterns = scorer.score(mockEdges, [], 50);
+
+      expect(resultWithPatterns.breakdown.layering).toBeLessThanOrEqual(
+        resultWithoutPatterns.breakdown.layering
+      );
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020"],
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}