awesome-slash 2.4.3 → 2.5.0

package/lib/platform/detection-configs.js

@@ -0,0 +1,93 @@
+/**
+ * Detection Configurations
+ * Centralized config for platform detection logic
+ *
+ * @module lib/platform/detection-configs
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+/**
+ * CI platform detection configuration
+ * Order matters - first match wins
+ */
+const CI_CONFIGS = [
+  { file: '.github/workflows', platform: 'github-actions' },
+  { file: '.gitlab-ci.yml', platform: 'gitlab-ci' },
+  { file: '.circleci/config.yml', platform: 'circleci' },
+  { file: 'Jenkinsfile', platform: 'jenkins' },
+  { file: '.travis.yml', platform: 'travis' }
+];
+
+/**
+ * Deployment platform detection configuration
+ * Order matters - first match wins
+ */
+const DEPLOYMENT_CONFIGS = [
+  { file: 'railway.json', platform: 'railway' },
+  { file: 'railway.toml', platform: 'railway' },  // Legacy Railway marker
+  { file: 'vercel.json', platform: 'vercel' },
+  { file: 'netlify.toml', platform: 'netlify' },
+  { file: '.netlify', platform: 'netlify' },       // Legacy Netlify marker
+  { file: 'fly.toml', platform: 'fly' },
+  { file: '.platform.app.yaml', platform: 'platformsh' },
+  { file: 'render.yaml', platform: 'render' }
+];
+
+/**
+ * Project type detection configuration
+ * Checks package.json for framework indicators
+ */
+const PROJECT_TYPE_CONFIGS = {
+  dependencies: [
+    { name: 'next', type: 'nextjs' },
+    { name: 'react', type: 'react' },
+    { name: 'vue', type: 'vue' },
+    { name: '@angular/core', type: 'angular' },
+    { name: 'svelte', type: 'svelte' },
+    { name: 'express', type: 'express' },
+    { name: '@nestjs/core', type: 'nestjs' },
+    { name: 'gatsby', type: 'gatsby' },
+    { name: '@remix-run/react', type: 'remix' },
+    { name: 'astro', type: 'astro' }
+  ]
+};
+
+/**
+ * Package manager detection configuration
+ * Lock files indicate package manager used
+ * Order matters - first match wins (prioritize pnpm > yarn > bun > npm for Node.js)
+ */
+const PACKAGE_MANAGER_CONFIGS = [
+  { file: 'pnpm-lock.yaml', manager: 'pnpm' },
+  { file: 'yarn.lock', manager: 'yarn' },
+  { file: 'bun.lockb', manager: 'bun' },
+  { file: 'package-lock.json', manager: 'npm' },
+  { file: 'poetry.lock', manager: 'poetry' },
+  { file: 'Pipfile.lock', manager: 'pipenv' },
+  { file: 'Cargo.lock', manager: 'cargo' },
+  { file: 'go.sum', manager: 'go' }
+];
+
+/**
+ * Branch strategy patterns
+ */
+const BRANCH_STRATEGIES = {
+  gitflow: ['develop', 'main', 'master'],
+  githubflow: ['main'],
+  trunkbased: ['main', 'trunk']
+};
+
+/**
+ * Main branch candidates (in priority order)
+ */
+const MAIN_BRANCH_CANDIDATES = ['main', 'master', 'trunk', 'develop'];
+
+module.exports = {
+  CI_CONFIGS,
+  DEPLOYMENT_CONFIGS,
+  PROJECT_TYPE_CONFIGS,
+  PACKAGE_MANAGER_CONFIGS,
+  BRANCH_STRATEGIES,
+  MAIN_BRANCH_CANDIDATES
+};

package/lib/platform/verify-tools.js

@@ -10,70 +10,19 @@
  * @license MIT
  */
 
