claude-self-reflect 3.3.1 → 4.0.0

package/scripts/csr-status

@@ -55,9 +55,120 @@ def get_import_status():
         return "📚 CSR: Error"
 
 
+def categorize_issues(file_reports):
+    """
+    Categorize issues from AST analysis into critical/medium/low.
+    """
+    critical = 0
+    medium = 0
+    low = 0
+
+    for file_path, report in file_reports.items():
+        # Only use top_issues for accurate counting (avoid double-counting from recommendations)
+        for issue in report.get('top_issues', []):
+            severity = issue.get('severity', 'medium')
+            count = issue.get('count', 0)
+            issue_id = issue.get('id', '').lower()
+
+            if severity == 'high' or severity == 'critical':
+                critical += count
+            elif severity == 'medium':
+                # Console.log and print statements are low severity
+                if 'print' in issue_id or 'console' in issue_id:
+                    low += count
+                else:
+                    medium += count
+            else:
+                low += count
+
+    return critical, medium, low
+
+
+def get_quality_icon(critical=0, medium=0, low=0):
+    """
+    Determine quality icon based on issue severity counts.
+    """
+    # Icon selection based on highest severity present
+    if critical > 0:
+        if critical >= 10:
+            return "🔴"  # Red circle - Critical issues need immediate attention
+        else:
+            return "🟠"  # Orange circle - Some critical issues
+    elif medium > 0:
+        if medium >= 50:
+            return "🟡"  # Yellow circle - Many medium issues
+        else:
+            return "🟢"  # Green circle - Few medium issues
+    elif low > 0:
+        if low >= 100:
+            return "⚪"  # White circle - Many minor issues (prints)
+        else:
+            return "✅"  # Check mark - Only minor issues
+    else:
+        return "✨"  # Sparkles - Perfect, no issues
+
+
+def format_statusline_quality(critical=0, medium=0, low=0):
+    """
+    Format statusline with colored dot and labeled numbers.
+    """
+    import os
+    icon = get_quality_icon(critical, medium, low)
+
+    # Check if we should use colors (when in a TTY)
+    use_colors = os.isatty(sys.stdout.fileno()) if hasattr(sys.stdout, 'fileno') else False
+
+    # Build count display with colors if supported
+    counts = []
+    if critical > 0:
+        if use_colors:
+            # Use bright red for critical
+            counts.append(f"\033[1;31mC:{critical}\033[0m")
+        else:
+            counts.append(f"C:{critical}")
+    if medium > 0:
+        if use_colors:
+            # Use bright yellow for medium
+            counts.append(f"\033[1;33mM:{medium}\033[0m")
+        else:
+            counts.append(f"M:{medium}")
+    if low > 0:
+        if use_colors:
+            # Use bright white/gray for low
+            counts.append(f"\033[1;37mL:{low}\033[0m")
+        else:
+            counts.append(f"L:{low}")
+
+    if counts:
+        return f"{icon} {' '.join(counts)}"
+    else:
+        return f"{icon}"  # Perfect - no counts needed
+
+
 def get_session_health():
-    """Get cached session health."""
-    cache_file = Path.home() / ".claude-self-reflect" / "session_quality.json"
+    """Get cached session health with icon-based quality display."""
+    # Check for session edit tracker to show appropriate label
+    tracker_file = Path.home() / ".claude-self-reflect" / "current_session_edits.json"
+
+    # Get quality cache file for current project
+    project_name = Path.cwd().name
+    cache_file = Path.home() / ".claude-self-reflect" / "quality_cache" / f"{project_name}.json"
+
+    # Default label prefix
+    label_prefix = ""
+
+    # Check if we have a session tracker with edited files
+    if tracker_file.exists():
+        try:
+            with open(tracker_file, 'r') as f:
+                tracker_data = json.load(f)
+                edited_files = tracker_data.get('edited_files', [])
+                if edited_files:
+                    # Show session label with file count
+                    file_count = len(edited_files)
+                    label_prefix = f"Session ({file_count} file{'s' if file_count > 1 else ''}): "
+        except:
+            pass
 
     if not cache_file.exists():
         # Fall back to import status if no health data
