comfygit 0.3.8.dev1__tar.gz → 0.3.10__tar.gz

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: comfygit
-Version: 0.3.8.dev1
+Version: 0.3.10
 Summary: ComfyGit - Git-based environment management for ComfyUI
 License-File: LICENSE.txt
 Requires-Python: >=3.10
 Requires-Dist: argcomplete>=3.5.0
-Requires-Dist: comfygit-core==0.3.8.dev1
+Requires-Dist: comfygit-core==0.3.10
 Description-Content-Type: text/markdown
 
 # ComfyGit CLI

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/comfygit_cli/cli.py

@@ -165,7 +165,6 @@ def _add_global_commands(subparsers: argparse._SubParsersAction) -> None:
     init_parser.add_argument("path", type=Path, nargs="?", help="Workspace directory (default: ~/comfygit)")
     init_parser.add_argument("--models-dir", type=Path, help="Path to existing models directory to index")
     init_parser.add_argument("--yes", "-y", action="store_true", help="Use all defaults, no interactive prompts")
-    init_parser.add_argument("--bare", action="store_true", help="Create workspace without system nodes (comfygit-manager)")
     init_parser.set_defaults(func=global_cmds.init)
 
     # list - List all environments
@@ -349,6 +348,26 @@ def _add_global_commands(subparsers: argparse._SubParsersAction) -> None:
     orch_logs_parser.add_argument("-n", "--lines", type=int, default=50, help="Number of lines to show (default: 50)")
     orch_logs_parser.set_defaults(func=global_cmds.orch_logs)
 
+    # Workspace management subcommands
+    workspace_parser = subparsers.add_parser("workspace", help="Workspace operations")
+    workspace_subparsers = workspace_parser.add_subparsers(
+        dest="workspace_command",
+        help="Workspace commands"
+    )
+    workspace_parser.set_defaults(func=_make_help_func(workspace_parser))
+
+    # workspace cleanup
+    workspace_cleanup_parser = workspace_subparsers.add_parser(
+        "cleanup",
+        help="Remove legacy workspace artifacts"
+    )
+    workspace_cleanup_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Skip verification and force cleanup"
+    )
+    workspace_cleanup_parser.set_defaults(func=global_cmds.workspace_cleanup)
+
 
 def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
     """Add environment-specific commands."""
@@ -796,5 +815,21 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
     )
     py_uv_parser.set_defaults(func=env_cmds.py_uv)
 
+    # Manager subcommands (per-environment comfygit-manager)
+    manager_parser = subparsers.add_parser("manager", help="Manage comfygit-manager installation")
+    manager_subparsers = manager_parser.add_subparsers(dest="manager_command", help="Manager commands")
+    manager_parser.set_defaults(func=_make_help_func(manager_parser))
+
+    # manager status
+    manager_status_parser = manager_subparsers.add_parser("status", help="Show manager version and update availability")
+    manager_status_parser.set_defaults(func=env_cmds.manager_status)
+
+    # manager update
+    manager_update_parser = manager_subparsers.add_parser("update", help="Update or migrate comfygit-manager")
+    manager_update_parser.add_argument("--version", help="Target version (default: latest)")
+    manager_update_parser.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompts")
+    manager_update_parser.set_defaults(func=env_cmds.manager_update)
+
+
 if __name__ == "__main__":
     main()

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/comfygit_cli/cli_utils.py

@@ -10,6 +10,7 @@ from .logging.environment_logger import WorkspaceLogger
 if TYPE_CHECKING:
     from comfygit_core.core.workspace import Workspace
 
+
 def get_workspace_or_exit() -> "Workspace":
     """Get workspace or exit with error message."""
     try:

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/comfygit_cli/env_commands.py

@@ -88,6 +88,13 @@ class EnvironmentCommands:
             sys.exit(1)
         return active
 