-const { execFileSync, spawnSync, spawn } = require('child_process');
+const { spawn } = require('child_process');
 
 // Detect Windows platform
 const isWindows = process.platform === 'win32';
 
 /**
- * Checks if a tool is available and returns its version (sync)
- * Uses safe execution methods to avoid shell injection vulnerabilities
- * @param {string} command - Command to check (e.g., 'git', 'node')
- * @param {string} versionFlag - Flag to get version (default: '--version')
- * @returns {Object} { available: boolean, version: string|null }
- */
-function checkTool(command, versionFlag = '--version') {
-  // Validate command contains only safe characters (alphanumeric, underscore, hyphen)
-  if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
-    return { available: false, version: null };
-  }
-  // Validate versionFlag contains only safe characters
-  if (!/^[a-zA-Z0-9_-]+$/.test(versionFlag)) {
-    return { available: false, version: null };
-  }
-
-  try {
-    let output;
-
-    if (isWindows) {
-      // On Windows, use spawnSync with shell to handle .cmd/.bat scripts
-      // Input is validated above so this is safe
-      const result = spawnSync(command, [versionFlag], {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'ignore'],
-        timeout: 5000,
-        windowsHide: true,
-        shell: true
-      });
-      if (result.error || result.status !== 0) {
-        return { available: false, version: null };
-      }
-      output = (result.stdout || '').trim();
-    } else {
-      // On Unix, use execFileSync (more secure, no shell)
-      output = execFileSync(command, [versionFlag], {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'ignore'],
-        timeout: 5000
-      }).trim();
-    }
-
-    // Extract version from first line
-    const version = output.split('\n')[0];
-    return { available: true, version };
-  } catch {
-    return { available: false, version: null };
-  }
-}
-
-/**
- * Checks if a tool is available and returns its version (async)
+ * Checks if a tool is available and returns its version
  * Uses safe execution methods to avoid shell injection vulnerabilities
  * @param {string} command - Command to check (e.g., 'git', 'node')
  * @param {string} versionFlag - Flag to get version (default: '--version')
  * @returns {Promise<Object>} { available: boolean, version: string|null }
  */
