comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/models/manifest.py

@@ -0,0 +1,132 @@
+# models/manifest.py
+from dataclasses import dataclass, field
+
+from comfygit_core.models.shared import ModelWithLocation
+from comfygit_core.models.workflow import WorkflowNodeWidgetRef
+
+
+@dataclass
+class ManifestWorkflowModel:
+    """Workflow model entry as stored in pyproject.toml"""
+    filename: str
+    category: str  # "checkpoints", "loras", etc.
+    criticality: str  # "required", "flexible", "optional"
+    status: str  # "resolved", "unresolved"
+    nodes: list[WorkflowNodeWidgetRef]
+    hash: str | None = None  # Only present if resolved
+    sources: list[str] = field(default_factory=list)  # Download URLs
+    relative_path: str | None = None  # Target path for download intents
+
+    def to_toml_dict(self) -> dict:
+        """Serialize to TOML-compatible dict with inline table formatting."""
+        import tomlkit
+
+        # Build nodes as inline tables for clean TOML output
+        nodes_array = tomlkit.array()
+        for n in self.nodes:
+            node_entry = tomlkit.inline_table()
+            node_entry['node_id'] = n.node_id
+            node_entry['node_type'] = n.node_type
+            node_entry['widget_idx'] = n.widget_index
+            node_entry['widget_value'] = n.widget_value
+            nodes_array.append(node_entry)
+
+        result = {
+            "filename": self.filename,
+            "category": self.category,
+            "criticality": self.criticality,
+            "status": self.status,
+            "nodes": nodes_array
+        }
+
+        # Only include optional fields if present
+        if self.hash is not None:
+            result["hash"] = self.hash
+        if self.sources:
+            result["sources"] = self.sources
+        if self.relative_path is not None:
+            result["relative_path"] = self.relative_path
+
+        return result
+    
+    @classmethod
+    def from_toml_dict(cls, data: dict) -> "ManifestWorkflowModel":
+        """Deserialize from TOML dict."""
+        nodes = [
+            WorkflowNodeWidgetRef(
+                node_id=n["node_id"],
+                node_type=n["node_type"],
+                widget_index=n["widget_idx"],
+                widget_value=n["widget_value"]
+            )
+            for n in data.get("nodes", [])
+        ]
+
+        return cls(
+            filename=data["filename"],
+            category=data["category"],
+            criticality=data.get("criticality", "flexible"),
+            status=data.get("status", "resolved"),
+            nodes=nodes,
+            hash=data.get("hash"),
+            sources=data.get("sources", []),
+            relative_path=data.get("relative_path")
+        )
+
+@dataclass
+class ManifestModel:
+    """Global model entry in [tool.comfygit.models]"""
+    hash: str  # Primary key
+    filename: str
+    size: int
+    relative_path: str
+    category: str
+    sources: list[str] = field(default_factory=list)
+    
+    def to_toml_dict(self) -> dict:
+        """Serialize to TOML-compatible dict."""
+        result = {
+            "filename": self.filename,
+            "size": self.size,
+            "relative_path": self.relative_path,
+            "category": self.category
+        }
+        if self.sources:
+            result["sources"] = self.sources
+        return result
+
+    @classmethod
+    def from_toml_dict(cls, hash_key: str, data: dict) -> "ManifestModel":
+        """Deserialize from TOML dict."""
+        return cls(
+            hash=hash_key,
+            filename=data["filename"],
+            size=data["size"],
+            relative_path=data["relative_path"],
+            category=data.get("category", "unknown"),
+            sources=data.get("sources", [])
+        )
+
+    @classmethod
+    def from_model_with_location(cls, model: "ModelWithLocation") -> "ManifestModel":
+        """Convert runtime model to manifest entry.
+
+        Note: Sources are intentionally empty here. They should be fetched from
+        the repository and provided when creating ManifestModel instances.
+
+        Args:
+            model: ModelWithLocation from model repository
+
+        Returns:
+            ManifestModel ready for TOML serialization
+        """
+        from comfygit_core.models.shared import ModelWithLocation
+
+        return cls(
+            hash=model.hash,
+            filename=model.filename,
+            size=model.file_size,
+            relative_path=model.relative_path,
+            category=model.category,
+            sources=[]
+        )

