slopfighter 0.1.0

package/src/rules/redundant-boolean-cast.mjs

@@ -0,0 +1,65 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// `!!x` inside an `if`/`while`/`?:`/`&&`/`||` — already coerces.
+// `Boolean(x)` in same contexts — same.
+// AI loves to add these for "explicitness".
+export default {
+  id: 'redundant-boolean-cast',
+  severity: 'info',
+  description: '`!!x` or `Boolean(x)` where the value is already coerced',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (!isBooleanContext(node, ts)) return;
+      // for if/while/?: the expression is `node.expression` or `node.condition`
+      const expr =
+        node.expression || node.condition;
+      if (!expr) return;
+      const reason = describeRedundantCast(expr, ts);
+      if (!reason) return;
+      const range = nodeRange(sourceFile, expr);
+      findings.push({
+        message: `${reason} — already coerced to boolean by the surrounding context`,
+        line: range.line,
+        column: range.column,
+      });
+    });
+    return findings;
+  },
+};
+
+function isBooleanContext(node, ts) {
+  return (
+    node.kind === ts.SyntaxKind.IfStatement ||
+    node.kind === ts.SyntaxKind.WhileStatement ||
+    node.kind === ts.SyntaxKind.DoStatement ||
+    node.kind === ts.SyntaxKind.ConditionalExpression ||
+    (node.kind === ts.SyntaxKind.PrefixUnaryExpression && node.operator === ts.SyntaxKind.ExclamationToken)
+  );
+}
+
+function describeRedundantCast(expr, ts) {
+  // `!!x`
+  if (
+    expr.kind === ts.SyntaxKind.PrefixUnaryExpression &&
+    expr.operator === ts.SyntaxKind.ExclamationToken &&
+    expr.operand &&
+    expr.operand.kind === ts.SyntaxKind.PrefixUnaryExpression &&
+    expr.operand.operator === ts.SyntaxKind.ExclamationToken
+  ) {
+    return '`!!x`';
+  }
+  // `Boolean(x)`
+  if (
+    expr.kind === ts.SyntaxKind.CallExpression &&
+    expr.expression &&
+    expr.expression.kind === ts.SyntaxKind.Identifier &&
+    expr.expression.text === 'Boolean' &&
+    (expr.arguments || []).length === 1
+  ) {
+    return '`Boolean(x)`';
+  }
+  return null;
+}

package/src/rules/redundant-error-rethrow.mjs

@@ -0,0 +1,44 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// `throw new Error(err.message)` — strips stack and type for no reason.
+// `throw new Error(String(err))` — same.
+export default {
+  id: 'redundant-error-rethrow',
+  severity: 'warn',
+  description: 'Re-wrapping an Error in `new Error(err.message)` destroys the stack',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (node.kind !== ts.SyntaxKind.ThrowStatement) return;
+      const expr = node.expression;
+      if (!expr || expr.kind !== ts.SyntaxKind.NewExpression) return;
+      const callee = expr.expression;
+      if (callee.kind !== ts.SyntaxKind.Identifier) return;
+      if (callee.text !== 'Error') return;
+      const args = expr.arguments || [];
+      if (args.length !== 1) return;
+      const arg = args[0];
+      // foo.message
+      const isDotMessage =
+        arg.kind === ts.SyntaxKind.PropertyAccessExpression &&
+        arg.name &&
+        arg.name.text === 'message';
+      // String(foo)
+      const isStringWrap =
+        arg.kind === ts.SyntaxKind.CallExpression &&
+        arg.expression &&
+        arg.expression.kind === ts.SyntaxKind.Identifier &&
+        arg.expression.text === 'String';
+      if (!isDotMessage && !isStringWrap) return;
+
+      const range = nodeRange(sourceFile, node);
+      findings.push({
+        message: 'rewrapping an Error destroys the stack — just `throw err` or use `{ cause: err }`',
+        ...range,
+      });
+    });
+    return findings;
+  },
+};

package/src/rules/return-undefined.mjs

