awesome-slash 2.8.3 → 2.9.1

package/.claude-plugin/marketplace.json

@@ -1,7 +1,7 @@
 {
   "name": "awesome-slash",
   "description": "Professional-grade slash commands for Claude Code with cross-platform support (OpenCode, Codex CLI)",
-  "version": "2.8.3",
+  "version": "2.9.1",
   "owner": {
     "name": "Avi Fenesh",
     "url": "https://github.com/avifenesh"
@@ -13,42 +13,42 @@
       "name": "next-task",
       "source": "./plugins/next-task",
       "description": "Master workflow orchestrator: autonomous workflow with model optimization (opus/sonnet/haiku), two-file state management, workflow enforcement gates, 14 specialist agents",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "productivity"
     },
     {
       "name": "ship",
       "source": "./plugins/ship",
       "description": "Complete PR workflow: commit to production, skips review when called from next-task, removes task from registry on cleanup, automatic rollback",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "deployment"
     },
     {
       "name": "deslop-around",
       "source": "./plugins/deslop-around",
       "description": "3-phase AI slop detection: regex patterns (HIGH), multi-pass analyzers (MEDIUM), CLI tools (LOW)",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "development"
     },
     {
       "name": "project-review",
       "source": "./plugins/project-review",
       "description": "Multi-agent iterative code review until zero issues remain",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "development"
     },
     {
       "name": "reality-check",
       "source": "./plugins/reality-check",
       "description": "Deep repository analysis to realign project plans with code reality - detects drift, gaps, and creates prioritized reconstruction plans",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "productivity"
     },
     {
       "name": "enhance",
       "source": "./plugins/enhance",
       "description": "Master enhancement orchestrator: parallel analyzer execution for plugins, agents, docs, CLAUDE.md, and prompts with unified reporting",
-      "version": "2.8.3",
+      "version": "2.9.1",
       "category": "development"
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,7 +1,16 @@
 {
   "name": "awesome-slash",
-  "version": "2.8.3",
+  "version": "2.9.1",
   "description": "Professional-grade slash commands for Claude Code with cross-platform support",
+  "keywords": [
+    "workflow",
+    "automation",
+    "code-review",
+    "ci-cd",
+    "deployment",
+    "slop-detection",
+    "task-management"
+  ],
   "author": {
     "name": "Avi Fenesh",
     "url": "https://github.com/avifenesh"

package/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.1] - 2025-01-23
+
+### Changed
+- **deslop-around skill** - Refactored to follow skill best practices
+  - Added `scripts/detect.js` CLI runner to invoke pipeline (instead of describing logic for LLM)
+  - Added `references/slop-categories.md` for progressive disclosure
+  - Moved constraints to top with explicit priority order (addresses "lost-in-the-middle")
+  - Added `<output_format>` XML tags for explicit output specification
+  - Reduced skill from 240 lines to 165 lines (~31% smaller)
+
+## [2.9.0] - 2025-01-23
+
+### Added
+- **Gitignore Support** - File scanning now respects `.gitignore` patterns
+  - New `parseGitignore()` function parses gitignore files and creates matcher
+  - `countSourceFiles()` respects gitignore by default (disable with `respectGitignore: false`)
+  - Supports all standard patterns: globs, directories, negation, globstar (`**`), anchored
+
+- **Multi-Language Stub Detection** - New multi-pass analyzer replaces regex-based detection
+  - Python: `return None`, `pass`, `...`, `raise NotImplementedError`
+  - Rust: `todo!()`, `unimplemented!()`, `panic!()`, `None`, `Vec::new()`
+  - Java: `return null`, `throw UnsupportedOperationException`, `Collections.emptyList()`
+  - Go: `return nil`, `panic()`, empty returns, typed slice/map literals
+  - 95% reduction in false positives compared to previous regex patterns
+
+- **Java Dead Code Support** - Extended `analyzeDeadCode` to detect unreachable code in Java
+  - Supports Java-specific patterns: `throw`, `return`, `break`, `continue`
+  - Respects Java block structures (try/catch/finally, switch/case)
+
+### Fixed
+- **Function Name Extraction** - Fixed bug where `export` and `async` keywords were captured as function names instead of actual function names in doc/code ratio analyzer
+- **TypeScript Language Matching** - Added fallback to ensure TypeScript files match JavaScript patterns
+- **Stub Pattern Exclude Globs** - Pattern exclude globs now properly honored in stub detection
+- **Multi-line Statement Detection** - Improved bracket balance tracking for all bracket types
+- **minConsecutiveLines Enforcement** - Block patterns now correctly require minimum consecutive lines
+
+### Changed
+- **Disabled placeholder_stub_returns_js** - Replaced with multi-pass `analyzeStubFunctions` (95% false positive rate in regex version)
+- **Removed generic_naming patterns** - Removed 4 patterns (JS, Python, Rust, Go) based on feedback that they weren't detecting real problems
+
 ## [2.8.3] - 2025-01-23
 
 ### Fixed

package/README.md

@@ -6,7 +6,7 @@ A cross-platform plugin providing powerful, zero-configuration slash commands fo
 
 [![npm](https://img.shields.io/npm/v/awesome-slash?color=red)](https://www.npmjs.com/package/awesome-slash)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-2.8.3-blue)](https://github.com/avifenesh/awesome-slash/releases)
+[![Version](https://img.shields.io/badge/version-2.9.0-blue)](https://github.com/avifenesh/awesome-slash/releases)
 [![GitHub stars](https://img.shields.io/github/stars/avifenesh/awesome-slash?style=flat&color=yellow)](https://github.com/avifenesh/awesome-slash/stargazers)
 [![Claude Code](https://img.shields.io/badge/Claude-Code%20Plugin-blue)](https://docs.anthropic.com/en/docs/claude-code)
 [![Codex CLI](https://img.shields.io/badge/Codex-CLI%20Compatible-green)](https://developers.openai.com/codex/cli)
@@ -16,6 +16,13 @@ A cross-platform plugin providing powerful, zero-configuration slash commands fo
 
 > **💡 Model Recommendation**: Using **Opus** as the main agent model produces significantly better results and follows workflow phases more tightly. While Sonnet works for simpler tasks, Opus is recommended for complex multi-step workflows.
 
+## What's New in v2.9.0
+
+- **Gitignore Support** - File scanning now respects `.gitignore` patterns automatically
+- **Multi-Language Stub Detection** - Python, Rust, Java, Go support with 95% false positive reduction
+- **Java Dead Code Analysis** - Extended dead code detection to Java codebases
+- **Critical Bug Fixes** - Function name extraction, TypeScript matching, bracket balance tracking
+
 ## What's New in v2.8.0
 
 - **Complete /enhance Suite** - 7 enhancement analyzers for plugins, agents, prompts, docs, and project memory

package/lib/patterns/pipeline.js

@@ -149,9 +149,11 @@ function runPhase1(repoPath, targetFiles, language) {
     : slopPatterns.slopPatterns;
 
   for (const file of targetFiles) {
+    // Detect file language once per file
+    const fileLanguage = analyzers.detectLanguage(file);
+
     // Skip if language filter doesn't match file extension
     if (language) {
-      const fileLanguage = analyzers.detectLanguage(file);
       // For JS/TS language filter, accept both 'javascript' and 'js' detection results
       const isJsFamily = (language === 'javascript' || language === 'typescript') && fileLanguage === 'js';
       if (fileLanguage !== language && !isJsFamily) continue;
@@ -178,21 +180,72 @@ function runPhase1(repoPath, targetFiles, language) {
       // Skip if file matches exclude patterns
       if (slopPatterns.isFileExcluded(file, pattern.exclude)) continue;
 
-      // Check each line
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (pattern.pattern.test(line)) {
-          findings.push({
-            file,
-            line: i + 1,
-            patternName,
-            severity: pattern.severity,
-            certainty: CERTAINTY.HIGH,
-            description: pattern.description,
-            autoFix: pattern.autoFix,
-            content: line.trim().substring(0, 100),
-            phase: 1
-          });
+      // Skip language-specific patterns that don't match file's language
+      if (pattern.language) {
+        const patternLang = pattern.language;
+        // Map detection results to pattern language names
+        // Note: 'js' from detectLanguage covers both JavaScript and TypeScript
+        const langMatch = (patternLang === 'javascript' && fileLanguage === 'js') ||
+                          (patternLang === 'python' && fileLanguage === 'python') ||
+                          (patternLang === 'rust' && fileLanguage === 'rust') ||
+                          (patternLang === 'go' && fileLanguage === 'go') ||
+                          (patternLang === 'java' && fileLanguage === 'java') ||
+                          patternLang === fileLanguage;  // Direct match fallback
+        if (!langMatch) continue;
+      }
+
+      // Handle patterns requiring consecutive line blocks
+      if (pattern.minConsecutiveLines) {
+        const minLines = pattern.minConsecutiveLines;
+        let consecutiveStart = -1;
+        let consecutiveCount = 0;
+
+        for (let i = 0; i <= lines.length; i++) {
+          const line = i < lines.length ? lines[i] : ''; // Empty line at end to flush
+          const matches = i < lines.length && pattern.pattern.test(line);
+
+          if (matches) {
+            if (consecutiveStart === -1) {
+              consecutiveStart = i;
+            }
+            consecutiveCount++;
+          } else {
+            // End of consecutive block - check if it meets threshold
+            if (consecutiveCount >= minLines) {
+              findings.push({
+                file,
+                line: consecutiveStart + 1,
+                patternName,
+                severity: pattern.severity,
+                certainty: CERTAINTY.HIGH,
+                description: `${pattern.description} (${consecutiveCount} consecutive lines)`,
+                autoFix: pattern.autoFix,
+                content: `Lines ${consecutiveStart + 1}-${consecutiveStart + consecutiveCount}`,
+                phase: 1,
+                details: { startLine: consecutiveStart + 1, endLine: consecutiveStart + consecutiveCount, lineCount: consecutiveCount }
+              });
+            }
+            consecutiveStart = -1;
+            consecutiveCount = 0;
+          }
+        }
+      } else {
+        // Standard per-line matching
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (pattern.pattern.test(line)) {
+            findings.push({
+              file,
+              line: i + 1,
+              patternName,
+              severity: pattern.severity,
+              certainty: CERTAINTY.HIGH,
+              description: pattern.description,
+              autoFix: pattern.autoFix,
+              content: line.trim().substring(0, 100),
+              phase: 1
+            });
+          }
         }
       }
     }
@@ -214,12 +267,14 @@ function runMultiPassAnalyzers(repoPath, targetFiles) {
   // Get multi-pass pattern definitions for thresholds
   const multiPassPatterns = slopPatterns.getMultiPassPatterns();
 
+  // Supported languages for doc/code and verbosity analysis
+  const docCodeLangs = /\.(js|jsx|ts|tsx|mjs|cjs|py|rs|java|go)$/i;
+
   for (const file of targetFiles) {
-    const filePath = path.isAbsolute(file) ? file : path.join(repoPath, file);
-    const lang = analyzers.detectLanguage(file);
+    if (!file.match(docCodeLangs)) continue;
+    if (analyzers.isTestFile(file)) continue;
 
-    // Skip non-JS files for doc/code ratio (JSDoc specific)
-    if (lang !== 'js') continue;
+    const filePath = path.isAbsolute(file) ? file : path.join(repoPath, file);
 
     let content;
     try {
@@ -228,31 +283,32 @@ function runMultiPassAnalyzers(repoPath, targetFiles) {
       continue;
     }
 
-    // Doc/code ratio analysis
+    // Doc/code ratio analysis (multi-language)
     const docCodePattern = multiPassPatterns.doc_code_ratio_js;
     if (docCodePattern) {
       const docRatioViolations = analyzers.analyzeDocCodeRatio(content, {
         minFunctionLines: docCodePattern.minFunctionLines || 3,
-        maxRatio: docCodePattern.maxRatio || 3.0
+        maxRatio: docCodePattern.maxRatio || 3.0,
+        filePath: file
       });
 
       for (const v of docRatioViolations) {
         findings.push({
           file,
           line: v.line,
-          patternName: 'doc_code_ratio_js',
+          patternName: 'doc_code_ratio',
           severity: docCodePattern.severity,
           certainty: CERTAINTY.MEDIUM,
           description: `${docCodePattern.description} (${v.docLines} doc lines / ${v.codeLines} code lines = ${v.ratio}x)`,
           autoFix: docCodePattern.autoFix,
-          content: `Function at line ${v.line}`,
+          content: v.functionName ? `${v.functionName}()` : `Function at line ${v.line}`,
           phase: 1,
-          details: { docLines: v.docLines, codeLines: v.codeLines, ratio: v.ratio }
+          details: { docLines: v.docLines, codeLines: v.codeLines, ratio: v.ratio, functionName: v.functionName }
         });
       }
     }
 
-    // Verbosity ratio analysis
+    // Verbosity ratio analysis (multi-language)
     const verbosityPattern = multiPassPatterns.verbosity_ratio;
     if (verbosityPattern) {
       const verbosityViolations = analyzers.analyzeVerbosityRatio(content, {
@@ -347,6 +403,107 @@ function runMultiPassAnalyzers(repoPath, targetFiles) {
     }
   }
 
+  // Dead code analysis (per-file)
+  const deadCodePattern = multiPassPatterns.dead_code;
+  if (deadCodePattern) {
+    for (const file of targetFiles) {
+      // Skip test files
+      if (analyzers.isTestFile(file)) continue;
+
+      const filePath = path.isAbsolute(file) ? file : path.join(repoPath, file);
+      let content;
+      try {
+        content = fs.readFileSync(filePath, 'utf8');
+      } catch {
+        continue;
+      }
+
+      const deadCodeViolations = analyzers.analyzeDeadCode(content, { filePath: file });
+
+      for (const v of deadCodeViolations) {
+        findings.push({
+          file,
+          line: v.line,
+          patternName: 'dead_code',
+          severity: deadCodePattern.severity,
+          certainty: CERTAINTY.MEDIUM,
+          description: `${deadCodePattern.description}: ${v.terminationType} at line ${v.terminationLine}`,
+          autoFix: deadCodePattern.autoFix,
+          content: v.content,
+          phase: 1,
+          details: { terminationType: v.terminationType, terminationLine: v.terminationLine }
+        });
+      }
+    }
+  }
+
+  // Stub function analysis (per-file, multi-language)
+  const stubPattern = multiPassPatterns.placeholder_stub_returns_js;
+  if (stubPattern) {
+    // Supported extensions for stub detection
+    const stubExtensions = /\.(js|jsx|ts|tsx|mjs|cjs|py|rs|java|go)$/i;
+
+    for (const file of targetFiles) {
+      if (analyzers.isTestFile(file)) continue;
+      if (!file.match(stubExtensions)) continue;
+      // Honor pattern exclude globs (e.g., *.config.*)
+      if (slopPatterns.isFileExcluded(file, stubPattern.exclude)) continue;
+
+      const filePath = path.isAbsolute(file) ? file : path.join(repoPath, file);
+      let content;
+      try {
+        content = fs.readFileSync(filePath, 'utf8');
+      } catch {
+        continue;
+      }
+
+      const stubViolations = analyzers.analyzeStubFunctions(content, { filePath: file });
+
+      for (const v of stubViolations) {
+        findings.push({
+          file,
+          line: v.line,
+          patternName: 'placeholder_stub_returns',
+          severity: v.hasTodo ? 'high' : stubPattern.severity,
+          certainty: v.certainty,
+          description: `${stubPattern.description}: ${v.functionName}() returns ${v.returnValue}`,
+          autoFix: stubPattern.autoFix,
+          content: v.content,
+          phase: 1,
+          details: { functionName: v.functionName, returnValue: v.returnValue, hasTodo: v.hasTodo }
+        });
+      }
+    }
+  }
+
+  // Shotgun surgery analysis (git history)
+  const shotgunPattern = multiPassPatterns.shotgun_surgery;
+  if (shotgunPattern) {
+    try {
+      const shotgunResult = analyzers.analyzeShotgunSurgery(repoPath, {
+        commitLimit: shotgunPattern.commitLimit || 100,
+        clusterThreshold: shotgunPattern.clusterThreshold || 5
+      });
+
+      for (const v of shotgunResult.violations) {
+        findings.push({
+          file: 'project-level',
+          line: 0,
+          patternName: 'shotgun_surgery',
+          severity: shotgunPattern.severity,
+          certainty: CERTAINTY.MEDIUM,
+          description: `${shotgunPattern.description}: ${v.files.length} files change together ${v.count} times`,
+          autoFix: shotgunPattern.autoFix,
+          content: v.files.join(', ').substring(0, 100),
+          phase: 1,
+          details: { files: v.files, changeCount: v.count }
+        });
+      }
+    } catch {
+      // Git not available or not a git repo - skip silently
+    }
+  }
+
   return findings;
 }