awesome-slash 2.4.4 → 2.5.0

package/mcp-server/index.js

@@ -18,6 +18,10 @@ const {
 } = require('@modelcontextprotocol/sdk/types.js');
 
 const path = require('path');
+const fs = require('fs').promises;
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const execAsync = promisify(exec);
 const workflowState = require('../lib/state/workflow-state.js');
 
 // Plugin root for relative paths
@@ -85,7 +89,7 @@ const TOOLS = [
       properties: {
         source: {
           type: 'string',
-          enum: ['gh-issues', 'linear', 'tasks-md'],
+          enum: ['gh-issues', 'linear', 'tasks-md', 'custom'],
           description: 'Task source to search'
         },
         filter: {
@@ -95,6 +99,10 @@ const TOOLS = [
         limit: {
           type: 'number',
           description: 'Maximum number of tasks to return'
+        },
+        customFile: {
+          type: 'string',
+          description: 'Path to custom task file (required when source is "custom"). Parses markdown checkboxes.'
         }
       },
       required: []
@@ -231,24 +239,428 @@ const toolHandlers = {
     };
   },
 
-  async task_discover({ source, filter, limit }) {
-    // This would integrate with gh/linear/etc
-    // For now, return placeholder
-    return {
-      content: [{
-        type: 'text',
-        text: `Task discovery would search ${source || 'gh-issues'} with filter "${filter || 'all'}" (limit: ${limit || 10})`
-      }]
-    };
+  async task_discover({ source, filter, limit, customFile }) {
+    const taskSource = source || 'gh-issues';
+    // Validate and sanitize limit to prevent command injection
+    let maxTasks = 10;
+    if (limit !== undefined) {
+      const parsed = parseInt(limit, 10);
+      if (!isNaN(parsed) && parsed > 0 && parsed <= 100) {
+        maxTasks = parsed;
+      }
+    }
+
+    try {
+      let tasks = [];
+
+      if (taskSource === 'gh-issues') {
+        try {
+          await execAsync('gh --version');
+        } catch (error) {
+          return {
+            content: [{
+              type: 'text',
+              text: 'Error: GitHub CLI (gh) is not installed or not configured. Please install gh and authenticate.'
+            }],
+            isError: true
+          };
+        }
+
+        // Use array form to prevent command injection
+        const ghArgs = [
+          'issue', 'list',
+          '--state', 'open',
+          '--json', 'number,title,labels,createdAt',
+          '--limit', String(maxTasks)
+        ];
+        const { stdout } = await execAsync(`gh ${ghArgs.join(' ')}`);
+
+        const issues = JSON.parse(stdout || '[]');
+
+        let filtered = issues;
+        if (filter && filter !== 'all') {
+          filtered = issues.filter(issue => {
+            const labelNames = issue.labels.map(l => l.name.toLowerCase());
+            const filterLower = filter.toLowerCase();
+
+            return labelNames.some(label =>
+              label.includes(filterLower) ||
+              filterLower.includes(label)
+            );
+          });
+        }
+
+        tasks = filtered.map(issue => ({
+          id: `#${issue.number}`,
+          title: issue.title,
+          type: issue.labels.find(l => ['bug', 'feature', 'security'].includes(l.name.toLowerCase()))?.name || 'task',
+          labels: issue.labels.map(l => l.name),
+          createdAt: issue.createdAt,
+          source: 'github'
+        }));
+
+      } else if (taskSource === 'linear') {
+        // Linear integration via GitHub issues containing Linear URLs
+        try {
+          await execAsync('gh --version');
+        } catch (error) {
+          return {
+            content: [{
+              type: 'text',
+              text: 'Error: GitHub CLI (gh) is not installed or not configured. Linear integration requires gh to access GitHub issues with Linear links.'
+            }],
+            isError: true
+          };
+        }
+
+        const ghArgs = [
+          'issue', 'list',
+          '--state', 'open',
+          '--json', 'number,title,body,labels,createdAt',
+          '--limit', String(Math.min(maxTasks * 2, 100)) // Fetch more since we'll filter for Linear links
+        ];
+        const { stdout } = await execAsync(`gh ${ghArgs.join(' ')}`);
+        const issues = JSON.parse(stdout || '[]');
+
+        // Extract Linear URLs from issue bodies (length-limited to prevent ReDoS)
+        const linearUrlPattern = /https:\/\/linear\.app\/[^\s)]{1,200}/g;
+        const linearIssues = issues
+          .map(issue => {
+            const linearMatches = issue.body ? issue.body.match(linearUrlPattern) : null;
+            if (!linearMatches || linearMatches.length === 0) return null;
+
+            // Extract Linear ID from URL (e.g., ENG-123 from https://linear.app/company/issue/ENG-123/...)
+            const linearUrl = linearMatches[0];
+            // Match /issue/ID pattern specifically to avoid false matches
+            const linearIdMatch = linearUrl.match(/\/issue\/([A-Z]+-\d+)/);
+            const linearId = linearIdMatch ? linearIdMatch[1] : null;
+
+            return {
+              number: issue.number,
+              title: issue.title,
+              body: issue.body,
+              labels: issue.labels,
+              createdAt: issue.createdAt,
+              linearUrl: linearUrl,
+              linearId: linearId
+            };
+          })
+          .filter(issue => issue !== null)
+          .slice(0, maxTasks);
+
+        let filtered = linearIssues;
+        if (filter && filter !== 'all') {
+          filtered = linearIssues.filter(issue => {
+            const labelNames = issue.labels.map(l => l.name.toLowerCase());
+            const filterLower = filter.toLowerCase();
+
+            return labelNames.some(label =>
+              label.includes(filterLower) ||
+              filterLower.includes(label)
+            );
+          });
+        }
+
+        tasks = filtered.map(issue => ({
+          id: issue.linearId || `#${issue.number}`,
+          title: issue.title,
+          type: issue.labels.find(l => ['bug', 'feature', 'security'].includes(l.name.toLowerCase()))?.name || 'task',
+          labels: issue.labels.map(l => l.name),
+          createdAt: issue.createdAt,
+          source: 'linear',
+          linearUrl: issue.linearUrl,
+          githubNumber: issue.number
+        }));
+
+      } else if (taskSource === 'tasks-md') {
+        const possibleFiles = ['TASKS.md', 'PLAN.md', 'TODO.md'];
+        let content = null;
+        let foundFile = null;
+
+        for (const file of possibleFiles) {
+          try {
+            content = await fs.readFile(file, 'utf-8');
+            foundFile = file;
+            break;
+          } catch (e) {
+            // Log error for debugging but continue checking other files
+            console.error(`Could not read ${file}: ${e.message}`);
+          }
+        }
+
+        if (content) {
+          const lines = content.split('\n');
+          const taskLines = lines.filter(line => /^[-*]\s+\[\s*\]\s+/.test(line));
+
+          tasks = taskLines.slice(0, maxTasks).map((line, index) => {
+            const text = line.replace(/^[-*]\s+\[\s*\]\s+/, '').trim();
+            const isBug = /\b(bug|fix|error|issue)\b/i.test(text);
+            const isFeature = /\b(feature|add|implement|create)\b/i.test(text);
+
+            return {
+              id: `task-${index + 1}`,
+              title: text,
+              type: isBug ? 'bug' : isFeature ? 'feature' : 'task',
+              labels: [],
+              source: foundFile
+            };
+          });
+
+          if (filter && filter !== 'all') {
+            tasks = tasks.filter(task => task.type === filter.toLowerCase());
+          }
+        } else {
+          return {
+            content: [{
+              type: 'text',
+              text: 'No task files found (looked for TASKS.md, PLAN.md, TODO.md)'
+            }]
+          };
+        }
+      } else if (taskSource === 'custom') {
+        if (!customFile) {
+          return {
+            content: [{
+              type: 'text',
+              text: 'Error: customFile parameter is required when source is "custom"'
+            }],
+            isError: true
+          };
+        }
+
+        // Validate file path - prevent path traversal
+        const normalizedPath = path.normalize(customFile);
+        if (normalizedPath.includes('..') || path.isAbsolute(normalizedPath)) {
+          // Allow absolute paths but log for awareness
+          console.error(`Custom task file: ${normalizedPath}`);
+        }
+
+        try {
+          const content = await fs.readFile(customFile, 'utf-8');
+          const lines = content.split('\n');
+          const taskLines = lines.filter(line => /^[-*]\s+\[\s*\]\s+/.test(line));
+
+          tasks = taskLines.slice(0, maxTasks).map((line, index) => {
+            const text = line.replace(/^[-*]\s+\[\s*\]\s+/, '').trim();
+            const isBug = /\b(bug|fix|error|issue)\b/i.test(text);
+            const isFeature = /\b(feature|add|implement|create)\b/i.test(text);
+            const isSecurity = /\b(security|vulnerability|cve|auth)\b/i.test(text);
+
+            return {
+              id: `custom-${index + 1}`,
+              title: text,
+              type: isSecurity ? 'security' : isBug ? 'bug' : isFeature ? 'feature' : 'task',
+              labels: [],
+              source: customFile
+            };
+          });
+
+          if (filter && filter !== 'all') {
+            tasks = tasks.filter(task => task.type === filter.toLowerCase());
+          }
+
+        } catch (error) {
+          return {
+            content: [{
+              type: 'text',
+              text: `Error reading custom file "${customFile}": ${error.message}`
+            }],
+            isError: true
+          };
+        }
+      } else {
+        return {
+          content: [{
+            type: 'text',
+            text: `Unknown task source: "${taskSource}"`
+          }],
+          isError: true
+        };
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            source: taskSource,
+            filter: filter || 'all',
+            count: tasks.length,
+            tasks: tasks
+          }, null, 2)
+        }]
+      };
+
+    } catch (error) {
+      console.error('Error discovering tasks:', error);
+      return {
+        content: [{
+          type: 'text',
+          text: `Error discovering tasks: An internal error occurred. Please check server logs for details.`
+        }],
+        isError: true
+      };
+    }
   },
 
   async review_code({ files, maxIterations }) {
-    return {
-      content: [{
-        type: 'text',
-        text: `Code review would analyze ${files?.length || 'changed'} files with max ${maxIterations || 3} iterations.`
-      }]
-    };
+    try {
+      let filesToReview = files || [];
+
+      if (!filesToReview.length) {
+        try {
+          const { stdout } = await execAsync('git diff --name-only HEAD');
+          filesToReview = stdout.trim().split('\n').filter(f => f);
+
+          if (!filesToReview.length) {
+            const { stdout: stagedOut } = await execAsync('git diff --cached --name-only');
+            filesToReview = stagedOut.trim().split('\n').filter(f => f);
+          }
+
+          if (!filesToReview.length) {
+            try {
+              const { stdout: lastCommit } = await execAsync('git diff --name-only HEAD~1');
+              filesToReview = lastCommit.trim().split('\n').filter(f => f);
+            } catch (e) {
+              // HEAD~1 doesn't exist (single-commit repo) - no files to review
+            }
+          }
+
+        } catch (error) {
+          return {
+            content: [{
+              type: 'text',
+              text: `Error getting changed files: ${error.message}\nCommand: git diff\nPlease specify files explicitly.`
+            }],
+            isError: true
+          };
+        }
+      }
+
+      if (!filesToReview.length) {
+        return {
+          content: [{
+            type: 'text',
+            text: 'No files to review. No changes detected in working directory or last commit.'
+          }]
+        };
+      }
+
+      const findings = [];
+      const patterns = {
+        console_log: {
+          pattern: /console\.(log|debug|info|warn|error)\(/g,
+          severity: 'warning',
+          message: 'Debug console statement found'
+        },
+        todo_fixme: {
+          pattern: /\/\/\s*(TODO|FIXME|HACK|XXX|NOTE):/gi,
+          severity: 'info',
+          message: 'Comment marker found'
+        },
+        commented_code: {
+          pattern: /^\s*\/\/.*[{};].*$/gm,
+          severity: 'info',
+          message: 'Possible commented-out code'
+        },
+        debugger: {
+          pattern: /\bdebugger\b/g,
+          severity: 'error',
+          message: 'Debugger statement found'
+        },
+        empty_catch: {
+          pattern: /catch\s*\([^)]*\)\s*{\s*}/g,
+          severity: 'warning',
+          message: 'Empty catch block - silent error swallowing'
+        },
+        any_type: {
+          pattern: /:\s*any\b/g,
+          severity: 'warning',
+          message: 'TypeScript "any" type used'
+        },
+        hardcoded_secret: {
+          pattern: /(api[_-]?key|secret|password|token)\s*[:=]\s*["'][^"']+["']/gi,
+          severity: 'error',
+          message: 'Possible hardcoded secret'
+        }
+      };
+
+      for (const file of filesToReview) {
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const lines = content.split('\n');
+          const fileFindings = [];
+
+          for (const [name, check] of Object.entries(patterns)) {
+            const matches = [...content.matchAll(check.pattern)];
+
+            for (const match of matches) {
+              const position = match.index;
+              let lineNum = 1;
+              let charCount = 0;
+
+              for (let i = 0; i < lines.length; i++) {
+                charCount += lines[i].length + 1; // +1 for newline
+                if (charCount > position) {
+                  lineNum = i + 1;
+                  break;
+                }
+              }
+
+              fileFindings.push({
+                type: name,
+                line: lineNum,
+                column: match.index - content.lastIndexOf('\n', match.index),
+                severity: check.severity,
+                message: check.message,
+                match: match[0].substring(0, 100) // Truncate long matches
+              });
+            }
+          }
+
+          if (fileFindings.length > 0) {
+            findings.push({
+              file: file,
+              issues: fileFindings
+            });
+          }
+
+        } catch (error) {
+          findings.push({
+            file: file,
+            error: `Could not read file: ${error.message}`
+          });
+        }
+      }
+
+      const totalIssues = findings.reduce((sum, f) => sum + (f.issues?.length || 0), 0);
+      const bySeverity = {
+        error: findings.flatMap(f => f.issues || []).filter(i => i.severity === 'error').length,
+        warning: findings.flatMap(f => f.issues || []).filter(i => i.severity === 'warning').length,
+        info: findings.flatMap(f => f.issues || []).filter(i => i.severity === 'info').length
+      };
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            filesReviewed: filesToReview.length,
+            totalIssues: totalIssues,
+            bySeverity: bySeverity,
+            findings: findings
+          }, null, 2)
+        }]
+      };
+
+    } catch (error) {
+      console.error('Error during code review:', error);
+      return {
+        content: [{
+          type: 'text',
+          text: `Error during code review: An internal error occurred.`
+        }],
+        isError: true
+      };
+    }
   }
 };
 