@@ -0,0 +1,35 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// `return undefined` — equivalent to `return` and `return undefined` is
+// pure noise that AI loves to add for "explicitness".
+// Also catches `return void 0;`.
+export default {
+  id: 'return-undefined',
+  severity: 'info',
+  description: '`return undefined` is identical to bare `return`',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (node.kind !== ts.SyntaxKind.ReturnStatement) return;
+      const e = node.expression;
+      if (!e) return;
+      const isUndefined = e.kind === ts.SyntaxKind.Identifier && e.text === 'undefined';
+      const isVoid0 =
+        e.kind === ts.SyntaxKind.VoidExpression &&
+        e.expression &&
+        e.expression.kind === ts.SyntaxKind.NumericLiteral &&
+        e.expression.text === '0';
+      if (!isUndefined && !isVoid0) return;
+      const range = nodeRange(sourceFile, node);
+      findings.push({
+        message: 'drop the explicit `undefined` — bare `return;` is equivalent',
+        line: range.line,
+        column: range.column,
+        fix: { start: node.getStart(sourceFile), end: node.getEnd(), replacement: 'return;' },
+      });
+    });
+    return findings;
+  },
+};

package/src/rules/single-method-class.mjs

@@ -0,0 +1,49 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// Class with no fields and exactly one public method that doesn't reference
+// `this` — it's just a namespace for a function. Convert to a function.
+export default {
+  id: 'single-method-class',
+  severity: 'info',
+  description: 'Class with one method that doesn\'t use `this` — should be a function',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (node.kind !== ts.SyntaxKind.ClassDeclaration) return;
+      if (!node.name) return;
+      // subclasses and interface implementations are intentionally classes
+      if (node.heritageClauses && node.heritageClauses.length > 0) return;
+      const members = node.members || [];
+      const props = members.filter((m) => m.kind === ts.SyntaxKind.PropertyDeclaration);
+      const methods = members.filter((m) => m.kind === ts.SyntaxKind.MethodDeclaration);
+      const ctors = members.filter((m) => m.kind === ts.SyntaxKind.Constructor);
+      if (props.length > 0) return;
+      if (methods.length !== 1) return;
+      if (ctors.length > 0 && ctors[0].body && ctors[0].body.statements.length > 0) return;
+
+      const method = methods[0];
+      if (usesThis(method, ts)) return;
+
+      const range = nodeRange(sourceFile, node);
+      findings.push({
+        message: `class "${node.name.text}" wraps a single this-free method — make it a function`,
+        line: range.line,
+        column: range.column,
+      });
+    });
+    return findings;
+  },
+};
+
+function usesThis(node, ts) {
+  let found = false;
+  visit(node);
+  return found;
+  function visit(n) {
+    if (found || !n) return;
+    if (n.kind === ts.SyntaxKind.ThisKeyword) { found = true; return; }
+    n.forEachChild(visit);
+  }
+}

package/src/rules/trivial-arrow-wrapper.mjs

@@ -0,0 +1,70 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// `arr.map(x => fn(x))` — useless lambda, just pass `fn`.
+// Catches `(x) => fn(x)` and `(x, y) => fn(x, y)` style wrappers where
+// param list exactly matches the call arg list.
+export default {
+  id: 'trivial-arrow-wrapper',
+  severity: 'info',
+  description: 'Arrow function that just forwards its args to another call',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (node.kind !== ts.SyntaxKind.ArrowFunction) return;
+      const params = node.parameters || [];
+      if (params.length === 0) return;
+      // skip params with default values, destructuring, rest, type-only modifiers
+      for (const p of params) {
+        if (p.dotDotDotToken) return;
+        if (p.initializer) return;
+        if (p.name && p.name.kind !== ts.SyntaxKind.Identifier) return;
+      }
+
+      // body must be a single call expression (or block with `return call;`)
+      const call = unwrapCall(node.body, ts);
+      if (!call) return;
+
+      const args = call.arguments || [];
+      if (args.length !== params.length) return;
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.kind !== ts.SyntaxKind.Identifier) return;
+        if (arg.text !== params[i].name.text) return;
+      }
+      // callee can be any expression; we'll just suggest replacing the wrapper
+      const range = nodeRange(sourceFile, node);
+      const calleeText = call.expression.getText(sourceFile);
+      findings.push({
+        message: `trivial wrapper — replace \`${truncate(node.getText(sourceFile), 40)}\` with \`${truncate(calleeText, 40)}\``,
+        line: range.line,
+        column: range.column,
+      });
+    });
+    return findings;
+  },
+};
+
+function unwrapCall(body, ts) {
+  if (!body) return null;
+  if (body.kind === ts.SyntaxKind.CallExpression) return body;
+  if (body.kind === ts.SyntaxKind.Block) {
+    const stmts = body.statements;
+    if (stmts.length !== 1) return null;
+    const s = stmts[0];
+    if (s.kind === ts.SyntaxKind.ReturnStatement && s.expression && s.expression.kind === ts.SyntaxKind.CallExpression) {
+      return s.expression;
+    }
+    if (s.kind === ts.SyntaxKind.ExpressionStatement && s.expression.kind === ts.SyntaxKind.CallExpression) {
+      // (x) => { fn(x); } — only flag if return type is void-ish; we'll be conservative and skip
+      return null;
+    }
+  }
+  return null;
+}
+
+function truncate(s, n) {
+  s = s.replace(/\s+/g, ' ');
+  return s.length > n ? s.slice(0, n - 1) + '…' : s;
+}

