fcis 0.1.0

package/tests/scorer.test.ts

@@ -0,0 +1,768 @@
+/**
+ * Scorer Tests
+ *
+ * Tests for the pure core scoring engine.
+ * These tests verify that file, directory, and project scores
+ * are correctly computed from classified functions.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  scoreFile,
+  scoreDirectory,
+  scoreProject,
+  groupFilesByDirectory,
+  calculateDelta,
+  getDiagnosticInsights,
+} from '../src/scoring/scorer.js'
+import type {
+  ClassifiedFunction,
+  FileScore,
+  DirectoryScore,
+  ProjectScore,
+} from '../src/types.js'
+
+/**
+ * Helper to create a classified function for testing
+ */
+function createClassifiedFunction(
+  overrides: Partial<ClassifiedFunction> = {},
+): ClassifiedFunction {
+  return {
+    name: 'testFunction',
+    filePath: '/test/file.ts',
+    startLine: 1,
+    endLine: 10,
+    isAsync: false,
+    isExported: false,
+    bodyLineCount: 10,
+    statementCount: 5,
+    hasConditionals: false,
+    parentContext: null,
+    callSites: [],
+    hasAwait: false,
+    propertyAccessChains: [],
+    kind: 'function',
+    markers: [],
+    classification: 'pure',
+    qualityScore: null,
+    status: 'ok',
+    ...overrides,
+  }
+}
+
+/**
+ * Helper to create a pure function
+ */
+function createPureFunction(
+  name: string,
+  bodyLineCount: number = 10,
+): ClassifiedFunction {
+  return createClassifiedFunction({
+    name,
+    bodyLineCount,
+    classification: 'pure',
+    qualityScore: null,
+    status: 'ok',
+    markers: [],
+  })
+}
+
+/**
+ * Helper to create an impure function
+ */
+function createImpureFunction(
+  name: string,
+  qualityScore: number,
+  status: 'ok' | 'review' | 'refactor' = 'ok',
+  bodyLineCount: number = 10,
+): ClassifiedFunction {
+  return createClassifiedFunction({
+    name,
+    bodyLineCount,
+    classification: 'impure',
+    qualityScore,
+    status,
+    markers: [{ type: 'database-call', detail: 'db.user.findFirst' }],
+  })
+}
+
+describe('scoreFile', () => {
+  describe('basic scoring', () => {
+    it('should score file with all pure functions as 100% purity', () => {
+      const functions = [
+        createPureFunction('fn1'),
+        createPureFunction('fn2'),
+        createPureFunction('fn3'),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.purity).toBe(100)
+      expect(score.pureCount).toBe(3)
+      expect(score.impureCount).toBe(0)
+    })
+
+    it('should score file with all impure functions as 0% purity', () => {
+      const functions = [
+        createImpureFunction('fn1', 70),
+        createImpureFunction('fn2', 60),
+        createImpureFunction('fn3', 50),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.purity).toBe(0)
+      expect(score.pureCount).toBe(0)
+      expect(score.impureCount).toBe(3)
+    })
+
+    it('should score file with mixed functions correctly', () => {
+      const functions = [
+        createPureFunction('pure1'),
+        createPureFunction('pure2'),
+        createImpureFunction('impure1', 70),
+        createImpureFunction('impure2', 60),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.purity).toBe(50)
+      expect(score.pureCount).toBe(2)
+      expect(score.impureCount).toBe(2)
+    })
+  })
+
+  describe('impurity quality', () => {
+    it('should calculate average impurity quality', () => {
+      const functions = [
+        createImpureFunction('fn1', 80),
+        createImpureFunction('fn2', 60),
+        createImpureFunction('fn3', 40),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.impurityQuality).toBe(60)
+    })
+
+    it('should return null impurity quality for all pure functions', () => {
+      const functions = [createPureFunction('fn1'), createPureFunction('fn2')]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.impurityQuality).toBeNull()
+    })
+
+    it('should calculate impurity quality for single impure function', () => {
+      const functions = [createImpureFunction('fn1', 75)]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.impurityQuality).toBe(75)
+    })
+  })
+
+  describe('health calculation', () => {
+    it('should calculate 100% health when all functions are ok', () => {
+      const functions = [
+        createPureFunction('pure1'),
+        createImpureFunction('impure1', 75, 'ok'),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.health).toBe(100)
+    })
+
+    it('should calculate health based on ok status percentage', () => {
+      const functions = [
+        createPureFunction('pure1'), // ok
+        createImpureFunction('impure1', 75, 'ok'),
+        createImpureFunction('impure2', 50, 'review'),
+        createImpureFunction('impure3', 30, 'refactor'),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.health).toBe(50) // 2 ok out of 4
+    })
+
+    it('should calculate 0% health when all functions need attention', () => {
+      const functions = [
+        createImpureFunction('fn1', 30, 'refactor'),
+        createImpureFunction('fn2', 35, 'refactor'),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.health).toBe(0)
+    })
+  })
+
+  describe('status breakdown', () => {
+    it('should count functions by status', () => {
+      const functions = [
+        createPureFunction('pure1'), // ok
+        createPureFunction('pure2'), // ok
+        createImpureFunction('impure1', 75, 'ok'),
+        createImpureFunction('impure2', 50, 'review'),
+        createImpureFunction('impure3', 50, 'review'),
+        createImpureFunction('impure4', 30, 'refactor'),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.statusBreakdown.ok).toBe(3)
+      expect(score.statusBreakdown.review).toBe(2)
+      expect(score.statusBreakdown.refactor).toBe(1)
+    })
+  })
+
+  describe('line counts', () => {
+    it('should sum line counts by classification', () => {
+      const functions = [
+        createPureFunction('pure1', 10),
+        createPureFunction('pure2', 20),
+        createImpureFunction('impure1', 70, 'ok', 15),
+        createImpureFunction('impure2', 60, 'ok', 25),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.pureLineCount).toBe(30)
+      expect(score.impureLineCount).toBe(40)
+    })
+  })
+
+  describe('refactoring candidates', () => {
+    it('should include functions with refactor status', () => {
+      const functions = [
+        createPureFunction('pure1'),
+        createImpureFunction('impure1', 75, 'ok'),
+        createImpureFunction('refactorMe', 30, 'refactor', 50),
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.refactoringCandidates).toHaveLength(1)
+      expect(score.refactoringCandidates[0]?.name).toBe('refactorMe')
+    })
+
+    it('should sort refactoring candidates by impact', () => {
+      const functions = [
+        createImpureFunction('small', 35, 'refactor', 10), // impact: 10 * 65 = 650
+        createImpureFunction('large', 25, 'refactor', 100), // impact: 100 * 75 = 7500
+        createImpureFunction('medium', 30, 'refactor', 50), // impact: 50 * 70 = 3500
+      ]
+
+      const score = scoreFile('/test/file.ts', functions)
+
+      expect(score.refactoringCandidates[0]?.name).toBe('large')
+      expect(score.refactoringCandidates[1]?.name).toBe('medium')
+      expect(score.refactoringCandidates[2]?.name).toBe('small')
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle empty file', () => {
+      const score = scoreFile('/test/file.ts', [])
+
+      expect(score.purity).toBe(100)
+      expect(score.health).toBe(100)
+      expect(score.impurityQuality).toBeNull()
+      expect(score.allExcluded).toBe(true)
+    })
+
+    it('should handle type-only file', () => {
+      const score = scoreFile('/test/types.ts', [], true)
+
+      expect(score.purity).toBe(100)
+      expect(score.health).toBe(100)
+      expect(score.typeOnly).toBe(true)
+    })
+  })
+})
+
+describe('scoreDirectory', () => {
+  /**
+   * Helper to create a file score for testing
+   */
+  function createFileScore(overrides: Partial<FileScore> = {}): FileScore {
+    return {
+      filePath: '/test/file.ts',
+      purity: 50,
+      impurityQuality: 60,
+      health: 75,
+      pureCount: 5,
+      impureCount: 5,
+      excludedCount: 0,
+      statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+      pureLineCount: 50,
+      impureLineCount: 100,
+      functions: [],
+      refactoringCandidates: [],
+      ...overrides,
+    }
+  }
+
+  it('should aggregate file scores with weighted averages', () => {
+    const fileScores = [
+      createFileScore({
+        filePath: '/test/a.ts',
+        purity: 80,
+        pureCount: 8,
+        impureCount: 2,
+      }),
+      createFileScore({
+        filePath: '/test/b.ts',
+        purity: 40,
+        pureCount: 4,
+        impureCount: 6,
+      }),
+    ]
+
+    const dirScore = scoreDirectory('/test', fileScores)
+
+    // Total: 12 pure, 8 impure = 60% purity
+    expect(dirScore.purity).toBe(60)
+    expect(dirScore.pureCount).toBe(12)
+    expect(dirScore.impureCount).toBe(8)
+  })
+
+  it('should calculate weighted impurity quality', () => {
+    const fileScores = [
+      createFileScore({
+        filePath: '/test/a.ts',
+        impurityQuality: 80,
+        impureCount: 2,
+      }),
+      createFileScore({
+        filePath: '/test/b.ts',
+        impurityQuality: 40,
+        impureCount: 6,
+      }),
+    ]
+
+    const dirScore = scoreDirectory('/test', fileScores)
+
+    // Weighted: (80*2 + 40*6) / 8 = 50
+    expect(dirScore.impurityQuality).toBe(50)
+  })
+
+  it('should aggregate status breakdown', () => {
+    const fileScores = [
+      createFileScore({
+        statusBreakdown: { ok: 5, review: 2, refactor: 1 },
+      }),
+      createFileScore({
+        statusBreakdown: { ok: 3, review: 4, refactor: 2 },
+      }),
+    ]
+
+    const dirScore = scoreDirectory('/test', fileScores)
+
+    expect(dirScore.statusBreakdown.ok).toBe(8)
+    expect(dirScore.statusBreakdown.review).toBe(6)
+    expect(dirScore.statusBreakdown.refactor).toBe(3)
+  })
+
+  it('should handle empty directory', () => {
+    const dirScore = scoreDirectory('/test', [])
+
+    expect(dirScore.purity).toBe(100)
+    expect(dirScore.health).toBe(100)
+    expect(dirScore.impurityQuality).toBeNull()
+  })
+
+  it('should exclude type-only files from aggregation', () => {
+    const fileScores = [
+      createFileScore({
+        filePath: '/test/a.ts',
+        purity: 60,
+        pureCount: 6,
+        impureCount: 4,
+      }),
+      createFileScore({
+        filePath: '/test/types.ts',
+        purity: 100,
+        pureCount: 0,
+        impureCount: 0,
+        typeOnly: true,
+      }),
+    ]
+
+    const dirScore = scoreDirectory('/test', fileScores)
+
+    expect(dirScore.purity).toBe(60)
+    expect(dirScore.pureCount).toBe(6)
+    expect(dirScore.impureCount).toBe(4)
+  })
+})
+
+describe('scoreProject', () => {
+  /**
+   * Helper to create a directory score for testing
+   */
+  function createDirScore(
+    overrides: Partial<DirectoryScore> = {},
+  ): DirectoryScore {
+    return {
+      dirPath: '/test',
+      purity: 50,
+      impurityQuality: 60,
+      health: 75,
+      pureCount: 10,
+      impureCount: 10,
+      excludedCount: 0,
+      statusBreakdown: { ok: 15, review: 3, refactor: 2 },
+      pureLineCount: 100,
+      impureLineCount: 200,
+      fileScores: [],
+      ...overrides,
+    }
+  }
+
+  it('should aggregate directory scores', () => {
+    const dirScores = [
+      createDirScore({
+        dirPath: '/src/services',
+        purity: 40,
+        pureCount: 4,
+        impureCount: 6,
+      }),
+      createDirScore({
+        dirPath: '/src/utils',
+        purity: 90,
+        pureCount: 9,
+        impureCount: 1,
+      }),
+    ]
+
+    const projectScore = scoreProject(dirScores)
+
+    // Total: 13 pure, 7 impure = 65% purity
+    expect(projectScore.purity).toBe(65)
+    expect(projectScore.pureCount).toBe(13)
+    expect(projectScore.impureCount).toBe(7)
+  })
+
+  it('should include timestamp and commit hash', () => {
+    const dirScores = [createDirScore()]
+
+    const projectScore = scoreProject(dirScores, {
+      timestamp: '2024-01-01T00:00:00.000Z',
+      commitHash: 'abc123',
+    })
+
+    expect(projectScore.timestamp).toBe('2024-01-01T00:00:00.000Z')
+    expect(projectScore.commitHash).toBe('abc123')
+  })
+
+  it('should mark subset analysis', () => {
+    const dirScores = [createDirScore()]
+
+    const projectScore = scoreProject(dirScores, {
+      subset: true,
+      filesGlob: 'src/services/**/*.ts',
+    })
+
+    expect(projectScore.subset).toBe(true)
+    expect(projectScore.filesGlob).toBe('src/services/**/*.ts')
+  })
+
+  it('should include errors when provided', () => {
+    const dirScores = [createDirScore()]
+    const errors = [
+      { filePath: '/test/bad.ts', error: 'Syntax error' },
+      { filePath: '/test/worse.ts', error: 'Parse failed' },
+    ]
+
+    const projectScore = scoreProject(dirScores, { errors })
+
+    expect(projectScore.errors).toHaveLength(2)
+  })
+
+  it('should collect refactoring candidates from all files', () => {
+    const dirScores = [
+      createDirScore({
+        fileScores: [
+          {
+            filePath: '/src/a.ts',
+            purity: 50,
+            impurityQuality: 60,
+            health: 75,
+            pureCount: 5,
+            impureCount: 5,
+            excludedCount: 0,
+            statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+            pureLineCount: 50,
+            impureLineCount: 100,
+            functions: [],
+            refactoringCandidates: [
+              {
+                name: 'fn1',
+                startLine: 10,
+                bodyLineCount: 50,
+                qualityScore: 30,
+                markers: ['database-call'],
+              },
+            ],
+          },
+        ],
+      }),
+      createDirScore({
+        fileScores: [
+          {
+            filePath: '/src/b.ts',
+            purity: 50,
+            impurityQuality: 60,
+            health: 75,
+            pureCount: 5,
+            impureCount: 5,
+            excludedCount: 0,
+            statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+            pureLineCount: 50,
+            impureLineCount: 100,
+            functions: [],
+            refactoringCandidates: [
+              {
+                name: 'fn2',
+                startLine: 20,
+                bodyLineCount: 100,
+                qualityScore: 20,
+                markers: ['network-fetch'],
+              },
+            ],
+          },
+        ],
+      }),
+    ]
+
+    const projectScore = scoreProject(dirScores)
+
+    expect(projectScore.refactoringCandidates).toHaveLength(2)
+    // Should be sorted by impact (bodyLineCount * (100 - qualityScore))
+    // fn2: 100 * 80 = 8000
+    // fn1: 50 * 70 = 3500
+    expect(projectScore.refactoringCandidates[0]?.name).toBe('fn2')
+    expect(projectScore.refactoringCandidates[1]?.name).toBe('fn1')
+  })
+
+  it('should handle empty project', () => {
+    const projectScore = scoreProject([])
+
+    expect(projectScore.purity).toBe(100)
+    expect(projectScore.health).toBe(100)
+    expect(projectScore.allExcluded).toBe(true)
+  })
+})
+
+describe('groupFilesByDirectory', () => {
+  it('should group files by their directory path', () => {
+    const fileScores: FileScore[] = [
+      {
+        filePath: '/src/services/a.ts',
+        purity: 50,
+        impurityQuality: 60,
+        health: 75,
+        pureCount: 5,
+        impureCount: 5,
+        excludedCount: 0,
+        statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+        pureLineCount: 50,
+        impureLineCount: 100,
+        functions: [],
+        refactoringCandidates: [],
+      },
+      {
+        filePath: '/src/services/b.ts',
+        purity: 60,
+        impurityQuality: 70,
+        health: 80,
+        pureCount: 6,
+        impureCount: 4,
+        excludedCount: 0,
+        statusBreakdown: { ok: 8, review: 1, refactor: 1 },
+        pureLineCount: 60,
+        impureLineCount: 80,
+        functions: [],
+        refactoringCandidates: [],
+      },
+      {
+        filePath: '/src/utils/c.ts',
+        purity: 90,
+        impurityQuality: 80,
+        health: 95,
+        pureCount: 9,
+        impureCount: 1,
+        excludedCount: 0,
+        statusBreakdown: { ok: 9, review: 1, refactor: 0 },
+        pureLineCount: 90,
+        impureLineCount: 10,
+        functions: [],
+        refactoringCandidates: [],
+      },
+    ]
+
+    const groups = groupFilesByDirectory(fileScores)
+
+    expect(groups.size).toBe(2)
+    expect(groups.get('/src/services')).toHaveLength(2)
+    expect(groups.get('/src/utils')).toHaveLength(1)
+  })
+
+  it('should handle files in root directory', () => {
+    const fileScores: FileScore[] = [
+      {
+        filePath: 'root.ts',
+        purity: 50,
+        impurityQuality: 60,
+        health: 75,
+        pureCount: 5,
+        impureCount: 5,
+        excludedCount: 0,
+        statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+        pureLineCount: 50,
+        impureLineCount: 100,
+        functions: [],
+        refactoringCandidates: [],
+      },
+    ]
+
+    const groups = groupFilesByDirectory(fileScores)
+
+    expect(groups.size).toBe(1)
+    expect(groups.get('.')).toHaveLength(1)
+  })
+})
+
+describe('calculateDelta', () => {
+  function createProjectScore(
+    overrides: Partial<ProjectScore> = {},
+  ): ProjectScore {
+    return {
+      purity: 50,
+      impurityQuality: 60,
+      health: 75,
+      pureCount: 10,
+      impureCount: 10,
+      excludedCount: 0,
+      statusBreakdown: { ok: 15, review: 3, refactor: 2 },
+      pureLineCount: 100,
+      impureLineCount: 200,
+      directoryScores: [],
+      timestamp: '2024-01-01T00:00:00.000Z',
+      commitHash: null,
+      refactoringCandidates: [],
+      ...overrides,
+    }
+  }
+
+  it('should calculate positive delta for improvement', () => {
+    const previous = createProjectScore({
+      purity: 40,
+      health: 60,
+      pureCount: 8,
+      impureCount: 12,
+    })
+    const current = createProjectScore({
+      purity: 50,
+      health: 75,
+      pureCount: 10,
+      impureCount: 10,
+    })
+
+    const delta = calculateDelta(current, previous)
+
+    expect(delta.purityDelta).toBe(10)
+    expect(delta.healthDelta).toBe(15)
+    expect(delta.pureCountDelta).toBe(2)
+    expect(delta.impureCountDelta).toBe(-2)
+  })
+
+  it('should calculate negative delta for regression', () => {
+    const previous = createProjectScore({
+      purity: 60,
+      health: 80,
+    })
+    const current = createProjectScore({
+      purity: 50,
+      health: 75,
+    })
+
+    const delta = calculateDelta(current, previous)
+
+    expect(delta.purityDelta).toBe(-10)
+    expect(delta.healthDelta).toBe(-5)
+  })
+
+  it('should handle null impurity quality', () => {
+    const previous = createProjectScore({ impurityQuality: null })
+    const current = createProjectScore({ impurityQuality: 70 })
+
+    const delta = calculateDelta(current, previous)
+
+    expect(delta.impurityQualityDelta).toBeNull()
+  })
+
+  it('should calculate impurity quality delta when both have values', () => {
+    const previous = createProjectScore({ impurityQuality: 50 })
+    const current = createProjectScore({ impurityQuality: 70 })
+
+    const delta = calculateDelta(current, previous)
+
+    expect(delta.impurityQualityDelta).toBe(20)
+  })
+})
+
+describe('getDiagnosticInsights', () => {
+  it('should provide insight for high purity + low impurity quality', () => {
+    const score = { purity: 70, impurityQuality: 40, health: 60 }
+
+    const insights = getDiagnosticInsights(score)
+
+    expect(
+      insights.some(i => i.includes('pure') && i.includes('tangled')),
+    ).toBe(true)
+  })
+
+  it('should provide insight for low purity + high impurity quality', () => {
+    const score = { purity: 30, impurityQuality: 80, health: 70 }
+
+    const insights = getDiagnosticInsights(score)
+
+    expect(
+      insights.some(i => i.includes('I/O') && i.includes('well-structured')),
+    ).toBe(true)
+  })
+
+  it('should provide insight for low purity + low impurity quality', () => {
+    const score = { purity: 30, impurityQuality: 40, health: 40 }
+
+    const insights = getDiagnosticInsights(score)
+
+    expect(insights.some(i => i.includes('technical debt'))).toBe(true)
+  })
+
+  it('should provide insight for low health', () => {
+    const score = { purity: 50, impurityQuality: 60, health: 40 }
+
+    const insights = getDiagnosticInsights(score)
+
+    expect(
+      insights.some(i => i.includes('attention') || i.includes('refactoring')),
+    ).toBe(true)
+  })
+
+  it('should return empty array for healthy codebase', () => {
+    const score = { purity: 70, impurityQuality: 80, health: 85 }
+
+    const insights = getDiagnosticInsights(score)
+
+    // High purity, high quality, high health - may have some insights or none
+    // At least verify no errors
+    expect(Array.isArray(insights)).toBe(true)
+  })
+})