Merge pull request #29 from comfygit-ai/dev

Release 0.3.7: Multi-model extraction and export --allow-issues fix

Author: akatz-ai

packages/cli/comfygit_cli/cli.py

@@ -197,7 +197,7 @@ def _add_global_commands(subparsers: argparse._SubParsersAction) -> None:
     # export - Export ComfyGit environment
     export_parser = subparsers.add_parser("export", help="Export ComfyGit environment (include relevant files from .cec)")
     export_parser.add_argument("path", type=Path, nargs="?", help="Path to output file")
-    export_parser.add_argument("--allow-issues", action="store_true", help="Skip confirmation if models are missing source URLs")
+    export_parser.add_argument("--allow-issues", action="store_true", help="Export even with unresolved workflows or models without source URLs")
     export_parser.set_defaults(func=global_cmds.export_env)
 
     # Model management subcommands

packages/cli/comfygit_cli/global_commands.py

@@ -749,7 +749,7 @@ def on_models_without_sources(self, models: list):
         callbacks = CLIExportCallbacks()
 
         try:
-            tarball_path = env.export_environment(output_path, callbacks=callbacks)
+            tarball_path = env.export_environment(output_path, callbacks=callbacks, allow_issues=args.allow_issues)
 
             # Check if we need user confirmation
             if callbacks.models_without_sources and not args.allow_issues:

packages/cli/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "comfygit"
-version = "0.3.6"
+version = "0.3.7"
 description = "ComfyGit - Git-based environment management for ComfyUI"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "comfygit-core==0.3.6",
+    "comfygit-core==0.3.7",
     "argcomplete>=3.5.0",
 ]
 

packages/core/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfygit-core"
-version = "0.3.6"
+version = "0.3.7"
 description = "ComfyGit Core - Git-based ComfyUI environment manager"
 readme = "README.md"
 requires-python = ">=3.10"

packages/core/src/comfygit_core/analyzers/workflow_dependency_parser.py

@@ -9,6 +9,7 @@
 from ..logging.logging_config import get_logger
 from .node_classifier import NodeClassifier
 from ..configs.model_config import ModelConfig