package/src/rules/unnecessary-async.mjs

@@ -0,0 +1,61 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// `async function foo() { return x }` — async with no await inside, no
+// Promise return needed beyond what `async` adds. Either drop `async`
+// or there's a missing await.
+export default {
+  id: 'unnecessary-async',
+  severity: 'info',
+  description: 'async function/method with no await in its body',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      const isAsync =
+        node.modifiers &&
+        node.modifiers.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+      if (!isAsync) return;
+
+      const isFn =
+        node.kind === ts.SyntaxKind.FunctionDeclaration ||
+        node.kind === ts.SyntaxKind.MethodDeclaration ||
+        node.kind === ts.SyntaxKind.ArrowFunction ||
+        node.kind === ts.SyntaxKind.FunctionExpression;
+      if (!isFn) return;
+      if (!node.body) return;
+
+      if (!hasAwait(node.body, ts)) {
+        const range = nodeRange(sourceFile, node);
+        const name = node.name && node.name.text ? `"${node.name.text}" ` : '';
+        findings.push({
+          message: `async ${name}has no \`await\` — drop \`async\` or add the missing await`,
+          line: range.line,
+          column: range.column,
+        });
+      }
+    });
+    return findings;
+  },
+};
+
+function hasAwait(node, ts) {
+  let found = false;
+  visit(node);
+  return found;
+
+  function visit(n) {
+    if (found || !n) return;
+    // do not descend into nested function bodies — their awaits are theirs
+    if (
+      n !== node &&
+      (n.kind === ts.SyntaxKind.FunctionDeclaration ||
+        n.kind === ts.SyntaxKind.FunctionExpression ||
+        n.kind === ts.SyntaxKind.ArrowFunction ||
+        n.kind === ts.SyntaxKind.MethodDeclaration)
+    ) return;
+    if (n.kind === ts.SyntaxKind.AwaitExpression) { found = true; return; }
+    if (n.kind === ts.SyntaxKind.ForOfStatement && n.awaitModifier) { found = true; return; }
+    n.forEachChild(visit);
+  }
+}

package/src/rules/useless-try-catch.mjs

