comfygit 0.3.1__py3-none-any.whl

comfygit_cli/logging/log_compressor.py

@@ -0,0 +1,101 @@
+"""Real-time log compression for reducing token count in debug logs."""
+
+import re
+from datetime import datetime
+
+
+class LogCompressor:
+    """Compresses log records in real-time while preserving semantic content."""
+
+    LOG_PATTERN = re.compile(
+        r'^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}) - '
+        r'([^ ]+) - '
+        r'(\w+) - '
+        r'([^:]+):(\d+) - '
+        r'(.+)$'
+    )
+
+    def __init__(self, compression_level: str = 'medium'):
+        self.compression_level = compression_level
+        self.module_dict = {}
+        self.session_start = None
+
+    def _get_module_id(self, module: str) -> str:
+        """Get or create short ID for module path."""
+        if module not in self.module_dict:
+            self.module_dict[module] = f"M{len(self.module_dict)}"
+        return self.module_dict[module]
+
+    def _format_delta(self, timestamp: datetime) -> str:
+        """Format timestamp as delta from session start."""
+        if self.session_start is None:
+            self.session_start = timestamp
+            return "+0.000s"
+
+        delta = (timestamp - self.session_start).total_seconds()
+        return f"+{delta:.3f}s"
+
+    def compress_record(self, message: str) -> str:
+        """Compress a single log record.
+
+        Args:
+            message: Formatted log message from handler
+
+        Returns:
+            Compressed version of the message
+        """
+        # Try to parse structured log line
+        match = self.LOG_PATTERN.match(message)
+        if not match:
+            # Non-standard line (command separator, continuation, etc)
+            return message
+
+        ts_str, module, level, function, line_num, msg = match.groups()
+
+        try:
+            timestamp = datetime.strptime(ts_str, '%Y-%m-%d %H:%M:%S,%f')
+        except ValueError:
+            # Fallback if timestamp parse fails
+            return message
+
+        # Always preserve errors and warnings with full module info
+        if level in ('ERROR', 'WARNING'):
+            delta = self._format_delta(timestamp)
+            return f"{delta} [{level}] {module} - {msg}"
+
+        # Command boundaries (separator lines)
+        if '====' in msg or '----' in msg:
+            return message
+
+        # For aggressive compression, skip some DEBUG details
+        if self.compression_level == 'aggressive' and level == 'DEBUG':
+            if 'Cache' in function or 'resolve_single_node' in function:
+                # Skip verbose cache/resolution internals
+                return ''
+
+        # Compress based on level
+        delta = self._format_delta(timestamp)
+
+        if self.compression_level == 'light':
+            # Light: Just delta + shortened module
+            mod_id = self._get_module_id(module)
+            return f"{delta} {mod_id}.{function} [{level}] {msg}"
+
+        # Medium/aggressive: more compression
+        if level == 'DEBUG':
+            mod_id = self._get_module_id(module)
+            return f"{delta} [{mod_id}] {msg}"
+        elif level == 'INFO':
+            return f"{delta} [INFO] {msg}"
+        else:
+            return f"{delta} [{level}] {msg}"
+
+    def get_dictionary(self) -> str:
+        """Get module dictionary for appending to log file."""
+        if not self.module_dict:
+            return ""
+
+        lines = ["\n# Module Dictionary:"]
+        for module, mod_id in sorted(self.module_dict.items(), key=lambda x: x[1]):
+            lines.append(f"# {mod_id} = {module}")
+        return '\n'.join(lines) + '\n'

comfygit_cli/logging/logging_config.py