@@ -79,22 +190,26 @@ def get_session_health():
             # Fall back to import status if no session
             return get_import_status()
 
-        summary = data['summary']
-        grade = summary['quality_grade']
-        issues = summary['total_issues']
+        # Extract issue counts by severity
+        file_reports = data.get('file_reports', {})
+        critical, medium, low = categorize_issues(file_reports)
 
-        # Color coding
-        if grade in ['A+', 'A']:
-            emoji = '🟢'
-        elif grade in ['B', 'C']:
-            emoji = '🟡'
-        else:
-            emoji = '🔴'
+        # Use the icon-based display with optional label
+        quality_display = format_statusline_quality(critical, medium, low)
 
-        if issues > 0:
-            return f"{emoji} Code: {grade} ({issues})"
-        else:
-            return f"{emoji} Code: {grade}"
+        # Add session label if we have one
+        if data.get('scope_label') == 'Session':
+            # For session scope, always show the label with counts
+            if label_prefix:
+                if critical == 0 and medium == 0 and low == 0:
+                    return f"{label_prefix}0 0 0 {quality_display}"
+                else:
+                    return f"{label_prefix}{critical} {medium} {low} {quality_display}"
+            else:
+                # Fallback if no tracker file
+                return f"Session: {critical} {medium} {low} {quality_display}"
+
+        return quality_display
 
     except Exception:
         return get_import_status()
@@ -257,6 +372,14 @@ def get_compact_status():
     cache_dir = Path.home() / ".claude-self-reflect" / "quality_cache"
     cache_file = cache_dir / f"{safe_project_name}.json"
 
+    # If the exact cache file doesn't exist, try to find one that ends with this project name
+    # This handles cases like "metafora-Atlas-gold.json" for project "Atlas-gold"
+    if not cache_file.exists():
+        # Look for files ending with the project name
+        possible_files = list(cache_dir.glob(f"*-{safe_project_name}.json"))
+        if possible_files:
+            cache_file = possible_files[0]  # Use the first match
+
     # Validate cache file path stays within cache directory
     if cache_file.exists() and not str(cache_file.resolve()).startswith(str(cache_dir.resolve())):
         # Security issue - return placeholder
@@ -273,30 +396,38 @@ def get_compact_status():
             mtime = datetime.fromtimestamp(cache_file.stat().st_mtime)
             age = datetime.now() - mtime
 
-            # Use quality data up to 24 hours old (more reasonable)
-            if age < timedelta(hours=24):
+            # Use quality data up to 30 minutes old for fresher results
+            if age < timedelta(minutes=30):
                 with open(cache_file, 'r') as f:
                     data = json.load(f)
 
-                if data.get('status') == 'success':
-                    summary = data['summary']
-                    grade = summary['quality_grade']
-                    issues = summary.get('total_issues', 0)
-                    scope = data.get('scope_label', 'Core')  # Get scope label
-
-                    # GPT-5 fix: Remove forced downgrades, trust the analyzer's grade
-                    # Grade should reflect actual quality metrics, not arbitrary thresholds
-
-                    # Pick emoji based on grade
-                    if grade in ['A+', 'A']:
-                        emoji = '🟢'
-                    elif grade in ['B', 'C']:
-                        emoji = '🟡'
+                if data.get('status') == 'non-code':
+                    # Non-code project - show documentation indicator
+                    grade_str = "[📚:Docs]"
+                    quality_valid = True
+                elif data.get('status') == 'success':
+                    # Extract issue counts by severity for icon display
+                    file_reports = data.get('file_reports', {})
+                    critical, medium, low = categorize_issues(file_reports)
+
+                    # Get icon based on severity
+                    icon = get_quality_icon(critical, medium, low)
+
+                    # Build compact display with ANSI colors for each severity level
+                    colored_parts = []
+                    if critical > 0:
+                        colored_parts.append(f"\033[31m{critical}\033[0m")  # Standard red for critical
+                    if medium > 0:
+                        colored_parts.append(f"\033[33m{medium}\033[0m")  # Standard yellow for medium
+                    if low > 0:
+                        colored_parts.append(f"\033[37m{low}\033[0m")  # White/light gray for low
+
+                    # Join with middle dot separator
+                    if colored_parts:
+                        grade_str = f"[{icon}:{'·'.join(colored_parts)}]"
                     else:
