@reidbuilds/slop 0.2.0

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git init *)",
+      "Bash(git add *)",
+      "Bash(git commit *)",
+      "Bash(gh auth *)",
+      "Bash(gh repo *)"
+    ]
+  }
+}

package/.firebaserc

@@ -0,0 +1,5 @@
+{
+  "projects": {
+    "default": "slopindex-c5a0c"
+  }
+}

package/README.md

@@ -0,0 +1,73 @@
+# Slop
+
+Catch AI-generated code anti-patterns before they ship.
+
+## Install
+
+```bash
+npm install -g slopcheck
+```
+
+Or run locally:
+
+```bash
+npm install
+node cli/index.js check ./src
+```
+
+## Usage
+
+```bash
+# Scan a single file
+slop check ./src/api/orders.js
+
+# Scan a directory
+slop check ./src
+
+# Filter by severity
+slop check ./src --severity high
+
+# Save a markdown report
+slop check ./src --output slop-report.md
+
+# Raw JSON output (for CI/scripts)
+slop check ./src --json
+
+# List all patterns in the SlopIndex
+slop patterns
+```
+
+## Setup
+
+Requires an `ANTHROPIC_API_KEY` environment variable.
+
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+```
+
+Or add to a `.env` file (use dotenv or set in your shell profile).
+
+## The SlopIndex
+
+The pattern library lives in `/slop-index/patterns/`. Each `.md` file is one anti-pattern with:
+
+- What it looks like
+- Why AI generates it
+- How to catch it
+- How to fix it
+
+The library grows over time. Contributions welcome.
+
+## Exit Codes
+
+- `0` — No high severity issues found
+- `1` — One or more high severity issues found (useful for CI blocking)
+
+## Roadmap
+
+- [ ] npm publish
+- [ ] GitHub Action
+- [ ] Pre-commit hook
+- [ ] Pattern auto-discovery from repo mining
+- [ ] Self-updating SlopIndex
+- [ ] VS Code extension

package/cli/analyzer.js

@@ -0,0 +1,150 @@
+import { readFileSync, readdirSync, appendFileSync } from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const PATTERNS_DIR = path.join(__dirname, '../slop-index/patterns')
+
+export function loadPatterns() {
+  const files = readdirSync(PATTERNS_DIR).filter(f => f.endsWith('.md'))
+  return files.map(f => ({
+    filename: f,
+    content: readFileSync(path.join(PATTERNS_DIR, f), 'utf-8')
+  }))
+}
+
+export async function analyzeFile(codeFile, patterns, options = {}) {
+  const patternText = patterns.map(p => p.content).join('\n\n---\n\n')
+
+  const MAX_CHARS = 6000
+  const code = codeFile.content.length > MAX_CHARS
+    ? codeFile.content.slice(0, MAX_CHARS) + '\n... [truncated]'
+    : codeFile.content
+
+  const prompt = `You are an expert code reviewer specializing in detecting AI-generated code anti-patterns.
+
+You have the following pattern library. Each pattern describes a specific mistake AI code generators make repeatedly.
+
+PATTERN LIBRARY:
+${patternText}
+
+---
+
+TASK:
+Analyze the code below and identify every instance of a pattern match. Be precise — flag real issues only, not style preferences.
+
+FILE: ${codeFile.filename}
+LINES: ${codeFile.lines}
+
+\`\`\`
+${code}
+\`\`\`
+
+Return ONLY a valid JSON object with this exact structure. No preamble, no explanation outside the JSON:
+
+{
+  "file": "${codeFile.filename}",
+  "flags": [
+    {
+      "pattern_id": "001",
+      "pattern_name": "hallucinated-imports",
+      "severity": "high",
+      "line_start": 1,
+      "line_end": 1,
+      "code_snippet": "the exact problematic code",
+      "explanation": "why this is a problem in this specific context",
+      "fix": "concrete fix for this specific instance"
+    }
+  ],
+  "summary": {
+    "total": 0,
+    "high": 0,
+    "medium": 0,
+    "low": 0
+  }
+}`
+
+  const severityFilter = options.severity
+  let response
+
+  try {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': process.env.ANTHROPIC_API_KEY,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: 'claude-sonnet-4-20250514',
+        max_tokens: 4096,
+        messages: [{ role: 'user', content: prompt }]
+      })
+    })
+    response = await res.json()
+    const raw = response.content[0].text.trim()
+    const clean = raw.replace(/^```json\n?/, '').replace(/\n?```$/, '').trim()
+    const result = JSON.parse(clean)
+
+    if (severityFilter) {
+      result.flags = result.flags.filter(f => f.severity === severityFilter)
+      result.summary = computeSummary(result.flags)
+    }
+
+    for (const flag of result.flags) {
+      logCatch(flag, codeFile.filename)
+      syncCatch(flag, codeFile.extension)
+    }
+
+    await delay(500)
+    return result
+  } catch (err) {
+    console.error('API response:', response ?? '(no response captured)')
+    await delay(500)
+    return {
+      file: codeFile.filename,
+      error: `Analysis failed: ${err.message}`,
+      flags: [],
+      summary: { total: 0, high: 0, medium: 0, low: 0 }
+    }
+  }
+}
+
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+const CATCHES_FILE = path.join(__dirname, '../slop-index/catches.jsonl')
+
+export function logCatch(flag, filename) {
+  const entry = JSON.stringify({
+    filename: path.basename(filename),
+    pattern_id: flag.pattern_id,
+    pattern_name: flag.pattern_name,
+    severity: flag.severity,
+    timestamp: new Date().toISOString()
+  })
+  appendFileSync(CATCHES_FILE, entry + '\n')
+}
+
+const SYNC_URL = 'https://slopsync-vktctiuffa-uc.a.run.app'
+
+function syncCatch(flag, extension) {
+  fetch(SYNC_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      pattern_id: flag.pattern_id,
+      severity: flag.severity,
+      language: extension ? extension.replace('.', '') : null,
+      timestamp: new Date().toISOString()
+    })
+  }).catch(() => {})
+}
+
+function computeSummary(flags) {
+  return {
+    total: flags.length,
+    high: flags.filter(f => f.severity === 'high').length,
+    medium: flags.filter(f => f.severity === 'medium').length,
+    low: flags.filter(f => f.severity === 'low').length
+  }
+}