@@ -0,0 +1,97 @@
+"""Logging configuration for ComfyUI Environment Capture."""
+
+import logging
+import logging.handlers
+import sys
+from pathlib import Path
+
+# Default log format
+LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+SIMPLE_FORMAT = "%(levelname)s - %(message)s"
+DETAILED_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s"
+
+
+def setup_logging(
+    level: str = "INFO",
+    log_file: Path | None = None,
+    simple_format: bool = False,
+    use_rotation: bool = True,
+    max_bytes: int = 10 * 1024 * 1024,  # 10MB
+    backup_count: int = 5,
+    console_level: str | None = None,
+    file_level: str | None = None
+) -> None:
+    """Configure logging for the application.
+    
+    Args:
+        level: Default logging level (DEBUG, INFO, WARNING, ERROR)
+        log_file: Optional file path for logging output
+        simple_format: Use simple format for console output
+        use_rotation: Use rotating file handler for log files
+        max_bytes: Maximum size of each log file in bytes (default 10MB)
+        backup_count: Number of backup files to keep (default 5)
+        console_level: Override console logging level (defaults to 'level')
+        file_level: Override file logging level (defaults to DEBUG)
+    """
+    default_level = getattr(logging, level.upper(), logging.INFO)
+    console_log_level = getattr(logging, (console_level or level).upper(), logging.INFO)
+    file_log_level = getattr(logging, (file_level or "DEBUG").upper(), logging.DEBUG)
+
+    # Root logger configuration - set to lowest of all levels
+    root_logger = logging.getLogger()
+    root_logger.setLevel(min(default_level, console_log_level, file_log_level))
+
+    # Remove existing handlers
+    root_logger.handlers.clear()
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(console_log_level)
+    console_format = SIMPLE_FORMAT if simple_format else LOG_FORMAT
+    console_handler.setFormatter(logging.Formatter(console_format))
+    root_logger.addHandler(console_handler)
+
+    # File handler (if specified)
+    if log_file:
+        # Ensure log directory exists
+        log_file = Path(log_file)
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        if use_rotation:
+            # Use rotating file handler
+            file_handler = logging.handlers.RotatingFileHandler(
+                log_file,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding='utf-8'
+            )
+        else:
+            # Use regular file handler
+            file_handler = logging.FileHandler(log_file, encoding='utf-8')
+
+        file_handler.setLevel(file_log_level)  # Use specified file log level
+        file_handler.setFormatter(logging.Formatter(DETAILED_FORMAT))
+        root_logger.addHandler(file_handler)
+
+        # Log the start of a new session
+        root_logger.debug("🟩" * 50)
+        root_logger.debug("=" * 80)
+        root_logger.debug("New logging session started")
+        root_logger.debug("=" * 80)
+        root_logger.debug("🟩" * 50)
+
+    # Set specific logger levels
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("requests").setLevel(logging.WARNING)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance for the given module.
+    
+    Args:
+        name: Module name (typically __name__)
+        
+    Returns:
+        Configured logger instance
+    """
+    return logging.getLogger(name)

comfygit_cli/resolution_strategies.py

@@ -0,0 +1,89 @@
+"""Model resolution strategies for CLI interaction."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from comfygit_core.models.commit import ModelResolutionRequest
+    from comfygit_core.models.shared import ModelWithLocation
+
+
+class InteractiveModelResolver:
+    """Handles interactive model resolution for CLI."""
+
+    def resolve_ambiguous_models(
+        self,
+        requests: list[ModelResolutionRequest]
+    ) -> dict[str, ModelWithLocation]:
+        """Interactively resolve ambiguous models.
+
+        Args:
+            requests: List of models needing resolution
+
+        Returns:
+            Dict mapping request key to selected model
+        """
+        resolutions = {}
+
+        if not requests:
+            return resolutions
+
+        print(f"\n🤔 Found {len(requests)} models requiring confirmation:")
+
+        for req in requests:
+            print(f"\nWorkflow: {req.workflow_name}")
+            print(f"Node: {req.node_type} (ID: {req.node_id})")
+            print(f"Looking for: {req.original_value}")
+            print(f"Found {len(req.candidates)} potential matches:")
+
+            for i, model in enumerate(req.candidates, 1):
+                size_gb = model.file_size / (1024**3)
+                print(f"  {i}. {model.relative_path}")
+                print(f"     Size: {size_gb:.1f} GB | Hash: {model.hash}")
+
+            print("  0. Skip this model")
+
+            while True:
+                choice = input(f"Select [1-{len(req.candidates)}] or 0: ").strip()
+
+                if choice == "0":
+                    break  # Skip this model
+
+                if choice.isdigit():
+                    idx = int(choice) - 1
+                    if 0 <= idx < len(req.candidates):
+                        # Create unique key for request
+                        req_key = f"{req.workflow_name}:{req.node_id}:{req.widget_index}"
+                        resolutions[req_key] = req.candidates[idx]
+                        print(f"✓ Selected: {req.candidates[idx].filename}")
+                        break
+
+                print("Invalid choice, please try again.")
+
+        return resolutions
+
+
+class AutomaticModelResolver:
+    """Automatically resolves models (for --no-interactive mode)."""
+
+    def resolve_ambiguous_models(
+        self,
+        requests: list[ModelResolutionRequest]
+    ) -> dict[str, ModelWithLocation]:
+        """Auto-resolve by picking first match or skipping.
+
+        Args:
+            requests: List of models needing resolution
+
+        Returns:
+            Dict mapping request key to selected model
+        """
+        resolutions = {}
+
+        for req in requests:
+            if req.candidates:
+                # Pick first candidate automatically
+                req_key = f"{req.workflow_name}:{req.node_id}:{req.widget_index}"
+                resolutions[req_key] = req.candidates[0]
+
+        return resolutions

