cold-shower 2.0.0

package/hooks/gate.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// PreToolUse hook — two jobs:
+//   Job 1 (Plan-gate): Block edit tools until a plan is approved via .plan-gate/APPROVED.
+//   Job 2 (Anti-regression): Warn when a file being edited is listed in brain/avoid.md.
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit'])
+
+const PLAN_GATE_BLOCK = `PLAN-GATE: No approved plan found.
+
+Cold-shower requires a plan before editing files.
+Claude should generate the implementation plan first, then ask the user to type APPROVED.
+
+To skip plan-gate for this change: delete .plan-gate/ACTIVE`
+
+function encodeCwd(cwd) {
+  // /Users/pradipt/Code/hukumai → Users-pradipt-Code-hukumai
+  return cwd.replace(/^\//, '').replace(/\//g, '-')
+}
+
+function fileExists(p) {
+  try { return fs.existsSync(p) } catch { return false }
+}
+
+function readFile(p) {
+  try { return fs.readFileSync(p, 'utf8') } catch { return null }
+}
+
+// Parse avoid.md for file paths.
+// Looks for:
+//   - Lines that start with a path-like token (starts with / or ./ or contains /)
+//   - Lines that contain backtick-wrapped paths: `path/to/file`
+// Returns array of { filePath, reason } objects.
+function parseAvoidMd(content) {
+  const entries = []
+  const lines = content.split('\n')
+
+  // Group lines: a "path line" followed by subsequent non-path lines form one entry.
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+
+    // Check for backtick path(s) anywhere on the line
+    const backtickMatches = [...line.matchAll(/`([^`]+)`/g)]
+    const backtickPaths = backtickMatches
+      .map(m => m[1])
+      .filter(p => p.includes('/') || p.endsWith('.js') || p.endsWith('.ts') ||
+                   p.endsWith('.py') || p.endsWith('.rb') || p.endsWith('.go') ||
+                   p.endsWith('.rs') || p.endsWith('.java') || p.endsWith('.kt') ||
+                   p.endsWith('.swift') || p.endsWith('.cs') || p.endsWith('.tsx') ||
+                   p.endsWith('.jsx') || p.endsWith('.vue') || p.endsWith('.php'))
+
+    if (backtickPaths.length > 0) {
+      // Treat rest of line (after the backtick) as reason
+      const reason = line.replace(/`[^`]+`/g, '').replace(/^[\s\-*#:]+/, '').trim() || line.trim()
+      for (const fp of backtickPaths) {
+        entries.push({ filePath: fp, reason: reason || line.trim() })
+      }
+      i++
+      continue
+    }
+
+    // Check for a line that starts like a path
+    const trimmed = line.trim()
+    const pathMatch = trimmed.match(/^([\/.]?[^\s]+\.[a-zA-Z0-9]{1,10})(\s+(.*))?$/)
+    if (pathMatch && (pathMatch[1].includes('/') || pathMatch[1].startsWith('.'))) {
+      const fp = pathMatch[1]
+      let reason = (pathMatch[3] || '').trim()
+      // Gather following indented lines as part of reason
+      let j = i + 1
+      while (j < lines.length) {
+        const next = lines[j]
+        if (next.match(/^\s+\S/) || next.match(/^[>*\-]\s/)) {
+          if (!reason) reason = next.trim()
+          j++
+        } else {
+          break
+        }
+      }
+      entries.push({ filePath: fp, reason: reason || trimmed })
+      i = j
+      continue
+    }
+
+    i++
+  }
+
+  return entries
+}
+
+// Returns a warning string if filePath matches any avoid entry, otherwise null.
+function checkAvoid(filePath, avoidEntries) {
+  if (!filePath) return null
+  const basename = path.basename(filePath)
+  const normalised = filePath.replace(/\\/g, '/')
+
+  for (const entry of avoidEntries) {
+    const ep = entry.filePath.replace(/\\/g, '/')
+    const epBasename = path.basename(ep)
+
+    // Match on full path suffix, basename, or exact match
+    if (
+      normalised.endsWith(ep) ||
+      normalised === ep ||
+      (epBasename && basename === epBasename && epBasename.length > 3) ||
+      normalised.includes(ep)
+    ) {
+      const reason = entry.reason || '(no reason given)'
+      return `RECALL WARNING: ${basename} is marked fragile in recall memory. Reason: ${reason}. Proceed carefully.`
+    }
+  }
+
+  return null
+}
+
+function main(data) {
+  const toolName = data.tool_name || ''
+  const toolInput = data.tool_input || {}
+
+  if (!EDIT_TOOLS.has(toolName)) {
+    // Not an edit tool — nothing to do
+    process.exit(0)
+  }
+
+  const cwd = process.cwd()
+  const filePath = toolInput.file_path || toolInput.path || ''
+
+  // ── Job 1: Plan-gate ──────────────────────────────────────────────────────
+  const activePath = path.join(cwd, '.plan-gate', 'ACTIVE')
+  const approvedPath = path.join(cwd, '.plan-gate', 'APPROVED')
+
+  if (fileExists(activePath) && !fileExists(approvedPath)) {
+    process.stderr.write(PLAN_GATE_BLOCK + '\n')
+    process.exit(2)
+  }
+
+  // ── Job 2: Anti-regression warn ──────────────────────────────────────────
+  const encodedCwd = encodeCwd(cwd)
+  const homeDir = os.homedir()
+
+  const avoidPaths = [
+    path.join(homeDir, '.claude', 'projects', encodedCwd, 'brain', 'avoid.md'),
+    path.join(homeDir, '.claude', 'brain', 'avoid-global.md'),
+  ]
+
+  let avoidEntries = []
+  for (const ap of avoidPaths) {
+    const content = readFile(ap)
+    if (content) {
+      avoidEntries = avoidEntries.concat(parseAvoidMd(content))
+    }
+  }
+
+  if (avoidEntries.length > 0) {
+    const warning = checkAvoid(filePath, avoidEntries)
+    if (warning) {
+      process.stderr.write(warning + '\n')
+    }
+  }
+
+  // Allow the edit
+  process.exit(0)
+}
+
+// Read stdin fully, then process
+let input = ''
+process.stdin.on('data', chunk => { input += chunk })
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input)
+    main(data)
+  } catch {
+    // Silent fail — never break user session
+    process.exit(0)
+  }
+})

