cue-ai 0.3.0 → 0.4.1

package/resources/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.

package/resources/claude-plugins-official/plugins/hookify/commands/list.md

@@ -1,82 +0,0 @@
----
-description: List all configured hookify rules
-allowed-tools: ["Glob", "Read", "Skill"]
----
-
-# List Hookify Rules
-
-**Load hookify:writing-rules skill first** to understand rule format.
-
-Show all configured hookify rules in the project.
-
-## Steps
-
-1. Use Glob tool to find all hookify rule files:
-   ```
-   pattern: ".claude/hookify.*.local.md"
-   ```
-
-2. For each file found:
-   - Use Read tool to read the file
-   - Extract frontmatter fields: name, enabled, event, pattern
-   - Extract message preview (first 100 chars)
-
-3. Present results in a table:
-
-```
-## Configured Hookify Rules
-
-| Name | Enabled | Event | Pattern | File |
-|------|---------|-------|---------|------|
-| warn-dangerous-rm | ✅ Yes | bash | rm\s+-rf | hookify.dangerous-rm.local.md |
-| warn-console-log | ✅ Yes | file | console\.log\( | hookify.console-log.local.md |
-| check-tests | ❌ No | stop | .* | hookify.require-tests.local.md |
-
-**Total**: 3 rules (2 enabled, 1 disabled)
-```
-
-4. For each rule, show a brief preview:
-```
-### warn-dangerous-rm
-**Event**: bash
-**Pattern**: `rm\s+-rf`
-**Message**: "⚠️ **Dangerous rm command detected!** This command could delete..."
-
-**Status**: ✅ Active
-**File**: .claude/hookify.dangerous-rm.local.md
-```
-
-5. Add helpful footer:
-```
----
-
-To modify a rule: Edit the .local.md file directly
-To disable a rule: Set `enabled: false` in frontmatter
-To enable a rule: Set `enabled: true` in frontmatter
-To delete a rule: Remove the .local.md file
-To create a rule: Use `/hookify` command
-
-**Remember**: Changes take effect immediately - no restart needed
-```
-
-## If No Rules Found
-
-If no hookify rules exist:
-
-```
-## No Hookify Rules Configured
-
-You haven't created any hookify rules yet.
-
-To get started:
-1. Use `/hookify` to analyze conversation and create rules
-2. Or manually create `.claude/hookify.my-rule.local.md` files
-3. See `/hookify:help` for documentation
-
-Example:
-```
-/hookify Warn me when I use console.log
-```
-
-Check `${CLAUDE_PLUGIN_ROOT}/examples/` for example rule files.
-```

package/resources/claude-plugins-official/plugins/hookify/core/config_loader.py

