@boyingliu01/xp-gate 0.8.9 → 0.8.10

package/principles/baseline.ts

@@ -0,0 +1,273 @@
+import fs from 'fs/promises';
+
+interface BaselineEntry {
+  eslint?: { warnings: number; errors: number };
+  principles?: { warnings: number; errors: number };
+  ccn?: { warnings: number; max: number };
+  ruff?: { warnings: number; errors: number };
+  golangci?: { warnings: number; errors: number };
+  shellcheck?: { warnings: number; errors: number };
+  totalWarnings: number;
+  lastAnalyzed: string;
+}
+
+interface BaselineStorageConfig {
+  maxSize?: number;
+  timeoutMs?: number;
+  batchSize?: number;
+}
+
+type ToolValidator = (entry: BaselineEntry, file: string) => void;
+
+function computeSummaryStats(baseline: Record<string, BaselineEntry>) {
+  let totalFiles = 0;
+  let totalWarnings = 0;
+  const toolStats: Record<string, { totalWarnings: number; totalErrors: number }> = {};
+  let ccnTotalWarnings = 0;
+  let ccnTotalMax = 0;
+
+  for (const entry of Object.values(baseline)) {
+    totalFiles++;
+    totalWarnings += entry.totalWarnings;
+    aggregateTool(toolStats, entry);
+    if (entry.ccn) {
+      ccnTotalWarnings += entry.ccn.warnings;
+      ccnTotalMax += entry.ccn.max;
+    }
+  }
+
+  if (ccnTotalWarnings > 0 || ccnTotalMax > 0) {
+    toolStats.ccn = { totalWarnings: ccnTotalWarnings, totalErrors: 0, totalMax: ccnTotalMax } as unknown as { totalWarnings: number; totalErrors: number };
+  }
+
+  return {
+    totalFiles,
+    totalWarnings,
+    averageWarningsPerFile: totalFiles > 0 ? totalWarnings / totalFiles : 0,
+    ...toolStats,
+  };
+}
+
+function aggregateTool(stats: Record<string, { totalWarnings: number; totalErrors: number }>, entry: BaselineEntry) {
+  const tools: Array<{ key: string; warnings: number; errors: number }> = [
+    { key: 'eslint', warnings: entry.eslint?.warnings ?? 0, errors: entry.eslint?.errors ?? 0 },
+    { key: 'principles', warnings: entry.principles?.warnings ?? 0, errors: entry.principles?.errors ?? 0 },
+    { key: 'ruff', warnings: entry.ruff?.warnings ?? 0, errors: entry.ruff?.errors ?? 0 },
+    { key: 'golangci', warnings: entry.golangci?.warnings ?? 0, errors: entry.golangci?.errors ?? 0 },
+    { key: 'shellcheck', warnings: entry.shellcheck?.warnings ?? 0, errors: entry.shellcheck?.errors ?? 0 },
+  ];
+  for (const t of tools) {
+    if (t.warnings > 0 || t.errors > 0) {
+      stats[t.key] = { totalWarnings: (stats[t.key]?.totalWarnings || 0) + t.warnings, totalErrors: (stats[t.key]?.totalErrors || 0) + t.errors };
+    }
+  }
+}
+
+function validateNumber(
+  entry: BaselineEntry,
+  tool: string,
+  file: string,
+  props: string[],
+): void {
+  const obj = entry[tool as keyof BaselineEntry];
+  if (!obj || typeof obj !== 'object') return;
+  for (const prop of props) {
+    if (typeof (obj as Record<string, unknown>)[prop] !== 'number') {
+      throw new Error(`Invalid ${tool} properties for file ${file}`);
+    }
+  }
+}
+
+const ENTRY_VALIDATORS: ToolValidator[] = [
+  e => validateNumber(e, 'eslint', '', ['warnings', 'errors']),
+  e => validateNumber(e, 'principles', '', ['warnings', 'errors']),
+  e => validateNumber(e, 'ccn', '', ['warnings', 'max']),
+  e => validateNumber(e, 'ruff', '', ['warnings', 'errors']),
+  e => validateNumber(e, 'golangci', '', ['warnings', 'errors']),
+  e => validateNumber(e, 'shellcheck', '', ['warnings', 'errors']),
+];
+
+function validateEntry(file: string, entry: BaselineEntry): void {
+  if (typeof entry.totalWarnings !== 'number' || entry.totalWarnings < 0) {
+    throw new Error(`Invalid totalWarnings value for file ${file}: ${entry.totalWarnings}`);
+  }
+  if (typeof entry.lastAnalyzed !== 'string') {
+    throw new Error(`Missing or invalid lastAnalyzed timestamp for file ${file}`);
+  }
+  for (const validator of ENTRY_VALIDATORS) {
+    validator(entry, file);
+  }
+}
+
+function filterBaselineWarnings(baseline: Record<string, BaselineEntry>, minWarningCount: number = 1): Record<string, BaselineEntry> {
+  const filtered: Record<string, BaselineEntry> = {};
+  for (const [file, entry] of Object.entries(baseline)) {
+    if (entry.totalWarnings >= minWarningCount) {
+      filtered[file] = entry;
+    }
+  }
+  return filtered;
+}
+
+class BaselineStorage {
+  private config: BaselineStorageConfig = {
+    maxSize: 10000,
+    timeoutMs: 300000, // 5 minutes
+    batchSize: 50
+  };
+
+  constructor(config?: BaselineStorageConfig) {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+  }
+
+  async load(baselinePath: string): Promise<Record<string, BaselineEntry>> {
+    try {
+      await fs.access(baselinePath);
+      const baselineContent = await fs.readFile(baselinePath, 'utf-8');
+      return JSON.parse(baselineContent);
+    } catch {
+      return {};
+    }
+  }
+
+  async save(baselinePath: string, baseline: Record<string, BaselineEntry>): Promise<void> {
+    await fs.writeFile(baselinePath, JSON.stringify(baseline, null, 2));
+  }
+
+  validate(baseline: Record<string, BaselineEntry>): boolean {
+    if (Object.keys(baseline).length > this.config.maxSize!) {
+      throw new Error(`Baseline exceeds maximum size of ${this.config.maxSize} files`);
+    }
+    for (const [file, entry] of Object.entries(baseline)) {
+      validateEntry(file, entry);
+    }
+    return true;
+  }
+
+  async createFromFiles(warningData: Array<{ file: string; counts: Partial<BaselineEntry> }>): Promise<Record<string, BaselineEntry>> {
+    const baseline: Record<string, BaselineEntry> = {};
+    
+    for (const item of warningData) {
+      let totalWarnings = 0;
+      
+      if (item.counts.eslint?.warnings) {
+        totalWarnings += item.counts.eslint.warnings;
+      }
+      if (item.counts.principles?.warnings) {
+        totalWarnings += item.counts.principles.warnings;
+      }
+      if (item.counts.ccn?.warnings) {
+        totalWarnings += item.counts.ccn.warnings;
+      }
+      if (item.counts.ruff?.warnings) {
+        totalWarnings += item.counts.ruff.warnings;
+      }
+      if (item.counts.golangci?.warnings) {
+        totalWarnings += item.counts.golangci.warnings;
+      }
+      if (item.counts.shellcheck?.warnings) {
+        totalWarnings += item.counts.shellcheck.warnings;
+      }
+      if (item.counts.totalWarnings) {
+        totalWarnings = item.counts.totalWarnings;
+      }
+      
+      baseline[item.file] = {
+        ...(item.counts.eslint && { eslint: item.counts.eslint }),
+        ...(item.counts.principles && { principles: item.counts.principles }),
+        ...(item.counts.ccn && { ccn: item.counts.ccn }),
+        ...(item.counts.ruff && { ruff: item.counts.ruff }),
+        ...(item.counts.golangci && { golangci: item.counts.golangci }),
+        ...(item.counts.shellcheck && { shellcheck: item.counts.shellcheck }),
+        totalWarnings,
+        lastAnalyzed: new Date().toISOString()
+      };
+    }
+    
+    return baseline;
+  }
+
+  getSummaryStatistics(baseline: Record<string, BaselineEntry>) {
+    return computeSummaryStats(baseline);
+  }
+
+  async initializeWithAnalyzer(
+    files: string[],
+    warningCountFunction: (file: string) => Promise<Partial<BaselineEntry>>,
+    onProgress?: (progress: { current: number; total: number; completed: string[] }) => void
+  ): Promise<Record<string, BaselineEntry>> {
+    if (files.length > this.config.maxSize!) {
+      throw new Error(`Trying to initialize baseline with ${files.length} files, which exceeds the maximum of ${this.config.maxSize}`);
+    }
+
+    const baseline: Record<string, BaselineEntry> = {};
+    const totalFiles = files.length;
+    const completed: string[] = [];
+
+    const timeoutPromise = new Promise<Record<string, BaselineEntry>>((_, reject) => {
+      setTimeout(() => reject(new Error('Baseline initialization timed out')), this.config.timeoutMs);
+    });
+
+    const processBatches = async () => {
+      for (let i = 0; i < files.length; i += this.config.batchSize!) {
+        const batch = files.slice(i, i + this.config.batchSize!);
+
+        const promiseResults = await Promise.allSettled(
+          batch.map(async (file) => {
+            const counts = await warningCountFunction(file);
+            
+            let totalWarnings = 0;
+            if (counts.eslint?.warnings) totalWarnings += counts.eslint.warnings;
+            if (counts.principles?.warnings) totalWarnings += counts.principles.warnings;
+            if (counts.ccn?.warnings) totalWarnings += counts.ccn.warnings;
+            if (counts.ruff?.warnings) totalWarnings += counts.ruff.warnings;
+            if (counts.golangci?.warnings) totalWarnings += counts.golangci.warnings;
+            if (counts.shellcheck?.warnings) totalWarnings += counts.shellcheck.warnings;
+            if (counts.totalWarnings !== undefined) totalWarnings = counts.totalWarnings;
+
+            const baselineEntry: BaselineEntry = {
+              ...(counts.eslint && { eslint: counts.eslint }),
+              ...(counts.principles && { principles: counts.principles }),
+              ...(counts.ccn && { ccn: counts.ccn }),
+              ...(counts.ruff && { ruff: counts.ruff }),
+              ...(counts.golangci && { golangci: counts.golangci }),
+              ...(counts.shellcheck && { shellcheck: counts.shellcheck }),
+              totalWarnings,
+              lastAnalyzed: new Date().toISOString()
+            };
+
+            baseline[file] = baselineEntry;
+            completed.push(file);
+
+            if (onProgress) {
+              onProgress({
+                current: completed.length,
+                total: totalFiles,
+                completed: [...completed]
+              });
+            }
+          })
+        );
+
+        const rejectedPromises = promiseResults.filter(r => r.status === 'rejected') as Array<{ status: 'rejected'; reason: unknown }>;
+        if (rejectedPromises.length > 0) {
+          console.error('Some files failed to analyze:', rejectedPromises.map(r => r.reason));
+        }
+      }
+
+      return baseline;
+    };
+
+    return Promise.race([processBatches(), timeoutPromise]);
+  }
+}
+
+export {
+  BaselineEntry,
+  BaselineStorage,
+  filterBaselineWarnings,
+  type BaselineStorageConfig
+};
+

