fcis 0.1.0 → 0.2.0

package/src/reporting/report-console.ts

@@ -16,20 +16,179 @@ import type {
   RefactoringCandidate,
   StatusBreakdown,
 } from '../types.js'
-import { getDiagnosticInsights } from '../scoring/scorer.js'
+import {
+  getDiagnosticInsights,
+  rollupDirectoriesByDepth,
+} from '../scoring/scorer.js'
 import {
   getStatusColor,
   getStatusEmoji,
 } from '../classification/derive-status.js'
 
+// ============================================================================
+// Color Helpers
+// ============================================================================
+
+type ChalkFn = typeof chalk.green
+
+/**
+ * Get the appropriate chalk color function for a metric value (0-100)
+ * - Green: >= 70
+ * - Yellow: >= 50
+ * - Red: < 50
+ */
+function getMetricColor(value: number): ChalkFn {
+  if (value >= 70) return chalk.green
+  if (value >= 50) return chalk.yellow
+  return chalk.red
+}
+
+/**
+ * Get the appropriate chalk color function for a nullable metric value
+ * Returns gray for null values
+ */
+function getMetricColorNullable(value: number | null): ChalkFn {
+  if (value === null) return chalk.gray
+  return getMetricColor(value)
+}
+
+// ============================================================================
+// Path Helpers
+// ============================================================================
+
+/**
+ * Convert an absolute path to a path relative to the current working directory
+ */
+function toRelativePath(absolutePath: string): string {
+  const cwd = process.cwd()
+  if (absolutePath.startsWith(cwd)) {
+    const relative = path.relative(cwd, absolutePath)
+    return relative || '.'
+  }
+  return absolutePath
+}
+
+/**
+ * Relativize directory paths for use with pure scoring functions
+ * This is a shell helper that performs path I/O before calling pure functions
+ */
+export function relativizeDirectoryPaths(
+  directories: DirectoryScore[],
+  projectRoot: string,
+): DirectoryScore[] {
+  return directories.map(d => ({
+    ...d,
+    dirPath: path.relative(projectRoot, d.dirPath).replace(/\\/g, '/'),
+  }))
+}
+
+// ============================================================================
+// Directory Table Printing
+// ============================================================================
+
+type DirectoryTableOptions = {
+  title: string
+  includeQualityColumn: boolean
+  sortBy: 'health-asc' | 'preserve-order'
+  emptyMessage?: string
+}
+
+/**
+ * Unified function for printing directory tables
+ */
+function printDirectoryTable(
+  directories: DirectoryScore[],
+  options: DirectoryTableOptions,
+): void {
+  const { title, includeQualityColumn, sortBy, emptyMessage } = options
+
+  // Filter to directories with functions
+  let filtered = directories.filter(d => d.pureCount + d.impureCount > 0)
+
+  // Sort based on option
+  if (sortBy === 'health-asc') {
+    filtered = [...filtered].sort((a, b) => a.health - b.health)
+  }
+  // 'preserve-order' - keep input order (caller is responsible for pre-sorting if needed)
+
+  console.log(chalk.bold(title))
+  console.log(chalk.gray('─'.repeat(80)))
+
+  if (includeQualityColumn) {
+    console.log(
+      chalk.gray(
+        padEnd('Directory', 40) +
+          padEnd('Health', 10) +
+          padEnd('Purity', 10) +
+          padEnd('Quality', 10) +
+          padEnd('Functions', 10),
+      ),
+    )
+  } else {
+    console.log(
+      chalk.gray(
+        padEnd('Directory', 45) +
+          padEnd('Health', 10) +
+          padEnd('Purity', 10) +
+          padEnd('Functions', 15),
+      ),
+    )
+  }
+  console.log(chalk.gray('─'.repeat(80)))
+
+  if (filtered.length === 0) {
+    if (emptyMessage) {
+      console.log(chalk.gray(`  ${emptyMessage}`))
+    }
+    console.log()
+    return
+  }
+
+  for (const dir of filtered) {
+    const healthColor = getMetricColor(dir.health)
+    const purityColor = getMetricColor(dir.purity)
+    const total = dir.pureCount + dir.impureCount
+
+    if (includeQualityColumn) {
+      const qualityStr =
+        dir.impurityQuality !== null
+          ? dir.impurityQuality.toFixed(0) + '%'
+          : '—'
+      const qualityColor = getMetricColorNullable(dir.impurityQuality)
+
+      console.log(
+        padEnd(dir.dirPath, 40) +
+          healthColor(padEnd(dir.health.toFixed(0) + '%', 10)) +
+          purityColor(padEnd(dir.purity.toFixed(0) + '%', 10)) +
+          qualityColor(padEnd(qualityStr, 10)) +
+          padEnd(`${dir.pureCount}/${total}`, 10),
+      )
+    } else {
+      const relativePath = toRelativePath(dir.dirPath)
+      console.log(
+        padEnd(relativePath, 45) +
+          healthColor(padEnd(dir.health.toFixed(0) + '%', 10)) +
+          purityColor(padEnd(dir.purity.toFixed(0) + '%', 10)) +
+          padEnd(`${dir.pureCount}/${total}`, 15),
+      )
+    }
+  }
+
+  console.log()
+}
+
+// ============================================================================
+// Main Report Functions
+// ============================================================================
+
 /**
  * Generate and print the full console report
  */
 export function printConsoleReport(
   score: ProjectScore,
-  options: { verbose?: boolean } = {},
+  options: { verbose?: boolean; dirDepth?: number } = {},
 ): void {
-  const { verbose = false } = options
+  const { verbose = false, dirDepth } = options
 
   printHeader()
   printProjectSummary(score)
@@ -39,8 +198,25 @@ export function printConsoleReport(
   )
   printInsights(score)
 
-  if (verbose) {
-    printDirectoryBreakdown(score.directoryScores)
+  if (dirDepth !== undefined) {
+    // Relativize paths in shell layer, then call pure rollup function
+    const relativized = relativizeDirectoryPaths(
+      score.directoryScores,
+      process.cwd(),
+    )
+    const rolledUp = rollupDirectoriesByDepth(relativized, dirDepth)
+    printDirectoryTable(rolledUp, {
+      title: `Directory Breakdown (depth=${dirDepth}):`,
+      includeQualityColumn: true,
+      sortBy: 'preserve-order',
+      emptyMessage: 'No directories with functions found',
+    })
+  } else if (verbose) {
+    printDirectoryTable(score.directoryScores, {
+      title: 'Directory Breakdown:',
+      includeQualityColumn: false,
+      sortBy: 'health-asc',
+    })
   } else {
     printWorstDirectories(score.directoryScores)
   }
@@ -71,19 +247,8 @@ function printHeader(): void {
  */
 function printProjectSummary(score: ProjectScore): void {
   const healthBar = createProgressBar(score.health, 25)
-
-  const healthColor =
-    score.health >= 70
-      ? chalk.green
-      : score.health >= 50
-        ? chalk.yellow
-        : chalk.red
-  const purityColor =
-    score.purity >= 70
-      ? chalk.green
-      : score.purity >= 50
-        ? chalk.yellow
-        : chalk.red
+  const healthColor = getMetricColor(score.health)
+  const purityColor = getMetricColor(score.purity)
 
   console.log(
     `Project Health: ${healthColor(score.health.toFixed(0) + '%')} ${healthBar}`,
@@ -93,12 +258,7 @@ function printProjectSummary(score: ProjectScore): void {
   )
 
   if (score.impurityQuality !== null) {
-    const qualityColor =
-      score.impurityQuality >= 70
-        ? chalk.green
-        : score.impurityQuality >= 50
-          ? chalk.yellow
-          : chalk.red
+    const qualityColor = getMetricColor(score.impurityQuality)
     console.log(
       `  Impurity Quality: ${qualityColor(score.impurityQuality.toFixed(0) + '%')} average`,
     )
@@ -148,58 +308,7 @@ function printInsights(score: ProjectScore): void {
 }
 
 /**
- * Print directory breakdown (verbose mode)
- */
-function printDirectoryBreakdown(directories: DirectoryScore[]): void {
-  // Sort by health ascending (worst first)
-  const sorted = [...directories]
-    .filter(d => d.pureCount + d.impureCount > 0)
-    .sort((a, b) => a.health - b.health)
-
-  if (sorted.length === 0) return
-
-  console.log(chalk.bold('Directory Breakdown:'))
-  console.log(chalk.gray('─'.repeat(80)))
-  console.log(
-    chalk.gray(
-      padEnd('Directory', 45) +
-        padEnd('Health', 10) +
-        padEnd('Purity', 10) +
-        padEnd('Functions', 15),
-    ),
-  )
-  console.log(chalk.gray('─'.repeat(80)))
-
-  for (const dir of sorted) {
-    const healthColor =
-      dir.health >= 70
-        ? chalk.green
-        : dir.health >= 50
-          ? chalk.yellow
-          : chalk.red
-    const purityColor =
-      dir.purity >= 70
-        ? chalk.green
-        : dir.purity >= 50
-          ? chalk.yellow
-          : chalk.red
-
-    const relativePath = toRelativePath(dir.dirPath)
-    const total = dir.pureCount + dir.impureCount
-
-    console.log(
-      padEnd(relativePath, 45) +
-        healthColor(padEnd(dir.health.toFixed(0) + '%', 10)) +
-        purityColor(padEnd(dir.purity.toFixed(0) + '%', 10)) +
-        padEnd(`${dir.pureCount}/${total}`, 15),
-    )
-  }
-
-  console.log()
-}
-
-/**
- * Print worst directories (non-verbose mode)
+ * Print worst directories (non-verbose mode) - compact format
  */
 function printWorstDirectories(directories: DirectoryScore[]): void {
   const sorted = [...directories]
@@ -212,7 +321,7 @@ function printWorstDirectories(directories: DirectoryScore[]): void {
   console.log(chalk.bold('Directories Needing Attention:'))
 
   for (const dir of sorted) {
-    const healthColor = dir.health >= 50 ? chalk.yellow : chalk.red
+    const healthColor = getMetricColor(dir.health)
     const total = dir.pureCount + dir.impureCount
     const relativePath = toRelativePath(dir.dirPath)
 
@@ -321,13 +430,7 @@ function createProgressBar(percent: number, width: number): string {
 
   const bar = filledChar.repeat(filled) + emptyChar.repeat(empty)
 
-  if (percent >= 70) {
-    return chalk.green(bar)
-  } else if (percent >= 50) {
-    return chalk.yellow(bar)
-  } else {
-    return chalk.red(bar)
-  }
+  return getMetricColor(percent)(bar)
 }
 
 /**
@@ -346,18 +449,6 @@ export function generateSummaryLine(score: ProjectScore): string {
   return parts.join(' | ')
 }
 
-/**
- * Convert an absolute path to a path relative to the current working directory
- */
-function toRelativePath(absolutePath: string): string {
-  const cwd = process.cwd()
-  if (absolutePath.startsWith(cwd)) {
-    const relative = path.relative(cwd, absolutePath)
-    return relative || '.'
-  }
-  return absolutePath
-}
-
 /**
  * Pad end of string to a fixed length
  */
@@ -370,12 +461,7 @@ function padEnd(str: string, length: number): string {
  * Print a file-level report (for verbose output)
  */
 export function printFileReport(fileScore: FileScore): void {
-  const healthColor =
-    fileScore.health >= 70
-      ? chalk.green
-      : fileScore.health >= 50
-        ? chalk.yellow
-        : chalk.red
+  const healthColor = getMetricColor(fileScore.health)
   const total = fileScore.pureCount + fileScore.impureCount
   const relativePath = toRelativePath(fileScore.filePath)
 

package/src/reporting/report-json.ts

@@ -10,19 +10,23 @@
  * - Directory and file breakdowns
  * - Refactoring candidates
  * - Any errors encountered during analysis
+ * - Rolled-up directories (when --dir-depth is used)
  */
 
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 
 import type { ProjectScore } from '../types.js'
+import { rollupDirectoriesByDepth } from '../scoring/scorer.js'
 
 /**
  * JSON report options
  */
 export type JsonReportOptions = {
   pretty?: boolean // Pretty print with indentation (default: true)
-  includeFunction?: boolean // Include function details (default: false for smaller output)
+  includeFunction?: boolean // Include function details (default: true)
+  dirDepth?: number // Roll up directories to specified depth
+  projectRoot?: string // Project root for computing relative paths (default: cwd)
 }
 
 /**
@@ -36,10 +40,29 @@ export function generateJsonReport(
   score: ProjectScore,
   options: JsonReportOptions = {},
 ): string {
-  const { pretty = true, includeFunction = false } = options
+  const {
+    pretty = true,
+    includeFunction = true,
+    dirDepth,
+    projectRoot = process.cwd(),
+  } = options
 
   // Create a copy to potentially filter out function details
-  const reportData = prepareReportData(score, includeFunction)
+  let reportData = prepareReportData(score, includeFunction)
+
+  // Add rolled-up directories if depth is specified
+  if (dirDepth !== undefined) {
+    // Relativize paths in shell layer before calling pure rollup function
+    const relativized = score.directoryScores.map(d => ({
+      ...d,
+      dirPath: path.relative(projectRoot, d.dirPath).replace(/\\/g, '/'),
+    }))
+    const rolledUp = rollupDirectoriesByDepth(relativized, dirDepth)
+    reportData = {
+      ...reportData,
+      rolledUpDirectories: rolledUp,
+    }
+  }
 
   if (pretty) {
     return JSON.stringify(reportData, null, 2)