Struct LearningManager 

pub struct LearningManager { /* private fields */ }

Central coordinator for all learning operations

Implementations

impl LearningManager

pub fn new(scope: RuleScope) -> Self

Create a new learning manager with the specified scope

pub fn with_config(config: LearningConfig) -> Result<Self>

Create a new learning manager with custom configuration

pub async fn get_config(&self) -> LearningConfig

Get the current configuration

pub async fn set_config(&self, config: LearningConfig) -> Result<()>

Update the configuration

pub async fn get_scope(&self) -> RuleScope

Get the current learning scope

pub async fn is_enabled(&self) -> bool

Check if learning is enabled

pub async fn set_enabled(&self, enabled: bool)

Enable or disable learning

pub async fn load_scope_configuration(&self) -> Result<ScopeConfiguration>

Load scope configuration from project/user/defaults hierarchy

pub async fn get_scope_configuration(&self) -> ScopeConfiguration

Get the current scope configuration

pub async fn set_scope_configuration( &self, config: ScopeConfiguration, ) -> Result<()>

Update the scope configuration

pub async fn is_scope_learning_enabled(&self) -> bool

Check if learning is enabled for the current scope

pub async fn set_scope_learning_enabled(&self, enabled: bool)

Enable or disable learning for the current scope

pub async fn is_project_only_learning(&self) -> bool

Check if project-only learning is enabled

pub async fn set_project_only_learning(&self, project_only: bool)

Enable or disable project-only learning

pub async fn is_approval_required(&self) -> bool

Check if approval is required for new rules

pub async fn set_approval_required(&self, required: bool)

Enable or disable approval requirement for new rules

pub async fn get_max_rules(&self) -> usize

Get the maximum number of rules for the current scope

pub async fn set_max_rules(&self, max_rules: usize) -> Result<()>

Set the maximum number of rules for the current scope

pub async fn get_retention_days(&self) -> u32

Get the retention period in days for the current scope

pub async fn set_retention_days(&self, retention_days: u32) -> Result<()>

Set the retention period in days for the current scope

pub async fn save_scope_configuration_to_project(&self) -> Result<()>

Save scope configuration to project-level config file

pub async fn save_scope_configuration_to_user(&self) -> Result<()>

Save scope configuration to user-level config file

pub async fn get_rules_for_scope(&self) -> Result<Vec<Rule>>

Get rules filtered by current scope

pub async fn get_rules_by_scope(&self, scope: RuleScope) -> Result<Vec<Rule>>

Get rules filtered by specific scope

pub async fn check_scope_interference( &self, scope1: RuleScope, scope2: RuleScope, ) -> Result<bool>

Check if rules from different scopes interfere

pub async fn capture_decision(&self, decision: Decision) -> Result<String>

Capture a decision with full metadata

pub async fn get_decisions(&self) -> Vec<Decision>

Get all captured decisions

pub async fn get_decisions_by_type(&self, decision_type: &str) -> Vec<Decision>

Get decisions by type

pub async fn get_decisions_by_context( &self, context: &DecisionContext, ) -> Vec<Decision>

Get decisions by context

pub async fn get_decision(&self, decision_id: &str) -> Result<Decision>

Get a specific decision by ID

pub async fn replay_decisions(&self) -> Vec<Decision>

Replay decisions for validation

pub async fn replay_decisions_for_context( &self, context: &DecisionContext, ) -> Vec<Decision>

Replay decisions for a specific context

pub async fn decision_count(&self) -> usize

Get the number of captured decisions

pub async fn clear_decisions(&self)

Clear all decisions

pub async fn get_decision_statistics(&self) -> DecisionStatistics

Get decision statistics

pub async fn store_rule(&self, rule: Rule) -> Result<String>

Store a rule (with validation)

pub async fn get_rule(&self, rule_id: &str) -> Result<Rule>

Get a rule by ID

pub async fn get_rules(&self) -> Result<Vec<Rule>>

Get all rules

pub async fn delete_rule(&self, rule_id: &str) -> Result<()>

Delete a rule

pub async fn update_rule(&self, rule: Rule) -> Result<String>

Update a rule (with validation)

pub fn validate_rule(&self, rule: &Rule) -> Result<()>

Validate a rule without storing it

pub fn validate_rule_with_report(&self, rule: &Rule) -> ValidationReport

Get a detailed validation report for a rule

pub async fn check_rule_conflicts(&self, rule: &Rule) -> Result<()>

Check if a rule conflicts with existing rules

pub async fn get_rules_by_pattern(&self, pattern: &str) -> Result<Vec<Rule>>

Get rules by pattern

pub async fn get_rules_by_source(&self, source: RuleSource) -> Result<Vec<Rule>>

Get rules by source

