comfygit 0.4.0__tar.gz → 0.4.2__tar.gz

{comfygit-0.4.0 → comfygit-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfygit
-Version: 0.4.0
+Version: 0.4.2
 Summary: ComfyGit - Git-based environment management for ComfyUI
 Project-URL: Documentation, https://docs.comfygit.org/
 Project-URL: Repository, https://github.com/comfygit-ai/comfygit
@@ -9,7 +9,7 @@ License-File: LICENSE.txt
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.13.4
 Requires-Dist: argcomplete>=3.5.0
-Requires-Dist: comfygit-core==0.4.0
+Requires-Dist: comfygit-core==0.4.2
 Requires-Dist: requests>=2.33.0
 Description-Content-Type: text/markdown
 

{comfygit-0.4.0 → comfygit-0.4.2}/comfygit_cli/cli.py

@@ -978,6 +978,37 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
     )
     node_add_parser.set_defaults(func=env_cmds.node_add)
 
+    # node dev-link
+    node_dev_link_parser = node_subparsers.add_parser(
+        "dev-link",
+        help="Link a tracked node to a local development checkout",
+    )
+    node_dev_link_parser.add_argument(
+        "node_name",
+        help="Existing node identifier/name, or identifier to use for a new dev node",
+    ).completer = installed_node_completer  # type: ignore[attr-defined]
+    node_dev_link_parser.add_argument(
+        "--path",
+        required=True,
+        type=Path,
+        help="Path to the local custom-node development checkout",
+    )
+    node_dev_link_parser.add_argument(
+        "--name",
+        help="custom_nodes directory/symlink name to use when no tracked node exists",
+    )
+    node_dev_link_parser.add_argument(
+        "--replace-existing",
+        action="store_true",
+        help="Archive an existing materialized node directory and replace it with a symlink",
+    )
+    node_dev_link_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Allow replacing an existing mismatched symlink or directory",
+    )
+    node_dev_link_parser.set_defaults(func=env_cmds.node_dev_link)
+
     # node remove
     node_remove_parser = node_subparsers.add_parser("remove", help="Remove custom node(s)")
     node_remove_parser.add_argument("node_names", nargs="+", help="Node registry ID(s) or name(s)").completer = installed_node_completer  # type: ignore[attr-defined]
@@ -1030,6 +1061,65 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
     )
     workflow_importance_parser.set_defaults(func=_make_help_func(workflow_importance_parser))
 
