@acmeacmeio/setup-sh 0.2.6

package/templates/.claude/commands/auto.md

@@ -0,0 +1,85 @@
+---
+description: Auto-detect and execute the best workflow for your request
+argument-hint: <your request in natural language>
+model: haiku
+---
+
+# Intent Router
+
+Automatically classify user intent and route to the appropriate workflow.
+
+## Available Commands
+
+List of commands in `.claude/commands/`:
+
+- `fix-issue` - Fix a GitHub issue following TDD workflow
+- `tdd` - Activate strict TDD mode
+- `review` - Run code review checklist
+- `clean-copy` - Restructure commits into clean history
+
+## Registry
+
+Reference the registry at `.claude/router/registry.yaml` for trigger patterns and chains.
+
+## Task
+
+Classify this request: **$ARGUMENTS**
+
+### Classification Process
+
+1. **Extract key intent** from the natural language request
+2. **Match against registry triggers** - find the best matching command or chain
+3. **Extract arguments** - pull out issue numbers, branch names, or other parameters
+4. **Determine confidence** - how well does this match?
+
+### Output
+
+Return a JSON object with your classification:
+
+```json
+{
+  "intent": "description of what user wants",
+  "match": {
+    "type": "command" | "chain",
+    "name": "command or chain name",
+    "confidence": 0.0-1.0
+  },
+  "args": {
+    "issue_number": "123",
+    "branch_name": "feature-x"
+  },
+  "execute": "/command-name args"
+}
+```
+
+### Confidence Guidelines
+
+- **0.9-1.0**: Exact trigger phrase match
+- **0.7-0.9**: Clear intent, slightly different wording
+- **0.5-0.7**: Probable match, some ambiguity
+- **Below 0.5**: Ask user to clarify
+
+### If Low Confidence
+
+If confidence is below 0.7, present options to the user:
+
+```
+I'm not sure which workflow you want. Did you mean:
+
+1. `/fix-issue` - Fix a GitHub issue with TDD
+2. `/tdd` - Start TDD mode
+3. `/review` - Review code changes
+
+Please choose or rephrase your request.
+```
+
+### Examples
+
+| Input                   | Match      | Confidence |
+| ----------------------- | ---------- | ---------- |
+| "fix issue #123"        | fix-issue  | 0.95       |
+| "I need to fix bug 456" | fix-issue  | 0.85       |
+| "review my changes"     | review     | 0.90       |
+| "clean up my commits"   | clean-copy | 0.85       |
+| "do tdd"                | tdd        | 0.80       |
+| "help me code"          | -          | 0.30       |

package/templates/.claude/commands/clean-copy.md

@@ -0,0 +1,93 @@
+---
+description: Reimplement branch with clean, narrative-quality commit history
+argument-hint: [new-branch-name]
+allowed-tools: Bash(git:*), Bash(gh pr create:*)
+model: opus
+is_finisher: true
+finishers: [review]
+---
+
+# Clean Copy
+
+Reimplement the current branch with clean, atomic commits suitable for reviewer comprehension.
+
+## Context
+
+Gather current state:
+
+- **Source branch**: `git branch --show-current`
+- **Git status**: `git status --short`
+- **Commits since main**: `git log main..HEAD --oneline`
+- **Diff stats**: `git diff main...HEAD --stat`
+- **Full diff**: `git diff main...HEAD`
+
+## Task
+
+Create a new branch with restructured commits that tell a clear story.
+
+**Branch name**: Use the argument if provided, otherwise `{source_branch}-clean`
+
+### Steps
+
+1. **Validate source branch**
+   - Ensure no uncommitted changes
+   - Ensure branch is up to date with main
+
+2. **Analyze the full diff**
+   - Understand the complete intended final state
+   - Identify logical units of change
+
+3. **Create clean branch from main**
+
+   ```bash
+   git checkout main
+   git pull origin main
+   git checkout -b {new_branch_name}
+   ```
+
+4. **Plan commit storyline**
+   - Break changes into self-contained logical steps
+   - Each commit should represent a single coherent idea
+   - Order commits so each builds on the previous (tutorial-style)
+   - Aim for 3-7 commits typically
+
+5. **Reimplement step-by-step**
+   For each logical unit:
+   - Apply the relevant changes
+   - Write a clear commit message following conventional commits
+   - Use `git commit --no-verify` for intermediate commits (types/tests may not pass until complete)
+
+6. **Verify final state matches source**
+
+   ```bash
+   git diff {source_branch}..HEAD
+   ```
+
+   This diff should be empty. If not, reconcile differences.
+
+7. **Final commit verification**
+   - The final commit must NOT use `--no-verify`
+   - All checks (lint, types, tests) must pass
+
+8. **Create PR**
+   - Follow project PR conventions
+   - Link to original branch or issue
+   - Use `gh pr create`
+
+### Rules
+
+- Never add "Co-Authored-By" or "Generated with Claude" lines
+- End state must be byte-for-byte identical to source branch
+- Each commit message should explain _why_, not just _what_
+- If the source branch has a linked issue, reference it in the PR
+
+### Example Commit Storyline
+
+For a feature adding user authentication:
+
+1. `feat: add User model and database migration`
+2. `feat: implement password hashing utilities`
+3. `feat: add login/logout API endpoints`
+4. `feat: add session middleware`
+5. `test: add authentication integration tests`
+6. `docs: update API documentation with auth endpoints`

