fcis 0.1.0 → 0.2.0

package/tests/scorer.test.ts

@@ -13,8 +13,12 @@ import {
   scoreDirectory,
   scoreProject,
   groupFilesByDirectory,
+  groupFunctionsByParent,
   calculateDelta,
   getDiagnosticInsights,
+  getPathAtDepth,
+  rollupDirectoriesByDepth,
+  aggregateMetrics,
 } from '../src/scoring/scorer.js'
 import type {
   ClassifiedFunction,
@@ -48,6 +52,8 @@ function createClassifiedFunction(
     classification: 'pure',
     qualityScore: null,
     status: 'ok',
+    enclosingFunctionStartLine: null,
+    isInlineCallback: false,
     ...overrides,
   }
 }
@@ -766,3 +772,883 @@ describe('getDiagnosticInsights', () => {
     expect(Array.isArray(insights)).toBe(true)
   })
 })
+
+describe('getPathAtDepth', () => {
+  it('should return first segment for depth 0', () => {
+    expect(getPathAtDepth('src/services/auth/utils', 0)).toBe('src')
+  })
+
+  it('should return first N+1 segments for depth N', () => {
+    expect(getPathAtDepth('src/services/auth/utils', 1)).toBe('src/services')
+    expect(getPathAtDepth('src/services/auth/utils', 2)).toBe(
+      'src/services/auth',
+    )
+    expect(getPathAtDepth('src/services/auth/utils', 3)).toBe(
+      'src/services/auth/utils',
+    )
+  })
+
+  it('should return full path when depth exceeds segments', () => {
+    expect(getPathAtDepth('src/utils', 5)).toBe('src/utils')
+    expect(getPathAtDepth('src', 10)).toBe('src')
+  })
+
+  it('should handle single segment paths', () => {
+    expect(getPathAtDepth('src', 0)).toBe('src')
+    expect(getPathAtDepth('src', 1)).toBe('src')
+  })
+
+  it('should handle empty path', () => {
+    expect(getPathAtDepth('', 0)).toBe('.')
+  })
+
+  it('should normalize backslashes to forward slashes', () => {
+    expect(getPathAtDepth('src\\services\\auth', 1)).toBe('src/services')
+  })
+})
+
+describe('rollupDirectoriesByDepth', () => {
+  /**
+   * Helper to create a directory score for rollup testing
+   */
+  function createDirScoreForRollup(
+    dirPath: string,
+    overrides: Partial<DirectoryScore> = {},
+  ): DirectoryScore {
+    return {
+      dirPath,
+      purity: 50,
+      impurityQuality: 60,
+      health: 75,
+      pureCount: 5,
+      impureCount: 5,
+      excludedCount: 0,
+      statusBreakdown: { ok: 7, review: 2, refactor: 1 },
+      pureLineCount: 50,
+      impureLineCount: 100,
+      fileScores: [],
+      ...overrides,
+    }
+  }
+
+  it('should return empty array for empty input', () => {
+    const rolled = rollupDirectoriesByDepth([], 1)
+    expect(rolled).toHaveLength(0)
+  })
+
+  it('should aggregate directories at depth 0', () => {
+    const dirs = [
+      createDirScoreForRollup('src/services/auth', {
+        pureCount: 5,
+        impureCount: 5,
+      }),
+      createDirScoreForRollup('src/services/users', {
+        pureCount: 3,
+        impureCount: 7,
+      }),
+      createDirScoreForRollup('src/utils/format', {
+        pureCount: 8,
+        impureCount: 2,
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    expect(rolled).toHaveLength(1)
+    expect(rolled[0]?.dirPath).toBe('src')
+    expect(rolled[0]?.pureCount).toBe(16)
+    expect(rolled[0]?.impureCount).toBe(14)
+  })
+
+  it('should aggregate directories at depth 1', () => {
+    const dirs = [
+      createDirScoreForRollup('src/services/auth', {
+        pureCount: 5,
+        impureCount: 5,
+      }),
+      createDirScoreForRollup('src/services/users', {
+        pureCount: 3,
+        impureCount: 7,
+      }),
+      createDirScoreForRollup('src/utils/format', {
+        pureCount: 8,
+        impureCount: 2,
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 1)
+
+    expect(rolled).toHaveLength(2)
+    expect(rolled.find(d => d.dirPath === 'src/services')?.pureCount).toBe(8)
+    expect(rolled.find(d => d.dirPath === 'src/services')?.impureCount).toBe(12)
+    expect(rolled.find(d => d.dirPath === 'src/utils')?.pureCount).toBe(8)
+    expect(rolled.find(d => d.dirPath === 'src/utils')?.impureCount).toBe(2)
+  })
+
+  it('should calculate weighted health correctly', () => {
+    const dirs = [
+      createDirScoreForRollup('src/a', {
+        pureCount: 10,
+        impureCount: 0,
+        statusBreakdown: { ok: 10, review: 0, refactor: 0 },
+      }),
+      createDirScoreForRollup('src/b', {
+        pureCount: 0,
+        impureCount: 10,
+        statusBreakdown: { ok: 0, review: 0, refactor: 10 },
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    // Weighted by function count: (10 ok out of 20 total) = 50%
+    expect(rolled[0]?.health).toBe(50)
+  })
+
+  it('should calculate weighted purity correctly', () => {
+    const dirs = [
+      createDirScoreForRollup('src/a', {
+        pureCount: 8,
+        impureCount: 2,
+        statusBreakdown: { ok: 10, review: 0, refactor: 0 },
+      }),
+      createDirScoreForRollup('src/b', {
+        pureCount: 2,
+        impureCount: 8,
+        statusBreakdown: { ok: 10, review: 0, refactor: 0 },
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    // Total: 10 pure, 10 impure = 50% purity
+    expect(rolled[0]?.purity).toBe(50)
+  })
+
+  it('should calculate weighted impurity quality correctly', () => {
+    const dirs = [
+      createDirScoreForRollup('src/a', {
+        pureCount: 0,
+        impureCount: 2,
+        impurityQuality: 80,
+        statusBreakdown: { ok: 2, review: 0, refactor: 0 },
+      }),
+      createDirScoreForRollup('src/b', {
+        pureCount: 0,
+        impureCount: 8,
+        impurityQuality: 40,
+        statusBreakdown: { ok: 8, review: 0, refactor: 0 },
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    // Weighted: (80*2 + 40*8) / 10 = 48
+    expect(rolled[0]?.impurityQuality).toBe(48)
+  })
+
+  it('should handle depth greater than actual nesting', () => {
+    const dirs = [
+      createDirScoreForRollup('src', { pureCount: 5, impureCount: 5 }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 5)
+
+    expect(rolled).toHaveLength(1)
+    expect(rolled[0]?.dirPath).toBe('src')
+  })
+
+  it('should sort results alphabetically by path', () => {
+    const dirs = [
+      createDirScoreForRollup('z/deep', {
+        pureCount: 1,
+        impureCount: 1,
+      }),
+      createDirScoreForRollup('a/deep', {
+        pureCount: 1,
+        impureCount: 1,
+      }),
+      createDirScoreForRollup('m/deep', {
+        pureCount: 1,
+        impureCount: 1,
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    expect(rolled.map(d => d.dirPath)).toEqual(['a', 'm', 'z'])
+  })
+
+  it('should have empty fileScores for rolled-up directories', () => {
+    const dirs = [
+      createDirScoreForRollup('src/a', {
+        pureCount: 5,
+        impureCount: 5,
+      }),
+      createDirScoreForRollup('src/b', {
+        pureCount: 5,
+        impureCount: 5,
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    expect(rolled[0]?.fileScores).toEqual([])
+  })
+
+  it('should aggregate excludedCount from all directories', () => {
+    const dirs = [
+      createDirScoreForRollup('src/a', {
+        pureCount: 5,
+        impureCount: 5,
+        excludedCount: 3,
+      }),
+      createDirScoreForRollup('src/b', {
+        pureCount: 5,
+        impureCount: 5,
+        excludedCount: 7,
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    expect(rolled[0]?.excludedCount).toBe(10)
+  })
+
+  it('should handle directories with no functions', () => {
+    const dirs = [
+      createDirScoreForRollup('src/types', {
+        pureCount: 0,
+        impureCount: 0,
+        statusBreakdown: { ok: 0, review: 0, refactor: 0 },
+      }),
+    ]
+
+    const rolled = rollupDirectoriesByDepth(dirs, 0)
+
+    expect(rolled).toHaveLength(1)
+    expect(rolled[0]?.purity).toBe(100)
+    expect(rolled[0]?.health).toBe(100)
+    expect(rolled[0]?.impurityQuality).toBeNull()
+  })
+})
+
+describe('aggregateMetrics', () => {
+  it('should aggregate metrics from multiple items', () => {
+    const items = [
+      {
+        pureCount: 5,
+        impureCount: 5,
+        impurityQuality: 80,
+        statusBreakdown: { ok: 8, review: 1, refactor: 1 },
+        pureLineCount: 50,
+        impureLineCount: 100,
+        excludedCount: 2,
+      },
+      {
+        pureCount: 3,
+        impureCount: 7,
+        impurityQuality: 40,
+        statusBreakdown: { ok: 5, review: 3, refactor: 2 },
+        pureLineCount: 30,
+        impureLineCount: 140,
+        excludedCount: 1,
+      },
+    ]
+
+    const aggregated = aggregateMetrics(items)
+
+    expect(aggregated.pureCount).toBe(8)
+    expect(aggregated.impureCount).toBe(12)
+    expect(aggregated.purity).toBe(40) // 8 / 20 = 40%
+    expect(aggregated.statusBreakdown.ok).toBe(13)
+    expect(aggregated.statusBreakdown.review).toBe(4)
+    expect(aggregated.statusBreakdown.refactor).toBe(3)
+    expect(aggregated.health).toBe(65) // 13 / 20 = 65%
+    expect(aggregated.pureLineCount).toBe(80)
+    expect(aggregated.impureLineCount).toBe(240)
+    expect(aggregated.excludedCount).toBe(3)
+  })
+
+  it('should return defaults for empty array', () => {
+    const aggregated = aggregateMetrics([])
+
+    expect(aggregated.purity).toBe(100)
+    expect(aggregated.health).toBe(100)
+    expect(aggregated.impurityQuality).toBeNull()
+    expect(aggregated.pureCount).toBe(0)
+    expect(aggregated.impureCount).toBe(0)
+  })
+
+  it('should calculate weighted impurity quality', () => {
+    const items = [
+      {
+        pureCount: 0,
+        impureCount: 2,
+        impurityQuality: 100,
+        statusBreakdown: { ok: 2, review: 0, refactor: 0 },
+        pureLineCount: 0,
+        impureLineCount: 20,
+        excludedCount: 0,
+      },
+      {
+        pureCount: 0,
+        impureCount: 8,
+        impurityQuality: 50,
+        statusBreakdown: { ok: 8, review: 0, refactor: 0 },
+        pureLineCount: 0,
+        impureLineCount: 80,
+        excludedCount: 0,
+      },
+    ]
+
+    const aggregated = aggregateMetrics(items)
+
+    // Weighted: (100*2 + 50*8) / 10 = 60
+    expect(aggregated.impurityQuality).toBe(60)
+  })
+})
+
+describe('groupFunctionsByParent', () => {
+  it('should group inline callbacks under their parent function', () => {
+    const parent = createClassifiedFunction({
+      name: 'parentFunction',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const callback1 = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1, // links to parent
+    })
+
+    const callback2 = createClassifiedFunction({
+      name: 'map',
+      startLine: 25,
+      endLine: 30,
+      bodyLineCount: 6,
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1, // links to parent
+    })
+
+    const grouped = groupFunctionsByParent([parent, callback1, callback2])
+
+    expect(grouped).toHaveLength(1) // only 1 top-level function
+    expect(grouped[0]?.fn.name).toBe('parentFunction')
+    expect(grouped[0]?.children).toHaveLength(2)
+  })
+
+  it('should treat module-scope inline callbacks as top-level', () => {
+    const moduleScopeCallback = createClassifiedFunction({
+      name: 'map',
+      startLine: 1,
+      endLine: 10,
+      bodyLineCount: 10,
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: null, // module scope
+    })
+
+    const grouped = groupFunctionsByParent([moduleScopeCallback])
+
+    expect(grouped).toHaveLength(1)
+    expect(grouped[0]?.fn.name).toBe('map')
+    expect(grouped[0]?.children).toHaveLength(0)
+  })
+
+  it('should treat non-inline-callback functions as top-level', () => {
+    const regularFn = createClassifiedFunction({
+      name: 'regularFunction',
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const trpcHandler = createClassifiedFunction({
+      name: 'query',
+      parentContext: 'query',
+      isInlineCallback: false, // tRPC handlers are not inline callbacks
+      enclosingFunctionStartLine: null,
+    })
+
+    const grouped = groupFunctionsByParent([regularFn, trpcHandler])
+
+    expect(grouped).toHaveLength(2)
+  })
+})
+
+describe('compositional scoring', () => {
+  it('should count only top-level functions', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'pure',
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const callback1 = createClassifiedFunction({
+      name: 'map',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'pure',
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const callback2 = createClassifiedFunction({
+      name: 'filter',
+      startLine: 25,
+      endLine: 30,
+      bodyLineCount: 6,
+      classification: 'pure',
+      parentContext: 'filter',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, callback1, callback2])
+
+    // Should count only 1 top-level function, not 3
+    expect(score.pureCount + score.impureCount).toBe(1)
+    expect(score.pureCount).toBe(1)
+    expect(score.impureCount).toBe(0)
+  })
+
+  it('should not double-count line counts', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50, // includes callback lines
+      classification: 'pure',
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const callback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'pure',
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, callback])
+
+    // Line count should be 50 (parent's lines), not 61 (50 + 11)
+    expect(score.pureLineCount).toBe(50)
+    expect(score.impureLineCount).toBe(0)
+  })
+
+  it('should treat module-scope inline callbacks independently', () => {
+    const moduleScopeCallback = createClassifiedFunction({
+      name: 'map',
+      startLine: 1,
+      endLine: 15,
+      bodyLineCount: 15,
+      statementCount: 5,
+      classification: 'impure',
+      qualityScore: 50,
+      status: 'review',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: null, // module scope - no enclosing function
+    })
+
+    const score = scoreFile('/test.ts', [moduleScopeCallback])
+
+    // Should count as its own function since it has no parent
+    expect(score.pureCount + score.impureCount).toBe(1)
+    expect(score.impureCount).toBe(1)
+  })
+
+  it('should make parent effectively impure if callback is impure', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'pure', // parent itself is pure
+      qualityScore: null,
+      status: 'ok',
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const impureCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'impure', // callback is impure
+      qualityScore: 40,
+      status: 'review',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, impureCallback])
+
+    // Parent should be counted as effectively impure
+    expect(score.pureCount).toBe(0)
+    expect(score.impureCount).toBe(1)
+    expect(score.impureLineCount).toBe(50)
+    expect(score.pureLineCount).toBe(0)
+  })
+
+  it('should use worst status among parent and children', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 75,
+      status: 'ok', // parent is ok
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const badCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'impure',
+      qualityScore: 20,
+      status: 'refactor', // callback needs refactoring
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, badCallback])
+
+    // Status breakdown should reflect the worst status
+    expect(score.statusBreakdown.refactor).toBe(1)
+    expect(score.statusBreakdown.ok).toBe(0)
+    expect(score.health).toBe(0) // 0% health because the only function needs refactoring
+  })
+
+  it('should calculate health based on effective status', () => {
+    const goodParent = createClassifiedFunction({
+      name: 'goodFunction',
+      startLine: 1,
+      endLine: 30,
+      bodyLineCount: 30,
+      classification: 'pure',
+      status: 'ok',
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const parentWithBadCallback = createClassifiedFunction({
+      name: 'parentWithIssue',
+      startLine: 50,
+      endLine: 100,
+      bodyLineCount: 51,
+      classification: 'impure',
+      qualityScore: 75,
+      status: 'ok',
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const badCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 60,
+      endLine: 70,
+      bodyLineCount: 11,
+      classification: 'impure',
+      qualityScore: 30,
+      status: 'refactor',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 50,
+    })
+
+    const score = scoreFile('/test.ts', [
+      goodParent,
+      parentWithBadCallback,
+      badCallback,
+    ])
+
+    // 2 top-level functions: 1 ok, 1 refactor
+    expect(score.pureCount + score.impureCount).toBe(2)
+    expect(score.statusBreakdown.ok).toBe(1)
+    expect(score.statusBreakdown.refactor).toBe(1)
+    expect(score.health).toBe(50) // 1/2 = 50%
+  })
+
+  it('should aggregate markers from children into refactoring candidates', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 30,
+      status: 'refactor',
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const callback1 = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'impure',
+      qualityScore: 20,
+      status: 'refactor',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const callback2 = createClassifiedFunction({
+      name: 'map',
+      startLine: 25,
+      endLine: 35,
+      bodyLineCount: 11,
+      classification: 'impure',
+      qualityScore: 25,
+      status: 'refactor',
+      markers: [
+        { type: 'logging', detail: 'logger.info' },
+        { type: 'console-log', detail: 'console.log' }, // duplicate type
+      ],
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, callback1, callback2])
+
+    // Should have 1 refactoring candidate (the parent)
+    expect(score.refactoringCandidates).toHaveLength(1)
+
+    const candidate = score.refactoringCandidates[0]
+    expect(candidate?.name).toBe('processItems')
+
+    // Markers should be aggregated and deduped
+    // Parent: database-call
+    // Callback1: console-log
+    // Callback2: logging, console-log (dupe)
+    expect(candidate?.markers).toContain('database-call')
+    expect(candidate?.markers).toContain('console-log')
+    expect(candidate?.markers).toContain('logging')
+    // Should be deduped (console-log appears only once)
+    expect(candidate?.markers.filter(m => m === 'console-log')).toHaveLength(1)
+  })
+
+  it('should blend parent and impure child quality by line count', () => {
+    // Parent: 50 total lines, 40 own lines (after subtracting child), quality 60
+    // Child: 10 lines, quality 40
+    // Composed: (60*40 + 40*10) / 50 = (2400 + 400) / 50 = 56
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 60,
+      status: 'review',
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const impureCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 19,
+      bodyLineCount: 10,
+      classification: 'impure',
+      qualityScore: 40,
+      status: 'review',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, impureCallback])
+
+    // impurityQuality should be the composed quality: 56
+    expect(score.impurityQuality).toBeCloseTo(56, 0)
+  })
+
+  it('should not affect quality if all children are pure', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 60,
+      status: 'review',
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const pureCallback = createClassifiedFunction({
+      name: 'map',
+      startLine: 10,
+      endLine: 19,
+      bodyLineCount: 10,
+      classification: 'pure',
+      qualityScore: null,
+      status: 'ok',
+      markers: [],
+      parentContext: 'map',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, pureCallback])
+
+    // Quality should be unchanged (60) since all children are pure
+    expect(score.impurityQuality).toBe(60)
+  })
+
+  it('should weight heavily toward child when child dominates line count', () => {
+    // Parent: 50 total lines, 10 own lines, quality 60
+    // Child: 40 lines, quality 20
+    // Composed: (60*10 + 20*40) / 50 = (600 + 800) / 50 = 28
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 60,
+      status: 'review',
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const largeImpureCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 5,
+      endLine: 44,
+      bodyLineCount: 40,
+      classification: 'impure',
+      qualityScore: 20,
+      status: 'refactor',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, largeImpureCallback])
+
+    // impurityQuality should be heavily influenced by the child: 28
+    expect(score.impurityQuality).toBeCloseTo(28, 0)
+  })
+
+  it('should handle pure parent with impure children', () => {
+    // Parent is pure (no direct markers), but has impure callback
+    // Result should still calculate quality for the impure child
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'pure', // parent itself is pure
+      qualityScore: null,
+      status: 'ok',
+      markers: [],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const impureCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 29,
+      bodyLineCount: 20,
+      classification: 'impure',
+      qualityScore: 40,
+      status: 'review',
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, impureCallback])
+
+    // Parent is effectively impure, quality blended:
+    // parentOwnLines = 50 - 20 = 30, parentQuality = 50 (default for pure)
+    // childLines = 20, childQuality = 40
+    // composed = (50*30 + 40*20) / 50 = (1500 + 800) / 50 = 46
+    expect(score.impureCount).toBe(1)
+    expect(score.pureCount).toBe(0)
+    expect(score.impurityQuality).toBeCloseTo(46, 0)
+  })
+
+  it('should not include callbacks in refactoring candidates list', () => {
+    const parent = createClassifiedFunction({
+      name: 'processItems',
+      startLine: 1,
+      endLine: 50,
+      bodyLineCount: 50,
+      classification: 'impure',
+      qualityScore: 75,
+      status: 'ok', // parent is ok
+      markers: [{ type: 'database-call', detail: 'db.find' }],
+      isInlineCallback: false,
+      enclosingFunctionStartLine: null,
+    })
+
+    const badCallback = createClassifiedFunction({
+      name: 'forEach',
+      startLine: 10,
+      endLine: 20,
+      bodyLineCount: 11,
+      classification: 'impure',
+      qualityScore: 20,
+      status: 'refactor', // callback needs refactoring
+      markers: [{ type: 'console-log', detail: 'console.log' }],
+      parentContext: 'forEach',
+      isInlineCallback: true,
+      enclosingFunctionStartLine: 1,
+    })
+
+    const score = scoreFile('/test.ts', [parent, badCallback])
+
+    // The callback itself should NOT appear as a separate refactoring candidate
+    // Only the parent (with effective status 'refactor') should be a candidate
+    expect(score.refactoringCandidates).toHaveLength(1)
+    expect(score.refactoringCandidates[0]?.name).toBe('processItems')
+  })
+})