pub async fn get_rules_by_confidence( &self, min_confidence: f32, ) -> Result<Vec<Rule>>

Get rules by confidence

pub async fn get_rules_by_usage(&self) -> Result<Vec<Rule>>

Get rules sorted by usage

pub async fn get_rules_by_usage_count( &self, min_usage: u64, ) -> Result<Vec<Rule>>

Get rules by usage count

pub async fn get_rules_by_success_rate( &self, min_success_rate: f32, ) -> Result<Vec<Rule>>

Get rules by success rate

pub async fn rule_count(&self) -> Result<usize>

Get rule count

pub async fn clear_rules(&self) -> Result<()>

Clear all rules

pub async fn load_rules(&self) -> Result<()>

Load all rules into cache

pub fn detect_rule_conflict(rule1: &Rule, rule2: &Rule) -> bool

Detect if two rules conflict

pub async fn find_rule_conflicts(&self) -> Result<Vec<(Rule, Rule)>>

Find all conflicts in the current rules

pub async fn check_rule_conflicts_before_storage( &self, rule: &Rule, ) -> Result<()>

Check if a rule conflicts with existing rules before storage

pub async fn get_rule_by_pattern_with_precedence( &self, pattern: &str, ) -> Result<Option<Rule>>

Apply scope precedence to get the highest priority rule for a pattern

pub async fn get_rules_by_pattern_with_precedence( &self, pattern: &str, ) -> Result<Vec<Rule>>

Get all rules for a pattern, applying scope precedence

pub async fn resolve_all_conflicts(&self) -> Result<Vec<Rule>>

Resolve conflicts in all rules by applying scope precedence

pub async fn check_cross_scope_conflicts( &self, project_rules: &[Rule], global_rules: &[Rule], ) -> Vec<(Rule, Rule)>

Check for conflicts between project and global rules

pub fn log_conflict_resolution( selected_rule: &Rule, conflicting_rules: &[Rule], ) -> String

Log conflict resolution decision

pub async fn store_pattern(&self, pattern: LearnedPattern) -> Result<String>

Store a pattern

pub async fn get_pattern(&self, pattern_id: &str) -> Result<LearnedPattern>

Get a pattern

pub async fn get_patterns(&self) -> Vec<LearnedPattern>

Get all patterns

pub async fn get_patterns_by_type( &self, pattern_type: &str, ) -> Vec<LearnedPattern>

Get patterns by type

pub async fn delete_pattern(&self, pattern_id: &str) -> Result<()>

Delete a pattern

pub fn get_scope_path(&self, scope: RuleScope) -> Result<PathBuf>

Get the storage path for a given scope

pub async fn extract_patterns(&self) -> Result<Vec<LearnedPattern>>

Extract patterns from decision history

pub async fn extract_patterns_with_analysis( &self, ) -> Result<Vec<(LearnedPattern, PatternAnalysis)>>

Extract patterns from decision history with detailed analysis

pub async fn validate_pattern(&self, pattern: &LearnedPattern) -> Result<f32>

Validate a pattern against historical decisions

pub async fn update_pattern_confidence( &self, pattern_id: &str, validation_score: f32, ) -> Result<()>

Update pattern confidence based on validation results

pub async fn validate_pattern_comprehensive( &self, pattern: &LearnedPattern, ) -> Result<ValidationResult>

Validate a pattern using the pattern validator

pub async fn validate_patterns( &self, patterns: &[LearnedPattern], ) -> Result<Vec<ValidationResult>>

Validate multiple patterns

pub async fn get_pattern_validation_statistics( &self, ) -> Result<ValidationStatistics>

Get validation statistics for all stored patterns

pub async fn validate_and_update_pattern( &self, pattern_id: &str, ) -> Result<ValidationResult>

Validate and update pattern confidence based on validation results

pub async fn capture_and_store_patterns(&self) -> Result<Vec<String>>

Capture patterns from recent decisions and store them

pub async fn get_patterns_by_confidence( &self, min_confidence: f32, ) -> Vec<LearnedPattern>

Get patterns by confidence threshold

pub async fn get_patterns_by_confidence_sorted(&self) -> Vec<LearnedPattern>

Get patterns sorted by confidence

pub async fn get_patterns_by_occurrences(&self) -> Vec<LearnedPattern>

Get patterns sorted by occurrences

pub async fn pattern_count(&self) -> usize

Get pattern count

pub async fn clear_patterns(&self)

Clear all patterns

pub async fn request_rule_promotion(&self, rule: Rule) -> Result<RuleReview>

Request promotion of a rule from project to global scope

pub async fn get_pending_promotion(&self, rule_id: &str) -> Result<RuleReview>

Get a pending promotion for review

pub async fn get_pending_promotions(&self) -> Vec<RuleReview>

Get all pending promotions

