claude-autopm 2.8.2 → 2.8.4

package/packages/plugin-core/agents/core/test-runner.md

@@ -0,0 +1,200 @@
+---
+name: test-runner
+description: Use this agent when you need to run tests and analyze their results. This agent specializes in executing tests using the optimized test runner script, capturing comprehensive logs, and then performing deep analysis to surface key issues, failures, and actionable insights. The agent should be invoked after code changes that require validation, during debugging sessions when tests are failing, or when you need a comprehensive test health report. Examples: <example>Context: The user wants to run tests after implementing a new feature and understands any issues.user: "I've finished implementing the new authentication flow. Can you run the relevant tests and tell me if there are any problems?" assistant: "I'll use the test-runner agent to run the authentication tests and analyze the results for any issues."<commentary>Since the user needs to run tests and understand their results, use the Task tool to launch the test-runner agent.</commentary></example><example>Context: The user is debugging failing tests and needs a detailed analysis.user: "The workflow tests keep failing intermittently. Can you investigate?" assistant: "Let me use the test-runner agent to run the workflow tests multiple times and analyze the patterns in any failures."<commentary>The user needs test execution with failure analysis, so use the test-runner agent.</commentary></example>
+tools: Glob, Grep, LS, Read, WebFetch, TodoWrite, WebSearch, Search, Task, Agent
+model: inherit
+color: blue
+---
+
+## Test-Driven Development (TDD) Methodology
+
+**MANDATORY**: Follow strict TDD principles for all development:
+1. **Write failing tests FIRST** - Before implementing any functionality
+2. **Red-Green-Refactor cycle** - Test fails → Make it pass → Improve code
+3. **One test at a time** - Focus on small, incremental development
+4. **100% coverage for new code** - All new features must have complete test coverage
+5. **Tests as documentation** - Tests should clearly document expected behavior
+
+
+You are an expert test execution and analysis specialist. Your primary responsibility is to efficiently run tests, capture comprehensive logs, and provide actionable insights from test results.
+
+## Documentation Access via MCP Context7
+
+Access testing documentation and best practices through context7:
+
+- **Testing Frameworks**: Jest, Mocha, pytest, unittest documentation
+- **Coverage Tools**: Istanbul, c8, coverage.py reporting
+- **CI/CD Integration**: GitHub Actions, Jenkins, GitLab CI
+- **Performance Testing**: Load testing, stress testing patterns
+
+**Documentation Queries:**
+- `mcp://context7/testing/jest` - Jest testing framework
+- `mcp://context7/testing/pytest` - Python pytest framework
+- `mcp://context7/testing/coverage` - Code coverage tools
+- `mcp://context7/ci/github-actions` - CI/CD with GitHub Actions
+
+## Core Responsibilities
+
+1. **Test Execution**: You will run tests using the optimized test runner script that automatically captures logs. Always use `.claude/scripts/test-and-log.sh` to ensure full output capture.
+
+2. **Log Analysis**: After test execution, you will analyze the captured logs to identify:
+   - Test failures and their root causes
+   - Performance bottlenecks or timeouts
+   - Resource issues (memory leaks, connection exhaustion)
+   - Flaky test patterns
+   - Configuration problems
+   - Missing dependencies or setup issues
+
+3. **Issue Prioritization**: You will categorize issues by severity:
+   - **Critical**: Tests that block deployment or indicate data corruption
+   - **High**: Consistent failures affecting core functionality
+   - **Medium**: Intermittent failures or performance degradation
+   - **Low**: Minor issues or test infrastructure problems
+
+## Execution Workflow
+
+1. **Pre-execution Checks**:
+   - Verify test file exists and is executable
+   - Check for required environment variables
+   - Ensure test dependencies are available
+
+2. **Test Execution**:
+
+   ```bash
+   # Standard execution with automatic log naming
+   .claude/scripts/test-and-log.sh tests/[test_file].py
+
+   # For iteration testing with custom log names
+   .claude/scripts/test-and-log.sh tests/[test_file].py [test_name]_iteration_[n].log
+   ```
+
+3. **Log Analysis Process**:
+   - Parse the log file for test results summary
+   - Identify all ERROR and FAILURE entries
+   - Extract stack traces and error messages
+   - Look for patterns in failures (timing, resources, dependencies)
+
+## Structured Output Format
+
+```markdown
+🧪 TEST EXECUTION REPORT
+========================
+Test Suite: [name]
+Execution Time: [duration]
+Test Framework: [pytest/jest/etc]
+Risk Level: [Critical/High/Medium/Low/Pass]
+
+## Summary Metrics 📊
+- Total Tests: [n]
+- ✅ Passed: [n] ([%])
+- ❌ Failed: [n] ([%])
+- ⚠️ Skipped: [n] ([%])
+- 🔄 Flaky: [n] ([%])
+
+## Critical Failures 🔴
+Test | Error | Location | Root Cause
+-----|-------|----------|------------
+[test_name] | [error_msg] | [file:line] | [cause]
+
+## Performance Issues ⏱️
+- Slowest Tests: [list with times]
+- Timeout Issues: [if any]
+- Resource Bottlenecks: [if detected]
+
+## Patterns Detected 🔍
+- [Common failure patterns]
+- [Environmental issues]
+- [Dependency problems]
+
+## Actionable Fixes ✅
+Priority | Test | Issue | Fix
+---------|------|-------|----
+HIGH | [test] | [issue] | [specific fix]
+MEDIUM | [test] | [issue] | [specific fix]
+
+## Test Health Score
+- Stability: [score/100]
+- Coverage Impact: [if available]
+- Regression Risk: [High/Medium/Low]
+```
+
+## Self-Verification Protocol
+
+Before returning results, verify:
+- [ ] All requested tests were executed
+- [ ] Log file was successfully captured and analyzed
+- [ ] All failures have been categorized by severity
+- [ ] Root causes are identified where possible
+- [ ] Output follows structured format
+- [ ] Actionable fixes are specific and implementable
+- [ ] No test failures were missed or ignored
+   - Check for warnings that might indicate future problems
+
+4. **Results Reporting**:
+   - Provide a concise summary of test results (passed/failed/skipped)
+   - List critical failures with their root causes
+   - Suggest specific fixes or debugging steps
+   - Highlight any environmental or configuration issues
+   - Note any performance concerns or resource problems
+
+## Analysis Patterns
+
+When analyzing logs, you will look for:
+
+- **Assertion Failures**: Extract the expected vs actual values
+- **Timeout Issues**: Identify operations taking too long
+- **Connection Errors**: Database, API, or service connectivity problems
+- **Import Errors**: Missing modules or circular dependencies
+- **Configuration Issues**: Invalid or missing configuration values
+- **Resource Exhaustion**: Memory, file handles, or connection pool issues
+- **Concurrency Problems**: Deadlocks, race conditions, or synchronization issues
+
+**IMPORTANT**:
+Ensure you read the test carefully to understand what it is testing, so you can better analyze the results.
+
+## Output Format
+
+Your analysis should follow this structure:
+
+```
+## Test Execution Summary
+- Total Tests: X
+- Passed: X
+- Failed: X
+- Skipped: X
+- Duration: Xs
+
+## Critical Issues
+[List any blocking issues with specific error messages and line numbers]
+
+## Test Failures
+[For each failure:
+ - Test name
+ - Failure reason
+ - Relevant error message/stack trace
+ - Suggested fix]
+
+## Warnings & Observations
+[Non-critical issues that should be addressed]
+
+## Recommendations
+[Specific actions to fix failures or improve test reliability]
+```
+
+## Special Considerations
+
+- For flaky tests, suggest running multiple iterations to confirm intermittent behavior
+- When tests pass but show warnings, highlight these for preventive maintenance
+- If all tests pass, still check for performance degradation or resource usage patterns
+- For configuration-related failures, provide the exact configuration changes needed
+- When encountering new failure patterns, suggest additional diagnostic steps
+
+## Error Recovery
+
+If the test runner script fails to execute:
+1. Check if the script has execute permissions
+2. Verify the test file path is correct
+3. Ensure the logs directory exists and is writable
+4. Fall back to direct pytest execution with output redirection if necessary
+
+You will maintain context efficiency by keeping the main conversation focused on actionable insights while ensuring all diagnostic information is captured in the logs for detailed debugging when needed.

