comfygit 0.3.8__tar.gz → 0.3.8.dev1__tar.gz

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: comfygit
-Version: 0.3.8
+Version: 0.3.8.dev1
 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
+Requires-Dist: comfygit-core==0.3.8.dev1
 Description-Content-Type: text/markdown
 
 # ComfyGit CLI

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

@@ -3,13 +3,12 @@
 
 import argparse
 import sys
-from importlib.metadata import version, PackageNotFoundError
+from collections.abc import Callable
+from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from typing import Callable
 
 import argcomplete
 
-from .completion_commands import CompletionCommands
 from .completers import (
     branch_completer,
     commit_hash_completer,
@@ -18,6 +17,7 @@ from .completers import (
     ref_completer,
     workflow_completer,
 )
+from .completion_commands import CompletionCommands
 from .env_commands import EnvironmentCommands
 from .global_commands import GlobalCommands
 from .logging.logging_config import setup_logging
@@ -274,8 +274,11 @@ def _add_global_commands(subparsers: argparse._SubParsersAction) -> None:
     registry_update_parser = registry_subparsers.add_parser("update", help="Update registry data from GitHub")
     registry_update_parser.set_defaults(func=global_cmds.registry_update)
 
-    # Config management
+    # Config management - now with subcommands
     config_parser = subparsers.add_parser("config", help="Manage configuration settings")
+    config_subparsers = config_parser.add_subparsers(dest="config_command", help="Configuration commands")
+
+    # Legacy flags - still supported at root level for backward compatibility
     config_parser.add_argument("--civitai-key", type=str, help="Set Civitai API key (use empty string to clear)")
     config_parser.add_argument("--show", action="store_true", help="Show current configuration")
     config_parser.set_defaults(func=global_cmds.config)
@@ -386,9 +389,42 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
 
     # Environment Operation Commands (operate IN environments, require -e or active)
 
+    # env-config - Environment-scoped configuration (requires -e or active env)
+    env_config_parser = subparsers.add_parser("env-config", help="Manage environment-specific configuration")
+    env_config_subparsers = env_config_parser.add_subparsers(dest="env_config_command", help="Environment config commands")
+    env_config_parser.set_defaults(func=_make_help_func(env_config_parser))
+
+    # env-config torch-backend - Manage PyTorch backend for this environment
+    env_config_torch_parser = env_config_subparsers.add_parser("torch-backend", help="Manage PyTorch backend settings")
+    env_config_torch_subparsers = env_config_torch_parser.add_subparsers(dest="torch_command", help="PyTorch backend commands")
+    env_config_torch_parser.set_defaults(func=_make_help_func(env_config_torch_parser))
+
+    # env-config torch-backend show
+    env_config_torch_show_parser = env_config_torch_subparsers.add_parser("show", help="Show current PyTorch backend")
+    env_config_torch_show_parser.set_defaults(func=env_cmds.env_config_torch_show)
+
+    # env-config torch-backend set <backend>
+    env_config_torch_set_parser = env_config_torch_subparsers.add_parser("set", help="Set PyTorch backend")
+    env_config_torch_set_parser.add_argument("backend", help="Backend to set (e.g., cu128, cpu, rocm6.3, xpu)")
+    env_config_torch_set_parser.set_defaults(func=env_cmds.env_config_torch_set)
+
+    # env-config torch-backend detect
+    env_config_torch_detect_parser = env_config_torch_subparsers.add_parser("detect", help="Auto-detect and show recommended backend")
+    env_config_torch_detect_parser.set_defaults(func=env_cmds.env_config_torch_detect)
+
     # run - Run ComfyUI (special handling for ComfyUI args)
     run_parser = subparsers.add_parser("run", help="Run ComfyUI")
     run_parser.add_argument("--no-sync", action="store_true", help="Skip environment sync before running")
+    run_parser.add_argument(
+        "--torch-backend",
+        default=None,
+        metavar="BACKEND",
+        help=(
+            "PyTorch backend override (one-time, not saved). Examples: cpu, "
+            "cu128 (CUDA 12.8), cu126, cu124, rocm6.3 (AMD), xpu (Intel). "
+            "Reads from .pytorch-backend file if not specified."
+        ),
+    )
     run_parser.set_defaults(func=env_cmds.run, args=[])
 
     # status - Show environment status
@@ -414,6 +450,25 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
     )
     repair_parser.set_defaults(func=env_cmds.repair)
 