+    def _get_python_version(self, env: Environment) -> str:
+        """Get Python version from environment."""
+        python_version_file = env.cec_path / ".python-version"
+        if python_version_file.exists():
+            return python_version_file.read_text(encoding="utf-8").strip()
+        return "3.12"
+
     def _get_or_probe_backend(
         self, env: Environment, override: str | None = None
     ) -> tuple[str, bool]:
@@ -104,29 +111,34 @@ class EnvironmentCommands:
         if override:
             return override, False
 
-        if env.pytorch_manager.has_backend():
-            return env.pytorch_manager.get_backend(), False
+        had_backend = env.pytorch_manager.has_backend()
 
-        # No backend configured - probe and set it
-        print("⚠️  No PyTorch backend configured. Auto-detecting...")
         try:
-            # Read Python version from .python-version file
-            python_version_file = env.cec_path / ".python-version"
-            python_version = (
-                python_version_file.read_text(encoding="utf-8").strip()
-                if python_version_file.exists()
-                else "3.12"
-            )
-            backend = env.pytorch_manager.probe_and_set_backend(
-                python_version,
-                backend="auto",
-            )
-            return backend, True
+            python_version = self._get_python_version(env)
+            backend = env.pytorch_manager.ensure_backend(python_version)
+
+            was_probed = not had_backend
+            if was_probed:
+                print("⚠️  No PyTorch backend configured. Auto-detecting...")
+                print(f"✓ Backend detected and saved: {backend}")
+                print("   To change: cg env-config torch-backend set <backend>")
+
+            return backend, was_probed
         except Exception as e:
             print(f"✗ Error probing PyTorch backend: {e}")
             print("   Try setting it explicitly: cg env-config torch-backend set <backend>")
             sys.exit(1)
 
+    def _show_legacy_manager_notice(self, env: Environment) -> None:
+        """Show legacy manager notice if environment uses symlinked manager."""
+        try:
+            status = env.get_manager_status()
+            if status.is_legacy:
+                print("")
+                print("Legacy manager detected. Run 'cg manager update' to migrate.")
+        except Exception:
+            pass  # Silently fail - notice is informational only
+
     def _format_size(self, size_bytes: int) -> str:
         """Format bytes as human-readable size."""
         for unit in ("B", "KB", "MB", "GB"):
@@ -611,6 +623,9 @@ class EnvironmentCommands:
 
             print("\n✓ No workflows")
             print("✓ No uncommitted changes")
+
+            # Show legacy manager notice even in clean state
+            self._show_legacy_manager_notice(env)
             return
 
         # Show environment name with branch
@@ -761,6 +776,9 @@ class EnvironmentCommands:
         # Suggested actions - smart and contextual
         self._show_smart_suggestions(status)
 
+        # Show legacy manager notice if applicable
+        self._show_legacy_manager_notice(env)
+
     # Removed: _has_uninstalled_packages - this logic is now in core's WorkflowAnalysisStatus
 
     def _print_workflow_issues(self, wf_analysis: WorkflowAnalysisStatus, verbose: bool = False) -> None:
@@ -2950,3 +2968,73 @@ class EnvironmentCommands:
                     print(f"    {m.actual_category}/{m.name} → {expected}/")
             else:
                 print("✓ No changes needed - all dependencies already resolved")