package/cli/index.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { scanTarget } from './scanner.js'
+import { loadPatterns, analyzeFile } from './analyzer.js'
+import { printResults } from './reporter.js'
+import { runLearn } from './learner.js'
+
+const program = new Command()
+
+program
+  .name('slop')
+  .description('Catch AI-generated code anti-patterns before they ship')
+  .version('0.2.0')
+
+program
+  .command('check <target>')
+  .description('Scan a file or directory for slop patterns')
+  .option('-o, --output <file>', 'Save report to a markdown file')
+  .option('-s, --severity <level>', 'Filter by severity: high | medium | low')
+  .option('-r, --no-recursive', 'Do not scan subdirectories')
+  .option('--json', 'Output raw JSON')
+  .action(async (target, options) => {
+    console.log(chalk.gray(`\n  slop check ${target}\n`))
+
+    let files
+    try {
+      files = await scanTarget(target, { recursive: options.recursive })
+      files = files.filter(Boolean)
+    } catch (err) {
+      console.error(chalk.red(`  Error: ${err.message}`))
+      process.exit(1)
+    }
+
+    if (files.length === 0) {
+      console.log(chalk.yellow('  No supported files found.'))
+      process.exit(0)
+    }
+
+    if (!options.json) {
+      console.log(chalk.gray(`  Loading pattern library...`))
+    }
+
+    let patterns
+    try {
+      patterns = loadPatterns()
+    } catch (err) {
+      console.error(chalk.red(`  Failed to load patterns: ${err.message}`))
+      process.exit(1)
+    }
+
+    if (!options.json) {
+      console.log(chalk.gray(`  ${patterns.length} patterns loaded · scanning ${files.length} file${files.length !== 1 ? 's' : ''}...\n`))
+    }
+
+    const results = []
+    for (const file of files) {
+      if (!options.json) {
+        process.stdout.write(chalk.gray(`  Analyzing ${file.filename}...`))
+      }
+      const result = await analyzeFile(file, patterns, { severity: options.severity })
+      if (!options.json) {
+        process.stdout.write('\r' + ' '.repeat(50) + '\r')
+      }
+      results.push(result)
+    }
+
+    printResults(results, {
+      json: options.json,
+      output: options.output
+    })
+
+    if (!options.json) {
+      try {
+        const learned = await runLearn()
+        if (!learned.error && learned.proposed.length > 0) {
+          console.log(chalk.gray(`  ${learned.proposed.length} new pattern${learned.proposed.length !== 1 ? 's' : ''} proposed → slop-index/proposed/`))
+        }
+      } catch {
+        // learn errors are non-fatal
+      }
+    }
+
+    const totalHigh = results.reduce((n, r) => n + (r.summary?.high || 0), 0)
+    process.exit(totalHigh > 0 ? 1 : 0)
+  })
+
+program
+  .command('learn')
+  .description('Analyze catch history and propose new patterns')
+  .action(async () => {
+    console.log(chalk.gray('\n  slop learn\n'))
+    console.log(chalk.gray('  Reading catch history...'))
+
+    try {
+      const result = await runLearn()
+
+      if (result.error) {
+        console.log(chalk.yellow(`  ${result.error}`))
+        process.exit(0)
+      }
+
+      if (result.proposed.length === 0) {
+        console.log(chalk.gray('  No new patterns proposed.\n'))
+      } else {
+        console.log(chalk.green(`\n  ${result.proposed.length} new pattern${result.proposed.length !== 1 ? 's' : ''} proposed:\n`))
+        for (const f of result.proposed) {
+          console.log(`    ${chalk.white(f)}`)
+        }
+        console.log(chalk.gray('\n  Review in slop-index/proposed/'))
+        console.log(chalk.gray('  Move to slop-index/patterns/ to activate.\n'))
+      }
+    } catch (err) {
+      console.error(chalk.red(`  Learn failed: ${err.message}`))
+      process.exit(1)
+    }
+  })
+
+program
+  .command('update')
+  .description('Pull community patterns from SlopIndex')
+  .action(async () => {
+    console.log(chalk.gray('\n  slop update\n'))
+
+    let community
+    try {
+      const res = await fetch('https://us-central1-slopindex-c5a0c.cloudfunctions.net/slopPatterns')
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      community = await res.json()
+    } catch (err) {
+      console.error(chalk.red(`  Failed to fetch community patterns: ${err.message}`))
+      process.exit(1)
+    }
+
+    const { readdirSync, writeFileSync } = await import('fs')
+    const { default: nodePath } = await import('path')
+    const { fileURLToPath: ftu } = await import('url')
+    const patternsDir = nodePath.join(nodePath.dirname(ftu(import.meta.url)), '../slop-index/patterns')
+
+    const existing = new Set(readdirSync(patternsDir).map(f => f.replace('.md', '')))
+
+    let added = 0
+    for (const pattern of community) {
+      const slug = pattern.name ?? pattern.id
+      const filename = `${String(pattern.id ?? slug).padStart(3, '0')}-${slug}.md`
+      if (existing.has(filename.replace('.md', ''))) continue
+      writeFileSync(nodePath.join(patternsDir, filename), pattern.content ?? '')
+      added++
+    }
+
+    if (added === 0) {
+      console.log(chalk.gray('  Already up to date.\n'))
+    } else {
+      console.log(chalk.green(`  ${added} new pattern${added !== 1 ? 's' : ''} added to slop-index/patterns/\n`))
+    }
+  })
+
+program
+  .command('patterns')
+  .description('List all patterns in the SlopIndex')
+  .action(() => {
+    const patterns = loadPatterns()
+    console.log(chalk.white.bold(`\n  SlopIndex — ${patterns.length} patterns\n`))
+    for (const p of patterns) {
+      const idMatch = p.filename.match(/^(\d+)/)
+      const id = idMatch ? idMatch[1] : '?'
+      const name = p.filename.replace(/^\d+-/, '').replace('.md', '')
+      const severityMatch = p.content.match(/^severity:\s*(\w+)/m)
+      const severity = severityMatch ? severityMatch[1] : 'unknown'
+      const color = SEVERITY_COLOR[severity] || chalk.white
+      console.log(`  ${chalk.gray(id)}  ${name.padEnd(35)} ${color(severity)}`)
+    }
+    console.log('')
+  })
+
+const SEVERITY_COLOR = {
+  high: chalk.red,
+  medium: chalk.yellow,
+  low: chalk.blue
+}
+
+program.parse()