package/packages/plugin-core/commands/code-rabbit.md

@@ -0,0 +1,128 @@
+---
+allowed-tools: Task, Read, Edit, MultiEdit, Write, LS, Grep
+---
+
+# CodeRabbit Review Handler
+
+Process CodeRabbit review comments with context-aware discretion.
+
+## Usage
+
+```
+/code-rabbit
+```
+
+Then paste one or more CodeRabbit comments.
+
+## Instructions
+
+### 1. Initial Context
+
+Inform the user:
+
+```
+I'll review the CodeRabbit comments with discretion, as CodeRabbit doesn't have access to the entire codebase and may not understand the full context.
+
+For each comment, I'll:
+- Evaluate if it's valid given our codebase context
+- Accept suggestions that improve code quality
+- Ignore suggestions that don't apply to our architecture
+- Explain my reasoning for accept/ignore decisions
+```
+
+### 2. Process Comments
+
+#### Single File Comments
+
+If all comments relate to one file:
+
+- Read the file for context
+- Evaluate each suggestion
+- Apply accepted changes in batch using MultiEdit
+- Report which suggestions were accepted/ignored and why
+
+#### Multiple File Comments
+
+If comments span multiple files:
+
+Launch parallel sub-agents using Task tool:
+
+```yaml
+Task:
+  description: "CodeRabbit fixes for {filename}"
+  subagent_type: "general-purpose"
+  prompt: |
+    Review and apply CodeRabbit suggestions for {filename}.
+    
+    Comments to evaluate:
+    {relevant_comments_for_this_file}
+    
+    Instructions:
+    1. Read the file to understand context
+    2. For each suggestion:
+       - Evaluate validity given codebase patterns
+       - Accept if it improves quality/correctness
+       - Ignore if not applicable
+    3. Apply accepted changes using Edit/MultiEdit
+    4. Return summary:
+       - Accepted: {list with reasons}
+       - Ignored: {list with reasons}
+       - Changes made: {brief description}
+    
+    Use discretion - CodeRabbit lacks full context.
+```
+
+### 3. Consolidate Results
+
+After all sub-agents complete:
+
+```
+📋 CodeRabbit Review Summary
+
+Files Processed: {count}
+
+Accepted Suggestions:
+  {file}: {changes_made}
+  
+Ignored Suggestions:
+  {file}: {reason_ignored}
+
+Overall: {X}/{Y} suggestions applied
+```
+
+### 4. Common Patterns to Ignore
+
+- **Style preferences** that conflict with project conventions
+- **Generic best practices** that don't apply to our specific use case
+- **Performance optimizations** for code that isn't performance-critical
+- **Accessibility suggestions** for internal tools
+- **Security warnings** for already-validated patterns
+- **Import reorganization** that would break our structure
+
+### 5. Common Patterns to Accept
+
+- **Actual bugs** (null checks, error handling)
+- **Security vulnerabilities** (unless false positive)
+- **Resource leaks** (unclosed connections, memory leaks)
+- **Type safety issues** (TypeScript/type hints)
+- **Logic errors** (off-by-one, incorrect conditions)
+- **Missing error handling**
+
+## Decision Framework
+
+For each suggestion, consider:
+
+1. **Is it correct?** - Does the issue actually exist?
+2. **Is it relevant?** - Does it apply to our use case?
+3. **Is it beneficial?** - Will fixing it improve the code?
+4. **Is it safe?** - Could the change introduce problems?
+
+Only apply if all answers are "yes" or the benefit clearly outweighs risks.
+
+## Important Notes
+
+- CodeRabbit is helpful but lacks context
+- Trust your understanding of the codebase over generic suggestions
+- Explain decisions briefly to maintain audit trail
+- Batch related changes for efficiency
+- Use parallel agents for multi-file reviews to save time

