claude-self-reflect 3.3.1 → 4.0.0

package/mcp-server/src/status.py

@@ -135,13 +135,15 @@ def get_status() -> dict:
                 # The actual structure has imported_files at the top level
                 imported_files = data.get("imported_files", {})
                 
-                # Count all files in imported_files object (they are all fully imported)
+                # Count all files in imported_files object (only if they still exist on disk)
                 for file_path in imported_files.keys():
                     normalized_path = normalize_file_path(file_path)
                     if normalized_path in file_to_project and normalized_path not in counted_files:
-                        project_name = file_to_project[normalized_path]
-                        project_stats[project_name]["indexed"] += 1
-                        counted_files.add(normalized_path)
+                        # Verify file actually exists before counting it as indexed
+                        if Path(normalized_path).exists():
+                            project_name = file_to_project[normalized_path]
+                            project_stats[project_name]["indexed"] += 1
+                            counted_files.add(normalized_path)
                 
                 # Also check file_metadata for partially imported files
                 file_metadata = data.get("file_metadata", {})
@@ -180,14 +182,17 @@ def get_status() -> dict:
             with open(watcher_state_file, 'r') as f:
                 watcher_data = json.load(f)
                 
-                # Count files imported by the watcher
+                # Count files imported by the watcher (only if they still exist on disk)
                 watcher_imports = watcher_data.get("imported_files", {})
                 for file_path in watcher_imports.keys():
                     normalized_path = normalize_file_path(file_path)
+                    # CRITICAL: Only count if file exists on disk AND is in our project list
                     if normalized_path in file_to_project and normalized_path not in counted_files:
-                        project_name = file_to_project[normalized_path]
-                        project_stats[project_name]["indexed"] += 1
-                        counted_files.add(normalized_path)
+                        # Verify file actually exists before counting it as indexed
+                        if Path(normalized_path).exists():
+                            project_name = file_to_project[normalized_path]
+                            project_stats[project_name]["indexed"] += 1
+                            counted_files.add(normalized_path)
         except (json.JSONDecodeError, KeyError, OSError):
             # If watcher file is corrupted or unreadable, continue
             pass

package/mcp-server/src/test_quality.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Test file with intentional quality issues for testing quality-fixer agent.
+This file contains patterns that should be fixed:
+- sync file operations that should be async
+- global variables
+- print statements
+- long functions
+"""
+
+import os
+import json
+import asyncio
+import logging
+import aiofiles
+from typing import List, Dict, Any
+
+# Set up logger instead of print statements
+logger = logging.getLogger(__name__)
+
+# Configuration management class instead of global variables
+class ConfigManager:
+    def __init__(self):
+        self.config = None
+        self.counter = 0
+
+async def load_config(config_manager: ConfigManager) -> Dict[str, Any]:
+    """Load config using async file operations."""
+    # Async file operation using aiofiles
+    async with aiofiles.open("config.json", "r") as f:
+        content = await f.read()
+        config_manager.config = json.loads(content)
+
+    logger.info(f"Config loaded: {config_manager.config}")
+    return config_manager.config
+
+async def save_data(data: Dict[str, Any], config_manager: ConfigManager) -> None:
+    """Save data using async operations."""
+    config_manager.counter += 1
+
+    # Async file operation using aiofiles
+    async with aiofiles.open("data.json", "w") as f:
+        await f.write(json.dumps(data))
+
+    logger.info(f"Data saved, counter: {config_manager.counter}")
+
+def validate_items(items: List[str]) -> List[str]:
+    """Validate input items."""
+    valid_items = []
+    for item in items:
+        if not item:
+            logger.warning(f"Invalid item: {item}")
+            continue
+        valid_items.append(item)
+    return valid_items
+
+def process_items(items: List[str]) -> List[str]:
+    """Process each item."""
+    return [item.upper() for item in items]
+
+def filter_results(results: List[str]) -> List[str]:
+    """Filter results by length."""
+    return [result for result in results if len(result) > 3]
+
+def create_summary(items: List[str], results: List[str], filtered: List[str]) -> Dict[str, int]:
+    """Create processing summary."""
+    return {
+        "total": len(items),
+        "processed": len(results),
+        "filtered": len(filtered)
+    }
+
+async def save_results(filtered: List[str]) -> None:
+    """Save results to file asynchronously."""
+    async with aiofiles.open("results.txt", "w") as f:
+        for item in filtered:
+            await f.write(f"{item}\n")
+
+async def process_items_improved(items: List[str], config_manager: ConfigManager) -> Dict[str, Any]:
+    """Improved function broken down into smaller functions."""
+    # Step 1: Validate items
+    valid_items = validate_items(items)
+
+    # Step 2: Process each item
+    results = process_items(valid_items)
+
+    # Step 3: Filter results
+    filtered = filter_results(results)
+
+    # Step 4: Sort results
+    filtered.sort()
+
+    # Step 5: Create summary
+    summary = create_summary(items, results, filtered)
+
+    # Step 6: Log summary
+    logger.info(f"Processing complete: {summary}")
+
+    # Step 7: Save results asynchronously
+    await save_results(filtered)
+
+    # Step 8: Update counter
+    config_manager.counter += len(filtered)
+
+    # Step 9: Create report
+    report = {
+        "summary": summary,
+        "results": filtered,
+        "counter": config_manager.counter
+    }
+
+    return report
+
+async def debug_function() -> None:
+    """Function with debug statements."""
+    logger.debug("Debug: Starting function")
+
+    # Reading file asynchronously
+    if os.path.exists("debug.log"):
+        async with aiofiles.open("debug.log", "r") as f:
+            log_data = await f.read()
+            logger.debug(f"Log data: {log_data}")
+
+    logger.debug("Debug: Function complete")
+
+# Using var instead of let/const (for JS patterns if analyzed)
+var_example = "This would be flagged in JS"
+
+async def main() -> None:
+    """Main execution function."""
+    # Set up logging
+    logging.basicConfig(level=logging.INFO)
+
+    # Initialize config manager
+    config_manager = ConfigManager()
+
+    logger.info("Starting application...")
+
+    try:
+        # Note: These operations would fail without actual files, but structure is correct
+        await load_config(config_manager)
+        await process_items_improved(["test", "data", "example"], config_manager)
+        await debug_function()
+    except FileNotFoundError:
+        logger.warning("Required files not found - this is expected in test context")
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+
+    logger.info("Application complete!")
+
+if __name__ == "__main__":
+    # Run async main function
+    asyncio.run(main())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "3.3.1",
+  "version": "4.0.0",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",

package/scripts/ast_grep_final_analyzer.py

@@ -50,6 +50,9 @@ class FinalASTGrepAnalyzer:
         with open(file_path, 'r', encoding='utf-8') as f:
             content = f.read()
 
+        # Count lines of code for normalization
+        lines_of_code = len(content.splitlines())
+
         # Create SgRoot for the detected language
         sg_language = self._get_sg_language(language)
         root = sg.SgRoot(content, sg_language)
@@ -105,8 +108,8 @@ class FinalASTGrepAnalyzer:
                     'error': str(e)[:200]
                 })
 
-        # Calculate quality score
-        quality_score = self.registry.calculate_quality_score(all_matches)
+        # Calculate quality score with LOC normalization
+        quality_score = self.registry.calculate_quality_score(all_matches, loc=lines_of_code)
 
         # Count good vs bad patterns
         good_matches = [m for m in all_matches if m['quality'] == 'good']

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}")