package/templates/.claude/commands/fix-issue.md

@@ -0,0 +1,34 @@
+---
+description: Fix a GitHub issue following TDD workflow
+argument-hint: <issue-number>
+finishers: [clean-copy]
+---
+
+# Fix Issue Workflow
+
+When fixing a GitHub issue:
+
+1. **Understand the issue**
+   - Read the issue description and comments
+   - Understand the expected vs actual behavior
+   - Identify affected files and components
+
+2. **Write a failing test**
+   - Create a test that reproduces the issue
+   - Run it to confirm it fails
+   - The test should clearly demonstrate the bug
+
+3. **Implement the fix**
+   - Write minimal code to fix the issue
+   - Keep changes focused on the bug
+   - Don't refactor unrelated code
+
+4. **Verify the fix**
+   - Run the new test to confirm it passes
+   - Run all related tests to ensure no regressions
+   - Run lint and typecheck
+
+5. **Create a PR**
+   - Use conventional commit: `fix: description`
+   - Reference the issue: `Fixes #123`
+   - Include before/after behavior in PR description

package/templates/.claude/commands/review.md

@@ -0,0 +1,46 @@
+---
+description: Run code review checklist
+is_finisher: true
+---
+
+# Code Review Checklist
+
+Review the code against this checklist:
+
+## Testing
+
+- [ ] Tests cover the changes
+- [ ] Edge cases are tested
+- [ ] Tests are readable and maintainable
+
+## Code Quality
+
+- [ ] No console.log or debug code
+- [ ] No commented-out code
+- [ ] Types are explicit (no `any`)
+- [ ] No hardcoded values that should be config
+- [ ] Follows existing patterns in codebase
+
+## Error Handling
+
+- [ ] Errors are handled appropriately
+- [ ] Error messages are helpful
+- [ ] No silent failures
+
+## Security
+
+- [ ] No credentials or secrets in code
+- [ ] User input is validated
+- [ ] No SQL injection or XSS vulnerabilities
+
+## Performance
+
+- [ ] No obvious performance issues
+- [ ] No unnecessary re-renders (React)
+- [ ] Database queries are efficient
+
+## Documentation
+
+- [ ] Complex logic has comments
+- [ ] Public APIs have documentation
+- [ ] Breaking changes are documented

