refactor(chat_interface): improve command parsing and execution logic

This commit refactors the chat interface to enhance command parsing and
execution. It simplifies the argument parsing process, adds support for
the 'user' parameter, and improves error handling. The changes also
ensure consistent behavior between the CLI and chat interface for date
handling and default values.

Author: pimoussTO

src/wellcode_cli/commands/chat_interface.py

@@ -68,7 +68,7 @@ def chat_interface():
                     console.print(f"[dim]Interpreting as: {interpreted_command}[/dim]")
 
                     if interpreted_command:
-                        execute_command(command)
+                        execute_command(interpreted_command)
                     else:
                         console.print("[yellow]I couldn't understand that request. Try rephrasing or type 'help' for suggestions.[/]")
 
@@ -89,48 +89,45 @@ def execute_command(command_str: str) -> bool:
         ctx = click.get_current_context()
 
         if command_type == CommandType.REVIEW:
-            # Clean up the command string and split properly
-            args = command_str.strip('"\'').split()
+            
+            parts = command_str.split()
+            
             date_args = {}
 
-            # Parse args list properly
-            i = 0
-            while i < len(args):
-                if args[i].startswith('--'):
-                    key = args[i].strip('--')
-                    if i + 1 < len(args):
-                        value = args[i + 1]
-                        date_args[key] = value
-                        i += 2
-                    else:
-                        i += 1
-                else:
-                    i += 1
-
+            # Parse the command parts directly
+            for i in range(len(parts)):
+                if parts[i] == '--start-date' and i + 1 < len(parts):
+                    date_args['start-date'] = parts[i + 1]
+                elif parts[i] == '--end-date' and i + 1 < len(parts):
+                    date_args['end-date'] = parts[i + 1]
+                elif parts[i] == '--team' and i + 1 < len(parts):
+                    date_args['team'] = parts[i + 1]
+                elif parts[i] == '--user' and i + 1 < len(parts):
+                    date_args['user'] = parts[i + 1]
+            
+            
             # Initialize dates
             now = datetime.now()
 
-            try:
-                if 'start-date' in date_args and 'end-date' in date_args:
-                    start_date = datetime.strptime(date_args['start-date'], '%Y-%m-%d')
-                    end_date = datetime.strptime(date_args['end-date'], '%Y-%m-%d')
-                else:
-                    # Default to last 7 days
-                    end_date = now
-                    start_date = end_date - timedelta(days=7)
+            if 'start-date' in date_args and 'end-date' in date_args:
+                start_date = datetime.strptime(date_args['start-date'], '%Y-%m-%d')
+                end_date = datetime.strptime(date_args['end-date'], '%Y-%m-%d')
+            else:
+                # Default to last 7 days
+                end_date = now
+                start_date = end_date - timedelta(days=7)
 
-                # Ensure proper time boundaries
-                end_date = end_date.replace(hour=23, minute=59, second=59)
-                start_date = start_date.replace(hour=0, minute=0, second=0)
+            # Ensure proper time boundaries
+            end_date = end_date.replace(hour=23, minute=59, second=59)
+            start_date = start_date.replace(hour=0, minute=0, second=0)
 
-                # Get team from args
-                team = date_args.get('team')
-                
-                ctx.invoke(review, start_date=start_date, end_date=end_date, team=team)
-                
-            except Exception as e:
-                console.print(f"[red]Error processing dates: {e}[/]")
-                return False
+            # Get team from args
+            team = date_args.get('team')
+
+            # get user from args
+            user = date_args.get('user')
+            
+            ctx.invoke(review, start_date=start_date, end_date=end_date, team=team, user=user)
         elif command_type == CommandType.CONFIG:
             ctx.invoke(config)
         elif command_type == CommandType.HELP:

src/wellcode_cli/commands/review.py

@@ -30,11 +30,11 @@ def review(start_date, end_date, user, team):
     if end_date is None:
         end_date = datetime.now()
 