pub async fn pending_promotion_count(&self) -> usize

Get the number of pending promotions

pub async fn approve_promotion( &self, rule_id: &str, reason: Option<String>, ) -> Result<Rule>

Approve a pending promotion and store the promoted rule

pub async fn reject_promotion( &self, rule_id: &str, reason: Option<String>, ) -> Result<()>

Reject a pending promotion

pub async fn get_promotion_history(&self) -> Vec<PromotionHistoryEntry>

Get promotion history

pub async fn get_promotion_history_for_rule( &self, rule_id: &str, ) -> Vec<PromotionHistoryEntry>

Get promotion history for a specific rule

pub async fn get_approved_promotions(&self) -> Vec<PromotionHistoryEntry>

Get approved promotions from history

pub async fn get_rejected_promotions(&self) -> Vec<PromotionHistoryEntry>

Get rejected promotions from history

pub async fn clear_pending_promotions(&self)

Clear all pending promotions

pub async fn clear_promotion_history(&self)

Clear promotion history

pub async fn apply_rule_to_context( &self, rule: &Rule, context: &GenerationContext, ) -> RuleApplicationResult

Apply a single rule to a generation context

pub async fn apply_rules_to_context( &self, rules: &[Rule], context: &GenerationContext, ) -> Vec<RuleApplicationResult>

Apply multiple rules to a generation context

pub async fn apply_rules_with_precedence( &self, rules: &[Rule], context: &GenerationContext, ) -> Option<RuleApplicationResult>

Apply rules with precedence to get the best matching rule

pub async fn chain_rules( &self, rules: &[Rule], context: &GenerationContext, ) -> Result<Vec<RuleApplicationResult>>

Chain multiple rules together for sequential application

pub async fn compose_rules( &self, rules: &[Rule], context: &GenerationContext, ) -> Result<Option<String>>

Compose multiple rules into a single action

pub async fn validate_rule_application( &self, rule: &Rule, context: &GenerationContext, ) -> Result<()>

Validate that a rule can be applied to a context

pub async fn get_matching_rules( &self, context: &GenerationContext, ) -> Result<Vec<Rule>>

Get all matching rules for a context

pub async fn get_matching_rules_sorted( &self, context: &GenerationContext, ) -> Result<Vec<Rule>>

Get matching rules sorted by confidence

pub async fn get_matching_rules_by_usage( &self, context: &GenerationContext, ) -> Result<Vec<Rule>>

Get matching rules sorted by usage

pub async fn get_matching_rules_by_success( &self, context: &GenerationContext, ) -> Result<Vec<Rule>>

Get matching rules sorted by success rate

pub async fn apply_learned_rules_to_generation( &self, context: &GenerationContext, ) -> Result<Option<String>>

Apply learned rules to guide code generation

pub async fn apply_learned_rules_get_all( &self, context: &GenerationContext, ) -> Result<Vec<String>>

Apply learned rules and get all matching actions

pub async fn apply_learned_rules_with_context( &self, generation_type: String, language: String, input: String, ) -> Result<Option<String>>

Apply learned rules with context-based matching

pub async fn record_rule_application( &self, rule_id: String, success: bool, application_time_ms: f64, ) -> Result<()>

Record a rule application in analytics

pub async fn get_rule_metrics( &self, rule_id: &str, ) -> Result<Option<RuleMetrics>>

Get metrics for a specific rule

pub async fn get_all_rule_metrics(&self) -> Result<Vec<RuleMetrics>>

Get all rule metrics

pub async fn update_rule_confidence( &self, rule_id: &str, new_confidence: f32, ) -> Result<()>

Update rule confidence based on validation results

pub async fn generate_analytics_insights(&self) -> Result<AnalyticsInsights>

Generate analytics insights

pub async fn clear_analytics_metrics(&self) -> Result<()>

Clear all analytics metrics

pub async fn get_metrics_for_scope( &self, scope: RuleScope, ) -> Result<Vec<RuleMetrics>>

Get metrics for rules in a specific scope

pub async fn export_rules_with_metrics( &self, description: Option<String>, ) -> Result<String>

Export rules with metrics to JSON

pub async fn export_rules_to_file( &self, path: &Path, description: Option<String>, ) -> Result<()>

Export rules with metrics to file

pub async fn import_rules_from_json(&self, json: &str) -> Result<Vec<Rule>>

Import rules from JSON with validation

pub async fn import_rules_from_file(&self, path: &Path) -> Result<Vec<Rule>>

Import rules from file with validation

pub async fn import_and_validate_rules( &self, json: &str, ) -> Result<(Vec<Rule>, Vec<String>)>

Import and validate rules, returning both valid and invalid rules

pub async fn store_imported_rules( &self, rules: Vec<Rule>, ) -> Result<Vec<String>>

Store imported rules