+    # sync - Sync environment (packages, nodes, models)
+    sync_parser = subparsers.add_parser("sync", help="Sync environment packages and dependencies")
+    sync_parser.add_argument(
+        "--torch-backend",
+        default=None,
+        metavar="BACKEND",
+        help=(
+            "PyTorch backend override (one-time, not saved). Examples: cpu, "
+            "cu128 (CUDA 12.8), cu126, cu124, rocm6.3 (AMD), xpu (Intel). "
+            "Reads from .pytorch-backend file if not specified."
+        ),
+    )
+    sync_parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Show full UV output during sync"
+    )
+    sync_parser.set_defaults(func=env_cmds.sync)
+
     # log - Show commit history
     log_parser = subparsers.add_parser("log", help="Show commit history")
     log_parser.add_argument("-n", "--limit", type=int, default=20, metavar="N", help="Number of commits to show (default: 20)")
@@ -489,6 +544,11 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
         default="origin",
         help="Git remote name (default: origin)"
     )
+    pull_parser.add_argument(
+        "-b", "--branch",
+        default=None,
+        help="Remote branch to pull (default: current local branch). Use when remote has different default branch (e.g., master vs main)"
+    )
     pull_parser.add_argument(
         "--models",
         choices=["all", "required", "skip"],
@@ -510,6 +570,16 @@ def _add_env_commands(subparsers: argparse._SubParsersAction) -> None:
         choices=["mine", "theirs"],
         help="Auto-resolve conflicts: 'mine' keeps local, 'theirs' takes incoming"
     )
+    pull_parser.add_argument(
+        "--torch-backend",
+        default=None,
+        metavar="BACKEND",
+        help=(
+            "PyTorch backend override (one-time, not saved). Examples: cpu, "
+            "cu128 (CUDA 12.8), cu126, cu124, rocm6.3 (AMD), xpu (Intel). "
+            "Reads from .pytorch-backend file if not specified."
+        ),
+    )
     pull_parser.set_defaults(func=env_cmds.pull)
 
     # push - Push commits to remote

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

@@ -88,6 +88,45 @@ class EnvironmentCommands:
             sys.exit(1)
         return active
 
+    def _get_or_probe_backend(
+        self, env: Environment, override: str | None = None
+    ) -> tuple[str, bool]:
+        """Get torch backend from file or probe if missing.
+
+        Args:
+            env: Environment to get backend for
+            override: Optional explicit backend override
+
+        Returns:
+            Tuple of (backend_string, was_probed) where was_probed is True
+            if we had to auto-probe because no backend was configured.
+        """
+        if override:
+            return override, False
+
+        if env.pytorch_manager.has_backend():
+            return env.pytorch_manager.get_backend(), False
+
+        # 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
+        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 _format_size(self, size_bytes: int) -> str:
         """Format bytes as human-readable size."""
         for unit in ("B", "KB", "MB", "GB"):
@@ -270,6 +309,121 @@ class EnvironmentCommands:
 
     # === Commands that operate IN environments ===
 
