winter-super-cli 2026.5.26 → 2026.5.28

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/hookify/agents/conversation-analyzer.md

@@ -1,176 +0,0 @@
----
-name: conversation-analyzer
-description: Use this agent when analyzing conversation transcripts to find behaviors worth preventing with hooks. Examples: <example>Context: User is running /hookify command without arguments\nuser: "/hookify"\nassistant: "I'll analyze the conversation to find behaviors you want to prevent"\n<commentary>The /hookify command without arguments triggers conversation analysis to find unwanted behaviors.</commentary></example><example>Context: User wants to create hooks from recent frustrations\nuser: "Can you look back at this conversation and help me create hooks for the mistakes you made?"\nassistant: "I'll use the conversation-analyzer agent to identify the issues and suggest hooks."\n<commentary>User explicitly asks to analyze conversation for mistakes that should be prevented.</commentary></example>
-model: inherit
-color: yellow
-tools: ["Read", "Grep"]
----
-
-You are a conversation analysis specialist that identifies problematic behaviors in Claude Code sessions that could be prevented with hooks.
-
-**Your Core Responsibilities:**
-1. Read and analyze user messages to find frustration signals
-2. Identify specific tool usage patterns that caused issues
-3. Extract actionable patterns that can be matched with regex
-4. Categorize issues by severity and type
-5. Provide structured findings for hook rule generation
-
-**Analysis Process:**
-
-### 1. Search for User Messages Indicating Issues
-
-Read through user messages in reverse chronological order (most recent first). Look for:
-
-**Explicit correction requests:**
-- "Don't use X"
-- "Stop doing Y"
-- "Please don't Z"
-- "Avoid..."
-- "Never..."
-
-**Frustrated reactions:**
-- "Why did you do X?"
-- "I didn't ask for that"
-- "That's not what I meant"
-- "That was wrong"
-
-**Corrections and reversions:**
-- User reverting changes Claude made
-- User fixing issues Claude created
-- User providing step-by-step corrections
-
-**Repeated issues:**
-- Same type of mistake multiple times
-- User having to remind multiple times
-- Pattern of similar problems
-
-### 2. Identify Tool Usage Patterns
-
-For each issue, determine:
-- **Which tool**: Bash, Edit, Write, MultiEdit
-- **What action**: Specific command or code pattern
-- **When it happened**: During what task/phase
-- **Why problematic**: User's stated reason or implicit concern
-
-**Extract concrete examples:**
-- For Bash: Actual command that was problematic
-- For Edit/Write: Code pattern that was added
-- For Stop: What was missing before stopping
-
-### 3. Create Regex Patterns
-
-Convert behaviors into matchable patterns:
-
-**Bash command patterns:**
-- `rm\s+-rf` for dangerous deletes
-- `sudo\s+` for privilege escalation
-- `chmod\s+777` for permission issues
-
-**Code patterns (Edit/Write):**
-- `console\.log\(` for debug logging
-- `eval\(|new Function\(` for dangerous eval
-- `innerHTML\s*=` for XSS risks
-
-**File path patterns:**
-- `\.env$` for environment files
-- `/node_modules/` for dependency files
-- `dist/|build/` for generated files
-
-### 4. Categorize Severity
-
-**High severity (should block in future):**
-- Dangerous commands (rm -rf, chmod 777)
-- Security issues (hardcoded secrets, eval)
-- Data loss risks
-
-**Medium severity (warn):**
-- Style violations (console.log in production)
-- Wrong file types (editing generated files)
-- Missing best practices
-
-**Low severity (optional):**
-- Preferences (coding style)
-- Non-critical patterns
-
-### 5. Output Format
-
-Return your findings as structured text in this format:
-
-```
-## Hookify Analysis Results
-
-### Issue 1: Dangerous rm Commands
-**Severity**: High
-**Tool**: Bash
-**Pattern**: `rm\s+-rf`
-**Occurrences**: 3 times
-**Context**: Used rm -rf on /tmp directories without verification
-**User Reaction**: "Please be more careful with rm commands"
-
-**Suggested Rule:**
-- Name: warn-dangerous-rm
-- Event: bash
-- Pattern: rm\s+-rf
-- Message: "Dangerous rm command detected. Verify path before proceeding."
-
----
-
-### Issue 2: Console.log in TypeScript
-**Severity**: Medium
-**Tool**: Edit/Write
-**Pattern**: `console\.log\(`
-**Occurrences**: 2 times
-**Context**: Added console.log statements to production TypeScript files
-**User Reaction**: "Don't use console.log in production code"
-
-**Suggested Rule:**
-- Name: warn-console-log
-- Event: file
-- Pattern: console\.log\(
-- Message: "Console.log detected. Use proper logging library instead."
-
----
-
-[Continue for each issue found...]
-
-## Summary
-
-Found {N} behaviors worth preventing:
-- {N} high severity
-- {N} medium severity
-- {N} low severity
-
-Recommend creating rules for high and medium severity issues.
-```
-
-**Quality Standards:**
-- Be specific about patterns (don't be overly broad)
-- Include actual examples from conversation
-- Explain why each issue matters
-- Provide ready-to-use regex patterns
-- Don't false-positive on discussions about what NOT to do
-
-**Edge Cases:**
-
-**User discussing hypotheticals:**
-- "What would happen if I used rm -rf?"
-- Don't treat as problematic behavior
-
-**Teaching moments:**
-- "Here's what you shouldn't do: ..."
-- Context indicates explanation, not actual problem
-
-**One-time accidents:**
-- Single occurrence, already fixed
-- Mention but mark as low priority
-
-**Subjective preferences:**
-- "I prefer X over Y"
-- Mark as low severity, let user decide
-
-**Return Results:**
-Provide your analysis in the structured format above. The /hookify command will use this to:
-1. Present findings to user
-2. Ask which rules to create
-3. Generate .local.md configuration files
-4. Save rules to .claude directory

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/hookify/commands/configure.md

@@ -1,128 +0,0 @@
----
-description: Enable or disable hookify rules interactively
-allowed-tools: ["Glob", "Read", "Edit", "AskUserQuestion", "Skill"]
----
-
-# Configure Hookify Rules
-
-**Load hookify:writing-rules skill first** to understand rule format.
-
-Enable or disable existing hookify rules using an interactive interface.
-
-## Steps
-
-### 1. Find Existing Rules
-
-Use Glob tool to find all hookify rule files:
-```
-pattern: ".claude/hookify.*.local.md"
-```
-
-If no rules found, inform user:
-```
-No hookify rules configured yet. Use `/hookify` to create your first rule.
-```
-
-### 2. Read Current State
-
-For each rule file:
-- Read the file
-- Extract `name` and `enabled` fields from frontmatter
-- Build list of rules with current state
-
-### 3. Ask User Which Rules to Toggle
-
-Use AskUserQuestion to let user select rules:
-
-```json
-{
-  "questions": [
-    {
-      "question": "Which rules would you like to enable or disable?",
-      "header": "Configure",
-      "multiSelect": true,
-      "options": [
-        {
-          "label": "warn-dangerous-rm (currently enabled)",
-          "description": "Warns about rm -rf commands"
-        },
-        {
-          "label": "warn-console-log (currently disabled)",
-          "description": "Warns about console.log in code"
-        },
-        {
-          "label": "require-tests (currently enabled)",
-          "description": "Requires tests before stopping"
-        }
-      ]
-    }
-  ]
-}
-```
-
-**Option format:**
-- Label: `{rule-name} (currently {enabled|disabled})`
-- Description: Brief description from rule's message or pattern
-
-### 4. Parse User Selection
-
-For each selected rule:
-- Determine current state from label (enabled/disabled)
-- Toggle state: enabled → disabled, disabled → enabled
-
-### 5. Update Rule Files
-
-For each rule to toggle:
-- Use Read tool to read current content
-- Use Edit tool to change `enabled: true` to `enabled: false` (or vice versa)
-- Handle both with and without quotes
-
-**Edit pattern for enabling:**
-```
-old_string: "enabled: false"
-new_string: "enabled: true"
-```
-
-**Edit pattern for disabling:**
-```
-old_string: "enabled: true"
-new_string: "enabled: false"
-```
-
-### 6. Confirm Changes
-
-Show user what was changed:
-
-```
-## Hookify Rules Updated
-
-**Enabled:**
-- warn-console-log
-
-**Disabled:**
-- warn-dangerous-rm
-
-**Unchanged:**
-- require-tests
-
-Changes apply immediately - no restart needed
-```
-
-## Important Notes
-
-- Changes take effect immediately on next tool use
-- You can also manually edit .claude/hookify.*.local.md files
-- To permanently remove a rule, delete its .local.md file
-- Use `/hookify:list` to see all configured rules
-
-## Edge Cases
-
-**No rules to configure:**
-- Show message about using `/hookify` to create rules first
-
-**User selects no rules:**
-- Inform that no changes were made
-
-**File read/write errors:**
-- Inform user of specific error
-- Suggest manual editing as fallback

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/hookify/commands/help.md

@@ -1,175 +0,0 @@
----
-description: Get help with the hookify plugin
-allowed-tools: ["Read"]
----
-
-# Hookify Plugin Help
-
-Explain how the hookify plugin works and how to use it.
-
-## Overview
-
-The hookify plugin makes it easy to create custom hooks that prevent unwanted behaviors. Instead of editing `hooks.json` files, users create simple markdown configuration files that define patterns to watch for.
-
-## How It Works
-
-### 1. Hook System
-
-Hookify installs generic hooks that run on these events:
-- **PreToolUse**: Before any tool executes (Bash, Edit, Write, etc.)
-- **PostToolUse**: After a tool executes
-- **Stop**: When Claude wants to stop working
-- **UserPromptSubmit**: When user submits a prompt
-
-These hooks read configuration files from `.claude/hookify.*.local.md` and check if any rules match the current operation.
-
-### 2. Configuration Files
-
-Users create rules in `.claude/hookify.{rule-name}.local.md` files:
-
-```markdown
----
-name: warn-dangerous-rm
-enabled: true
-event: bash
-pattern: rm\s+-rf
----
-
-⚠️ **Dangerous rm command detected!**
-
-This command could delete important files. Please verify the path.
-```
-
-**Key fields:**
-- `name`: Unique identifier for the rule
-- `enabled`: true/false to activate/deactivate
-- `event`: bash, file, stop, prompt, or all
-- `pattern`: Regex pattern to match
-
-The message body is what Claude sees when the rule triggers.
-
-### 3. Creating Rules
-
-**Option A: Use /hookify command**
-```
-/hookify Don't use console.log in production files
-```
-
-This analyzes your request and creates the appropriate rule file.
-
-**Option B: Create manually**
-Create `.claude/hookify.my-rule.local.md` with the format above.
-
-**Option C: Analyze conversation**
-```
-/hookify
-```
-
-Without arguments, hookify analyzes recent conversation to find behaviors you want to prevent.
-
-## Available Commands
-
-- **`/hookify`** - Create hooks from conversation analysis or explicit instructions
-- **`/hookify:help`** - Show this help (what you're reading now)
-- **`/hookify:list`** - List all configured hooks
-- **`/hookify:configure`** - Enable/disable existing hooks interactively
-
-## Example Use Cases
-
-**Prevent dangerous commands:**
-```markdown
----
-name: block-chmod-777
-enabled: true
-event: bash
-pattern: chmod\s+777
----
-
-Don't use chmod 777 - it's a security risk. Use specific permissions instead.
-```
-
-**Warn about debugging code:**
-```markdown
----
-name: warn-console-log
-enabled: true
-event: file
-pattern: console\.log\(
----
-
-Console.log detected. Remember to remove debug logging before committing.
-```
-
-**Require tests before stopping:**
-```markdown
----
-name: require-tests
-enabled: true
-event: stop
-pattern: .*
----
-
-Did you run tests before finishing? Make sure `npm test` or equivalent was executed.
-```
-
-## Pattern Syntax
-
-Use Python regex syntax:
-- `\s` - whitespace
-- `\.` - literal dot
-- `|` - OR
-- `+` - one or more
-- `*` - zero or more
-- `\d` - digit
-- `[abc]` - character class
-
-**Examples:**
-- `rm\s+-rf` - matches "rm -rf"
-- `console\.log\(` - matches "console.log("
-- `(eval|exec)\(` - matches "eval(" or "exec("
-- `\.env$` - matches files ending in .env
-
-## Important Notes
-
-**No Restart Needed**: Hookify rules (`.local.md` files) take effect immediately on the next tool use. The hookify hooks are already loaded and read your rules dynamically.
-
-**Block or Warn**: Rules can either `block` operations (prevent execution) or `warn` (show message but allow). Set `action: block` or `action: warn` in the rule's frontmatter.
-
-**Rule Files**: Keep rules in `.claude/hookify.*.local.md` - they should be git-ignored (add to .gitignore if needed).
-
-**Disable Rules**: Set `enabled: false` in frontmatter or delete the file.
-
-## Troubleshooting
-
-**Hook not triggering:**
-- Check rule file is in `.claude/` directory
-- Verify `enabled: true` in frontmatter
-- Confirm pattern is valid regex
-- Test pattern: `python3 -c "import re; print(re.search('your_pattern', 'test_text'))"`
-- Rules take effect immediately - no restart needed
-
-**Import errors:**
-- Check Python 3 is available: `python3 --version`
-- Verify hookify plugin is installed correctly
-
-**Pattern not matching:**
-- Test regex separately
-- Check for escaping issues (use unquoted patterns in YAML)
-- Try simpler pattern first, then refine
-
-## Getting Started
-
-1. Create your first rule:
-   ```
-   /hookify Warn me when I try to use rm -rf
-   ```
-
-2. Try to trigger it:
-   - Ask Claude to run `rm -rf /tmp/test`
-   - You should see the warning
-
-4. Refine the rule by editing `.claude/hookify.warn-rm.local.md`
-
-5. Create more rules as you encounter unwanted behaviors
-
-For more examples, check the `${CLAUDE_PLUGIN_ROOT}/examples/` directory.

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/hookify/commands/hookify.md

@@ -1,231 +0,0 @@
----
-description: Create hooks to prevent unwanted behaviors from conversation analysis or explicit instructions
-argument-hint: Optional specific behavior to address
-allowed-tools: ["Read", "Write", "AskUserQuestion", "Task", "Grep", "TodoWrite", "Skill"]
----
-
-# Hookify - Create Hooks from Unwanted Behaviors
-
-**FIRST: Load the hookify:writing-rules skill** using the Skill tool to understand rule file format and syntax.
-
-Create hook rules to prevent problematic behaviors by analyzing the conversation or from explicit user instructions.
-
-## Your Task
-
-You will help the user create hookify rules to prevent unwanted behaviors. Follow these steps:
-
-### Step 1: Gather Behavior Information
-
-**If $ARGUMENTS is provided:**
-- User has given specific instructions: `$ARGUMENTS`
-- Still analyze recent conversation (last 10-15 user messages) for additional context
-- Look for examples of the behavior happening
-
-**If $ARGUMENTS is empty:**
-- Launch the conversation-analyzer agent to find problematic behaviors
-- Agent will scan user prompts for frustration signals
-- Agent will return structured findings
-
-**To analyze conversation:**
-Use the Task tool to launch conversation-analyzer agent:
-```
-{
-  "subagent_type": "general-purpose",
-  "description": "Analyze conversation for unwanted behaviors",
-  "prompt": "You are analyzing a Claude Code conversation to find behaviors the user wants to prevent.
-
-Read user messages in the current conversation and identify:
-1. Explicit requests to avoid something (\"don't do X\", \"stop doing Y\")
-2. Corrections or reversions (user fixing Claude's actions)
-3. Frustrated reactions (\"why did you do X?\", \"I didn't ask for that\")
-4. Repeated issues (same problem multiple times)
-
-For each issue found, extract:
-- What tool was used (Bash, Edit, Write, etc.)
-- Specific pattern or command
-- Why it was problematic
-- User's stated reason
-
-Return findings as a structured list with:
-- category: Type of issue
-- tool: Which tool was involved
-- pattern: Regex or literal pattern to match
-- context: What happened
-- severity: high/medium/low
-
-Focus on the most recent issues (last 20-30 messages). Don't go back further unless explicitly asked."
-}
-```
-
-### Step 2: Present Findings to User
-
-After gathering behaviors (from arguments or agent), present to user using AskUserQuestion:
-
-**Question 1: Which behaviors to hookify?**
-- Header: "Create Rules"
-- multiSelect: true
-- Options: List each detected behavior (max 4)
-  - Label: Short description (e.g., "Block rm -rf")
-  - Description: Why it's problematic
-
-**Question 2: For each selected behavior, ask about action:**
-- "Should this block the operation or just warn?"
-- Options:
-  - "Just warn" (action: warn - shows message but allows)
-  - "Block operation" (action: block - prevents execution)
-
-**Question 3: Ask for example patterns:**
-- "What patterns should trigger this rule?"
-- Show detected patterns
-- Allow user to refine or add more
-
-### Step 3: Generate Rule Files
-
-For each confirmed behavior, create a `.claude/hookify.{rule-name}.local.md` file:
-
-**Rule naming convention:**
-- Use kebab-case
-- Be descriptive: `block-dangerous-rm`, `warn-console-log`, `require-tests-before-stop`
-- Start with action verb: block, warn, prevent, require
-
-**File format:**
-```markdown
----
-name: {rule-name}
-enabled: true
-event: {bash|file|stop|prompt|all}
-pattern: {regex pattern}
-action: {warn|block}
----
-
-{Message to show Claude when rule triggers}
-```
-
-**Action values:**
-- `warn`: Show message but allow operation (default)
-- `block`: Prevent operation or stop session
-
-**For more complex rules (multiple conditions):**
-```markdown
----
-name: {rule-name}
-enabled: true
-event: file
-conditions:
-  - field: file_path
-    operator: regex_match
-    pattern: \.env$
-  - field: new_text
-    operator: contains
-    pattern: API_KEY
----
-
-{Warning message}
-```
-
-### Step 4: Create Files and Confirm
-
-**IMPORTANT**: Rule files must be created in the current working directory's `.claude/` folder, NOT the plugin directory.
-
-Use the current working directory (where Claude Code was started) as the base path.
-
-1. Check if `.claude/` directory exists in current working directory
-   - If not, create it first with: `mkdir -p .claude`
-
-2. Use Write tool to create each `.claude/hookify.{name}.local.md` file
-   - Use relative path from current working directory: `.claude/hookify.{name}.local.md`
-   - The path should resolve to the project's .claude directory, not the plugin's
-
-3. Show user what was created:
-   ```
-   Created 3 hookify rules:
-   - .claude/hookify.dangerous-rm.local.md
-   - .claude/hookify.console-log.local.md
-   - .claude/hookify.sensitive-files.local.md
-
-   These rules will trigger on:
-   - dangerous-rm: Bash commands matching "rm -rf"
-   - console-log: Edits adding console.log statements
-   - sensitive-files: Edits to .env or credentials files
-   ```
-
-4. Verify files were created in the correct location by listing them
-
-5. Inform user: **"Rules are active immediately - no restart needed!"**
-
-   The hookify hooks are already loaded and will read your new rules on the next tool use.
-
-## Event Types Reference
-
-- **bash**: Matches Bash tool commands
-- **file**: Matches Edit, Write, MultiEdit tools
-- **stop**: Matches when agent wants to stop (use for completion checks)
-- **prompt**: Matches when user submits prompts
-- **all**: Matches all events
-
-## Pattern Writing Tips
-
-**Bash patterns:**
-- Match dangerous commands: `rm\s+-rf|chmod\s+777|dd\s+if=`
-- Match specific tools: `npm\s+install\s+|pip\s+install`
-
-**File patterns:**
-- Match code patterns: `console\.log\(|eval\(|innerHTML\s*=`
-- Match file paths: `\.env$|\.git/|node_modules/`
-
-**Stop patterns:**
-- Check for missing steps: (check transcript or completion criteria)
-
-## Example Workflow
-
-**User says**: "/hookify Don't use rm -rf without asking me first"
-
-**Your response**:
-1. Analyze: User wants to prevent rm -rf commands
-2. Ask: "Should I block this command or just warn you?"
-3. User selects: "Just warn"
-4. Create `.claude/hookify.dangerous-rm.local.md`:
-   ```markdown
-   ---
-   name: warn-dangerous-rm
-   enabled: true
-   event: bash
-   pattern: rm\s+-rf
-   ---
-
-   ⚠️ **Dangerous rm command detected**
-
-   You requested to be warned before using rm -rf.
-   Please verify the path is correct.
-   ```
-5. Confirm: "Created hookify rule. It's active immediately - try triggering it!"
-
-## Important Notes
-
-- **No restart needed**: Rules take effect immediately on the next tool use
-- **File location**: Create files in project's `.claude/` directory (current working directory), NOT the plugin's .claude/
-- **Regex syntax**: Use Python regex syntax (raw strings, no need to escape in YAML)
-- **Action types**: Rules can `warn` (default) or `block` operations
-- **Testing**: Test rules immediately after creating them
-
-## Troubleshooting
-
-**If rule file creation fails:**
-1. Check current working directory with pwd
-2. Ensure `.claude/` directory exists (create with mkdir if needed)
-3. Use absolute path if needed: `{cwd}/.claude/hookify.{name}.local.md`
-4. Verify file was created with Glob or ls
-
-**If rule doesn't trigger after creation:**
-1. Verify file is in project `.claude/` not plugin `.claude/`
-2. Check file with Read tool to ensure pattern is correct
-3. Test pattern with: `python3 -c "import re; print(re.search(r'pattern', 'test text'))"`
-4. Verify `enabled: true` in frontmatter
-5. Remember: Rules work immediately, no restart needed
-
-**If blocking seems too strict:**
-1. Change `action: block` to `action: warn` in the rule file
-2. Or adjust the pattern to be more specific
-3. Changes take effect on next tool use
-
-Use TodoWrite to track your progress through the steps.