comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/services/registry_data_manager.py

@@ -0,0 +1,161 @@
+"""Manages dynamic registry data fetching and caching."""
+import json
+import time
+from pathlib import Path
+from typing import Optional
+from urllib.request import urlopen, Request
+from urllib.error import URLError
+import socket
+
+from ..constants import GITHUB_NODE_MAPPINGS_URL, MAX_REGISTRY_DATA_AGE_HOURS
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class RegistryDataManager:
+    """Manages fetching and caching of registry node mappings."""
+
+    MAX_AGE_HOURS = MAX_REGISTRY_DATA_AGE_HOURS
+    FETCH_TIMEOUT = 10  # seconds
+
+    def __init__(self, cache_dir: Path):
+        """Initialize with cache directory.
+
+        Args:
+            cache_dir: Directory to store cached registry data
+        """
+        self.cache_dir = cache_dir
+        self.registry_dir = cache_dir / "registry"
+        self.custom_nodes_dir = cache_dir / "custom_nodes"
+        self.mappings_file = self.custom_nodes_dir / "node_mappings.json"
+        self.metadata_file = self.registry_dir / "metadata.json"
+
+        # Ensure directories exist
+        self.registry_dir.mkdir(parents=True, exist_ok=True)
+        self.custom_nodes_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_mappings_path(self) -> Path:
+        """Get path to node mappings file, fetching if needed.
+
+        Returns:
+            Path to node_mappings.json (may be stale if fetch fails)
+        """
+        # If no file exists, we MUST fetch
+        if not self.mappings_file.exists():
+            logger.info("No cached registry data found, fetching...")
+            if self._fetch_mappings():
+                logger.info("Successfully fetched registry data")
+            else:
+                logger.error("Failed to fetch registry data - no mappings available")
+                return self.mappings_file  # Return path even if doesn't exist
+
+        # If file exists but is stale, try to update (non-blocking)
+        elif self._is_stale():
+            logger.debug("Registry data is stale, attempting refresh...")
+            if self._fetch_mappings():
+                logger.info("Updated registry data")
+            else:
+                logger.warning("Using stale registry data (update failed)")
+
+        return self.mappings_file
+
+    def _is_stale(self) -> bool:
+        """Check if cached data is older than MAX_AGE_HOURS."""
+        if not self.mappings_file.exists():
+            return True
+
+        age_seconds = time.time() - self.mappings_file.stat().st_mtime
+        age_hours = age_seconds / 3600
+        return age_hours > self.MAX_AGE_HOURS
+
+    def _fetch_mappings(self) -> bool:
+        """Fetch latest mappings from GitHub.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Create request with timeout
+            req = Request(GITHUB_NODE_MAPPINGS_URL, headers={
+                'User-Agent': 'ComfyDock/1.0',
+                'Accept': 'application/json'
+            })
+
+            # Download with timeout
+            with urlopen(req, timeout=self.FETCH_TIMEOUT) as response:
+                data = response.read()
+
+            # Parse to validate JSON
+            mappings = json.loads(data)
+
+            # Write atomically (temp file + rename)
+            temp_file = self.mappings_file.with_suffix('.tmp')
+            temp_file.write_bytes(data)
+            temp_file.rename(self.mappings_file)
+
+            # Update metadata
+            self._write_metadata({
+                'updated_at': time.time(),
+                'version': mappings.get('version', 'unknown'),
+                'stats': mappings.get('stats', {})
+            })
+
+            return True
+
+        except (URLError, socket.timeout) as e:
+            logger.debug(f"Network error fetching registry data: {e}")
+            return False
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in registry response: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Unexpected error fetching registry data: {e}")
+            return False
+
+    def _write_metadata(self, metadata: dict) -> None:
+        """Write metadata about the cached data."""
+        try:
+            with open(self.metadata_file, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2)
+        except Exception as e:
+            logger.debug(f"Failed to write metadata: {e}")
+
+    def force_update(self) -> bool:
+        """Force fetch latest mappings.
+
+        Returns:
+            True if successful
+        """
+        logger.info("Force updating registry data...")
+        return self._fetch_mappings()
+
+    def get_cache_info(self) -> dict:
+        """Get information about cached data.
+
+        Returns:
+            Dict with cache status and metadata
+        """
+        info = {
+            'exists': self.mappings_file.exists(),
+            'path': str(self.mappings_file),
+            'stale': False,
+            'age_hours': None,
+            'version': None
+        }
+
+        if self.mappings_file.exists():
+            age_seconds = time.time() - self.mappings_file.stat().st_mtime
+            age_hours = age_seconds / 3600
+            info['age_hours'] = round(age_hours, 1)
+            info['stale'] = age_hours > self.MAX_AGE_HOURS
+
+        if self.metadata_file.exists():
+            try:
+                with open(self.metadata_file, encoding='utf-8') as f:
+                    metadata = json.load(f)
+                    info['version'] = metadata.get('version')
+            except:
+                pass
+
+        return info

comfygit_core/strategies/__init__.py

@@ -0,0 +1,4 @@
+"""Resolution strategies for workflow dependencies."""
+from .auto import AutoModelStrategy, AutoNodeStrategy
+
+__all__ = ['AutoNodeStrategy', 'AutoModelStrategy']

comfygit_core/strategies/auto.py

@@ -0,0 +1,72 @@
+"""Auto resolution strategies for workflow dependencies."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from comfygit_core.models.protocols import ModelResolutionStrategy, NodeResolutionStrategy
+
+from ..models.workflow import ModelResolutionContext, NodeResolutionContext, ResolvedModel, WorkflowNodeWidgetRef
+
+if TYPE_CHECKING:
+    from ..models.workflow import ResolvedNodePackage
+
+
+class AutoNodeStrategy(NodeResolutionStrategy):
+    """Automatic node resolution - makes best effort choices without user input."""
+
+    def resolve_unknown_node(
+        self,
+        node_type: str,
+        possible: list[ResolvedNodePackage],
+        context: "NodeResolutionContext"
+    ) -> ResolvedNodePackage | None:
+        """Pick the top suggestion by confidence, or first if tied.
+
+        Args:
+            node_type: The unknown node type
+            possible: List of possible package matches
+            context: Resolution context (unused in auto mode)
+
+        Returns:
+            ResolvedNodePackage or None if no candidates
+        """
+        if not possible:
+            return None
+
+        # Sort by confidence descending, then just pick first
+        sorted_suggestions = sorted(
+            possible, key=lambda s: s.match_confidence, reverse=True
+        )
+
+        return sorted_suggestions[0]
+
+    def confirm_node_install(self, package: ResolvedNodePackage) -> bool:
+        """Always confirm - we're making automated choices."""
+        return True
+
+
+class AutoModelStrategy(ModelResolutionStrategy):
+    """Automatic model resolution - makes simple naive choices."""
+
+    def resolve_model(
+        self,
+        reference: WorkflowNodeWidgetRef,
+        candidates: list[ResolvedModel],
+        context: ModelResolutionContext,
+    ) -> ResolvedModel | None:
+        """Pick the first candidate, or skip if none available.
+
+        Args:
+            reference: The model reference from workflow
+            candidates: List of potential matches (may be empty for missing models)
+            context: Resolution context with search function and workflow info
+
+        Returns:
+            First candidate as ResolvedModel, or None to skip
+        """
+        if not candidates:
+            # No candidates - skip (don't mark as optional)
+            return None
+
+        # Return first candidate (already a ResolvedModel)
+        return candidates[0]