package/cli/learner.js

@@ -0,0 +1,156 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync } from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CATCHES_FILE = path.join(__dirname, '../slop-index/catches.jsonl')
+const PATTERNS_DIR = path.join(__dirname, '../slop-index/patterns')
+const PROPOSED_DIR = path.join(__dirname, '../slop-index/proposed')
+
+export async function runLearn() {
+  if (!existsSync(CATCHES_FILE)) {
+    return { error: 'No catches.jsonl found. Run `slop check` first.' }
+  }
+
+  const lines = readFileSync(CATCHES_FILE, 'utf-8').trim().split('\n').filter(Boolean)
+  if (lines.length === 0) {
+    return { error: 'catches.jsonl is empty. Run `slop check` first.' }
+  }
+
+  const catches = lines.map(l => JSON.parse(l))
+
+  const grouped = {}
+  for (const c of catches) {
+    if (!grouped[c.pattern_id]) {
+      grouped[c.pattern_id] = { pattern_id: c.pattern_id, pattern_name: c.pattern_name, count: 0, examples: [] }
+    }
+    grouped[c.pattern_id].count++
+    if (grouped[c.pattern_id].examples.length < 5 && c.code_snippet) {
+      grouped[c.pattern_id].examples.push({
+        filename: c.filename,
+        code_snippet: c.code_snippet,
+        explanation: c.explanation
+      })
+    }
+  }
+
+  if (!existsSync(PROPOSED_DIR)) mkdirSync(PROPOSED_DIR, { recursive: true })
+
+  const existingNames = [
+    ...readdirSync(PATTERNS_DIR).filter(f => f.endsWith('.md')),
+    ...readdirSync(PROPOSED_DIR).filter(f => f.endsWith('.md'))
+  ].map(f => f.replace(/^\d+-/, '').replace('.md', ''))
+
+  const catchSummary = Object.values(grouped)
+    .sort((a, b) => b.count - a.count)
+    .map(g => {
+      const examples = g.examples.map(e =>
+        `  - file: ${e.filename}\n    code: ${e.code_snippet}\n    why: ${e.explanation}`
+      ).join('\n')
+      return `pattern ${g.pattern_id} (${g.pattern_name ?? 'unknown'}): ${g.count} catch${g.count !== 1 ? 'es' : ''}\n${examples}`
+    })
+    .join('\n\n')
+
+  const prompt = `You are a code quality expert analyzing real catch data from an AI-generated code detector.
+
+EXISTING PATTERNS — do not re-propose these:
+${existingNames.join(', ')}
+
+CATCH DATA — real code flagged across user codebases:
+${catchSummary}
+
+Identify NEW anti-patterns not yet in the library. Look for: variants of existing patterns that deserve their own entry, new patterns visible in the code snippets, and cross-cutting issues suggested by file contexts.
+
+Return a JSON array. Each element must have exactly these keys:
+- "name": kebab-case slug
+- "severity": "high" | "medium" | "low"
+- "languages": string[]
+- "tags": string[]
+- "description": string (one paragraph)
+- "example_code": string (realistic bad code)
+- "why_ai_does_this": string (one paragraph)
+- "catch_signals": string[] (3-5 items)
+- "fix_example": string (realistic fixed code)
+- "severity_rationale": string (one sentence)
+
+Return ONLY valid JSON. No preamble, no explanation outside the array.`
+
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': process.env.ANTHROPIC_API_KEY,
+      'anthropic-version': '2023-06-01'
+    },
+    body: JSON.stringify({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 4096,
+      messages: [{ role: 'user', content: prompt }]
+    })
+  })
+
+  const response = await res.json()
+  const raw = response.content[0].text.trim()
+  const clean = raw.replace(/^```json\n?/, '').replace(/\n?```$/, '').trim()
+  const proposed = JSON.parse(clean)
+
+  const allFiles = [
+    ...readdirSync(PATTERNS_DIR).filter(f => f.endsWith('.md')),
+    ...readdirSync(PROPOSED_DIR).filter(f => f.endsWith('.md'))
+  ]
+  const maxId = allFiles.reduce((max, f) => {
+    const m = f.match(/^(\d+)/)
+    return m ? Math.max(max, parseInt(m[1], 10)) : max
+  }, 0)
+
+  const saved = []
+  proposed.forEach((p, i) => {
+    const id = String(maxId + i + 1).padStart(3, '0')
+    const filename = `${id}-${p.name}.md`
+    writeFileSync(path.join(PROPOSED_DIR, filename), formatPattern(id, p))
+    saved.push(filename)
+  })
+
+  return { proposed: saved }
+}
+
+function formatPattern(id, p) {
+  const today = new Date().toISOString().split('T')[0]
+  return `---
+id: ${id}
+name: ${p.name}
+severity: ${p.severity}
+languages: [${p.languages.join(', ')}]
+tags: [${p.tags.join(', ')}]
+added: ${today}
+---
+
+# Pattern: ${titleCase(p.name)}
+
+## Description
+${p.description}
+
+## What It Looks Like
+\`\`\`
+${p.example_code}
+\`\`\`
+
+## Why AI Does This
+${p.why_ai_does_this}
+
+## Catch Signal
+${p.catch_signals.map(s => `- ${s}`).join('\n')}
+
+## Fix Template
+\`\`\`
+${p.fix_example}
+\`\`\`
+
+## Severity Rationale
+${p.severity} — ${p.severity_rationale}
+`
+}
+
+function titleCase(slug) {
+  return slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+}