@@ -0,0 +1,62 @@
+import { walk, nodeRange } from './_util.mjs';
+
+// catch (e) { throw e } — useless wrapping.
+// catch (e) { console.log(e); throw e } — only slightly less useless.
+export default {
+  id: 'useless-try-catch',
+  severity: 'warn',
+  description: 'try/catch that just rethrows or logs-then-rethrows',
+  check(ctx) {
+    const { sourceFile, ts } = ctx;
+    const findings = [];
+
+    walk(sourceFile, (node) => {
+      if (node.kind !== ts.SyntaxKind.TryStatement) return;
+      const cc = node.catchClause;
+      if (!cc || !cc.block) return;
+      const stmts = cc.block.statements || [];
+      if (stmts.length === 0) {
+        // swallow: also bad but a different smell — skip here
+        return;
+      }
+      const last = stmts[stmts.length - 1];
+      const errName = cc.variableDeclaration && cc.variableDeclaration.name && cc.variableDeclaration.name.text;
+
+      // is the last statement `throw e` referencing the catch var?
+      const lastIsRethrow =
+        last.kind === ts.SyntaxKind.ThrowStatement &&
+        last.expression &&
+        last.expression.kind === ts.SyntaxKind.Identifier &&
+        last.expression.text === errName;
+
+      if (!lastIsRethrow) return;
+
+      const others = stmts.slice(0, -1);
+      const allOthersAreLogs = others.every((s) => isJustLog(s, ts));
+      if (others.length === 0 || allOthersAreLogs) {
+        const range = nodeRange(sourceFile, cc);
+        findings.push({
+          message:
+            others.length === 0
+              ? `catch only rethrows ${errName} — drop the try/catch entirely.`
+              : `catch logs and rethrows — caller can handle it, the log just spams noise.`,
+          ...range,
+        });
+      }
+    });
+    return findings;
+  },
+};
+
+function isJustLog(stmt, ts) {
+  if (stmt.kind !== ts.SyntaxKind.ExpressionStatement) return false;
+  const expr = stmt.expression;
+  if (expr.kind !== ts.SyntaxKind.CallExpression) return false;
+  const callee = expr.expression;
+  // console.<anything>(...)
+  if (callee.kind === ts.SyntaxKind.PropertyAccessExpression) {
+    const obj = callee.expression;
+    if (obj.kind === ts.SyntaxKind.Identifier && obj.text === 'console') return true;
+  }
+  return false;
+}

package/src/scanner.mjs

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { allRules } from './rules/index.mjs';
+
+const DEFAULT_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.next', 'out', 'coverage', '.cache',
+  'vendor', 'vendored', 'third_party', 'thirdparty', 'generated', '__generated__',
+  '.svelte-kit', '.nuxt', '.turbo', '.parcel-cache',
+]);
+
+export async function scanPath(target, flags = {}) {
+  const stat = fs.statSync(target);
+  const files = stat.isDirectory() ? collectFiles(target, flags.ignore || []) : [target];
+  const activeRules = filterRules(allRules, flags);
+
+  const findings = [];
+  for (const file of files) {
+    const fileFindings = scanFile(file, activeRules);
+    findings.push(...fileFindings);
+  }
+  // Return both findings (array — callers that destructure or just use
+  // .length keep working) AND a side-channel fileCount via a non-enumerable
+  // property, so the score can normalize correctly.
+  Object.defineProperty(findings, 'fileCount', { value: files.length, enumerable: false });
+  return findings;
+}
+
+function collectFiles(dir, ignorePatterns) {
+  const out = [];
+  walk(dir);
+  return out;
+
+  function walk(d) {
+    let entries;
+    try {
+      entries = fs.readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(d, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        walk(full);
+      } else if (e.isFile()) {
+        const ext = path.extname(e.name);
+        if (!DEFAULT_EXTENSIONS.has(ext)) continue;
+        if (shouldIgnore(full, ignorePatterns)) continue;
+        out.push(full);
+      }
+    }
+  }
+}
+
+function shouldIgnore(file, patterns) {
+  if (!patterns.length) return false;
+  const norm = file.replace(/\\/g, '/');
+  return patterns.some((p) => norm.includes(p));
+}
+
+function filterRules(rules, flags) {
+  let r = rules;
+  if (flags.rules && flags.rules.length) {
+    const set = new Set(flags.rules);
+    r = r.filter((rule) => set.has(rule.id));
+  }
+  if (!flags.strict) {
+    r = r.filter((rule) => !rule.strictOnly);
+  }
+  return r;
+}
+
+function scanFile(file, rules) {
+  let source;
+  try {
+    source = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const ext = path.extname(file);
+  const scriptKind =
+    ext === '.tsx' ? ts.ScriptKind.TSX :
+    ext === '.ts' ? ts.ScriptKind.TS :
+    ext === '.jsx' ? ts.ScriptKind.JSX : ts.ScriptKind.JS;
+  const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, scriptKind);
+  const lines = source.split(/\r?\n/);
+
+  const ctx = { file, source, lines, sourceFile, ts };
+  const findings = [];
+  for (const rule of rules) {
+    try {
+      const results = rule.check(ctx) || [];
+      for (const r of results) {
+        findings.push({
+          ruleId: rule.id,
+          severity: r.severity || rule.severity || 'warn',
+          message: r.message,
+          file,
+          line: r.line,
+          column: r.column || 1,
+          endLine: r.endLine || r.line,
+          endColumn: r.endColumn || (r.column || 1) + 1,
+          fixable: !!r.fix,
+          fix: r.fix || null,
+        });
+      }
+    } catch (err) {
+      // never crash the scan on a buggy rule
+      findings.push({
+        ruleId: rule.id,
+        severity: 'error',
+        message: `rule crashed: ${err.message}`,
+        file,
+        line: 1,
+        column: 1,
+      });
+    }
+  }
+  return findings;
+}