comfygit_core/models/node_mapping.py

@@ -0,0 +1,201 @@
+"""Global node mappings table dataclasses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+""" example mappings:
+"mappings": {
+    "(Down)Load Hibiki Model::_": {
+        "package_id": "comfyui-hibiki",
+        "versions": [
+            "1.0.0"
+        ]
+    },
+    "(Down)Load Kokoro Model::_": {
+        "package_id": "comfyui-jhj-kokoro-onnx",
+        "versions": [],
+        "source": "manager"
+    },
+    "Test::_": [ # TODO: Multiple mappings possible for same node type, order by downloads/stars
+        {
+            "package_id": "comfyui-jhj-kokoro-onnx",
+            "versions": [...],
+            "source": "registry",
+            "rank": 1
+        },
+        {
+            "package_id": "comfyui-some-node",
+            "versions": [...],
+            "source": "manager",
+            "rank": 2
+        },
+        ...
+    ],
+"""
+
+
+@dataclass
+class PackageMapping:
+    """Single package mapping entry within a node key."""
+    package_id: str
+    versions: list[str]
+    rank: int  # 1-based popularity ranking
+    source: str | None = None  # "manager" or None (Registry default)
+
+
+@dataclass
+class GlobalNodeMapping:
+    """Mapping from node type to list of package options (ranked)."""
+
+    id: str  # Compound key (e.g. "NodeType::<input list hash>")
+    packages: list[PackageMapping]  # List of package options, ranked by popularity
+
+
+""" example package:
+"comfyui-hibiki": {
+    "display_name": "ComfyUI-hibiki",
+    "author": "",
+    "description": "ComfyUI wrapper for Speech-to-Speech translation, hibiki: https://github.com/kyutai-labs/hibiki",
+    "repository": "https://github.com/jhj0517/ComfyUI-hibiki.git",
+    "downloads": 909,
+    "github_stars": 0,
+    "rating": 0,
+    "license": "{\"file\": \"LICENSE\"}",
+    "category": "",
+    "tags": [],
+    "status": "NodeStatusActive",
+    "created_at": "2025-02-09T12:51:54.479852Z",
+    "versions": {
+        "1.0.0": {
+            "version": "1.0.0",
+            "changelog": "",
+            "release_date": "2025-02-09T12:51:54.912872Z",
+            "dependencies": [
+                "git+https://github.com/jhj0517/moshi_comfyui_wrapper.git@main#subdirectory=moshi"
+            ],
+            "deprecated": false,
+            "download_url": "https://cdn.comfy.org/jhj0517/comfyui-hibiki/1.0.0/node.zip",
+            "status": "NodeVersionStatusFlagged",
+            "supported_accelerators": null,
+            "supported_comfyui_version": "",
+            "supported_os": null
+        }
+    }
+},
+...
+"github_zzw5516_comfyui-zw-tools": {
+    "display_name": "comfyui-zw-tools",
+    "author": "zzw5516",
+    "description": "",
+    "repository": "https://github.com/zzw5516/ComfyUI-zw-tools",
+    "synthetic": true,
+    "source": "manager",
+    "versions": {}
+}
+"""
+
+@dataclass
+class GlobalNodePackageVersion:
+    """Package version data."""
+    version: str  # Version (required)
+    # Core fields used by CLI
+    download_url: str | None = None  # Download URL
+    deprecated: bool | None = None  # Deprecated
+    dependencies: list[str] | None = None  # Dependencies
+    # Unused fields (kept for potential future use, omitted from minimal schema)
+    changelog: str | None = None  # Changelog
+    release_date: str | None = None  # Release date
+    status: str | None = None  # Status
+    supported_accelerators: list[str] | None = None  # Supported accelerators
+    supported_comfyui_version: str | None = None  # Supported ComfyUI version
+    supported_os: list[str] | None = None  # Supported OS
+
+    def __repr__(self) -> str:
+        """Concise representation showing version and key flags."""
+        parts = [f"v{self.version}"]
+        if self.deprecated:
+            parts.append("deprecated")
+        if self.dependencies:
+            parts.append(f"{len(self.dependencies)} deps")
+        return f"GlobalNodePackageVersion({', '.join(parts)})"
+
+@dataclass
+class GlobalNodePackage:
+    """Global standard package data."""
+
+    id: str  # Package ID (required)
+    # Core fields used by CLI
+    display_name: str | None = None  # Display name
+    description: str | None = None  # Description
+    repository: str | None = None  # Repository
+    github_stars: int | None = None  # GitHub stars
+    versions: dict[str, GlobalNodePackageVersion] | None = None  # Versions
+    source: str | None = None  # Source of the package (None = Registry, "manager" = Manager-only)
+    # Unused fields (kept for potential future use, omitted from minimal schema)
+    author: str | None = None  # Author
+    downloads: int | None = None  # Downloads
+    rating: int | None = None  # Rating
+    license: str | None = None  # License
+    category: str | None = None  # Category
+    icon: str | None = None  # Icon URL
+    tags: list[str] | None = None  # Tags
+    status: str | None = None  # Status
+    created_at: str | None = None  # Created at
+
+    def __repr__(self) -> str:
+        """Concise representation showing key package info and version list."""
+        version_str = ""
+        if self.versions:
+            version_list = list(self.versions.keys())
+            if len(version_list) <= 3:
+                version_str = f", versions=[{', '.join(version_list)}]"
+            else:
+                version_str = f", versions=[{', '.join(version_list[:3])}, ... +{len(version_list) - 3} more]"
+
+        repo_short = ""
+        if self.repository:
+            # Extract just the repo name from URL
+            repo_parts = self.repository.rstrip('/').split('/')
+            repo_short = f", repo={repo_parts[-1] if repo_parts else self.repository}"
+
+        return f"GlobalNodePackage(id={self.id!r}{repo_short}{version_str})"
+
+
+""" example full mappings file:
+"version": "2025.09.19",
+"generated_at": "2025-09-19T18:25:18.347947",
+"stats": {
+    "packages": 3398,
+    "signatures": 34049,
+    "total_nodes": 15280,
+    "augmented": true,
+    "augmentation_date": "2025-09-19T18:26:03.820776",
+    "nodes_from_manager": 19402,
+    "synthetic_packages": 485
+},
+"mappings": {...},
+"packages": {...},
+"""
+
+
+@dataclass
+class GlobalNodeMappingsStats:
+    packages: int | None = None
+    signatures: int | None = None
+    total_nodes: int | None = None
+    augmented: bool | None = None
+    augmentation_date: str | None = None
+    nodes_from_manager: int | None = None
+    manager_packages: int | None = None
+
+
+@dataclass
+class GlobalNodeMappings:
+    """Global node mappings table."""
+
+    version: str
+    generated_at: str
+    stats: GlobalNodeMappingsStats | None
+    mappings: dict[str, GlobalNodeMapping] = field(default_factory=dict)
+    packages: dict[str, GlobalNodePackage] = field(default_factory=dict)

comfygit_core/models/protocols.py

@@ -0,0 +1,248 @@
+"""Resolution strategy protocols for dependency injection."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+from .workflow import (
+    ModelResolutionContext,
+    NodeResolutionContext,
+    ResolvedModel,
+    WorkflowNodeWidgetRef,
+)
+
+if TYPE_CHECKING:
+    from ..models.workflow import ResolvedNodePackage
+
+class NodeResolutionStrategy(Protocol):
+    """Protocol for resolving unknown custom nodes."""
+
+    def resolve_unknown_node(
+        self,
+        node_type: str,
+        possible: list[ResolvedNodePackage],
+        context: NodeResolutionContext
+    ) -> ResolvedNodePackage | None:
+        """Given node type and suggestions, return package ID or None.
+
+        Args:
+            node_type: The unknown node type (e.g. "MyCustomNode")
+            possible: List of registry suggestions with package_id, confidence
+            context: Resolution context with search function and installed packages
+
+        Returns:
+            ResolvedNodePackage to install or None to skip
+        """
+        ...
+
+    def confirm_node_install(self, package: ResolvedNodePackage) -> bool:
+        """Confirm whether to install a node package.
+
+        Args:
+            package: Resolved node package to confirm
+
+        Returns:
+            True to install, False to skip
+        """
+        ...
+
+
+class ModelResolutionStrategy(Protocol):
+    """Protocol for resolving model references."""
+
+    def resolve_model(
+        self,
+        reference: WorkflowNodeWidgetRef,
+        candidates: list[ResolvedModel],
+        context: ModelResolutionContext,
+    ) -> ResolvedModel | None:
+        """Resolve a model reference (ambiguous or missing).
+
+        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:
+            ResolvedModel with resolved_model filled (or None for optional unresolved)
+            None to skip resolution
+
+        Note:
+            - For resolved models: Return ResolvedModel with resolved_model set
+            - For optional unresolved: Return ResolvedModel with resolved_model=None, is_optional=True
+            - To skip: Return None
+        """
+        ...
+
+
+class RollbackStrategy(Protocol):
+    """Protocol for confirming destructive rollback operations."""
+
+    def confirm_destructive_rollback(
+        self,
+        git_changes: bool,
+        workflow_changes: bool,
+    ) -> bool:
+        """Confirm rollback that will discard uncommitted changes.
+
+        Args:
+            git_changes: Whether there are uncommitted git changes in .cec/
+            workflow_changes: Whether there are modified/new/deleted workflows
+
+        Returns:
+            True to proceed with rollback, False to cancel
+        """
+        ...
+
+
+class SyncCallbacks(Protocol):
+    """Protocol for sync operation callbacks."""
+
+    def on_dependency_group_start(self, group_name: str, is_optional: bool) -> None:
+        """Called when starting to install a dependency group.
+
+        Args:
+            group_name: Name of the dependency group
+            is_optional: Whether this is an optional group
+        """
+        ...
+
+    def on_dependency_group_complete(self, group_name: str, success: bool, error: str | None = None) -> None:
+        """Called when dependency group installation completes.
+
+        Args:
+            group_name: Name of the dependency group
+            success: Whether the installation succeeded
+            error: Error message if failed (None if succeeded)
+        """
+        ...
+
+
+class ImportCallbacks(Protocol):
+    """Protocol for import operation callbacks."""
+
+    def on_phase(self, phase: str, description: str) -> None:
+        """Called when entering a new import phase.
+
+        Args:
+            phase: Phase identifier (e.g., "extract", "install_deps", "sync_nodes")
+            description: Human-readable phase description
+        """
+        ...
+
+    def on_dependency_group_start(self, group_name: str, is_optional: bool) -> None:
+        """Called when starting to install a dependency group.
+
+        Args:
+            group_name: Name of the dependency group
+            is_optional: Whether this is an optional group
+        """
+        ...
+
+    def on_dependency_group_complete(self, group_name: str, success: bool, error: str | None = None) -> None:
+        """Called when dependency group installation completes.
+
+        Args:
+            group_name: Name of the dependency group
+            success: Whether the installation succeeded
+            error: Error message if failed (None if succeeded)
+        """
+        ...
+
+    def on_workflow_copied(self, workflow_name: str) -> None:
+        """Called when a workflow file is copied.
+
+        Args:
+            workflow_name: Name of the workflow file
+        """
+        ...
+
+    def on_node_installed(self, node_name: str) -> None:
+        """Called when a custom node is installed.
+
+        Args:
+            node_name: Name of the installed node
+        """
+        ...
+
+    def on_workflow_resolved(self, workflow_name: str, downloads: int) -> None:
+        """Called when a workflow is resolved.
+
+        Args:
+            workflow_name: Name of the workflow
+            downloads: Number of models downloaded for this workflow
+        """
+        ...
+
+    def on_error(self, error: str) -> None:
+        """Called when a non-fatal error occurs.
+
+        Args:
+            error: Error message
+        """
+        ...
+
+    def on_download_failures(self, failures: list[tuple[str, str]]) -> None:
+        """Called when model downloads fail during import.
+
+        Args:
+            failures: List of (workflow_name, model_filename) tuples
+        """
+        ...
+
+    def on_download_batch_start(self, count: int) -> None:
+        """Called when batch model downloads start.
+
+        Args:
+            count: Number of models to download
+        """
+        ...
+
+    def on_download_file_start(self, name: str, idx: int, total: int) -> None:
+        """Called when individual model download starts.
+
+        Args:
+            name: Model filename
+            idx: Current file index (1-based)
+            total: Total number of files
+        """
+        ...
+
+    def on_download_file_progress(self, downloaded: int, total: int | None) -> None:
+        """Called during model download progress.
+
+        Args:
+            downloaded: Bytes downloaded so far
+            total: Total bytes (None if unknown)
+        """
+        ...
+
+    def on_download_file_complete(self, name: str, success: bool, error: str | None) -> None:
+        """Called when model download completes.
+
+        Args:
+            name: Model filename
+            success: Whether download succeeded
+            error: Error message if failed
+        """
+        ...
+
+    def on_download_batch_complete(self, success: int, total: int) -> None:
+        """Called when all downloads complete.
+
+        Args:
+            success: Number of successful downloads
+            total: Total number of downloads attempted
+        """
+        ...
+
+
+class ExportCallbacks(Protocol):
+    """Protocol for export operation callbacks."""
+
+    def on_models_without_sources(self, models: list) -> None:
+        """Called when models are missing source URLs.
+
+        Args:
+            models: List of ModelWithoutSourceInfo instances
+        """
+        ...