+from ..configs.comfyui_models import MULTI_MODEL_WIDGET_CONFIGS
 from ..models.workflow import (
     WorkflowNodeWidgetRef,
     WorkflowNode,
@@ -88,57 +89,151 @@ def analyze_dependencies(self) -> WorkflowDependencies:
     def _extract_model_node_refs(self, node_id: str, node_info: WorkflowNode) -> List["WorkflowNodeWidgetRef"]:
         """Extract possible model references from a single node.
 
+        Uses a two-pronged approach:
+        1. Extract from properties.models (preferred - has URLs for auto-download)
+        2. Fall back to widget extraction using MULTI_MODEL_WIDGET_CONFIGS
+
         Args:
             node_id: Scoped node ID from workflow.nodes dict key (e.g., "uuid:12" for subgraph nodes)
             node_info: WorkflowNode object containing node data
         """
+        refs: list[WorkflowNodeWidgetRef] = []
 
-        refs = []
+        # Strategy 1: Extract from properties.models (preferred - has URLs)
+        property_models = node_info.properties.get('models', [])
+        if property_models:
+            refs.extend(self._extract_from_properties_models(node_id, node_info, property_models))
 
-        # Handle multi-model nodes specially
-        if node_info.type == "CheckpointLoader":
-            # Index 0: checkpoint, Index 1: config
-            widgets = node_info.widgets_values or []
-            if len(widgets) > 0 and widgets[0]:
-                refs.append(WorkflowNodeWidgetRef(
-                    node_id=node_id,  # Use scoped ID from dict key
-                    node_type=node_info.type,
-                    widget_index=0,
-                    widget_value=widgets[0]
-                ))
-            if len(widgets) > 1 and widgets[1]:
-                refs.append(WorkflowNodeWidgetRef(
-                    node_id=node_id,  # Use scoped ID from dict key
-                    node_type=node_info.type,
-                    widget_index=1,
-                    widget_value=widgets[1]
-                ))
+        # Strategy 2: Multi-model nodes (explicit widget indices from config)
+        if node_info.type in MULTI_MODEL_WIDGET_CONFIGS:
+            widget_refs = self._extract_multi_model_widgets(node_id, node_info)
+            refs = self._merge_model_refs(refs, widget_refs)
 
-        # Standard single-model loaders
+        # Strategy 3: Standard single-model loaders
         elif self.model_config.is_model_loader_node(node_info.type):
-            widget_idx = self.model_config.get_widget_index_for_node(node_info.type)
-            widgets = node_info.widgets_values or []
-            if widget_idx < len(widgets) and widgets[widget_idx]:
-                refs.append(WorkflowNodeWidgetRef(
-                    node_id=node_id,  # Use scoped ID from dict key
-                    node_type=node_info.type,
-                    widget_index=widget_idx,
-                    widget_value=widgets[widget_idx]
-                ))
+            widget_refs = self._extract_single_model_widget(node_id, node_info)
+            refs = self._merge_model_refs(refs, widget_refs)
 
-        # Pattern match all widgets for custom nodes
+        # Strategy 4: Pattern match all widgets for custom nodes
         else:
-            widgets = node_info.widgets_values or []
-            for idx, value in enumerate(widgets):
-                if self._looks_like_model(value):
+            widget_refs = self._extract_by_pattern(node_id, node_info)
+            refs = self._merge_model_refs(refs, widget_refs)
+
+        return refs
+
+    def _extract_from_properties_models(
+        self,
+        node_id: str,
+        node_info: WorkflowNode,
+        property_models: list[dict]
+    ) -> list[WorkflowNodeWidgetRef]:
+        """Extract model refs from node.properties.models array.
+
+        Properties models have structure:
+        {"name": "model.safetensors", "url": "https://...", "directory": "text_encoders"}
+        """
+        refs = []
+        for idx, model_entry in enumerate(property_models):
+            if not isinstance(model_entry, dict):
+                continue
+            name = model_entry.get('name', '')
+            if not name:
+                continue
+
+            # Find corresponding widget index by matching name to widgets_values
+            widget_idx = self._find_widget_index_for_name(node_info, name)
+
+            refs.append(WorkflowNodeWidgetRef(
+                node_id=node_id,
+                node_type=node_info.type,
+                widget_index=widget_idx if widget_idx is not None else idx,
+                widget_value=name,
+                property_url=model_entry.get('url'),
+                property_directory=model_entry.get('directory')
+            ))
+        return refs
+
+    def _find_widget_index_for_name(self, node_info: WorkflowNode, name: str) -> int | None:
+        """Find widget index that contains the given model name."""
+        widgets = node_info.widgets_values or []
+        for idx, value in enumerate(widgets):
+            if isinstance(value, str) and value == name:
+                return idx
+        return None
+
+    def _extract_multi_model_widgets(self, node_id: str, node_info: WorkflowNode) -> list[WorkflowNodeWidgetRef]:
+        """Extract models from multi-model nodes using MULTI_MODEL_WIDGET_CONFIGS.
+
+        Note: Unlike pattern matching, multi-model configs explicitly define which
+        widgets contain models, so we trust them without extension filtering.
+        This allows CheckpointLoader to capture both .safetensors and .yaml configs.
+        """
+        refs = []
+        widget_indices = MULTI_MODEL_WIDGET_CONFIGS.get(node_info.type, [])
+        widgets = node_info.widgets_values or []
+
+        for widget_idx in widget_indices:
+            if widget_idx < len(widgets) and widgets[widget_idx]:
+                value = widgets[widget_idx]
+                if isinstance(value, str) and value.strip():
                     refs.append(WorkflowNodeWidgetRef(
-                        node_id=node_id,  # Use scoped ID from dict key
+                        node_id=node_id,
                         node_type=node_info.type,
-                        widget_index=idx,
+                        widget_index=widget_idx,
                         widget_value=value
                     ))
+        return refs
+
+    def _extract_single_model_widget(self, node_id: str, node_info: WorkflowNode) -> list[WorkflowNodeWidgetRef]:
+        """Extract model from standard single-model loader nodes."""
+        refs = []
+        widget_idx = self.model_config.get_widget_index_for_node(node_info.type)
+        widgets = node_info.widgets_values or []
+
+        if widget_idx < len(widgets) and widgets[widget_idx]:
+            refs.append(WorkflowNodeWidgetRef(
+                node_id=node_id,
+                node_type=node_info.type,
+                widget_index=widget_idx,
+                widget_value=widgets[widget_idx]
+            ))
+        return refs
+
+    def _extract_by_pattern(self, node_id: str, node_info: WorkflowNode) -> list[WorkflowNodeWidgetRef]:
+        """Extract models by pattern matching widget values (for custom nodes)."""
+        refs = []
+        widgets = node_info.widgets_values or []
 
+        for idx, value in enumerate(widgets):
+            if self._looks_like_model(value):
+                refs.append(WorkflowNodeWidgetRef(
+                    node_id=node_id,
+                    node_type=node_info.type,
+                    widget_index=idx,
+                    widget_value=value
+                ))
         return refs
+
+    def _merge_model_refs(
+        self,
+        property_refs: list[WorkflowNodeWidgetRef],
+        widget_refs: list[WorkflowNodeWidgetRef]
+    ) -> list[WorkflowNodeWidgetRef]:
+        """Merge property refs with widget refs, preserving property metadata.
+
+        Property refs take precedence when both have the same widget_value,
+        since they may contain URL metadata for auto-download.
+        """
+        # Build set of values already in property_refs
+        property_values = {ref.widget_value for ref in property_refs}
+
+        # Add widget refs that aren't already covered by property refs
+        merged = list(property_refs)
+        for ref in widget_refs:
+            if ref.widget_value not in property_values:
+                merged.append(ref)
+
+        return merged
 
     def _looks_like_model(self, value: Any) -> bool:
         """Check if value looks like a model path"""

packages/core/src/comfygit_core/configs/comfyui_models.py

@@ -1,5 +1,14 @@
 """Default ComfyUI models configuration"""
 
+# Multi-model widget configurations: node_type -> list of widget indices containing models
+# These nodes load multiple models from different widget positions
+MULTI_MODEL_WIDGET_CONFIGS: dict[str, list[int]] = {
+    "CheckpointLoader": [0, 1],           # checkpoint, config
+    "DualCLIPLoader": [0, 1],             # clip_name1, clip_name2
+    "TripleCLIPLoader": [0, 1, 2],        # clip_name1, clip_name2, clip_name3
+    "QuadrupleCLIPLoader": [0, 1, 2, 3],  # clip_name1, clip_name2, clip_name3, clip_name4
+}
+
 COMFYUI_MODELS_CONFIG = {
     "version": "2024.1",
     "default_extensions": [

packages/core/src/comfygit_core/core/environment.py

@@ -1474,19 +1474,21 @@ def list_dependencies(self, all: bool = False) -> dict[str, list[str]]:
     def export_environment(
         self,
         output_path: Path,
-        callbacks: ExportCallbacks | None = None
+        callbacks: ExportCallbacks | None = None,
+        allow_issues: bool = False
     ) -> Path:
         """Export environment as .tar.gz bundle.
 
         Args:
             output_path: Path for output tarball
             callbacks: Optional callbacks for warnings/progress
+            allow_issues: Allow export even with unresolved workflow issues
 
         Returns:
             Path to created tarball
 
         Raises:
-            CDExportError: If environment has uncommitted changes or unresolved issues
+            CDExportError: If environment has uncommitted changes or unresolved issues (unless allow_issues)
         """
         from ..managers.export_import_manager import ExportImportManager
         from ..models.exceptions import CDExportError, ExportErrorContext
@@ -1516,8 +1518,8 @@ def export_environment(
                 context=context
             )
 
-        # Validation: Check all workflows are resolved
-        if not status.is_commit_safe:
+        # Validation: Check all workflows are resolved (unless allow_issues)
+        if not status.is_commit_safe and not allow_issues:
             context = ExportErrorContext(has_unresolved_issues=True)
             raise CDExportError(
                 "Cannot export - workflows have unresolved issues",

packages/core/src/comfygit_core/models/workflow.py

@@ -621,24 +621,35 @@ def version_mismatch(self) -> bool:
         return bool(self.suggested_version and
                    self.installed_version != self.suggested_version)
 
-@dataclass(frozen=True)
+@dataclass
 class WorkflowNodeWidgetRef:
-    """Reference to a widget value in a workflow node."""
+    """Reference to a widget value in a workflow node.
+
+    Core identity fields: node_id, node_type, widget_index, widget_value
+    Optional metadata fields: property_url, property_directory (from properties.models)
+
+    Hash/eq are based only on core identity fields for deduplication.
+    """
     node_id: str
     node_type: str
     widget_index: int
     widget_value: str  # Original value from workflow
-    
+
+    # Optional metadata from properties.models (for download intent creation)
+    property_url: str | None = None
+    property_directory: str | None = None
+
     def __eq__(self, value: object) -> bool:
+        """Compare based on core identity fields only (excludes property metadata)."""
         if isinstance(value, WorkflowNodeWidgetRef):
-            return self.node_id == value.node_id and \
-                self.node_type == value.node_type and \
-                self.widget_index == value.widget_index and \
-                self.widget_value == value.widget_value
+            return (self.node_id == value.node_id and
+                    self.node_type == value.node_type and
+                    self.widget_index == value.widget_index and
+                    self.widget_value == value.widget_value)
         return False
-    
+
     def __hash__(self) -> int:
-        """Hash based on all fields for proper dict/set lookups."""
+        """Hash based on core identity fields only for proper dict/set lookups."""
         return hash((self.node_id, self.node_type, self.widget_index, self.widget_value))
 
 @dataclass

packages/core/src/comfygit_core/resolvers/model_resolver.py

@@ -152,10 +152,41 @@ def resolve_model(
                 for model in candidates
             ]
 
+        # Strategy 5: Auto-create download intent from properties.models metadata
+        if ref.property_url:
+            target_directory = ref.property_directory or self._infer_directory_for_node(ref.node_type)
+            target_path = Path(target_directory) / Path(ref.widget_value).name
+            logger.debug(
+                f"Creating property-based download intent for {ref.widget_value} "
+                f"from URL: {ref.property_url} -> {target_path}"
+            )
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    resolved_model=None,
+                    model_source=ref.property_url,
+                    target_path=target_path,
+                    match_type="property_download_intent",
+                    match_confidence=1.0,
+                )
+            ]
+
         # No matches found
         logger.debug(f"No matches found in pyproject or model index for {ref}")
         return None
 
+    def _infer_directory_for_node(self, node_type: str) -> str:
+        """Infer target model directory from node type.
+
+        Uses model_config mappings to determine appropriate directory.
+        Falls back to 'models' if node type is unknown.
+        """
+        directories = self.model_config.get_directories_for_node(node_type)
+        if directories:
+            return directories[0]  # Use first directory as default
+        return "models"
+
     def _try_exact_match(self, path: str, all_models: list[ModelWithLocation] | None =None) -> list["ModelWithLocation"]:
         """Try exact path match"""
         if all_models is None: