@jack200714/mafw 4.5.1 → 4.8.0

package/.opencode/skills/brand/scripts/sync-brand-to-tokens.cjs

@@ -1,248 +0,0 @@
-#!/usr/bin/env node
-/**
- * sync-brand-to-tokens.cjs
- *
- * Syncs brand-guidelines.md colors → design-tokens.json → design-tokens.css
- *
- * Usage:
- *   node sync-brand-to-tokens.cjs
- *   node sync-brand-to-tokens.cjs --dry-run
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-// Paths
-const BRAND_GUIDELINES = 'docs/brand-guidelines.md';
-const DESIGN_TOKENS_JSON = 'assets/design-tokens.json';
-const DESIGN_TOKENS_CSS = 'assets/design-tokens.css';
-const GENERATE_TOKENS_SCRIPT = '.claude/skills/design-system/scripts/generate-tokens.cjs';
-
-/**
- * Extract color info from brand guidelines markdown
- */
-function extractColorsFromMarkdown(content) {
-  const colors = {
-    primary: { name: 'primary', shades: {} },
-    secondary: { name: 'secondary', shades: {} },
-    accent: { name: 'accent', shades: {} }
-  };
-
-  // Match a "| Label | #hex |" markdown table row. Bold around the label
-  // (**Label**) is optional, so this handles both the bundled starter template
-  // ("| Primary Blue | #2563EB |") and bolded variants.
-  const rowRe = /\|\s*\*{0,2}([^*|]+?)\*{0,2}\s*\|\s*#([A-Fa-f0-9]{6})\b/g;
-
-  // 1) Quick Reference table — hex only, no parenthesized name required.
-  const quickRef = {
-    primary: /Primary Color\s*\|\s*#([A-Fa-f0-9]{6})/i,
-    secondary: /Secondary Color\s*\|\s*#([A-Fa-f0-9]{6})/i,
-    accent: /Accent Color\s*\|\s*#([A-Fa-f0-9]{6})/i
-  };
-  for (const key of Object.keys(quickRef)) {
-    const m = content.match(quickRef[key]);
-    if (m) colors[key].base = `#${m[1]}`;
-  }
-
-  // 2) Dedicated "### <Role> Colors" tables — assign base/dark/light by the
-  //    row label keyword.
-  const assignFromSection = (heading, target) => {
-    const section = content.match(new RegExp(`### ${heading}[\\s\\S]*?(?=\\n###|$)`, 'i'));
-    if (!section) return;
-    for (const m of section[0].matchAll(rowRe)) {
-      const label = m[1].trim().toLowerCase();
-      const hex = `#${m[2]}`;
-      if (label.includes('dark')) target.dark = hex;
-      else if (label.includes('light')) target.light = hex;
-      else if (!target.base) target.base = hex;
-    }
-  };
-  assignFromSection('Primary Colors', colors.primary);
-  assignFromSection('Secondary Colors', colors.secondary);
-  assignFromSection('Accent Colors', colors.accent);
-
-  // 3) Fallback: an accent swatch may live in another table (the starter
-  //    lists "Accent Green" under Secondary Colors).
-  if (!colors.accent.base) {
-    for (const m of content.matchAll(rowRe)) {
-      if (m[1].trim().toLowerCase().includes('accent')) {
-        colors.accent.base = `#${m[2]}`;
-        break;
-      }
-    }
-  }
-
-  return colors;
-}
-
-/**
- * Generate color scale from base color (simple approach)
- */
-function generateColorScale(baseHex, darkHex, lightHex) {
-  // Use provided shades or generate approximations
-  return {
-    "50": { "$value": lightHex || adjustBrightness(baseHex, 0.9), "$type": "color" },
-    "100": { "$value": lightHex || adjustBrightness(baseHex, 0.8), "$type": "color" },
-    "200": { "$value": adjustBrightness(baseHex, 0.6), "$type": "color" },
-    "300": { "$value": adjustBrightness(baseHex, 0.4), "$type": "color" },
-    "400": { "$value": adjustBrightness(baseHex, 0.2), "$type": "color" },
-    "500": { "$value": baseHex, "$type": "color" },
-    "600": { "$value": darkHex || adjustBrightness(baseHex, -0.15), "$type": "color" },
-    "700": { "$value": adjustBrightness(baseHex, -0.3), "$type": "color" },
-    "800": { "$value": adjustBrightness(baseHex, -0.45), "$type": "color" },
-    "900": { "$value": adjustBrightness(baseHex, -0.6), "$type": "color" }
-  };
-}
-
-/**
- * Adjust hex color brightness
- */
-function adjustBrightness(hex, percent) {
-  if (typeof hex !== 'string') return '#000000';
-  const num = parseInt(hex.replace('#', ''), 16);
-  const r = Math.min(255, Math.max(0, (num >> 16) + Math.round(255 * percent)));
-  const g = Math.min(255, Math.max(0, ((num >> 8) & 0x00FF) + Math.round(255 * percent)));
-  const b = Math.min(255, Math.max(0, (num & 0x0000FF) + Math.round(255 * percent)));
-  return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0').toUpperCase()}`;
-}
-
-/**
- * Update design tokens JSON
- */
-function updateDesignTokens(tokens, colors) {
-  // Update brand name
-  const brandName = `ClaudeKit Marketing - ${colors.primary.name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}`;
-  tokens.brand = brandName;
-
-  // Update primitive colors with new names
-  tokens.primitive = tokens.primitive || {};
-  const primitiveColors = tokens.primitive.color || {};
-
-  // Remove old color keys, add new ones
-  delete primitiveColors.coral;
-  delete primitiveColors.purple;
-  delete primitiveColors.mint;
-
-  // Add new named colors. Skip any role with no base hex rather than crashing
-  // on an unexpected guidelines format.
-  for (const role of ['primary', 'secondary', 'accent']) {
-    const c = colors[role];
-    if (!c.base) {
-      console.warn(`⚠️  No base hex found for ${role} color — skipping its token scale.`);
-      continue;
-    }
-    primitiveColors[c.name] = generateColorScale(c.base, c.dark, c.light);
-  }
-
-  tokens.primitive.color = primitiveColors;
-
-  // Update ALL semantic color references
-  if (tokens.semantic?.color) {
-    const sem = tokens.semantic.color;
-    const p = colors.primary.name;
-    const s = colors.secondary.name;
-    const a = colors.accent.name;
-
-    // Primary variants
-    sem.primary = { "$value": `{primitive.color.${p}.500}`, "$type": "color" };
-    sem['primary-hover'] = { "$value": `{primitive.color.${p}.600}`, "$type": "color" };
-    sem['primary-active'] = { "$value": `{primitive.color.${p}.700}`, "$type": "color" };
-    sem['primary-light'] = { "$value": `{primitive.color.${p}.400}`, "$type": "color" };
-    sem['primary-lighter'] = { "$value": `{primitive.color.${p}.100}`, "$type": "color" };
-    sem['primary-dark'] = { "$value": `{primitive.color.${p}.600}`, "$type": "color" };
-
-    // Secondary variants
-    sem.secondary = { "$value": `{primitive.color.${s}.500}`, "$type": "color" };
-    sem['secondary-hover'] = { "$value": `{primitive.color.${s}.600}`, "$type": "color" };
-    sem['secondary-light'] = { "$value": `{primitive.color.${s}.300}`, "$type": "color" };
-    sem['secondary-dark'] = { "$value": `{primitive.color.${s}.600}`, "$type": "color" };
-
-    // Accent variants
-    sem.accent = { "$value": `{primitive.color.${a}.500}`, "$type": "color" };
-    sem['accent-hover'] = { "$value": `{primitive.color.${a}.600}`, "$type": "color" };
-    sem['accent-light'] = { "$value": `{primitive.color.${a}.300}`, "$type": "color" };
-
-    // Status colors (use accent for success, primary for error/info)
-    sem.success = { "$value": `{primitive.color.${a}.500}`, "$type": "color" };
-    sem['success-light'] = { "$value": `{primitive.color.${a}.300}`, "$type": "color" };
-    sem.error = { "$value": `{primitive.color.${p}.500}`, "$type": "color" };
-    sem['error-light'] = { "$value": `{primitive.color.${p}.300}`, "$type": "color" };
-    sem.info = { "$value": `{primitive.color.${s}.500}`, "$type": "color" };
-    sem['info-light'] = { "$value": `{primitive.color.${s}.300}`, "$type": "color" };
-  }
-
-  // Update component references (button uses primary color with opacity)
-  if (tokens.component?.button?.secondary && colors.primary.base) {
-    const primaryBase = colors.primary.base;
-    tokens.component.button.secondary['bg-hover'] = {
-      "$value": `${primaryBase}1A`,
-      "$type": "color"
-    };
-  }
-
-  return tokens;
-}
-
-/**
- * Main
- */
-function main() {
-  const dryRun = process.argv.includes('--dry-run');
-
-  console.log('🔄 Syncing brand guidelines → design tokens\n');
-
-  // Read brand guidelines
-  const guidelinesPath = path.resolve(process.cwd(), BRAND_GUIDELINES);
-  if (!fs.existsSync(guidelinesPath)) {
-    console.error(`❌ Brand guidelines not found: ${guidelinesPath}`);
-    process.exit(1);
-  }
-  const guidelinesContent = fs.readFileSync(guidelinesPath, 'utf-8');
-
-  // Extract colors
-  const colors = extractColorsFromMarkdown(guidelinesContent);
-  console.log('📊 Extracted colors:');
-  console.log(`   Primary: ${colors.primary.name} (${colors.primary.base})`);
-  console.log(`   Secondary: ${colors.secondary.name} (${colors.secondary.base})`);
-  console.log(`   Accent: ${colors.accent.name} (${colors.accent.base})\n`);
-
-  // Read existing tokens
-  const tokensPath = path.resolve(process.cwd(), DESIGN_TOKENS_JSON);
-  let tokens = {};
-  if (fs.existsSync(tokensPath)) {
-    tokens = JSON.parse(fs.readFileSync(tokensPath, 'utf-8'));
-  }
-
-  // Update tokens
-  tokens = updateDesignTokens(tokens, colors);
-
-  if (dryRun) {
-    console.log('📋 Would update design-tokens.json:');
-    console.log(JSON.stringify(tokens.primitive.color, null, 2).slice(0, 500) + '...');
-    console.log('\n⏭️  Dry run - no files changed');
-    return;
-  }
-
-  // Write updated tokens
-  fs.writeFileSync(tokensPath, JSON.stringify(tokens, null, 2));
-  console.log(`✅ Updated: ${DESIGN_TOKENS_JSON}`);
-
-  // Regenerate CSS
-  const generateScript = path.resolve(process.cwd(), GENERATE_TOKENS_SCRIPT);
-  if (fs.existsSync(generateScript)) {
-    try {
-      execFileSync('node', [generateScript, '--config', DESIGN_TOKENS_JSON, '-o', DESIGN_TOKENS_CSS], {
-        cwd: process.cwd(),
-        stdio: 'inherit'
-      });
-      console.log(`✅ Regenerated: ${DESIGN_TOKENS_CSS}`);
-    } catch (e) {
-      console.error('⚠️  Failed to regenerate CSS:', e.message);
-    }
-  }
-
-  console.log('\n✨ Brand sync complete!');
-}
-
-main();