package/hooks/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/hooks/trigger.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+// UserPromptSubmit hook — detects cold-shower trigger phrases in the user's prompt.
+// When matched, reinforces the skill context so Claude activates it automatically.
+
+let input = ''
+process.stdin.on('data', chunk => { input += chunk })
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input)
+    const prompt = (data.prompt || '').toLowerCase()
+
+    const triggers = [
+      'cold shower', 'cold-shower',
+      'audit my codebase', 'audit my app', 'audit my project', 'audit this',
+      'is this ready to ship', 'ready to ship', 'ready to deploy', 'can i ship',
+      'reality check',
+      'something always breaks', 'always breaks when i',
+      'llm bill', 'api bill', 'openai bill', 'anthropic bill',
+      'costs too high', 'spending too much', 'api costs',
+      'is my ai secure', 'ai endpoint', 'prompt injection',
+      'clean up my deps', 'unused packages', 'too many packages', 'remove packages',
+      'app crashed', 'app is down', '500 errors', 'getting 500s',
+      'too many connections', 'database overload', 'db is slow',
+      'went viral', 'hacker news', 'product hunt', 'traffic spike',
+      'vibe code mess', 'vibe coding debt', 'my code is a mess', 'codebase is a mess',
+      'god component', 'god file', 'file is too long',
+      'circular dep', 'duplicate code', 'technical debt',
+      // Audit F — git/github/CI triggers
+      'github setup', 'ci setup', 'github actions', 'branch protection',
+      'gitignore', '.gitignore', 'secrets in git', 'env committed',
+      'no ci', 'missing ci', 'no pipeline', 'devops setup',
+      'staging environment', 'production environment', 'preview deployment',
+      'dependabot', 'unpinned actions', 'workflow security',
+      'git hygiene', 'git setup', 'repo setup', 'missing workflow',
+      // Pre-deploy gate triggers
+      'about to deploy', 'about to push', 'about to ship',
+      'pushing to prod', 'pushing to production', 'merging to main',
+      'going live', 'going to prod', 'before i push', 'before i deploy',
+      'ready to merge', 'shipping today', 'deploy today',
+      // Re-audit / score check triggers
+      're-audit', 'reaudit', 'check score', 'check my score',
+      'did score improve', 'run audit again', 'audit again',
+      // Plan-gate triggers — implementation intent
+      'implement', 'add feature', 'add endpoint', 'add support for',
+      'build this', 'create component', 'create a new', 'create the',
+      'fix this bug', 'fix the bug', 'fix the issue', 'fix the error',
+      'refactor', 'migrate', 'rewrite', 'update the', 'modify the',
+      // Recall triggers — memory commands
+      'remember this', 'remember that', 'save this', 'dont forget',
+      "don't forget", 'recall', 'what did we decide', 'brain dump',
+      '/recall', '/plan',
+    ]
+
+    const matched = triggers.some(t => prompt.includes(t))
+
+    if (!matched) return
+
+    // Detect which mode triggered
+    const planTriggers = ['implement', 'add feature', 'add endpoint', 'add support for',
+      'build this', 'create component', 'create a new', 'create the',
+      'fix this bug', 'fix the bug', 'fix the issue', 'fix the error',
+      'refactor', 'migrate', 'rewrite', 'update the', 'modify the']
+    const recallTriggers = ['remember this', 'remember that', 'save this', 'dont forget',
+      "don't forget", 'recall', 'what did we decide', 'brain dump', '/recall']
+    const auditTriggers = ['cold shower', 'cold-shower', 'audit', 'vibe score',
+      'ready to ship', 'ready to deploy', 'about to deploy', 'about to push',
+      're-audit', 'reaudit', 'check score']
+
+    const isPlan = planTriggers.some(t => prompt.includes(t))
+    const isRecall = recallTriggers.some(t => prompt.includes(t))
+    const isAudit = auditTriggers.some(t => prompt.includes(t))
+
+    // Load score history for audit mode
+    const scoreHistoryPath = require('path').join(process.cwd(), '.cold-shower', 'score-history.json')
+    let scoreHistory = []
+    try { scoreHistory = JSON.parse(require('fs').readFileSync(scoreHistoryPath, 'utf8')) } catch {}
+    const lastScore = scoreHistory.length > 0 ? scoreHistory[scoreHistory.length - 1] : null
+    const scoreContext = lastScore
+      ? `Last Vibe Score: ${lastScore.score}/100 (${lastScore.grade}) on ${lastScore.date}.`
+      : 'No previous Vibe Score.'
+
+    // Load recall memories
+    const path = require('path')
+    const os = require('os')
+    const projectName = path.basename(process.cwd())
+    const brainDir = path.join(os.homedir(), '.claude', 'brain')
+    const projectBrainDir = path.join(os.homedir(), '.claude', 'projects', projectName, 'brain')
+    let recallContext = ''
+    try {
+      const files = ['context.md', 'decisions.md', 'avoid.md', 'bugs.md']
+      const lines = []
+      for (const f of files) {
+        try {
+          const content = require('fs').readFileSync(path.join(projectBrainDir, f), 'utf8')
+          lines.push(...content.split('\n').filter(l => l.startsWith('##')).slice(0, 3))
+        } catch {}
+      }
+      if (lines.length > 0) recallContext = '\nRECALL CONTEXT:\n' + lines.slice(0, 8).join('\n')
+    } catch {}
+
+    // Create plan-gate ACTIVE marker if implementation intent
+    if (isPlan && !isAudit) {
+      try {
+        const fs = require('fs')
+        fs.mkdirSync(path.join(process.cwd(), '.plan-gate'), { recursive: true })
+        fs.writeFileSync(path.join(process.cwd(), '.plan-gate', 'ACTIVE'), new Date().toISOString())
+        // Remove any stale approval
+        try { fs.unlinkSync(path.join(process.cwd(), '.plan-gate', 'APPROVED')) } catch {}
+      } catch {}
+    }
+
+    let additionalContext = ''
+
+    if (isRecall && !isPlan && !isAudit) {
+      additionalContext = [
+        'COLD-SHOWER RECALL MODE',
+        recallContext,
+        'User wants to manage memories. Available commands:',
+        '- "remember [decision/pattern/bug/context]" → save to brain',
+        '- "what did we decide about X" → search brain files',
+        '- "show avoid list" → show fragile files',
+        '- "/recall review" → review memories older than 90 days',
+        'Brain files: ~/.claude/brain/ (global) and ~/.claude/projects/' + projectName + '/brain/ (project)',
+      ].join('\n')
+    } else if (isPlan && !isAudit) {
+      additionalContext = [
+        'COLD-SHOWER PLAN-GATE ACTIVATED',
+        recallContext,
+        'User wants to implement something. Generate a structured plan BEFORE writing any code:',
+        '',
+        '## Plan: [task name]',
+        '### Understanding — problem, definition of done, out of scope',
+        '### Files to Touch — table: file | lines | change type | reason',
+        '### Files NOT to Touch — table: file | reason (check recall avoid.md for fragile files)',
+        '### Contracts That Cannot Change — API signatures, response shapes callers depend on',
+        '### Dependency Order — numbered, which changes unlock others',
+        '### Risk Assessment — HIGH/MEDIUM/LOW with specific failure mode',
+        '### Pre-Mortem — "If this fails, most likely cause is..."',
+        '### Rollback — exact steps to undo, does it need migration rollback?',
+        '',
+        'After generating the plan: ask user "Type APPROVED to proceed with implementation."',
+        'Do NOT write any code or edit any files until user types APPROVED.',
+        'Plan-gate is active — edits are blocked until approved.',
+      ].join('\n')
+    } else {
+      // Audit mode (default)
+      additionalContext = [
+        'COLD-SHOWER SKILL ACTIVATED',
+        scoreContext,
+        recallContext,
+        'Run the audit workflow:',
+        '1. Emergency check — app actively failing? Jump to EMERGENCY MODE.',
+        '2. Phase 0: detect stack.',
+        '3. Phase 1: run audits A-F in parallel.',
+        '4. Phase 2: compute Vibe Score, write to .cold-shower/score-history.json.',
+        '5. Phase 3: ask which fix sprint. After sprint: remind user to type re-audit.',
+      ].join('\n')
+    }
+
+    process.stdout.write(JSON.stringify({ additionalContext }))
+  } catch {
+    // Silent fail — never break the user session
+  }
+})

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "cold-shower",
+  "version": "2.0.0",
+  "description": "Reality check for vibe-coded apps. 6 audits + plan-gate + second brain for Claude Code.",
+  "bin": {
+    "cold-shower": "bin/cold-shower.js"
+  },
+  "files": [
+    "bin/",
+    "skills/",
+    "hooks/",
+    ".claude-plugin/"
+  ],
+  "keywords": [
+    "claude-code",
+    "claude",
+    "skill",
+    "vibe-coding",
+    "ai",
+    "security",
+    "audit",
+    "plan-gate"
+  ],
+  "author": "PradiptaPutra",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PradiptaPutra/cold-shower.git"
+  },
+  "homepage": "https://github.com/PradiptaPutra/cold-shower",
+  "engines": {
+    "node": ">=18"
+  }
+}