-    # Handle start date
+    # Handle start date - use the passed start_date instead of defaulting to 1 day
     if start_date is None:
-        start_date = end_date - timedelta(days=1)
+        start_date = end_date - timedelta(days=7)  # Changed from 1 to 7 days default
 
-    # Ensure we're working with whole days
+    # Ensure we're working with whole days and use the passed dates
     start_date = start_date.replace(hour=0, minute=0, second=0, microsecond=0)
     end_date = end_date.replace(hour=23, minute=59, second=59, microsecond=999999)
 

src/wellcode_cli/github/github_metrics.py

@@ -149,11 +149,17 @@ def process_repository_batch(repo, org_metrics, start_date, end_date, user_filte
         repo_metrics = org_metrics.get_or_create_repository(repo.name)
         repo_metrics.default_branch = repo.default_branch
 
-        # Track PR counts
+        # Track PR counts for both repo and org
         repo_metrics.prs_created += len(relevant_pulls)
+        org_metrics.prs_created += len(relevant_pulls)
+        
         merged_prs = [pr for pr in relevant_pulls if pr.merged]
         repo_metrics.prs_merged += len(merged_prs)
-        repo_metrics.prs_merged_to_main += sum(1 for pr in merged_prs if pr.base.ref == repo_metrics.default_branch)
+        org_metrics.prs_merged += len(merged_prs)
+        
+        merged_to_main = sum(1 for pr in merged_prs if pr.base.ref == repo_metrics.default_branch)
+        repo_metrics.prs_merged_to_main += merged_to_main
+        org_metrics.prs_merged_to_main += merged_to_main
 
         # Add contributor tracking
         for pr in relevant_pulls:
@@ -200,7 +206,6 @@ def process_pr(pr, repo_metrics, org_metrics, start_date, end_date):
                                repo_metrics, org_metrics)
         ]
 
-        # Wait for all updates to complete
         for future in as_completed(futures):
             future.result()
 
@@ -279,28 +284,56 @@ def update_review_metrics(pr, pr_data, repo_metrics, org_metrics):
 
 def update_time_metrics(pr, commits, repo_metrics, org_metrics, start_date, end_date):
     """Update time metrics for a PR"""
-    if pr.merged_at:
-        merge_time = ensure_datetime(pr.merged_at)
-        
-        # Update merge distribution
-        if merge_time.weekday() >= 5:  # Weekend
-            repo_metrics.time_metrics.merge_distribution['weekends'] += 1
-            org_metrics.time_metrics.merge_distribution['weekends'] += 1
-        elif 9 <= merge_time.hour < 17:  # Business hours (simplified)
-            repo_metrics.time_metrics.merge_distribution['business_hours'] += 1
-            org_metrics.time_metrics.merge_distribution['business_hours'] += 1
-        else:  # After hours
-            repo_metrics.time_metrics.merge_distribution['after_hours'] += 1
-            org_metrics.time_metrics.merge_distribution['after_hours'] += 1
+    try:
+        if pr.merged_at:
+            # Convert all times to datetime with timezone
+            merge_time = ensure_datetime(pr.merged_at)
+            created_time = ensure_datetime(pr.created_at)
 
