awesome-slash 2.4.4 → 2.5.1

package/plugins/project-review/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/plugins/project-review/lib/platform/state-dir.js

@@ -0,0 +1,122 @@
+/**
+ * Platform-aware state directory detection
+ *
+ * Determines the appropriate state directory based on the AI coding assistant
+ * being used (Claude Code, OpenCode, or Codex CLI).
+ *
+ * @module lib/platform/state-dir
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Cached state directory name (relative, without leading dot handling)
+ * @type {string|null}
+ */
+let _cachedStateDir = null;
+
+/**
+ * Detect which AI coding assistant is running and return appropriate state directory
+ *
+ * Detection order:
+ * 1. AI_STATE_DIR env var (user override)
+ * 2. OpenCode detection (OPENCODE_CONFIG env or .opencode/ exists)
+ * 3. Codex detection (CODEX_HOME env or .codex/ exists)
+ * 4. Default to .claude (Claude Code or unknown)
+ *
+ * @param {string} [basePath=process.cwd()] - Base path to check for project directories
+ * @returns {string} State directory name (e.g., '.claude', '.opencode', '.codex')
+ */
+function getStateDir(basePath = process.cwd()) {
+  // Check user override first
+  if (process.env.AI_STATE_DIR) {
+    return process.env.AI_STATE_DIR;
+  }
+
+  // Return cached value if available
+  if (_cachedStateDir) {
+    return _cachedStateDir;
+  }
+
+  // OpenCode detection
+  if (process.env.OPENCODE_CONFIG || process.env.OPENCODE_CONFIG_DIR) {
+    _cachedStateDir = '.opencode';
+    return _cachedStateDir;
+  }
+
+  // Check for .opencode directory in project
+  try {
+    const opencodePath = path.join(basePath, '.opencode');
+    if (fs.existsSync(opencodePath) && fs.statSync(opencodePath).isDirectory()) {
+      _cachedStateDir = '.opencode';
+      return _cachedStateDir;
+    }
+  } catch {
+    // Ignore errors, continue detection
+  }
+
+  // Codex detection
+  if (process.env.CODEX_HOME) {
+    _cachedStateDir = '.codex';
+    return _cachedStateDir;
+  }
+
+  // Check for .codex directory in project
+  try {
+    const codexPath = path.join(basePath, '.codex');
+    if (fs.existsSync(codexPath) && fs.statSync(codexPath).isDirectory()) {
+      _cachedStateDir = '.codex';
+      return _cachedStateDir;
+    }
+  } catch {
+    // Ignore errors, continue detection
+  }
+
+  // Default to Claude Code
+  _cachedStateDir = '.claude';
+  return _cachedStateDir;
+}
+
+/**
+ * Get the full path to the state directory
+ * @param {string} [basePath=process.cwd()] - Base path
+ * @returns {string} Full path to state directory
+ */
+function getStateDirPath(basePath = process.cwd()) {
+  return path.join(basePath, getStateDir(basePath));
+}
+
+/**
+ * Get the detected platform name
+ * @param {string} [basePath=process.cwd()] - Base path
+ * @returns {string} Platform name ('claude', 'opencode', 'codex', or 'custom')
+ */
+function getPlatformName(basePath = process.cwd()) {
+  const stateDir = getStateDir(basePath);
+
+  if (process.env.AI_STATE_DIR) {
+    return 'custom';
+  }
+
+  switch (stateDir) {
+    case '.opencode': return 'opencode';
+    case '.codex': return 'codex';
+    case '.claude': return 'claude';
+    default: return 'unknown';
+  }
+}
+
+/**
+ * Clear the cached state directory (useful for testing)
+ */
+function clearCache() {
+  _cachedStateDir = null;
+}
+
+module.exports = {
+  getStateDir,
+  getStateDirPath,
+  getPlatformName,
+  clearCache
+};

package/plugins/project-review/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/plugins/project-review/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