Shell Integration

class Generic:
    """
    Base shell class with common functionality.
    
    All shell-specific classes inherit from this base class
    and override methods as needed for shell-specific behavior.
    """
    
    def get_aliases(self):
        """
        Returns dictionary of shell aliases.
        
        Returns:
        dict: Mapping of alias names to their expansions
        
        Default implementation returns empty dict.
        Shell-specific implementations parse alias files/commands.
        """
    
    def from_shell(self, command_script):
        """
        Prepares command before running in app.
        
        Parameters:
        - command_script (str): Original command string
        
        Returns:
        str: Command with aliases expanded
        
        Expands shell aliases to full commands for proper analysis.
        """
    
    def to_shell(self, command_script):
        """
        Prepares command for running in shell.
        
        Parameters:
        - command_script (str): Command to prepare for shell execution
        
        Returns:
        str: Shell-ready command string
        
        Default implementation returns command unchanged.
        Shell-specific implementations may add escaping or formatting.
        """
    
    def app_alias(self, fuck):
        """
        Returns shell alias configuration for thefuck integration.
        
        Parameters:
        - fuck (str): Alias name to use (typically 'fuck')
        
        Returns:
        str: Shell-specific alias command
        
        Generates the alias command that users add to their shell config.
        """
    
    def put_to_history(self, command_script):
        """
        Adds command script to shell history.
        
        Parameters:
        - command_script (str): Command to add to history
        
        Returns:
        None
        
        Appends the corrected command to the shell's history file
        so it appears in command history for future use.
        """

def from_shell(command):
    """
    Prepares command using current shell's from_shell method.
    
    Parameters:
    - command (str): Command string to prepare
    
    Returns:
    str: Command prepared by current shell implementation
    
    Automatically detects current shell and delegates to appropriate handler.
    """

def to_shell(command):
    """
    Prepares command using current shell's to_shell method.
    
    Parameters:
    - command (str): Command string to prepare for shell
    
    Returns:
    str: Shell-ready command string
    
    Automatically detects current shell and delegates to appropriate handler.
    """

def thefuck_alias():
    """
    Returns default alias name for thefuck.
    
    Returns:
    str: Default alias name (typically 'fuck')
    
    Can be overridden by TF_ALIAS environment variable.
    """

def app_alias(alias):
    """
    Returns alias command for current shell.
    
    Parameters:
    - alias (str): Desired alias name
    
    Returns:
    str: Shell-specific alias configuration command
    
    Generates alias command for user's shell configuration file.
    """

def put_to_history(command):
    """
    Adds command to current shell's history.
    
    Parameters:
    - command (str): Command to add to history
    
    Returns:
    None
    
    Uses current shell's history mechanism to store the command.
    """

class Bash(Generic):
    """
    Bash shell implementation with bash-specific features.
    
    Supports:
    - Bash history file (~/.bash_history)
    - Bash alias parsing
    - Bash-specific alias format
    """
    
    def app_alias(self, fuck):
        """
        Returns bash-specific alias command.
        
        Example output:
        alias fuck='TF_ALIAS=fuck eval $(thefuck $(fc -ln -1))'
        """

class Zsh(Generic):
    """
    Zsh shell implementation with zsh-specific features.
    
    Supports:
    - Zsh history file (~/.zsh_history)
    - Zsh alias parsing
    - Zsh-specific history format
    """

class Fish(Generic):
    """
    Fish shell implementation with fish-specific features.
    
    Supports:
    - Fish history file (~/.local/share/fish/fish_history)
    - Fish alias (abbreviation) parsing
    - Fish-specific syntax
    """
    
    def app_alias(self, fuck):
        """
        Returns fish-specific alias command.
        
        Example output:
        function fuck; eval (thefuck (history | head -1)); end
        """

class Powershell(Generic):
    """
    PowerShell implementation for Windows environments.
    
    Supports:
    - PowerShell history
    - PowerShell alias format
    - Windows-specific paths and commands
    """

from thefuck.shells import from_shell, to_shell, put_to_history

# Process command through current shell
original_command = "ll -la"
expanded_command = from_shell(original_command)  # Expands 'll' alias to 'ls -la'
print(f"Expanded: {expanded_command}")

# Prepare corrected command for shell execution
corrected = "ls -la"
shell_ready = to_shell(corrected)
print(f"Shell ready: {shell_ready}")

# Add to shell history
put_to_history("ls -la")

from thefuck.shells import app_alias, thefuck_alias

# Get default alias name
default_alias = thefuck_alias()  # Usually 'fuck'
print(f"Default alias: {default_alias}")

# Generate alias command for current shell
alias_command = app_alias('f')  # Use 'f' instead of 'fuck'
print(f"Add to shell config: {alias_command}")

# Examples of output for different shells:
# Bash: alias f='TF_ALIAS=f eval $(thefuck $(fc -ln -1))'
# Fish: function f; eval (thefuck (history | head -1)); end
# Zsh: alias f='TF_ALIAS=f eval $(thefuck $(fc -ln -1))'

from thefuck.shells import Generic, Bash, Fish

# Create shell-specific instances
bash_shell = Bash()
fish_shell = Fish()

# Use bash-specific functionality
bash_aliases = bash_shell.get_aliases()
bash_alias_cmd = bash_shell.app_alias('fuck')
print(f"Bash alias: {bash_alias_cmd}")

# Use fish-specific functionality
fish_alias_cmd = fish_shell.app_alias('fuck')
print(f"Fish alias: {fish_alias_cmd}")

# Process command through specific shell
command = "ll"
bash_expanded = bash_shell.from_shell(command)
fish_expanded = fish_shell.from_shell(command)

from thefuck.shells import put_to_history

# Add corrected commands to history
corrections = [
    "git push origin main",
    "sudo apt update",
    "ls -la /home/user"
]

for correction in corrections:
    put_to_history(correction)
    print(f"Added to history: {correction}")

import os
from thefuck.shells import Generic, Bash, Zsh, Fish

def get_current_shell():
    """Detect current shell from environment."""
    shell_path = os.environ.get('SHELL', '')
    
    if 'bash' in shell_path:
        return Bash()
    elif 'zsh' in shell_path:
        return Zsh()
    elif 'fish' in shell_path:
        return Fish()
    else:
        return Generic()

# Use detected shell
current_shell = get_current_shell()
alias_cmd = current_shell.app_alias('f')
print(f"Shell-specific alias: {alias_cmd}")

# Example alias expansions:
# 'll' -> 'ls -la'
# 'gs' -> 'git status'
# 'la' -> 'ls -A'
# 'gp' -> 'git push'

expanded = from_shell('ll /home')  # Becomes 'ls -la /home'