fcis 0.1.0 → 0.2.0

package/src/types.ts

@@ -31,7 +31,7 @@ export type ExtractedFunction = {
   bodyLineCount: number
   statementCount: number
   hasConditionals: boolean
-  parentContext: string | null // e.g. class name, variable name
+  parentContext: string | null // e.g. class name, variable name, or HOF method name
   callSites: CallSite[] // enriched call expressions with position and await context
   hasAwait: boolean // convenience flag: true if any callSite.isAwaited
   propertyAccessChains: string[] // e.g. ["process.env.NODE_ENV", "db.user"]
@@ -42,6 +42,11 @@ export type ExtractedFunction = {
     | 'function-expression'
     | 'getter'
     | 'setter'
+  // Compositional scoring fields (Plan 007)
+  // Reference to enclosing function for inline callbacks; null if at module scope or not a callback
+  enclosingFunctionStartLine: number | null
+  // True if this is an inline callback passed to a known HOF (map, filter, forEach, etc.)
+  isInlineCallback: boolean
 }
 
 /**
@@ -65,7 +70,6 @@ export type MarkerType =
   | 'database-call'
   | 'network-fetch'
   | 'network-http'
-  | 'fs-import'
   | 'fs-call'
   | 'env-access'
   | 'console-log'
@@ -187,6 +191,8 @@ export type ProjectScore = {
   filesGlob?: string // the glob pattern used for --files
   // Errors encountered during analysis
   errors?: AnalysisError[]
+  // Rolled-up directories (when --dir-depth is used)
+  rolledUpDirectories?: DirectoryScore[]
 }
 
 /**
@@ -210,6 +216,7 @@ export type AnalyzerConfig = {
   outputPath?: string
   quiet?: boolean
   verbose?: boolean
+  dirDepth?: number
 }
 
 /**

package/tests/classifier.test.ts

@@ -155,7 +155,6 @@ describe('classifyFunction', () => {
         'database-call',
         'network-fetch',
         'network-http',
-        'fs-import',
         'fs-call',
         'env-access',
         'console-log',

package/tests/cli.test.ts

@@ -0,0 +1,356 @@
+/**
+ * CLI Tests
+ *
+ * Tests for the extracted pure functions from the CLI module.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+import {
+  validateCliFlags,
+  validateGlobPattern,
+  buildAnalyzerConfig,
+  buildThresholdConfig,
+  type CliFlags,
+} from '../src/cli-utils.js'
+
+/**
+ * Helper to create default CLI flags
+ */
+function createDefaultFlags(overrides: Partial<CliFlags> = {}): CliFlags {
+  return {
+    json: false,
+    output: undefined,
+    minHealth: undefined,
+    minPurity: undefined,
+    minQuality: undefined,
+    files: undefined,
+    format: 'console',
+    quiet: false,
+    verbose: false,
+    dirDepth: undefined,
+    version: undefined,
+    help: undefined,
+    ...overrides,
+  }
+}
+
+describe('validateCliFlags', () => {
+  describe('threshold validation', () => {
+    it('should accept valid minHealth', () => {
+      const flags = createDefaultFlags({ minHealth: 70 })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept minHealth of 0', () => {
+      const flags = createDefaultFlags({ minHealth: 0 })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept minHealth of 100', () => {
+      const flags = createDefaultFlags({ minHealth: 100 })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should reject minHealth > 100', () => {
+      const flags = createDefaultFlags({ minHealth: 101 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--min-health')
+      }
+    })
+
+    it('should reject minHealth < 0', () => {
+      const flags = createDefaultFlags({ minHealth: -1 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+    })
+
+    it('should reject minPurity > 100', () => {
+      const flags = createDefaultFlags({ minPurity: 150 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--min-purity')
+      }
+    })
+
+    it('should reject minQuality > 100', () => {
+      const flags = createDefaultFlags({ minQuality: 200 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--min-quality')
+      }
+    })
+
+    it('should accept all thresholds at once', () => {
+      const flags = createDefaultFlags({
+        minHealth: 70,
+        minPurity: 50,
+        minQuality: 60,
+      })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+  })
+
+  describe('format validation', () => {
+    it('should accept console format', () => {
+      const flags = createDefaultFlags({ format: 'console' })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept json format', () => {
+      const flags = createDefaultFlags({ format: 'json' })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept summary format', () => {
+      const flags = createDefaultFlags({ format: 'summary' })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should reject invalid format', () => {
+      const flags = createDefaultFlags({ format: 'xml' })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--format')
+      }
+    })
+  })
+
+  describe('--dir-depth validation', () => {
+    it('should accept positive integer', () => {
+      const flags = createDefaultFlags({ dirDepth: 2 })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept depth of 1', () => {
+      const flags = createDefaultFlags({ dirDepth: 1 })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should reject zero', () => {
+      const flags = createDefaultFlags({ dirDepth: 0 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--dir-depth')
+      }
+    })
+
+    it('should reject negative numbers', () => {
+      const flags = createDefaultFlags({ dirDepth: -1 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--dir-depth')
+      }
+    })
+
+    it('should reject non-integers', () => {
+      const flags = createDefaultFlags({ dirDepth: 1.5 })
+      const result = validateCliFlags(flags)
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('--dir-depth')
+      }
+    })
+
+    it('should accept undefined (flag not provided)', () => {
+      const flags = createDefaultFlags({ dirDepth: undefined })
+      const result = validateCliFlags(flags)
+      expect(result).toEqual({ valid: true })
+    })
+  })
+})
+
+describe('validateGlobPattern', () => {
+  describe('valid patterns', () => {
+    it('should accept simple glob', () => {
+      const result = validateGlobPattern('src/**/*.ts')
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept pattern with brackets', () => {
+      const result = validateGlobPattern('src/[abc]/*.ts')
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept pattern with braces', () => {
+      const result = validateGlobPattern('src/{a,b,c}/*.ts')
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should accept relative path', () => {
+      const result = validateGlobPattern('./src/**/*.ts')
+      expect(result).toEqual({ valid: true })
+    })
+  })
+
+  describe('invalid patterns', () => {
+    it('should reject empty pattern', () => {
+      const result = validateGlobPattern('')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('empty')
+      }
+    })
+
+    it('should reject whitespace-only pattern', () => {
+      const result = validateGlobPattern('   ')
+      expect(result.valid).toBe(false)
+    })
+
+    it('should reject absolute path', () => {
+      const result = validateGlobPattern('/Users/test/src/**/*.ts')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('absolute')
+      }
+    })
+
+    it('should reject unbalanced opening bracket', () => {
+      const result = validateGlobPattern('src/[incomplete/*.ts')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('unbalanced')
+      }
+    })
+
+    it('should reject unbalanced closing bracket', () => {
+      const result = validateGlobPattern('src/incomplete]/*.ts')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('unbalanced')
+      }
+    })
+
+    it('should reject unbalanced opening brace', () => {
+      const result = validateGlobPattern('src/{a,b/*.ts')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('unbalanced')
+      }
+    })
+
+    it('should reject unbalanced closing brace', () => {
+      const result = validateGlobPattern('src/a,b}/*.ts')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('unbalanced')
+      }
+    })
+  })
+})
+
+describe('buildAnalyzerConfig', () => {
+  it('should build minimal config', () => {
+    const flags = createDefaultFlags()
+    const config = buildAnalyzerConfig('/path/to/tsconfig.json', flags)
+
+    expect(config.tsconfigPath).toBe('/path/to/tsconfig.json')
+    expect(config.format).toBe('console')
+    expect(config.quiet).toBe(false)
+    expect(config.verbose).toBe(false)
+    expect(config.filesGlob).toBeUndefined()
+    expect(config.minHealth).toBeUndefined()
+    expect(config.dirDepth).toBeUndefined()
+  })
+
+  it('should include optional properties when provided', () => {
+    const flags = createDefaultFlags({
+      files: 'src/**/*.ts',
+      minHealth: 70,
+      minPurity: 50,
+      minQuality: 60,
+      output: 'report.json',
+      format: 'json',
+      quiet: true,
+      verbose: true,
+      dirDepth: 2,
+    })
+    const config = buildAnalyzerConfig('/path/to/tsconfig.json', flags)
+
+    expect(config.tsconfigPath).toBe('/path/to/tsconfig.json')
+    expect(config.filesGlob).toBe('src/**/*.ts')
+    expect(config.minHealth).toBe(70)
+    expect(config.minPurity).toBe(50)
+    expect(config.minQuality).toBe(60)
+    expect(config.outputPath).toBe('report.json')
+    expect(config.format).toBe('json')
+    expect(config.quiet).toBe(true)
+    expect(config.verbose).toBe(true)
+    expect(config.dirDepth).toBe(2)
+  })
+
+  it('should include dirDepth when provided', () => {
+    const flags = createDefaultFlags({ dirDepth: 1 })
+    const config = buildAnalyzerConfig('/path/to/tsconfig.json', flags)
+
+    expect(config.dirDepth).toBe(1)
+  })
+
+  it('should not include dirDepth when undefined', () => {
+    const flags = createDefaultFlags({ dirDepth: undefined })
+    const config = buildAnalyzerConfig('/path/to/tsconfig.json', flags)
+
+    expect(config.dirDepth).toBeUndefined()
+  })
+})
+
+describe('buildThresholdConfig', () => {
+  it('should return empty object when no thresholds set', () => {
+    const flags = createDefaultFlags()
+    const config = buildThresholdConfig(flags)
+
+    expect(config).toEqual({})
+  })
+
+  it('should include minHealth when set', () => {
+    const flags = createDefaultFlags({ minHealth: 70 })
+    const config = buildThresholdConfig(flags)
+
+    expect(config).toEqual({ minHealth: 70 })
+  })
+
+  it('should include minPurity when set', () => {
+    const flags = createDefaultFlags({ minPurity: 50 })
+    const config = buildThresholdConfig(flags)
+
+    expect(config).toEqual({ minPurity: 50 })
+  })
+
+  it('should include minQuality when set', () => {
+    const flags = createDefaultFlags({ minQuality: 60 })
+    const config = buildThresholdConfig(flags)
+
+    expect(config).toEqual({ minQuality: 60 })
+  })
+
+  it('should include all thresholds when all set', () => {
+    const flags = createDefaultFlags({
+      minHealth: 70,
+      minPurity: 50,
+      minQuality: 60,
+    })
+    const config = buildThresholdConfig(flags)
+
+    expect(config).toEqual({
+      minHealth: 70,
+      minPurity: 50,
+      minQuality: 60,
+    })
+  })
+})

package/tests/detect-markers.test.ts

@@ -271,9 +271,7 @@ describe('detectMarkers', () => {
 
       const markers = detectMarkers(fn, context)
 
-      expect(
-        markers.filter(m => m.type === 'fs-import' || m.type === 'fs-call'),
-      ).toHaveLength(0)
+      expect(markers.filter(m => m.type === 'fs-call')).toHaveLength(0)
     })
 
     it('should detect fs.readFile calls', () => {

package/tests/extractor.test.ts

@@ -10,7 +10,10 @@ import * as fs from 'node:fs'
 import * as path from 'node:path'
 import * as os from 'node:os'
 
-import { loadProject } from '../src/extraction/extractor.js'
+import {
+  loadProject,
+  validateTsconfigContent,
+} from '../src/extraction/extractor.js'
 
 describe('loadProject', () => {
   let tempDir: string
@@ -126,6 +129,97 @@ describe('loadProject', () => {
 
       expect(() => loadProject({ tsconfigPath })).not.toThrow()
     })
+
+    it('should parse tsconfig with trailing commas', () => {
+      const tsconfigContent = `{
+        "compilerOptions": {
+          "typeRoots": [
+            "./node_modules/@types",
+          ]
+        },
+        "include": [
+          "./src/**/*.ts",
+        ],
+        "exclude": [
+          "node_modules",
+        ],
+      }`
+
+      const tsconfigPath = path.join(tempDir, 'tsconfig.json')
+      fs.writeFileSync(tsconfigPath, tsconfigContent)
+
+      // Create a simple source file
+      fs.writeFileSync(path.join(tempDir, 'index.ts'), 'export const foo = 1;')
+
+      expect(() => loadProject({ tsconfigPath })).not.toThrow()
+    })
+
+    it('should parse tsconfig with extends and trailing comma in array (like packages/chat)', () => {
+      // This matches the exact format of packages/chat/tsconfig.json
+      const tsconfigContent = `{
+  "extends": "@sai/tsconfig/pkg.json",
+  "compilerOptions": {
+    "typeRoots": [
+      "./node_modules/@types",
+    ]
+  },
+  "include": [
+    "./src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}`
+
+      const tsconfigPath = path.join(tempDir, 'tsconfig.json')
+      fs.writeFileSync(tsconfigPath, tsconfigContent)
+
+      // Create a simple source file
+      fs.writeFileSync(path.join(tempDir, 'index.ts'), 'export const foo = 1;')
+
+      expect(() => loadProject({ tsconfigPath })).not.toThrow()
+    })
+  })
+
+  describe('validateTsconfigContent', () => {
+    it('should return valid for correct JSON', () => {
+      const result = validateTsconfigContent('{ "compilerOptions": {} }')
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should return valid for JSONC with comments', () => {
+      const content = `{
+      // This is a comment
+      "compilerOptions": {
+        "target": "es2022" /* inline */
+      }
+    }`
+      const result = validateTsconfigContent(content)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should return valid for JSONC with trailing commas', () => {
+      const content = `{
+      "compilerOptions": {
+        "lib": ["es2023",],
+      },
+    }`
+      const result = validateTsconfigContent(content)
+      expect(result).toEqual({ valid: true })
+    })
+
+    it('should return error for invalid JSON', () => {
+      const result = validateTsconfigContent('{ invalid }')
+      expect(result.valid).toBe(false)
+      if (!result.valid) {
+        expect(result.error).toContain('Parse error')
+      }
+    })
+
+    it('should return error for missing closing brace', () => {
+      const result = validateTsconfigContent('{ "a": 1')
+      expect(result.valid).toBe(false)
+    })
   })
 
   describe('error handling', () => {