comfygit_core/models/registry.py

@@ -0,0 +1,63 @@
+import re
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from .exceptions import ComfyDockError
+
+@dataclass
+class RegistryNodeVersion:
+    """Version information for a node."""
+    changelog: str
+    dependencies: list[str]
+    deprecated: bool
+    id: str
+    version: str
+    download_url: str
+
+    @classmethod
+    def from_api_data(cls, api_data: dict) -> "RegistryNodeVersion | None":
+        if not api_data:
+            return None
+        return cls(
+            changelog=api_data.get("changelog", ""),
+            dependencies=api_data.get("dependencies", []),
+            deprecated=api_data.get("deprecated", False),
+            id=api_data.get("id", ""),
+            version=api_data.get("version", ""),
+            download_url=api_data.get("downloadUrl", ""),
+        )
+
+@dataclass
+class RegistryNodeInfo:
+    """Information about a custom node."""
+    id: str
+    name: str
+    description: str
+    author: str | None = None
+    license: str | None = None
+    icon: str | None = None
+    repository: str | None = None
+    tags: list[str] = field(default_factory=list)
+    latest_version: RegistryNodeVersion | None = None
+
+    @classmethod
+    def from_api_data(cls, api_data: dict) -> "RegistryNodeInfo | None":
+        # Ensure dict has id, name and description keys:
+        id = api_data.get("id")
+        name = api_data.get("name")
+        description = api_data.get("description")
+        if not id or not name or not description:
+            return None
+        return cls(
+            id=id,
+            name=name,
+            description=description,
+            author=api_data.get("author"),
+            license=api_data.get("license"),
+            icon=api_data.get("icon"),
+            repository=api_data.get("repository"),
+            tags=api_data.get("tags", []),
+            latest_version=RegistryNodeVersion.from_api_data(api_data.get("latest_version", {})),
+        )