claude-self-reflect 3.3.1 → 4.0.1

package/scripts/ast_grep_unified_registry.py

@@ -59,6 +59,9 @@ class UnifiedASTGrepRegistry:
         # JavaScript patterns (shared with TS)
         patterns.update(self._load_javascript_patterns())
 
+        # Shell script patterns
+        patterns.update(self._load_shell_patterns())
+
         return patterns
 
     def _load_python_patterns(self) -> Dict[str, List[Dict[str, Any]]]:
@@ -224,6 +227,41 @@ class UnifiedASTGrepRegistry:
                     "quality": "bad",
                     "weight": -4,
                     "language": "python"
+                },
+                {
+                    "id": "sync-voyage-embed",
+                    "pattern": "$CLIENT.embed($$$)",
+                    "description": "Blocking Voyage embed in async context",
+                    "quality": "bad",
+                    "weight": -5,
+                    "language": "python",
+                    "inside": "async def $FUNC($$$): $$$"
+                },
+                {
+                    "id": "thread-join-async",
+                    "pattern": "$THREAD.join($$$)",
+                    "description": "Thread join blocking async context",
+                    "quality": "bad",
+                    "weight": -5,
+                    "language": "python",
+                    "inside": "async def $FUNC($$$): $$$"
+                },
+                {
+                    "id": "invalid-env-var-hyphen",
+                    "pattern": "os.getenv('$VAR')",
+                    "description": "Environment variable with hyphen (invalid in shells)",
+                    "quality": "bad",
+                    "weight": -3,
+                    "language": "python",
+                    "constraint": "$VAR matches .*-.*"
+                },
+                {
+                    "id": "dotenv-override-runtime",
+                    "pattern": "load_dotenv($$$, override=True)",
+                    "description": "Runtime environment mutation in MCP",
+                    "quality": "bad",
+                    "weight": -3,
+                    "language": "python"
                 }
             ],
             "python_qdrant": [
@@ -268,6 +306,50 @@ class UnifiedASTGrepRegistry:
                     "quality": "good",
                     "weight": 5,
                     "language": "python"
+                },
+                {
+                    "id": "missing-embedding-guard",
+                    "pattern": "query_embedding = await $MGR.generate_embedding($$$)\n$$$\nawait $CLIENT.search($$$, query_vector=query_embedding, $$$)",
+                    "description": "Missing None check after embedding generation",
+                    "quality": "bad",
+                    "weight": -4,
+                    "language": "python"
+                },
+                {
+                    "id": "attr-vs-api",
+                    "pattern": "$MGR.model_name",
+                    "description": "Accessing non-existent attribute instead of API",
+                    "quality": "bad",
+                    "weight": -3,
+                    "language": "python",
+                    "note": "Use get_model_info() instead"
+                },
+                {
+                    "id": "duplicate-import",
+                    "pattern": "import $MODULE\n$$$\ndef $FUNC($$$):\n    $$$\n    import $MODULE",
+                    "description": "Duplicate import inside function",
+                    "quality": "bad",
+                    "weight": -2,
+                    "language": "python"
+                }
+            ],
+            "python_runtime_modification": [
+                {
+                    "id": "singleton-state-change",
+                    "pattern": "$SINGLETON.$ATTR = $VALUE",
+                    "description": "Runtime singleton state modification",
+                    "quality": "neutral",
+                    "weight": 0,
+                    "language": "python",
+                    "note": "Can be good for mode switching, bad if uncontrolled"
+                },
+                {
+                    "id": "public-init-exposure",
+                    "pattern": "def try_initialize_$TYPE(self): $$$",
+                    "description": "Public initialization method for runtime config",
+                    "quality": "neutral",
+                    "weight": 0,
+                    "language": "python"
                 }
             ]
         }
@@ -386,6 +468,48 @@ class UnifiedASTGrepRegistry:
             ]
         }
 