+    # === Environment Configuration ===
+
+    @with_env_logging("env-config torch-backend show")
+    def env_config_torch_show(self, args: argparse.Namespace, logger=None) -> None:
+        """Show current PyTorch backend setting for this environment."""
+        env = self._get_env(args)
+
+        backend = env.pytorch_manager.get_backend()
+        backend_file = env.pytorch_manager.backend_file
+        versions = env.pytorch_manager.get_versions()
+
+        print(f"PyTorch Backend: {backend}")
+        if versions:
+            for pkg, ver in versions.items():
+                print(f"   {pkg}={ver}")
+
+        if backend_file.exists():
+            print(f"   Source: {backend_file}")
+        else:
+            print("   Source: auto-detected (no .pytorch-backend file)")
+            print()
+            print(f"💡 To save this setting: cg env-config torch-backend set {backend}")
+
+    @with_env_logging("env-config torch-backend set")
+    def env_config_torch_set(self, args: argparse.Namespace, logger=None) -> None:
+        """Set PyTorch backend for this environment.
+
+        Probes for exact versions and stores both backend and version pins.
+        """
+        from comfygit_core.utils.pytorch_prober import PyTorchProbeError
+
+        env = self._get_env(args)
+        backend = args.backend
+
+        # Validate backend format
+        if not env.pytorch_manager.is_valid_backend(backend):
+            print(f"✗ Invalid backend: {backend}")
+            print()
+            print("Valid formats:")
+            print("  • cu118, cu121, cu124, cu126, cu128 (CUDA)")
+            print("  • cpu")
+            print("  • rocm6.2, rocm6.3 (AMD)")
+            print("  • xpu (Intel)")
+            sys.exit(1)
+
+        # Read python version
+        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"
+        )
+
+        # Probe and set backend with versions
+        print(f"🔍 Probing PyTorch versions for {backend} (Python {python_version})...")
+        try:
+            resolved = env.pytorch_manager.probe_and_set_backend(python_version, backend)
+        except PyTorchProbeError as e:
+            print(f"✗ Error probing PyTorch: {e}")
+            sys.exit(1)
+
+        # Show what was stored
+        versions = env.pytorch_manager.get_versions()
+        print(f"✓ PyTorch backend set to: {resolved}")
+        if versions:
+            for pkg, ver in versions.items():
+                print(f"   {pkg}={ver}")
+        print()
+        print("Run 'cg sync' to apply the new backend configuration.")
+
+    @with_env_logging("env-config torch-backend detect")
+    def env_config_torch_detect(self, args: argparse.Namespace, logger=None) -> None:
+        """Auto-detect recommended PyTorch backend using uv probe."""
+        from comfygit_core.utils.pytorch_prober import PyTorchProbeError, probe_pytorch_versions
+
+        env = self._get_env(args)
+        backend_file = env.pytorch_manager.backend_file
+
+        # Read python version from 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"
+        )
+
+        # Probe for recommended backend
+        print(f"🔍 Probing PyTorch compatibility for Python {python_version}...")
+        try:
+            _, detected = probe_pytorch_versions(python_version, "auto")
+        except PyTorchProbeError as e:
+            print(f"✗ Error probing PyTorch: {e}")
+            sys.exit(1)
+
+        # Get current backend (if any)
+        if env.pytorch_manager.has_backend():
+            current = env.pytorch_manager.get_backend()
+        else:
+            current = "(not configured)"
+
+        print(f"Detected backend: {detected}")
+        print(f"Current backend:  {current}")
+
+        if backend_file.exists():
+            print(f"   Source: {backend_file}")
+        else:
+            print("   Source: not configured")
+
+        if current != detected and current != "(not configured)":
+            print()
+            print(f"💡 Consider updating: cg env-config torch-backend set {detected}")
+        elif current == "(not configured)":
+            print()
+            print(f"💡 Set the backend: cg env-config torch-backend set {detected}")
+
     @with_env_logging("run")
     def run(self, args: argparse.Namespace) -> None:
         """Run ComfyUI in the specified environment."""
@@ -278,14 +432,32 @@ class EnvironmentCommands:
         comfyui_args = args.args if hasattr(args, 'args') else []
         no_sync = getattr(args, 'no_sync', False)
 
+        # Handle torch-backend: use override, read from file, or probe if missing
+        torch_backend_override = getattr(args, 'torch_backend', None)
+        torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+        if torch_backend_override:
+            print(f"🔧 Using PyTorch backend override: {torch_backend}")
+        elif was_probed:
+            print(f"✓ Backend detected and saved: {torch_backend}")
+            print(f"   To change: cg env-config torch-backend set <backend>")
+        else:
+            print(f"🔧 Using PyTorch backend: {torch_backend}")
+
         current_branch = env.get_current_branch()
         branch_display = f" (on {current_branch})" if current_branch else " (detached HEAD)"
 
         while True:
             # Sync before running (unless --no-sync)
+            # Use explicit override if provided, otherwise None (backend is now in file)
             if not no_sync:
                 print(f"🔄 Syncing environment: {env.name}")
-                env.sync(preserve_workflows=True, remove_extra_nodes=False)
+                env.sync(
+                    preserve_workflows=True,
+                    remove_extra_nodes=False,
+                    backend_override=torch_backend_override if torch_backend_override else None,
+                    verbose=True,
+                )
 
             print(f"🎮 Starting ComfyUI in environment: {env.name}{branch_display}")
             if comfyui_args:
@@ -300,6 +472,54 @@ class EnvironmentCommands:
 
             sys.exit(result.returncode)
 
+    @with_env_logging("sync")
+    def sync(self, args: argparse.Namespace, logger=None) -> None:
+        """Sync environment packages and dependencies."""
+        env = self._get_env(args)
+
+        # Handle torch-backend: use override, read from file, or probe if missing
+        torch_backend_override = getattr(args, 'torch_backend', None)
+        torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+        if torch_backend_override:
+            print(f"🔧 Using PyTorch backend override: {torch_backend}")
+        elif was_probed:
+            print(f"✓ Backend detected and saved: {torch_backend}")
+            print(f"   To change: cg env-config torch-backend set <backend>")
+        else:
+            print(f"🔧 Using PyTorch backend: {torch_backend}")
+
+        print(f"\n🔄 Syncing environment: {env.name}")
+
+        verbose = getattr(args, 'verbose', False)
+
+        try:
+            # Use explicit override if provided, otherwise None (backend is now in file)
+            result = env.sync(
+                dry_run=False,
+                model_strategy="skip",  # Sync command focuses on packages
+                remove_extra_nodes=False,  # Don't remove nodes, just sync
+                verbose=verbose,
+                backend_override=torch_backend_override if torch_backend_override else None,
+            )
+
+            if result.success:
+                print("\n✓ Sync complete")
+                if result.packages_synced:
+                    print(f"   Packages synced: {result.packages_synced}")
+                if result.dependency_groups_installed:
+                    print(f"   Dependency groups: {', '.join(result.dependency_groups_installed)}")
+            else:
+                print("\n⚠️  Sync completed with warnings")
+                for error in result.errors:
+                    print(f"   • {error}")
+
+        except Exception as e:
+            if logger:
+                logger.error(f"Sync failed: {e}", exc_info=True)
+            print(f"\n✗ Sync failed: {e}", file=sys.stderr)
+            sys.exit(1)
+
     def manifest(self, args: argparse.Namespace) -> None:
         """Show environment manifest (pyproject.toml configuration)."""
         env = self._get_env(args)
@@ -1997,10 +2217,11 @@ class EnvironmentCommands:
             sys.exit(1)
 
         # Preview mode - read-only, just show what would change
+        branch = getattr(args, 'branch', None)
         if getattr(args, "preview", False):
             try:
                 print(f"Fetching from {args.remote}...")
-                diff = env.preview_pull(remote=args.remote)
+                diff = env.preview_pull(remote=args.remote, branch=branch)
 
                 if not diff.has_changes:
                     if diff.is_already_merged:
@@ -2044,7 +2265,7 @@ class EnvironmentCommands:
             else:
                 # Check for conflicts before pull
                 print(f"Checking for conflicts with {args.remote}...")