package/principles/boy-scout.ts

@@ -0,0 +1,416 @@
+import * as fs from 'fs/promises';
+import { analyze, getAdapterForFile } from './analyzer';
+import { getAllRules } from './index';
+
+interface FileClassification {
+  new: string[];
+  modified: string[];
+  deleted: string[];
+  renamed: { oldPath: string; newPath: string }[];
+}
+
+// Exported helper to get warning counts for a batch of files using the principles checker
+export async function analyzeWarningsForFiles(filesInput: string | string[]): Promise<Record<string, number>> {
+  const files = (typeof filesInput === 'string' ? filesInput.split(',') : filesInput)
+    .flatMap(f => f.split(',').map(s => s.trim()))
+    .filter(f => f);
+  if (files.length === 0) {
+    return {};
+  }
+
+  const rules = getAllRules();
+  const result = await analyze(files, rules, getAdapterForFile);
+
+  const fileWarnings: Record<string, number> = {};
+  
+  // Initialize all requested files with 0 warnings
+  for (const file of files) {
+    fileWarnings[file] = 0;
+  }
+  
+  // Count violations per file
+  for (const violation of result.violations) {
+    // Only count warnings and errors (ignore info level)
+    if (violation.severity === 'warning' || violation.severity === 'error') {
+      fileWarnings[violation.file] = (fileWarnings[violation.file] || 0) + 1;
+    }
+  }
+  
+  return fileWarnings;
+}
+
+interface BaselineEntry {
+  eslint?: { warnings: number; errors: number };
+  principles?: { warnings: number; errors: number };
+  ccn?: { warnings: number; max: number };
+  totalWarnings: number;
+  lastAnalyzed: string;
+}
+
+interface DeltaResult {
+  file: string;
+  status: 'NEW' | 'MODIFIED' | 'UNCHANGED';
+  baselineWarnings: number;
+  currentWarnings: number;
+  delta: number;
+  enforcement: 'PASS' | 'BLOCK';
+  reason: string;
+}
+
+interface EnforcementResult {
+  overallStatus: 'PASS' | 'BLOCK';
+  violations: DeltaResult[];
+  detailedReport: DeltaResult[];
+  summary: {
+    totalFiles: number;
+    passedFiles: number;
+    blockedFiles: number;
+  };
+}
+
+export function classifyFiles(gitDiffLines: string[]): FileClassification {
+  const result: FileClassification = {
+    new: [],
+    modified: [],
+    deleted: [],
+    renamed: []
+  };
+
+  for (const line of gitDiffLines) {
+    if (!line.trim()) continue;
+
+    const parts = line.split(/\s+/).filter(Boolean);
+    if (parts.length < 2) continue;
+
+    const status = parts[0].trim();
+    switch (status.charAt(0)) {
+      case 'A':
+        result.new.push(parts.slice(1).join(' '));
+        break;
+      case 'M':
+        result.modified.push(parts.slice(1).join(' '));
+        break;
+      case 'D':
+        result.deleted.push(parts.slice(1).join(' '));
+        break;
+      case 'R':
+        if (parts.length >= 3) {
+          result.renamed.push({
+            oldPath: parts[1],
+            newPath: parts[2]
+          });
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+  return result;
+}
+
+export async function loadBaseline(baselinePath: string): Promise<Record<string, BaselineEntry>> {
+  try {
+    await fs.access(baselinePath);
+    const baselineContent = await fs.readFile(baselinePath, 'utf-8');
+    return JSON.parse(baselineContent);
+  } catch {
+    return {};
+  }
+}
+
+export async function saveBaseline(baselinePath: string, baseline: Record<string, BaselineEntry>): Promise<void> {
+  await fs.writeFile(baselinePath, JSON.stringify(baseline, null, 2));
+}
+
+function evaluateNewFile(currentWarnings: number): Pick<DeltaResult, 'enforcement' | 'reason'> {
+  if (currentWarnings > 0) {
+    return {
+      enforcement: 'BLOCK',
+      reason: `New files must have zero warnings (currently: ${currentWarnings}). Boy Scout Rule: Leave the code cleaner than you found it.`,
+    };
+  }
+  return { enforcement: 'PASS', reason: 'New file with zero warnings' };
+}
+
+function describeNonIncreasedDelta(delta: number, currentWarnings: number): string {
+  if (delta < 0) return `Warnings decreased by ${Math.abs(delta)}`;
+  if (currentWarnings === 0) return 'All warnings cleared';
+  return 'No new warnings introduced';
+}
+
+function evaluateModifiedFile(
+  baselineEntry: BaselineEntry | null,
+  currentWarnings: number,
+  baselineWarnings: number,
+): Pick<DeltaResult, 'enforcement' | 'reason'> {
+  if (!baselineEntry) {
+    return { enforcement: 'PASS', reason: 'File added to baseline with current warning count' };
+  }
+
+  if (currentWarnings > baselineWarnings) {
+    return {
+      enforcement: 'BLOCK',
+      reason: `Modified files cannot increase warnings (${currentWarnings} > ${baselineWarnings}). Boy Scout Rule: Leave the code cleaner than you found it.`,
+    };
+  }
+
+  if (baselineWarnings <= 5 && currentWarnings > 0) {
+    return {
+      enforcement: 'BLOCK',
+      reason: `Files with <=5 warnings must clear to zero (currently: ${currentWarnings}/${baselineWarnings}). Boy Scout Rule: Leave the code cleaner than you found it.`,
+    };
+  }
+
+  return {
+    enforcement: 'PASS',
+    reason: describeNonIncreasedDelta(currentWarnings - baselineWarnings, currentWarnings),
+  };
+}
+
+export function calculateDelta(
+  baselineEntry: BaselineEntry | null,
+  currentWarnings: number,
+  status: 'NEW' | 'MODIFIED'
+): DeltaResult {
+  const baselineWarnings = baselineEntry ? baselineEntry.totalWarnings : 0;
+  const delta = status === 'NEW' ? currentWarnings : currentWarnings - baselineWarnings;
+
+  const evaluation = status === 'NEW'
+    ? evaluateNewFile(currentWarnings)
+    : evaluateModifiedFile(baselineEntry, currentWarnings, baselineWarnings);
+
+  return {
+    file: '',
+    status,
+    baselineWarnings,
+    currentWarnings,
+    delta,
+    enforcement: evaluation.enforcement,
+    reason: evaluation.reason,
+  };
+}
+
+export function enforceBoyScoutRule(deltas: DeltaResult[]): EnforcementResult {
+  const violations = deltas.filter(delta => delta.enforcement === 'BLOCK');
+  
+  let passedCount = 0;
+  deltas.forEach(delta => {
+    if (delta.enforcement === 'PASS') passedCount++;
+  });
+
+  return {
+    overallStatus: violations.length > 0 ? 'BLOCK' : 'PASS',
+    violations,
+    detailedReport: deltas,
+    summary: {
+      totalFiles: deltas.length,
+      passedFiles: passedCount,
+      blockedFiles: violations.length
+    }
+  };
+}
+
+export async function initBaseline(files: string[]): Promise<Record<string, BaselineEntry>> {
+  const currentWarnings = await analyzeWarningsForFiles(files);
+  const baseline: Record<string, BaselineEntry> = {};
+
+  for (const file of files) {
+    try {
+      const warningCount = currentWarnings[file] || 0;
+      if (warningCount > 0) {
+        baseline[file] = {
+          totalWarnings: warningCount,
+          lastAnalyzed: new Date().toISOString(),
+        };
+      }
+    } catch (error: unknown) {
+      console.error(`Failed to analyze file for baseline: ${file}`, error);
+    }
+  }
+
+  return baseline;
+}
+
+ /**
+ * Initializes baseline from current violations for the specified files
+ */
+async function autoInitBaseline(
+  files: string[], 
+  baselinePath: string
+): Promise<Record<string, BaselineEntry>> {
+  const currentWarnings = await analyzeWarningsForFiles(files);
+  const baseline: Record<string, BaselineEntry> = {};
+
+  for (const file of files) {
+    const count = currentWarnings[file] || 0;
+    if (count > 0) {
+      baseline[file] = {
+        totalWarnings: count,
+        lastAnalyzed: new Date().toISOString(),
+      };
+    }
+  }
+
+  await saveBaseline(baselinePath, baseline);
+  return baseline;
+}
+
+async function runInitBaselineCommand(parsed: Record<string, unknown>): Promise<number> {
+  try {
+    await initBaselineCommand((parsed.files ?? []) as string[]);
+    console.log('Baseline initialized successfully');
+    return 0;
+  } catch (error: unknown) {
+    console.error('Error initializing baseline:', error);
+    return 1;
+  }
+}
+
+export async function runEnforcementCommand(parsed: Record<string, unknown>): Promise<number> {
+  try {
+    const enforcementResult = await runEnforcement(
+      (parsed.newFiles ?? []) as string[],
+      (parsed.modifiedFiles ?? []) as string[],
+      (parsed.baselinePath as string) || '.warnings-baseline.json'
+    );
+    console.log(JSON.stringify(enforcementResult, null, 2));
+    return enforcementResult.overallStatus === 'PASS' ? 0 : 1;
+  } catch (error: unknown) {
+    console.error('Error during enforcement:', error);
+    return 1;
+  }
+}
+
+export async function main(): Promise<number> {
+  const parsed = parseArgs(process.argv.slice(2));
+  return parsed.command === 'init-baseline'
+    ? runInitBaselineCommand(parsed)
+    : runEnforcementCommand(parsed);
+}
+
+function splitCsvArg(raw: string | undefined): string[] {
+  return raw?.split(',').map((s: string) => s.trim()).filter(Boolean) || [];
+}
+
+const ARG_HANDLERS: Record<string, (parsed: Record<string, unknown>, next: string | undefined) => boolean> = {
+  '--new-files': (parsed, next) => { parsed.newFiles = splitCsvArg(next); return true; },
+  '--modified-files': (parsed, next) => { parsed.modifiedFiles = splitCsvArg(next); return true; },
+  '--baseline': (parsed, next) => { parsed.baselinePath = next; return true; },
+  '--init-baseline': (parsed, next) => {
+    parsed.command = 'init-baseline';
+    parsed.files = splitCsvArg(next);
+    return true;
+  },
+};
+
+function parseArgs(args: string[]): Record<string, unknown> {
+  const parsed: Record<string, unknown> = {
+    command: null,
+    newFiles: [],
+    modifiedFiles: [],
+    baselinePath: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      showHelp();
+      process.exit(0);
+    }
+    const handler = ARG_HANDLERS[arg];
+    if (handler && handler(parsed, args[i + 1])) {
+      i++;
+    }
+  }
+
+  return parsed;
+}
+
+function showHelp(): void {
+  console.log(`
+Usage: boy-scout <options>
+Options:
+  --new-files <file1,file2,...>    Specify new files to analyze
+  --modified-files <file1,file2,...>    Specify modified files to analyze  
+  --baseline <path>                Path to baseline file (default: .warnings-baseline.json)
+  --init-baseline [file1,file2,...]    Initialize baseline with current warning counts
+  --help                          Show this help message
+  
+Examples:
+  npx tsx boy-scout.ts --new-files src/new-file.ts
+  npx tsx boy-scout.ts --modified-files src/changed-file.ts --baseline my-baseline.json
+  npx tsx boy-scout.ts --init-baseline src/file1.ts,src/file2.ts
+`);
+}
+
+async function initBaselineCommand(files: string[]): Promise<void> {
+  const baseline = await initBaseline(files);
+  await saveBaseline('.warnings-baseline.json', baseline);
+}
+
+async function runEnforcement(newFiles: string[], modifiedFiles: string[], baselinePath: string): Promise<EnforcementResult> {
+  const allFiles = [...newFiles.filter(f => f.trim()), ...modifiedFiles.filter(f => f.trim())];
+  const currentWarnings = await analyzeWarningsForFiles(allFiles);
+  
+  const baseline = await loadBaseline(baselinePath);
+  
+  // Check for missing baseline entries for modified files
+  const missingBaselineEntries: string[] = [];
+  for (const file of modifiedFiles) {
+    if (!baseline[file]) {
+      missingBaselineEntries.push(file);
+    }
+  }
+  
+  // If there are missing baseline entries, auto-initialize them
+  if (missingBaselineEntries.length > 0) {
+    for (const file of missingBaselineEntries) {
+      const warningCount = currentWarnings[file] || 0;
+      if (warningCount > 0) {
+        baseline[file] = {
+          totalWarnings: warningCount,
+          lastAnalyzed: new Date().toISOString(),
+        };
+      }
+    }
+    // Save the updated baseline
+    await saveBaseline(baselinePath, baseline);
+    console.log(`ℹ️  Auto-initialized baseline for ${missingBaselineEntries.length} files`);
+  }
+  
+  const deltaResults: DeltaResult[] = [];
+
+  for (const file of newFiles) {
+    const warningCount = currentWarnings[file] || 0;
+    const delta = calculateDelta(null, warningCount, 'NEW');
+    delta.file = file;
+    deltaResults.push(delta);
+  }
+  
+  for (const file of modifiedFiles) {
+    const baselineEntry = baseline[file] || null;
+    const warningCount = currentWarnings[file] || 0;
+    const delta = calculateDelta(baselineEntry, warningCount, 'MODIFIED');
+    delta.file = file;
+    deltaResults.push(delta);
+  }
+  
+  return enforceBoyScoutRule(deltaResults);
+}
+
+if ((typeof require !== 'undefined' && require.main === module) || 
+    (typeof require === 'undefined' && process.argv[1]?.includes('boy-scout'))) {
+  main()
+    .then(code => process.exit(code))
+    .catch(error => {
+      console.error('Unhandled error:', error);
+      process.exit(1);
+    });
+}
+
+export {
+  initBaselineCommand,
+  runEnforcement,
+  autoInitBaseline
+};