@artemiskit/cli 0.2.2 → 0.2.4

package/src/commands/validate.ts

@@ -0,0 +1,254 @@
+/**
+ * Validate command - Validate scenarios without running them
+ */
+
+import { readdirSync, statSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { basename, join, resolve } from 'node:path';
+import { ScenarioValidator, type ValidationResult, type ValidationSummary } from '@artemiskit/core';
+import { generateValidationJUnitReport } from '@artemiskit/reports';
+import { Glob } from 'bun';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { icons } from '../ui/index.js';
+
+interface ValidateOptions {
+  json?: boolean;
+  strict?: boolean;
+  quiet?: boolean;
+  export?: 'junit';
+  exportOutput?: string;
+}
+
+export function validateCommand(): Command {
+  const cmd = new Command('validate');
+
+  cmd
+    .description('Validate scenario files without running them')
+    .argument('<path>', 'Path to scenario file, directory, or glob pattern')
+    .option('--json', 'Output as JSON')
+    .option('--strict', 'Treat warnings as errors')
+    .option('-q, --quiet', 'Only output errors (no success messages)')
+    .option('--export <format>', 'Export results to format (junit for CI integration)')
+    .option('--export-output <dir>', 'Output directory for exports (default: ./artemis-exports)')
+    .action(async (pathArg: string, options: ValidateOptions) => {
+      const validator = new ScenarioValidator({ strict: options.strict });
+
+      // Resolve files to validate
+      const files = resolveFiles(pathArg);
+
+      if (files.length === 0) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                valid: false,
+                error: `No scenario files found matching: ${pathArg}`,
+                results: [],
+                summary: { total: 0, passed: 0, failed: 0, withWarnings: 0 },
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(chalk.red(`${icons.failed} No scenario files found matching: ${pathArg}`));
+        }
+        process.exit(2);
+      }
+
+      // Validate all files
+      const results: ValidationResult[] = [];
+
+      if (!options.json && !options.quiet) {
+        console.log(chalk.bold('Validating scenarios...\n'));
+      }
+
+      for (const file of files) {
+        const result = validator.validate(file);
+        results.push(result);
+
+        // In strict mode, warnings become errors
+        if (options.strict && result.warnings.length > 0) {
+          result.valid = false;
+          result.errors.push(
+            ...result.warnings.map((w: ValidationResult['warnings'][0]) => ({
+              ...w,
+              severity: 'error' as const,
+            }))
+          );
+        }
+
+        if (!options.json) {
+          printFileResult(result, options);
+        }
+      }
+
+      // Calculate summary
+      const summary: ValidationSummary = {
+        total: results.length,
+        passed: results.filter((r) => r.valid && r.warnings.length === 0).length,
+        failed: results.filter((r) => !r.valid).length,
+        withWarnings: results.filter((r) => r.valid && r.warnings.length > 0).length,
+      };
+
+      // Output results
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              valid: summary.failed === 0,
+              results: results.map((r) => ({
+                file: r.file,
+                valid: r.valid,
+                errors: r.errors,
+                warnings: r.warnings,
+              })),
+              summary,
+            },
+            null,
+            2
+          )
+        );
+      } else if (!options.quiet) {
+        console.log();
+        printSummary(summary, options.strict);
+      }
+
+      // Export to JUnit if requested
+      if (options.export === 'junit') {
+        const exportDir = options.exportOutput || './artemis-exports';
+        await mkdir(exportDir, { recursive: true });
+        const junit = generateValidationJUnitReport(results);
+        const junitPath = join(exportDir, `validation-${Date.now()}.xml`);
+        await writeFile(junitPath, junit);
+        if (!options.quiet) {
+          console.log(chalk.dim(`Exported: ${junitPath}`));
+        }
+      }
+
+      // Exit with appropriate code
+      if (summary.failed > 0) {
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}
+
+/**
+ * Resolve files from path argument (file, directory, or glob)
+ */
+function resolveFiles(pathArg: string): string[] {
+  const resolved = resolve(pathArg);
+
+  try {
+    const stat = statSync(resolved);
+
+    if (stat.isFile()) {
+      // Single file
+      return [resolved];
+    }
+
+    if (stat.isDirectory()) {
+      // Directory - find all yaml files recursively
+      return findYamlFiles(resolved);
+    }
+  } catch {
+    // Path doesn't exist as file/directory - try as glob
+  }
+
+  // Try as glob pattern using Bun's Glob
+  const glob = new Glob(pathArg);
+  const matches: string[] = [];
+  for (const file of glob.scanSync({ absolute: true, onlyFiles: true })) {
+    if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+      matches.push(file);
+    }
+  }
+
+  return matches;
+}
+
+/**
+ * Find all YAML files in a directory recursively
+ */
+function findYamlFiles(dir: string): string[] {
+  const files: string[] = [];
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...findYamlFiles(fullPath));
+    } else if (entry.isFile() && (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml'))) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Print result for a single file
+ */
+function printFileResult(result: ValidationResult, options: ValidateOptions): void {
+  const fileName = basename(result.file);
+
+  if (result.valid && result.warnings.length === 0) {
+    if (!options.quiet) {
+      console.log(`${icons.passed} ${chalk.green(fileName)}`);
+    }
+  } else if (result.valid && result.warnings.length > 0) {
+    console.log(`${icons.warning} ${chalk.yellow(fileName)}`);
+    for (const warning of result.warnings) {
+      const location = warning.column
+        ? `Line ${warning.line}:${warning.column}`
+        : `Line ${warning.line}`;
+      console.log(chalk.yellow(`    ${location}: ${warning.message}`));
+      if (warning.suggestion) {
+        console.log(chalk.dim(`    Suggestion: ${warning.suggestion}`));
+      }
+    }
+  } else {
+    console.log(`${icons.failed} ${chalk.red(fileName)}`);
+    for (const error of result.errors) {
+      const location = error.column ? `Line ${error.line}:${error.column}` : `Line ${error.line}`;
+      console.log(chalk.red(`    ${location}: ${error.message}`));
+      if (error.suggestion) {
+        console.log(chalk.dim(`    Suggestion: ${error.suggestion}`));
+      }
+    }
+    for (const warning of result.warnings) {
+      const location = warning.column
+        ? `Line ${warning.line}:${warning.column}`
+        : `Line ${warning.line}`;
+      console.log(chalk.yellow(`    ${location}: ${warning.message}`));
+    }
+  }
+}
+
+/**
+ * Print validation summary
+ */
+function printSummary(summary: ValidationSummary, strict?: boolean): void {
+  const parts: string[] = [];
+
+  if (summary.passed > 0) {
+    parts.push(chalk.green(`${summary.passed} passed`));
+  }
+  if (summary.failed > 0) {
+    parts.push(chalk.red(`${summary.failed} failed`));
+  }
+  if (summary.withWarnings > 0 && !strict) {
+    parts.push(chalk.yellow(`${summary.withWarnings} with warnings`));
+  }
+
+  const statusIcon = summary.failed > 0 ? icons.failed : icons.passed;
+  const statusColor = summary.failed > 0 ? chalk.red : chalk.green;
+
+  console.log(statusColor(`${statusIcon} ${parts.join(', ')}`));
+  console.log(chalk.dim(`${summary.total} scenario(s) validated`));
+}