+
+    # ================================================================================
+    # Manager Commands - Per-environment comfygit-manager management
+    # ================================================================================
+
+    @with_env_logging("manager status")
+    def manager_status(self, args: argparse.Namespace, logger: Any = None) -> None:
+        """Show manager version and update availability."""
+        env = self._get_env(args)
+
+        status = env.get_manager_status()
+
+        print("comfygit-manager")
+        print(f"   Current: {status.current_version or 'not installed'}")
+        print(f"   Latest:  {status.latest_version or 'unknown'}")
+
+        if status.is_legacy:
+            print("   Legacy installation (symlinked)")
+            print(f"   Run 'cg -e {env.name} manager update' to migrate")
+        elif not status.is_tracked:
+            print("   Not installed")
+            print(f"   Run 'cg -e {env.name} manager update' to install")
+        elif status.update_available:
+            print("   Update available!")
+        else:
+            print("   Up to date")
+
+    @with_env_logging("manager update")
+    def manager_update(self, args: argparse.Namespace, logger: Any = None) -> None:
+        """Update or migrate comfygit-manager."""
+        from comfygit_core.strategies.confirmation import AutoConfirmStrategy, InteractiveConfirmStrategy
+
+        env = self._get_env(args)
+        version = getattr(args, 'version', None) or "latest"
+        use_yes = getattr(args, 'yes', False)
+
+        # Ensure backend is configured (same as sync/run commands)
+        had_backend = env.pytorch_manager.has_backend()
+        if not had_backend:
+            print("⚠️  No PyTorch backend configured. Auto-detecting...")
+            python_version = self._get_python_version(env)
+            backend = env.pytorch_manager.ensure_backend(python_version)
+            print(f"✓ Backend detected and saved: {backend}")
+            print("   To change: cg env-config torch-backend set <backend>\n")
+
+        status = env.get_manager_status()
+
+        if status.is_legacy:
+            print("Migrating comfygit-manager to per-environment installation...")
+        elif not status.is_tracked:
+            print("Installing comfygit-manager...")
+        else:
+            print("Updating comfygit-manager...")
+
+        strategy = AutoConfirmStrategy() if use_yes else InteractiveConfirmStrategy()
+
+        try:
+            result = env.update_manager(version=version, confirmation_strategy=strategy)
+
+            if result.changed:
+                print(f"   {result.message}")
+                print("\n   Restart this environment to use the new version")
+            else:
+                print(f"   {result.message}")
+
+        except Exception as e:
+            print(f"   Failed to update manager: {e}", file=sys.stderr)
+            if logger:
+                logger.error(f"Manager update failed: {e}", exc_info=True)
+            sys.exit(1)

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/comfygit_cli/global_commands.py

@@ -16,15 +16,6 @@ from .utils import create_progress_callback, paginate, show_civitai_auth_help, s
 
 logger = get_logger(__name__)
 
-# Default system nodes to install with new workspaces.
-# These are infrastructure custom nodes that provide management capabilities.
-# Use `cg init --bare` to skip installation.
-DEFAULT_SYSTEM_NODES = {
-    "comfygit-manager": {
-        "url": "https://github.com/comfyhub-org/comfygit-manager.git",
-        "description": "ComfyGit management panel for ComfyUI",
-    },
-}
 
 
 class GlobalCommands:
@@ -141,12 +132,6 @@ class GlobalCommands:
 
             print(f"✓ Workspace initialized at {workspace.path}")
 
-            # Install default system nodes (unless --bare)
-            if not getattr(args, 'bare', False):
-                self._install_system_nodes(workspace)
-            else:
-                print("📦 Skipping system node installation (--bare flag)")
-
             # Handle models directory setup
             self._setup_models_directory(workspace, args)
 
@@ -162,39 +147,6 @@ class GlobalCommands:
             print(f"✗ Failed to initialize workspace: {e}", file=sys.stderr)
             sys.exit(1)
 
-    def _install_system_nodes(self, workspace: Workspace) -> None:
-        """Install default system nodes (comfygit-manager) into workspace.
-
-        System nodes are infrastructure custom nodes that:
-        - Live at workspace level (.metadata/system_nodes/)
-        - Are symlinked into every environment
-        - Are never tracked in pyproject.toml
-        """
-        from comfygit_core.utils.git import git_clone
-
-        system_nodes_path = workspace.paths.system_nodes
-
-        for node_name, node_config in DEFAULT_SYSTEM_NODES.items():
-            target_path = system_nodes_path / node_name
-
-            if target_path.exists():
-                logger.debug(f"System node '{node_name}' already exists, skipping")
-                continue
-
-            print(f"📦 Installing system node: {node_name}")
-            try:
-                git_clone(
-                    url=node_config["url"],
-                    target_path=target_path,
-                    depth=1  # Shallow clone for speed
-                )
-                print(f"   ✓ Installed {node_name}")
-                logger.info(f"Installed system node: {node_name}")
-            except Exception as e:
-                print(f"   ⚠️  Failed to install {node_name}: {e}")
-                print("   You can install it manually later")
-                logger.warning(f"Failed to install system node {node_name}: {e}")
-
     def _show_workspace_env_setup(self, workspace_path: Path) -> None:
         """Show instructions for setting COMFYGIT_HOME for custom workspace location."""
         import os