package/.opencode/skills/brand/scripts/tests/test_sync_brand_to_tokens.py

@@ -1,52 +0,0 @@
-"""Regression test for sync-brand-to-tokens.cjs.
-
-The color parser required a parenthesized name in the Quick Reference row
-(`#2563EB (name)`) and a bolded label in the color tables (`**Primary Blue**`),
-neither of which the bundled starter template uses. As a result the base hex
-came back `undefined` and `adjustBrightness(undefined)` threw a TypeError —
-i.e. the script crashed on its own documented happy path. This test runs the
-sync against the bundled starter template and asserts it completes and writes
-the expected base colors. It is pytest-based so the existing pytest CI runs it.
-"""
-
-import json
-import shutil
-import subprocess
-from pathlib import Path
-
-import pytest
-
-SCRIPTS = Path(__file__).resolve().parent.parent
-SCRIPT = SCRIPTS / "sync-brand-to-tokens.cjs"
-BRAND_STARTER = SCRIPTS.parent / "templates" / "brand-guidelines-starter.md"
-TOKENS_STARTER = (
-    SCRIPTS.parent.parent / "design-system" / "templates" / "design-tokens-starter.json"
-)
-
-
-def test_sync_parses_bundled_starter_template(tmp_path):
-    node = shutil.which("node")
-    if not node:
-        pytest.skip("node not available")
-
-    (tmp_path / "docs").mkdir()
-    (tmp_path / "assets").mkdir()
-    shutil.copy(BRAND_STARTER, tmp_path / "docs" / "brand-guidelines.md")
-    shutil.copy(TOKENS_STARTER, tmp_path / "assets" / "design-tokens.json")
-
-    result = subprocess.run(
-        [node, str(SCRIPT)],
-        cwd=tmp_path,
-        capture_output=True,
-        text=True,
-    )
-
-    # Must not crash (the bug raised an unhandled TypeError).
-    assert "TypeError" not in result.stderr, result.stderr
-    assert result.returncode == 0, result.stderr + result.stdout
-
-    tokens = json.loads((tmp_path / "assets" / "design-tokens.json").read_text())
-    primitive = tokens["primitive"]["color"]
-    assert primitive["primary"]["500"]["$value"] == "#2563EB"
-    assert primitive["secondary"]["500"]["$value"] == "#8B5CF6"
-    assert primitive["accent"]["500"]["$value"] == "#10B981"

