claude-self-reflect 3.0.0 → 3.0.2

package/scripts/importer/utils/logger.py

@@ -0,0 +1,87 @@
+"""Centralized logging configuration."""
+
+import logging
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+
+def setup_logging(
+    level: str = "INFO",
+    log_file: Optional[str] = None,
+    format_string: Optional[str] = None
+) -> logging.Logger:
+    """
+    Set up logging configuration.
+    
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional log file path
+        format_string: Optional custom format string
+        
+    Returns:
+        Configured root logger
+    """
+    # Default format
+    if not format_string:
+        format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Configure root logger
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format=format_string,
+        handlers=[]  # Clear default handlers
+    )
+    
+    logger = logging.getLogger()
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(logging.Formatter(format_string))
+    logger.addHandler(console_handler)
+    
+    # File handler if specified
+    if log_file:
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        file_handler = logging.FileHandler(log_path)
+        file_handler.setFormatter(logging.Formatter(format_string))
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+class ProgressLogger:
+    """Logger for tracking import progress."""
+    
+    def __init__(self, total: int, logger: Optional[logging.Logger] = None):
+        self.total = total
+        self.current = 0
+        self.logger = logger or logging.getLogger(__name__)
+        self.start_time = datetime.now()
+    
+    def update(self, increment: int = 1, message: Optional[str] = None) -> None:
+        """Update progress."""
+        self.current += increment
+        percentage = (self.current / self.total * 100) if self.total > 0 else 0
+        
+        elapsed = (datetime.now() - self.start_time).total_seconds()
+        rate = self.current / elapsed if elapsed > 0 else 0
+        eta = (self.total - self.current) / rate if rate > 0 else 0
+        
+        log_message = f"Progress: {self.current}/{self.total} ({percentage:.1f}%)"
+        if message:
+            log_message += f" - {message}"
+        log_message += f" - Rate: {rate:.1f}/s - ETA: {eta:.0f}s"
+        
+        self.logger.info(log_message)
+    
+    def complete(self) -> None:
+        """Mark as complete."""
+        elapsed = (datetime.now() - self.start_time).total_seconds()
+        self.logger.info(
+            f"Completed {self.total} items in {elapsed:.1f}s "
+            f"({self.total/elapsed:.1f} items/s)"
+        )

package/scripts/importer/utils/project_normalizer.py

@@ -0,0 +1,120 @@
+"""Project name normalization utilities."""
+
+import hashlib
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectNormalizer:
+    """
+    Normalize project names and generate collection names.
+    
+    This is the CRITICAL component that was broken before.
+    Must correctly extract project names from Claude's dash-separated format.
+    """
+    
+    @staticmethod
+    def normalize_project_name(project_path: str) -> str:
+        """
+        Normalize a project path to a consistent project name.
+        
+        CRITICAL: This must match the implementation in utils.py
+        
+        Examples:
+        - "-Users-name-projects-claude-self-reflect" -> "claude-self-reflect"
+        - "claude-self-reflect" -> "claude-self-reflect"
+        - "/path/to/-Users-name-projects-myapp" -> "myapp"
+        """
+        # Get the final component of the path
+        if '/' in project_path:
+            final_component = project_path.split('/')[-1]
+        else:
+            final_component = project_path
+        
+        # Handle Claude's dash-separated format
+        if final_component.startswith('-') and 'projects' in final_component:
+            # Find the last occurrence of 'projects-'
+            idx = final_component.rfind('projects-')
+            if idx != -1:
+                # Extract everything after 'projects-'
+                project_name = final_component[idx + len('projects-'):]
+                logger.debug(f"Normalized '{project_path}' to '{project_name}'")
+                return project_name
+        
+        # Already normalized or different format
+        logger.debug(f"Project path '{project_path}' already normalized")
+        return final_component
+    
+    def get_project_name(self, file_path: Path) -> str:
+        """
+        Extract project name from a file path.
+        
+        Args:
+            file_path: Path to a conversation file
+            
+        Returns:
+            Normalized project name
+        """
+        # Get the parent directory name
+        parent_name = file_path.parent.name
+        
+        # Normalize it
+        return self.normalize_project_name(parent_name)
+    
+    def get_collection_name(self, file_path: Path) -> str:
+        """
+        Generate collection name for a file.
+        
+        Format: conv_HASH_local
+        Where HASH is first 8 chars of MD5 hash of normalized project name.
+        """
+        project_name = self.get_project_name(file_path)
+        
+        # Generate hash
+        project_hash = hashlib.md5(project_name.encode()).hexdigest()[:8]
+        
+        # Generate collection name
+        collection_name = f"conv_{project_hash}_local"
+        
+        logger.debug(f"Collection for project '{project_name}': {collection_name}")
+        return collection_name
+    
+    @staticmethod
+    def validate_normalization() -> bool:
+        """
+        Self-test to ensure normalization is working correctly.
+        
+        Returns:
+            True if all tests pass
+        """
+        test_cases = [
+            ("-Users-name-projects-claude-self-reflect", "claude-self-reflect", "7f6df0fc"),
+            ("claude-self-reflect", "claude-self-reflect", "7f6df0fc"),
+            ("/Users/name/.claude/projects/-Users-name-projects-myapp", "myapp", None),
+            ("-Users-name-projects-procsolve-website", "procsolve-website", "9f2f312b")
+        ]
+        
+        normalizer = ProjectNormalizer()
+        all_passed = True
+        
+        for input_path, expected_name, expected_hash in test_cases:
+            normalized = normalizer.normalize_project_name(input_path)
+            if normalized != expected_name:
+                logger.error(
+                    f"Normalization failed: '{input_path}' -> '{normalized}' "
+                    f"(expected '{expected_name}')"
+                )
+                all_passed = False
+            
+            if expected_hash:
+                actual_hash = hashlib.md5(normalized.encode()).hexdigest()[:8]
+                if actual_hash != expected_hash:
+                    logger.error(
+                        f"Hash mismatch for '{normalized}': "
+                        f"{actual_hash} != {expected_hash}"
+                    )
+                    all_passed = False
+        
+        return all_passed