thefuck-leeguoo 3.41__py2.py3-none-any.whl

thefuck/entrypoints/not_configured.py

@@ -0,0 +1,201 @@
+# Initialize output before importing any module, that can use colorama.
+from ..system import init_output
+
+init_output()
+
+import getpass  # noqa: E402
+import os  # noqa: E402
+import json  # noqa: E402
+import sys  # noqa: E402
+import subprocess  # noqa: E402
+from tempfile import gettempdir  # noqa: E402
+import time  # noqa: E402
+import six  # noqa: E402
+from psutil import Process  # noqa: E402
+from .. import logs, const, types  # noqa: E402
+from ..shells import shell  # noqa: E402
+from ..conf import settings  # noqa: E402
+from ..system import Path  # noqa: E402
+from ..corrector import get_corrected_commands  # noqa: E402
+from ..exceptions import EmptyCommand  # noqa: E402
+
+
+def _get_shell_pid():
+    """Returns parent process pid."""
+    proc = Process(os.getpid())
+
+    try:
+        return proc.parent().pid
+    except TypeError:
+        return proc.parent.pid
+
+
+def _get_not_configured_usage_tracker_path():
+    """Returns path of special file where we store latest shell pid."""
+    return Path(gettempdir()).joinpath(u'thefuck.last_not_configured_run_{}'.format(
+        getpass.getuser(),
+    ))
+
+
+def _record_first_run():
+    """Records shell pid to tracker file."""
+    info = {'pid': _get_shell_pid(),
+            'time': time.time()}
+
+    mode = 'wb' if six.PY2 else 'w'
+    with _get_not_configured_usage_tracker_path().open(mode) as tracker:
+        json.dump(info, tracker)
+
+
+def _get_previous_command():
+    history = shell.get_history()
+
+    if history:
+        return history[-1]
+    else:
+        return None
+
+
+def _is_second_run():
+    """Returns `True` when we know that `fuck` called second time."""
+    tracker_path = _get_not_configured_usage_tracker_path()
+    if not tracker_path.exists():
+        return False
+
+    current_pid = _get_shell_pid()
+    with tracker_path.open('r') as tracker:
+        try:
+            info = json.load(tracker)
+        except ValueError:
+            return False
+
+    if not (isinstance(info, dict) and info.get('pid') == current_pid):
+        return False
+
+    return (_get_previous_command() == 'fuck' or
+            time.time() - info.get('time', 0) < const.CONFIGURATION_TIMEOUT)
+
+
+def _is_already_configured(configuration_details):
+    """Returns `True` when alias already in shell config."""
+    path = Path(configuration_details.path).expanduser()
+    with path.open('r') as shell_config:
+        return configuration_details.content in shell_config.read()
+
+
+def _configure(configuration_details):
+    """Adds alias to shell config."""
+    path = Path(configuration_details.path).expanduser()
+    with path.open('a') as shell_config:
+        shell_config.write(u'\n')
+        shell_config.write(configuration_details.content)
+        shell_config.write(u'\n')
+
+
+def _get_last_command_from_history():
+    """Gets the last command from shell history, excluding 'fuck' itself."""
+    history = shell.get_history()
+    if not history:
+        return None
+    
+    # Find the last command that isn't 'fuck'
+    for cmd in reversed(history):
+        cmd_stripped = cmd.strip()
+        if cmd_stripped and cmd_stripped != 'fuck' and not cmd_stripped.startswith('fuck '):
+            return cmd_stripped
+    return None
+
+
+def _run_and_fix_command(command_script):
+    """Runs the command and tries to fix it."""
+    try:
+        command = types.Command.from_raw_script([command_script])
+    except EmptyCommand:
+        logs.debug('Empty command, nothing to do')
+        return False
+
+    corrected_commands = get_corrected_commands(command)
+    
+    # Get the first corrected command
+    selected_command = None
+    for cmd in corrected_commands:
+        selected_command = cmd
+        break
+    
+    if selected_command:
+        # Print the fixed command
+        fixed_script = selected_command.script
+        print(u'\nSuggested fix: {}'.format(fixed_script))
+        
+        # Ask for confirmation
+        try:
+            if six.PY2:
+                response = raw_input('Run this command? [Y/n] ')  # noqa: F821
+            else:
+                response = input('Run this command? [Y/n] ')
+            if response.lower() in ('', 'y', 'yes'):
+                subprocess.call(fixed_script, shell=True)
+                return True
+        except (KeyboardInterrupt, EOFError):
+            print('')
+        return True
+    return False
+
+
+def _auto_configure_shell():
+    """Automatically configures the shell if possible."""
+    configuration_details = shell.how_to_configure()
+    if (configuration_details and 
+        configuration_details.can_configure_automatically and
+        not _is_already_configured(configuration_details)):
+        _configure(configuration_details)
+        return True
+    return False
+
+
+def main():
+    """Main entry point for 'fuck' command.
+    
+    This now works in two modes:
+    1. If shell alias is configured: works through the alias (fast mode)
+    2. If not configured: reads history, reruns command, and fixes it
+    
+    Also auto-configures the shell for better experience next time.
+    """
+    settings.init()
+    
+    # Check if we're being called through the alias (TF_COMMAND is set)
+    if os.environ.get('TF_COMMAND'):
+        # We're being called through alias, delegate to fix_command
+        from .fix_command import fix_command
+        from ..argument_parser import Parser
+        parser = Parser()
+        known_args = parser.parse(sys.argv)
+        fix_command(known_args)
+        return
+    
+    # Not called through alias - work directly with history
+    last_command = _get_last_command_from_history()
+    
+    if not last_command:
+        logs.how_to_configure_alias(shell.how_to_configure())
+        return
+    
+    # Try to fix the command
+    print(u'Last command: {}'.format(last_command))
+    print(u'Re-running to get output...')
+    
+    if _run_and_fix_command(last_command):
+        # Auto-configure shell for next time
+        if _auto_configure_shell():
+            print(u'\nShell configured! Restart your terminal for faster experience.')
+    else:
+        print(u'No fix found for this command.')
+        
+        # Show configuration help
+        configuration_details = shell.how_to_configure()
+        if configuration_details:
+            if _auto_configure_shell():
+                print(u'\nShell auto-configured! Restart your terminal.')
+            else:
+                logs.how_to_configure_alias(configuration_details)

thefuck/entrypoints/setup.py

@@ -0,0 +1,227 @@
+import os
+import sys
+import shutil
+from getpass import getpass
+import six
+from ..conf import settings
+from ..logs import warn
+from ..shells import shell
+from ..system import Path
+
+# Use builtin input to avoid colorama wrapper issues
+if six.PY2:
+    _input = raw_input  # noqa: F821
+else:
+    import builtins
+    _input = builtins.input
+
+
+def _ask(prompt, default=None, secret=False):
+    if default:
+        prompt_text = '{} [{}]: '.format(prompt, default)
+    else:
+        prompt_text = '{}: '.format(prompt)
+    if secret:
+        value = getpass(prompt_text)
+    else:
+        value = _input(prompt_text)
+    value = value.strip()
+    if not value:
+        return default
+    return value
+
+
+def _ask_bool(prompt, default):
+    suffix = 'Y/n' if default else 'y/N'
+    while True:
+        value = _input('{} ({})? '.format(prompt, suffix)).strip().lower()
+        if not value:
+            return default
+        if value in ('y', 'yes'):
+            return True
+        if value in ('n', 'no'):
+            return False
+        sys.stderr.write('Please enter y or n.\n')
+
+
+def _ask_int(prompt, default):
+    value = _ask(prompt, six.text_type(default))
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        warn('Invalid number, using default {}'.format(default))
+        return default
+
+
+def _normalize_mode(mode, default):
+    if mode in ('prefer', 'fallback'):
+        return mode
+    warn("Unknown AI mode '{}', using {}".format(mode, default))
+    return default
+
+
+def _quote(value):
+    return shell.quote(six.text_type(value))
+
+
+def _is_fish():
+    return shell.__class__.__name__.lower() == 'fish'
+
+
+def _build_env_lines(values, fish):
+    lines = []
+    for key, value in values.items():
+        if value is None:
+            continue
+        if fish:
+            lines.append('set -gx {} {}'.format(key, _quote(value)))
+        else:
+            lines.append('export {}={}'.format(key, _quote(value)))
+    return lines
+
+
+def _shell_path(path, xdg_config_home, use_xdg):
+    if use_xdg and xdg_config_home:
+        xdg_root = Path(xdg_config_home, 'thefuck').expanduser()
+        if path == xdg_root:
+            return '$XDG_CONFIG_HOME/thefuck'
+        if str(path).startswith(str(xdg_root) + os.sep):
+            suffix = str(path)[len(str(xdg_root)) + 1:]
+            return '$XDG_CONFIG_HOME/thefuck/{}'.format(suffix)
+    home = Path('~').expanduser()
+    if str(path).startswith(str(home) + os.sep):
+        suffix = str(path)[len(str(home)) + 1:]
+        return '$HOME/{}'.format(suffix)
+    return str(path)
+
+
+def _write_env_file(path, lines):
+    with path.open(mode='w') as env_file:
+        env_file.write('# thefuck env\n')
+        for line in lines:
+            env_file.write(line + '\n')
+
+
+def _build_path_lines(bin_path, fish):
+    if fish:
+        return ['set -gx PATH {} $PATH'.format(bin_path)]
+    return ['export PATH="{}:$PATH"'.format(bin_path)]
+
+
+def _write_wrapper(path):
+    content = (
+        '#!/bin/sh\n'
+        'if [ -n "$THEFUCK_PROJECT_PATH" ]; then\n'
+        '  exec uv run --project "$THEFUCK_PROJECT_PATH" thefuck "$@"\n'
+        'fi\n'
+        'if command -v uvx >/dev/null 2>&1; then\n'
+        '  exec uvx thefuck "$@"\n'
+        'fi\n'
+        'exec uv run thefuck "$@"\n'
+    )
+    with path.open(mode='w') as script_file:
+        script_file.write(content)
+    os.chmod(str(path), 0o755)
+
+
+def setup():
+    print('Setup:')
+    print('Press enter to keep the default value shown in brackets.')
+
+    xdg_config_home_env = os.environ.get('XDG_CONFIG_HOME')
+    xdg_config_home = xdg_config_home_env or '~/.config'
+    use_xdg = xdg_config_home_env is not None
+    config_root = Path(xdg_config_home, 'thefuck').expanduser()
+    legacy_root = Path('~/.thefuck').expanduser()
+    if legacy_root.is_dir() and legacy_root != config_root:
+        if _ask_bool(
+                'Legacy config found at {}. Migrate to {}'
+                .format(legacy_root, config_root),
+                True):
+            try:
+                if not config_root.parent.is_dir():
+                    config_root.parent.mkdir(parents=True)
+                shutil.move(str(legacy_root), str(config_root))
+            except OSError as exc:
+                warn('Failed to migrate config: {}'.format(exc))
+                config_root = legacy_root
+        else:
+            config_root = legacy_root
+    bin_dir = config_root.joinpath('bin')
+    fish = _is_fish()
+    env_path = config_root.joinpath('env.fish' if fish else 'env.sh')
+    env_path_shell = _shell_path(env_path, xdg_config_home, use_xdg)
+    bin_path_shell = _shell_path(bin_dir, xdg_config_home, use_xdg)
+
+    if not config_root.is_dir():
+        config_root.mkdir(parents=True)
+    if not bin_dir.is_dir():
+        bin_dir.mkdir(parents=True)
+
+    settings.init()
+    defaults = {
+        'ai_enabled': settings.ai_enabled,
+        'ai_url': settings.ai_url,
+        'ai_token': settings.ai_token,
+        'ai_model': settings.ai_model,
+        'ai_timeout': settings.ai_timeout,
+        'ai_reasoning_effort': settings.ai_reasoning_effort,
+        'ai_stream': settings.ai_stream,
+        'ai_mode': settings.ai_mode,
+        'ai_stream_output': settings.ai_stream_output
+    }
+
+    ai_enabled = _ask_bool('Enable AI', defaults['ai_enabled'])
+    values = {
+        'THEFUCK_AI_ENABLED': 'true' if ai_enabled else 'false'
+    }
+
+    if ai_enabled:
+        ai_url = _ask('AI URL', defaults['ai_url'])
+        ai_token = _ask('AI token', defaults['ai_token'], secret=False)
+        ai_model = _ask('AI model', defaults['ai_model'])
+        ai_timeout = _ask_int('Timeout seconds', defaults['ai_timeout'])
+        ai_reasoning_effort = _ask(
+            'Reasoning effort (low/medium/high)',
+            defaults['ai_reasoning_effort'])
+        ai_stream = _ask_bool('Use SSE stream', defaults['ai_stream'])
+        ai_stream_output = _ask_bool(
+            'Stream output while waiting', defaults['ai_stream_output'])
+        ai_mode = _normalize_mode(
+            _ask('AI mode (prefer/fallback)', defaults['ai_mode']),
+            defaults['ai_mode'])
+
+        values.update({
+            'THEFUCK_AI_URL': ai_url,
+            'THEFUCK_AI_TOKEN': ai_token,
+            'THEFUCK_AI_MODEL': ai_model,
+            'THEFUCK_AI_TIMEOUT': ai_timeout,
+            'THEFUCK_AI_REASONING_EFFORT': ai_reasoning_effort,
+            'THEFUCK_AI_STREAM': 'true' if ai_stream else 'false',
+            'THEFUCK_AI_MODE': ai_mode,
+            'THEFUCK_AI_STREAM_OUTPUT': 'true' if ai_stream_output else 'false'
+        })
+
+    env_lines = _build_path_lines(bin_path_shell, fish)
+    env_lines.extend(_build_env_lines(values, fish))
+    _write_env_file(env_path, env_lines)
+    _write_wrapper(bin_dir.joinpath('thefuck'))
+
+    print('\nWrote env file:', env_path)
+    print('Wrote wrapper:', bin_dir.joinpath('thefuck'))
+    print('\nAdd to your shell config:')
+    print('source {}'.format(env_path_shell))
+    print('\nOptional for local development:')
+    print('set THEFUCK_PROJECT_PATH to use a local checkout with uv run')
+
+    config = shell.how_to_configure()
+    if config and _ask_bool(
+            'Append setup to {}'.format(config.path), False):
+        path = os.path.expanduser(config.path)
+        try:
+            with open(path, 'a') as config_file:
+                config_file.write('\n# thefuck config\n')
+                config_file.write('source {}\n'.format(env_path_shell))
+            print('Done. Run: {}'.format(config.reload))
+        except OSError as exc:
+            warn('Failed to write {}: {}'.format(path, exc))