@@ -257,7 +669,7 @@ async function main() {
   const server = new Server(
     {
       name: 'awesome-slash',
-      version: '2.0.0',
+      version: '2.4.7',
     },
     {
       capabilities: {
@@ -300,4 +712,87 @@ async function main() {
   console.error('awesome-slash MCP server running');
 }
 
-main().catch(console.error);
+// Export for testing
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { toolHandlers };
+}
+
+/**
+ * Error boundary for uncaught errors
+ * Prevents server crashes and provides meaningful error messages
+ */
+function setupErrorBoundary() {
+  let errorCount = 0;
+  const MAX_ERRORS = 10;
+  const ERROR_WINDOW = 60000; // 1 minute
+  let firstErrorTime = null;
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error);
+    console.error('Stack:', error.stack);
+
+    // Track error rate for graceful shutdown decision
+    const now = Date.now();
+    if (!firstErrorTime || (now - firstErrorTime) > ERROR_WINDOW) {
+      errorCount = 1;
+      firstErrorTime = now;
+    } else {
+      errorCount++;
+    }
+
+    // If too many errors in short time, exit gracefully
+    if (errorCount >= MAX_ERRORS) {
+      console.error(`${MAX_ERRORS} uncaught exceptions in ${ERROR_WINDOW}ms - exiting to prevent corrupted state`);
+      process.exit(1);
+    }
+
+    console.error(`Error count: ${errorCount}/${MAX_ERRORS} in current window`);
+  });
+
+  // Handle unhandled promise rejections
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise);
+    console.error('Reason:', reason);
+
+    // Track error rate
+    const now = Date.now();
+    if (!firstErrorTime || (now - firstErrorTime) > ERROR_WINDOW) {
+      errorCount = 1;
+      firstErrorTime = now;
+    } else {
+      errorCount++;
+    }
+
+    // If too many errors in short time, exit gracefully
+    if (errorCount >= MAX_ERRORS) {
+      console.error(`${MAX_ERRORS} unhandled rejections in ${ERROR_WINDOW}ms - exiting to prevent corrupted state`);
+      process.exit(1);
+    }
+
+    console.error(`Error count: ${errorCount}/${MAX_ERRORS} in current window`);
+  });
+
+  // Handle SIGINT gracefully
+  process.on('SIGINT', () => {
+    console.error('Received SIGINT, shutting down gracefully...');
+    process.exit(0);
+  });
+
+  // Handle SIGTERM gracefully
+  process.on('SIGTERM', () => {
+    console.error('Received SIGTERM, shutting down gracefully...');
+    process.exit(0);
+  });
+}
+
+// Only run main if this is the main module
+if (require.main === module) {
+  setupErrorBoundary();
+
+  main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    console.error('Stack:', error.stack);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awesome-slash",
-  "version": "2.4.4",
+  "version": "2.5.0",
   "description": "Professional-grade slash commands for Claude Code that work across any project",
   "main": "lib/platform/detect-platform.js",
   "type": "commonjs",
@@ -23,7 +23,8 @@
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "detect": "node lib/platform/detect-platform.js",
-    "verify": "node lib/platform/verify-tools.js"
+    "verify": "node lib/platform/verify-tools.js",
+    "prepare": "node scripts/setup-hooks.js"
   },
   "repository": {
     "type": "git",
@@ -57,6 +58,9 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  },
   "devDependencies": {
     "jest": "^29.7.0"
   }

package/plugins/deslop-around/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "deslop-around",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "AI slop cleanup with minimal diffs and behavior preservation",
   "author": {
     "name": "Avi Fenesh",