388 lines
12 KiB
Python
388 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Marketplace Configuration Validator for Claude Code
|
|
|
|
Validates marketplace.json files for correctness and best practices.
|
|
|
|
Usage:
|
|
python validate_marketplace.py [marketplace.json]
|
|
|
|
Example:
|
|
python validate_marketplace.py .claude-plugin/marketplace.json
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Tuple
|
|
|
|
|
|
class ValidationError:
|
|
"""Represents a validation error or warning."""
|
|
|
|
def __init__(self, level: str, path: str, message: str):
|
|
self.level = level # 'error' or 'warning'
|
|
self.path = path
|
|
self.message = message
|
|
|
|
def __str__(self):
|
|
icon = "❌" if self.level == "error" else "⚠️"
|
|
return f"{icon} {self.level.upper()}: {self.path}: {self.message}"
|
|
|
|
|
|
class MarketplaceValidator:
|
|
"""Validates Claude Code marketplace.json files."""
|
|
|
|
def __init__(self, marketplace_path: Path):
|
|
self.marketplace_path = marketplace_path
|
|
self.base_dir = marketplace_path.parent.parent
|
|
self.errors: List[ValidationError] = []
|
|
self.warnings: List[ValidationError] = []
|
|
self.data: Dict[str, Any] = {}
|
|
|
|
def validate(self) -> bool:
|
|
"""
|
|
Perform all validation checks.
|
|
|
|
Returns:
|
|
True if validation passes (no errors), False otherwise
|
|
"""
|
|
if not self._load_json():
|
|
return False
|
|
|
|
self._validate_structure()
|
|
self._validate_plugins()
|
|
|
|
return len(self.errors) == 0
|
|
|
|
def _load_json(self) -> bool:
|
|
"""Load and parse the JSON file."""
|
|
try:
|
|
with open(self.marketplace_path, "r") as f:
|
|
self.data = json.load(f)
|
|
return True
|
|
except FileNotFoundError:
|
|
self.errors.append(
|
|
ValidationError("error", str(self.marketplace_path), "File not found")
|
|
)
|
|
return False
|
|
except json.JSONDecodeError as e:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
str(self.marketplace_path),
|
|
f"Invalid JSON: {e}"
|
|
)
|
|
)
|
|
return False
|
|
|
|
def _validate_structure(self):
|
|
"""Validate top-level marketplace structure."""
|
|
# Check for required field
|
|
if "plugins" not in self.data:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
"marketplace.json",
|
|
"Missing required field 'plugins'"
|
|
)
|
|
)
|
|
return
|
|
|
|
if not isinstance(self.data["plugins"], list):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
"marketplace.json",
|
|
"'plugins' must be an array"
|
|
)
|
|
)
|
|
|
|
# Check for optional pluginRoot
|
|
if "pluginRoot" in self.data:
|
|
plugin_root = self.data["pluginRoot"]
|
|
if not isinstance(plugin_root, str):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
"pluginRoot",
|
|
"Must be a string"
|
|
)
|
|
)
|
|
elif not plugin_root.startswith("./"):
|
|
self.warnings.append(
|
|
ValidationError(
|
|
"warning",
|
|
"pluginRoot",
|
|
"Should start with './' for relative paths"
|
|
)
|
|
)
|
|
|
|
def _validate_plugins(self):
|
|
"""Validate each plugin entry."""
|
|
if "plugins" not in self.data or not isinstance(self.data["plugins"], list):
|
|
return
|
|
|
|
plugin_names = set()
|
|
|
|
for idx, plugin in enumerate(self.data["plugins"]):
|
|
path_prefix = f"plugins[{idx}]"
|
|
|
|
if not isinstance(plugin, dict):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
path_prefix,
|
|
"Plugin entry must be an object"
|
|
)
|
|
)
|
|
continue
|
|
|
|
# Validate required fields
|
|
if "name" not in plugin:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}",
|
|
"Missing required field 'name'"
|
|
)
|
|
)
|
|
else:
|
|
name = plugin["name"]
|
|
|
|
# Check for duplicate names
|
|
if name in plugin_names:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.name",
|
|
f"Duplicate plugin name '{name}'"
|
|
)
|
|
)
|
|
plugin_names.add(name)
|
|
|
|
# Validate name format
|
|
if not self._is_valid_kebab_case(name):
|
|
self.warnings.append(
|
|
ValidationError(
|
|
"warning",
|
|
f"{path_prefix}.name",
|
|
f"Plugin name '{name}' should use kebab-case"
|
|
)
|
|
)
|
|
|
|
if "source" not in plugin:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}",
|
|
"Missing required field 'source'"
|
|
)
|
|
)
|
|
else:
|
|
self._validate_source_path(plugin["source"], path_prefix)
|
|
|
|
# Validate optional fields
|
|
if "version" in plugin and not isinstance(plugin["version"], str):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.version",
|
|
"Version must be a string"
|
|
)
|
|
)
|
|
|
|
if "description" in plugin and not isinstance(plugin["description"], str):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.description",
|
|
"Description must be a string"
|
|
)
|
|
)
|
|
|
|
# Validate component arrays
|
|
for component_type in ["agents", "commands", "skills"]:
|
|
if component_type in plugin:
|
|
self._validate_component_array(
|
|
plugin[component_type],
|
|
f"{path_prefix}.{component_type}",
|
|
plugin.get("source", "")
|
|
)
|
|
|
|
def _validate_source_path(self, source: str, path_prefix: str):
|
|
"""Validate plugin source path."""
|
|
if not isinstance(source, str):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.source",
|
|
"Source must be a string"
|
|
)
|
|
)
|
|
return
|
|
|
|
# Check for relative path prefix
|
|
if not source.startswith("./"):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.source",
|
|
f"Source path '{source}' must start with './'"
|
|
)
|
|
)
|
|
|
|
# Check if directory exists
|
|
source_path = self.base_dir / source.lstrip("./")
|
|
if not source_path.exists():
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.source",
|
|
f"Source directory '{source}' does not exist"
|
|
)
|
|
)
|
|
elif not source_path.is_dir():
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{path_prefix}.source",
|
|
f"Source path '{source}' is not a directory"
|
|
)
|
|
)
|
|
|
|
def _validate_component_array(
|
|
self,
|
|
components: Any,
|
|
path_prefix: str,
|
|
plugin_source: str
|
|
):
|
|
"""Validate component array (agents, commands, or skills)."""
|
|
if not isinstance(components, list):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
path_prefix,
|
|
"Component array must be an array"
|
|
)
|
|
)
|
|
return
|
|
|
|
component_type = path_prefix.split(".")[-1] # Extract 'agents', 'commands', etc.
|
|
|
|
for idx, component in enumerate(components):
|
|
comp_path = f"{path_prefix}[{idx}]"
|
|
|
|
if not isinstance(component, dict):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
comp_path,
|
|
"Component entry must be an object"
|
|
)
|
|
)
|
|
continue
|
|
|
|
# Validate required 'path' field
|
|
if "path" not in component:
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
comp_path,
|
|
"Missing required field 'path'"
|
|
)
|
|
)
|
|
else:
|
|
comp_file_path = component["path"]
|
|
if not isinstance(comp_file_path, str):
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{comp_path}.path",
|
|
"Path must be a string"
|
|
)
|
|
)
|
|
else:
|
|
# Resolve full path
|
|
if plugin_source:
|
|
full_path = self.base_dir / plugin_source.lstrip("./") / comp_file_path
|
|
if not full_path.exists():
|
|
self.errors.append(
|
|
ValidationError(
|
|
"error",
|
|
f"{comp_path}.path",
|
|
f"Component file '{comp_file_path}' does not exist at '{full_path}'"
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def _is_valid_kebab_case(name: str) -> bool:
|
|
"""Check if string follows kebab-case convention."""
|
|
if not name:
|
|
return False
|
|
if not all(c.islower() or c.isdigit() or c == '-' for c in name):
|
|
return False
|
|
if name.startswith('-') or name.endswith('-'):
|
|
return False
|
|
if '--' in name:
|
|
return False
|
|
return True
|
|
|
|
def print_report(self):
|
|
"""Print validation report."""
|
|
if self.errors:
|
|
print("\n🔴 ERRORS:")
|
|
for error in self.errors:
|
|
print(f" {error}")
|
|
|
|
if self.warnings:
|
|
print("\n⚠️ WARNINGS:")
|
|
for warning in self.warnings:
|
|
print(f" {warning}")
|
|
|
|
print("\n" + "=" * 60)
|
|
if self.errors:
|
|
print(f"❌ Validation FAILED: {len(self.errors)} error(s), {len(self.warnings)} warning(s)")
|
|
elif self.warnings:
|
|
print(f"✅ Validation PASSED with {len(self.warnings)} warning(s)")
|
|
else:
|
|
print("✅ Validation PASSED: No errors or warnings")
|
|
print("=" * 60)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Validate Claude Code marketplace.json files",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""
|
|
Examples:
|
|
python validate_marketplace.py .claude-plugin/marketplace.json
|
|
python validate_marketplace.py /path/to/marketplace.json
|
|
"""
|
|
)
|
|
|
|
parser.add_argument(
|
|
"marketplace_file",
|
|
nargs="?",
|
|
default=".claude-plugin/marketplace.json",
|
|
help="Path to marketplace.json file (default: .claude-plugin/marketplace.json)"
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
marketplace_path = Path(args.marketplace_file)
|
|
|
|
print(f"Validating: {marketplace_path}")
|
|
print("=" * 60)
|
|
|
|
validator = MarketplaceValidator(marketplace_path)
|
|
success = validator.validate()
|
|
validator.print_report()
|
|
|
|
sys.exit(0 if success else 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|