claude-self-reflect 3.3.1 → 4.0.1

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/status_unified.py

@@ -0,0 +1,286 @@
+"""Ultra-fast status checker using unified state management.
+
+This module reads from the unified state file for indexing status.
+Designed for <20ms execution time to support status bars and shell scripts.
+"""
+
+import json
+import time
+import sys
+from pathlib import Path
+from collections import defaultdict
+
+# Add scripts directory to path for unified state manager
+scripts_dir = Path(__file__).parent.parent.parent / "scripts"
+if scripts_dir.exists():
+    sys.path.insert(0, str(scripts_dir))
+
+try:
+    from unified_state_manager import UnifiedStateManager
+except ImportError:
+    # Fallback to reading JSON directly if manager not available
+    UnifiedStateManager = None
+
+# Try to import shared utilities
+try:
+    from shared_utils import (
+        extract_project_name_from_path,
+        get_claude_projects_dir,
+        get_csr_config_dir
+    )
+except ImportError:
+    # Fallback implementations
+    def extract_project_name_from_path(file_path: str) -> str:
+        """Extract project name from JSONL file path."""
+        path_obj = Path(file_path)
+        dir_name = path_obj.parent.name
+
+        if dir_name.startswith('-') and 'projects' in dir_name:
+            parts = dir_name.split('-')
+            try:
+                projects_idx = parts.index('projects')
+                if projects_idx + 1 < len(parts):
+                    project_parts = parts[projects_idx + 1:]
+                    return '-'.join(project_parts)
+            except ValueError:
+                pass
+
+        return dir_name.lstrip('-')
+
+    def get_claude_projects_dir() -> Path:
+        """Get Claude projects directory."""
+        import os
+        if 'CLAUDE_PROJECTS_DIR' in os.environ:
+            return Path(os.environ['CLAUDE_PROJECTS_DIR'])
+        return Path.home() / ".claude" / "projects"
+
+    def get_csr_config_dir() -> Path:
+        """Get CSR config directory."""
+        import os
+        if 'CSR_CONFIG_DIR' in os.environ:
+            return Path(os.environ['CSR_CONFIG_DIR'])
+        return Path.home() / '.claude-self-reflect' / 'config'
+
+
+def get_watcher_status() -> dict:
+    """Get streaming watcher status from unified state."""
+    try:
+        if UnifiedStateManager:
+            manager = UnifiedStateManager()
+            state = manager.read_state()
+
+            # Get watcher status from importers section
+            watcher_info = state.get("importers", {}).get("streaming", {})
+            last_run = watcher_info.get("last_run")
+
+            if last_run:
+                from datetime import datetime, timezone
+                last_run_dt = datetime.fromisoformat(last_run)
+                now = datetime.now(timezone.utc)
+                age_seconds = (now - last_run_dt).total_seconds()
+                is_active = age_seconds < 120  # Active if updated in last 2 minutes
+            else:
+                is_active = False
+                age_seconds = float('inf')
+
+            return {
+                "running": is_active,
+                "files_processed": watcher_info.get("files_processed", 0),
+                "last_update_seconds": int(age_seconds) if age_seconds != float('inf') else None,
+                "status": "🟢 active" if is_active else "🔴 inactive"
+            }
+        else:
+            # Fallback to old method if UnifiedStateManager not available
+            watcher_state_file = get_csr_config_dir() / "csr-watcher.json"
+
+            if not watcher_state_file.exists():
+                return {"running": False, "status": "not configured"}
+
+            with open(watcher_state_file) as f:
+                state = json.load(f)
+
+            file_age = time.time() - watcher_state_file.stat().st_mtime
+            is_active = file_age < 120
+
+            return {
+                "running": is_active,
+                "files_processed": len(state.get("imported_files", {})),
+                "last_update_seconds": int(file_age),
+                "status": "🟢 active" if is_active else "🔴 inactive"
+            }
+    except Exception as e:
+        return {"running": False, "status": f"error: {str(e)[:50]}"}
+
+
+def get_status() -> dict:
+    """Get indexing status from unified state with per-project breakdown.
+
+    Returns:
+        dict: JSON structure with overall and per-project indexing status
+    """
+    start_time = time.time()
+
+    try:
+        if UnifiedStateManager:
+            # Use unified state manager for fast access
+            manager = UnifiedStateManager()
+            status = manager.get_status()
+
+            # Get per-project breakdown
+            project_stats = defaultdict(lambda: {"indexed": 0, "total": 0})
+
+            # Count total JSONL files per project
+            projects_dir = get_claude_projects_dir()
+            if projects_dir.exists():
+                for jsonl_file in projects_dir.glob("**/*.jsonl"):
+                    project_name = extract_project_name_from_path(str(jsonl_file))
+                    project_stats[project_name]["total"] += 1
+
+            # Count indexed files per project from unified state
+            state = manager.read_state()
+            for file_path, metadata in state.get("files", {}).items():
+                if metadata.get("status") == "completed":
+                    project_name = extract_project_name_from_path(file_path)
+                    if project_name in project_stats:
+                        project_stats[project_name]["indexed"] += 1
+
+            # Format response
+            result = {
+                "overall": {
+                    "percentage": status["percentage"],
+                    "indexed_files": status["indexed_files"],
+                    "total_files": status["total_files"],
+                    "total_chunks": status["total_chunks"],
+                },
+                "watcher": get_watcher_status(),
+                "projects": dict(project_stats),
+                "execution_time_ms": round((time.time() - start_time) * 1000, 2)
+            }
+
+            return result
+
+        else:
+            # Fallback to old multi-file method
+            return get_status_legacy()
+
+    except Exception as e:
+        return {
+            "error": str(e),
+            "execution_time_ms": round((time.time() - start_time) * 1000, 2)
+        }
+
+
+def get_status_legacy() -> dict:
+    """Legacy status method reading from multiple files (fallback)."""
+    projects_dir = get_claude_projects_dir()
+    project_stats = defaultdict(lambda: {"indexed": 0, "total": 0})
+
+    # Count total JSONL files per project
+    if projects_dir.exists():
+        for jsonl_file in projects_dir.glob("**/*.jsonl"):
+            file_str = str(jsonl_file)
+            project_name = extract_project_name_from_path(file_str)
+            project_stats[project_name]["total"] += 1
+
+    # Read imported-files.json to count indexed files
+    config_dir = get_csr_config_dir()
+    imported_files_path = config_dir / "imported-files.json"
+
+    if imported_files_path.exists():
+        try:
+            with open(imported_files_path, 'r') as f:
+                data = json.load(f)
+                imported_files = data.get("imported_files", {})
+
+                for file_path in imported_files.keys():
+                    # Normalize path
+                    if file_path.startswith("/logs/"):
+                        projects_path = str(get_claude_projects_dir())
+                        normalized_path = file_path.replace("/logs/", projects_path + "/", 1)
+                    else:
+                        normalized_path = file_path
+
+                    # Check if file exists and count it
+                    if Path(normalized_path).exists():
+                        project_name = extract_project_name_from_path(normalized_path)
+                        if project_name in project_stats:
+                            project_stats[project_name]["indexed"] += 1
+        except Exception:
+            pass
+
+    # Calculate overall stats
+    total_files = sum(p["total"] for p in project_stats.values())
+    indexed_files = sum(p["indexed"] for p in project_stats.values())
+    percentage = (indexed_files / max(total_files, 1)) * 100
+
+    return {
+        "overall": {
+            "percentage": percentage,
+            "indexed_files": indexed_files,
+            "total_files": total_files
+        },
+        "watcher": get_watcher_status(),
+        "projects": dict(project_stats)
+    }
+
+
+def main():
+    """CLI interface for status checking."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Check Claude Self-Reflect indexing status")
+    parser.add_argument("--format", choices=["json", "text"], default="json",
+                       help="Output format (default: json)")
+    parser.add_argument("--watch", action="store_true",
+                       help="Watch mode - update every 2 seconds")
+
+    args = parser.parse_args()
+
+    if args.watch:
+        try:
+            while True:
+                status = get_status()
+                if args.format == "json":
+                    print(json.dumps(status, indent=2))
+                else:
+                    overall = status.get("overall", {})
+                    print(f"Indexing: {overall.get('percentage', 0):.1f}% "
+                          f"({overall.get('indexed_files', 0)}/{overall.get('total_files', 0)})")
+
+                    watcher = status.get("watcher", {})
+                    print(f"Watcher: {watcher.get('status', '🔴 inactive')}")
+
+                    if status.get("execution_time_ms"):
+                        print(f"Time: {status['execution_time_ms']}ms")
+
+                print("\n" + "-" * 40)
+                time.sleep(2)
+
+        except KeyboardInterrupt:
+            print("\nStopped")
+    else:
+        status = get_status()
+        if args.format == "json":
+            print(json.dumps(status, indent=2))
+        else:
+            overall = status.get("overall", {})
+            print(f"Indexing: {overall.get('percentage', 0):.1f}% "
+                  f"({overall.get('indexed_files', 0)}/{overall.get('total_files', 0)} files)")
+
+            watcher = status.get("watcher", {})
+            print(f"Watcher: {watcher.get('status', '🔴 inactive')}")
+
+            # Show per-project if available
+            projects = status.get("projects", {})
+            if projects:
+                print("\nProjects:")
+                for proj, stats in projects.items():
+                    pct = (stats["indexed"] / max(stats["total"], 1)) * 100
+                    print(f"  {proj}: {pct:.1f}% ({stats['indexed']}/{stats['total']})")
+
+            if status.get("execution_time_ms"):
+                print(f"\nExecution time: {status['execution_time_ms']}ms")
+
+
+if __name__ == "__main__":
+    main()

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.1",
   "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']