package/templates/.claude/router/classify.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * Intent Classifier for Claude Code
+ *
+ * Runs on every UserPromptSubmit to classify intent and suggest workflows.
+ * Uses simple pattern matching for fast, local classification.
+ * Zero external dependencies - uses only Node.js built-ins.
+ *
+ * Usage: node classify.js "<user prompt>"
+ *
+ * Output: JSON metadata that Claude uses to route the request
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// Load registry from JSON (no external dependencies)
+function loadRegistry() {
+  const registryPath = path.join(__dirname, "registry.json");
+  try {
+    const content = fs.readFileSync(registryPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return getDefaultRegistry();
+  }
+}
+
+// Default registry fallback
+function getDefaultRegistry() {
+  return {
+    commands: {
+      "fix-issue": {
+        triggers: ["fix issue", "fix bug", "resolve issue", "fix #"],
+        finishers: ["clean-copy"],
+      },
+      tdd: {
+        triggers: ["tdd mode", "test driven", "write tests first"],
+      },
+      review: {
+        triggers: ["review code", "code review", "check my code"],
+        is_finisher: true,
+      },
+      "clean-copy": {
+        triggers: ["clean commits", "clean history", "atomic commits"],
+        is_finisher: true,
+        finishers: ["review"],
+      },
+    },
+    chains: {
+      "complete-fix": {
+        triggers: ["fix and review", "complete fix"],
+        sequence: ["fix-issue", "clean-copy", "review"],
+      },
+    },
+    classification: {
+      confidence_threshold: 0.7,
+    },
+  };
+}
+
+// Calculate match score between prompt and trigger
+function matchScore(prompt, trigger) {
+  const normalizedPrompt = prompt.toLowerCase().trim();
+  const normalizedTrigger = trigger.toLowerCase().trim();
+
+  // Exact match
+  if (normalizedPrompt.includes(normalizedTrigger)) {
+    return 0.95;
+  }
+
+  // Word-based matching
+  const promptWords = normalizedPrompt.split(/\s+/);
+  const triggerWords = normalizedTrigger.split(/\s+/);
+
+  let matchedWords = 0;
+  for (const tw of triggerWords) {
+    if (promptWords.some((pw) => pw.includes(tw) || tw.includes(pw))) {
+      matchedWords++;
+    }
+  }
+
+  if (matchedWords === triggerWords.length) {
+    return 0.85;
+  }
+
+  if (matchedWords > 0) {
+    return 0.5 + (matchedWords / triggerWords.length) * 0.3;
+  }
+
+  return 0;
+}
+
+// Extract arguments from prompt
+function extractArgs(prompt) {
+  const args = {};
+
+  // Extract issue numbers
+  const issueMatch = prompt.match(/#(\d+)/);
+  if (issueMatch) {
+    args.issue_number = issueMatch[1];
+  }
+
+  // Extract branch names (common patterns)
+  const branchMatch = prompt.match(/branch[:\s]+([a-zA-Z0-9_\-/]+)/i);
+  if (branchMatch) {
+    args.branch_name = branchMatch[1];
+  }
+
+  return args;
+}
+
+// Main classification function
+function classify(prompt) {
+  const registry = loadRegistry();
+  const threshold = registry.classification?.confidence_threshold ?? 0.7;
+
+  let bestMatch = null;
+  let bestScore = 0;
+
+  // Check chains first (more specific)
+  for (const [chainName, chain] of Object.entries(registry.chains ?? {})) {
+    for (const trigger of chain.triggers ?? []) {
+      const score = matchScore(prompt, trigger);
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = {
+          type: "chain",
+          name: chainName,
+          sequence: chain.sequence,
+        };
+      }
+    }
+  }
+
+  // Check commands
+  for (const [cmdName, cmd] of Object.entries(registry.commands ?? {})) {
+    for (const trigger of cmd.triggers ?? []) {
+      const score = matchScore(prompt, trigger);
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = {
+          type: "command",
+          name: cmdName,
+          finishers: cmd.finishers,
+        };
+      }
+    }
+  }
+
+  const args = extractArgs(prompt);
+
+  const result = {
+    prompt: prompt,
+    classification: {
+      match: bestMatch,
+      confidence: bestScore,
+      above_threshold: bestScore >= threshold,
+      args: args,
+    },
+  };
+
+  // Add suggested execution if confidence is high enough
+  if (bestMatch && bestScore >= threshold) {
+    if (bestMatch.type === "chain") {
+      result.suggested_execution = {
+        workflow: bestMatch.name,
+        sequence: bestMatch.sequence,
+        first_command: `/${bestMatch.sequence[0]}${
+          args.issue_number ? " " + args.issue_number : ""
+        }`,
+      };
+    } else {
+      result.suggested_execution = {
+        command: `/${bestMatch.name}${
+          args.issue_number ? " " + args.issue_number : ""
+        }`,
+        finishers: bestMatch.finishers,
+      };
+    }
+  }
+
+  return result;
+}
+
+// Read stdin as JSON (for hook input)
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("readable", () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+    process.stdin.on("end", () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch {
+        resolve(null);
+      }
+    });
+    // Timeout after 100ms if no stdin
+    setTimeout(() => resolve(null), 100);
+  });
+}
+
+// CLI entry point
+if (require.main === module) {
+  // Check for command line argument first (manual testing)
+  const cliPrompt = process.argv[2];
+
+  if (cliPrompt) {
+    const result = classify(cliPrompt);
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    // Read from stdin (hook mode)
+    readStdin().then((input) => {
+      if (!input || !input.prompt) {
+        process.exit(0);
+      }
+
+      const result = classify(input.prompt);
+
+      // Output context for Claude if confidence is high
+      if (result.classification.above_threshold) {
+        const suggestion = result.suggested_execution;
+        if (suggestion) {
+          console.log(
+            `Intent detected: ${result.classification.match.name} (${Math.round(result.classification.confidence * 100)}% confidence). Suggested command: ${suggestion.command || suggestion.first_command}`,
+          );
+        }
+      }
+
+      process.exit(0);
+    });
+  }
+}
+
+module.exports = { classify, loadRegistry, matchScore };