@@ -1811,3 +1763,26 @@ class GlobalCommands:
             else:
                 print("(empty log file)")
 
+    # === Workspace Management ===
+
+    @with_workspace_logging("workspace cleanup")
+    def workspace_cleanup(self, args: argparse.Namespace) -> None:
+        """Clean up legacy workspace artifacts.
+
+        Removes .metadata/system_nodes/ directory if no environments
+        still use legacy symlinked manager.
+        """
+        force = getattr(args, 'force', False)
+
+        result = self.workspace.cleanup_legacy_system_nodes(force=force)
+
+        if result.success:
+            print(f"Removed {result.removed_path}")
+        else:
+            if result.legacy_environments:
+                print("Cannot cleanup: Some environments still use legacy manager")
+                for env in result.legacy_environments:
+                    print(f"  {env}")
+                print("\nRun 'cg -e <ENV> manager update' to migrate, then retry.")
+            else:
+                print(f"{result.message}")

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/pyproject.toml

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

comfygit-0.3.10/tests/test_manager_commands.py

@@ -0,0 +1,319 @@
+"""Tests for manager commands (cg manager status/update)."""
+import argparse
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from comfygit_core.models.shared import ManagerStatus, ManagerUpdateResult
+
+
+class TestManagerCommands:
+    """Tests for manager status and update CLI commands."""
+
+    def test_manager_status_shows_not_installed(self, capsys):
+        """manager status shows 'not installed' when manager is missing."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version=None,
+            latest_version="0.3.0",
+            update_available=False,
+            is_legacy=False,
+            is_tracked=False,
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env")
+            env_cmds.manager_status(args)
+
+        captured = capsys.readouterr()
+        assert "not installed" in captured.out
+        assert "manager update" in captured.out
+
+    def test_manager_status_shows_legacy(self, capsys):
+        """manager status shows legacy notice for symlinked installations."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.2.0",
+            latest_version="0.3.0",
+            update_available=True,
+            is_legacy=True,
+            is_tracked=False,
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env")
+            env_cmds.manager_status(args)
+
+        captured = capsys.readouterr()
+        assert "Legacy" in captured.out
+        assert "manager update" in captured.out
+
+    def test_manager_status_shows_update_available(self, capsys):
+        """manager status shows update available for tracked installations."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.2.0",
+            latest_version="0.3.0",
+            update_available=True,
+            is_legacy=False,
+            is_tracked=True,
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env")
+            env_cmds.manager_status(args)
+
+        captured = capsys.readouterr()
+        assert "Update available" in captured.out
+        assert "0.2.0" in captured.out
+        assert "0.3.0" in captured.out
+
+    def test_manager_status_shows_up_to_date(self, capsys):
+        """manager status shows up to date when no update needed."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.3.0",
+            latest_version="0.3.0",
+            update_available=False,
+            is_legacy=False,
+            is_tracked=True,
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env")
+            env_cmds.manager_status(args)
+
+        captured = capsys.readouterr()
+        assert "Up to date" in captured.out
+
+    def test_manager_update_calls_env_update_manager(self, capsys):
+        """manager update calls environment update_manager method."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.2.0",
+            latest_version="0.3.0",
+            update_available=True,
+            is_legacy=False,
+            is_tracked=True,
+        )
+        mock_env.update_manager.return_value = ManagerUpdateResult(
+            changed=True,
+            message="Updated from 0.2.0 to 0.3.0",
+            old_version="0.2.0",
+            new_version="0.3.0",
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env", version=None, yes=True)
+            env_cmds.manager_update(args)
+
+        mock_env.update_manager.assert_called_once()
+        captured = capsys.readouterr()
+        assert "Updated" in captured.out or "Updating" in captured.out
+
+    def test_manager_update_shows_migration_message_for_legacy(self, capsys):
+        """manager update shows migration message for legacy installations."""
+        from comfygit_cli.env_commands import EnvironmentCommands
+
+        env_cmds = EnvironmentCommands()
+
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.2.0",
+            latest_version="0.3.0",
+            update_available=True,
+            is_legacy=True,
+            is_tracked=False,
+        )
+        mock_env.update_manager.return_value = ManagerUpdateResult(
+            changed=True,
+            was_migration=True,
+            message="Migrated and updated to 0.3.0",
+            old_version="0.2.0",
+            new_version="0.3.0",
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env", version=None, yes=True)
+            env_cmds.manager_update(args)
+
+        captured = capsys.readouterr()
+        assert "Migrating" in captured.out
+
+
+class TestInitNoSystemNodes:
+    """Tests that init no longer installs system nodes."""
+
+    def test_init_does_not_install_system_nodes(self, tmp_path):
+        """init should not call _install_system_nodes (removed)."""
+        from comfygit_cli.global_commands import GlobalCommands
+
+        global_cmds = GlobalCommands()
+
+        # Mock workspace factory and creation
+        mock_workspace = MagicMock()
+        mock_workspace.paths.root = tmp_path
+        mock_workspace.path = tmp_path
+        mock_workspace.update_registry_data.return_value = True
+        mock_workspace.get_models_directory.return_value = tmp_path / "models"
+
+        with patch("comfygit_cli.global_commands.WorkspaceFactory") as mock_factory:
+            mock_factory.get_paths.return_value = mock_workspace.paths
+            mock_factory.create.return_value = mock_workspace
+
+            with patch.object(global_cmds, "_setup_models_directory"):
+                args = argparse.Namespace(
+                    path=None,
+                    models_dir=None,
+                    yes=True,
+                )
+
+                global_cmds.init(args)
+
+                # Verify workspace was created (no system nodes installation)
+                mock_factory.create.assert_called_once()
+
+    def test_bare_flag_no_longer_exists(self):
+        """--bare flag should not exist in init parser."""
+        from comfygit_cli.cli import create_parser
+
+        parser = create_parser()
+
+        # Find the init subparser through the subparsers action
+        init_action = None
+        for action in parser._subparsers._actions:
+            if hasattr(action, "choices") and action.choices is not None:
+                if "init" in action.choices:
+                    init_action = action.choices["init"]
+                    break
+
+        assert init_action is not None, "init subparser should exist"
+
+        # Check that --bare is not in the init parser
+        option_strings = []
+        for action in init_action._actions:
+            option_strings.extend(action.option_strings)
+
+        assert "--bare" not in option_strings
+
+
+class TestStatusLegacyManagerNotice:
+    """Tests that status command shows legacy manager notice."""
+
+    def test_status_shows_legacy_notice_even_when_clean(self, capsys):
+        """status should show legacy manager notice even when environment is clean.
+
+        Bug: Previously the status command returned early for clean environments,
+        skipping the legacy manager notice check.
+        """
+        from comfygit_cli.env_commands import EnvironmentCommands
+        from comfygit_core.models.environment import (
+            EnvironmentComparison,
+            EnvironmentStatus,
+            GitStatus,
+        )
+        from comfygit_core.models.shared import ManagerStatus
+        from comfygit_core.models.workflow import DetailedWorkflowStatus, WorkflowSyncStatus
+
+        env_cmds = EnvironmentCommands()
+
+        # Mock a clean environment with legacy manager
+        mock_env = MagicMock()
+        mock_env.name = "test-env"
+
+        # Create clean status (no workflows, no changes, synced)
+        mock_env.status.return_value = EnvironmentStatus(
+            git=GitStatus(
+                current_branch="main",
+                has_changes=False,
+            ),
+            workflow=DetailedWorkflowStatus(
+                sync_status=WorkflowSyncStatus(
+                    synced=[],
+                    new=[],
+                    modified=[],
+                    deleted=[],
+                ),
+                analyzed_workflows=[],
+            ),
+            comparison=EnvironmentComparison(
+                missing_nodes=[],
+                extra_nodes=[],
+                version_mismatches=[],
+                packages_in_sync=True,
+            ),
+            missing_models=[],
+        )
+
+        # Legacy manager detected
+        mock_env.get_manager_status.return_value = ManagerStatus(
+            current_version="0.2.0",
+            latest_version="0.3.0",
+            update_available=True,
+            is_legacy=True,
+            is_tracked=False,
+        )
+
+        with patch.object(env_cmds, "_get_env", return_value=mock_env):
+            args = argparse.Namespace(target_env="test-env", verbose=False)
+            env_cmds.status(args)
+
+        captured = capsys.readouterr()
+        # Should show clean state
+        assert "No workflows" in captured.out
+        assert "No uncommitted changes" in captured.out
+        # AND also show legacy notice
+        assert "Legacy manager detected" in captured.out
+
+
+class TestLegacyWorkspaceNotice:
+    """Tests for legacy notice in get_workspace_or_exit.
+
+    Note: Legacy notices have been moved to per-environment level.
+    The workspace-level notice has been removed. These tests verify
+    that get_workspace_or_exit() does NOT show legacy notices.
+    """
+
+    def test_no_legacy_notice_at_workspace_level(self, capsys):
+        """Workspace-level legacy notice has been removed."""
+        from comfygit_cli import cli_utils
+
+        mock_workspace = MagicMock()
+        mock_workspace.has_legacy_system_nodes.return_value = True
+
+        with patch.object(cli_utils.WorkspaceFactory, "find", return_value=mock_workspace):
+            with patch.object(cli_utils.WorkspaceLogger, "set_workspace_path"):
+                result = cli_utils.get_workspace_or_exit()
+
+        assert result == mock_workspace
+        captured = capsys.readouterr()
+        # Legacy notices are now per-environment, not workspace-level
+        assert "Legacy workspace" not in captured.out
+        assert "Legacy" not in captured.out

{comfygit-0.3.8.dev1 → comfygit-0.3.10}/tests/test_torch_backend_cli.py

@@ -152,15 +152,17 @@ class TestSyncBehavior:
     """Test that sync reads from file and doesn't overwrite user settings."""
 
     @patch('comfygit_cli.env_commands.get_workspace_or_exit')