+    def _load_shell_patterns(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Shell script patterns."""
+        return {
+            "shell_env_handling": [
+                {
+                    "id": "unused-shell-var",
+                    "pattern": "$VAR=\"$VALUE\"",
+                    "description": "Assigned but never referenced variable",
+                    "quality": "bad",
+                    "weight": -2,
+                    "language": "bash",
+                    "note": "Check if variable is used later"
+                },
+                {
+                    "id": "unsafe-var-check",
+                    "pattern": "[ ! -z \"$VAR\" ]",
+                    "description": "Unsafe variable check (breaks with set -u)",
+                    "quality": "bad",
+                    "weight": -3,
+                    "language": "bash",
+                    "fix": "[ -n \"${VAR:-}\" ]"
+                },
+                {
+                    "id": "redundant-export",
+                    "pattern": "export $VAR=\"$VAR\"",
+                    "description": "Redundant export of same value",
+                    "quality": "bad",
+                    "weight": -2,
+                    "language": "bash"
+                },
+                {
+                    "id": "missing-safety-flags",
+                    "pattern": "#!/bin/bash",
+                    "description": "Missing safety flags",
+                    "quality": "bad",
+                    "weight": -3,
+                    "language": "bash",
+                    "note": "Add 'set -euo pipefail' after shebang"
+                }
+            ]
+        }
+
     def _load_javascript_patterns(self) -> Dict[str, List[Dict[str, Any]]]:
         """JavaScript patterns (subset of TypeScript)."""
         return {
@@ -466,26 +590,56 @@ class UnifiedASTGrepRegistry:
         """Get only bad quality patterns (anti-patterns)."""
         return [p for p in self.get_all_patterns() if p.get('quality') == 'bad']
 
-    def calculate_quality_score(self, matches: List[Dict]) -> float:
+    def calculate_quality_score(self, matches: List[Dict], loc: int = 1000) -> float:
         """
-        Calculate quality score based on pattern matches.
-        Each match includes the pattern and count.
+        Calculate quality score using penalty-based approach.
+        Issues dominate the score; good patterns provide minimal bonus.
+
+        Args:
+            matches: List of pattern matches with weight and count
+            loc: Lines of code (for normalization)
+
+        Returns:
+            Score from 0.0 to 1.0
         """
-        total_weight = 0
-        total_count = 0
+        import math
+
+        # Normalize to KLOC (thousands of lines)
+        kloc = max(1.0, loc / 1000.0)
+
+        # Separate issues (bad) from good patterns
+        issues = [m for m in matches if m.get('quality') == 'bad']
+        good_patterns = [m for m in matches if m.get('quality') == 'good']
+
+        # Calculate severity-weighted issue density
+        total_issues = 0
+        for issue in issues:
+            severity = abs(issue.get('weight', 1))  # Use weight as severity
+            count = issue.get('count', 0)
+            total_issues += severity * count
+
+        issues_per_kloc = total_issues / kloc
+
+        # Penalty calculation (logarithmic to avoid linear dominance)
+        # Calibrated so 50 issues/KLOC = ~50% penalty
+        penalty = min(0.7, 0.15 * math.log1p(issues_per_kloc))
+
+        # Small bonus for good patterns (capped at 5%)
+        good_score = 0
+        if good_patterns:
+            for pattern in good_patterns:
+                weight = pattern.get('weight', 1)
+                count = pattern.get('count', 0)
+                # Cap contribution per pattern type
+                normalized_count = min(count / kloc, 50)  # Max 50 per KLOC
+                good_score += weight * normalized_count / 1000
 
-        for match in matches:
-            weight = match.get('weight', 0)
-            count = match.get('count', 0)
-            total_weight += weight * count
-            total_count += abs(weight) * count
+        bonus = min(0.05, good_score)  # Cap at 5% bonus
 
-        if total_count == 0:
-            return 0.5
+        # Final score: start at 100%, subtract penalty, add small bonus
+        score = max(0.0, min(1.0, 1.0 - penalty + bonus))
 
-        # Normalize to 0-1 range
-        normalized = (total_weight + 100) / 200
-        return max(0.0, min(1.0, normalized))
+        return score
 
     def export_to_json(self, path: str):
         """Export registry to JSON file."""
@@ -545,7 +699,7 @@ if __name__ == "__main__":
         print(f"  - {category}: {count} patterns")
 
     # Export to JSON
-    export_path = "/Users/ramakrishnanannaswamy/projects/claude-self-reflect/scripts/unified_registry.json"
+    export_path = Path(__file__).parent / "unified_registry.json"
     registry.export_to_json(export_path)
     print(f"\n✅ Exported unified registry to {export_path}")
 

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: