fcis 0.1.0

package/src/cli.ts

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * FCIS CLI - Command Line Interface
+ *
+ * Entry point for the FCIS analyzer. Supports running analysis against
+ * a TypeScript project and outputting results in various formats.
+ *
+ * Exit codes:
+ * - 0: Success, all thresholds passed
+ * - 1: Analysis completed but below threshold
+ * - 2: Configuration error
+ * - 3: Analysis error (zero files could be analyzed)
+ */
+
+import { cli } from 'cleye'
+import { z } from 'zod'
+import chalk from 'chalk'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import { analyze, checkThresholds } from './analyzer.js'
+import { stripJsonComments } from './extraction/extractor.js'
+import {
+  printConsoleReport,
+  generateSummaryLine,
+} from './reporting/report-console.js'
+import { generateJsonReport, writeJsonReport } from './reporting/report-json.js'
+import type { AnalyzerConfig } from './types.js'
+
+const EXIT_SUCCESS = 0
+const EXIT_THRESHOLD_FAILED = 1
+const EXIT_CONFIG_ERROR = 2
+const EXIT_ANALYSIS_ERROR = 3
+
+const ThresholdSchema = z.number().min(0).max(100)
+
+const argv = cli({
+  name: 'fcis',
+  version: '0.1.0',
+  flags: {
+    json: {
+      type: Boolean,
+      description: 'Output JSON to stdout (for piping/parsing)',
+      default: false,
+    },
+    output: {
+      type: String,
+      alias: 'o',
+      description: 'Write JSON report to file',
+    },
+    minHealth: {
+      type: Number,
+      description: 'Exit with code 1 if project health < N (0-100)',
+    },
+    minPurity: {
+      type: Number,
+      description: 'Exit with code 1 if purity < N (0-100)',
+    },
+    minQuality: {
+      type: Number,
+      description: 'Exit with code 1 if impurity quality < N (0-100)',
+    },
+    files: {
+      type: String,
+      alias: 'f',
+      description:
+        'Analyze only files matching glob (for incremental/pre-commit)',
+    },
+    format: {
+      type: String,
+      description: 'Output format: console (default), json, summary',
+      default: 'console',
+    },
+    quiet: {
+      type: Boolean,
+      alias: 'q',
+      description: 'Suppress all output except errors; rely on exit code',
+      default: false,
+    },
+    verbose: {
+      type: Boolean,
+      alias: 'v',
+      description: 'Show per-file scores and all classified functions',
+      default: false,
+    },
+  },
+  parameters: ['<tsconfig>'],
+  help: {
+    description:
+      'Analyze TypeScript code for Functional Core, Imperative Shell patterns',
+    examples: [
+      'fcis analyze tsconfig.json',
+      'fcis analyze tsconfig.json --min-health 70',
+      'fcis analyze tsconfig.json --format json --output report.json',
+      'fcis analyze tsconfig.json --files "src/services/**/*.ts"',
+    ],
+  },
+})
+
+async function main(): Promise<void> {
+  const { flags, _: args } = argv
+
+  const tsconfigPath = args.tsconfig
+
+  // Validate tsconfig exists
+  if (!tsconfigPath) {
+    console.error(chalk.red('Error: tsconfig path is required'))
+    console.error('Usage: fcis <tsconfig> [options]')
+    process.exit(EXIT_CONFIG_ERROR)
+  }
+
+  const absoluteTsconfigPath = path.resolve(tsconfigPath)
+  if (!fs.existsSync(absoluteTsconfigPath)) {
+    console.error(
+      chalk.red(`Error: tsconfig.json not found at: ${absoluteTsconfigPath}`),
+    )
+    process.exit(EXIT_CONFIG_ERROR)
+  }
+
+  // Validate tsconfig is valid JSON (strip comments first since TypeScript allows them)
+  try {
+    const content = fs.readFileSync(absoluteTsconfigPath, 'utf-8')
+    const strippedContent = stripJsonComments(content)
+    JSON.parse(strippedContent)
+  } catch (e) {
+    console.error(
+      chalk.red(`Error: Invalid tsconfig.json at ${absoluteTsconfigPath}`),
+    )
+    console.error(e instanceof Error ? e.message : String(e))
+    process.exit(EXIT_CONFIG_ERROR)
+  }
+
+  // Validate threshold values
+  if (flags.minHealth !== undefined) {
+    const result = ThresholdSchema.safeParse(flags.minHealth)
+    if (!result.success) {
+      console.error(
+        chalk.red('Error: --min-health must be a number between 0 and 100'),
+      )
+      process.exit(EXIT_CONFIG_ERROR)
+    }
+  }
+
+  if (flags.minPurity !== undefined) {
+    const result = ThresholdSchema.safeParse(flags.minPurity)
+    if (!result.success) {
+      console.error(
+        chalk.red('Error: --min-purity must be a number between 0 and 100'),
+      )
+      process.exit(EXIT_CONFIG_ERROR)
+    }
+  }
+
+  if (flags.minQuality !== undefined) {
+    const result = ThresholdSchema.safeParse(flags.minQuality)
+    if (!result.success) {
+      console.error(
+        chalk.red('Error: --min-quality must be a number between 0 and 100'),
+      )
+      process.exit(EXIT_CONFIG_ERROR)
+    }
+  }
+
+  // Validate format
+  const validFormats = ['console', 'json', 'summary']
+  if (!validFormats.includes(flags.format)) {
+    console.error(
+      chalk.red(`Error: --format must be one of: ${validFormats.join(', ')}`),
+    )
+    process.exit(EXIT_CONFIG_ERROR)
+  }
+
+  // Validate output path if provided
+  if (flags.output) {
+    const outputDir = path.dirname(path.resolve(flags.output))
+    if (!fs.existsSync(outputDir)) {
+      try {
+        fs.mkdirSync(outputDir, { recursive: true })
+      } catch (e) {
+        console.error(
+          chalk.red(`Error: Cannot create output directory: ${outputDir}`),
+        )
+        process.exit(EXIT_CONFIG_ERROR)
+      }
+    }
+  }
+
+  // Run analysis
+  try {
+    if (!flags.quiet && flags.format === 'console') {
+      console.log(chalk.gray(`Analyzing ${process.cwd()}...`))
+    }
+
+    // Build config with proper undefined handling
+    const config: AnalyzerConfig = {
+      tsconfigPath: absoluteTsconfigPath,
+      format: flags.format as 'console' | 'json' | 'summary',
+      quiet: flags.quiet,
+      verbose: flags.verbose,
+    }
+
+    // Only add optional properties if they are defined
+    if (flags.files !== undefined) {
+      config.filesGlob = flags.files
+    }
+    if (flags.minHealth !== undefined) {
+      config.minHealth = flags.minHealth
+    }
+    if (flags.minPurity !== undefined) {
+      config.minPurity = flags.minPurity
+    }
+    if (flags.minQuality !== undefined) {
+      config.minQuality = flags.minQuality
+    }
+    if (flags.output !== undefined) {
+      config.outputPath = flags.output
+    }
+
+    const score = await analyze(config)
+
+    // Output results based on format
+    if (!flags.quiet) {
+      if (flags.json || flags.format === 'json') {
+        console.log(generateJsonReport(score, { pretty: true }))
+      } else if (flags.format === 'summary') {
+        console.log(generateSummaryLine(score))
+      } else {
+        printConsoleReport(score, { verbose: flags.verbose })
+      }
+    }
+
+    // Write JSON to file if requested
+    if (flags.output) {
+      writeJsonReport(score, flags.output, { pretty: true })
+      if (!flags.quiet && flags.format !== 'json') {
+        console.log(chalk.green(`Report written to: ${flags.output}`))
+      }
+    }
+
+    // Check thresholds - build object only with defined values
+    const thresholdConfig: {
+      minHealth?: number
+      minPurity?: number
+      minQuality?: number
+    } = {}
+
+    if (flags.minHealth !== undefined) {
+      thresholdConfig.minHealth = flags.minHealth
+    }
+    if (flags.minPurity !== undefined) {
+      thresholdConfig.minPurity = flags.minPurity
+    }
+    if (flags.minQuality !== undefined) {
+      thresholdConfig.minQuality = flags.minQuality
+    }
+
+    const thresholdResult = checkThresholds(score, thresholdConfig)
+
+    if (!thresholdResult.passed) {
+      if (!flags.quiet) {
+        console.log()
+        console.log(chalk.red.bold('Threshold check failed:'))
+        for (const failure of thresholdResult.failures) {
+          console.log(chalk.red(`  ✗ ${failure}`))
+        }
+      }
+      process.exit(EXIT_THRESHOLD_FAILED)
+    }
+
+    process.exit(EXIT_SUCCESS)
+  } catch (error) {
+    if (!flags.quiet) {
+      console.error(chalk.red('Analysis failed:'))
+      console.error(error instanceof Error ? error.message : String(error))
+    }
+
+    // Check if it's a "no files" error
+    if (error instanceof Error && error.message.includes('No source files')) {
+      process.exit(EXIT_ANALYSIS_ERROR)
+    }
+
+    process.exit(EXIT_ANALYSIS_ERROR)
+  }
+}
+
+main()