-                diff = env.preview_pull(remote=args.remote)
+                diff = env.preview_pull(remote=args.remote, branch=branch)
                 if diff.has_conflicts:
                     # Interactive conflict resolution
                     from .strategies.conflict_resolver import InteractiveConflictResolver
@@ -2073,6 +2294,18 @@ class EnvironmentCommands:
 
             print(f"📥 Pulling from {args.remote}...")
 
+            # Handle torch-backend: use override, read from file, or probe if missing
+            torch_backend_override = getattr(args, 'torch_backend', None)
+            torch_backend, was_probed = self._get_or_probe_backend(env, torch_backend_override)
+
+            if torch_backend_override:
+                print(f"🔧 Using PyTorch backend override: {torch_backend}")
+            elif was_probed:
+                print(f"🔧 Auto-detected PyTorch backend: {torch_backend}")
+                print(f"   To save: cg env-config torch-backend set {torch_backend}")
+            else:
+                print(f"🔧 Using PyTorch backend: {torch_backend}")
+
             # Create callbacks for node and model progress (reuse repair command patterns)
             from comfygit_core.models.workflow import BatchDownloadCallbacks, NodeInstallCallbacks
             from .utils.progress import create_progress_callback
@@ -2113,11 +2346,13 @@ class EnvironmentCommands:
             force = getattr(args, 'force', False)
             result = env.pull_and_repair(
                 remote=args.remote,
+                branch=branch,
                 model_strategy=getattr(args, 'models', 'all'),
                 model_callbacks=model_callbacks,
                 node_callbacks=node_callbacks,
                 strategy_option=strategy_option,
                 force=force,
+                backend_override=torch_backend,
             )
 
             # Extract sync result for summary

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

@@ -94,7 +94,6 @@ class GlobalCommands:
         - uv_cache/ for package management
         - environments/ for ComfyUI environments
         """
-        from pathlib import Path
 
         # Validate models directory if provided (before creating workspace)
         explicit_models_dir = getattr(args, 'models_dir', None)
@@ -193,7 +192,7 @@ class GlobalCommands:
                 logger.info(f"Installed system node: {node_name}")
             except Exception as e:
                 print(f"   ⚠️  Failed to install {node_name}: {e}")
-                print(f"   You can install it manually later")
+                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:
@@ -231,8 +230,7 @@ class GlobalCommands:
             args: CLI arguments containing models_dir and yes flags
         """
         from pathlib import Path
-        from comfygit_cli.utils.progress import create_model_sync_progress
-        from comfygit_core.utils.common import format_size
+
 
         # Check for explicit flags
         use_interactive = not getattr(args, 'yes', False)
@@ -256,7 +254,7 @@ class GlobalCommands:
         print("\nOptions:")
         print("  1. Point to an existing ComfyUI models directory (recommended)")
         print("     → Access all your existing models immediately")
-        print(f"     → Example: ~/ComfyUI/models")
+        print("     → Example: ~/ComfyUI/models")
         print("\n  2. Use the default empty directory")
         print(f"     → ComfyGit created: {workspace.paths.models}")
         print("     → Download models as needed later")
@@ -296,7 +294,7 @@ class GlobalCommands:
                 # Auto-detect if they entered ComfyUI root instead of models subdir
                 if (models_path / "models").exists() and models_path.name != "models":
                     print(f"\n⚠️  Detected ComfyUI installation at: {models_path}")
-                    use_subdir = input(f"Use models/ subdirectory instead? (Y/n): ").strip().lower()
+                    use_subdir = input("Use models/ subdirectory instead? (Y/n): ").strip().lower()
                     if use_subdir != 'n':
                         models_path = models_path / "models"
                         print(f"Using: {models_path}")