comfygit_core/strategies/confirmation.py

@@ -0,0 +1,69 @@
+"""Confirmation strategies for user interaction."""
+
+from abc import ABC, abstractmethod
+
+
+class ConfirmationStrategy(ABC):
+    """Strategy for confirming user actions."""
+
+    @abstractmethod
+    def confirm_update(self, node_name: str, current_version: str, new_version: str) -> bool:
+        """Ask user to confirm a node update.
+
+        Args:
+            node_name: Name of the node
+            current_version: Current version
+            new_version: New version
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        pass
+
+    def confirm_replace_dev_node(self, node_name: str, current_version: str, new_version: str) -> bool:
+        """Ask user to confirm replacing a development node.
+
+        Args:
+            node_name: Name of the development node
+            current_version: Current version ('dev')
+            new_version: New version to install
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        # Default: use confirm_update for backward compatibility
+        return self.confirm_update(node_name, current_version, new_version)
+
+
+class AutoConfirmStrategy(ConfirmationStrategy):
+    """Always confirm without asking."""
+
+    def confirm_update(self, node_name: str, current_version: str, new_version: str) -> bool:
+        return True
+
+
+class InteractiveConfirmStrategy(ConfirmationStrategy):
+    """Ask user interactively via CLI."""
+
+    def confirm_update(self, node_name: str, current_version: str, new_version: str) -> bool:
+        response = input(
+            f"Update '{node_name}' from {current_version} → {new_version}? (Y/n): "
+        )
+        return response.lower() != 'n'
+
+    def confirm_replace_dev_node(self, node_name: str, current_version: str, new_version: str) -> bool:
+        """Ask user to confirm replacing a development node.
+
+        Args:
+            node_name: Name of the development node
+            current_version: Current version ('dev')
+            new_version: New version to install
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        print(f"⚠️  '{node_name}' is a development node (local changes may exist)")
+        response = input(
+            f"Replace with registry version {new_version}? This will delete local changes. (y/N): "
+        )
+        return response.lower() == 'y'

comfygit_core/utils/comfyui_ops.py

@@ -0,0 +1,125 @@
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+from .common import run_command
+from .git import git_clone
+
+logger = get_logger(__name__)
+
+
+def validate_comfyui_installation(comfyui_path: Path) -> bool:
+    """Check if a directory contains a valid ComfyUI installation.
+
+    Args:
+        comfyui_path: Path to check
+
+    Returns:
+        True if valid ComfyUI installation, False otherwise
+    """
+    # Check for essential ComfyUI files
+    required_files = ["main.py", "nodes.py", "folder_paths.py"]
+
+    for file in required_files:
+        if not (comfyui_path / file).exists():
+            return False
+
+    # Check for essential directories
+    required_dirs = ["comfy", "models"]
+
+    for dir_name in required_dirs:
+        if not (comfyui_path / dir_name).is_dir():
+            return False
+
+    return True
+
+
+def get_comfyui_version(comfyui_path: Path) -> str:
+    """Detect ComfyUI version from git tags."""
+    comfyui_version = "unknown"
+    try:
+        git_dir = comfyui_path / ".git"
+        if git_dir.exists():
+            result = run_command(
+                ["git", "describe", "--tags", "--always"], cwd=comfyui_path
+            )
+            if result.returncode == 0:
+                comfyui_version = result.stdout.strip()
+    except Exception as e:
+        logger.debug(f"Could not detect ComfyUI version from {comfyui_path}: {e}")
+
+    return comfyui_version
+
+
+def resolve_comfyui_version(
+    version_spec: str | None,
+    github_client
+) -> tuple[str, str, str | None]:
+    """Resolve version specification to concrete version.
+
+    Args:
+        version_spec: User input ("latest", "v0.3.20", "abc123", "main", None)
+        github_client: GitHub client for API calls
+
+    Returns:
+        Tuple of (version_to_clone, version_type, commit_sha)
+        - version_to_clone: What to pass to git clone
+        - version_type: "release" | "commit" | "branch"
+        - commit_sha: Actual commit SHA (None if not yet cloned)
+
+    Examples:
+        None → ("v0.3.20", "release", None)  # Latest release
+        "latest" → ("v0.3.20", "release", None)
+        "v0.3.15" → ("v0.3.15", "release", None)
+        "abc123" → ("abc123", "commit", None)
+        "master" → ("master", "branch", None)
+    """
+    COMFYUI_REPO = "https://github.com/comfyanonymous/ComfyUI.git"
+
+    # Handle None or "latest" - fetch latest release
+    if version_spec is None or version_spec == "latest":
+        repo_info = github_client.get_repository_info(COMFYUI_REPO)
+        if repo_info and repo_info.latest_release:
+            return (repo_info.latest_release, "release", None)
+        else:
+            logger.warning("No releases found, falling back to master branch")
+            return ("master", "branch", None)
+
+    # Handle release tags (starts with 'v')
+    if version_spec.startswith('v'):
+        # Validate release exists
+        if github_client.validate_version_exists(COMFYUI_REPO, version_spec):
+            return (version_spec, "release", None)
+        else:
+            logger.warning(f"Release {version_spec} not found on GitHub")
+            raise ValueError(f"ComfyUI release {version_spec} does not exist")
+
+    # Handle branch alias (ComfyUI only has master branch)
+    if version_spec == "master":
+        return (version_spec, "branch", None)
+
+    # Assume commit hash
+    return (version_spec, "commit", None)
+
+
+def clone_comfyui(target_path: Path, version: str | None = None) -> str | None:
+    """Clone ComfyUI repository to a target path.
+
+    Args:
+        target_path: Where to clone ComfyUI
+        version: Optional specific version/tag/commit to checkout
+
+    Returns:
+        ComfyUI version string (commit hash or tag)
+
+    Raises:
+        RuntimeError: If cloning fails
+    """
+    # Clone the repository with shallow clone for speed
+    git_clone(
+        "https://github.com/comfyanonymous/ComfyUI.git",
+        target_path,
+        depth=1,
+        ref=version,
+        timeout=60,
+    )
+    return get_comfyui_version(target_path)

comfygit_core/utils/common.py

@@ -0,0 +1,164 @@
+"""Common utilities for ComfyUI Environment Capture."""
+
+import re
+import subprocess
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+from ..models.exceptions import CDProcessError
+
+logger = get_logger(__name__)
+
+
+def run_command(
+    cmd: list[str],
+    cwd: Path | None = None,
+    timeout: int | None = 30,
+    capture_output: bool = True,
+    text: bool = True,
+    check: bool = False,
+    env: dict | None = None
+) -> subprocess.CompletedProcess:
+    """Run a subprocess command with proper error handling.
+
+    Args:
+        cmd: Command and arguments as a list
+        cwd: Working directory for the command
+        timeout: Command timeout in seconds
+        capture_output: Whether to capture stdout/stderr
+        text: Whether to decode output as text
+        check: Whether to raise exception on non-zero exit code
+        env: Environment variables to pass to subprocess
+
+    Returns:
+        CompletedProcess instance
+
+    Raises:
+        CDProcessError: If command fails and check=True
+        subprocess.TimeoutExpired: If command times out
+    """
+    try:
+        logger.debug(f"Running command: {' '.join(cmd)}")
+        if cwd:
+            logger.debug(f"Working directory: {cwd}")
+
+        result = subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            check=check,
+            timeout=timeout,
+            capture_output=capture_output,
+            text=text,
+            env=env
+        )
+
+        return result
+
+    except subprocess.CalledProcessError as e:
+        # Transform CalledProcessError into our custom exception
+        error_msg = f"Command failed with exit code {e.returncode}: {' '.join(cmd)}"
+        if e.stderr:
+            error_msg += f"\nStderr: {e.stderr}"
+        logger.error(error_msg)
+        raise CDProcessError(
+            message=error_msg,
+            command=cmd,
+            stderr=e.stderr,
+            stdout=e.stdout,
+            returncode=e.returncode
+        )
+    except subprocess.TimeoutExpired:
+        error_msg = f"Command timed out after {timeout}s: {' '.join(cmd)}"
+        logger.error(error_msg)
+        # Let TimeoutExpired propagate - it's specific and useful
+        raise
+    except Exception as e:
+        error_msg = f"Error running command {' '.join(cmd)}: {e}"
+        logger.error(error_msg)
+        raise
+
+def format_size(size_bytes: int) -> str:
+    """Format a size in bytes as human-readable string.
+    
+    Args:
+        size_bytes: Size in bytes
+        
+    Returns:
+        Human-readable size string (e.g., "1.5 MB")
+    """
+    if size_bytes == 0:
+        return "0 B"
+
+    size_names = ["B", "KB", "MB", "GB", "TB"]
+    size_index = 0
+    size = float(size_bytes)
+
+    while size >= 1024.0 and size_index < len(size_names) - 1:
+        size /= 1024.0
+        size_index += 1
+
+    if size_index == 0:
+        return f"{int(size)} {size_names[size_index]}"
+    else:
+        return f"{size:.1f} {size_names[size_index]}"
+
+
+def log_pyproject_content(pyproject_path: Path, context: str = "") -> None:
+    """Log pyproject.toml content in a nicely formatted way.
+    
+    Args:
+        pyproject_path: Path to pyproject.toml file
+        context: Optional context string for the log message
+    """
+    try:
+        content = pyproject_path.read_text(encoding='utf-8')
+        # Add indentation to each line for nice formatting
+        indented_lines = ['' + line for line in content.split('\n')]
+        formatted_content = '\n'.join(indented_lines)
+
+        # Create the log message with separator lines
+        separator = '-' * 60
+        if context:
+            msg = f"{context}:\n{separator}\n{formatted_content}\n{separator}"
+        else:
+            msg = f"pyproject.toml content:\n{separator}\n{formatted_content}\n{separator}"
+
+        # Log as a single INFO message (change to DEBUG if too verbose)
+        logger.info(msg)
+    except Exception as e:
+        logger.debug(f"Could not log pyproject.toml: {e}")
+
+def log_requirements_content(requirements_file: Path, show_all: bool = True) -> None:
+    """Log the compiled requirements file content.
+    
+    Args:
+        requirements_file: Path to the compiled requirements file
+        show_all: If True, show all lines, otherwise show a summary
+    """
+    try:
+        content = requirements_file.read_text(encoding='utf-8')
+        lines = content.split('\n')
+
+        # Count non-comment, non-empty lines
+        package_lines = [l for l in lines if l.strip() and not l.strip().startswith('#')]
+
+        #
+        separator = '=' * 60
+        msg_lines = [
+            f"Compiled requirements file ({len(package_lines)} packages):",
+            separator
+        ]
+
+        # Show first 10 and last 5 packages if there are many
+        if len(lines) > 50 and not show_all:
+            msg_lines.extend(lines[:30])
+            msg_lines.append(f"... ({len(lines) - 35} more lines) ...")
+            msg_lines.extend(lines[-5:])
+        else:
+            msg_lines.extend(lines)
+
+        msg_lines.append(separator)
+
+        logger.info('\n'.join(msg_lines))
+    except Exception as e:
+        logger.debug(f"Could not log requirements file: {e}")