392 lines
11 KiB
JavaScript
392 lines
11 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
/**
|
||
* Marketplace Validation Script
|
||
* Validates marketplace structure, configuration, and content
|
||
*/
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
|
||
class MarketplaceValidator {
|
||
constructor() {
|
||
this.errors = [];
|
||
this.warnings = [];
|
||
this.info = [];
|
||
}
|
||
|
||
log(message, type = 'info') {
|
||
this[type].push(message);
|
||
}
|
||
|
||
/**
|
||
* Validate marketplace directory structure
|
||
*/
|
||
validateStructure(marketplacePath) {
|
||
console.log('Validating marketplace structure...');
|
||
|
||
const requiredDirs = ['.claude-plugin'];
|
||
const requiredFiles = ['.claude-plugin/marketplace.json'];
|
||
const optionalDirs = ['plugins', 'skills', 'docs', 'tests', 'scripts', 'examples'];
|
||
|
||
// Check required directories
|
||
requiredDirs.forEach(dir => {
|
||
const dirPath = path.join(marketplacePath, dir);
|
||
if (!fs.existsSync(dirPath)) {
|
||
this.log(`Required directory missing: ${dir}`, 'errors');
|
||
} else {
|
||
this.log(`Required directory found: ${dir}`, 'info');
|
||
}
|
||
});
|
||
|
||
// Check required files
|
||
requiredFiles.forEach(file => {
|
||
const filePath = path.join(marketplacePath, file);
|
||
if (!fs.existsSync(filePath)) {
|
||
this.log(`Required file missing: ${file}`, 'errors');
|
||
} else {
|
||
this.log(`Required file found: ${file}`, 'info');
|
||
}
|
||
});
|
||
|
||
// Check optional directories
|
||
optionalDirs.forEach(dir => {
|
||
const dirPath = path.join(marketplacePath, dir);
|
||
if (fs.existsSync(dirPath)) {
|
||
this.log(`Optional directory found: ${dir}`, 'info');
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Validate marketplace configuration
|
||
*/
|
||
validateConfiguration(marketplacePath) {
|
||
console.log('Validating marketplace configuration...');
|
||
|
||
const configPath = path.join(marketplacePath, '.claude-plugin', 'marketplace.json');
|
||
|
||
if (!fs.existsSync(configPath)) {
|
||
this.log('Marketplace configuration file missing', 'errors');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
|
||
|
||
// Validate required fields
|
||
const requiredFields = ['name', 'version', 'description', 'owner'];
|
||
requiredFields.forEach(field => {
|
||
if (!config[field]) {
|
||
this.log(`Required configuration field missing: ${field}`, 'errors');
|
||
} else {
|
||
this.log(`Required field found: ${field}`, 'info');
|
||
}
|
||
});
|
||
|
||
// Validate version format
|
||
if (config.version && !this.isValidVersion(config.version)) {
|
||
this.log(`Invalid version format: ${config.version}`, 'errors');
|
||
}
|
||
|
||
// Validate plugins array
|
||
if (config.plugins) {
|
||
if (!Array.isArray(config.plugins)) {
|
||
this.log('Plugins field must be an array', 'errors');
|
||
} else {
|
||
this.log(`Found ${config.plugins.length} plugins in configuration`, 'info');
|
||
}
|
||
}
|
||
|
||
// Validate skills array
|
||
if (config.skills) {
|
||
if (!Array.isArray(config.skills)) {
|
||
this.log('Skills field must be an array', 'errors');
|
||
} else {
|
||
this.log(`Found ${config.skills.length} skills in configuration`, 'info');
|
||
}
|
||
}
|
||
|
||
// Validate owner object
|
||
if (config.owner) {
|
||
const ownerFields = ['name', 'email'];
|
||
ownerFields.forEach(field => {
|
||
if (config.owner[field]) {
|
||
this.log(`Owner ${field} found: ${config.owner[field]}`, 'info');
|
||
}
|
||
});
|
||
}
|
||
|
||
this.log('Configuration file structure validated', 'info');
|
||
} catch (error) {
|
||
this.log(`Invalid JSON in configuration file: ${error.message}`, 'errors');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Validate plugins
|
||
*/
|
||
validatePlugins(marketplacePath) {
|
||
console.log('Validating plugins...');
|
||
|
||
const configPath = path.join(marketplacePath, '.claude-plugin', 'marketplace.json');
|
||
|
||
if (!fs.existsSync(configPath)) {
|
||
this.log('Cannot validate plugins - configuration file missing', 'warnings');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
|
||
|
||
if (!config.plugins || config.plugins.length === 0) {
|
||
this.log('No plugins configured in marketplace', 'warnings');
|
||
return;
|
||
}
|
||
|
||
const pluginsDir = path.join(marketplacePath, 'plugins');
|
||
|
||
if (!fs.existsSync(pluginsDir)) {
|
||
this.log('Plugins directory not found', 'warnings');
|
||
return;
|
||
}
|
||
|
||
for (const plugin of config.plugins) {
|
||
this.validatePlugin(plugin, pluginsDir);
|
||
}
|
||
} catch (error) {
|
||
this.log(`Error validating plugins: ${error.message}`, 'errors');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Validate individual plugin
|
||
*/
|
||
validatePlugin(plugin, pluginsDir) {
|
||
if (!plugin.name) {
|
||
this.log('Plugin found without name in configuration', 'errors');
|
||
return;
|
||
}
|
||
|
||
const pluginPath = path.join(pluginsDir, plugin.name);
|
||
if (!fs.existsSync(pluginPath)) {
|
||
this.log(`Plugin directory not found: ${plugin.name}`, 'warnings');
|
||
return;
|
||
}
|
||
|
||
const pluginJsonPath = path.join(pluginPath, '.claude-plugin', 'plugin.json');
|
||
if (!fs.existsSync(pluginJsonPath)) {
|
||
this.log(`Plugin configuration missing: ${plugin.name}/plugin.json`, 'errors');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const pluginConfig = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8'));
|
||
|
||
// Validate plugin structure
|
||
const requiredFields = ['name', 'version', 'description'];
|
||
requiredFields.forEach(field => {
|
||
if (!pluginConfig[field]) {
|
||
this.log(`Plugin ${plugin.name}: Required field missing: ${field}`, 'errors');
|
||
}
|
||
});
|
||
|
||
this.log(`Plugin validated: ${plugin.name}`, 'info');
|
||
} catch (error) {
|
||
this.log(`Plugin ${plugin.name}: Invalid configuration - ${error.message}`, 'errors');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Validate skills
|
||
*/
|
||
validateSkills(marketplacePath) {
|
||
console.log('Validating skills...');
|
||
|
||
const skillsDir = path.join(marketplacePath, 'skills');
|
||
|
||
if (!fs.existsSync(skillsDir)) {
|
||
this.log('Skills directory not found', 'warnings');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const skills = fs
|
||
.readdirSync(skillsDir, { withFileTypes: true })
|
||
.filter(dirent => dirent.isDirectory())
|
||
.map(dirent => dirent.name);
|
||
|
||
if (skills.length === 0) {
|
||
this.log('No skills found in marketplace', 'warnings');
|
||
return;
|
||
}
|
||
|
||
for (const skill of skills) {
|
||
this.validateSkill(path.join(skillsDir, skill), skill);
|
||
}
|
||
} catch (error) {
|
||
this.log(`Error validating skills: ${error.message}`, 'errors');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Validate individual skill
|
||
*/
|
||
validateSkill(skillPath, skillName) {
|
||
const skillMdPath = path.join(skillPath, 'SKILL.md');
|
||
|
||
if (!fs.existsSync(skillMdPath)) {
|
||
this.log(`Skill SKILL.md missing: ${skillName}`, 'errors');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const content = fs.readFileSync(skillMdPath, 'utf8');
|
||
|
||
// Check for required frontmatter
|
||
if (!content.includes('---')) {
|
||
this.log(`Skill ${skillName}: Missing frontmatter`, 'errors');
|
||
return;
|
||
}
|
||
|
||
// Extract and validate frontmatter
|
||
const frontmatterMatch = content.match(/^---\n(.*?)\n---/s);
|
||
if (frontmatterMatch) {
|
||
try {
|
||
const frontmatter = JSON.parse(frontmatterMatch[1].replace(/(\w+):/g, '"$1":'));
|
||
|
||
if (!frontmatter.name) {
|
||
this.log(`Skill ${skillName}: Missing name in frontmatter`, 'errors');
|
||
}
|
||
|
||
if (!frontmatter.description) {
|
||
this.log(`Skill ${skillName}: Missing description in frontmatter`, 'warnings');
|
||
}
|
||
} catch (error) {
|
||
this.log(`Skill ${skillName}: Invalid frontmatter format`, 'errors');
|
||
}
|
||
}
|
||
|
||
this.log(`Skill validated: ${skillName}`, 'info');
|
||
} catch (error) {
|
||
this.log(`Skill ${skillName}: Error reading file - ${error.message}`, 'errors');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Validate documentation
|
||
*/
|
||
validateDocumentation(marketplacePath) {
|
||
console.log('Validating documentation...');
|
||
|
||
const docsDir = path.join(marketplacePath, 'docs');
|
||
|
||
if (!fs.existsSync(docsDir)) {
|
||
this.log('Documentation directory not found', 'warnings');
|
||
return;
|
||
}
|
||
|
||
const requiredDocs = ['README.md'];
|
||
const recommendedDocs = ['GUIDE.md', 'CONTRIBUTING.md'];
|
||
|
||
// Check required documentation
|
||
requiredDocs.forEach(doc => {
|
||
const docPath = path.join(marketplacePath, doc);
|
||
if (fs.existsSync(docPath)) {
|
||
this.log(`Required documentation found: ${doc}`, 'info');
|
||
} else {
|
||
this.log(`Required documentation missing: ${doc}`, 'errors');
|
||
}
|
||
});
|
||
|
||
// Check recommended documentation
|
||
recommendedDocs.forEach(doc => {
|
||
const docPath = path.join(docsDir, doc);
|
||
if (fs.existsSync(docPath)) {
|
||
this.log(`Recommended documentation found: ${doc}`, 'info');
|
||
} else {
|
||
this.log(`Recommended documentation missing: ${doc}`, 'warnings');
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Check if version string is valid
|
||
*/
|
||
isValidVersion(version) {
|
||
return /^\d+\.\d+\.\d+(-.*)?$/.test(version);
|
||
}
|
||
|
||
/**
|
||
* Run complete validation
|
||
*/
|
||
async validate(marketplacePath = './') {
|
||
console.log(`Starting marketplace validation for: ${marketplacePath}`);
|
||
console.log('='.repeat(50));
|
||
|
||
// Check if marketplace exists
|
||
if (!fs.existsSync(marketplacePath)) {
|
||
console.error('Error: Marketplace directory does not exist');
|
||
process.exit(1);
|
||
}
|
||
|
||
// Run all validations
|
||
this.validateStructure(marketplacePath);
|
||
this.validateConfiguration(marketplacePath);
|
||
this.validatePlugins(marketplacePath);
|
||
this.validateSkills(marketplacePath);
|
||
this.validateDocumentation(marketplacePath);
|
||
|
||
// Report results
|
||
console.log('='.repeat(50));
|
||
console.log('Validation Results:');
|
||
console.log(`Errors: ${this.errors.length}`);
|
||
console.log(`Warnings: ${this.warnings.length}`);
|
||
console.log(`Info: ${this.info.length}`);
|
||
|
||
if (this.errors.length > 0) {
|
||
console.log('\nErrors:');
|
||
this.errors.forEach(error => console.log(` ❌ ${error}`));
|
||
}
|
||
|
||
if (this.warnings.length > 0) {
|
||
console.log('\nWarnings:');
|
||
this.warnings.forEach(warning => console.log(` ⚠️ ${warning}`));
|
||
}
|
||
|
||
if (this.verbose && this.info.length > 0) {
|
||
console.log('\nInfo:');
|
||
this.info.forEach(info => console.log(` ℹ️ ${info}`));
|
||
}
|
||
|
||
// Exit with appropriate code
|
||
if (this.errors.length > 0) {
|
||
console.log('\n❌ Validation failed with errors');
|
||
process.exit(1);
|
||
} else if (this.warnings.length > 0) {
|
||
console.log('\n⚠️ Validation completed with warnings');
|
||
process.exit(2);
|
||
} else {
|
||
console.log('\n✅ Validation passed successfully');
|
||
process.exit(0);
|
||
}
|
||
}
|
||
}
|
||
|
||
// CLI interface
|
||
if (require.main === module) {
|
||
const args = process.argv.slice(2);
|
||
const marketplacePath = args[0] || './';
|
||
const validator = new MarketplaceValidator();
|
||
|
||
// Check for verbose flag
|
||
validator.verbose = args.includes('--verbose');
|
||
|
||
validator.validate(marketplacePath).catch(error => {
|
||
console.error('Validation error:', error.message);
|
||
process.exit(1);
|
||
});
|
||
}
|
||
|
||
module.exports = MarketplaceValidator;
|