package/src/score.mjs

@@ -0,0 +1,44 @@
+const WEIGHTS = { error: 5, warn: 2, info: 1 };
+
+// Score is computed on penalty-per-file so a clean 2000-file repo isn't
+// punished by sheer volume. Single-file scans use the penalty directly.
+export function computeScore(findings, options = {}) {
+  const counts = { error: 0, warn: 0, info: 0 };
+  const byRule = {};
+  const files = new Set();
+  for (const f of findings) {
+    counts[f.severity] = (counts[f.severity] || 0) + 1;
+    byRule[f.ruleId] = (byRule[f.ruleId] || 0) + 1;
+    if (f.file) files.add(f.file);
+  }
+
+  const penalty =
+    counts.error * WEIGHTS.error +
+    counts.warn * WEIGHTS.warn +
+    counts.info * WEIGHTS.info;
+
+  // normalize: prefer caller-supplied fileCount, else side-channel on the
+  // findings array (set by scanner), else dirty-file count, else 1.
+  const fileCount =
+    options.fileCount || findings.fileCount || Math.max(files.size, 1);
+  const perFilePenalty = penalty / fileCount;
+  // tuned against real codebases: hallmark ~0.5 fpf → B, cline ~1.4 → D,
+  // continue ~3.0 → F. Divisor 3.0 keeps clean codebases in A/B range.
+  const value = Math.max(0, Math.round(100 * Math.exp(-perFilePenalty / 3)));
+  let grade;
+  if (value >= 90) grade = 'A';
+  else if (value >= 75) grade = 'B';
+  else if (value >= 60) grade = 'C';
+  else if (value >= 40) grade = 'D';
+  else grade = 'F';
+
+  return {
+    value,
+    grade,
+    total: findings.length,
+    counts,
+    byRule,
+    fileCount,
+    perFilePenalty: +perFilePenalty.toFixed(2),
+  };
+}