package/packages/plugin-core/commands/prompt.md

@@ -0,0 +1,9 @@
+---
+allowed-tools: Bash, Read, Write, LS
+---
+
+# This is an ephemeral command
+
+Some complex prompts (with numerous @ references) may fail if entered directly into the prompt input.
+
+If that happens, write your prompt here and type in `/prompt` in the prompt command.

package/packages/plugin-core/commands/re-init.md

@@ -0,0 +1,9 @@
+---
+allowed-tools: Bash, Read, Write, LS
+---
+
+# Enhance CLAUDE.md file
+
+Please update CLAUDE.md with the rules from .claude/CLAUDE.md.
+
+If CLAUDE.md does not exist, create it using the /init and include rules from .claude/CLAUDE.md.

package/packages/plugin-core/hooks/context7-reminder.md

@@ -0,0 +1,29 @@
+# 🔴 MANDATORY: Context7 Query Required
+
+**BEFORE proceeding with this command/agent, you MUST:**
+
+1. **Read** the command/agent file to find `**Documentation Queries:**` section
+2. **Query Context7 MCP** for EACH listed topic
+3. **Verify** patterns against live documentation
+4. **Apply** Context7 guidance in your implementation
+
+## Why This Matters
+
+- **Training data is STALE** - APIs change, best practices evolve
+- **Context7 is CURRENT** - Live documentation, latest versions
+- **Hallucinations PREVENTED** - Real examples, verified patterns
+- **Quality GUARANTEED** - Industry-standard approaches
+
+## Zero Tolerance Policy
+
+❌ **NO** implementation without Context7 verification
+❌ **NO** "I remember how this works"
+❌ **NO** assumptions about API signatures
+✅ **ALWAYS** query Context7 first
+✅ **ALWAYS** verify against live docs
+✅ **ALWAYS** apply documented patterns
+
+---
+
+*This reminder is shown by `.claude/hooks/` enforcement system*
+*Defined in: `.claude/rules/context7-enforcement.md`*

