awesome-slash 2.5.0 → 2.5.1

package/plugins/next-task/lib/platform/verify-tools.js

@@ -10,75 +10,19 @@
  * @license MIT
  */
 
-const { execFileSync, spawnSync, spawn } = require('child_process');
+const { spawn } = require('child_process');
 
 // Detect Windows platform
 const isWindows = process.platform === 'win32';
 
-// Import shared deprecation utilities
-const { warnDeprecation, _resetDeprecationWarnings } = require('../utils/deprecation');
-
 /**
- * Checks if a tool is available and returns its version (sync)
- * Uses safe execution methods to avoid shell injection vulnerabilities
- * @deprecated Use checkToolAsync() instead. Will be removed in v3.0.0.
- * @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') {
-  warnDeprecation('checkTool', 'checkToolAsync');
-  // 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)) {
@@ -92,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
@@ -183,31 +126,15 @@ const TOOL_DEFINITIONS = [
 ];
 
 /**
- * Verifies all development tools (sync)
- * @deprecated Use verifyToolsAsync() instead. Will be removed in v3.0.0.
- * @returns {Object} Tool availability map
- */
-function verifyTools() {
-  warnDeprecation('verifyTools', 'verifyToolsAsync');
-  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];
@@ -216,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({
@@ -235,10 +162,6 @@ if (require.main === module) {
 // Export for use as module
 module.exports = {
   verifyTools,
-  verifyToolsAsync,
   checkTool,
-  checkToolAsync,
-  TOOL_DEFINITIONS,
-  // Testing utilities (prefixed with _ to indicate internal use)
-  _resetDeprecationWarnings
+  TOOL_DEFINITIONS
 };

package/plugins/next-task/lib/schemas/validator.js

@@ -34,15 +34,57 @@ class SchemaValidator {
   static validate(data, schema) {
     const errors = [];
 
-    // Check type (handle arrays correctly)
+    // Check type (handle arrays correctly and null separately)
     if (schema.type) {
-      const actualType = Array.isArray(data) ? 'array' : typeof data;
+      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) {

package/plugins/next-task/lib/sources/source-cache.js

@@ -2,15 +2,28 @@
  * Source Cache
  * File-based persistence for task source preferences
  *
+ * State directory is platform-aware:
+ * - Claude Code: .claude/sources/
+ * - OpenCode: .opencode/sources/
+ * - Codex CLI: .codex/sources/
+ *
  * @module lib/sources/source-cache
  */
 
 const fs = require('fs');
 const path = require('path');
+const { getStateDir } = require('../platform/state-dir');
 
-const SOURCES_DIR = '.claude/sources';
 const PREFERENCE_FILE = 'preference.json';
 
+/**
+ * Get the sources directory path (platform-aware)
+ * @returns {string} Path to sources directory
+ */
+function getSourcesDir() {
+  return path.join(getStateDir(), 'sources');
+}
+
 /**
  * Validate tool name to prevent path traversal
  * @param {string} toolName - Tool name to validate
@@ -26,10 +39,11 @@ function isValidToolName(toolName) {
  * @returns {string} Path to sources directory
  */
 function ensureDir() {
-  if (!fs.existsSync(SOURCES_DIR)) {
-    fs.mkdirSync(SOURCES_DIR, { recursive: true });
+  const sourcesDir = getSourcesDir();
+  if (!fs.existsSync(sourcesDir)) {
+    fs.mkdirSync(sourcesDir, { recursive: true });
   }
-  return SOURCES_DIR;
+  return sourcesDir;
 }
 
 /**
@@ -40,7 +54,7 @@ function ensureDir() {
  * // Or: { source: 'custom', type: 'cli', tool: 'tea' }
  */
 function getPreference() {
-  const filePath = path.join(SOURCES_DIR, PREFERENCE_FILE);
+  const filePath = path.join(getSourcesDir(), PREFERENCE_FILE);
   if (!fs.existsSync(filePath)) {
     return null;
   }
@@ -62,7 +76,7 @@ function getPreference() {
  */
 function savePreference(preference) {
   ensureDir();
-  const filePath = path.join(SOURCES_DIR, PREFERENCE_FILE);
+  const filePath = path.join(getSourcesDir(), PREFERENCE_FILE);
   fs.writeFileSync(filePath, JSON.stringify({
     ...preference,
     savedAt: new Date().toISOString()
@@ -80,7 +94,7 @@ function getToolCapabilities(toolName) {
     console.error(`Invalid tool name: ${toolName}`);
     return null;
   }
-  const filePath = path.join(SOURCES_DIR, `${toolName}.json`);
+  const filePath = path.join(getSourcesDir(), `${toolName}.json`);
   if (!fs.existsSync(filePath)) {
     return null;
   }
@@ -106,7 +120,7 @@ function saveToolCapabilities(toolName, capabilities) {
     return;
   }
   ensureDir();
-  const filePath = path.join(SOURCES_DIR, `${toolName}.json`);
+  const filePath = path.join(getSourcesDir(), `${toolName}.json`);
   fs.writeFileSync(filePath, JSON.stringify({
     ...capabilities,
     discoveredAt: new Date().toISOString()
@@ -117,10 +131,11 @@ function saveToolCapabilities(toolName, capabilities) {
  * Clear all cached preferences
  */
 function clearCache() {
-  if (fs.existsSync(SOURCES_DIR)) {
-    const files = fs.readdirSync(SOURCES_DIR);
+  const sourcesDir = getSourcesDir();
+  if (fs.existsSync(sourcesDir)) {
+    const files = fs.readdirSync(sourcesDir);
     for (const file of files) {
-      const filePath = path.join(SOURCES_DIR, file);
+      const filePath = path.join(sourcesDir, file);
       const stats = fs.statSync(filePath);
       if (stats.isFile()) {
         fs.unlinkSync(filePath);

package/plugins/next-task/lib/state/workflow-state.js

@@ -2,16 +2,21 @@
  * Simplified workflow state management
  *
  * Two files:
- * - Main project: .claude/tasks.json (tracks active worktree/task)
- * - Worktree: .claude/flow.json (tracks workflow progress)
+ * - Main project: {stateDir}/tasks.json (tracks active worktree/task)
+ * - Worktree: {stateDir}/flow.json (tracks workflow progress)
+ *
+ * State directory is platform-aware:
+ * - Claude Code: .claude/
+ * - OpenCode: .opencode/
+ * - Codex CLI: .codex/
  */
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const { getStateDir } = require('../platform/state-dir');
 
 // File paths
-const CLAUDE_DIR = '.claude';
 const TASKS_FILE = 'tasks.json';
 const FLOW_FILE = 'flow.json';
 
@@ -74,14 +79,14 @@ const PHASES = [
 ];
 
 /**
- * Ensure .claude directory exists
+ * Ensure state directory exists (platform-aware)
  */
-function ensureClaudeDir(basePath) {
-  const claudeDir = path.join(basePath, CLAUDE_DIR);
-  if (!fs.existsSync(claudeDir)) {
-    fs.mkdirSync(claudeDir, { recursive: true });
+function ensureStateDir(basePath) {
+  const stateDir = path.join(basePath, getStateDir(basePath));
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
   }
-  return claudeDir;
+  return stateDir;
 }
 
 // =============================================================================
@@ -93,7 +98,7 @@ function ensureClaudeDir(basePath) {
  */
 function getTasksPath(projectPath = process.cwd()) {
   const validatedBase = validatePath(projectPath);
-  const tasksPath = path.join(validatedBase, CLAUDE_DIR, TASKS_FILE);
+  const tasksPath = path.join(validatedBase, getStateDir(projectPath), TASKS_FILE);
   validatePathWithinBase(tasksPath, validatedBase);
   return tasksPath;
 }
@@ -125,7 +130,7 @@ function readTasks(projectPath = process.cwd()) {
  * Write tasks.json to main project
  */
 function writeTasks(tasks, projectPath = process.cwd()) {
-  ensureClaudeDir(projectPath);
+  ensureStateDir(projectPath);
   const tasksPath = getTasksPath(projectPath);
   fs.writeFileSync(tasksPath, JSON.stringify(tasks, null, 2), 'utf8');
   return true;
@@ -170,7 +175,7 @@ function hasActiveTask(projectPath = process.cwd()) {
  */
 function getFlowPath(worktreePath = process.cwd()) {
   const validatedBase = validatePath(worktreePath);
-  const flowPath = path.join(validatedBase, CLAUDE_DIR, FLOW_FILE);
+  const flowPath = path.join(validatedBase, getStateDir(worktreePath), FLOW_FILE);
   validatePathWithinBase(flowPath, validatedBase);
   return flowPath;
 }
@@ -198,7 +203,7 @@ function readFlow(worktreePath = process.cwd()) {
  * Creates a copy to avoid mutating the original object
  */
 function writeFlow(flow, worktreePath = process.cwd()) {
-  ensureClaudeDir(worktreePath);
+  ensureStateDir(worktreePath);
   // Clone to avoid mutating the original object
   const flowCopy = JSON.parse(JSON.stringify(flow));
   flowCopy.lastUpdate = new Date().toISOString();

package/plugins/project-review/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "project-review",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "Multi-agent iterative code review until zero issues remain",
   "author": {
     "name": "Avi Fenesh",

package/plugins/project-review/lib/patterns/slop-patterns.js

@@ -644,9 +644,8 @@ function isFileExcluded(filePath, excludePatterns) {
   const cacheKey = JSON.stringify([filePath, excludePatterns]);
 
   // Check cache first (O(1) lookup)
-  if (_excludeResultCache.has(cacheKey)) {
-    return _excludeResultCache.get(cacheKey);
-  }
+  const cached = _excludeResultCache.get(cacheKey);
+  if (cached !== undefined) return cached;
 
   // Compute result
   const result = excludePatterns.some(pattern => {