package/templates/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: slopfighter
+description: Detect and clean AI-generated code slop (padding comments, useless try/catch, dead imports, explicit any, premature abstractions, commented-out code, unnecessary async, and more) in JS/TS code. Use after a set of edits or before committing.
+---
+
+# slopfighter
+
+You are using **slopfighter**, an anti-AI-slop linter that catches the structural bloat patterns LLMs love to generate.
+
+## When to run
+
+- After completing a chunk of code generation (≥3 edits to one file, or any new file).
+- Before staging changes for a commit.
+- When the user says "clean this up", "remove the slop", "tighten this".
+- Whenever the user explicitly invokes you.
+
+## How to run
+
+```
+npx slopfighter scan <path>           # human-readable report
+npx slopfighter score <path> --json   # just the score (0-100), useful in checks
+npx slopfighter fix <path> --safe     # apply unambiguous fixes (e.g. drop padding comments)
+```
+
+Default to scanning the files you just touched, not the whole repo. For a fresh module, scan its directory.
+
+## How to act on findings
+
+1. **`warn` severity**: surface to the user with the rule id and a one-line fix suggestion. Don't silently rewrite — these need judgement.
+2. **`info` severity**: mention briefly but don't make it the headline.
+3. **fixable findings** (auto-fix safe): run `npx slopfighter fix <path> --safe` after confirming with user, then re-scan.
+4. **score < 60**: treat as a fail. Don't hand the work back to the user as "done" — list the top 3 issues and ask whether to fix.
+
+## What the rules mean (cheat-sheet)
+
+| Rule | Why it matters |
+|---|---|
+| `padding-comments` | Comments restating the function name add noise, not info. |
+| `useless-try-catch` | Logging-then-rethrowing spams; pure rethrow is dead code. |
+| `dead-imports` | Unused imports = stale context; often a sign of half-finished refactor. |
+| `explicit-any` | `any` defeats TS; either pick a real type or use `unknown`. |
+| `future-proof-naming` | `XManager`/`XHelper` with one method is just a function. |
+| `commented-out-code` | "Let me also try" leftovers — either remove or restore. |
+| `unnecessary-async` | `async` with no `await` adds a microtask for nothing. |
+| `trivial-arrow-wrapper` | `(x) => fn(x)` is just `fn`. |
+| `redundant-await` | `return await x` outside try/catch is a wasted frame. |
+| `return-undefined` | `return undefined` is bare `return`. |
+| `redundant-error-rethrow` | `throw new Error(e.message)` destroys the stack. |
+| `excessive-jsdoc` | 8-line JSDoc on a 2-line body is padding. |
+| `over-defensive-null-check` | Triple-checking the same var is one check. |
+| `always-true-conditional` | `if (true)` / `if (x === x)` is dead branching. |
+| `single-method-class` | One method that doesn't use `this` → make it a function. |
+
+## Output format
+
+When you report findings to the user, prefer this shape:
+
+```
+slopfighter scan: <score>/100 (<grade>) — N findings in M files
+
+Top issues:
+  src/foo.ts:42  [warn] padding-comments: "Get user name" just restates "getUserName"
+  src/bar.ts:18  [warn] explicit-any: avoid `any` — pick a real type
+  ...
+```
+
+Don't dump the full report verbatim — summarize, then offer "want me to fix the auto-fixable ones?"

package/templates/agents-section.md

@@ -0,0 +1,7 @@
+<!-- slopfighter:start — do not edit between markers, regenerated by `npx slopfighter install` -->
+## Code quality (slopfighter)
+
+After editing code, run `npx slopfighter scan <changed-paths>`. Treat score < 60 as a failed change — surface top warnings to the user before declaring done. Use `npx slopfighter fix --safe` for auto-fixable items only after confirming.
+
+Rules covered: padding-comments, useless-try-catch, dead-imports, explicit-any, future-proof-naming, commented-out-code, unnecessary-async, trivial-arrow-wrapper, redundant-await, return-undefined, redundant-error-rethrow, excessive-jsdoc, over-defensive-null-check, always-true-conditional, single-method-class.
+<!-- slopfighter:end -->

package/templates/cursor-command.md

@@ -0,0 +1,23 @@
+# /slopfighter
+
+Run `npx slopfighter scan .` on the current workspace. Summarize the score, the top 3 findings (rule id + file:line + one-line fix), and ask whether to auto-fix.
+
+If the user says yes to auto-fix, run `npx slopfighter fix . --safe` then re-scan. Surface anything that's still warn-level after the fix pass.
+
+Rules cheat-sheet:
+
+- `padding-comments` — comments restating the function name
+- `useless-try-catch` — rethrow-only or log-then-rethrow
+- `dead-imports` — unused imports
+- `explicit-any` — `any` annotations
+- `future-proof-naming` — `XManager`/`XHelper` with one method
+- `commented-out-code` — old code blocks left in
+- `unnecessary-async` — `async` with no `await`
+- `trivial-arrow-wrapper` — `(x) => fn(x)` instead of `fn`
+- `redundant-await` — `return await x` outside try
+- `return-undefined` — `return undefined` instead of bare `return`
+- `redundant-error-rethrow` — `throw new Error(e.message)`
+- `excessive-jsdoc` — JSDoc longer than the body
+- `over-defensive-null-check` — triple null-checks
+- `always-true-conditional` — `if (true)` / `if (x === x)`
+- `single-method-class` — single-method class without `this`