648 lines
22 KiB
Markdown
648 lines
22 KiB
Markdown
# Dynamic Rule Engine
|
|
|
|
## Real-time Rule Generation and Management for Claude Code
|
|
|
|
The Dynamic Rule Engine enables Claude Code to create, adapt, and apply intelligent rules based on project context, learned patterns, and real-time development situations.
|
|
|
|
### Rule Architecture for Claude Code Integration
|
|
|
|
#### Rule Structure and Classification
|
|
```yaml
|
|
rule_definition:
|
|
metadata:
|
|
id: "{uuid}"
|
|
name: "prevent_database_connection_leaks"
|
|
category: "security|performance|quality|process|integration"
|
|
created_by: "error_prevention_system"
|
|
created_from: "pattern_analysis"
|
|
created_timestamp: "2024-01-15T10:30:00Z"
|
|
confidence_level: 87 # 0-100 confidence score
|
|
usage_count: 15
|
|
success_rate: 94.2
|
|
|
|
conditions:
|
|
when:
|
|
- context_matches: "database_operations"
|
|
- file_pattern: "**/*.{js,ts}"
|
|
- technology_includes: ["nodejs", "postgresql", "mysql"]
|
|
- operation_type: "code_modification"
|
|
|
|
unless:
|
|
- exception_condition: "test_files"
|
|
- override_present: "disable_connection_check"
|
|
- development_mode: true
|
|
|
|
actions:
|
|
must:
|
|
- action: "validate_connection_cleanup"
|
|
reason: "Prevent connection pool exhaustion"
|
|
claude_tools: ["Grep", "Read"]
|
|
validation_pattern: "connection.*close|pool.*release"
|
|
|
|
should:
|
|
- action: "suggest_connection_pool_monitoring"
|
|
benefit: "Early detection of connection issues"
|
|
claude_tools: ["Write", "Edit"]
|
|
template: "connection_monitoring_template"
|
|
|
|
must_not:
|
|
- action: "create_connection_without_cleanup"
|
|
consequence: "Potential connection pool exhaustion"
|
|
detection_pattern: "new.*Connection(?!.*close)"
|
|
|
|
validation:
|
|
how_to_verify:
|
|
- "Use Grep to find connection creation patterns"
|
|
- "Verify each connection has corresponding cleanup"
|
|
- "Check error handling paths for connection cleanup"
|
|
automated_check: true
|
|
success_criteria: "All connections have cleanup in same function or try/catch"
|
|
claude_code_implementation: |
|
|
async function validate_connection_cleanup(file_path) {
|
|
const content = await claude_code_read(file_path);
|
|
const connections = await claude_code_grep("new.*Connection", file_path);
|
|
|
|
for (const connection of connections.matches) {
|
|
const cleanup_check = await claude_code_grep(
|
|
"close|release|end",
|
|
file_path,
|
|
{ context: 10, line_start: connection.line_number }
|
|
);
|
|
|
|
if (!cleanup_check.matches.length) {
|
|
return {
|
|
valid: false,
|
|
issue: `Connection at line ${connection.line_number} lacks cleanup`,
|
|
suggestion: "Add connection.close() or pool.release(connection)"
|
|
};
|
|
}
|
|
}
|
|
|
|
return { valid: true };
|
|
}
|
|
|
|
learning_context:
|
|
source_incidents: ["connection_pool_exhaustion_incident_2024_01_10"]
|
|
related_patterns: ["resource_management", "error_handling"]
|
|
applicable_technologies: ["nodejs", "python", "java"]
|
|
project_types: ["web_api", "microservices", "data_processing"]
|
|
|
|
adaptation_rules:
|
|
technology_adaptations:
|
|
python:
|
|
pattern_modifications:
|
|
- original: "new.*Connection"
|
|
- adapted: "connect\\(|Connection\\("
|
|
cleanup_patterns:
|
|
- "close()"
|
|
- "disconnect()"
|
|
- "with.*as.*conn:"
|
|
java:
|
|
pattern_modifications:
|
|
- original: "new.*Connection"
|
|
- adapted: "DriverManager\\.getConnection|DataSource\\.getConnection"
|
|
cleanup_patterns:
|
|
- "close()"
|
|
- "try-with-resources"
|
|
```
|
|
|
|
### Dynamic Rule Generation
|
|
|
|
#### Pattern-Based Rule Creation
|
|
```python
|
|
async def generate_rules_from_patterns(pattern_analysis, project_context):
|
|
"""
|
|
Generate intelligent rules from detected patterns using Claude Code insights
|
|
"""
|
|
generated_rules = []
|
|
|
|
for pattern in pattern_analysis.successful_patterns:
|
|
# Analyze pattern for rule generation potential
|
|
rule_potential = assess_rule_generation_potential(pattern)
|
|
|
|
if rule_potential.score > 0.7: # High potential for useful rule
|
|
# Extract rule components from pattern
|
|
rule_components = extract_rule_components(pattern, project_context)
|
|
|
|
# Generate rule using Claude Code tools for validation
|
|
generated_rule = await create_rule_from_pattern(
|
|
rule_components,
|
|
pattern,
|
|
project_context
|
|
)
|
|
|
|
# Validate rule effectiveness
|
|
validation_result = await validate_rule_effectiveness(
|
|
generated_rule,
|
|
project_context
|
|
)
|
|
|
|
if validation_result.is_effective:
|
|
generated_rules.append(generated_rule)
|
|
|
|
# Generate rules from error patterns
|
|
for error_pattern in pattern_analysis.error_patterns:
|
|
prevention_rule = await generate_prevention_rule(
|
|
error_pattern,
|
|
project_context
|
|
)
|
|
|
|
if prevention_rule:
|
|
generated_rules.append(prevention_rule)
|
|
|
|
return generated_rules
|
|
|
|
async def create_rule_from_pattern(rule_components, pattern, project_context):
|
|
"""
|
|
Create a structured rule from pattern components
|
|
"""
|
|
rule = {
|
|
'id': generate_uuid(),
|
|
'name': generate_rule_name(pattern),
|
|
'category': classify_rule_category(pattern),
|
|
'created_by': 'pattern_analysis',
|
|
'created_from': pattern.source,
|
|
'confidence_level': pattern.confidence_score,
|
|
'metadata': {
|
|
'pattern_id': pattern.id,
|
|
'source_projects': pattern.source_projects,
|
|
'success_rate': pattern.success_rate
|
|
}
|
|
}
|
|
|
|
# Define conditions based on pattern context
|
|
rule['conditions'] = {
|
|
'when': [
|
|
{'context_matches': pattern.context_type},
|
|
{'technology_includes': pattern.applicable_technologies},
|
|
{'file_pattern': pattern.file_patterns}
|
|
],
|
|
'unless': extract_exception_conditions(pattern)
|
|
}
|
|
|
|
# Define actions based on pattern behavior
|
|
if pattern.type == 'success_pattern':
|
|
rule['actions'] = generate_success_pattern_actions(pattern, project_context)
|
|
elif pattern.type == 'error_pattern':
|
|
rule['actions'] = generate_error_prevention_actions(pattern, project_context)
|
|
|
|
# Create validation strategy using Claude Code tools
|
|
rule['validation'] = await create_validation_strategy(pattern, project_context)
|
|
|
|
return rule
|
|
|
|
async def generate_success_pattern_actions(pattern, project_context):
|
|
"""
|
|
Generate actions that encourage successful pattern adoption
|
|
"""
|
|
actions = {
|
|
'should': [],
|
|
'could': [],
|
|
'consider': []
|
|
}
|
|
|
|
# Analyze what made this pattern successful
|
|
success_factors = analyze_pattern_success_factors(pattern)
|
|
|
|
for factor in success_factors:
|
|
if factor.impact_score > 0.8: # High impact
|
|
action = {
|
|
'action': f"apply_{factor.name}",
|
|
'benefit': factor.benefit_description,
|
|
'claude_tools': determine_required_tools(factor),
|
|
'implementation_guide': await generate_implementation_guide(
|
|
factor,
|
|
project_context
|
|
)
|
|
}
|
|
actions['should'].append(action)
|
|
|
|
elif factor.impact_score > 0.5: # Medium impact
|
|
action = {
|
|
'action': f"consider_{factor.name}",
|
|
'benefit': factor.benefit_description,
|
|
'claude_tools': determine_required_tools(factor),
|
|
'when_appropriate': factor.applicable_contexts
|
|
}
|
|
actions['could'].append(action)
|
|
|
|
return actions
|
|
|
|
async def generate_error_prevention_actions(pattern, project_context):
|
|
"""
|
|
Generate actions that prevent error patterns
|
|
"""
|
|
actions = {
|
|
'must': [],
|
|
'must_not': [],
|
|
'validate': []
|
|
}
|
|
|
|
# Analyze error causes and prevention strategies
|
|
error_analysis = analyze_error_pattern(pattern)
|
|
|
|
for prevention_strategy in error_analysis.prevention_strategies:
|
|
if prevention_strategy.criticality == 'high':
|
|
# Create mandatory prevention action
|
|
must_action = {
|
|
'action': prevention_strategy.action_name,
|
|
'reason': prevention_strategy.reasoning,
|
|
'claude_tools': prevention_strategy.required_tools,
|
|
'validation_pattern': prevention_strategy.validation_regex,
|
|
'implementation': await generate_prevention_implementation(
|
|
prevention_strategy,
|
|
project_context
|
|
)
|
|
}
|
|
actions['must'].append(must_action)
|
|
|
|
# Create prohibition actions for dangerous patterns
|
|
if prevention_strategy.prohibits:
|
|
must_not_action = {
|
|
'action': prevention_strategy.prohibited_action,
|
|
'consequence': prevention_strategy.consequence_description,
|
|
'detection_pattern': prevention_strategy.detection_regex,
|
|
'alternative_approach': prevention_strategy.safer_alternative
|
|
}
|
|
actions['must_not'].append(must_not_action)
|
|
|
|
return actions
|
|
```
|
|
|
|
#### Context-Aware Rule Application
|
|
```python
|
|
async def apply_rules_to_claude_operation(operation_type, operation_context, available_rules):
|
|
"""
|
|
Apply relevant rules to Claude Code operations
|
|
"""
|
|
# Filter rules relevant to current operation
|
|
relevant_rules = filter_relevant_rules(
|
|
available_rules,
|
|
operation_type,
|
|
operation_context
|
|
)
|
|
|
|
# Sort rules by priority and confidence
|
|
prioritized_rules = prioritize_rules(relevant_rules, operation_context)
|
|
|
|
rule_application_results = {
|
|
'preventive_actions': [],
|
|
'suggestions': [],
|
|
'validations': [],
|
|
'warnings': []
|
|
}
|
|
|
|
for rule in prioritized_rules:
|
|
# Check rule conditions
|
|
condition_check = await evaluate_rule_conditions(rule, operation_context)
|
|
|
|
if condition_check.applies:
|
|
# Apply rule actions
|
|
application_result = await apply_rule_actions(
|
|
rule,
|
|
operation_context,
|
|
condition_check
|
|
)
|
|
|
|
# Categorize results
|
|
if rule['category'] in ['security', 'critical']:
|
|
rule_application_results['preventive_actions'].extend(
|
|
application_result.preventive_actions
|
|
)
|
|
|
|
rule_application_results['suggestions'].extend(
|
|
application_result.suggestions
|
|
)
|
|
|
|
rule_application_results['validations'].extend(
|
|
application_result.validations
|
|
)
|
|
|
|
if application_result.warnings:
|
|
rule_application_results['warnings'].extend(
|
|
application_result.warnings
|
|
)
|
|
|
|
return rule_application_results
|
|
|
|
async def apply_rule_actions(rule, operation_context, condition_check):
|
|
"""
|
|
Apply specific rule actions using Claude Code tools
|
|
"""
|
|
application_result = {
|
|
'preventive_actions': [],
|
|
'suggestions': [],
|
|
'validations': [],
|
|
'warnings': []
|
|
}
|
|
|
|
# Apply 'must' actions (mandatory)
|
|
for must_action in rule['actions'].get('must', []):
|
|
try:
|
|
action_result = await execute_must_action(
|
|
must_action,
|
|
operation_context
|
|
)
|
|
application_result['preventive_actions'].append(action_result)
|
|
|
|
except Exception as e:
|
|
# Mandatory action failed - this is a warning
|
|
application_result['warnings'].append({
|
|
'rule_id': rule['id'],
|
|
'action': must_action['action'],
|
|
'error': str(e),
|
|
'severity': 'high'
|
|
})
|
|
|
|
# Apply 'should' actions (recommendations)
|
|
for should_action in rule['actions'].get('should', []):
|
|
try:
|
|
suggestion_result = await execute_should_action(
|
|
should_action,
|
|
operation_context
|
|
)
|
|
application_result['suggestions'].append(suggestion_result)
|
|
|
|
except Exception as e:
|
|
# Recommendation failed - log but continue
|
|
application_result['warnings'].append({
|
|
'rule_id': rule['id'],
|
|
'action': should_action['action'],
|
|
'error': str(e),
|
|
'severity': 'low'
|
|
})
|
|
|
|
# Check 'must_not' actions (prohibitions)
|
|
for must_not_action in rule['actions'].get('must_not', []):
|
|
violation_check = await check_prohibition_violation(
|
|
must_not_action,
|
|
operation_context
|
|
)
|
|
|
|
if violation_check.is_violated:
|
|
application_result['warnings'].append({
|
|
'rule_id': rule['id'],
|
|
'violation': must_not_action['action'],
|
|
'consequence': must_not_action['consequence'],
|
|
'severity': 'critical',
|
|
'detection_details': violation_check.details
|
|
})
|
|
|
|
return application_result
|
|
|
|
async def execute_must_action(must_action, operation_context):
|
|
"""
|
|
Execute mandatory rule action using appropriate Claude Code tools
|
|
"""
|
|
action_type = must_action['action']
|
|
required_tools = must_action.get('claude_tools', [])
|
|
|
|
if action_type.startswith('validate_'):
|
|
# Validation action
|
|
validation_result = await execute_validation_action(
|
|
must_action,
|
|
operation_context,
|
|
required_tools
|
|
)
|
|
return {
|
|
'type': 'validation',
|
|
'action': action_type,
|
|
'result': validation_result,
|
|
'passed': validation_result.get('valid', False)
|
|
}
|
|
|
|
elif action_type.startswith('ensure_'):
|
|
# Enforcement action
|
|
enforcement_result = await execute_enforcement_action(
|
|
must_action,
|
|
operation_context,
|
|
required_tools
|
|
)
|
|
return {
|
|
'type': 'enforcement',
|
|
'action': action_type,
|
|
'result': enforcement_result,
|
|
'applied': enforcement_result.get('success', False)
|
|
}
|
|
|
|
elif action_type.startswith('prevent_'):
|
|
# Prevention action
|
|
prevention_result = await execute_prevention_action(
|
|
must_action,
|
|
operation_context,
|
|
required_tools
|
|
)
|
|
return {
|
|
'type': 'prevention',
|
|
'action': action_type,
|
|
'result': prevention_result,
|
|
'prevented': prevention_result.get('blocked', False)
|
|
}
|
|
|
|
return {
|
|
'type': 'unknown',
|
|
'action': action_type,
|
|
'result': {'error': 'Unknown action type'},
|
|
'applied': False
|
|
}
|
|
```
|
|
|
|
### Rule Learning and Evolution
|
|
|
|
#### Adaptive Rule Improvement
|
|
```python
|
|
async def learn_from_rule_applications():
|
|
"""
|
|
Learn from rule application outcomes to improve rule effectiveness
|
|
"""
|
|
# Get recent rule applications
|
|
recent_applications = await get_recent_rule_applications(days=7)
|
|
|
|
learning_insights = {
|
|
'effective_rules': [],
|
|
'ineffective_rules': [],
|
|
'rule_improvements': [],
|
|
'new_rule_opportunities': []
|
|
}
|
|
|
|
for application in recent_applications:
|
|
# Analyze rule effectiveness
|
|
effectiveness_analysis = analyze_rule_effectiveness(application)
|
|
|
|
if effectiveness_analysis.was_helpful:
|
|
learning_insights['effective_rules'].append({
|
|
'rule_id': application.rule_id,
|
|
'effectiveness_score': effectiveness_analysis.score,
|
|
'positive_outcomes': effectiveness_analysis.positive_outcomes
|
|
})
|
|
else:
|
|
learning_insights['ineffective_rules'].append({
|
|
'rule_id': application.rule_id,
|
|
'issues': effectiveness_analysis.issues,
|
|
'improvement_suggestions': effectiveness_analysis.improvements
|
|
})
|
|
|
|
# Identify improvement opportunities
|
|
for ineffective_rule in learning_insights['ineffective_rules']:
|
|
rule_improvements = await generate_rule_improvements(
|
|
ineffective_rule['rule_id'],
|
|
ineffective_rule['issues'],
|
|
ineffective_rule['improvement_suggestions']
|
|
)
|
|
learning_insights['rule_improvements'].append(rule_improvements)
|
|
|
|
# Apply improvements
|
|
for improvement in learning_insights['rule_improvements']:
|
|
await apply_rule_improvement(improvement)
|
|
|
|
return learning_insights
|
|
|
|
async def evolve_rule_based_on_feedback(rule_id, feedback_data):
|
|
"""
|
|
Evolve a specific rule based on usage feedback and outcomes
|
|
"""
|
|
# Load current rule
|
|
current_rule = await load_rule(rule_id)
|
|
|
|
# Analyze feedback patterns
|
|
feedback_analysis = analyze_rule_feedback(feedback_data)
|
|
|
|
evolution_changes = {
|
|
'condition_refinements': [],
|
|
'action_improvements': [],
|
|
'confidence_adjustments': [],
|
|
'scope_modifications': []
|
|
}
|
|
|
|
# Refine conditions based on false positives/negatives
|
|
if feedback_analysis.false_positives > 0.1: # 10% false positive rate
|
|
condition_refinements = refine_rule_conditions(
|
|
current_rule['conditions'],
|
|
feedback_analysis.false_positive_cases
|
|
)
|
|
evolution_changes['condition_refinements'] = condition_refinements
|
|
|
|
# Improve actions based on effectiveness feedback
|
|
if feedback_analysis.action_effectiveness < 0.7: # 70% effectiveness threshold
|
|
action_improvements = improve_rule_actions(
|
|
current_rule['actions'],
|
|
feedback_analysis.action_feedback
|
|
)
|
|
evolution_changes['action_improvements'] = action_improvements
|
|
|
|
# Adjust confidence based on success rate
|
|
new_confidence = calculate_updated_confidence(
|
|
current_rule['confidence_level'],
|
|
feedback_analysis.success_rate,
|
|
feedback_analysis.sample_size
|
|
)
|
|
evolution_changes['confidence_adjustments'] = new_confidence
|
|
|
|
# Apply evolution changes
|
|
evolved_rule = await apply_rule_evolution(current_rule, evolution_changes)
|
|
|
|
# Store evolved rule
|
|
await store_evolved_rule(evolved_rule)
|
|
|
|
return {
|
|
'rule_id': rule_id,
|
|
'evolution_applied': True,
|
|
'changes': evolution_changes,
|
|
'new_confidence': new_confidence
|
|
}
|
|
```
|
|
|
|
### Rule Repository Management
|
|
|
|
#### Intelligent Rule Organization
|
|
```yaml
|
|
rule_repository:
|
|
categorization:
|
|
by_domain:
|
|
security_rules:
|
|
- authentication_patterns
|
|
- authorization_checks
|
|
- input_validation
|
|
- secure_communications
|
|
|
|
performance_rules:
|
|
- caching_strategies
|
|
- database_optimization
|
|
- resource_management
|
|
- algorithm_efficiency
|
|
|
|
quality_rules:
|
|
- code_standards
|
|
- testing_requirements
|
|
- documentation_standards
|
|
- maintainability_patterns
|
|
|
|
by_technology:
|
|
javascript_rules:
|
|
- nodejs_specific
|
|
- react_patterns
|
|
- async_handling
|
|
- package_management
|
|
|
|
python_rules:
|
|
- django_patterns
|
|
- flask_patterns
|
|
- data_processing
|
|
- dependency_management
|
|
|
|
by_project_phase:
|
|
development_rules:
|
|
- coding_standards
|
|
- testing_practices
|
|
- version_control
|
|
|
|
deployment_rules:
|
|
- configuration_management
|
|
- environment_setup
|
|
- monitoring_setup
|
|
|
|
rule_lifecycle:
|
|
creation:
|
|
- pattern_analysis
|
|
- manual_definition
|
|
- error_learning
|
|
- best_practice_codification
|
|
|
|
evolution:
|
|
- feedback_incorporation
|
|
- effectiveness_optimization
|
|
- scope_refinement
|
|
- condition_improvement
|
|
|
|
retirement:
|
|
- obsolescence_detection
|
|
- replacement_with_better_rules
|
|
- context_no_longer_applicable
|
|
- low_effectiveness_score
|
|
```
|
|
|
|
### Claude Code Integration Commands
|
|
|
|
```bash
|
|
# Rule generation and management
|
|
bmad rules generate --from-patterns --project-context "current"
|
|
bmad rules create --manual --category "security" --name "api_validation"
|
|
bmad rules import --from-project "path/to/project" --extract-patterns
|
|
|
|
# Rule application and validation
|
|
bmad rules apply --to-operation "file_edit" --file "src/auth.js"
|
|
bmad rules validate --rule-id "uuid" --test-context "nodejs_api"
|
|
bmad rules check --violations --severity "high"
|
|
|
|
# Rule learning and evolution
|
|
bmad rules learn --from-outcomes --time-period "last-week"
|
|
bmad rules evolve --rule-id "uuid" --based-on-feedback
|
|
bmad rules optimize --repository --remove-ineffective --merge-similar
|
|
|
|
# Rule analysis and reporting
|
|
bmad rules analyze --effectiveness --by-category
|
|
bmad rules report --usage-statistics --time-period "last-month"
|
|
bmad rules export --active-rules --format "yaml"
|
|
```
|
|
|
|
This Dynamic Rule Engine transforms Claude Code into an intelligent development assistant that can automatically create and apply context-appropriate rules, learn from experience, and continuously improve its guidance to prevent errors and promote best practices. |