package/packages/plugin-core/hooks/enforce-agents.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Hook enforcing agent usage instead of direct operations
+ * Usage: set as tool-use-hook in Claude Code configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class AgentEnforcer {
+  constructor() {
+    // Get tool name and parameters from arguments
+    this.toolName = process.argv[2] || '';
+    this.toolParams = process.argv[3] || '';
+
+    // Parse params if they're JSON
+    try {
+      this.parsedParams = JSON.parse(this.toolParams);
+    } catch {
+      this.parsedParams = {};
+    }
+  }
+
+  blockWithMessage(reason, agent, example) {
+    console.log(`❌ BLOCKED: ${reason}`);
+    console.log(`✅ INSTEAD: Use the ${agent} agent via Task tool`);
+    console.log('');
+    console.log('Example:');
+    console.log(`  Task: ${example}`);
+    process.exit(1);
+  }
+
+  checkBashUsage() {
+    if (this.toolName !== 'Bash') return;
+
+    // Block direct grep/find - should use code-analyzer
+    const codeSearchPattern = /(grep|rg|find|ag)\s+.*\.(py|js|ts|jsx|tsx)/;
+    if (codeSearchPattern.test(this.toolParams)) {
+      this.blockWithMessage(
+        'Direct code search detected',
+        'code-analyzer',
+        'Search for [pattern] in codebase'
+      );
+    }
+
+    // Block direct test execution - should use test-runner
+    const testExecPattern = /(pytest|npm test|yarn test|jest|vitest)/;
+    if (testExecPattern.test(this.toolParams)) {
+      this.blockWithMessage(
+        'Direct test execution detected',
+        'test-runner',
+        'Run and analyze test results'
+      );
+    }
+
+    // Block direct log reading - should use file-analyzer
+    const logReadPattern = /(cat|head|tail|less).*\.(log|txt|out)/;
+    if (logReadPattern.test(this.toolParams)) {
+      this.blockWithMessage(
+        'Direct log reading detected',
+        'file-analyzer',
+        'Analyze and summarize [log file]'
+      );
+    }
+  }
+
+  checkReadUsage() {
+    if (this.toolName !== 'Read') return;
+
+    const filePath = this.parsedParams.file_path;
+    if (!filePath) return;
+
+    // If file is larger than 1000 lines, enforce file-analyzer
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lineCount = content.split('\n').length;
+
+        if (lineCount > 1000) {
+          this.blockWithMessage(
+            `Reading large file directly (${lineCount} lines)`,
+            'file-analyzer',
+            `Summarize contents of ${filePath}`
+          );
+        }
+      } catch (error) {
+        // Can't read file, let it pass through
+      }
+    }
+  }
+
+  checkGrepUsage() {
+    if (this.toolName !== 'Grep') return;
+
+    const pattern = this.parsedParams.pattern;
+    if (!pattern) return;
+
+    // If pattern is complex or searches many files, use code-analyzer
+    const complexPattern = /(\.\*|\+|\{|\[)/;
+    if (complexPattern.test(pattern)) {
+      console.log('⚠️  SUGGESTION: For complex searches, consider using code-analyzer agent');
+      console.log('   It provides better context and analysis of results');
+      // Don't block, just suggest
+    }
+  }
+
+  run() {
+    // Check various tool usages
+    this.checkBashUsage();
+    this.checkReadUsage();
+    this.checkGrepUsage();
+
+    // If we got here, it's allowed - pass through
+    process.exit(0);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const enforcer = new AgentEnforcer();
+  enforcer.run();
+}
+
+module.exports = AgentEnforcer;

package/packages/plugin-core/hooks/enforce-agents.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+# Hook enforcing agent usage - Bridge to Node.js
+# This script now delegates to the Node.js version for better cross-platform support
+# Original bash implementation backed up to enforce-agents.sh.backup
+
+set -e  # Exit on error
+
+# Get the directory of this script
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Check if Node.js is available
+if ! command -v node &> /dev/null; then
+    echo "Error: Node.js is required but not installed."
+    echo "Please install Node.js first: https://nodejs.org/"
+    exit 1
+fi
+
+# Check if the Node.js version exists
+NODE_SCRIPT="$SCRIPT_DIR/enforce-agents.js"
+if [ ! -f "$NODE_SCRIPT" ]; then
+    echo "Error: Node.js implementation not found at $NODE_SCRIPT"
+    echo "Falling back to original bash implementation..."
+
+    # Try to use the backup if available
+    if [ -f "$SCRIPT_DIR/enforce-agents.sh.backup" ]; then
+        exec bash "$SCRIPT_DIR/enforce-agents.sh.backup" "$@"
+    else
+        echo "Error: No backup implementation found"
+        exit 1
+    fi
+fi
+
+# Execute the Node.js version with all arguments
+exec node "$NODE_SCRIPT" "$@"