awesome-slash 2.4.2

package/mcp-server/index.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+/**
+ * MCP Server for awesome-slash-commands
+ *
+ * Exposes workflow tools to any MCP-compatible AI coding assistant:
+ * - Claude Code (native)
+ * - OpenCode
+ * - Codex CLI
+ *
+ * Run: node mcp-server/index.js
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+
+const path = require('path');
+const workflowState = require('../lib/state/workflow-state.js');
+
+// Plugin root for relative paths
+const PLUGIN_ROOT = process.env.PLUGIN_ROOT || path.join(__dirname, '..');
+
+// Define available tools
+const TOOLS = [
+  {
+    name: 'workflow_status',
+    description: 'Get the current workflow state, including active task, phase, and resume capability',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'workflow_start',
+    description: 'Start a new workflow with specified policy settings',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskSource: {
+          type: 'string',
+          enum: ['gh-issues', 'linear', 'tasks-md', 'custom'],
+          description: 'Where to look for tasks'
+        },
+        priorityFilter: {
+          type: 'string',
+          enum: ['continue', 'bugs', 'security', 'features', 'all'],
+          description: 'What type of tasks to prioritize'
+        },
+        stoppingPoint: {
+          type: 'string',
+          enum: ['implemented', 'pr-created', 'all-green', 'merged', 'deployed', 'production'],
+          description: 'How far to take the task'
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'workflow_resume',
+    description: 'Resume an interrupted workflow from its last checkpoint',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'workflow_abort',
+    description: 'Abort the current workflow and cleanup resources (worktree, branches)',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'task_discover',
+    description: 'Discover and prioritize available tasks from configured sources',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: {
+          type: 'string',
+          enum: ['gh-issues', 'linear', 'tasks-md'],
+          description: 'Task source to search'
+        },
+        filter: {
+          type: 'string',
+          description: 'Filter tasks by type (bug, feature, security, etc.)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of tasks to return'
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'review_code',
+    description: 'Run multi-agent code review on changed files',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Files to review (defaults to git diff)'
+        },
+        maxIterations: {
+          type: 'number',
+          description: 'Maximum review iterations (default: 3)'
+        }
+      },
+      required: []
+    }
+  }
+];
+
+// Tool handlers
+const toolHandlers = {
+  async workflow_status() {
+    const state = workflowState.readState();
+
+    if (state instanceof Error) {
+      return {
+        content: [{ type: 'text', text: `Error: ${state.message}` }],
+        isError: true
+      };
+    }
+    if (!state) {
+      return { content: [{ type: 'text', text: 'No active workflow.' }] };
+    }
+
+    const summary = workflowState.getWorkflowSummary();
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(summary, null, 2)
+      }]
+    };
+  },
+
+  async workflow_start({ taskSource, priorityFilter, stoppingPoint }) {
+    // Check for existing workflow
+    if (workflowState.hasActiveWorkflow()) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Error: Active workflow exists. Use workflow_abort to cancel or workflow_resume to continue.'
+        }],
+        isError: true
+      };
+    }
+
+    const policy = {
+      ...workflowState.DEFAULT_POLICY,
+      taskSource: taskSource || 'gh-issues',
+      priorityFilter: priorityFilter || 'continue',
+      stoppingPoint: stoppingPoint || 'merged'
+    };
+
+    const state = workflowState.createState('next-task', policy);
+    workflowState.writeState(state);
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Workflow started: ${state.workflow.id}\nPolicy: ${JSON.stringify(policy, null, 2)}`
+      }]
+    };
+  },
+
+  async workflow_resume() {
+    const state = workflowState.readState();
+
+    if (state instanceof Error) {
+      return {
+        content: [{ type: 'text', text: `Error: ${state.message}` }],
+        isError: true
+      };
+    }
+    if (!state) {
+      return {
+        content: [{ type: 'text', text: 'No workflow to resume.' }],
+        isError: true
+      };
+    }
+
+    if (!state.checkpoints?.canResume) {
+      return {
+        content: [{ type: 'text', text: 'Workflow cannot be resumed from current state.' }],
+        isError: true
+      };
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Resuming workflow ${state.workflow.id} from phase: ${state.checkpoints.resumeFrom}`
+      }]
+    };
+  },
+
+  async workflow_abort() {
+    const state = workflowState.readState();
+
+    if (state instanceof Error) {
+      return {
+        content: [{ type: 'text', text: `Error: ${state.message}` }],
+        isError: true
+      };
+    }
+    if (!state) {
+      return {
+        content: [{ type: 'text', text: 'No workflow to abort.' }]
+      };
+    }
+
+    workflowState.abortWorkflow('User requested abort');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Workflow ${state.workflow.id} aborted. Cleanup: worktree and branches should be removed manually.`
+      }]
+    };
+  },
+
+  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 review_code({ files, maxIterations }) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Code review would analyze ${files?.length || 'changed'} files with max ${maxIterations || 3} iterations.`
+      }]
+    };
+  }
+};
+
+// Create and run server
+async function main() {
+  const server = new Server(
+    {
+      name: 'awesome-slash',
+      version: '2.0.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // List available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+  });
+
+  // Handle tool calls
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    const handler = toolHandlers[name];
+    if (!handler) {
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    }
+
+    try {
+      return await handler(args || {});
+    } catch (error) {
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true
+      };
+    }
+  });
+
+  // Connect via stdio
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  console.error('awesome-slash MCP server running');
+}
+
+main().catch(console.error);

package/mcp-server/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "awesome-slash-mcp-server",
+  "version": "2.0.0",
+  "description": "MCP server for awesome-slash-commands - enables cross-platform AI assistant integration",
+  "main": "index.js",
+  "bin": {
+    "awesome-slash-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "opencode",
+    "codex",
+    "ai-coding"
+  ],
+  "license": "MIT"
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "awesome-slash",
+  "version": "2.4.2",
+  "description": "Professional-grade slash commands for Claude Code that work across any project",
+  "main": "lib/platform/detect-platform.js",
+  "type": "commonjs",
+  "files": [
+    ".claude-plugin/",
+    ".mcp.json",
+    "lib/",
+    "mcp-server/index.js",
+    "mcp-server/package.json",
+    "plugins/",
+    "scripts/install/",
+    "adapters/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "detect": "node lib/platform/detect-platform.js",
+    "verify": "node lib/platform/verify-tools.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avifenesh/awesome-slash.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "claude-plugin",
+    "anthropic",
+    "slash-commands",
+    "ai-coding",
+    "workflow-automation",
+    "ci-cd",
+    "deployment",
+    "code-review",
+    "mcp",
+    "developer-tools",
+    "opencode",
+    "codex-cli"
+  ],
+  "author": {
+    "name": "Avi Fenesh",
+    "url": "https://github.com/avifenesh"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/avifenesh/awesome-slash/issues"
+  },
+  "homepage": "https://github.com/avifenesh/awesome-slash#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

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

@@ -0,0 +1,20 @@
+{
+  "name": "deslop-around",
+  "version": "2.3.1",
+  "description": "AI slop cleanup with minimal diffs and behavior preservation",
+  "author": {
+    "name": "Avi Fenesh",
+    "email": "[email protected]",
+    "url": "https://github.com/avifenesh"
+  },
+  "homepage": "https://github.com/avifenesh/awesome-slash#deslop-around",
+  "repository": "https://github.com/avifenesh/awesome-slash",
+  "license": "MIT",
+  "keywords": [
+    "code-quality",
+    "cleanup",
+    "refactoring",
+    "maintenance",
+    "slop-detection"
+  ]
+}

package/plugins/deslop-around/commands/deslop-around.md

@@ -0,0 +1,220 @@
+---
+description: Cleanup AI slop with minimal diffs and behavior preservation
+argument-hint: "[report|apply] [scope-path] [max-changes]"
+---
+
+# /deslop-around - AI Slop Cleanup
+
+You are a senior maintainer doing periodic repo hygiene. Your mission: remove "AI slop" while preserving behavior and minimizing diffs.
+
+## Arguments
+
+- **Mode**: `report` (default) or `apply`
+- **Scope**: Path or glob pattern (default: `.`)
+- **Max changes**: Number of changesets (default: 5)
+
+Parse from $ARGUMENTS or use defaults.
+
+## Pre-Context: Platform Detection
+
+```bash
+# Detect project type and test command
+if [ -f "package.json" ]; then
+  PROJECT_TYPE="nodejs"
+  if command -v npm &> /dev/null; then
+    TEST_CMD="npm test"
+  elif command -v pnpm &> /dev/null; then
+    TEST_CMD="pnpm test"
+  elif command -v yarn &> /dev/null; then
+    TEST_CMD="yarn test"
+  fi
+elif [ -f "requirements.txt" ] || [ -f "pyproject.toml" ]; then
+  PROJECT_TYPE="python"
+  TEST_CMD="pytest"
+elif [ -f "Cargo.toml" ]; then
+  PROJECT_TYPE="rust"
+  TEST_CMD="cargo test"
+elif [ -f "go.mod" ]; then
+  PROJECT_TYPE="go"
+  TEST_CMD="go test ./..."
+else
+  PROJECT_TYPE="unknown"
+  TEST_CMD=""
+fi
+```
+
+## Non-Negotiable Constraints
+
+1. Preserve behavior and public APIs
+2. Minimal diffs - don't reformat unrelated code
+3. Prefer deletion over invention
+4. Do NOT add dependencies or new abstractions
+5. Respect repo conventions (check CLAUDE.md if present)
+
+## Ignore Zones
+
+- Build artifacts: `dist/`, `build/`, `target/`, `out/`, `.next/`, coverage/
+- Vendored/generated: `vendor/`, `third_party/`, `node_modules/`, `**/*.min.*`, `**/*.gen.*`
+- Lockfiles (unless explicitly in scope)
+
+## Pre-Context Commands
+
+Run these and analyze output:
+
+```bash
+git rev-parse --show-toplevel  # Repo root
+git branch --show-current       # Current branch
+git status --porcelain=v1       # Dirty status
+git log --oneline -15          # Recent commits
+git ls-files | wc -l           # File count
+```
+
+## AI Slop Definitions
+
+Detect and remove:
+
+- **Console Debugging**: `console.log()`, `print()`, `println!()`, `dbg!()`
+- **Old TODOs**: Comments >90 days old (check line age)
+- **Commented Code**: >5 consecutive commented lines
+- **Placeholder Text**: "lorem ipsum", "test test", "TODO: implement"
+- **Empty Catch**: Empty catch/except blocks without logging
+- **Magic Numbers**: Large hardcoded numbers (>1000)
+- **Disabled Linters**: eslint-disable, pylint: disable, #noqa
+- **Trailing Whitespace**: Whitespace at end of lines
+- **Mixed Indentation**: Tabs and spaces mixed
+- **Unused Imports**: Imports marked as unused
+- **Hardcoded URLs**: URLs that should be config
+- **Debug Imports**: `import pdb`, `import ipdb`
+
+Reference patterns from `${CLAUDE_PLUGIN_ROOT}/lib/patterns/slop-patterns.js`
+
+## Phase A: Map + Diagnose (Always)
+
+1. Scan files in scope using slop patterns
+2. Identify top 10 "Slop Hotspots":
+   - File path
+   - What's wrong (specific line numbers)
+   - Risk level (low/medium/high)
+   - Proposed fix type (remove/replace/flag)
+3. Sort by smallest-first (lowest risk, highest confidence)
+
+## Phase B: Report Mode (Default)
+
+Output:
+- Prioritized cleanup plan (3-7 steps)
+- For each step:
+  - Files affected
+  - Expected diff size
+  - Estimated risk
+  - Verification command
+- "Do Next" checklist
+
+**Do NOT modify files in report mode.**
+
+## Phase C: Apply Mode
+
+Implement up to MAX_CHANGES changesets:
+
+### Rules for Apply
+
+1. One changeset at a time
+2. Show diff summary after each
+3. Explain verification
+4. Don't mix unrelated changes
+5. Verify with tests/typecheck/lint if available
+6. Stop early if detecting brittle code
+
+### Per Changeset Deliverables
+
+1. What changed (1-3 bullets)
+2. Why it's slop + why new shape is better
+3. Verification commands + results
+4. Concise diff (`git diff --stat` + key hunks)
+
+### Verification Strategy
+
+```bash
+# Run test command if available
+if command -v $TEST_CMD >/dev/null 2>&1; then
+  $TEST_CMD
+fi
+
+# Run type check if available
+if [ "$PROJECT_TYPE" = "nodejs" ] && [ -f tsconfig.json ]; then
+  ${PACKAGE_MGR} run check-types || tsc --noEmit
+fi
+
+# Run linter if available
+if [ -f .eslintrc.js ] || [ -f .eslintrc.json ]; then
+  ${PACKAGE_MGR} run lint || eslint .
+fi
+```
+
+### Rollback on Failure
+
+If verification fails:
+```bash
+git restore .
+```
+
+Report which changes failed verification and recommend manual review.
+
+## Final Rollup Summary
+
+After all changesets (apply mode only):
+
+```markdown
+## Cleanup Summary
+
+**Files Changed**: X
+**Lines Deleted**: Y
+**Lines Added**: Z
+**Net Change**: Y - Z
+
+### Verification Results
+- Tests: ✓ Passed / ✗ Failed
+- Type Check: ✓ Passed / ✗ Failed
+- Lint: ✓ Passed / ✗ Failed
+
+### Remaining Hotspots
+1. File: path/to/file.js - Issue description (needs manual review)
+2. ...
+```
+
+## Output Style
+
+Be direct, skeptical, and pragmatic. No fluff. Concrete references only (paths, line numbers, commands).
+
+## Example Usage
+
+```bash
+/deslop-around
+# Report mode: analyze and generate cleanup plan
+
+/deslop-around apply
+# Apply mode: fix up to 5 changesets with verification
+
+/deslop-around apply src/ 10
+# Apply mode: fix up to 10 changesets in src/ directory
+
+/deslop-around report tests/
+# Report mode: analyze only tests/ directory
+```
+
+## Error Handling
+
+- If git not available: Fail with "Git required"
+- If not in git repo: Fail with "Must run in git repository"
+- If scope path doesn't exist: Fail with "Invalid scope path"
+- If verification fails in apply mode: Rollback and report
+
+## Important Notes
+
+- Use slop patterns from library (don't hardcode)
+- Adapt verification to detected project type
+- Respect test command from platform detection
+- Always preserve behavior
+- Minimal diffs only
+- No speculation - only fix confirmed slop
+
+Begin Phase A now.