package/templates/.claude/router/registry.json

@@ -0,0 +1,49 @@
+{
+  "commands": {
+    "fix-issue": {
+      "description": "Fix a GitHub issue following TDD workflow",
+      "triggers": [
+        "fix issue",
+        "fix bug",
+        "resolve issue",
+        "close issue",
+        "fix #",
+        "resolve #"
+      ],
+      "finishers": ["clean-copy"]
+    },
+    "review": {
+      "description": "Run code review checklist",
+      "triggers": [
+        "review code",
+        "code review",
+        "check my code",
+        "review changes",
+        "review pr"
+      ],
+      "is_finisher": true
+    },
+    "clean-copy": {
+      "description": "Restructure commits into clean, reviewable history",
+      "triggers": [
+        "clean commits",
+        "clean history",
+        "atomic commits",
+        "clean copy",
+        "restructure commits"
+      ],
+      "is_finisher": true,
+      "finishers": ["review"]
+    }
+  },
+  "chains": {
+    "complete-fix": {
+      "description": "Full issue fix workflow with clean commits and review",
+      "triggers": ["fix and review", "complete fix", "full fix"],
+      "sequence": ["fix-issue", "clean-copy", "review"]
+    }
+  },
+  "classification": {
+    "confidence_threshold": 0.7
+  }
+}

package/templates/.claude/settings.json

@@ -0,0 +1,113 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run lint)",
+      "Bash(npm run test)",
+      "Bash(npm run typecheck)",
+      "Bash(pnpm lint)",
+      "Bash(pnpm test)",
+      "Bash(pnpm typecheck)",
+      "Bash(git status)",
+      "Bash(git diff*)",
+      "Bash(git log*)",
+      "Bash(git branch*)",
+      "Bash(git checkout*)",
+      "Bash(git commit*)",
+      "Bash(gh pr create*)",
+      "Command(clean-copy)",
+      "Command(review)"
+    ],
+    "deny": ["Bash(git push --force*)", "Bash(rm -rf*)"]
+  },
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/router/classify.js \"$CLAUDE_PROMPT\""
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"if (process.argv[1]?.includes('.env')) { console.log('BLOCKED: Cannot edit .env files'); process.exit(1); }\" -- \"$CLAUDE_FILE_PATH\""
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"if (process.argv[1]?.includes('.env')) { console.log('BLOCKED: Cannot edit .env files'); process.exit(1); }\" -- \"$CLAUDE_FILE_PATH\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx prettier --write \"$CLAUDE_FILE_PATH\" && npx eslint --fix \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx prettier --write \"$CLAUDE_FILE_PATH\" && npx eslint --fix \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
+          }
+        ]
+      }
+    ]
+  },
+  "extraKnownMarketplaces": {
+    "anthropics-skills": {
+      "source": {
+        "source": "github",
+        "repo": "anthropics/skills"
+      }
+    },
+    "anthropics-plugins": {
+      "source": {
+        "source": "github",
+        "repo": "anthropics/claude-code-plugins"
+      }
+    },
+    "vercel-labs": {
+      "source": {
+        "source": "github",
+        "repo": "vercel-labs/agent-skills"
+      }
+    },
+    "better-auth": {
+      "source": {
+        "source": "github",
+        "repo": "better-auth/skills"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "frontend-design@anthropics-skills": true,
+    "commit-commands@anthropics-plugins": true,
+    "pr-review-toolkit@anthropics-plugins": true,
+    "code-simplifier@anthropics-plugins": true,
+    "create-auth-skill@better-auth": true,
+    "agent-browser@vercel-labs": true,
+    "github-cli@vercel-labs": true,
+    "skill-creator@vercel-labs": true,
+    "vercel-react-best-practices@vercel-labs": true,
+    "web-design-guidelines@vercel-labs": true
+  }
+}