comfygit 0.3.1__py3-none-any.whl

comfygit_cli/cli_utils.py

@@ -0,0 +1,32 @@
+"""Utility functions for ComfyGit CLI."""
+
+import sys
+from typing import TYPE_CHECKING
+
+from comfygit_core.factories.workspace_factory import WorkspaceFactory
+from comfygit_core.models.exceptions import CDWorkspaceNotFoundError
+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:
+        workspace = WorkspaceFactory.find()
+        # Initialize workspace logging
+        WorkspaceLogger.set_workspace_path(workspace.path)
+        return workspace
+    except CDWorkspaceNotFoundError:
+        print("✗ No workspace initialized. Run 'cg init' first.")
+        sys.exit(1)
+
+def get_workspace_optional() -> "Workspace | None":
+    """Get workspace if it exists."""
+    try:
+        workspace = WorkspaceFactory.find()
+        # Initialize workspace logging
+        WorkspaceLogger.set_workspace_path(workspace.path)
+        return workspace
+    except CDWorkspaceNotFoundError:
+        return None

comfygit_cli/completers.py

@@ -0,0 +1,239 @@
+"""Custom argcomplete completers for ComfyGit CLI."""
+import argparse
+from typing import Any
+
+from argcomplete.io import warn
+
+from comfygit_core.core.environment import Environment
+from comfygit_core.core.workspace import Workspace
+from comfygit_core.factories.workspace_factory import WorkspaceFactory
+from comfygit_core.models.exceptions import CDWorkspaceNotFoundError
+
+
+# ============================================================================
+# Shared Utilities
+# ============================================================================
+
+def get_workspace_safe() -> Workspace | None:
+    """Get workspace or return None if not initialized."""
+    try:
+        return WorkspaceFactory.find()
+    except CDWorkspaceNotFoundError:
+        return None
+    except Exception as e:
+        warn(f"Error loading workspace: {e}")
+        return None
+
+
+def get_env_from_args(parsed_args: argparse.Namespace, workspace: Workspace) -> Environment | None:
+    """Get environment from -e flag or active environment.
+
+    Args:
+        parsed_args: Parsed arguments from argparse
+        workspace: Workspace instance
+
+    Returns:
+        Environment instance or None
+    """
+    try:
+        # Check for -e/--env flag
+        env_name = getattr(parsed_args, 'target_env', None)
+        if env_name:
+            return workspace.get_environment(env_name, auto_sync=False)
+
+        # Fall back to active environment
+        env = workspace.get_active_environment()
+        if not env:
+            warn("No active environment. Use -e or run 'cg use <env>'")
+        return env
+    except Exception as e:
+        warn(f"Error loading environment: {e}")
+        return None
+
+
+def filter_by_prefix(items: list[str], prefix: str) -> list[str]:
+    """Filter items that start with the given prefix."""
+    return [item for item in items if item.startswith(prefix)]
+
+
+# ============================================================================
+# Completers
+# ============================================================================
+
+def environment_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete environment names from workspace.
+
+    Used for:
+    - comfygit use <TAB>
+    - comfygit delete <TAB>
+    - comfygit -e <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    try:
+        envs = workspace.list_environments()
+        names = [env.name for env in envs]
+        return filter_by_prefix(names, prefix)
+    except Exception as e:
+        warn(f"Error listing environments: {e}")
+        return []
+
+
+def workflow_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete workflow names, prioritizing unresolved workflows.
+
+    Smart ordering:
+    1. New/modified workflows (likely need resolution)
+    2. Synced workflows
+
+    Used for:
+    - comfygit workflow resolve <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    env = get_env_from_args(parsed_args, workspace)
+    if not env:
+        return []
+
+    try:
+        workflows = env.list_workflows()
+
+        # Build candidates with smart ordering
+        candidates = []
+
+        # Priority 1: Unresolved workflows (new/modified)
+        candidates.extend(workflows.new)
+        candidates.extend(workflows.modified)
+
+        # Priority 2: Synced workflows
+        candidates.extend(workflows.synced)
+
+        # Remove .json extension and filter by prefix
+        names = [name.replace('.json', '') for name in candidates]
+        return filter_by_prefix(names, prefix)
+
+    except Exception as e:
+        warn(f"Error listing workflows: {e}")
+        return []
+
+
+def installed_node_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete installed node names.
+
+    Used for:
+    - comfygit node remove <TAB>
+    - comfygit node update <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    env = get_env_from_args(parsed_args, workspace)
+    if not env:
+        return []
+
+    try:
+        nodes = env.list_nodes()
+        # Use registry_id if available, otherwise fall back to name
+        names = [node.registry_id or node.name for node in nodes]
+        return filter_by_prefix(names, prefix)
+    except Exception as e:
+        warn(f"Error listing nodes: {e}")
+        return []
+
+
+def branch_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete branch names from environment.
+
+    Returns only branch names for commands that accept branches.
+
+    Used for:
+    - cg switch <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    env = get_env_from_args(parsed_args, workspace)
+    if not env:
+        return []
+
+    try:
+        # Get branches (returns list of (name, is_current) tuples)
+        branches = env.list_branches()
+        names = [name for name, _ in branches]
+        return filter_by_prefix(names, prefix)
+
+    except Exception as e:
+        warn(f"Error loading branches: {e}")
+        return []
+
+
+def commit_hash_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete commit hashes from environment history.
+
+    Returns only short commit hashes for clean tab completion.
+    Users can run 'cg log' to see commit messages.
+
+    Used for:
+    - cg reset <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    env = get_env_from_args(parsed_args, workspace)
+    if not env:
+        return []
+
+    try:
+        # Get recent commits (50 should cover most use cases)
+        history = env.get_commit_history(limit=50)
+
+        # Return only hashes for clean completion
+        hashes = [commit['hash'] for commit in history]
+        return filter_by_prefix(hashes, prefix)
+
+    except Exception as e:
+        warn(f"Error loading commits: {e}")
+        return []
+
+
+def ref_completer(prefix: str, parsed_args: argparse.Namespace, **kwargs: Any) -> list[str]:
+    """Complete git refs (branches and commits) from environment.
+
+    Returns branches first (most common use case), then recent commit hashes.
+    This provides comprehensive completion for commands like checkout that
+    accept both branches and commits.
+
+    Used for:
+    - cg checkout <TAB>
+    """
+    workspace = get_workspace_safe()
+    if not workspace:
+        return []
+
+    env = get_env_from_args(parsed_args, workspace)
+    if not env:
+        return []
+
+    try:
+        candidates = []
+
+        # Priority 1: Branches (most common for checkout)
+        branches = env.list_branches()
+        candidates.extend([name for name, _ in branches])
+
+        # Priority 2: Recent commits
+        history = env.get_commit_history(limit=50)
+        candidates.extend([commit['hash'] for commit in history])
+
+        return filter_by_prefix(candidates, prefix)
+
+    except Exception as e:
+        warn(f"Error loading refs: {e}")
+        return []

