fcis 0.1.0 → 0.2.0

package/tests/integration.test.ts

@@ -703,4 +703,348 @@ describe('Integration: Full Pipeline', () => {
       expect(computeResult?.classification).toBe('pure')
     })
   })
+
+  describe('checkForConditionals scoping', () => {
+    it('should NOT detect conditionals inside nested callbacks', () => {
+      const project = createTestProject({
+        '/src/no-leak.ts': `
+          function outer() {
+            const x = items.map(item => item.active ? item.name : 'unknown')
+            const y = x.length
+            const z = y + 1
+            return z
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/no-leak.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const outer = functions.find(f => f.name === 'outer')
+
+      // The ternary is inside the callback, not in outer itself
+      expect(outer?.hasConditionals).toBe(false)
+    })
+
+    it('should still detect conditionals in the function itself', () => {
+      const project = createTestProject({
+        '/src/has-conditional.ts': `
+          function outer() {
+            if (items.length === 0) return []
+            const result = items
+            const final = result
+            return final
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/has-conditional.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const outer = functions.find(f => f.name === 'outer')
+
+      expect(outer?.hasConditionals).toBe(true)
+    })
+
+    it('should detect conditionals in callback but not leak to parent', () => {
+      const project = createTestProject({
+        '/src/callback-conditional.ts': `
+          function process() {
+            const results = items.forEach(item => {
+              if (item.active) {
+                doSomething(item)
+              }
+              logItem(item)
+              saveItem(item)
+            })
+            const x = 1
+            const y = 2
+            return results
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/callback-conditional.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const process = functions.find(f => f.name === 'process')
+      const callback = functions.find(f => f.parentContext === 'forEach')
+
+      // Parent should NOT have conditionals (the if is in the callback)
+      expect(process?.hasConditionals).toBe(false)
+      // Callback SHOULD have conditionals
+      expect(callback?.hasConditionals).toBe(true)
+    })
+
+    it('should handle switch statements in callbacks without leaking', () => {
+      const project = createTestProject({
+        '/src/switch-callback.ts': `
+          function handleItems() {
+            items.map(item => {
+              switch (item.type) {
+                case 'a': return 1
+                case 'b': return 2
+                default: return 0
+              }
+            })
+            const a = 1
+            const b = 2
+            return a + b
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/switch-callback.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const handleItems = functions.find(f => f.name === 'handleItems')
+      const callback = functions.find(f => f.parentContext === 'map')
+
+      expect(handleItems?.hasConditionals).toBe(false)
+      expect(callback?.hasConditionals).toBe(true)
+    })
+  })
+
+  describe('inline callback detection', () => {
+    it('should mark arrow functions passed to map as inline callbacks', () => {
+      const project = createTestProject({
+        '/src/map-callback.ts': `
+          const result = items.map(item => item.value)
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/map-callback.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const callback = functions.find(f => f.parentContext === 'map')
+
+      expect(callback?.isInlineCallback).toBe(true)
+      expect(callback?.enclosingFunctionStartLine).toBeNull() // module-scope
+    })
+
+    it('should link nested callbacks to their enclosing function', () => {
+      const project = createTestProject({
+        '/src/nested-callback.ts': `
+          function outer() {
+            items.forEach(item => {
+              console.log(item)
+              doSomething(item)
+              saveItem(item)
+            })
+            const x = 1
+            const y = 2
+            return x + y
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/nested-callback.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const outer = functions.find(f => f.name === 'outer')
+      const callback = functions.find(f => f.parentContext === 'forEach')
+
+      expect(callback?.isInlineCallback).toBe(true)
+      expect(callback?.enclosingFunctionStartLine).toBe(outer?.startLine)
+    })
+
+    it('should NOT mark callbacks to unknown methods as inline', () => {
+      const project = createTestProject({
+        '/src/custom-method.ts': `
+          const result = customMethod(item => item.value)
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/custom-method.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const callback = functions.find(f => f.parentContext === 'customMethod')
+
+      expect(callback?.isInlineCallback).toBe(false)
+      expect(callback?.enclosingFunctionStartLine).toBeNull()
+    })
+
+    it('should NOT mark tRPC handlers as inline callbacks', () => {
+      const project = createTestProject({
+        '/src/trpc-router.ts': `
+          export const router = createRouter({
+            getUser: query(async ({ ctx }) => {
+              const user = await ctx.db.user.findFirst()
+              const formatted = formatUser(user)
+              return formatted
+            }),
+          })
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/trpc-router.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const handler = functions.find(f => f.parentContext === 'query')
+
+      expect(handler?.isInlineCallback).toBe(false)
+    })
+
+    it('should handle deeply nested callbacks with correct enclosing function', () => {
+      const project = createTestProject({
+        '/src/deeply-nested.ts': `
+          function process() {
+            items.forEach(item => {
+              item.tags.map(tag => tag.name)
+              doSomething(item)
+              logItem(item)
+            })
+            const a = 1
+            const b = 2
+            return a + b
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/deeply-nested.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+      const process = functions.find(f => f.name === 'process')
+      const forEachCb = functions.find(f => f.parentContext === 'forEach')
+      const mapCb = functions.find(f => f.parentContext === 'map')
+
+      // forEach callback links to process
+      expect(forEachCb?.isInlineCallback).toBe(true)
+      expect(forEachCb?.enclosingFunctionStartLine).toBe(process?.startLine)
+
+      // map callback's enclosing function is the forEach callback
+      expect(mapCb?.isInlineCallback).toBe(true)
+      expect(mapCb?.enclosingFunctionStartLine).toBe(forEachCb?.startLine)
+    })
+
+    it('should mark filter, reduce, find, some, every as inline callbacks', () => {
+      const project = createTestProject({
+        '/src/array-methods.ts': `
+          function processItems() {
+            const filtered = items.filter(x => x.active)
+            const reduced = items.reduce((acc, x) => acc + x.value, 0)
+            const found = items.find(x => x.id === 1)
+            const hasAny = items.some(x => x.valid)
+            const allValid = items.every(x => x.ok)
+            return { filtered, reduced, found, hasAny, allValid }
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/array-methods.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+
+      const filterCb = functions.find(f => f.parentContext === 'filter')
+      const reduceCb = functions.find(f => f.parentContext === 'reduce')
+      const findCb = functions.find(f => f.parentContext === 'find')
+      const someCb = functions.find(f => f.parentContext === 'some')
+      const everyCb = functions.find(f => f.parentContext === 'every')
+
+      expect(filterCb?.isInlineCallback).toBe(true)
+      expect(reduceCb?.isInlineCallback).toBe(true)
+      expect(findCb?.isInlineCallback).toBe(true)
+      expect(someCb?.isInlineCallback).toBe(true)
+      expect(everyCb?.isInlineCallback).toBe(true)
+    })
+
+    it('should mark Promise methods as inline callbacks', () => {
+      const project = createTestProject({
+        '/src/promise-methods.ts': `
+          function fetchData() {
+            return fetch('/api')
+              .then(res => res.json())
+              .catch(err => handleError(err))
+              .finally(() => cleanup())
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/promise-methods.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+
+      const thenCb = functions.find(f => f.parentContext === 'then')
+      const catchCb = functions.find(f => f.parentContext === 'catch')
+      const finallyCb = functions.find(f => f.parentContext === 'finally')
+
+      expect(thenCb?.isInlineCallback).toBe(true)
+      expect(catchCb?.isInlineCallback).toBe(true)
+      expect(finallyCb?.isInlineCallback).toBe(true)
+    })
+
+    it('should NOT mark mutation/subscription as inline callbacks', () => {
+      const project = createTestProject({
+        '/src/trpc-handlers.ts': `
+          export const router = {
+            create: mutation(async ({ input }) => {
+              const result = await db.create(input)
+              const formatted = format(result)
+              return formatted
+            }),
+            onUpdate: subscription(({ ctx }) => {
+              return observable(emit => {
+                ctx.ee.on('update', emit)
+              })
+            }),
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/trpc-handlers.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+
+      const mutationCb = functions.find(f => f.parentContext === 'mutation')
+      const subscriptionCb = functions.find(
+        f => f.parentContext === 'subscription',
+      )
+
+      expect(mutationCb?.isInlineCallback).toBe(false)
+      expect(subscriptionCb?.isInlineCallback).toBe(false)
+    })
+
+    it('should set isInlineCallback false for regular named functions', () => {
+      const project = createTestProject({
+        '/src/regular-functions.ts': `
+          function regularFunction() {
+            const x = 1
+            const y = 2
+            return x + y
+          }
+
+          const arrowFunction = () => {
+            const a = 1
+            const b = 2
+            return a + b
+          }
+        `,
+      })
+
+      const sourceFile = project.getSourceFile('/src/regular-functions.ts')
+      if (!sourceFile) throw new Error('File not found')
+
+      const functions = extractFunctions(sourceFile)
+
+      const regular = functions.find(f => f.name === 'regularFunction')
+      const arrow = functions.find(f => f.name === 'arrowFunction')
+
+      expect(regular?.isInlineCallback).toBe(false)
+      expect(regular?.enclosingFunctionStartLine).toBeNull()
+      expect(arrow?.isInlineCallback).toBe(false)
+      expect(arrow?.enclosingFunctionStartLine).toBeNull()
+    })
+  })
 })

package/tests/report-console.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Report Console Tests
+ *
+ * Tests for the console reporting shell layer.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import { relativizeDirectoryPaths } from '../src/reporting/report-console.js'
+import type { DirectoryScore } from '../src/types.js'
+
+/**
+ * Helper to create a directory score for testing
+ */
+function createDirScore(
+  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,
+  }
+}
+
+describe('relativizeDirectoryPaths', () => {
+  it('should convert absolute paths to relative paths', () => {
+    const dirs = [
+      createDirScore('/project/src/services'),
+      createDirScore('/project/src/utils'),
+    ]
+
+    const result = relativizeDirectoryPaths(dirs, '/project')
+
+    expect(result[0]?.dirPath).toBe('src/services')
+    expect(result[1]?.dirPath).toBe('src/utils')
+  })
+
+  it('should normalize backslashes to forward slashes', () => {
+    const dirs = [createDirScore('/project/src\\services\\auth')]
+
+    const result = relativizeDirectoryPaths(dirs, '/project')
+
+    expect(result[0]?.dirPath).toBe('src/services/auth')
+  })
+
+  it('should preserve other directory properties', () => {
+    const dirs = [
+      createDirScore('/project/src', {
+        pureCount: 10,
+        impureCount: 5,
+        health: 80,
+        purity: 66.67,
+        impurityQuality: 75,
+      }),
+    ]
+
+    const result = relativizeDirectoryPaths(dirs, '/project')
+
+    expect(result[0]?.dirPath).toBe('src')
+    expect(result[0]?.pureCount).toBe(10)
+    expect(result[0]?.impureCount).toBe(5)
+    expect(result[0]?.health).toBe(80)
+    expect(result[0]?.purity).toBe(66.67)
+    expect(result[0]?.impurityQuality).toBe(75)
+  })
+
+  it('should handle empty array', () => {
+    const result = relativizeDirectoryPaths([], '/project')
+
+    expect(result).toEqual([])
+  })
+
+  it('should handle paths that are already relative', () => {
+    const dirs = [createDirScore('src/services')]
+
+    const result = relativizeDirectoryPaths(dirs, '/project')
+
+    // path.relative will return the path as-is or with ../ prefix
+    // depending on the relationship
+    expect(result[0]?.dirPath).toBeDefined()
+  })
+})