-        # Calculate deployment frequency (merges per day to main branch)
-        if pr.base.ref == repo_metrics.default_branch:
-            one_day_seconds = 24 * 60 * 60
-            days_in_period = (end_date - start_date).total_seconds() / one_day_seconds
-            repo_metrics.time_metrics.deployment_frequency = repo_metrics.prs_merged_to_main / days_in_period
-            org_metrics.time_metrics.deployment_frequency = org_metrics.prs_merged_to_main / days_in_period
-
-    # ... rest of existing update_time_metrics code ...
+            # Calculate time to merge in hours
+            merge_duration = (merge_time - created_time).total_seconds() / 3600
+            repo_metrics.time_metrics.time_to_merge.append(merge_duration)
+            org_metrics.time_metrics.time_to_merge.append(merge_duration)
+            
+            # Calculate lead time if we have commits
+            if commits and len(commits) > 0:
+                first_commit = min(commits, key=lambda c: ensure_datetime(c.commit.author.date))
+                first_commit_date = ensure_datetime(first_commit.commit.author.date)
+                lead_time = (merge_time - first_commit_date).total_seconds() / 3600
+                repo_metrics.time_metrics.lead_times.append(lead_time)
+                org_metrics.time_metrics.lead_times.append(lead_time)
+                
+                # Calculate cycle time
+                cycle_time = (merge_time - first_commit_date).total_seconds() / 3600
+                repo_metrics.time_metrics.cycle_time.append(cycle_time)
+                org_metrics.time_metrics.cycle_time.append(cycle_time)
+            
+            # Update merge distribution
+            if merge_time.weekday() >= 5:  # Weekend
+                repo_metrics.time_metrics.merge_distribution['weekends'] += 1
+                org_metrics.time_metrics.merge_distribution['weekends'] += 1
+            elif 9 <= merge_time.hour < 17:  # Business hours
+                repo_metrics.time_metrics.merge_distribution['business_hours'] += 1
+                org_metrics.time_metrics.merge_distribution['business_hours'] += 1
+            else:  # After hours
+                repo_metrics.time_metrics.merge_distribution['after_hours'] += 1
+                org_metrics.time_metrics.merge_distribution['after_hours'] += 1
+            
+            # Calculate deployment frequency with safety check
+            if pr.base.ref == repo_metrics.default_branch:
+                one_day_seconds = 24 * 60 * 60
+                days_in_period = max((end_date - start_date).total_seconds() / one_day_seconds, 1)  # Ensure minimum 1 day
+                
+                # Add safety checks for division
+                if days_in_period > 0:
+                    if repo_metrics.prs_merged_to_main > 0:
+                        repo_metrics.time_metrics.deployment_frequency = repo_metrics.prs_merged_to_main / days_in_period
+                    if org_metrics.prs_merged_to_main > 0:
+                        org_metrics.time_metrics.deployment_frequency = org_metrics.prs_merged_to_main / days_in_period
+    except Exception as e:
+        print(f"DEBUG: Error in update_time_metrics: {str(e)}")
+        # Continue processing even if there's an error with one PR
+        pass
 
 def process_reviews(pr, reviews, repo_metrics, org_metrics):
     """Process reviews for a PR"""
@@ -323,8 +356,8 @@ def process_reviews(pr, reviews, repo_metrics, org_metrics):
         repo_metrics.review_metrics.update_from_review(review, pr)
         org_metrics.review_metrics.update_from_review(review, pr)
 
-        # Update collaboration metrics
-        update_collaboration_metrics(pr, review, repo_metrics, org_metrics, reviewer_metrics)
+        # Fix: Remove reviewer_metrics from this call
+        update_collaboration_metrics(pr, reviews, repo_metrics, org_metrics)
 
 def update_collaboration_metrics(pr, reviews, repo_metrics, org_metrics):
     """Update collaboration metrics including participation rate"""
@@ -334,42 +367,46 @@ def update_collaboration_metrics(pr, reviews, repo_metrics, org_metrics):
         org_metrics.collaboration_metrics.self_merges += 1
 
     # Update collaboration metrics at all levels
