claude-self-reflect 3.3.0 → 3.3.1

package/scripts/session_quality_tracker.py

@@ -0,0 +1,481 @@
+#!/usr/bin/env python3
+"""
+Session Quality Tracker
+Analyzes code quality for files edited in the current Claude session.
+MANDATORY AST-GREP analysis for real-time quality feedback.
+"""
+
+import json
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional, Set
+import logging
+import sys
+
+# Setup logger
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+
+# Add scripts directory to path
+sys.path.append(str(Path(__file__).parent))
+
+from ast_grep_final_analyzer import FinalASTGrepAnalyzer
+from update_patterns import check_and_update_patterns
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SessionQualityTracker:
+    """
+    Tracks code quality for the current Claude session.
+    Provides real-time feedback on code quality issues.
+    """
+
+    def __init__(self):
+        self.analyzer = FinalASTGrepAnalyzer()
+        self.session_files = set()
+        self.quality_history = {}
+        self.current_session_id = None
+
+    def find_active_session(self, project_path: Optional[str] = None) -> Optional[Path]:
+        """Find the most recently modified JSONL file (active session)."""
+        claude_projects = Path.home() / ".claude" / "projects"
+
+        if project_path:
+            # Look for specific project
+            project_dir = claude_projects / project_path.replace('/', '-')
+        else:
+            # Look for claude-self-reflect project
+            project_dir = claude_projects / "-Users-ramakrishnanannaswamy-projects-claude-self-reflect"
+
+        if not project_dir.exists():
+            logger.warning(f"Project directory not found: {project_dir}")
+            return None
+
+        # Find most recent JSONL file (modified in last 2 hours)
+        recent_files = []
+        cutoff_time = datetime.now() - timedelta(hours=2)
+
+        for jsonl_file in project_dir.glob("*.jsonl"):
+            if jsonl_file.stat().st_mtime > cutoff_time.timestamp():
+                recent_files.append((jsonl_file, jsonl_file.stat().st_mtime))
+
+        if not recent_files:
+            return None
+
+        # Return most recent file
+        recent_files.sort(key=lambda x: x[1], reverse=True)
+        return recent_files[0][0]
+
+    def extract_edited_files(self, session_file: Path) -> Set[str]:
+        """Extract files edited in the current session."""
+        edited_files = set()
+
+        try:
+            with open(session_file, 'r') as f:
+                for line in f:
+                    try:
+                        entry = json.loads(line.strip())
+
+                        # Look for messages with tool usage
+                        if 'messages' in entry:
+                            for msg in entry['messages']:
+                                if msg.get('role') == 'assistant' and 'content' in msg:
+                                    content = msg['content']
+
+                                    # Handle different content formats
+                                    if isinstance(content, list):
+                                        for item in content:
+                                            if isinstance(item, dict) and item.get('type') == 'tool_use':
+                                                tool_name = item.get('name', '')
+                                                if tool_name in ['Edit', 'Write', 'MultiEdit', 'NotebookEdit']:
+                                                    input_data = item.get('input', {})
+                                                    if 'file_path' in input_data:
+                                                        file_path = input_data['file_path']
+                                                        if file_path and os.path.exists(file_path):
+                                                            edited_files.add(file_path)
+
+                    except json.JSONDecodeError:
+                        continue
+                    except Exception as e:
+                        logger.debug(f"Error processing line: {e}")
+
+        except Exception as e:
+            logger.error(f"Error reading session file: {e}")
+
+        return edited_files
+
+    def analyze_session_quality(self, session_file: Optional[Path] = None) -> Dict[str, Any]:
+        """
+        Analyze code quality for all files edited in current session.
+        Returns quality report with actionable insights.
+        """
+        # Update patterns (uses cache, <100ms)
+        check_and_update_patterns()
+
+        # Find active session if not provided
+        if not session_file:
+            session_file = self.find_active_session()
+            if not session_file:
+                # Fallback: analyze recently modified files in project
+                return self.analyze_recent_files()
+
+        self.current_session_id = session_file.stem
+
+        # Extract edited files
+        edited_files = self.extract_edited_files(session_file)
+
+        if not edited_files:
+            # Fallback to analyzing recent files when no edits in session
+            logger.info("No files edited in current session, analyzing recent project files...")
+            return self.analyze_recent_files()
+
+        # 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(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,
+                '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': 'Sess',  # Session scope - files edited in current session
+            '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)
+            },
+            'file_reports': file_reports,
+            'actionable_items': self._generate_actionable_items(file_reports),
+            'quality_trend': self._calculate_quality_trend()
+        }
+
+    def _get_top_issues(self, analysis_result: Dict) -> List[Dict]:
+        """Extract top issues from analysis result."""
+        top_issues = []
+
+        for match in analysis_result.get('all_matches', []):
+            if match['quality'] == 'bad' and match['count'] > 0:
+                top_issues.append({
+                    'id': match['id'],
+                    'description': match['description'],
+                    'count': match['count'],
+                    'severity': 'high' if match['weight'] <= -3 else 'medium'
+                })
+
+        # Sort by count * weight (impact)
+        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:
+            return 'F'
+
+    def _generate_actionable_items(self, file_reports: Dict) -> List[str]:
+        """Generate actionable recommendations for the user."""
+        actions = []
+
+        # Collect all issues
+        all_issues = {}
+        for file_path, report in file_reports.items():
+            for issue in report.get('top_issues', []):
+                issue_id = issue['id']
+                if issue_id not in all_issues:
+                    all_issues[issue_id] = {
+                        'description': issue['description'],
+                        'total_count': 0,
+                        'files': []
+                    }
+                all_issues[issue_id]['total_count'] += issue['count']
+                all_issues[issue_id]['files'].append(Path(file_path).name)
+
+        # Sort by total impact
+        sorted_issues = sorted(all_issues.items(), key=lambda x: x[1]['total_count'], reverse=True)
+
+        # Generate actions
+        for issue_id, issue_data in sorted_issues[:3]:  # Top 3 issues
+            if issue_id == 'print-call':
+                actions.append(f"🔧 Replace {issue_data['total_count']} print statements with logger in {', '.join(issue_data['files'][:2])}")
+            elif issue_id == 'sync-open':
+                actions.append(f"⚡ Use async file operations ({issue_data['total_count']} sync opens found)")
+            elif issue_id == 'broad-except':
+                actions.append(f"🎯 Fix {issue_data['total_count']} bare except clauses for better error handling")
+            elif issue_id == 'no-console-log':
+                actions.append(f"🚫 Remove {issue_data['total_count']} console.log statements")
+            else:
+                actions.append(f"📝 Fix {issue_data['total_count']} instances of {issue_data['description']}")
+
+        return actions
+
+    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",
+        ]
+
+        edited_files = set()
+        for file_path in core_files:
+            full_path = project_root / file_path
+            if full_path.exists():
+                edited_files.add(str(full_path))
+
+        # 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 {}
+
+            # Use pathlib instead of subprocess for safer file discovery
+            scripts_dir = project_root / "scripts"
+            if scripts_dir.exists():
+                from datetime import datetime, timedelta
+                cutoff_time = datetime.now() - timedelta(minutes=30)
+                for py_file in scripts_dir.glob("*.py"):
+                    if py_file.stat().st_mtime > cutoff_time.timestamp():
+                        # Skip test files and temporary files
+                        if "test_" not in py_file.name and "verify_" not in py_file.name:
+                            edited_files.add(str(py_file))
+        except Exception as e:
+            logger.debug(f"Error checking recent files: {e}")
+
+        if not edited_files:
+            return {
+                'status': 'no_edits',
+                'session_id': 'recent_files',
+                'message': 'No recently modified code files'
+            }
+
+        # Analyze the files
+        self.current_session_id = "recent_files"
+        file_reports = {}
+        total_issues = 0
+        total_good_patterns = 0
+        quality_scores = []
+
+        for file_path in list(edited_files)[:10]:  # Limit to 10 files for performance
+            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_issues': self._get_top_issues(result)
+                }
+
+                total_issues += metrics['total_issues']
+                total_good_patterns += metrics['good_patterns_found']
+                quality_scores.append(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': 'recent_files',
+                'message': 'No analyzable code files'
+            }
+
+        avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+
+        # Determine scope label based on what files we're analyzing
+        scope_label = 'Core'  # Default to core project files
+        if any('session_quality_tracker' in str(f) for f in edited_files):
+            scope_label = 'Fix'  # Files we just fixed
+        elif any(Path(f).stat().st_mtime > (datetime.now().timestamp() - 1800) for f in edited_files if Path(f).exists()):
+            scope_label = 'Recent'  # Recently modified
+
+        return {
+            'status': 'success',
+            'session_id': 'recent_files',
+            'scope_label': 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)
+            },
+            'file_reports': file_reports,
+            'actionable_items': self._generate_actionable_items(file_reports),
+            'quality_trend': self._calculate_quality_trend()
+        }
+
+    def _calculate_quality_trend(self) -> str:
+        """Calculate quality trend across session."""
+        if not self.quality_history:
+            return "No trend data"
+
+        # Look at average change
+        improvements = 0
+        degradations = 0
+
+        for file_path, history in self.quality_history.items():
+            if len(history) >= 2:
+                delta = history[-1]['score'] - history[0]['score']
+                if delta > 0.05:
+                    improvements += 1
+                elif delta < -0.05:
+                    degradations += 1
+
+        if improvements > degradations:
+            return f"📈 Improving ({improvements} files better)"
+        elif degradations > improvements:
+            return f"📉 Degrading ({degradations} files worse)"
+        else:
+            return "➡️ Stable"
+
+    def generate_report(self, analysis: Dict) -> str:
+        """Generate human-readable report."""
+        if analysis['status'] != 'success':
+            return f"❌ {analysis['message']}"
+
+        summary = analysis['summary']
+        grade = summary['quality_grade']
+        emoji = '🟢' if grade in ['A+', 'A'] else '🟡' if grade in ['B', 'C'] else '🔴'
+
+        report = []
+        report.append("=" * 60)
+        report.append("SESSION CODE QUALITY REPORT")
+        report.append("=" * 60)
+        report.append(f"Session: {analysis['session_id'][:8]}...")
+        report.append(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        report.append("")
+        report.append(f"{emoji} Overall Grade: {grade} ({summary['avg_quality_score']:.1%})")
+        report.append(f"Files Analyzed: {summary['files_analyzed']}")
+        report.append(f"Total Issues: {summary['total_issues']}")
+        report.append(f"Good Patterns: {summary['total_good_patterns']}")
+        report.append(f"Trend: {analysis['quality_trend']}")
+        report.append("")
+
+        if analysis['actionable_items']:
+            report.append("ACTIONS NEEDED:")
+            for action in analysis['actionable_items']:
+                report.append(f"  {action}")
+            report.append("")
+
+        report.append("FILE DETAILS:")
+        for file_path, file_report in analysis['file_reports'].items():
+            file_name = Path(file_path).name
+            score = file_report['quality_score']
+            emoji = '✅' if score > 0.7 else '⚠️' if score > 0.5 else '❌'
+            report.append(f"  {emoji} {file_name}: {score:.1%} ({file_report['issues']} issues)")
+
+        report.append("")
+        report.append("💡 Ask Claude: 'Please fix the code quality issues in this session'")
+        report.append("=" * 60)
+
+        return '\n'.join(report)
+
+
+def main():
+    """Run session quality analysis."""
+    tracker = SessionQualityTracker()
+
+    logger.info("🔍 Analyzing current session code quality...")
+    logger.info("")
+
+    analysis = tracker.analyze_session_quality()
+    report = tracker.generate_report(analysis)
+
+    logger.info(report)
+
+    # 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())
+        # Secure sanitization with whitelist approach
+        import re
+        safe_project_name = re.sub(r'[^a-zA-Z0-9_-]', '_', project_name)[:100]
+
+        # Save to per-project cache directory
+        cache_dir = Path.home() / ".claude-self-reflect" / "quality_cache"
+        cache_dir.mkdir(exist_ok=True, parents=True)
+        report_path = cache_dir / f"{safe_project_name}.json"
+
+        # Validate the report path stays within cache directory
+        if not str(report_path.resolve()).startswith(str(cache_dir.resolve())):
+            logger.error(f"Security: Invalid cache path for {project_name}")
+            return
+
+        with open(report_path, 'w') as f:
+            json.dump(analysis, f, indent=2)
+        logger.info(f"\n📊 Full report saved to: {report_path}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/streaming-watcher.py

@@ -484,7 +484,20 @@ class QdrantService:
     
     def __init__(self, config: Config, embedding_provider: EmbeddingProvider):
         self.config = config
-        self.client = AsyncQdrantClient(url=config.qdrant_url)
+
+        # Security: Validate Qdrant URL for remote connections
+        from urllib.parse import urlparse
+        parsed = urlparse(config.qdrant_url)
+        host = (parsed.hostname or "").lower()
+
+        if config.require_tls_for_remote and host not in ("localhost", "127.0.0.1", "qdrant") and parsed.scheme != "https":
+            raise ValueError(f"Insecure QDRANT_URL for remote host: {config.qdrant_url} (use https:// or set QDRANT_REQUIRE_TLS_FOR_REMOTE=false)")
+
+        # Initialize with API key if provided
+        self.client = AsyncQdrantClient(
+            url=config.qdrant_url,
+            api_key=config.qdrant_api_key if hasattr(config, 'qdrant_api_key') else None
+        )
         self.embedding_provider = embedding_provider
         self._collection_cache: Dict[str, float] = {}
         self.request_semaphore = asyncio.Semaphore(config.max_concurrent_qdrant)
@@ -979,7 +992,66 @@ class StreamingWatcher:
                         text_parts.append(item.get('text', ''))
             return ' '.join(text_parts)
         return str(content) if content else ''
-    
+
+    def _update_quality_cache(self, pattern_analysis: Dict, avg_score: float, project_name: str = None):
+        """Update quality cache file for statusline display - PER PROJECT."""
+        try:
+            # Determine project name from current context or use provided
+            if not project_name:
+                # Try to infer from analyzed files
+                files = pattern_analysis.get('files', [])
+                if files and len(files) > 0:
+                    # Extract project from first file path
+                    first_file = Path(files[0])
+                    # Walk up to find .git directory or use immediate parent
+                    for parent in first_file.parents:
+                        if (parent / '.git').exists():
+                            project_name = parent.name
+                            break
+                    else:
+                        project_name = 'unknown'
+                else:
+                    project_name = 'unknown'
+
+            # Sanitize project name for filename
+            safe_project_name = project_name.replace('/', '-').replace(' ', '_')
+            cache_dir = Path.home() / ".claude-self-reflect" / "quality_cache"
+            cache_dir.mkdir(exist_ok=True, parents=True)
+            cache_file = cache_dir / f"{safe_project_name}.json"
+
+            # Calculate total issues from pattern analysis
+            total_issues = sum(p.get('count', 0) for p in pattern_analysis.get('issues', []))
+
+            # Determine grade based on score
+            if avg_score >= 0.95:
+                grade = 'A+' if total_issues < 10 else 'A'
+            elif avg_score >= 0.8:
+                grade = 'B'
+            elif avg_score >= 0.6:
+                grade = 'C'
+            else:
+                grade = 'D'
+
+            cache_data = {
+                'status': 'success',
+                'session_id': 'watcher',
+                'timestamp': datetime.now().isoformat(),
+                'summary': {
+                    'files_analyzed': len(pattern_analysis.get('files', [])),
+                    'avg_quality_score': round(avg_score, 3),
+                    'total_issues': total_issues,
+                    'quality_grade': grade
+                }
+            }
+
+            with open(cache_file, 'w') as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.debug(f"Updated quality cache: {grade}/{total_issues}")
+
+        except Exception as e:
+            logger.debug(f"Failed to update quality cache: {e}")
+
     async def process_file(self, file_path: Path) -> bool:
         """Process a single file."""
         try:
@@ -1034,7 +1106,70 @@ class StreamingWatcher:
             
             # Extract metadata
             tool_usage = extract_tool_usage_from_conversation(all_messages)
-            
+
+            # MANDATORY AST-GREP Analysis for HOT files
+            pattern_analysis = {}
+            avg_quality_score = 0.0
+            freshness_level, _ = self.categorize_freshness(file_path)
+
+            # Analyze code quality for HOT files (current session)
+            if freshness_level == FreshnessLevel.HOT and (tool_usage.get('files_edited') or tool_usage.get('files_analyzed')):
+                try:
+                    # Import analyzer (lazy import to avoid startup overhead)
+                    from ast_grep_final_analyzer import FinalASTGrepAnalyzer
+                    from update_patterns import check_and_update_patterns
+
+                    # Update patterns (24h cache, <100ms)
+                    check_and_update_patterns()
+
+                    # Create analyzer
+                    if not hasattr(self, '_ast_analyzer'):
+                        self._ast_analyzer = FinalASTGrepAnalyzer()
+
+                    # Analyze edited files from this session
+                    files_to_analyze = list(set(
+                        tool_usage.get('files_edited', [])[:5] +
+                        tool_usage.get('files_analyzed', [])[:5]
+                    ))
+
+                    quality_scores = []
+                    for file_ref in files_to_analyze:
+                        if file_ref and any(file_ref.endswith(ext) for ext in ['.py', '.ts', '.js', '.tsx', '.jsx']):
+                            try:
+                                if os.path.exists(file_ref):
+                                    result = self._ast_analyzer.analyze_file(file_ref)
+                                    metrics = result['quality_metrics']
+                                    pattern_analysis[file_ref] = {
+                                        'score': metrics['quality_score'],
+                                        'good_patterns': metrics['good_patterns_found'],
+                                        'bad_patterns': metrics['bad_patterns_found'],
+                                        'issues': metrics['total_issues']
+                                    }
+                                    quality_scores.append(metrics['quality_score'])
+
+                                    # Log quality issues for HOT files
+                                    if metrics['quality_score'] < 0.6:
+                                        logger.warning(f"⚠️ Quality issue in {os.path.basename(file_ref)}: {metrics['quality_score']:.1%} ({metrics['total_issues']} issues)")
+                            except Exception as e:
+                                logger.debug(f"Could not analyze {file_ref}: {e}")
+
+                    if quality_scores:
+                        avg_quality_score = sum(quality_scores) / len(quality_scores)
+                        logger.info(f"📊 Session quality: {avg_quality_score:.1%} for {len(quality_scores)} files")
+
+                        # Update quality cache for statusline - watcher handles this automatically!
+                        # Pass project name from current file being processed
+                        project_name = file_path.parent.name if file_path else None
+                        self._update_quality_cache(pattern_analysis, avg_quality_score, project_name)
+
+                except Exception as e:
+                    logger.debug(f"AST analysis not available: {e}")
+
+            # Add pattern analysis to tool_usage metadata
+            if pattern_analysis:
+                tool_usage['pattern_analysis'] = pattern_analysis
+                tool_usage['avg_quality_score'] = round(avg_quality_score, 3)
+
             # Build text
             text_parts = []
             for msg in all_messages:
@@ -1043,7 +1178,7 @@ class StreamingWatcher:
                 text = self._extract_message_text(content)
                 if text:
                     text_parts.append(f"{role}: {text}")
-            
+
             combined_text = "\n\n".join(text_parts)
             if not combined_text.strip():
                 logger.warning(f"No textual content in {file_path}, marking as processed")
@@ -1057,7 +1192,7 @@ class StreamingWatcher:
                 }
                 self.stats["files_processed"] += 1
                 return True
-            
+
             concepts = extract_concepts(combined_text, tool_usage)
             
             # Now we know we have content, ensure collection exists