-    def test_sync_reads_from_backend_file(self, mock_get_workspace):
-        """Sync should read backend from .pytorch-backend file."""
+    def test_sync_uses_ensure_backend(self, mock_get_workspace):
+        """Sync should use ensure_backend() which handles both existing and missing backends."""
         from comfygit_cli.env_commands import EnvironmentCommands
 
         # Setup mocks
         mock_env = MagicMock()
         mock_env.name = "test-env"
-        mock_env.pytorch_manager.backend_file.exists.return_value = True
-        mock_env.pytorch_manager.get_backend.return_value = "cu128"
+        mock_env.cec_path = MagicMock()
+        mock_env.cec_path.__truediv__ = MagicMock(return_value=MagicMock(exists=MagicMock(return_value=True)))
+        mock_env.pytorch_manager.has_backend.return_value = True
+        mock_env.pytorch_manager.ensure_backend.return_value = "cu128"
         mock_env.sync.return_value = MagicMock(success=True, packages_synced=0, dependency_groups_installed=[], errors=[])
 
         mock_workspace = MagicMock()
@@ -175,17 +177,14 @@ class TestSyncBehavior:
 
         args = argparse.Namespace(
             target_env=None,
-            torch_backend=None,  # No override - should read from file
+            torch_backend=None,  # No override - should use ensure_backend
             verbose=False
         )
 
         cmd.sync(args)
 