package/.opencode/skills/brand/scripts/validate-asset.cjs

@@ -1,387 +0,0 @@
-#!/usr/bin/env node
-/**
- * validate-asset.cjs
- *
- * Validates marketing assets against brand guidelines.
- * Checks: file naming, dimensions, file size, metadata.
- *
- * Usage:
- *   node validate-asset.cjs <asset-path>
- *   node validate-asset.cjs <asset-path> --json
- *   node validate-asset.cjs <asset-path> --fix
- *
- * For color validation of images, use with extract-colors.cjs
- */
-
-const fs = require("fs");
-const path = require("path");
-
-// Validation rules
-const RULES = {
-  naming: {
-    pattern: /^[a-z]+_[a-z0-9-]+_[a-z0-9-]+_\d{8}(_[a-z0-9-]+)?\.[a-z]+$/,
-    description:
-      "{type}_{campaign}_{description}_{timestamp}_{variant}.{ext}",
-    examples: [
-      "banner_claude-launch_hero-image_20251209.png",
-      "logo_brand-refresh_horizontal_20251209_dark.svg",
-    ],
-  },
-  dimensions: {
-    banner: { minWidth: 600, minHeight: 300 },
-    logo: { minWidth: 100, minHeight: 100 },
-    design: { minWidth: 800, minHeight: 600 },
-    video: { minWidth: 640, minHeight: 480 },
-    default: { minWidth: 100, minHeight: 100 },
-  },
-  fileSize: {
-    image: { max: 5 * 1024 * 1024, recommended: 1 * 1024 * 1024 },
-    video: { max: 100 * 1024 * 1024, recommended: 50 * 1024 * 1024 },
-    svg: { max: 500 * 1024, recommended: 100 * 1024 },
-  },
-  formats: {
-    image: ["png", "jpg", "jpeg", "webp", "gif"],
-    vector: ["svg"],
-    video: ["mp4", "mov", "webm"],
-    document: ["pdf", "psd", "ai", "fig"],
-  },
-};
-
-/**
- * Parse asset filename
- */
-function parseFilename(filename) {
-  const parts = filename.replace(/\.[^.]+$/, "").split("_");
-
-  if (parts.length < 4) {
-    return null;
-  }
-
-  return {
-    type: parts[0],
-    campaign: parts[1],
-    description: parts[2],
-    timestamp: parts[3],
-    variant: parts.length > 4 ? parts[4] : null,
-    extension: path.extname(filename).slice(1).toLowerCase(),
-  };
-}
-
-/**
- * Validate filename convention
- */
-function validateFilename(filename) {
-  const issues = [];
-  const suggestions = [];
-
-  // Check pattern match
-  if (!RULES.naming.pattern.test(filename)) {
-    issues.push("Filename does not match naming convention");
-    suggestions.push(`Expected format: ${RULES.naming.description}`);
-    suggestions.push(`Examples: ${RULES.naming.examples.join(", ")}`);
-  }
-
-  // Parse and check components
-  const parsed = parseFilename(filename);
-  if (parsed) {
-    // Check timestamp format
-    if (!/^\d{8}$/.test(parsed.timestamp)) {
-      issues.push("Timestamp should be YYYYMMDD format");
-    }
-
-    // Check kebab-case for campaign and description
-    if (parsed.campaign && !/^[a-z0-9-]+$/.test(parsed.campaign)) {
-      issues.push("Campaign name should be kebab-case");
-    }
-
-    if (parsed.description && !/^[a-z0-9-]+$/.test(parsed.description)) {
-      issues.push("Description should be kebab-case");
-    }
-
-    // Check valid type
-    const validTypes = [
-      "banner",
-      "logo",
-      "design",
-      "video",
-      "infographic",
-      "icon",
-      "photo",
-    ];
-    if (!validTypes.includes(parsed.type)) {
-      suggestions.push(`Consider using type: ${validTypes.join(", ")}`);
-    }
-  }
-
-  return { valid: issues.length === 0, issues, suggestions, parsed };
-}
-
-/**
- * Validate file size
- */
-function validateFileSize(filepath, extension) {
-  const issues = [];
-  const warnings = [];
-
-  const stats = fs.statSync(filepath);
-  const size = stats.size;
-
-  let limits;
-  if (RULES.formats.video.includes(extension)) {
-    limits = RULES.fileSize.video;
-  } else if (extension === "svg") {
-    limits = RULES.fileSize.svg;
-  } else {
-    limits = RULES.fileSize.image;
-  }
-
-  if (size > limits.max) {
-    issues.push(
-      `File size (${formatBytes(size)}) exceeds maximum (${formatBytes(
-        limits.max
-      )})`
-    );
-  } else if (size > limits.recommended) {
-    warnings.push(
-      `File size (${formatBytes(size)}) exceeds recommended (${formatBytes(
-        limits.recommended
-      )})`
-    );
-  }
-
-  return { valid: issues.length === 0, issues, warnings, size };
-}
-
-/**
- * Validate file format
- */
-function validateFormat(extension) {
-  const issues = [];
-  const info = { category: null };
-
-  const allFormats = [
-    ...RULES.formats.image,
-    ...RULES.formats.vector,
-    ...RULES.formats.video,
-    ...RULES.formats.document,
-  ];
-
-  if (!allFormats.includes(extension)) {
-    issues.push(`Unsupported file format: .${extension}`);
-    return { valid: false, issues, info };
-  }
-
-  // Determine category
-  if (RULES.formats.image.includes(extension)) info.category = "image";
-  else if (RULES.formats.vector.includes(extension)) info.category = "vector";
-  else if (RULES.formats.video.includes(extension)) info.category = "video";
-  else if (RULES.formats.document.includes(extension))
-    info.category = "document";
-
-  return { valid: true, issues, info };
-}
-
-/**
- * Check if asset exists in manifest
- */
-function checkManifest(filepath) {
-  const manifestPath = path.join(process.cwd(), ".assets", "manifest.json");
-
-  if (!fs.existsSync(manifestPath)) {
-    return { registered: false, message: "Manifest not found" };
-  }
-
-  try {
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-    const relativePath = path.relative(process.cwd(), filepath);
-    const found = manifest.assets?.find(
-      (a) => a.path === relativePath || a.path === filepath
-    );
-
-    return {
-      registered: !!found,
-      message: found ? "Asset registered in manifest" : "Asset not in manifest",
-      asset: found,
-    };
-  } catch {
-    return { registered: false, message: "Error reading manifest" };
-  }
-}
-
-/**
- * Generate suggested filename
- */
-function suggestFilename(original, parsed) {
-  if (!parsed) return null;
-
-  const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const type = parsed.type || "asset";
-  const campaign = parsed.campaign || "general";
-  const description = parsed.description || "untitled";
-  const ext = parsed.extension || "png";
-
-  return `${type}_${campaign}_${description}_${today}.${ext}`;
-}
-
-/**
- * Format bytes to human readable
- */
-function formatBytes(bytes) {
-  if (bytes === 0) return "0 Bytes";
-  const k = 1024;
-  const sizes = ["Bytes", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-}
-
-/**
- * Main validation function
- */
-function validateAsset(assetPath) {
-  const results = {
-    path: assetPath,
-    filename: path.basename(assetPath),
-    valid: true,
-    issues: [],
-    warnings: [],
-    suggestions: [],
-    checks: {},
-  };
-
-  // Check file exists
-  if (!fs.existsSync(assetPath)) {
-    results.valid = false;
-    results.issues.push(`File not found: ${assetPath}`);
-    return results;
-  }
-
-  const filename = path.basename(assetPath);
-  const extension = path.extname(filename).slice(1).toLowerCase();
-
-  // 1. Validate filename
-  const filenameResult = validateFilename(filename);
-  results.checks.filename = filenameResult;
-  if (!filenameResult.valid) {
-    results.issues.push(...filenameResult.issues);
-    results.suggestions.push(...filenameResult.suggestions);
-  }
-
-  // 2. Validate format
-  const formatResult = validateFormat(extension);
-  results.checks.format = formatResult;
-  if (!formatResult.valid) {
-    results.issues.push(...formatResult.issues);
-  }
-
-  // 3. Validate file size
-  const sizeResult = validateFileSize(assetPath, extension);
-  results.checks.fileSize = sizeResult;
-  if (!sizeResult.valid) {
-    results.issues.push(...sizeResult.issues);
-  }
-  results.warnings.push(...sizeResult.warnings);
-
-  // 4. Check manifest registration
-  const manifestResult = checkManifest(assetPath);
-  results.checks.manifest = manifestResult;
-  if (!manifestResult.registered) {
-    results.warnings.push("Asset not registered in manifest.json");
-    results.suggestions.push(
-      "Register asset in .assets/manifest.json for tracking"
-    );
-  }
-
-  // 5. Suggest corrected filename if needed
-  if (!filenameResult.valid && filenameResult.parsed) {
-    const suggested = suggestFilename(filename, filenameResult.parsed);
-    if (suggested) {
-      results.suggestions.push(`Suggested filename: ${suggested}`);
-    }
-  }
-
-  // Overall validity
-  results.valid = results.issues.length === 0;
-
-  return results;
-}
-
-/**
- * Format output for console
- */
-function formatOutput(results) {
-  const lines = [];
-
-  lines.push("\n" + "=".repeat(60));
-  lines.push(`ASSET VALIDATION: ${results.filename}`);
-  lines.push("=".repeat(60));
-
-  lines.push(`\nStatus: ${results.valid ? "PASS" : "FAIL"}`);
-  lines.push(`Path: ${results.path}`);
-
-  if (results.issues.length > 0) {
-    lines.push("\nISSUES:");
-    results.issues.forEach((issue) => lines.push(`  - ${issue}`));
-  }
-
-  if (results.warnings.length > 0) {
-    lines.push("\nWARNINGS:");
-    results.warnings.forEach((warning) => lines.push(`  - ${warning}`));
-  }
-
-  if (results.suggestions.length > 0) {
-    lines.push("\nSUGGESTIONS:");
-    results.suggestions.forEach((suggestion) =>
-      lines.push(`  - ${suggestion}`)
-    );
-  }
-
-  // File size info
-  if (results.checks.fileSize?.size) {
-    lines.push(`\nFile Size: ${formatBytes(results.checks.fileSize.size)}`);
-  }
-
-  lines.push("\n" + "=".repeat(60));
-
-  return lines.join("\n");
-}
-
-/**
- * Main
- */
-function main() {
-  const args = process.argv.slice(2);
-  const jsonOutput = args.includes("--json");
-  const assetPath = args.find((a) => !a.startsWith("--"));
-
-  if (!assetPath) {
-    console.error("Usage: node validate-asset.cjs <asset-path> [--json]");
-    console.error("\nExamples:");
-    console.error(
-      "  node validate-asset.cjs assets/banners/social-media/banner_launch_hero_20251209.png"
-    );
-    console.error(
-      "  node validate-asset.cjs assets/logos/icon-only/logo-icon.svg --json"
-    );
-    process.exit(1);
-  }
-
-  // Resolve path
-  const resolvedPath = path.isAbsolute(assetPath)
-    ? assetPath
-    : path.join(process.cwd(), assetPath);
-
-  // Validate
-  const results = validateAsset(resolvedPath);
-
-  // Output
-  if (jsonOutput) {
-    console.log(JSON.stringify(results, null, 2));
-  } else {
-    console.log(formatOutput(results));
-  }
-
-  // Exit with appropriate code
-  process.exit(results.valid ? 0 : 1);
-}
-
-main();