thefuck/entrypoints/shell_logger.py

@@ -0,0 +1,79 @@
+import array
+import fcntl
+from functools import partial
+import mmap
+import os
+import pty
+import signal
+import sys
+import termios
+import tty
+from .. import logs, const
+
+
+def _read(f, fd):
+    data = os.read(fd, 1024)
+    try:
+        f.write(data)
+    except ValueError:
+        position = const.LOG_SIZE_IN_BYTES - const.LOG_SIZE_TO_CLEAN
+        f.move(0, const.LOG_SIZE_TO_CLEAN, position)
+        f.seek(position)
+        f.write(b'\x00' * const.LOG_SIZE_TO_CLEAN)
+        f.seek(position)
+    return data
+
+
+def _set_pty_size(master_fd):
+    buf = array.array('h', [0, 0, 0, 0])
+    fcntl.ioctl(pty.STDOUT_FILENO, termios.TIOCGWINSZ, buf, True)
+    fcntl.ioctl(master_fd, termios.TIOCSWINSZ, buf)
+
+
+def _spawn(shell, master_read):
+    """Create a spawned process.
+
+    Modified version of pty.spawn with terminal size support.
+
+    """
+    pid, master_fd = pty.fork()
+
+    if pid == pty.CHILD:
+        os.execlp(shell, shell)
+
+    try:
+        mode = tty.tcgetattr(pty.STDIN_FILENO)
+        tty.setraw(pty.STDIN_FILENO)
+        restore = True
+    except tty.error:    # This is the same as termios.error
+        restore = False
+
+    _set_pty_size(master_fd)
+    signal.signal(signal.SIGWINCH, lambda *_: _set_pty_size(master_fd))
+
+    try:
+        pty._copy(master_fd, master_read, pty._read)
+    except OSError:
+        if restore:
+            tty.tcsetattr(pty.STDIN_FILENO, tty.TCSAFLUSH, mode)
+
+    os.close(master_fd)
+    return os.waitpid(pid, 0)[1]
+
+
+def shell_logger(output):
+    """Logs shell output to the `output`.
+
+    Works like unix script command with `-f` flag.
+
+    """
+    if not os.environ.get('SHELL'):
+        logs.warn("Shell logger doesn't support your platform.")
+        sys.exit(1)
+
+    fd = os.open(output, os.O_CREAT | os.O_TRUNC | os.O_RDWR)
+    os.write(fd, b'\x00' * const.LOG_SIZE_IN_BYTES)
+    buffer = mmap.mmap(fd, const.LOG_SIZE_IN_BYTES, mmap.MAP_SHARED, mmap.PROT_WRITE)
+    return_code = _spawn(os.environ['SHELL'], partial(_read, buffer))
+
+    sys.exit(return_code)

thefuck/exceptions.py

@@ -0,0 +1,10 @@
+class EmptyCommand(Exception):
+    """Raised when empty command passed to `thefuck`."""
+
+
+class NoRuleMatched(Exception):
+    """Raised when no rule matched for some command."""
+
+
+class ScriptNotInLog(Exception):
+    """Script not found in log."""