comfygit_cli/strategies/__init__.py

@@ -0,0 +1 @@
+"""Resolution strategy implementations for CLI."""

comfygit_cli/strategies/conflict_resolver.py

@@ -0,0 +1,113 @@
+"""Conflict resolution strategies for pull/merge operations.
+
+Based on the Atomic Semantic Merge architecture:
+- Only WORKFLOW conflicts are shown to users (nodes/deps are derived)
+- NO skip option - every conflict must be resolved
+- pyproject.toml conflicts are not shown (it's derived state)
+"""
+
+from typing import Literal
+
+from comfygit_core.models.ref_diff import (
+    RefDiff,
+    WorkflowConflict,
+)
+
+# Only two valid resolutions - no "skip"
+Resolution = Literal["take_base", "take_target"]
+
+
+class InteractiveConflictResolver:
+    """CLI interactive conflict resolver - NO skip option.
+
+    Prompts user for each WORKFLOW conflict detected before a merge/pull.
+    Node and dependency conflicts are not shown as they are derived from
+    workflow resolutions.
+    """
+
+    def resolve_workflow(self, conflict: WorkflowConflict) -> Resolution:
+        """Prompt user to resolve a workflow conflict."""
+        print(f"\n  Workflow: {conflict.identifier}.json")
+        print(f"    Your version:   {(conflict.base_hash or 'unknown')[:8]}...")
+        print(f"    Their version:  {(conflict.target_hash or 'unknown')[:8]}...")
+        print()
+
+        while True:
+            choice = input("    [m] Keep mine  [t] Keep theirs: ").lower().strip()
+            if choice == "m":
+                return "take_base"
+            elif choice == "t":
+                return "take_target"
+            print("    Please enter 'm' or 't'")
+
+    def resolve_all(self, diff: RefDiff) -> dict[str, Resolution]:
+        """Resolve all workflow conflicts interactively.
+
+        Only shows WORKFLOW conflicts. Nodes/deps are derived from workflows.
+
+        Args:
+            diff: RefDiff with conflicts
+
+        Returns:
+            Dict mapping workflow names to resolutions
+        """
+        resolutions: dict[str, Resolution] = {}
+
+        if not diff.has_conflicts:
+            return resolutions
+
+        # Only handle WORKFLOW conflicts
+        workflow_conflicts = [
+            wf.conflict
+            for wf in diff.workflow_changes
+            if wf.conflict and wf.conflict.resolution == "unresolved"
+        ]
+
+        if not workflow_conflicts:
+            return resolutions
+
+        print(f"\n{len(workflow_conflicts)} workflow conflict(s) to resolve:\n")
+
+        for conflict in workflow_conflicts:
+            resolution = self.resolve_workflow(conflict)
+            resolutions[conflict.identifier] = resolution
+            conflict.resolution = resolution
+            print()
+
+        return resolutions
+
+
+class AutoConflictResolver:
+    """Auto-resolve conflicts using a fixed strategy.
+
+    Used with --auto-resolve or --strategy flag for non-interactive resolution.
+    """
+
+    def __init__(self, strategy: Literal["mine", "theirs"]):
+        """Initialize with resolution strategy.
+
+        Args:
+            strategy: "mine" to keep local (take_base), "theirs" to take incoming (take_target)
+        """
+        self._resolution: Resolution = (
+            "take_base" if strategy == "mine" else "take_target"
+        )
+
+    def resolve_all(self, diff: RefDiff) -> dict[str, Resolution]:
+        """Auto-resolve all workflow conflicts.
+
+        Args:
+            diff: RefDiff with conflicts
+
+        Returns:
+            Dict mapping workflow names to resolutions
+        """
+        resolutions: dict[str, Resolution] = {}
+
+        # Only handle WORKFLOW conflicts
+        for wf in diff.workflow_changes:
+            if wf.conflict and wf.conflict.resolution == "unresolved":
+                resolutions[wf.conflict.identifier] = self._resolution
+                wf.conflict.resolution = self._resolution
+
+        return resolutions