-    repo_metrics.collaboration_metrics.update_from_reviews(
-        reviews, pr,
-        author_team=pr.user.team,
-        reviewer_team=reviews[0].user.team
-    )
-    org_metrics.collaboration_metrics.update_from_reviews(
-        reviews, pr,
-        author_team=pr.user.team,
-        reviewer_team=reviews[0].user.team
-    )
-    
-    # Update team reviews
-    if reviews[0].user.team and pr.user.team:
-        if reviews[0].user.team == pr.user.team:
-            repo_metrics.collaboration_metrics.team_reviews += 1
-            org_metrics.collaboration_metrics.team_reviews += 1
+    if reviews and len(reviews) > 0 and hasattr(pr.user, 'team') and hasattr(reviews[0].user, 'team'):
+        repo_metrics.collaboration_metrics.update_from_reviews(
+            reviews, pr,
+            author_team=pr.user.team,
+            reviewer_team=reviews[0].user.team
+        )
+        org_metrics.collaboration_metrics.update_from_reviews(
+            reviews, pr,
+            author_team=pr.user.team,
+            reviewer_team=reviews[0].user.team
+        )
+        
+        # Update team reviews
+        if reviews[0].user.team and pr.user.team:
+            if reviews[0].user.team == pr.user.team:
+                repo_metrics.collaboration_metrics.team_reviews += 1
+                org_metrics.collaboration_metrics.team_reviews += 1
+            else:
+                repo_metrics.collaboration_metrics.cross_team_reviews += 1
+                org_metrics.collaboration_metrics.cross_team_reviews += 1
         else:
-            repo_metrics.collaboration_metrics.cross_team_reviews += 1
-            org_metrics.collaboration_metrics.cross_team_reviews += 1
-    else:
-        repo_metrics.collaboration_metrics.external_reviews += 1
-        org_metrics.collaboration_metrics.external_reviews += 1
+            repo_metrics.collaboration_metrics.external_reviews += 1
+            org_metrics.collaboration_metrics.external_reviews += 1
+    
+    # Calculate review participation rate for repository
+    repo_total_reviews = (repo_metrics.collaboration_metrics.team_reviews + 
+                         repo_metrics.collaboration_metrics.cross_team_reviews + 
+                         repo_metrics.collaboration_metrics.external_reviews)
+    
+    if repo_metrics.prs_created > 0:
+        repo_metrics.collaboration_metrics.review_participation_rate = repo_total_reviews / repo_metrics.prs_created
 
-    # Calculate review participation rate
-    total_reviews = repo_metrics.collaboration_metrics.team_reviews + \
-                   repo_metrics.collaboration_metrics.cross_team_reviews + \
-                   repo_metrics.collaboration_metrics.external_reviews
-    total_prs = repo_metrics.prs_merged + repo_metrics.collaboration_metrics.self_merges
+    # Calculate review participation rate for organization
+    org_total_reviews = (org_metrics.collaboration_metrics.team_reviews + 
+                        org_metrics.collaboration_metrics.cross_team_reviews + 
+                        org_metrics.collaboration_metrics.external_reviews)
 
-    if total_prs > 0:
-        repo_metrics.collaboration_metrics.review_participation_rate = total_reviews / total_prs
-        org_metrics.collaboration_metrics.review_participation_rate = \
-            (org_metrics.collaboration_metrics.team_reviews + \
-             org_metrics.collaboration_metrics.cross_team_reviews + \
-             org_metrics.collaboration_metrics.external_reviews) / \
-            (org_metrics.prs_merged + org_metrics.collaboration_metrics.self_merges)
+    # Fix: Use prs_created instead of total_prs
+    if org_metrics.prs_created > 0:  # Changed from total_prs to prs_created
+        org_metrics.collaboration_metrics.review_participation_rate = org_total_reviews / org_metrics.prs_created
 
 def get_team_members(org, team_filter: str) -> set:
     """Get team members for a specific team"""

src/wellcode_cli/github/models/metrics.py

@@ -343,6 +343,9 @@ class OrganizationMetrics(BaseMetrics):
     time_metrics: TimeMetrics = field(default_factory=TimeMetrics)
     collaboration_metrics: CollaborationMetrics = field(default_factory=CollaborationMetrics)
     bottleneck_metrics: BottleneckMetrics = field(default_factory=BottleneckMetrics)
+    prs_created: int = 0
+    prs_merged: int = 0
+    prs_merged_to_main: int = 0
 
     def get_or_create_repository(self, name: str, default_branch: str = "main") -> RepositoryMetrics:
         if name not in self.repositories: