Comment Checker

// Initialize variables
const count = 0

// Helper function to calculate sum
function add(a: number, b: number): number {
  return a + b
}

// This function does X
function doSomething() { ... }

// src/hooks/comment-checker/hook.ts
export function createCommentCheckerHooks(config?: CommentCheckerConfig) {
  return {
    'tool.execute.before': async (input, output) => {
      // Register pending call for Write/Edit/MultiEdit
      if (toolName === "write" || toolName === "edit" || toolName === "multiedit") {
        registerPendingCall(input.callID, {
          filePath,
          content,
          oldString,
          newString,
          edits,
          tool: toolName,
          sessionID: input.sessionID,
          timestamp: Date.now(),
        })
      }
    },

    'tool.execute.after': async (input, output) => {
      // Check for AI-generated comments
      const pendingCall = takePendingCall(input.callID)
      if (pendingCall) {
        await processWithCli(input, pendingCall, output, cliPath, config?.custom_prompt)
      }
    }
  }
}

// src/hooks/comment-checker/hook.ts:119
if (toolName === "apply_patch") {
  const parsed = ApplyPatchMetadataSchema.safeParse(output.metadata)
  if (parsed.success) {
    const edits = parsed.data.files
      .filter((f) => f.type !== "delete")
      .map((f) => ({
        filePath: f.movePath ?? f.filePath,
        before: f.before,
        after: f.after,
      }))
    await processApplyPatchEditsWithCli(...)
  }
}

// ❌ Detected as slop
// Initialize variables
// Set up the state
// Define constants

// ✅ Allowed (specific context)
// Memoize expensive calculation to avoid re-renders

// ❌ Detected as slop
// Helper function to...
// Utility function for...
// Function to calculate...

// ✅ Allowed (explains why/when)
// Optimized for large datasets using binary search

// ❌ Detected as slop
// This function does X
// This class handles Y
// Returns the result

// ✅ Allowed (non-obvious behavior)
// Returns null instead of throwing to support optional chaining

// Initialize CLI (downloads if needed)
initializeCommentCheckerCli(debugLog)

// Process file content
await processWithCli(
  input,
  pendingCall,
  output,
  cliPath,
  customPrompt,
  debugLog
)

{
  "disabled_hooks": [
    "comment-checker"  // Disable slop prevention
  ]
}

{
  "comment_checker": {
    "custom_prompt": "Avoid generic comments. Explain the WHY, not the WHAT."
  }
}

export const CommentCheckerConfigSchema = z.object({
  custom_prompt: z.string().optional(),
})

// Before (normal Write result)
{
  title: "File written",
  output: "Successfully wrote to /path/to/file.ts"
}

// After (slop detected)
{
  title: "File written",
  output: "Successfully wrote to /path/to/file.ts\n\n" +
          "⚠️  AI-GENERATED COMMENT DETECTED\n" +
          "Generic comments found on lines: 5, 12, 23\n" +
          "Please rewrite without:\n" +
          "  - 'Initialize variables'\n" +
          "  - 'Helper function to...'\n" +
          "  - 'This function does X'"
}

const pendingCalls = new Map<string, PendingCall>()

// Register in tool.execute.before
registerPendingCall(callID, {
  filePath: "/path/to/file.ts",
  content: "...",
  tool: "write",
  sessionID,
  timestamp: Date.now(),
})

// Retrieve in tool.execute.after
const call = takePendingCall(callID)

// src/hooks/comment-checker/pending-calls.ts
startPendingCallCleanup()  // Runs every 30s

COMMENT_CHECKER_DEBUG=1 opencode

// src/hooks/comment-checker/hook.ts:19
const DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1"
const DEBUG_FILE = join(tmpdir(), "comment-checker-debug.log")

function debugLog(...args: unknown[]) {
  if (DEBUG) {
    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args
      .map((a) => (typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)))
      .join(" ")}\n`
    fs.appendFileSync(DEBUG_FILE, msg)
  }
}

packages/comment-checker/
├── src/
│   ├── cli.ts           # CLI entry point
│   ├── detector.ts      # AST-based pattern detection
│   ├── patterns.ts      # Slop patterns
│   └── parser.ts        # Language parsers
├── bin/
│   ├── darwin-arm64     # macOS Apple Silicon
│   ├── darwin-x64       # macOS Intel
│   ├── linux-x64        # Linux x64
│   └── win32-x64.exe    # Windows x64
└── package.json

// src/hooks/comment-checker/hook.ts:95
const outputLower = (output.output ?? "").toLowerCase()
const isToolFailure =
  outputLower.includes("error:") ||
  outputLower.includes("failed to") ||
  outputLower.includes("could not") ||
  outputLower.startsWith("error")

if (isToolFailure) {
  debugLog("skipping due to tool failure in output")
  return
}

## Anti-Patterns (NEVER)

- Never use emojis in code/comments unless user explicitly asks
- Never add AI-generated comment patterns (enforced by comment-checker hook)
- Comments: avoid AI-generated comment patterns