-        # Should have read from file, NOT called detect_backend
-        mock_env.pytorch_manager.get_backend.assert_called()
-        mock_env.pytorch_manager.detect_backend.assert_not_called()
-        # Should NOT have called set_backend (no file write)
-        mock_env.pytorch_manager.set_backend.assert_not_called()
+        # Should have called ensure_backend which reads from file or probes
+        mock_env.pytorch_manager.ensure_backend.assert_called()
 
     @patch('comfygit_cli.env_commands.get_workspace_or_exit')
     def test_sync_warns_when_no_backend_file(self, mock_get_workspace, capsys, tmp_path):
@@ -257,15 +256,17 @@ class TestRunBehavior:
     """Test that run reads from file like sync does."""
 
     @patch('comfygit_cli.env_commands.get_workspace_or_exit')
-    def test_run_uses_backend_from_file(self, mock_get_workspace):
-        """Run should use backend from .pytorch-backend file."""
+    def test_run_uses_ensure_backend(self, mock_get_workspace):
+        """Run should use ensure_backend() which handles both existing and missing backends."""
         from comfygit_cli.env_commands import EnvironmentCommands
 
         mock_env = MagicMock()
         mock_env.name = "test-env"
         mock_env.get_current_branch.return_value = "main"
-        mock_env.pytorch_manager.backend_file.exists.return_value = True
-        mock_env.pytorch_manager.get_backend.return_value = "cu128"
+        mock_env.cec_path = MagicMock()
+        mock_env.cec_path.__truediv__ = MagicMock(return_value=MagicMock(exists=MagicMock(return_value=True)))
+        mock_env.pytorch_manager.has_backend.return_value = True
+        mock_env.pytorch_manager.ensure_backend.return_value = "cu128"
         mock_env.sync.return_value = MagicMock(success=True)
         mock_env.run.return_value = MagicMock(returncode=0)
 