+    model_list_parser = workflow_model_subparsers.add_parser(
+        "list",
+        help="List models declared for a workflow"
+    )
+    model_list_parser.add_argument(
+        "workflow_name",
+        nargs="?",
+        help="Workflow name (interactive if omitted)"
+    ).completer = workflow_completer  # type: ignore[attr-defined]
+    model_list_parser.set_defaults(func=env_cmds.workflow_model_list)
+
+    model_add_parser = workflow_model_subparsers.add_parser(
+        "add",
+        help="Declare an indexed local model as required by a workflow"
+    )
+    model_add_parser.add_argument(
+        "workflow_name",
+        help="Workflow name"
+    ).completer = workflow_completer  # type: ignore[attr-defined]
+    model_add_parser.add_argument(
+        "--hash",
+        dest="model_hash",
+        help="Indexed model hash to attach"
+    )
+    model_add_parser.add_argument(
+        "--path",
+        dest="relative_path",
+        help="Model path relative to the models directory, e.g. checkpoints/model.safetensors"
+    )
+    model_add_parser.add_argument(
+        "--importance",
+        "--criticality",
+        dest="importance",
+        default="required",
+        choices=["required", "flexible", "optional"],
+        help="Workflow dependency importance (default: required)"
+    )
+    model_add_parser.set_defaults(func=env_cmds.workflow_model_add)
+
+    model_remove_parser = workflow_model_subparsers.add_parser(
+        "remove",
+        help="Remove a manually declared workflow model"
+    )
+    model_remove_parser.add_argument(
+        "workflow_name",
+        help="Workflow name"
+    ).completer = workflow_completer  # type: ignore[attr-defined]
+    model_remove_parser.add_argument(
+        "--hash",
+        dest="model_hash",
+        help="Manual model hash to remove"
+    )
+    model_remove_parser.add_argument(
+        "--path",
+        dest="relative_path",
+        help="Manual model path relative to the models directory"
+    )
+    model_remove_parser.set_defaults(func=env_cmds.workflow_model_remove)
+
     importance_parser = workflow_model_subparsers.add_parser(
         "importance",
         help="Set model importance (required/flexible/optional)"

{comfygit-0.4.0 → comfygit-0.4.2}/comfygit_cli/env_commands.py

@@ -1799,6 +1799,50 @@ packages = []
 
         print(f"\nRun 'cg -e {env.name} status' to review changes")
 
+    @with_env_logging("node dev-link")
+    def node_dev_link(self, args: argparse.Namespace, logger=None) -> None:
+        """Link a tracked or new custom node to a local development checkout."""
+        env = self._get_env(args)
+
+        print(f"🔗 Linking development node: {args.node_name}")
+
+        try:
+            result = env.link_development_node(
+                args.node_name,
+                args.path,
+                name=getattr(args, "name", None),
+                replace_existing=getattr(args, "replace_existing", False),
+                force=getattr(args, "force", False),
+            )
+        except CDNodeConflictError as e:
+            if logger:
+                logger.error(f"Node dev-link conflict for '{args.node_name}': {e}", exc_info=True)
+            print(f"✗ Cannot link development node '{args.node_name}'", file=sys.stderr)
+            print(f"   {e}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            if logger:
+                logger.error(f"Node dev-link failed for '{args.node_name}': {e}", exc_info=True)
+            print(f"✗ Failed to link development node '{args.node_name}'", file=sys.stderr)
+            print(f"   {e}", file=sys.stderr)
+            sys.exit(1)
+
+        if result.already_linked and not result.requirements_changed:
+            print(f"✓ Development node '{result.name}' is already linked")
+        else:
+            print(f"✓ Development node '{result.name}' linked and tracked")
+
+        print(f"   Identifier: {result.identifier}")
+        print(f"   Link: {result.link_path} -> {result.source_path}")
+        if result.backup_path:
+            print(f"   Archived previous copy: {result.backup_path}")
+        if result.requirements_changed:
+            print("   Python requirements updated")
+        if result.needs_restart:
+            print("   Restart ComfyUI for Python node changes to load")
+
+        print(f"\nRun 'cg -e {env.name} status' to review changes")
+
     @with_env_logging("node remove")
     def node_remove(self, args: argparse.Namespace, logger=None) -> None:
         """Remove custom node(s) - handles filesystem immediately."""
@@ -3424,6 +3468,90 @@ packages = []
 
             print(f"\n✓ Updated {updated_count}/{len(models)} model(s)")
 
+    @with_env_logging("workflow model list", get_env_name=lambda self, args: self._get_env(args).name)
+    def workflow_model_list(self, args: argparse.Namespace, logger=None) -> None:
+        """List models declared for a workflow."""
+        env = self._get_env(args)
+        workflow_name = getattr(args, "workflow_name", None)
+        if not workflow_name:
+            workflow_name = self._select_workflow_interactive(env)
+            if not workflow_name:
+                print("✗ No workflow selected")
+                return
+
+        models = env.pyproject.workflows.get_workflow_models(workflow_name)
+        if not models:
+            print(f"✗ No models found in workflow '{workflow_name}'")
+            return
+
+        print(f"\n📦 Models for workflow: {workflow_name}")
+        for model in models:
+            manual = getattr(model, "declared_by", None) == "manual" or not getattr(model, "nodes", None)
+            print(f"\n  • {model.filename}")
+            if model.hash:
+                print(f"    hash:       {model.hash}")
+            if model.relative_path:
+                print(f"    path:       {model.relative_path}")
+            print(f"    category:   {model.category}")
+            print(f"    importance: {model.criticality}")
+            print(f"    status:     {model.status}")
+            print(f"    declared:   {'manual' if manual else 'workflow graph'}")
+
+    @with_env_logging("workflow model add", get_env_name=lambda self, args: self._get_env(args).name)
+    def workflow_model_add(self, args: argparse.Namespace, logger=None) -> None:
+        """Declare an indexed local model as a manual workflow dependency."""
+        env = self._get_env(args)
+        model_hash = getattr(args, "model_hash", None)
+        relative_path = getattr(args, "relative_path", None)
+        importance = getattr(args, "importance", "required")
+
+        if not model_hash and not relative_path:
+            print("✗ Provide --hash or --path for the indexed model to add")
+            sys.exit(1)
+
+        try:
+            model = env.workflow_manager.add_existing_model_to_workflow(
+                workflow_name=args.workflow_name,
+                model_hash=model_hash,
+                relative_path=relative_path,
+                criticality=importance,
+            )
+        except ValueError as e:
+            print(f"✗ {e}")
+            sys.exit(1)
+
+        identifier = model.relative_path or model.hash or model.filename
+        print(f"✓ Added manual model dependency to '{args.workflow_name}': {identifier}")
+        print(f"  importance: {model.criticality}")
+
+    @with_env_logging("workflow model remove", get_env_name=lambda self, args: self._get_env(args).name)
+    def workflow_model_remove(self, args: argparse.Namespace, logger=None) -> None:
+        """Remove a manually declared workflow model dependency."""
+        env = self._get_env(args)
+        model_hash = getattr(args, "model_hash", None)
+        relative_path = getattr(args, "relative_path", None)
+
+        if not model_hash and not relative_path:
+            print("✗ Provide --hash or --path for the manual model to remove")
+            sys.exit(1)
+
+        try:
+            removed = env.workflow_manager.remove_manual_model_from_workflow(
+                workflow_name=args.workflow_name,
+                model_hash=model_hash,
+                relative_path=relative_path,
+            )
+        except ValueError as e:
+            print(f"✗ {e}")
+            sys.exit(1)
+
+        if not removed:
+            print(f"✗ Manual model not found in workflow '{args.workflow_name}'")
+            sys.exit(1)
+
+        identifier = relative_path or model_hash
+        print(f"✓ Removed manual model dependency from '{args.workflow_name}': {identifier}")
+
     def _select_workflow_interactive(self, env) -> str | None:
         """Interactive workflow selection from available workflows.
 
@@ -3782,7 +3910,7 @@ packages = []
     def metadata_refresh(self, args: argparse.Namespace, logger: Any = None) -> None:
         """Refresh extracted metadata from ComfyUI installation.
 
-        Re-extracts builtins and folder paths for the current environment.
+        Re-extracts builtins, folder paths, and model loader metadata for the current environment.
         Useful after upgrading ComfyUI or to fix missing metadata files.
         """
         env = self._get_env(args)
@@ -3792,17 +3920,32 @@ packages = []
         try:
             result = env.refresh_metadata()
 
-            if result["builtins_refreshed"]:
-                print(f"   Refreshed comfyui_builtins.json ({result['builtins_count']} nodes)")
+            if result.get("builtins_refreshed"):
+                print(f"   Refreshed comfyui_builtins.json ({result.get('builtins_count', 0)} nodes)")
             else:
                 print("   Failed to refresh comfyui_builtins.json")
 
-            if result["folder_paths_refreshed"]:
-                print(f"   Refreshed comfyui_folder_paths.json ({result['folder_mappings_count']} folder types)")
+            if result.get("folder_paths_refreshed"):
+                print(
+                    f"   Refreshed comfyui_folder_paths.json "
+                    f"({result.get('folder_mappings_count', 0)} folder types)"
+                )
             else:
                 print("   Failed to refresh comfyui_folder_paths.json")
 
-            if result["builtins_refreshed"] or result["folder_paths_refreshed"]:
+            if result.get("model_loaders_refreshed"):
+                print(
+                    f"   Refreshed comfyui_model_loaders.json "
+                    f"({result.get('model_loaders_count', 0)} model loaders)"
+                )
+            elif "model_loaders_refreshed" in result:
+                print("   Failed to refresh comfyui_model_loaders.json")
+
+            if (
+                result.get("builtins_refreshed")
+                or result.get("folder_paths_refreshed")
+                or result.get("model_loaders_refreshed")
+            ):
                 print("\nMetadata refreshed successfully")
             else:
                 print("\nNo metadata was refreshed", file=sys.stderr)

{comfygit-0.4.0 → comfygit-0.4.2}/comfygit_cli/serve_runtime.py

@@ -576,14 +576,28 @@ def _serve_artifact_dir(env: Environment, config: ServeConfig) -> Path:
 
 
 def _studio_static_dir() -> Path:
-    return Path(str(resources.files("comfygit_cli").joinpath("contract_studio_static")))
+    return Path(str(resources.files("comfygit_cli").joinpath("studio_static")))
 
 
 async def studio_index_handler(request: web.Request) -> web.StreamResponse:
     static_dir = request.app[STUDIO_STATIC_DIR_KEY]
     index_path = static_dir / "index.html"
     if index_path.exists():
-        return web.FileResponse(index_path)
+        html = index_path.read_text(encoding="utf-8")
+        env_name = getattr(_state(request).env, "name", "Environment")
+        config = {
+            "apiBasePath": "",
+            "authMode": "none",
+            "endpointName": env_name if isinstance(env_name, str) else "Environment",
+        }
+        script = f"<script>window.__COMFYGIT_STUDIO_CONFIG__ = {json.dumps(config)};</script>"
+        if "<head>" in html:
+            html = html.replace("<head>", f"<head>{script}", 1)
+        elif "</head>" in html:
+            html = html.replace("</head>", f"{script}</head>", 1)
+        else:
+            html = f"{script}{html}"
+        return web.Response(text=html, content_type="text/html")
     return web.Response(
         text=(
             "<!doctype html><html><head><title>ComfyGit Studio</title></head>"