-                        emoji = '🔴'
+                        grade_str = f"[{icon}]"
 
-                    # Simple, clear display without confusing scope labels
-                    grade_str = f"[{emoji}:{grade}/{issues}]"
                     quality_valid = True
         except:
             pass
@@ -308,17 +439,31 @@ def get_compact_status():
             if cache_file.exists():
                 with open(cache_file, 'r') as f:
                     old_data = json.load(f)
-                if old_data.get('status') == 'success':
-                    old_grade = old_data['summary']['quality_grade']
-                    old_issues = old_data['summary'].get('total_issues', 0)
-                    # Show with dimmed indicator that it's old
-                    if old_grade in ['A+', 'A']:
-                        emoji = '🟢'
-                    elif old_grade in ['B', 'C']:
-                        emoji = '🟡'
+                if old_data.get('status') == 'non-code':
+                    # Non-code project - show documentation indicator
+                    grade_str = "[📚:Docs]"
+                elif old_data.get('status') == 'success':
+                    # Extract issue counts by severity for icon display
+                    file_reports = old_data.get('file_reports', {})
+                    critical, medium, low = categorize_issues(file_reports)
+
+                    # Get icon based on severity
+                    icon = get_quality_icon(critical, medium, low)
+
+                    # Build compact display with ANSI colors for each severity level
+                    colored_parts = []
+                    if critical > 0:
+                        colored_parts.append(f"\033[31m{critical}\033[0m")  # Standard red for critical
+                    if medium > 0:
+                        colored_parts.append(f"\033[33m{medium}\033[0m")  # Standard yellow for medium
+                    if low > 0:
+                        colored_parts.append(f"\033[37m{low}\033[0m")  # White/light gray for low
+
+                    # Join with middle dot separator
+                    if colored_parts:
+                        grade_str = f"[{icon}:{'·'.join(colored_parts)}]"
                     else:
-                        emoji = '🔴'
-                    grade_str = f"[{emoji}:{old_grade}/{old_issues}]"
+                        grade_str = f"[{icon}]"
                 else:
                     grade_str = "[...]"
             else:

package/scripts/import-conversations-unified.py

@@ -335,22 +335,27 @@ def extract_metadata_single_pass(file_path: str) -> tuple[Dict[str, Any], str, i
         "concepts": [],
         "ast_elements": [],
         "has_code_blocks": False,
-        "total_messages": 0
+        "total_messages": 0,
+        "project_path": None  # Add project path from cwd
     }
-    
+
     first_timestamp = None
     message_count = 0
     all_text = []
-    
+
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             for line in f:
                 if not line.strip():
                     continue
-                    
+
                 try:
                     data = json.loads(line)
-                    
+
+                    # Extract cwd (current working directory) as project path
+                    if metadata["project_path"] is None and 'cwd' in data:
+                        metadata["project_path"] = data.get('cwd')
+
                     # Get timestamp from first valid entry
                     if first_timestamp is None and 'timestamp' in data:
                         first_timestamp = data.get('timestamp')

package/scripts/session_quality_tracker.py

@@ -106,7 +106,7 @@ class SessionQualityTracker:
 
         return edited_files
 
-    def analyze_session_quality(self, session_file: Optional[Path] = None) -> Dict[str, Any]:
+    def analyze_session_quality(self, session_file: Optional[Path] = None, use_tracker: bool = False) -> Dict[str, Any]:
         """
         Analyze code quality for all files edited in current session.
         Returns quality report with actionable insights.
@@ -114,6 +114,22 @@ class SessionQualityTracker:
         # Update patterns (uses cache, <100ms)
         check_and_update_patterns()
 
+        # Check for session edit tracker first (priority mode)
+        if use_tracker or (not session_file):
+            tracker_file = Path.home() / ".claude-self-reflect" / "current_session_edits.json"
+            if tracker_file.exists():
+                try:
+                    with open(tracker_file, 'r') as f:
+                        tracker_data = json.load(f)
+                        edited_files = set(tracker_data.get('edited_files', []))
+                        if edited_files:
+                            logger.info(f"Using session tracker: {len(edited_files)} files edited in session")
+                            self.current_session_id = 'active_session'
+                            # Use Session scope label for tracked edits
+                            return self._analyze_files_with_scope(edited_files, scope_label='Session')
+                except Exception as e:
+                    logger.debug(f"Error reading tracker file: {e}")
+
         # Find active session if not provided
         if not session_file:
             session_file = self.find_active_session()
@@ -188,7 +204,7 @@ class SessionQualityTracker:
                 'avg_quality_score': round(avg_quality, 3),
                 'total_issues': total_issues,
                 'total_good_patterns': total_good_patterns,
-                'quality_grade': self._get_quality_grade(avg_quality)
+                'quality_grade': self._get_quality_grade(avg_quality, total_issues)
             },
             'file_reports': file_reports,
             'actionable_items': self._generate_actionable_items(file_reports),
@@ -212,20 +228,92 @@ class SessionQualityTracker:
         top_issues.sort(key=lambda x: x['count'], reverse=True)
         return top_issues[:5]  # Top 5 issues
 
-    def _get_quality_grade(self, score: float) -> str:
-        """Convert quality score to letter grade."""
-        if score >= 0.9:
-            return 'A+'
-        elif score >= 0.8:
-            return 'A'
-        elif score >= 0.7:
-            return 'B'
-        elif score >= 0.6:
-            return 'C'
-        elif score >= 0.5:
-            return 'D'
-        else:
+    def _get_quality_grade(self, score: float, total_issues: int = 0) -> str:
+        """
+        Convert quality score to letter grade.
+        Based on consensus: issues should dominate grading.
+
+        Grade boundaries (adjusted for issue count):
+        - A+: score >= 0.97 AND issues <= 5
+        - A:  score >= 0.93 AND issues <= 20
+        - B:  score >= 0.83 AND issues <= 50
+        - C:  score >= 0.73 AND issues <= 100
+        - D:  score >= 0.60
+        - F:  score < 0.60
+        """
+        # Hard caps based on issue count (industry standard)
+        if total_issues > 200:
             return 'F'
+        elif total_issues > 100:
+            # Many issues - max grade is C
+            if score >= 0.77:
+                return 'C+'
+            elif score >= 0.73:
+                return 'C'
+            elif score >= 0.70:
+                return 'C-'
+            elif score >= 0.60:
+                return 'D'
+            else:
+                return 'F'
+        elif total_issues > 50:
+            # Moderate issues - max grade is B
+            if score >= 0.87:
+                return 'B+'
+            elif score >= 0.83:
+                return 'B'
+            elif score >= 0.80:
+                return 'B-'
+            elif score >= 0.73:
+                return 'C'
+            elif score >= 0.60:
+                return 'D'
+            else:
+                return 'F'
+        elif total_issues > 20:
+            # Some issues - max grade is A-
+            if score >= 0.90:
+                return 'A-'
+            elif score >= 0.87:
+                return 'B+'
+            elif score >= 0.83:
+                return 'B'
+            elif score >= 0.73:
+                return 'C'
+            elif score >= 0.60:
+                return 'D'
+            else:
+                return 'F'
+        elif total_issues > 5:
+            # Few issues - max grade is A
+            if score >= 0.93:
+                return 'A'
+            elif score >= 0.90:
+                return 'A-'
+            elif score >= 0.83:
+                return 'B'
+            elif score >= 0.73:
+                return 'C'
+            elif score >= 0.60:
+                return 'D'
+            else:
+                return 'F'
+        else:
+            # Very few issues (0-5) - can achieve A+
+            if score >= 0.97:
+                return 'A+'
+            elif score >= 0.93:
+                return 'A'
+            elif score >= 0.90:
+                return 'A-'
+            elif score >= 0.83:
+                return 'B'
+            elif score >= 0.73:
+                return 'C'
+            elif score >= 0.60:
+                return 'D'
+            else:
+                return 'F'
 
     def _generate_actionable_items(self, file_reports: Dict) -> List[str]:
         """Generate actionable recommendations for the user."""
@@ -263,23 +351,101 @@ class SessionQualityTracker:
 
         return actions
 
+    def _analyze_files_with_scope(self, edited_files: set, scope_label: str = 'Session') -> Dict[str, Any]:
+        """
+        Analyze specific files with a given scope label.
+        Used for both session tracking and fallback modes.
+        """
+        # Analyze each edited file
+        file_reports = {}
+        total_issues = 0
+        total_good_patterns = 0
+        quality_scores = []
+
+        for file_path in edited_files:
+            # Only analyze code files
+            if any(str(file_path).endswith(ext) for ext in ['.py', '.ts', '.js', '.tsx', '.jsx']):
+                try:
+                    result = self.analyzer.analyze_file(file_path)
+                    metrics = result['quality_metrics']
+
+                    file_reports[file_path] = {
+                        'quality_score': metrics['quality_score'],
+                        'good_patterns': metrics['good_patterns_found'],
+                        'issues': metrics['total_issues'],
+                        'recommendations': result.get('recommendations', [])[:3],  # Top 3
+                        'top_issues': self._get_top_issues(result)
+                    }
+
+                    total_issues += metrics['total_issues']
+                    total_good_patterns += metrics['good_patterns_found']
+                    quality_scores.append(metrics['quality_score'])
+
+                    # Track quality history
+                    if file_path not in self.quality_history:
+                        self.quality_history[file_path] = []
+                    self.quality_history[file_path].append({
+                        'timestamp': datetime.now().isoformat(),
+                        'score': metrics['quality_score']
+                    })
+
+                except Exception as e:
+                    logger.error(f"Failed to analyze {file_path}: {e}")
+
+        if not file_reports:
+            return {
+                'status': 'no_code_files',
+                'session_id': self.current_session_id,
+                'scope_label': scope_label,
+                'message': 'No analyzable code files in session'
+            }
+
+        # Calculate session average
+        avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+
+        # Generate session report
+        return {
+            'status': 'success',
+            'session_id': self.current_session_id,
+            'scope_label': scope_label,  # Use provided scope label
+            'timestamp': datetime.now().isoformat(),
+            'summary': {
+                'files_analyzed': len(file_reports),
+                'avg_quality_score': round(avg_quality, 3),
+                'total_issues': total_issues,
+                'total_good_patterns': total_good_patterns,
+                'quality_grade': self._get_quality_grade(avg_quality, total_issues)
+            },
+            'file_reports': file_reports,
+            'actionable_items': self._generate_actionable_items(file_reports),
+            'quality_trend': self._calculate_quality_trend()
+        }
+
     def analyze_recent_files(self) -> Dict[str, Any]:
         """Analyze core project files when no session is found."""
-        project_root = Path(__file__).parent.parent
-
-        # Define core project files to analyze (not test files)
-        core_files = [
-            "scripts/session_quality_tracker.py",
-            "scripts/cc-statusline-unified.py",
-            "scripts/pattern_registry_enhanced.py",
-            "scripts/simplified_metadata_extractor.py",
-            "scripts/streaming-watcher.py",
-            "scripts/quality-report.py",
-            "mcp-server/src/server.py",
-            "mcp-server/src/search_tools.py",
-            "mcp-server/src/temporal_tools.py",
-            "mcp-server/src/reflection_tools.py",
-        ]
+        # Use current working directory as project root
+        project_root = Path.cwd()
+
+        # Find code files in the project dynamically
+        code_extensions = {'.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.cpp', '.c',
+                          '.h', '.hpp', '.rs', '.go', '.rb', '.php'}
+
+        core_files = []
+        # Look for code files in the project (limit to avoid too many files)
+        for ext in code_extensions:
+            files = list(project_root.rglob(f'*{ext}'))
+            # Filter out common non-source directories
+            files = [f for f in files if not any(
+                skip in f.parts for skip in ['venv', '.venv', 'node_modules', '.git',
+                                            '__pycache__', '.pytest_cache', 'dist',
+                                            'build', 'target', '.idea', '.vscode']
+            )]
+            core_files.extend(files[:20])  # Take up to 20 files per extension
+            if len(core_files) >= 50:  # Increased limit to 50 files for better coverage
+                break
+
+        # Convert to relative paths
+        core_files = [str(f.relative_to(project_root)) for f in core_files[:50]]
 
         edited_files = set()
         for file_path in core_files:
@@ -289,10 +455,7 @@ class SessionQualityTracker:
 
         # Also check for recently modified files (last 30 minutes) to catch actual work
         try:
-            # Validate project_root is within expected bounds
-            if not str(project_root.resolve()).startswith(str(Path(__file__).parent.parent.resolve())):
-                logger.error("Security: Invalid project root path")
-                return {}
+            # No need to validate project_root - we can analyze any project
 
             # Use pathlib instead of subprocess for safer file discovery
             scripts_dir = project_root / "scripts"
@@ -321,7 +484,7 @@ class SessionQualityTracker:
         total_good_patterns = 0
         quality_scores = []
 
-        for file_path in list(edited_files)[:10]:  # Limit to 10 files for performance
+        for file_path in list(edited_files)[:50]:  # Analyze up to 50 files for better coverage
             try:
                 result = self.analyzer.analyze_file(file_path)
                 metrics = result['quality_metrics']
@@ -367,7 +530,7 @@ class SessionQualityTracker:
                 'avg_quality_score': round(avg_quality, 3),
                 'total_issues': total_issues,
                 'total_good_patterns': total_good_patterns,
-                'quality_grade': self._get_quality_grade(avg_quality)
+                'quality_grade': self._get_quality_grade(avg_quality, total_issues)
             },
             'file_reports': file_reports,
             'actionable_items': self._generate_actionable_items(file_reports),
@@ -441,14 +604,14 @@ class SessionQualityTracker:
         return '\n'.join(report)
 
 
-def main():
+def main(use_tracker=False):
     """Run session quality analysis."""
     tracker = SessionQualityTracker()
 
     logger.info("🔍 Analyzing current session code quality...")
     logger.info("")
 
-    analysis = tracker.analyze_session_quality()
+    analysis = tracker.analyze_session_quality(use_tracker=use_tracker)
     report = tracker.generate_report(analysis)
 
     logger.info(report)
@@ -456,8 +619,8 @@ def main():
     # Save report for watcher integration - PER PROJECT
     # Always save cache, even with fallback analysis
     if analysis.get('status') in ['success', 'fallback']:
-        # Get project name from current directory
-        project_name = os.path.basename(os.getcwd())
+        # Get project name from environment or current directory
+        project_name = os.environ.get('QUALITY_PROJECT_NAME', os.path.basename(os.getcwd()))
         # Secure sanitization with whitelist approach
         import re
         safe_project_name = re.sub(r'[^a-zA-Z0-9_-]', '_', project_name)[:100]
@@ -478,4 +641,21 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    import argparse
+    parser = argparse.ArgumentParser(description='Analyze code quality for projects')
+    parser.add_argument('--project-path', help='Path to the project to analyze')
+    parser.add_argument('--project-name', help='Name of the project for cache file')
+    parser.add_argument('--use-tracker', action='store_true',
+                        help='Use session edit tracker for analysis')
+    args = parser.parse_args()
+
+    # If external project specified, change to that directory
+    if args.project_path:
+        os.chdir(args.project_path)
+
+    # Override project name if specified
+    if args.project_name:
+        # This will be used in the main() function for cache naming
+        os.environ['QUALITY_PROJECT_NAME'] = args.project_name
+
+    main(use_tracker=args.use_tracker)