-function checkToolAsync(command, versionFlag = '--version') {
+function checkTool(command, versionFlag = '--version') {
   return new Promise((resolve) => {
     // Validate command contains only safe characters (alphanumeric, underscore, hyphen)
     if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
@@ -87,8 +36,7 @@ function checkToolAsync(command, versionFlag = '--version') {
     let child;
 
     if (isWindows) {
-      // On Windows, spawn shell directly with command as single argument to avoid deprecation warning
-      // Input is validated above so this is safe
+      // On Windows, spawn shell directly with command as single argument
       child = spawn('cmd.exe', ['/c', command, versionFlag], {
         stdio: ['pipe', 'pipe', 'ignore'],
         windowsHide: true
@@ -178,29 +126,15 @@ const TOOL_DEFINITIONS = [
 ];
 
 /**
- * Verifies all development tools (sync)
- * @returns {Object} Tool availability map
- */
-function verifyTools() {
-  const result = {};
-  for (const tool of TOOL_DEFINITIONS) {
-    result[tool.name] = checkTool(tool.name, tool.flag);
-  }
-  return result;
-}
-
-/**
- * Verifies all development tools (async, parallel)
- * Runs all tool checks in parallel for ~10x faster execution
+ * Verifies all development tools (parallel execution)
+ * Runs all tool checks in parallel for fast execution
  * @returns {Promise<Object>} Tool availability map
  */
-async function verifyToolsAsync() {
-  // Run all checks in parallel
+async function verifyTools() {
   const results = await Promise.all(
-    TOOL_DEFINITIONS.map(tool => checkToolAsync(tool.name, tool.flag))
+    TOOL_DEFINITIONS.map(tool => checkTool(tool.name, tool.flag))
   );
 
-  // Build result object
   const toolMap = {};
   TOOL_DEFINITIONS.forEach((tool, index) => {
     toolMap[tool.name] = results[index];
@@ -209,11 +143,11 @@ async function verifyToolsAsync() {
   return toolMap;
 }
 
-// When run directly, output JSON (uses async for better performance)
+// When run directly, output JSON
 if (require.main === module) {
   (async () => {
     try {
-      const result = await verifyToolsAsync();
+      const result = await verifyTools();
       console.log(JSON.stringify(result, null, 2));
     } catch (error) {
       console.error(JSON.stringify({
@@ -228,8 +162,6 @@ if (require.main === module) {
 // Export for use as module
 module.exports = {
   verifyTools,
-  verifyToolsAsync,
   checkTool,
-  checkToolAsync,
   TOOL_DEFINITIONS
 };

package/lib/schemas/README.md

@@ -0,0 +1,195 @@
+# JSON Schema Definitions
+
+JSON Schema validation for plugin manifests and configuration files.
+
+## Overview
+
+This directory contains JSON Schema definitions and validators for:
+
+- **Plugin Manifest** (`plugin.json`) - Plugin metadata validation
+- Additional schemas can be added for other JSON config files
+
+## Files
+
+- `plugin-manifest.schema.json` - JSON Schema for plugin.json
+- `validator.js` - Schema validation utility
+- `README.md` - This file
+
+## Usage
+
+### Command Line
+
+Validate a plugin manifest:
+
+```bash
+# Validate default location
+node lib/schemas/validator.js
+
+# Validate specific file
+node lib/schemas/validator.js plugins/next-task/.claude-plugin/plugin.json
+
+# Output on success:
+# ✓ Manifest is valid
+#   Plugin: next-task v2.3.1
+#   Author: Avi Fenesh
+
+# Output on failure:
+# ✗ Manifest is invalid:
+#   - Missing required property: name
+#   - version: does not match pattern
+```
+
+### Programmatic Use
+
+```javascript
+const { validateManifestFile, SchemaValidator } = require('./lib/schemas/validator');
+
+// Validate a manifest file
+const result = validateManifestFile('.claude-plugin/plugin.json');
+if (result.valid) {
+  console.log('Valid!', result.manifest);
+} else {
+  console.error('Errors:', result.errors);
+}
+
+// Validate manifest object directly
+const manifest = {
+  name: "my-plugin",
+  version: "1.0.0",
+  description: "My awesome plugin",
+  author: { name: "John Doe" },
+  license: "MIT"
+};
+
+const validation = SchemaValidator.validatePluginManifest(manifest);
+if (!validation.valid) {
+  console.error(validation.errors);
+}
+```
+
+### Integration in Tests
+
+```javascript
+const { validateManifestFile } = require('./lib/schemas/validator');
+const path = require('path');
+
+describe('Plugin Manifest', () => {
+  it('should be valid', () => {
+    const result = validateManifestFile(
+      path.join(__dirname, '../.claude-plugin/plugin.json')
+    );
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should have required fields', () => {
+    const result = validateManifestFile(
+      path.join(__dirname, '../.claude-plugin/plugin.json')
+    );
+    expect(result.manifest.name).toBeTruthy();
+    expect(result.manifest.version).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+});
+```
+
+## Schema Details
+
+### plugin-manifest.schema.json
+
+Validates `plugin.json` files with the following rules:
+
+**Required fields:**
+- `name` - Kebab-case identifier (e.g., "awesome-slash")
+- `version` - Semantic version (e.g., "1.0.0")
+- `description` - 10-500 characters
+- `author` - Object with `name` field
+- `license` - SPDX identifier (e.g., "MIT")
+
+**Optional fields:**
+- `homepage` - URL to plugin homepage
+- `repository` - URL to source repository
+- `keywords` - Array of search terms (1-20 items)
+- `minClaudeVersion` - Minimum required version
+- `dependencies` - Plugin dependencies
+- `config` - Plugin configuration
+
+**Constraints:**
+- `name` must be lowercase, kebab-case
+- `version` must follow semver (X.Y.Z)
+- `keywords` must be unique, 2-50 chars each
+- `author.email` must be valid email format
+- `author.url` must be valid URI format
+
+### Example Valid Manifest
+
+```json
+{
+  "name": "awesome-slash",
+  "version": "2.4.2",
+  "description": "Professional-grade slash commands for Claude Code",
+  "author": {
+    "name": "Avi Fenesh",
+    "email": "[email protected]",
+    "url": "https://github.com/avifenesh"
+  },
+  "homepage": "https://github.com/avifenesh/awesome-slash",
+  "repository": "https://github.com/avifenesh/awesome-slash",
+  "license": "MIT",
+  "keywords": ["workflow", "automation", "productivity"],
+  "minClaudeVersion": "1.0.0"
+}
+```
+
+## Validation Errors
+
+Common validation errors and fixes:
+
+### "Missing required property: name"
+**Fix:** Add `name` field to plugin.json
+
+### "name: does not match pattern"
+**Fix:** Use lowercase, kebab-case (e.g., "my-plugin" not "MyPlugin")
+
+### "version: does not match pattern"
+**Fix:** Use semantic version format: "1.0.0" not "v1.0" or "1.0"
+
+### "description: string too short"
+**Fix:** Provide description with at least 10 characters
+
+### "Unexpected property: xyz"
+**Fix:** Remove invalid field or update schema if it's a new field
+
+### "keywords: array too long"
+**Fix:** Use maximum 20 keywords
+
+## Adding New Schemas
+
+To add validation for other JSON files:
+
+1. Create `{name}.schema.json` in this directory
+2. Add validator method to `validator.js`:
+   ```javascript
+   static validate{Name}(data) {
+     const schema = this.loadSchema(path.join(__dirname, '{name}.schema.json'));
+     return this.validate(data, schema);
+   }
+   ```
+3. Export validation function
+4. Update this README
+
+## External Tools
+
+For more advanced validation, consider using:
+
+- [ajv](https://ajv.js.org/) - Production-grade JSON Schema validator
+- [json-schema-validator](https://www.jsonschemavalidator.net/) - Online validator
+- [VSCode JSON Schema](https://code.visualstudio.com/docs/languages/json#_json-schemas) - IDE integration
+
+## Related
+
+- **TypeScript Types**: `lib/types/` - TypeScript definitions for same structures
+- **Plugin Manifest Spec**: See `lib/types/README.md` for detailed type documentation
+
+## License
+
+MIT © Avi Fenesh

package/lib/schemas/validator.js

@@ -0,0 +1,247 @@
+/**
+ * JSON Schema Validator
+ * Validates plugin manifests against JSON Schema
+ *
+ * @module lib/schemas/validator
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Simple JSON Schema validator (minimal implementation)
+ * For production use, consider using a library like ajv
+ */
+class SchemaValidator {
+  /**
+   * Load a JSON Schema from file
+   * @param {string} schemaPath - Path to schema file
+   * @returns {Object} Loaded schema
+   */
+  static loadSchema(schemaPath) {
+    const content = fs.readFileSync(schemaPath, 'utf8');
+    return JSON.parse(content);
+  }
+
+  /**
+   * Validate data against a schema
+   * @param {Object} data - Data to validate
+   * @param {Object} schema - JSON Schema
+   * @returns {{valid: boolean, errors: string[]}} Validation result
+   */
+  static validate(data, schema) {
+    const errors = [];
+
+    // Check type (handle arrays correctly and null separately)
+    if (schema.type) {
+      let actualType;
+      if (data === null) {
+        actualType = 'null';
+      } else if (Array.isArray(data)) {
+        actualType = 'array';
+      } else {
+        actualType = typeof data;
+      }
+
+      if (actualType !== schema.type) {
+        errors.push(`Expected type ${schema.type}, got ${actualType}`);
+        return { valid: false, errors };
+      }
+    }
+
+    // String validations (for primitive string values)
+    if (schema.type === 'string' && typeof data === 'string') {
+      if (schema.minLength && data.length < schema.minLength) {
+        errors.push(`String too short (min ${schema.minLength})`);
+      }
+      if (schema.maxLength && data.length > schema.maxLength) {
+        errors.push(`String too long (max ${schema.maxLength})`);
+      }
+      if (schema.pattern && !new RegExp(schema.pattern).test(data)) {
+        errors.push(`String does not match pattern ${schema.pattern}`);
+      }
+    }
+
+    // Array validations (for primitive array values)
+    if (schema.type === 'array' && Array.isArray(data)) {
+      if (schema.minItems && data.length < schema.minItems) {
+        errors.push(`Array too short (min ${schema.minItems})`);
+      }
+      if (schema.maxItems && data.length > schema.maxItems) {
+        errors.push(`Array too long (max ${schema.maxItems})`);
+      }
+      if (schema.uniqueItems) {
+        const seen = new Set();
+        for (const item of data) {
+          const key = JSON.stringify(item);
+          if (seen.has(key)) {
+            errors.push(`Array contains duplicate items`);
+            break;
+          }
+          seen.add(key);
+        }
+      }
+    }
+
+    // Check required properties
+    if (schema.required && Array.isArray(schema.required)) {
+      for (const required of schema.required) {
+        if (!(required in data)) {
+          errors.push(`Missing required property: ${required}`);
+        }
+      }
+    }
+
+    // Check properties (guard against null)
+    if (schema.properties && typeof data === 'object' && data !== null) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (key in data) {
+          const propResult = this.validateProperty(data[key], propSchema, key);
+          errors.push(...propResult.errors);
+        }
+      }
+    }
+
+    // Check additional properties (guard against null, honor patternProperties)
+    if (schema.additionalProperties === false && typeof data === 'object' && data !== null) {
+      const allowedKeys = new Set(Object.keys(schema.properties || {}));
+
+      // Honor patternProperties - don't reject keys that match patterns
+      const patternProps = schema.patternProperties || {};
+      const patternRegexes = Object.keys(patternProps).map(p => new RegExp(p));
+
+      for (const key of Object.keys(data)) {
+        const matchesPattern = patternRegexes.some(regex => regex.test(key));
+        if (!allowedKeys.has(key) && !matchesPattern) {
+          errors.push(`Unexpected property: ${key}`);
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validate a single property
+   * @param {*} value - Property value
+   * @param {Object} schema - Property schema
+   * @param {string} path - Property path for error messages
+   * @returns {{valid: boolean, errors: string[]}} Validation result
+   */
+  static validateProperty(value, schema, path) {
+    const errors = [];
+
+    // Type check
+    if (schema.type) {
+      const actualType = Array.isArray(value) ? 'array' : typeof value;
+      if (actualType !== schema.type) {
+        errors.push(`${path}: expected type ${schema.type}, got ${actualType}`);
+        return { valid: false, errors };
+      }
+    }
+
+    // String validations
+    if (schema.type === 'string' && typeof value === 'string') {
+      if (schema.minLength && value.length < schema.minLength) {
+        errors.push(`${path}: string too short (min ${schema.minLength})`);
+      }
+      if (schema.maxLength && value.length > schema.maxLength) {
+        errors.push(`${path}: string too long (max ${schema.maxLength})`);
+      }
+      if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+        errors.push(`${path}: does not match pattern ${schema.pattern}`);
+      }
+    }
+
+    // Array validations
+    if (schema.type === 'array' && Array.isArray(value)) {
+      if (schema.minItems && value.length < schema.minItems) {
+        errors.push(`${path}: array too short (min ${schema.minItems})`);
+      }
+      if (schema.maxItems && value.length > schema.maxItems) {
+        errors.push(`${path}: array too long (max ${schema.maxItems})`);
+      }
+      if (schema.uniqueItems) {
+        const seen = new Set();
+        for (const item of value) {
+          const key = JSON.stringify(item);
+          if (seen.has(key)) {
+            errors.push(`${path}: duplicate items not allowed`);
+            break;
+          }
+          seen.add(key);
+        }
+      }
+    }
+
+    // Object validations
+    if (schema.type === 'object' && typeof value === 'object' && value !== null) {
+      const result = this.validate(value, schema);
+      for (const error of result.errors) {
+        errors.push(`${path}.${error}`);
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validate a plugin manifest
+   * @param {Object} manifest - Plugin manifest to validate
+   * @returns {{valid: boolean, errors: string[]}} Validation result
+   */
+  static validatePluginManifest(manifest) {
+    const schemaPath = path.join(__dirname, 'plugin-manifest.schema.json');
+    const schema = this.loadSchema(schemaPath);
+    return this.validate(manifest, schema);
+  }
+}
+
+/**
+ * Validate a plugin manifest file
+ * @param {string} manifestPath - Path to plugin.json
+ * @returns {{valid: boolean, errors: string[], manifest?: Object}} Validation result
+ */
+function validateManifestFile(manifestPath) {
+  try {
+    const content = fs.readFileSync(manifestPath, 'utf8');
+    const manifest = JSON.parse(content);
+    const result = SchemaValidator.validatePluginManifest(manifest);
+    return { ...result, manifest };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [`Failed to load manifest: ${error.message}`]
+    };
+  }
+}
+
+module.exports = {
+  SchemaValidator,
+  validateManifestFile
+};
+
+// CLI usage
+if (require.main === module) {
+  const manifestPath = process.argv[2] || '.claude-plugin/plugin.json';
+
+  console.log(`Validating: ${manifestPath}`);
+  const result = validateManifestFile(manifestPath);
+
+  if (result.valid) {
+    console.log('✓ Manifest is valid');
+    if (result.manifest) {
+      console.log(`  Plugin: ${result.manifest.name} v${result.manifest.version}`);
+      console.log(`  Author: ${result.manifest.author.name}`);
+    }
+    process.exit(0);
+  } else {
+    console.error('✗ Manifest is invalid:');
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+}