package/cli/reporter.js

@@ -0,0 +1,126 @@
+import chalk from 'chalk'
+import { writeFileSync } from 'fs'
+
+const SEVERITY_COLOR = {
+  high: chalk.red.bold,
+  medium: chalk.yellow.bold,
+  low: chalk.blue
+}
+
+const SEVERITY_ICON = {
+  high: '✗',
+  medium: '⚠',
+  low: '◦'
+}
+
+export function printResults(results, options = {}) {
+  const allFlags = results.flatMap(r => r.flags || [])
+  const errors = results.filter(r => r.error)
+
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2))
+    return
+  }
+
+  console.log('')
+
+  for (const result of results) {
+    if (result.error) {
+      console.log(chalk.red(`  Error scanning ${result.file}: ${result.error}`))
+      continue
+    }
+
+    if (result.flags.length === 0) {
+      console.log(chalk.green(`  ✓ ${result.file} — clean`))
+      continue
+    }
+
+    console.log(chalk.white.bold(`  ${result.file}`))
+
+    for (const flag of result.flags) {
+      const colorFn = SEVERITY_COLOR[flag.severity] || chalk.white
+      const icon = SEVERITY_ICON[flag.severity] || '?'
+
+      console.log('')
+      console.log(`    ${colorFn(`${icon} [${flag.severity.toUpperCase()}]`)} ${chalk.white(flag.pattern_name)} ${chalk.gray(`(line ${flag.line_start}${flag.line_end !== flag.line_start ? `-${flag.line_end}` : ''})`)
+}`)
+      console.log(`    ${chalk.gray('Code:')}    ${chalk.dim(truncate(flag.code_snippet, 80))}`)
+      console.log(`    ${chalk.gray('Issue:')}   ${flag.explanation}`)
+      console.log(`    ${chalk.gray('Fix:')}     ${chalk.cyan(flag.fix)}`)
+    }
+
+    console.log('')
+  }
+
+  printSummary(results)
+
+  if (options.output) {
+    const md = buildMarkdownReport(results)
+    writeFileSync(options.output, md)
+    console.log(chalk.gray(`  Report saved to ${options.output}`))
+  }
+}
+
+function printSummary(results) {
+  const total = results.reduce((n, r) => n + (r.summary?.total || 0), 0)
+  const high = results.reduce((n, r) => n + (r.summary?.high || 0), 0)
+  const medium = results.reduce((n, r) => n + (r.summary?.medium || 0), 0)
+  const low = results.reduce((n, r) => n + (r.summary?.low || 0), 0)
+  const filesScanned = results.length
+  const filesClean = results.filter(r => r.flags?.length === 0 && !r.error).length
+
+  console.log(chalk.gray('  ─────────────────────────────'))
+  console.log(`  ${chalk.white.bold('Summary')}  ${chalk.gray(`${filesScanned} file${filesScanned !== 1 ? 's' : ''} scanned · ${filesClean} clean`)}`)
+  console.log('')
+
+  if (total === 0) {
+    console.log(chalk.green('  No slop detected.'))
+  } else {
+    const parts = []
+    if (high) parts.push(chalk.red.bold(`${high} high`))
+    if (medium) parts.push(chalk.yellow.bold(`${medium} medium`))
+    if (low) parts.push(chalk.blue(`${low} low`))
+    console.log(`  ${chalk.white.bold(total + ' flags')}   ${parts.join(chalk.gray('  ·  '))}`)
+  }
+
+  console.log('')
+}
+
+function buildMarkdownReport(results) {
+  const lines = ['# Slop Report\n']
+  const date = new Date().toISOString().split('T')[0]
+  lines.push(`Generated: ${date}\n`)
+
+  for (const result of results) {
+    lines.push(`## ${result.file}\n`)
+    if (result.error) {
+      lines.push(`> Error: ${result.error}\n`)
+      continue
+    }
+    if (result.flags.length === 0) {
+      lines.push('✓ Clean\n')
+      continue
+    }
+    for (const flag of result.flags) {
+      lines.push(`### [${flag.severity.toUpperCase()}] ${flag.pattern_name} — line ${flag.line_start}\n`)
+      lines.push(`**Code:** \`${flag.code_snippet}\`\n`)
+      lines.push(`**Issue:** ${flag.explanation}\n`)
+      lines.push(`**Fix:** ${flag.fix}\n`)
+    }
+  }
+
+  const total = results.reduce((n, r) => n + (r.summary?.total || 0), 0)
+  const high = results.reduce((n, r) => n + (r.summary?.high || 0), 0)
+  const medium = results.reduce((n, r) => n + (r.summary?.medium || 0), 0)
+  const low = results.reduce((n, r) => n + (r.summary?.low || 0), 0)
+
+  lines.push(`## Summary\n`)
+  lines.push(`| Severity | Count |\n|---|---|\n| High | ${high} |\n| Medium | ${medium} |\n| Low | ${low} |\n| **Total** | **${total}** |\n`)
+
+  return lines.join('\n')
+}
+
+function truncate(str, max) {
+  if (!str) return ''
+  return str.length > max ? str.slice(0, max) + '…' : str
+}