comfygit_cli/completion_commands.py

@@ -0,0 +1,246 @@
+"""Commands for managing shell completion setup."""
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+class CompletionCommands:
+    """Handle shell completion installation and management."""
+
+    COMMANDS = ['comfygit', 'cg']
+    COMPLETION_COMMENT = "# ComfyGit tab completion"
+    ZSH_INIT_CHECK = 'if ! command -v compdef &> /dev/null; then'
+
+    @classmethod
+    def _completion_lines(cls):
+        """Generate completion lines for all command aliases."""
+        return [f'eval "$(register-python-argcomplete {cmd})"' for cmd in cls.COMMANDS]
+
+    @staticmethod
+    def _zsh_compinit_block():
+        """Generate zsh compinit initialization block."""
+        return [
+            "# Initialize zsh completion system if not already loaded",
+            "if ! command -v compdef &> /dev/null; then",
+            "    autoload -Uz compinit",
+            "    compinit",
+            "fi",
+        ]
+
+    @staticmethod
+    def _detect_shell():
+        """Detect the user's shell and return shell name and config file path."""
+        shell = os.environ.get('SHELL', '')
+
+        if 'bash' in shell:
+            config_file = Path.home() / '.bashrc'
+            return 'bash', config_file
+        elif 'zsh' in shell:
+            config_file = Path.home() / '.zshrc'
+            return 'zsh', config_file
+        else:
+            return None, None
+
+    @staticmethod
+    def _check_argcomplete_available():
+        """Check if register-python-argcomplete is available in PATH."""
+        return shutil.which('register-python-argcomplete') is not None
+
+    @staticmethod
+    def _install_argcomplete():
+        """Install argcomplete globally using uv tool."""
+        try:
+            print("📦 Installing argcomplete globally...")
+            result = subprocess.run(
+                ['uv', 'tool', 'install', 'argcomplete'],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"✗ Failed to install argcomplete: {e.stderr}")
+            return False
+        except FileNotFoundError:
+            print("✗ 'uv' command not found. Please install uv first.")
+            return False
+
+    @classmethod
+    def _is_completion_installed(cls, config_file):
+        """Check if completion is already installed in config file."""
+        if not config_file.exists():
+            return False
+
+        content = config_file.read_text()
+        return cls.COMPLETION_COMMENT in content and all(line in content for line in cls._completion_lines())
+
+    @classmethod
+    def _add_completion_to_config(cls, shell, config_file):
+        """Add completion lines to shell config file."""
+        # Ensure file exists
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        config_file.touch(exist_ok=True)
+
+        # Read current content
+        content = config_file.read_text()
+
+        # Add completion lines at the end
+        if content and not content.endswith('\n'):
+            content += '\n'
+
+        content += f'\n{cls.COMPLETION_COMMENT}\n'
+
+        # Add zsh compinit initialization if needed
+        if shell == 'zsh':
+            for line in cls._zsh_compinit_block():
+                content += f'{line}\n'
+            content += '\n'
+
+        for line in cls._completion_lines():
+            content += f'{line}\n'
+
+        # Write back
+        config_file.write_text(content)
+
+    @classmethod
+    def _remove_completion_from_config(cls, config_file):
+        """Remove completion lines from shell config file."""
+        if not config_file.exists():
+            return False
+
+        lines = config_file.read_text().splitlines(keepends=True)
+        new_lines = []
+        in_block = False
+
+        for line in lines:
+            # Start of completion block
+            if cls.COMPLETION_COMMENT in line:
+                in_block = True
+                continue
+
+            # Inside block - skip all lines until we find a non-completion line
+            if in_block:
+                # Check if this is part of our block (init, completion, or empty lines)
+                stripped = line.strip()
+                is_our_line = (
+                    not stripped  # empty line
+                    or '# Initialize zsh completion system' in line  # our specific comment
+                    or cls.ZSH_INIT_CHECK in line  # zsh init check
+                    or 'autoload -Uz compinit' in line
+                    or stripped == 'compinit'
+                    or stripped == 'fi'
+                    or any(comp in line for comp in cls._completion_lines())
+                )
+                if is_our_line:
+                    continue
+                else:
+                    # Non-completion line found, exit block
+                    in_block = False
+
+            new_lines.append(line)
+
+        config_file.write_text(''.join(new_lines))
+        return True
+
+    def install(self, args):
+        """Install shell completion for the current user."""
+        shell, config_file = self._detect_shell()
+
+        if not shell:
+            print("✗ Could not detect shell (bash or zsh)")
+            print("  Your SHELL environment variable is:", os.environ.get('SHELL', 'not set'))
+            print("\nManual setup:")
+            print("  Add these lines to your shell config file:")
+            for line in self._completion_lines():
+                print(f"  {line}")
+            sys.exit(1)
+
+        # Check if already installed
+        if self._is_completion_installed(config_file):
+            print(f"✓ Tab completion is already installed in {config_file}")
+            print(f"\nTo activate in current shell, run:")
+            print(f"  source {config_file}")
+            return
+
+        # Check if argcomplete is available
+        if not self._check_argcomplete_available():
+            print("⚠️  argcomplete not found in PATH")
+            print("   Installing argcomplete as a uv tool...")
+            if not self._install_argcomplete():
+                print("\n✗ Could not install argcomplete automatically")
+                print("\nManual installation:")
+                print("  uv tool install argcomplete")
+                print("\nThen run:")
+                print("  cg completion install")
+                sys.exit(1)
+            print("✓ argcomplete installed")
+
+        # Install completion
+        try:
+            self._add_completion_to_config(shell, config_file)
+            print(f"\n✓ Tab completion installed successfully!")
+            print(f"\nAdded to: {config_file}")
+            print(f"\nTo activate in current shell, run:")
+            print(f"  source {config_file}")
+            print(f"\nOr start a new terminal session.")
+            print(f"\nTry it out:")
+            print(f"  cg stat<TAB>")
+            print(f"  cg use <TAB>")
+            print(f"  cg workflow resolve <TAB>")
+        except Exception as e:
+            print(f"✗ Failed to install completion: {e}")
+            sys.exit(1)
+
+    def uninstall(self, args):
+        """Remove shell completion from config."""
+        shell, config_file = self._detect_shell()
+
+        if not shell:
+            print("✗ Could not detect shell (bash or zsh)")
+            sys.exit(1)
+
+        if not self._is_completion_installed(config_file):
+            print(f"✓ Tab completion is not installed")
+            return
+
+        try:
+            self._remove_completion_from_config(config_file)
+            print(f"✓ Tab completion uninstalled")
+            print(f"\nRemoved from: {config_file}")
+            print(f"\nRestart your shell for changes to take effect.")
+        except Exception as e:
+            print(f"✗ Failed to uninstall completion: {e}")
+            sys.exit(1)
+
+    def status(self, args):
+        """Show completion installation status."""
+        shell, config_file = self._detect_shell()
+
+        print("Shell Completion Status")
+        print("=" * 40)
+
+        if not shell:
+            print("Shell: Unknown")
+            print("Status: ✗ Not supported")
+            print(f"\nYour SHELL: {os.environ.get('SHELL', 'not set')}")
+            print("Supported shells: bash, zsh")
+            return
+
+        print(f"Shell: {shell}")
+        print(f"Config: {config_file}")
+
+        # Check argcomplete availability
+        argcomplete_available = self._check_argcomplete_available()
+        print(f"Argcomplete: {'✓ Available' if argcomplete_available else '✗ Not found'}")
+
+        if self._is_completion_installed(config_file):
+            print("Status: ✓ Installed")
+            if not argcomplete_available:
+                print("\n⚠️  Warning: Completion is configured but argcomplete is not in PATH")
+                print("   Install with: uv tool install argcomplete")
+            print(f"\nTo uninstall: cg completion uninstall")
+        else:
+            print("Status: ✗ Not installed")
+            print(f"\nTo install: cg completion install")