@@ -322,9 +320,10 @@ class GlobalCommands:
             workspace: The workspace instance
             models_path: Path to the models directory to scan
         """
-        from comfygit_cli.utils.progress import create_model_sync_progress
         from comfygit_core.utils.common import format_size
 
+        from comfygit_cli.utils.progress import create_model_sync_progress
+
         try:
             progress = create_model_sync_progress()
             workspace.set_models_directory(models_path, progress=progress)
@@ -404,7 +403,7 @@ class GlobalCommands:
 
         # Read log lines
         try:
-            with open(log_file, 'r', encoding='utf-8') as f:
+            with open(log_file, encoding='utf-8') as f:
                 lines = f.readlines()
         except Exception as e:
             print(f"✗ Failed to read log file: {e}", file=sys.stderr)
@@ -453,9 +452,9 @@ class GlobalCommands:
             for line in record:
                 print(line.rstrip())
 
-        print(f"\n=== End of logs ===")
+        print("\n=== End of logs ===")
         if not args.full and len(records) == args.lines:
-            print(f"Tip: Use --full to see all logs, or increase --lines to see more")
+            print("Tip: Use --full to see all logs, or increase --lines to see more")
 
     @with_workspace_logging("migrate")
     def migrate(self, args: argparse.Namespace) -> None:
@@ -1519,10 +1518,10 @@ class GlobalCommands:
     def orch_status(self, args: argparse.Namespace) -> None:
         """Show orchestrator status."""
         from .utils.orchestrator import (
+            format_uptime,
+            get_orchestrator_uptime,
             is_orchestrator_running,
             read_switch_status,
-            get_orchestrator_uptime,
-            format_uptime
         )
 
         metadata_dir = self.workspace.path / ".metadata"
@@ -1578,7 +1577,7 @@ class GlobalCommands:
             try:
                 port = control_port_file.read_text().strip()
                 print(f"Control Port:   {port}")
-            except IOError:
+            except OSError:
                 pass
 
         # Check switch status
@@ -1605,6 +1604,7 @@ class GlobalCommands:
     def orch_restart(self, args: argparse.Namespace) -> None:
         """Request orchestrator to restart ComfyUI."""
         import time
+
         from .utils.orchestrator import is_orchestrator_running, safe_write_command
 
         metadata_dir = self.workspace.path / ".metadata"
@@ -1643,11 +1643,12 @@ class GlobalCommands:
     def orch_kill(self, args: argparse.Namespace) -> None:
         """Shutdown orchestrator."""
         import time
+
         from .utils.orchestrator import (
             is_orchestrator_running,
-            safe_write_command,
             kill_orchestrator_process,
-            read_switch_status
+            read_switch_status,
+            safe_write_command,
         )
 
         metadata_dir = self.workspace.path / ".metadata"
@@ -1701,9 +1702,9 @@ class GlobalCommands:
     def orch_clean(self, args: argparse.Namespace) -> None:
         """Clean orchestrator state files."""
         from .utils.orchestrator import (
+            cleanup_orchestrator_state,
             is_orchestrator_running,
             kill_orchestrator_process,
-            cleanup_orchestrator_state
         )
 
         metadata_dir = self.workspace.path / ".metadata"
@@ -1742,7 +1743,7 @@ class GlobalCommands:
             print("\nNote: workspace_config.json will be preserved")
 
             if args.kill:
-                print(f"\n⚠️  --kill flag: Will also terminate orchestrator process")
+                print("\n⚠️  --kill flag: Will also terminate orchestrator process")
 
             response = input("\nContinue? [y/N]: ").strip().lower()
             if response not in ['y', 'yes']:
@@ -1784,6 +1785,7 @@ class GlobalCommands:
     def orch_logs(self, args: argparse.Namespace) -> None:
         """Show orchestrator logs."""
         import subprocess
+
         from .utils.orchestrator import tail_log_file
 
         metadata_dir = self.workspace.path / ".metadata"
@@ -1808,3 +1810,4 @@ class GlobalCommands:
                 print("".join(lines))
             else:
                 print("(empty log file)")
+