@@ -279,7 +280,7 @@ class TestRunBehavior:
 
         args = argparse.Namespace(
             target_env=None,
-            torch_backend=None,  # Should read from file
+            torch_backend=None,  # Should use ensure_backend
             no_sync=False,
             args=[]
         )
@@ -287,6 +288,5 @@ class TestRunBehavior:
         with pytest.raises(SystemExit) as exc_info:
             cmd.run(args)
 
-        # Should have read from file, not auto-detected
-        mock_env.pytorch_manager.get_backend.assert_called()
-        mock_env.pytorch_manager.detect_backend.assert_not_called()
+        # Should have called ensure_backend which reads from file or probes
+        mock_env.pytorch_manager.ensure_backend.assert_called()

comfygit-0.3.8.dev1/tests/test_init_system_nodes.py

@@ -1,126 +0,0 @@
-"""Tests for system node installation during workspace init."""
-import argparse
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-class TestInitSystemNodes:
-    """Tests for system node installation in init command."""
-
-    def test_default_system_nodes_constant_exists(self):
-        """DEFAULT_SYSTEM_NODES constant should exist and include comfygit-manager."""
-        from comfygit_cli.global_commands import DEFAULT_SYSTEM_NODES
-
-        assert DEFAULT_SYSTEM_NODES is not None
-        assert "comfygit-manager" in DEFAULT_SYSTEM_NODES
-        assert "url" in DEFAULT_SYSTEM_NODES["comfygit-manager"]
-
-    def test_install_system_nodes_clones_comfygit_manager(self, tmp_path):
-        """_install_system_nodes should clone comfygit-manager to system_nodes."""
-        from comfygit_cli.global_commands import GlobalCommands
-
-        # Create mock workspace
-        mock_workspace = MagicMock()
-        mock_workspace.paths.system_nodes = tmp_path / "system_nodes"
-        mock_workspace.paths.system_nodes.mkdir(parents=True)
-
-        global_cmds = GlobalCommands()
-
-        # Patch at the source module where git_clone is defined
-        with patch("comfygit_core.utils.git.git_clone") as mock_clone:
-            global_cmds._install_system_nodes(mock_workspace)
-
-            # Verify git_clone was called
-            mock_clone.assert_called_once()
-            call_args = mock_clone.call_args
-
-            # Check URL
-            assert "comfygit-manager" in call_args.kwargs["url"]
-            # Check target path
-            assert str(call_args.kwargs["target_path"]).endswith("comfygit-manager")
-            # Check shallow clone
-            assert call_args.kwargs["depth"] == 1
-
-    def test_install_system_nodes_skips_existing(self, tmp_path):
-        """_install_system_nodes should skip if node already exists."""
-        from comfygit_cli.global_commands import GlobalCommands
-
-        # Create mock workspace with existing comfygit-manager
-        mock_workspace = MagicMock()
-        mock_workspace.paths.system_nodes = tmp_path / "system_nodes"
-        mock_workspace.paths.system_nodes.mkdir(parents=True)
-        (mock_workspace.paths.system_nodes / "comfygit-manager").mkdir()
-
-        global_cmds = GlobalCommands()
-
-        # Patch at the source module where git_clone is defined
-        with patch("comfygit_core.utils.git.git_clone") as mock_clone:
-            global_cmds._install_system_nodes(mock_workspace)
-
-            # git_clone should NOT be called since directory exists
-            mock_clone.assert_not_called()
-
-    def test_bare_flag_skips_system_nodes(self, tmp_path, monkeypatch):
-        """init with --bare flag should skip system node installation."""
-        from comfygit_cli.global_commands import GlobalCommands
-
-        global_cmds = GlobalCommands()
-
-        # Mock workspace factory and creation
-        mock_workspace = MagicMock()
-        mock_workspace.paths.root = tmp_path
-        mock_workspace.paths.system_nodes = tmp_path / "system_nodes"
-        mock_workspace.path = tmp_path
-        mock_workspace.update_registry_data.return_value = True
-        mock_workspace.get_models_directory.return_value = tmp_path / "models"
-
-        with patch("comfygit_cli.global_commands.WorkspaceFactory") as mock_factory:
-            mock_factory.get_paths.return_value = mock_workspace.paths
-            mock_factory.create.return_value = mock_workspace
-
-            with patch.object(global_cmds, "_install_system_nodes") as mock_install:
-                with patch.object(global_cmds, "_setup_models_directory"):
-                    args = argparse.Namespace(
-                        path=None,
-                        models_dir=None,
-                        yes=True,
-                        bare=True
-                    )
-
-                    global_cmds.init(args)
-
-                    # _install_system_nodes should NOT be called
-                    mock_install.assert_not_called()
-
-    def test_init_calls_install_system_nodes_by_default(self, tmp_path, monkeypatch):
-        """init without --bare should call _install_system_nodes."""
-        from comfygit_cli.global_commands import GlobalCommands
-
-        global_cmds = GlobalCommands()
-
-        # Mock workspace factory and creation
-        mock_workspace = MagicMock()
-        mock_workspace.paths.root = tmp_path
-        mock_workspace.paths.system_nodes = tmp_path / "system_nodes"
-        mock_workspace.path = tmp_path
-        mock_workspace.update_registry_data.return_value = True
-        mock_workspace.get_models_directory.return_value = tmp_path / "models"
-
-        with patch("comfygit_cli.global_commands.WorkspaceFactory") as mock_factory:
-            mock_factory.get_paths.return_value = mock_workspace.paths
-            mock_factory.create.return_value = mock_workspace
-
-            with patch.object(global_cmds, "_install_system_nodes") as mock_install:
-                with patch.object(global_cmds, "_setup_models_directory"):
-                    args = argparse.Namespace(
-                        path=None,
-                        models_dir=None,
-                        yes=True,
-                        bare=False
-                    )
-
-                    global_cmds.init(args)
-
-                    # _install_system_nodes SHOULD be called
-                    mock_install.assert_called_once_with(mock_workspace)