@@ -1,297 +0,0 @@
-#!/usr/bin/env python3
-"""Configuration loader for hookify plugin.
-
-Loads and parses .claude/hookify.*.local.md files.
-"""
-
-import os
-import sys
-import glob
-import re
-from typing import List, Optional, Dict, Any
-from dataclasses import dataclass, field
-
-
-@dataclass
-class Condition:
-    """A single condition for matching."""
-    field: str  # "command", "new_text", "old_text", "file_path", etc.
-    operator: str  # "regex_match", "contains", "equals", etc.
-    pattern: str  # Pattern to match
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'Condition':
-        """Create Condition from dict."""
-        return cls(
-            field=data.get('field', ''),
-            operator=data.get('operator', 'regex_match'),
-            pattern=data.get('pattern', '')
-        )
-
-
-@dataclass
-class Rule:
-    """A hookify rule."""
-    name: str
-    enabled: bool
-    event: str  # "bash", "file", "stop", "all", etc.
-    pattern: Optional[str] = None  # Simple pattern (legacy)
-    conditions: List[Condition] = field(default_factory=list)
-    action: str = "warn"  # "warn" or "block" (future)
-    tool_matcher: Optional[str] = None  # Override tool matching
-    message: str = ""  # Message body from markdown
-
-    @classmethod
-    def from_dict(cls, frontmatter: Dict[str, Any], message: str) -> 'Rule':
-        """Create Rule from frontmatter dict and message body."""
-        # Handle both simple pattern and complex conditions
-        conditions = []
-
-        # New style: explicit conditions list
-        if 'conditions' in frontmatter:
-            cond_list = frontmatter['conditions']
-            if isinstance(cond_list, list):
-                conditions = [Condition.from_dict(c) for c in cond_list]
-
-        # Legacy style: simple pattern field
-        simple_pattern = frontmatter.get('pattern')
-        if simple_pattern and not conditions:
-            # Convert simple pattern to condition
-            # Infer field from event
-            event = frontmatter.get('event', 'all')
-            if event == 'bash':
-                field = 'command'
-            elif event == 'file':
-                field = 'new_text'
-            else:
-                field = 'content'
-
-            conditions = [Condition(
-                field=field,
-                operator='regex_match',
-                pattern=simple_pattern
-            )]
-
-        return cls(
-            name=frontmatter.get('name', 'unnamed'),
-            enabled=frontmatter.get('enabled', True),
-            event=frontmatter.get('event', 'all'),
-            pattern=simple_pattern,
-            conditions=conditions,
-            action=frontmatter.get('action', 'warn'),
-            tool_matcher=frontmatter.get('tool_matcher'),
-            message=message.strip()
-        )
-
-
-def extract_frontmatter(content: str) -> tuple[Dict[str, Any], str]:
-    """Extract YAML frontmatter and message body from markdown.
-
-    Returns (frontmatter_dict, message_body).
-
-    Supports multi-line dictionary items in lists by preserving indentation.
-    """
-    if not content.startswith('---'):
-        return {}, content
-
-    # Split on --- markers
-    parts = content.split('---', 2)
-    if len(parts) < 3:
-        return {}, content
-
-    frontmatter_text = parts[1]
-    message = parts[2].strip()
-
-    # Simple YAML parser that handles indented list items
-    frontmatter = {}
-    lines = frontmatter_text.split('\n')
-
-    current_key = None
-    current_list = []
-    current_dict = {}
-    in_list = False
-    in_dict_item = False
-
-    for line in lines:
-        # Skip empty lines and comments
-        stripped = line.strip()
-        if not stripped or stripped.startswith('#'):
-            continue
-
-        # Check indentation level
-        indent = len(line) - len(line.lstrip())
-
-        # Top-level key (no indentation or minimal)
-        if indent == 0 and ':' in line and not line.strip().startswith('-'):
-            # Save previous list/dict if any
-            if in_list and current_key:
-                if in_dict_item and current_dict:
-                    current_list.append(current_dict)
-                    current_dict = {}
-                frontmatter[current_key] = current_list
-                in_list = False
-                in_dict_item = False
-                current_list = []
-
-            key, value = line.split(':', 1)
-            key = key.strip()
-            value = value.strip()
-
-            if not value:
-                # Empty value - list or nested structure follows
-                current_key = key
-                in_list = True
-                current_list = []
-            else:
-                # Simple key-value pair
-                value = value.strip('"').strip("'")
-                if value.lower() == 'true':
-                    value = True
-                elif value.lower() == 'false':
-                    value = False
-                frontmatter[key] = value
-
-        # List item (starts with -)
-        elif stripped.startswith('-') and in_list:
-            # Save previous dict item if any
-            if in_dict_item and current_dict:
-                current_list.append(current_dict)
-                current_dict = {}
-
-            item_text = stripped[1:].strip()
-
-            # Check if this is an inline dict (key: value on same line)
-            if ':' in item_text and ',' in item_text:
-                # Inline comma-separated dict: "- field: command, operator: regex_match"
-                item_dict = {}
-                for part in item_text.split(','):
-                    if ':' in part:
-                        k, v = part.split(':', 1)
-                        item_dict[k.strip()] = v.strip().strip('"').strip("'")
-                current_list.append(item_dict)
-                in_dict_item = False
-            elif ':' in item_text:
-                # Start of multi-line dict item: "- field: command"
-                in_dict_item = True
-                k, v = item_text.split(':', 1)
-                current_dict = {k.strip(): v.strip().strip('"').strip("'")}
-            else:
-                # Simple list item
-                current_list.append(item_text.strip('"').strip("'"))
-                in_dict_item = False
-
-        # Continuation of dict item (indented under list item)
-        elif indent > 2 and in_dict_item and ':' in line:
-            # This is a field of the current dict item
-            k, v = stripped.split(':', 1)
-            current_dict[k.strip()] = v.strip().strip('"').strip("'")
-
-    # Save final list/dict if any
-    if in_list and current_key:
-        if in_dict_item and current_dict:
-            current_list.append(current_dict)
-        frontmatter[current_key] = current_list
-
-    return frontmatter, message
-
-
-def load_rules(event: Optional[str] = None) -> List[Rule]:
-    """Load all hookify rules from .claude directory.
-
-    Args:
-        event: Optional event filter ("bash", "file", "stop", etc.)
-
-    Returns:
-        List of enabled Rule objects matching the event.
-    """
-    rules = []
-
-    # Find all hookify.*.local.md files
-    pattern = os.path.join('.claude', 'hookify.*.local.md')
-    files = glob.glob(pattern)
-
-    for file_path in files:
-        try:
-            rule = load_rule_file(file_path)
-            if not rule:
-                continue
-
-            # Filter by event if specified
-            if event:
-                if rule.event != 'all' and rule.event != event:
-                    continue
-
-            # Only include enabled rules
-            if rule.enabled:
-                rules.append(rule)
-
-        except (IOError, OSError, PermissionError) as e:
-            # File I/O errors - log and continue
-            print(f"Warning: Failed to read {file_path}: {e}", file=sys.stderr)
-            continue
-        except (ValueError, KeyError, AttributeError, TypeError) as e:
-            # Parsing errors - log and continue
-            print(f"Warning: Failed to parse {file_path}: {e}", file=sys.stderr)
-            continue
-        except Exception as e:
-            # Unexpected errors - log with type details
-            print(f"Warning: Unexpected error loading {file_path} ({type(e).__name__}): {e}", file=sys.stderr)
-            continue
-
-    return rules
-
-
-def load_rule_file(file_path: str) -> Optional[Rule]:
-    """Load a single rule file.
-
-    Returns:
-        Rule object or None if file is invalid.
-    """
-    try:
-        with open(file_path, 'r') as f:
-            content = f.read()
-
-        frontmatter, message = extract_frontmatter(content)
-
-        if not frontmatter:
-            print(f"Warning: {file_path} missing YAML frontmatter (must start with ---)", file=sys.stderr)
-            return None
-
-        rule = Rule.from_dict(frontmatter, message)
-        return rule
-
-    except (IOError, OSError, PermissionError) as e:
-        print(f"Error: Cannot read {file_path}: {e}", file=sys.stderr)
-        return None
-    except (ValueError, KeyError, AttributeError, TypeError) as e:
-        print(f"Error: Malformed rule file {file_path}: {e}", file=sys.stderr)
-        return None
-    except UnicodeDecodeError as e:
-        print(f"Error: Invalid encoding in {file_path}: {e}", file=sys.stderr)
-        return None
-    except Exception as e:
-        print(f"Error: Unexpected error parsing {file_path} ({type(e).__name__}): {e}", file=sys.stderr)
-        return None
-
-
-# For testing
-if __name__ == '__main__':
-    import sys
-
-    # Test frontmatter parsing
-    test_content = """---
-name: test-rule
-enabled: true
-event: bash
-pattern: "rm -rf"
----
-
-⚠️ Dangerous command detected!
-"""
-
-    fm, msg = extract_frontmatter(test_content)
-    print("Frontmatter:", fm)
-    print("Message:", msg)
-
-    rule = Rule.from_dict(fm, msg)
-    print("Rule:", rule)