yaml-validate-cli 1.0.0

package/cli.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI color codes
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+
+function colorize(text, ...codes) {
+  if (!process.stdout.isTTY) return text;
+  return codes.join('') + text + RESET;
+}
+
+function printHelp() {
+  console.log(`
+${colorize('yaml-validate', BOLD, CYAN)} - Validate YAML files from the command line
+
+${colorize('Usage:', BOLD)}
+  yaml-validate <file.yml> [file2.yml ...]
+  yaml-validate *.yml
+  yaml-validate --strict <files>
+  yaml-validate --help
+
+${colorize('Options:', BOLD)}
+  --strict      Treat warnings as errors (exit code 1 if any warnings)
+  --no-color    Disable colored output
+  --quiet       Only show errors, suppress pass messages
+  --help, -h    Show this help message
+  --version     Show version number
+
+${colorize('Examples:', BOLD)}
+  yaml-validate config.yml
+  yaml-validate docker-compose.yml k8s/*.yml
+  yaml-validate --strict .github/workflows/*.yml
+
+${colorize('Exit codes:', BOLD)}
+  0   All files valid
+  1   One or more files have errors (or warnings with --strict)
+  2   No files specified or files not found
+`);
+}
+
+// Core YAML validator — no external dependencies
+function validateYAML(content, filename, strict) {
+  const lines = content.split('\n');
+  const errors = [];
+  const warnings = [];
+
+  // Track state
+  const keyTracker = [{}]; // stack of key maps per indentation level
+  let inMultilineScalar = false;
+  let multilineIndent = -1;
+  let inBlockScalar = false;
+  let blockScalarIndent = -1;
+  let prevIndent = 0;
+  let indentUnit = null; // detected indent size (spaces per level)
+
+  // Check for BOM
+  if (content.charCodeAt(0) === 0xFEFF) {
+    warnings.push({ line: 1, msg: 'File starts with BOM (byte order mark) — consider removing it' });
+  }
+
+  // Check for tabs used as indentation
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+
+    // Skip empty lines and comments for most checks
+    const trimmed = raw.trimEnd();
+    const isEmptyOrComment = trimmed.trim() === '' || trimmed.trim().startsWith('#');
+
+    // Tab indentation check
+    if (/^\t/.test(raw)) {
+      errors.push({ line: lineNum, msg: 'Tabs are not allowed as indentation in YAML (use spaces)' });
+      continue;
+    }
+
+    // Detect indent unit from first indented line
+    if (!isEmptyOrComment) {
+      const leadingSpaces = raw.match(/^( +)/);
+      if (leadingSpaces && indentUnit === null) {
+        indentUnit = leadingSpaces[1].length;
+      }
+    }
+
+    // Block scalar tracking (| and >)
+    if (!isEmptyOrComment) {
+      const indent = raw.search(/\S/);
+      if (inBlockScalar) {
+        if (indent <= blockScalarIndent && trimmed.trim() !== '') {
+          inBlockScalar = false;
+        } else {
+          continue;
+        }
+      }
+      if (/:\s*[|>][-+]?\s*$/.test(trimmed)) {
+        inBlockScalar = true;
+        blockScalarIndent = indent;
+      }
+    }
+
+    if (isEmptyOrComment) continue;
+
+    const indent = raw.search(/\S/);
+    const content_part = raw.trim();
+
+    // Detect keys and values
+    const keyMatch = content_part.match(/^([^:'"{\[]+?):\s*(.*)?$/);
+    const listItemMatch = content_part.match(/^-\s+(.*)?$/);
+    const docStart = content_part === '---';
+    const docEnd = content_part === '...';
+
+    if (docStart || docEnd) {
+      // Reset key tracker on new document
+      if (docStart) {
+        keyTracker.length = 0;
+        keyTracker.push({});
+      }
+      prevIndent = 0;
+      continue;
+    }
+
+    // Check indent consistency (must be multiple of detected unit)
+    if (indentUnit && indent > 0 && indent % indentUnit !== 0) {
+      warnings.push({ line: lineNum, msg: `Inconsistent indentation: ${indent} spaces (expected multiple of ${indentUnit})` });
+    }
+
+    // Check for trailing spaces
+    if (/\s+$/.test(raw) && raw !== '') {
+      warnings.push({ line: lineNum, msg: 'Trailing whitespace detected' });
+    }
+
+    // Check for duplicate keys at the same indentation level
+    if (keyMatch) {
+      const keyName = keyMatch[1].trim();
+
+      // Normalize indent level index
+      const level = indentUnit ? Math.round(indent / indentUnit) : indent;
+      while (keyTracker.length <= level) keyTracker.push({});
+      // Reset deeper levels when we go back up
+      if (indent < prevIndent) {
+        for (let l = level + 1; l < keyTracker.length; l++) {
+          keyTracker[l] = {};
+        }
+      }
+
+      if (keyTracker[level][keyName]) {
+        errors.push({ line: lineNum, msg: `Duplicate key "${keyName}" (first seen at line ${keyTracker[level][keyName]})` });
+      } else {
+        keyTracker[level][keyName] = lineNum;
+      }
+
+      prevIndent = indent;
+
+      // Check for unquoted special chars in values
+      const value = (keyMatch[2] || '').trim();
+      if (value && !value.startsWith('"') && !value.startsWith("'") && !value.startsWith('|') && !value.startsWith('>')) {
+        // Warn on values that look like they might be ambiguous booleans
+        if (/^(yes|no|on|off|true|false)$/i.test(value)) {
+          warnings.push({ line: lineNum, msg: `Ambiguous boolean-like value "${value}" for key "${keyName}" — consider quoting if string intended` });
+        }
+        // Warn on numeric-looking values with leading zeros (could be octal)
+        if (/^0\d+$/.test(value)) {
+          warnings.push({ line: lineNum, msg: `Value "${value}" has leading zero — may be interpreted as octal` });
+        }
+      }
+    }
+
+    // Check for unclosed brackets/braces inline
+    const inlineContent = content_part.replace(/"[^"]*"|'[^']*'/g, '""'); // strip quoted strings
+    const openBrackets = (inlineContent.match(/\[/g) || []).length;
+    const closeBrackets = (inlineContent.match(/\]/g) || []).length;
+    const openBraces = (inlineContent.match(/\{/g) || []).length;
+    const closeBraces = (inlineContent.match(/\}/g) || []).length;
+    if (openBrackets !== closeBrackets) {
+      errors.push({ line: lineNum, msg: `Unmatched brackets [ ] on this line (${openBrackets} open, ${closeBrackets} close)` });
+    }
+    if (openBraces !== closeBraces) {
+      errors.push({ line: lineNum, msg: `Unmatched braces { } on this line (${openBraces} open, ${closeBraces} close)` });
+    }
+
+    // Check for colon in unquoted string values without space after
+    if (/:\S/.test(content_part) && !content_part.startsWith('http') && !keyMatch) {
+      // Might be a mapping indicator without space
+      const colonNoSpace = content_part.match(/([^"':]):([\S])/);
+      if (colonNoSpace) {
+        warnings.push({ line: lineNum, msg: `Colon followed by non-space character — may cause parse errors if intended as mapping` });
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+function validateFile(filePath, options) {
+  const { strict, quiet } = options;
+
+  if (!fs.existsSync(filePath)) {
+    console.log(colorize(`  NOT FOUND: ${filePath}`, RED));
+    return { valid: false, notFound: true };
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch (e) {
+    console.log(colorize(`  ERROR reading ${filePath}: ${e.message}`, RED));
+    return { valid: false };
+  }
+
+  const { errors, warnings } = validateYAML(content, filePath, strict);
+  const hasErrors = errors.length > 0;
+  const hasWarnings = warnings.length > 0;
+  const failed = hasErrors || (strict && hasWarnings);
+  const shortName = path.relative(process.cwd(), filePath);
+
+  if (failed) {
+    console.log(colorize(`${BOLD}FAIL${RESET} ${colorize(shortName, BOLD)}`, RED));
+    for (const e of errors) {
+      console.log(colorize(`  [ERROR]`, RED) + colorize(` line ${e.line}: `, DIM) + e.msg);
+    }
+    if (strict) {
+      for (const w of warnings) {
+        console.log(colorize(`  [WARN] `, YELLOW) + colorize(` line ${w.line}: `, DIM) + w.msg);
+      }
+    }
+  } else {
+    if (!quiet) {
+      console.log(colorize(`PASS`, GREEN) + ` ${colorize(shortName, BOLD)}` +
+        (hasWarnings ? colorize(` (${warnings.length} warning${warnings.length > 1 ? 's' : ''})`, YELLOW) : ''));
+    }
+    if (hasWarnings && !quiet) {
+      for (const w of warnings) {
+        console.log(colorize(`  [WARN] `, YELLOW) + colorize(` line ${w.line}: `, DIM) + w.msg);
+      }
+    }
+  }
+
+  return { valid: !failed, errors: errors.length, warnings: warnings.length };
+}
+
+// Expand glob patterns (basic support for *.yml etc.)
+function expandGlob(pattern) {
+  const dir = path.dirname(pattern);
+  const base = path.basename(pattern);
+  if (!base.includes('*') && !base.includes('?')) return [pattern];
+  try {
+    const entries = fs.readdirSync(dir === '.' ? process.cwd() : dir);
+    const regex = new RegExp('^' + base.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+    return entries
+      .filter(e => regex.test(e))
+      .map(e => path.join(dir === '.' ? process.cwd() : dir, e));
+  } catch {
+    return [];
+  }
+}
+
+// Main entry
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    process.exit(args.length === 0 ? 2 : 0);
+  }
+
+  if (args.includes('--version')) {
+    const pkg = require('./package.json');
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  const strict = args.includes('--strict');
+  const quiet = args.includes('--quiet');
+  const noColor = args.includes('--no-color');
+  if (noColor) process.env.NO_COLOR = '1';
+
+  const files = args
+    .filter(a => !a.startsWith('--'))
+    .flatMap(expandGlob)
+    .filter(f => f.endsWith('.yml') || f.endsWith('.yaml') || true);
+
+  if (files.length === 0) {
+    console.error(colorize('No files specified or matched.', RED));
+    process.exit(2);
+  }
+
+  let totalPass = 0, totalFail = 0, totalWarn = 0;
+
+  console.log(colorize(`\nyaml-validate`, BOLD, CYAN) + colorize(` v1.0.0`, DIM) + (strict ? colorize(' [strict]', YELLOW) : '') + '\n');
+
+  for (const f of files) {
+    const result = validateFile(f, { strict, quiet });
+    if (result.valid) totalPass++;
+    else totalFail++;
+    totalWarn += result.warnings || 0;
+  }
+
+  console.log(`\n${colorize('Summary:', BOLD)} ${colorize(`${totalPass} passed`, GREEN)}, ${colorize(`${totalFail} failed`, totalFail > 0 ? RED : DIM)}, ${colorize(`${totalWarn} warnings`, totalWarn > 0 ? YELLOW : DIM)}\n`);
+
+  process.exit(totalFail > 0 ? 1 : 0);
+}
+
+main();

package/index.js

@@ -0,0 +1,73 @@
+// yaml-validate-cli — programmatic API
+'use strict';
+
+const fs = require('fs');
+
+function validateYAML(content) {
+  const lines = content.split('\n');
+  const errors = [];
+  const warnings = [];
+  const keyTracker = [{}];
+  let inBlockScalar = false;
+  let blockScalarIndent = -1;
+  let prevIndent = 0;
+  let indentUnit = null;
+
+  if (content.charCodeAt(0) === 0xFEFF) {
+    warnings.push({ line: 1, msg: 'File starts with BOM' });
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trimEnd();
+    const isEmptyOrComment = trimmed.trim() === '' || trimmed.trim().startsWith('#');
+
+    if (/^\t/.test(raw)) {
+      errors.push({ line: lineNum, msg: 'Tabs not allowed as indentation' });
+      continue;
+    }
+
+    if (!isEmptyOrComment) {
+      const leadingSpaces = raw.match(/^( +)/);
+      if (leadingSpaces && indentUnit === null) indentUnit = leadingSpaces[1].length;
+    }
+
+    if (!isEmptyOrComment) {
+      const indent = raw.search(/\S/);
+      if (inBlockScalar) {
+        if (indent <= blockScalarIndent && trimmed.trim() !== '') inBlockScalar = false;
+        else continue;
+      }
+      if (/:\s*[|>][-+]?\s*$/.test(trimmed)) { inBlockScalar = true; blockScalarIndent = indent; }
+    }
+
+    if (isEmptyOrComment) continue;
+
+    const indent = raw.search(/\S/);
+    const content_part = raw.trim();
+
+    if (content_part === '---') { keyTracker.length = 0; keyTracker.push({}); prevIndent = 0; continue; }
+    if (content_part === '...') { prevIndent = 0; continue; }
+
+    const keyMatch = content_part.match(/^([^:'"{\[]+?):\s*(.*)?$/);
+    if (keyMatch) {
+      const keyName = keyMatch[1].trim();
+      const level = indentUnit ? Math.round(indent / indentUnit) : indent;
+      while (keyTracker.length <= level) keyTracker.push({});
+      if (indent < prevIndent) for (let l = level + 1; l < keyTracker.length; l++) keyTracker[l] = {};
+      if (keyTracker[level][keyName]) errors.push({ line: lineNum, msg: `Duplicate key "${keyName}"` });
+      else keyTracker[level][keyName] = lineNum;
+      prevIndent = indent;
+    }
+  }
+
+  return { errors, warnings, valid: errors.length === 0 };
+}
+
+function validateFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return validateYAML(content);
+}
+
+module.exports = { validateYAML, validateFile };

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "yaml-validate-cli",
+  "version": "1.0.0",
+  "description": "Validate YAML files from the command line with detailed error reporting",
+  "main": "index.js",
+  "bin": { "yaml-validate": "./cli.js" },
+  "scripts": { "test": "node cli.js --help" },
+  "keywords": ["yaml", "validate", "cli", "lint", "devops"],
+  "author": "Wilson Xu",
+  "license": "MIT",
+  "dependencies": {}
+}