sendstash.py

#!/usr/bin/env python3
import os
import sys
import yaml
import subprocess
import argparse
import tempfile
import re
import platform
import shutil
import glob as globmod
from datetime import datetime, timedelta


class SendStash:
    # ANSI color codes (auto-disabled when not a TTY)
    _COLORS = {
        'reset': '\033[0m',
        'bold': '\033[1m',
        'dim': '\033[2m',
        'red': '\033[31m',
        'green': '\033[32m',
        'yellow': '\033[33m',
        'blue': '\033[34m',
        'cyan': '\033[36m',
        'gray': '\033[90m',
    }

    def _c(self, color, text):
        """Colorize text if stdout is a TTY."""
        if not hasattr(self, '_use_color'):
            self._use_color = sys.stdout.isatty()
        if self._use_color and color in self._COLORS:
            return f"{self._COLORS[color]}{text}{self._COLORS['reset']}"
        return str(text)

    def __init__(self, config_path=None):
        self.config_path = self._find_config_file(config_path)
        if not self.config_path:
            print(f"{self._c('red', '[err]')} Could not find config.yaml")
            print(f"     -> Place it in one of the documented locations")
            sys.exit(1)

        print(f"{self._c('blue', '[info]')} Config: {self.config_path}")
        self.config = self._load_config(self.config_path)
        self.project_path = None

    def _find_config_file(self, specified_path):
        """Finds the config file in a prioritized list of locations."""
        if specified_path and os.path.exists(specified_path):
            return specified_path

        # Path specified by environment variable
        env_path = os.getenv('SENDSTASH_CONFIG_PATH')
        if env_path and os.path.exists(env_path):
            return env_path

        # User-specific config directory
        user_config_path = os.path.expanduser("~/.config/sendstash/config.yaml")
        if os.path.exists(user_config_path):
            return user_config_path

        # In an adjacent directory: ../sendstash-config/config.yaml
        script_dir = os.path.dirname(os.path.realpath(__file__))
        adjacent_config_path = os.path.join(script_dir, '..', 'sendstash-config', 'config.yaml')
        if os.path.exists(adjacent_config_path):
            return os.path.normpath(adjacent_config_path)

        # In the same directory as the script
        script_config_path = os.path.join(script_dir, 'config.yaml')
        if os.path.exists(script_config_path):
            return script_config_path

        return None

    def _load_config(self, config_path):
        """Loads the configuration from a YAML file."""
        with open(config_path, 'r') as f:
            config = yaml.safe_load(f)

        # Resolve password from password_cmd if needed
        smb = config.get('smb', {})
        if 'password_cmd' in smb and 'password' not in smb:
            try:
                result = subprocess.run(
                    smb['password_cmd'], shell=True,
                    capture_output=True, text=True, check=True
                )
                smb['password'] = result.stdout.strip()
            except subprocess.CalledProcessError as e:
                print(f"{self._c('red', '[err]')} password_cmd failed: {e}")
                sys.exit(1)

        # Expand project paths
        root = os.path.expanduser(config.get('root', ''))
        if 'projects' in config:
            for name, project in config['projects'].items():
                project['path'] = os.path.expanduser(project['path'].format(root=root))

        return config

    def get_project_choices(self):
        """Returns a list of project names from the config."""
        return list(self.config.get('projects', {}).keys())

    def set_project(self, project_name):
        """Set the working directory to a configured project's path."""
        projects = self.config.get('projects', {})
        if project_name not in projects:
            print(f"{self._c('red', '[err]')} Project '{project_name}' not found")
            print(f"     -> Available: {', '.join(projects.keys())}")
            sys.exit(1)
        self.project_path = projects[project_name]['path']
        if not os.path.isdir(self.project_path):
            print(f"{self._c('red', '[err]')} Path does not exist: {self.project_path}")
            sys.exit(1)
        print(f"{self._c('blue', '[info]')} Project: {project_name} ({self.project_path})")

    def _run_command(self, command, cwd=None, interactive=False, capture=False, env=None):
        """Runs a command and streams its output."""
        if capture:
            result = subprocess.run(
                command, cwd=cwd, shell=isinstance(command, str),
                capture_output=True, text=True, env=env
            )
            return result
        elif interactive:
            process = subprocess.Popen(command, cwd=cwd, shell=isinstance(command, str), env=env)
            process.wait()
            return process.returncode
        else:
            process = subprocess.Popen(
                command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                universal_newlines=True, cwd=cwd, shell=isinstance(command, str), env=env
            )
            for line in process.stdout:
                print(line, end='')
            process.wait()
            return process.returncode

    def sync_config(self):
        """Syncs the configuration file itself based on 'config_sync' settings."""
        if 'config_sync' not in self.config:
            print(f"{self._c('yellow', '[warn]')} 'config_sync' section not defined in config.yaml")
            return

        sync_settings = self.config['config_sync']
        command = sync_settings.get('command')

        if not command:
            print(f"{self._c('red', '[err]')} 'config_sync' missing 'command' key")
            return

        config_dir = os.path.dirname(self.config_path)

        print(f"{self._c('blue', '[info]')} Syncing config: '{command}' in '{config_dir}'")
        return_code = self._run_command(command, cwd=config_dir)

        if return_code == 0:
            print(f"     -> Sync complete, reloading config")
            self.config = self._load_config(self.config_path)
        else:
            print(f"{self._c('red', '[err]')} Config sync failed (exit {return_code})")
            sys.exit(1)

    def open_folder(self):
        """Opens the sendstash script directory in the file explorer."""
        script_dir = os.path.dirname(os.path.realpath(__file__))

        print(f"{self._c('blue', '[info]')} Opening: {script_dir}")

        try:
            if sys.platform == "win32":
                subprocess.run(['explorer', script_dir], check=True)
            elif sys.platform == "darwin":
                subprocess.run(['open', script_dir], check=True)
            elif sys.platform == "linux":
                file_managers = ['xdg-open', 'nautilus', 'dolphin', 'thunar', 'nemo', 'pcmanfm']
                opened = False

                for fm in file_managers:
                    try:
                        subprocess.run([fm, script_dir], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                        opened = True
                        break
                    except (subprocess.CalledProcessError, FileNotFoundError):
                        continue

                if not opened:
                    print(f"{self._c('yellow', '[warn]')} No file manager found")
                    print(f"     -> {script_dir}")
                    return
            else:
                print(f"{self._c('yellow', '[warn]')} Unsupported platform: {sys.platform}")
                print(f"     -> {script_dir}")
                return

        except subprocess.CalledProcessError as e:
            print(f"{self._c('red', '[err]')} {e}")
            print(f"     -> {script_dir}")
        except Exception as e:
            print(f"{self._c('red', '[err]')} {e}")
            print(f"     -> {script_dir}")

    def _get_cwd(self):
        """Get the working directory — project path if set, otherwise current dir."""
        return self.project_path or os.getcwd()

    def _scan_repos_with_stashes(self):
        """Scan {root}/projects/*/ for git repos that have stashes.
        Returns [(dir_name, path, stash_count)] for repos WITH stashes."""
        root = os.path.expanduser(self.config.get('root', ''))
        projects_dir = os.path.join(root, 'projects')
        if not os.path.isdir(projects_dir):
            print(f"{self._c('yellow', '[warn]')} Projects dir not found: {projects_dir}")
            return []

        results = []
        for entry in sorted(os.listdir(projects_dir)):
            repo_path = os.path.join(projects_dir, entry)
            if not os.path.isdir(os.path.join(repo_path, '.git')):
                continue
            result = self._run_command('git stash list', cwd=repo_path, capture=True)
            if result.returncode != 0 or not result.stdout.strip():
                continue
            stash_count = len(result.stdout.strip().split('\n'))
            results.append((entry, repo_path, stash_count))

        return results

    def scan(self, path=None):
        """Recursively scan directories for git repos with stashes."""
        if path:
            scan_root = os.path.expanduser(path)
        else:
            scan_root = os.path.expanduser(self.config.get('root', ''))

        if not os.path.isdir(scan_root):
            print(f"{self._c('red', '[error]')} Directory not found: {scan_root}")
            return

        print(f"{self._c('blue', '[scan]')} Scanning {scan_root} for repos with stashes...")

        results = []
        for dirpath, dirnames, _ in os.walk(scan_root):
            if '.git' in dirnames:
                result = self._run_command('git stash list', cwd=dirpath, capture=True)
                if result.returncode == 0 and result.stdout.strip():
                    stash_count = len(result.stdout.strip().split('\n'))
                    name = os.path.basename(dirpath)
                    results.append((name, dirpath, stash_count))
                # Don't descend into .git
                dirnames.remove('.git')

        if not results:
            print(f"{self._c('yellow', '[info]')} No repos with stashes found.")
            return

        print(f"\n{self._c('green', '[found]')} {len(results)} repo(s) with stashes:\n")
        for name, repo_path, count in sorted(results, key=lambda x: x[0]):
            print(f"  {self._c('cyan', name):30s} ({count} stash{'es' if count != 1 else ''})  {repo_path}")

        self._ensure_projects_in_config(results)

    def _ensure_projects_in_config(self, repos):
        """Check scanned repos against config and prompt to add new ones."""
        configured = set(self.config.get('projects', {}).keys())
        new_repos = [(name, path) for name, path, _ in repos if name not in configured]

        if not new_repos:
            return

        print(f"\n{self._c('blue', '[info]')} {len(new_repos)} repo(s) not in config:")
        for name, path in new_repos:
            print(f"  - {name}")

        try:
            choice = input("\n[a]dd all / [s]elect individually / [n]one / [q]uit: ").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print()
            return

        if choice == 'q':
            print("Quitting.")
            sys.exit(0)

        to_add = []
        if choice == 'a':
            to_add = new_repos
        elif choice == 's':
            for name, path in new_repos:
                try:
                    yn = input(f"  Add '{name}'? [y/n]: ").strip().lower()
                except (EOFError, KeyboardInterrupt):
                    print()
                    break
                if yn == 'y':
                    to_add.append((name, path))
        else:
            return

        if not to_add:
            return

        # Read raw config, append new projects, write back
        root = self.config.get('root', '~/Dev')
        with open(self.config_path, 'r') as f:
            raw_config = yaml.safe_load(f)

        if 'projects' not in raw_config:
            raw_config['projects'] = {}

        for name, path in to_add:
            expanded_root = os.path.expanduser(root)
            rel_path = os.path.relpath(path, expanded_root)
            raw_config['projects'][name] = {'path': '{root}/' + rel_path}
            print(f"  {self._c('green', '[+]')} {name}")

        with open(self.config_path, 'w') as f:
            yaml.safe_dump(raw_config, f, sort_keys=False)

        # Reload config
        self.config = self._load_config(self.config_path)
        print(f"{self._c('blue', '[info]')} Config reloaded ({len(to_add)} added)")

    def _get_repo_name(self):
        """Derive repo name from current git repo's root directory name."""
        result = self._run_command('git rev-parse --show-toplevel', cwd=self._get_cwd(), capture=True)
        if result.returncode != 0:
            print(f"{self._c('red', '[err]')} Not inside a git repository")
            sys.exit(1)
        return os.path.basename(result.stdout.strip())

    def _get_branch_name(self):
        """Get the current branch name."""
        result = self._run_command('git rev-parse --abbrev-ref HEAD', cwd=self._get_cwd(), capture=True)
        if result.returncode != 0:
            print(f"{self._c('red', '[err]')} Could not determine branch")
            sys.exit(1)
        return result.stdout.strip()

    def _sanitize_name(self, name):
        """Sanitize a name for use in filenames (replace / with _)."""
        return re.sub(r'[/\\]', '_', name)

    def _sanitize_for_filename(self, text, max_len=40):
        """Sanitize arbitrary text for use in a filename component."""
        # Replace whitespace and unsafe chars with hyphens, collapse runs, strip edges
        sanitized = re.sub(r'[^\w.-]+', '-', text).strip('-')
        return sanitized[:max_len].rstrip('-')

    def _smb_cmd(self, subcmd):
        """Build and run an smbclient command with auth from config."""
        smb = self.config['smb']
        server = smb['server']
        username = smb['username']
        password = smb['password']

        cmd = ['smbclient', server, '-U', f'{username}%{password}', '-c', subcmd]
        return subprocess.run(cmd, capture_output=True, text=True)

    def _get_remote_dir(self):
        """Get the base remote directory from config."""
        return self.config['smb'].get('remote_dir', 'stash-sync')

    def _detect_backend(self):
        """Detect whether to use mount-based I/O or smbclient."""
        if hasattr(self, '_backend'):
            return self._backend, self._mount_root

        smb = self.config['smb']

        # 1. Explicit mount_path in config
        mount_path = smb.get('mount_path')
        if mount_path:
            mount_path = os.path.expanduser(mount_path)
            if os.path.exists(mount_path):
                self._backend = 'mount'
                self._mount_root = mount_path
                return self._backend, self._mount_root
            else:
                print(f"{self._c('yellow', '[warn]')} mount_path '{mount_path}' does not exist")

        server = smb.get('server', '')
        # Parse //server/share into components
        parts = server.replace('\\', '/').strip('/').split('/')
        if len(parts) < 2:
            self._backend = 'smbclient'
            self._mount_root = None
            return self._backend, self._mount_root

        host, share = parts[0], parts[1]
        system = platform.system()
        is_wsl = False

        if system == 'Linux':
            try:
                with open('/proc/version', 'r') as f:
                    proc_version = f.read()
                if 'microsoft' in proc_version.lower():
                    is_wsl = True
            except (OSError, IOError):
                pass

        # 2. Auto-detect existing mounts
        if system == 'Windows':
            unc_path = f'\\\\{host}\\{share}'
            if os.path.exists(unc_path):
                self._backend = 'mount'
                self._mount_root = unc_path
                return self._backend, self._mount_root
        elif is_wsl:
            mnt_path = f'/mnt/{host}/{share}'
            if os.path.exists(mnt_path):
                self._backend = 'mount'
                self._mount_root = mnt_path
                return self._backend, self._mount_root

        # 3. Attempt auto-mount on Windows/WSL
        if system == 'Windows' or is_wsl:
            mount_result = self._ensure_mount(host, share, is_wsl)
            self._backend = 'mount'
            self._mount_root = mount_result
            return self._backend, self._mount_root

        # 4. Native Linux — fall back to smbclient
        self._backend = 'smbclient'
        self._mount_root = None
        return self._backend, self._mount_root

    def _ensure_mount(self, host, share, is_wsl):
        """Attempt to auto-mount the SMB share on Windows/WSL. Exits on failure."""
        smb = self.config['smb']
        username = smb.get('username', '')
        password = smb.get('password', '')

        if is_wsl:
            unc = f'\\\\\\\\{host}\\\\{share}'
            cmd = [
                'powershell.exe', '-Command',
                f'net use {unc} /user:{username} {password}'
            ]
            mount_path = f'/mnt/{host}/{share}'
        else:
            # Native Windows
            unc = f'\\\\{host}\\{share}'
            cmd = ['net', 'use', unc, f'/user:{username}', password]
            mount_path = unc

        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            if result.returncode == 0 and os.path.exists(mount_path):
                print(f"{self._c('blue', '[info]')} Auto-mounted: {mount_path}")
                return mount_path
        except (OSError, FileNotFoundError):
            pass

        print(f"{self._c('red', '[err]')} Could not auto-mount SMB share")
        if is_wsl:
            print(f"     -> Try: powershell.exe -Command \"net use \\\\\\\\{host}\\\\{share} /user:{username} <password>\"")
            print(f"     -> Or: sudo mount -t cifs //{host}/{share} /mnt/{host}/{share} -o username={username},password=<password>")
        else:
            print(f"     -> Try: net use \\\\{host}\\{share} /user:{username} <password>")
        print(f"     -> Or set 'mount_path' in your config.yaml to the mount point")
        sys.exit(1)

    def _get_share_path(self, *parts):
        """Return the full local path to a file/dir on the mounted share."""
        return os.path.join(self._mount_root, self._get_remote_dir(), *parts)

    def _list_patches_raw(self, repo_name):
        """List patches on the share. Returns [(name, size, date), ...] sorted by name."""
        backend, _ = self._detect_backend()

        if backend == 'mount':
            share_dir = self._get_share_path(repo_name)
            if not os.path.isdir(share_dir):
                return []
            patch_files = globmod.glob(os.path.join(share_dir, '*.patch'))
            patches = []
            for path in patch_files:
                name = os.path.basename(path)
                stat = os.stat(path)
                size = str(stat.st_size)
                date = datetime.fromtimestamp(stat.st_mtime).strftime('%a %b %d %H:%M:%S %Y')
                patches.append((name, size, date))
            patches.sort(key=lambda x: x[0])
            return patches
        else:
            remote_dir = self._get_remote_dir()
            smb_subcmd = f"ls {remote_dir}\\{repo_name}\\*.patch"
            result = self._smb_cmd(smb_subcmd)
            if result.returncode != 0:
                return []
            return self._parse_ls_output(result.stdout)

    def _upload_patch(self, repo_name, local_patch, local_msg, filename, msg_filename):
        """Upload a patch and its message file to the share."""
        backend, _ = self._detect_backend()

        if backend == 'mount':
            dest_dir = self._get_share_path(repo_name)
            os.makedirs(dest_dir, exist_ok=True)
            shutil.copy2(local_patch, os.path.join(dest_dir, filename))
            shutil.copy2(local_msg, os.path.join(dest_dir, msg_filename))
        else:
            remote_dir = self._get_remote_dir()
            smb_subcmd = (
                f"mkdir {remote_dir}; "
                f"mkdir {remote_dir}\\{repo_name}; "
                f"cd {remote_dir}\\{repo_name}; "
                f"put {local_patch} {filename}; "
                f"put {local_msg} {msg_filename}"
            )
            result = self._smb_cmd(smb_subcmd)

            stderr_lines = result.stderr.strip().split('\n') if result.stderr else []
            real_errors = [
                line for line in stderr_lines
                if line.strip() and 'NT_STATUS_OBJECT_NAME_COLLISION' not in line
            ]

            if result.returncode != 0 and real_errors:
                print(f"{self._c('red', '[err]')} Upload failed:")
                print('\n'.join(real_errors))
                sys.exit(1)

    def _download_patch(self, repo_name, patch_name, dest_path):
        """Download a single patch file from the share."""
        backend, _ = self._detect_backend()

        if backend == 'mount':
            src = self._get_share_path(repo_name, patch_name)
            shutil.copy2(src, dest_path)
        else:
            remote_dir = self._get_remote_dir()
            smb_subcmd = (
                f"cd {remote_dir}\\{repo_name}; "
                f"get {patch_name} {dest_path}"
            )
            result = self._smb_cmd(smb_subcmd)
            if result.returncode != 0:
                print(f"{self._c('red', '[err]')} Download failed:")
                print(result.stderr)
                raise RuntimeError("Download failed")

    def _delete_patches(self, repo_name, patch_names):
        """Delete patch and message files from the share."""
        backend, _ = self._detect_backend()

        if backend == 'mount':
            for name in patch_names:
                patch_path = self._get_share_path(repo_name, name)
                if os.path.exists(patch_path):
                    os.remove(patch_path)
                msg_name = name.rsplit('.patch', 1)[0] + '.msg'
                msg_path = self._get_share_path(repo_name, msg_name)
                if os.path.exists(msg_path):
                    os.remove(msg_path)
        else:
            remote_dir = self._get_remote_dir()
            delete_cmds = []
            for name in patch_names:
                delete_cmds.append(f"del {name}")
                msg_name = name.rsplit('.patch', 1)[0] + '.msg'
                delete_cmds.append(f"del {msg_name}")

            smb_subcmd = f"cd {remote_dir}\\{repo_name}; {'; '.join(delete_cmds)}"
            result = self._smb_cmd(smb_subcmd)

            stderr_lines = result.stderr.strip().split('\n') if result.stderr else []
            real_errors = [
                line for line in stderr_lines
                if line.strip()
                and 'NT_STATUS_OBJECT_NAME_NOT_FOUND' not in line
                and 'NT_STATUS_NO_SUCH_FILE' not in line
            ]

            if result.returncode != 0 and real_errors:
                print(f"{self._c('red', '[err]')} Clean failed:")
                print('\n'.join(real_errors))
                raise RuntimeError("Delete failed")

    def _get_stash_message(self, stash_ref):
        """Get the message for a stash ref from git stash list."""
        result = self._run_command('git stash list', cwd=self._get_cwd(), capture=True)
        if result.returncode != 0 or not result.stdout.strip():
            return ''
        # stash_ref is like "stash@{0}", look for matching line
        for line in result.stdout.strip().split('\n'):
            if line.startswith(stash_ref):
                # Format: "stash@{0}: On branch: message"
                parts = line.split(':', 2)
                if len(parts) >= 3:
                    return parts[2].strip()
                return ''
        return ''

    def _get_stash_hash(self, stash_ref):
        """Get the short commit hash for a stash ref."""
        result = self._run_command(
            f'git rev-parse --short=8 "{stash_ref}"',
            cwd=self._get_cwd(), capture=True
        )
        if result.returncode != 0 or not result.stdout.strip():
            return ''
        return result.stdout.strip()

    def _generate_rej_for_skipped(self, patch_path, skipped_files, workdir):
        """Generate .rej files for files that git apply --reject skipped entirely.

        When git apply reports "does not exist in index" or "does not match index",
        it doesn't generate .rej files. This extracts the diff hunks for those files
        from the patch and writes them as .rej files so users can inspect them.
        """
        with open(patch_path, 'r', errors='replace') as f:
            lines = f.readlines()

        i = 0
        while i < len(lines):
            if lines[i].startswith('diff --git a/'):
                # Extract the b/ path
                parts = lines[i].split(' b/')
                if len(parts) >= 2:
                    file_path = parts[-1].strip()
                else:
                    i += 1
                    continue

                if file_path in skipped_files:
                    # Collect all lines for this diff section
                    diff_lines = [lines[i]]
                    j = i + 1
                    while j < len(lines) and not lines[j].startswith('diff --git '):
                        diff_lines.append(lines[j])
                        j += 1

                    # Write .rej file
                    rej_path = os.path.join(workdir, file_path + '.rej')
                    rej_dir = os.path.dirname(rej_path)
                    if rej_dir and not os.path.isdir(rej_dir):
                        os.makedirs(rej_dir, exist_ok=True)
                    with open(rej_path, 'w', newline='') as rej:
                        rej.writelines(diff_lines)

                    i = j
                    continue
            i += 1

    def _prepare_patch_targets(self, patch_path, workdir):
        """Ensure files referenced in a patch exist in workdir with correct base content.

        For files that don't exist in the workdir (not in HEAD's tree), reconstructs
        the original (pre-patch) content from the diff's context and removal lines,
        so that patch(1) can apply hunks against the correct base.
        """
        # Parse the patch into per-file sections
        with open(patch_path, 'r', errors='replace') as f:
            lines = f.readlines()

        i = 0
        while i < len(lines):
            # Find +++ b/path header
            if lines[i].startswith('+++ b/'):
                rel_path = lines[i][6:].strip()
                if rel_path == '/dev/null':
                    i += 1
                    continue
                full_path = os.path.join(workdir, rel_path)
                parent = os.path.dirname(full_path)
                if parent and not os.path.isdir(parent):
                    os.makedirs(parent, exist_ok=True)

                if not os.path.exists(full_path):
                    # Reconstruct original file content from diff hunks
                    # Context lines (space prefix) and removal lines (- prefix) = original
                    original_lines = []
                    j = i + 1
                    while j < len(lines):
                        line = lines[j]
                        if line.startswith('diff --git '):
                            break
                        if line.startswith('@@'):
                            j += 1
                            continue
                        if line.startswith(' ') or line.startswith('-'):
                            original_lines.append(line[1:])
                        # '+' lines are additions — skip for original content
                        j += 1
                    with open(full_path, 'w', newline='') as out:
                        out.writelines(original_lines)
            i += 1

    def _apply_patch_in_temp_workdir(self, patch_path, cwd, tmp_env):
        """Fallback: apply a patch using a temporary working directory.

        When git apply --cached fails (e.g. new files not in index, or context
        mismatch from a diverged base), checkout HEAD's tree into a temp dir,
        apply the patch there, then git add -A to update the temp index.

        Returns a result-like object with returncode 0 on success, or None on failure.
        """
        tmpdir = tempfile.mkdtemp(prefix='sendstash_workdir_')
        try:
            workdir_env = dict(tmp_env)
            workdir_env['GIT_WORK_TREE'] = tmpdir
            workdir_env['GIT_DIR'] = os.path.join(cwd, '.git')

            # Checkout HEAD's tree into temp workdir
            r = self._run_command('git checkout-index -a', cwd=cwd, capture=True, env=workdir_env)
            if r.returncode != 0:
                print(f"{self._c('yellow', '[warn]')} checkout-index failed, temp workdir may be incomplete")

            # Apply patch in the temp working directory (non-cached)
            r = self._run_command(
                f'git apply --ignore-whitespace {patch_path}',
                cwd=tmpdir, capture=True, env=workdir_env
            )
            if r.returncode != 0:
                # Try with --3way for diverged bases (may exit 1 with conflicts, but files are still applied)
                r = self._run_command(
                    f'git apply --3way --ignore-whitespace {patch_path}',
                    cwd=tmpdir, capture=True, env=workdir_env
                )
                if r.returncode != 0:
                    # --3way exits 1 on conflicts but still applies the files — check if any files were modified
                    applied = any('Applied patch' in line for line in (r.stderr or '').splitlines() + (r.stdout or '').splitlines())
                    if not applied:
                        # Fallback: git apply --reject (cross-platform, applies what it can)
                        self._prepare_patch_targets(patch_path, tmpdir)
                        # Stage prepared files so git apply --reject can see them in the index
                        self._run_command('git add -A', cwd=tmpdir, capture=True, env=workdir_env)
                        r2 = self._run_command(
                            f'git apply --reject --ignore-whitespace {patch_path}',
                            cwd=tmpdir, capture=True, env=workdir_env
                        )

                        # Generate .rej for files that git apply skipped entirely
                        # (e.g. "does not exist in index" or "does not match index")
                        skipped_files = set()
                        for line in (r2.stderr or '').splitlines():
                            if ': does not exist in index' in line or ': does not match index' in line:
                                fname = line.split('error: ', 1)[-1].split(':')[0].strip()
                                skipped_files.add(fname)
                        if skipped_files:
                            self._generate_rej_for_skipped(patch_path, skipped_files, tmpdir)

                        # Collect .rej files
                        rej_files = []
                        for root, dirs, files in os.walk(tmpdir):
                            for f in files:
                                if f.endswith('.rej'):
                                    rej_files.append(os.path.relpath(os.path.join(root, f), tmpdir))

                        # Check if anything was applied or .rej files were generated
                        applied_reject = 'Applied patch' in (r2.stderr or '') + (r2.stdout or '')
                        if not applied_reject and not rej_files and r2.returncode != 0:
                            return r  # nothing applied at all

                        if rej_files:
                            print(f"     -> {self._c('yellow', '[warn]')} Diverged base, .rej in stash: {self._c('yellow', ', '.join(rej_files))}")

            # Stage all changes (including new files) into the temp index
            r = self._run_command('git add -A', cwd=tmpdir, capture=True, env=workdir_env)
            if r.returncode != 0:
                return r

            # Return success-like object
            class _Success:
                returncode = 0
                stderr = ''
            return _Success()
        finally:
            shutil.rmtree(tmpdir, ignore_errors=True)

    def _inject_stash_from_patch(self, patch_path, stash_msg):
        """Inject a stash entry directly from a patch file without touching the working directory."""
        cwd = self._get_cwd()

        # Get HEAD commit hash and tree
        head_result = self._run_command('git rev-parse HEAD', cwd=cwd, capture=True)
        if head_result.returncode != 0:
            print(f"{self._c('red', '[err]')} Could not resolve HEAD")
            return False
        head = head_result.stdout.strip()

        head_tree_result = self._run_command('git rev-parse HEAD:', cwd=cwd, capture=True)
        if head_tree_result.returncode != 0:
            print(f"{self._c('red', '[err]')} Could not resolve HEAD tree")
            return False
        head_tree = head_tree_result.stdout.strip()

        # Get branch name
        branch_result = self._run_command('git branch --show-current', cwd=cwd, capture=True)
        branch = branch_result.stdout.strip() if branch_result.returncode == 0 and branch_result.stdout.strip() else 'detached'

        # Get short HEAD description
        head_short_result = self._run_command("git log -1 --format='%h %s' HEAD", cwd=cwd, capture=True)
        head_short = head_short_result.stdout.strip().strip("'") if head_short_result.returncode == 0 else head[:7]

        # Create I commit (index state — identical to HEAD tree since we only modify W)
        i_msg = f"index on {branch}: {head_short}"
        i_result = self._run_command(
            f'git commit-tree {head_tree} -p {head} -m "{i_msg}"',
            cwd=cwd, capture=True
        )
        if i_result.returncode != 0:
            print(f"{self._c('red', '[err]')} Index commit failed: {i_result.stderr.strip()}")
            return False
        i_commit = i_result.stdout.strip()

        # Create temporary index file
        tmp_index = tempfile.mktemp(prefix='sendstash_idx_')
        tmp_env = dict(os.environ, GIT_INDEX_FILE=tmp_index)

        try:
            # Populate temp index with HEAD's tree
            r = self._run_command('git read-tree HEAD', cwd=cwd, capture=True, env=tmp_env)
            if r.returncode != 0:
                print(f"{self._c('red', '[err]')} Temp index failed: {r.stderr.strip()}")
                return False

            # Apply patch to temp index (try --3way for diverged bases, --ignore-whitespace for CRLF)
            r = self._run_command(f'git apply --cached --3way --ignore-whitespace {patch_path}', cwd=cwd, capture=True, env=tmp_env)
            if r.returncode != 0:
                # Fallback: try without --3way in case patch lacks blob info
                r = self._run_command(f'git apply --cached --ignore-whitespace {patch_path}', cwd=cwd, capture=True, env=tmp_env)
            if r.returncode != 0:
                # Final fallback: apply in a temp working directory (handles new files, diverged content)
                r = self._apply_patch_in_temp_workdir(patch_path, cwd, tmp_env)
            if r is None or (hasattr(r, 'returncode') and r.returncode != 0):
                print(f"{self._c('red', '[err]')} Patch apply failed: {r.stderr.strip() if hasattr(r, 'stderr') and r.stderr else ''}")
                return False

            # Write tree from temp index
            r = self._run_command('git write-tree', cwd=cwd, capture=True, env=tmp_env)
            if r.returncode != 0:
                print(f"{self._c('red', '[err]')} Write-tree failed: {r.stderr.strip()}")
                return False
            w_tree = r.stdout.strip()
        finally:
            if os.path.exists(tmp_index):
                os.unlink(tmp_index)

        # Create W commit (working tree state)
        w_msg = f"On {branch}: {stash_msg}" if stash_msg else f"On {branch}: WIP"
        w_result = self._run_command(
            f'git commit-tree {w_tree} -p {head} -p {i_commit} -m "{w_msg}"',
            cwd=cwd, capture=True
        )
        if w_result.returncode != 0:
            print(f"{self._c('red', '[err]')} W-commit failed: {w_result.stderr.strip()}")
            return False
        w_commit = w_result.stdout.strip()

        # Store as stash entry
        store_result = self._run_command(
            f'git stash store -m "{w_msg}" {w_commit}',
            cwd=cwd, capture=True
        )
        if store_result.returncode != 0:
            print(f"{self._c('red', '[err]')} Stash store failed: {store_result.stderr.strip()}")
            return False

        return w_commit

    def _get_local_stash_hashes(self):
        """Get the set of stash hashes for all local stash entries."""
        entries = self._list_stash_refs()
        hashes = set()
        for ref, _ in entries:
            h = self._get_stash_hash(ref)
            if h:
                hashes.add(h)
        return hashes

    def _content_hash(self, patch_content):
        """SHA-256 of patch content with normalized line endings."""
        import hashlib
        normalized = patch_content.replace('\r\n', '\n').replace('\r', '\n')
        return hashlib.sha256(normalized.encode('utf-8', errors='replace')).hexdigest()[:16]

    def _semantic_content_hash(self, patch_content):
        """SHA-256 of patch content with index lines stripped.

        Git 'index' lines contain blob hashes that change on re-stash even when
        the actual diff is identical.  Stripping them gives a stable hash for
        semantically identical patches.
        """
        import hashlib
        normalized = patch_content.replace('\r\n', '\n').replace('\r', '\n')
        stripped = re.sub(r'^index [0-9a-f]+\.\.[0-9a-f]+( \d+)?$', '', normalized, flags=re.MULTILINE)
        return hashlib.sha256(stripped.encode('utf-8', errors='replace')).hexdigest()[:16]

    def _get_local_content_hashes(self):
        """Get a set of content hashes for all local stash entries.

        Includes both:
        - Hashes computed from local `git stash show -p` output
        - Source content hashes stored as git notes (refs/notes/sendstash)
          (these are added during pull to survive cross-platform hash differences)
        """
        entries = self._list_stash_refs()
        hashes = set()

        # Collect W commit SHAs for current stash entries
        stash_commits = set()
        for ref, _ in entries:
            rev = self._run_command(
                f'git rev-parse {ref}',
                cwd=self._get_cwd(), capture=True
            )
            if rev.returncode == 0:
                stash_commits.add(rev.stdout.strip())

        # Read source content hashes from git notes (refs/notes/sendstash),
        # but only for commits that are still current stash entries
        result = self._run_command(
            'git notes --ref=sendstash list',
            cwd=self._get_cwd(), capture=True
        )
        if result.returncode == 0 and result.stdout.strip():
            for line in result.stdout.strip().split('\n'):
                parts = line.split()
                if len(parts) == 2 and parts[1] in stash_commits:
                    note_hash = self._run_command(
                        f'git notes --ref=sendstash show {parts[1]}',
                        cwd=self._get_cwd(), capture=True
                    )
                    if note_hash.returncode == 0:
                        hashes.add(note_hash.stdout.strip())

        for ref, msg in entries:
            result = self._run_command(
                f'git stash show -p --include-untracked "{ref}"',
                cwd=self._get_cwd(), capture=True
            )
            if result.returncode != 0:
                result = self._run_command(
                    f'git stash show -p "{ref}"',
                    cwd=self._get_cwd(), capture=True
                )
            if result.returncode == 0 and result.stdout.strip():
                hashes.add(self._content_hash(result.stdout))
                hashes.add(self._semantic_content_hash(result.stdout))
        return hashes

    def _get_remote_hashes(self):
        """Get the set of stash hashes already present on the SMB share."""
        repo_name = self._get_repo_name()
        patches = self._list_patches_raw(repo_name)
        hashes = set()
        for name, _, _ in patches:
            # Extract 8-char hex hash from filename: branch_name_HASH_timestamp.patch
            match = re.search(r'_([0-9a-f]{8})_\d{4}-\d{2}-\d{2}_', name)
            if match:
                hashes.add(match.group(1))
        return hashes

    def _get_remote_content_hashes(self, repo_name=None):
        """Get the set of content and semantic hashes from remote patches.

        For patches whose .msg already contains a semantic_hash, that value is
        used directly.  For older .msg files without one, the actual .patch file
        is downloaded and the semantic hash is computed on the fly.
        """
        if repo_name is None:
            repo_name = self._get_repo_name()
        patches = self._list_patches_raw(repo_name)
        messages = self._fetch_messages(repo_name, patches)
        hashes = set()
        need_download = []
        for patch_name, _, _ in patches:
            _, _, ch, sh = messages.get(patch_name, ('', '', '', ''))
            if ch:
                hashes.add(ch)
            if sh:
                hashes.add(sh)
            elif ch:
                # Old .msg without semantic_hash — need to download patch to compute it
                need_download.append(patch_name)

        # Download and compute semantic hashes for legacy patches
        for patch_name in need_download:
            with tempfile.NamedTemporaryFile(mode='w', suffix='.patch', delete=False) as f:
                temp_path = f.name
            try:
                self._download_patch(repo_name, patch_name, temp_path)
                with open(temp_path, 'r') as f:
                    content = f.read()
                if content.strip():
                    hashes.add(self._semantic_content_hash(content))
            except (RuntimeError, OSError):
                pass
            finally:
                if os.path.exists(temp_path):
                    os.unlink(temp_path)

        return hashes

    def _check_push_duplicate(self, stash_ref, remote_hashes, remote_content_hashes):
        """Check if a local stash already exists on the remote. Returns skip reason or None."""
        # Tier 1: commit hash match
        stash_hash = self._get_stash_hash(stash_ref)
        if stash_hash and stash_hash in remote_hashes:
            return f"hash match: {stash_hash}"

        # Tier 2: content hash match
        if remote_content_hashes:
            result = self._run_command(
                f'git stash show -p --include-untracked "{stash_ref}"',
                cwd=self._get_cwd(), capture=True
            )
            if result.returncode != 0:
                result = self._run_command(
                    f'git stash show -p "{stash_ref}"',
                    cwd=self._get_cwd(), capture=True
                )
            if result.returncode == 0 and result.stdout.strip():
                ch = self._content_hash(result.stdout)
                if ch in remote_content_hashes:
                    return f"content match: {ch[:8]}"
                sh = self._semantic_content_hash(result.stdout)
                if sh in remote_content_hashes:
                    return f"content match: {sh[:8]}"

        return None

    def _check_pull_duplicate(self, patch_name, content_hash, semantic_hash, local_hashes, local_content_hashes):
        """Check if a remote patch already exists locally. Returns skip reason or None."""
        # Tier 1: commit hash match
        hash_match = re.search(r'_([0-9a-f]{8})_\d{4}-\d{2}-\d{2}_', patch_name)
        if hash_match and hash_match.group(1) in local_hashes:
            return f"hash match: {hash_match.group(1)}"

        # Tier 2: content hash match (raw or semantic)
        if content_hash and content_hash in local_content_hashes:
            return f"content match: {content_hash[:8]}"
        if semantic_hash and semantic_hash in local_content_hashes:
            return f"content match: {semantic_hash[:8]}"

        return None

    def _list_stash_refs(self):
        """Returns a list of (ref, message) for all stash entries."""
        result = self._run_command('git stash list', cwd=self._get_cwd(), capture=True)
        if result.returncode != 0 or not result.stdout.strip():
            return []
        entries = []
        for line in result.stdout.strip().split('\n'):
            parts = line.split(':', 2)
            ref = parts[0].strip()
            message = parts[2].strip() if len(parts) >= 3 else ''
            entries.append((ref, message))
        return entries

    def push_all(self, message=None, force=False):
        """Push all stash entries to the SMB share."""
        entries = self._list_stash_refs()
        if not entries:
            print(f"{self._c('blue', '[info]')} No stashes found")
            return

        # Get existing patches on SMB to avoid duplicates
        remote_hashes = self._get_remote_hashes() if not force else set()
        remote_content_hashes = self._get_remote_content_hashes() if not force else set()

        for ref, _ in entries:
            if not force:
                skip_reason = self._check_push_duplicate(ref, remote_hashes, remote_content_hashes)
                if skip_reason:
                    print(f"  {self._c('gray', '[skip]')} {ref}  ({skip_reason})")
                    continue
            print(f"\n  {self._c('cyan', '[push]')} {ref}")
            self.push(message=message, stash_ref=ref, force=True)

    def push_global(self, force=False, message=None):
        """Push stashes from all repos under the configured root."""
        repos = self._scan_repos_with_stashes()
        if not repos:
            print(f"{self._c('blue', '[info]')} No repos with stashes found")
            return

        print(f"{self._c('blue', '[info]')} {len(repos)} repo(s) with stashes:")
        for name, path, count in repos:
            print(f"  {name}: {count} stash(es)")

        self._ensure_projects_in_config(repos)

        configured = self.config.get('projects', {})
        stashed_names = {name for name, _, _ in repos}

        success = 0
        failed = 0

        for proj_name, proj_info in configured.items():
            if proj_name not in stashed_names:
                continue
            print(f"\n{self._c('bold', '='*60)}")
            print(f" {proj_name}")
            print(f"{self._c('bold', '='*60)}")
            self.project_path = proj_info['path']
            try:
                self.push_all(message=message, force=force)
                success += 1
            except SystemExit:
                print(f"  {self._c('red', '[err]')} Push failed for {proj_name}")
                failed += 1
            except Exception as e:
                print(f"  {self._c('red', '[err]')} {proj_name}: {e}")
                failed += 1

        print(f"\n{self._c('green', 'Done:')} {success} pushed, {failed} failed")

    def push(self, message=None, stash_ref='stash@{0}', force=False, pick=False):
        """Push a stash patch to the SMB share."""
        # Interactive pick mode
        if pick:
            entries = self._list_stash_refs()
            if not entries:
                print(f"{self._c('blue', '[info]')} No stashes found")
                return
            print("Available stashes:")
            for i, (ref, msg) in enumerate(entries, 1):
                print(self._format_stash_item(i, ref, msg))
            try:
                choice = int(input("\nSelect stash number: "))
                if choice < 1 or choice > len(entries):
                    print("Invalid selection.")
                    return
                stash_ref = entries[choice - 1][0]
            except (ValueError, EOFError):
                print("Invalid selection.")
                return

        # Normalize bare numbers like "1" into "stash@{1}"
        if stash_ref.isdigit():
            stash_ref = f'stash@{{{stash_ref}}}'

        repo_name = self._get_repo_name()
        branch = self._get_branch_name()
        remote_dir = self._get_remote_dir()

        # Check for duplicate on remote unless --force
        if not force:
            remote_hashes = self._get_remote_hashes()
            remote_content_hashes = self._get_remote_content_hashes()
            skip_reason = self._check_push_duplicate(stash_ref, remote_hashes, remote_content_hashes)
            if skip_reason:
                print(f"{self._c('gray', '[skip]')} Already on remote ({skip_reason})")
                print(f"     -> Use --force to push anyway")
                return

        # Generate the patch from stash (include untracked files if present)
        result = self._run_command(
            f'git stash show -p --include-untracked "{stash_ref}"',
            cwd=self._get_cwd(), capture=True
        )
        if result.returncode != 0:
            # Fall back to without --include-untracked for older git versions
            result = self._run_command(
                f'git stash show -p "{stash_ref}"',
                cwd=self._get_cwd(), capture=True
            )
        if result.returncode != 0:
            print(f"{self._c('red', '[err]')} Could not generate patch from {stash_ref}")
            print(result.stderr)
            return

        patch_content = result.stdout
        if not patch_content.strip():
            print(f"{self._c('yellow', '[warn]')} Empty patch from {stash_ref}, skipping")
            return

        # Get stash name from git for the filename
        stash_name = self._get_stash_message(stash_ref)

        # Resolve .msg content: explicit flag > git stash name > empty
        if message is None:
            message = stash_name

        # Generate filename
        timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
        sanitized_branch = self._sanitize_name(branch)
        stash_hash = self._get_stash_hash(stash_ref)
        # Include stash name in filename if available: branch_stashname_hash_timestamp
        stash_label = self._sanitize_for_filename(stash_name) if stash_name else ''
        if stash_label and stash_hash:
            base_name = f"{sanitized_branch}_{stash_label}_{stash_hash}_{timestamp}"
        elif stash_label:
            base_name = f"{sanitized_branch}_{stash_label}_{timestamp}"
        elif stash_hash:
            base_name = f"{sanitized_branch}_{stash_hash}_{timestamp}"
        else:
            base_name = f"{sanitized_branch}_{timestamp}"
        filename = f"{base_name}.patch"
        msg_filename = f"{base_name}.msg"

        # Write patch to temp file
        with tempfile.NamedTemporaryFile(mode='w', suffix='.patch', delete=False) as f:
            f.write(patch_content)
            temp_patch_path = f.name

        # Write message to temp file (with stash_name and content_hash headers)
        content_hash = self._content_hash(patch_content)
        semantic_hash = self._semantic_content_hash(patch_content)
        with tempfile.NamedTemporaryFile(mode='w', suffix='.msg', delete=False) as f:
            f.write(f"stash_name: {stash_name}\ncontent_hash: {content_hash}\nsemantic_hash: {semantic_hash}\n---\n{message}")
            temp_msg_path = f.name

        try:
            self._upload_patch(repo_name, temp_patch_path, temp_msg_path, filename, msg_filename)
            print(f"  -> Pushed: {filename}")
            if message:
                print(f"     -> Message: {message}")
        finally:
            os.unlink(temp_patch_path)
            os.unlink(temp_msg_path)

    def _parse_msg_file(self, content):
        """Parse .msg file content. Returns (stash_name, message, content_hash, semantic_hash).

        New format:
            stash_name: WIP on login feature
            content_hash: abc123...
            semantic_hash: def456...
            ---
            User's custom message here

        Old format (backward compat): entire content is the message, stash_name and content_hash are empty.
        """
        if '---' in content:
            header, _, body = content.partition('---')
            stash_name = ''
            content_hash = ''
            semantic_hash = ''
            for line in header.strip().split('\n'):
                if line.startswith('stash_name:'):
                    stash_name = line[len('stash_name:'):].strip()
                elif line.startswith('content_hash:'):
                    content_hash = line[len('content_hash:'):].strip()
                elif line.startswith('semantic_hash:'):
                    semantic_hash = line[len('semantic_hash:'):].strip()
            return (stash_name, body.strip(), content_hash, semantic_hash)
        return ('', content.strip(), '', '')

    def _format_msg_display(self, stash_name, message):
        """Format stash_name and message for display."""
        if stash_name and message and stash_name != message:
            return f'{stash_name} \u2014 {message}'
        if stash_name:
            return stash_name
        return message

    def _human_size(self, size_str):
        """Convert byte string to human-readable size."""
        try:
            n = int(size_str)
        except (ValueError, TypeError):
            return size_str
        if n < 1024:
            return f"{n} B"
        elif n < 1024 * 1024:
            return f"{n / 1024:.1f} KB"
        else:
            return f"{n / (1024 * 1024):.1f} MB"

    def _format_patch_item(self, index, name, size, date, messages):
        """Format a single patch list item as two lines:
          idx. "message"
               filename  (size, date)
        """
        stash_name, msg, _content_hash, _semantic_hash = messages.get(name, ('', '', '', ''))
        display = self._format_msg_display(stash_name, msg)
        num = self._c('cyan', f"{index}.")
        human = self._human_size(size)
        if display:
            line1 = f"  {num} {self._c('bold', display)}"
        else:
            line1 = f"  {num} {self._c('dim', '(no message)')}"
        line2 = f"     {self._c('dim', name)}  {self._c('dim', f'({human}, {date})')}"
        return f"{line1}\n{line2}"

    def _format_stash_item(self, index, ref, msg):
        """Format a single stash list item for push --pick."""
        num = self._c('cyan', f"{index}.")
        ref_fmt = self._c('dim', ref)
        return f"  {num} {ref_fmt}: {msg}"

    def _fetch_messages(self, repo_name, patches):
        """Batch-download .msg files for a list of patches. Returns dict of patch_name -> (stash_name, message, content_hash)."""
        backend, _ = self._detect_backend()
        messages = {}

        if backend == 'mount':
            for name, _, _ in patches:
                base = name.rsplit('.patch', 1)[0]
                msg_path = self._get_share_path(repo_name, f"{base}.msg")
                if os.path.exists(msg_path):
                    with open(msg_path, 'r') as f:
                        messages[name] = self._parse_msg_file(f.read())
        else:
            remote_dir = self._get_remote_dir()
            with tempfile.TemporaryDirectory() as tmpdir:
                smb_subcmd = (
                    f"cd {remote_dir}\\{repo_name}; "
                    f"prompt OFF; "
                    f"lcd {tmpdir}; "
                    f"mget *.msg"
                )
                self._smb_cmd(smb_subcmd)

                for name, _, _ in patches:
                    base = name.rsplit('.patch', 1)[0]
                    msg_path = os.path.join(tmpdir, f"{base}.msg")
                    if os.path.exists(msg_path):
                        with open(msg_path, 'r') as f:
                            messages[name] = self._parse_msg_file(f.read())

        return messages

    def list_patches(self):
        """List available patches on the SMB share for the current repo."""
        repo_name = self._get_repo_name()

        patches = self._list_patches_raw(repo_name)

        if not patches:
            print(f"{self._c('blue', '[info]')} No patches for '{repo_name}'")
            return []

        # Fetch messages for all patches in one smbclient call
        messages = self._fetch_messages(repo_name, patches)

        print(f"Patches for '{repo_name}':")
        for i, (name, size, date) in enumerate(patches, 1):
            print(self._format_patch_item(i, name, size, date, messages))

        return patches

    def list_global(self):
        """List patches for all configured projects."""
        configured = self.config.get('projects', {})
        if not configured:
            print(f"{self._c('blue', '[info]')} No projects configured")
            return

        total_patches = 0

        for proj_name, proj_info in configured.items():
            proj_path = proj_info['path']
            if not os.path.isdir(proj_path):
                continue

            self.project_path = proj_path

            try:
                repo_name = self._get_repo_name()
            except SystemExit:
                continue

            patches = self._list_patches_raw(repo_name)
            if not patches:
                continue

            messages = self._fetch_messages(repo_name, patches)

            print(f"\n{self._c('bold', '='*60)}")
            print(f" {proj_name} ({len(patches)} patch(es))")
            print(f"{self._c('bold', '='*60)}")
            for i, (name, size, date) in enumerate(patches, 1):
                print(self._format_patch_item(i, name, size, date, messages))

            total_patches += len(patches)

        if total_patches == 0:
            print(f"{self._c('blue', '[info]')} No patches found")
        else:
            print(f"\nTotal: {total_patches} patch(es)")

    def _parse_ls_output(self, output):
        """Parse smbclient ls output into list of (filename, size, date_string)."""
        patches = []
        for line in output.strip().split('\n'):
            line = line.strip()
            if not line or not line.endswith('.patch'):
                # Try to parse lines that contain .patch
                pass

            # smbclient ls format: "  filename    A    size  date"
            # Match lines containing .patch files
            match = re.match(
                r'\s*(\S+\.patch)\s+[A-Za-z]*\s+(\d+)\s+(.*)',
                line
            )
            if match:
                name = match.group(1)
                size = match.group(2)
                date = match.group(3).strip()
                patches.append((name, size, date))

        # Sort by filename (which contains timestamp) so newest is last
        patches.sort(key=lambda x: x[0])
        return patches

    def pull(self, latest=True, pick=False, number=None, name=None, apply_to_workdir=False, force=False):
        """Pull a stash patch from the SMB share and restore it as a stash entry (or apply directly with --apply)."""
        repo_name = self._get_repo_name()

        patches = self._list_patches_raw(repo_name)
        if not patches:
            print(f"{self._c('blue', '[info]')} No patches for '{repo_name}'")
            return

        # Fetch messages (needed for display and stash-restore)
        messages = self._fetch_messages(repo_name, patches)

        if number is not None:
            if number < 1 or number > len(patches):
                print(f"{self._c('red', '[err]')} Invalid patch number: {number} (must be 1-{len(patches)})")
                return
            selected = patches[number - 1]
            print(f"{self._c('blue', '[info]')} Selected patch {number}:")
            print(self._format_patch_item(number, selected[0], selected[1], selected[2], messages))
        elif name is not None:
            matches = [(i, p) for i, p in enumerate(patches, 1) if name.lower() in p[0].lower()]
            if not matches:
                print(f"{self._c('blue', '[info]')} No patches matching '{name}'")
                return
            if len(matches) > 1:
                print(f"Multiple patches match '{name}':")
                for num, (pname, size, date) in matches:
                    print(self._format_patch_item(num, pname, size, date, messages))
                print(f"     -> Please be more specific")
                return
            selected = matches[0][1]
            print(f"{self._c('blue', '[info]')} Selected patch:")
            print(self._format_patch_item(matches[0][0], selected[0], selected[1], selected[2], messages))
        elif pick:
            # Show list and let user choose
            print(f"Available patches for '{repo_name}':")
            for i, (pname, size, date) in enumerate(patches, 1):
                print(self._format_patch_item(i, pname, size, date, messages))

            try:
                choice = int(input("\nSelect patch number: "))
                if choice < 1 or choice > len(patches):
                    print("Invalid selection.")
                    return
                selected = patches[choice - 1]
            except (ValueError, EOFError):
                print("Invalid selection.")
                return
        else:
            # Default: latest (last in sorted list)
            selected = patches[-1]

        patch_name = selected[0]
        selected_stash_name, selected_msg, selected_content_hash, selected_semantic_hash = messages.get(patch_name, ('', '', '', ''))

        # Check for duplicate unless --force
        if not force:
            local_hashes = self._get_local_stash_hashes()
            local_content_hashes = self._get_local_content_hashes()
            skip_reason = self._check_pull_duplicate(
                patch_name, selected_content_hash, selected_semantic_hash, local_hashes, local_content_hashes
            )
            if skip_reason:
                print(f"{self._c('gray', '[skip]')} Already in local stashes ({skip_reason})")
                print(f"     -> Use --force to pull anyway")
                return

        print(f"{self._c('cyan', '[pull]')} {patch_name}")

        # Download patch to temp file
        with tempfile.NamedTemporaryFile(mode='w', suffix='.patch', delete=False) as f:
            temp_path = f.name

        try:
            try:
                self._download_patch(repo_name, patch_name, temp_path)
            except RuntimeError:
                return

            if apply_to_workdir:
                # Apply directly to working directory
                apply_result = self._run_command(f'git apply {temp_path}', cwd=self._get_cwd(), capture=True)
                if apply_result.returncode != 0:
                    print(f"{self._c('red', '[err]')} Patch apply failed")
                    print(apply_result.stderr)
                    print(f"     -> Patch saved: {temp_path}")
                    return
                print(f"  -> Applied to workdir: {patch_name}")
            else:
                # Stash-restore mode: inject stash directly without touching working directory
                stash_label = selected_stash_name or selected_msg
                if not self._inject_stash_from_patch(temp_path, stash_label):
                    print(f"     -> Patch saved: {temp_path}")
                    return

                print(f"  -> Restored as: {stash_label or patch_name}")
                # Show top stash entry
                list_result = self._run_command('git stash list -1', cwd=self._get_cwd(), capture=True)
                if list_result.returncode == 0 and list_result.stdout.strip():
                    print(list_result.stdout.strip())
        finally:
            if os.path.exists(temp_path):
                os.unlink(temp_path)

    def pull_all(self, force=False):
        """Pull all patches from the SMB share and inject each as a stash entry."""
        repo_name = self._get_repo_name()

        patches = self._list_patches_raw(repo_name)
        if not patches:
            print(f"{self._c('blue', '[info]')} No patches for '{repo_name}'")
            return

        messages = self._fetch_messages(repo_name, patches)

        # Get local hashes and content hashes once for duplicate detection
        local_hashes = self._get_local_stash_hashes() if not force else set()
        local_content_hashes = self._get_local_content_hashes() if not force else set()

        success_count = 0
        skipped_count = 0
        total = len(patches)

        for patch_name, size, date in patches:
            stash_name, msg, patch_content_hash, patch_semantic_hash = messages.get(patch_name, ('', '', '', ''))

            # Check for duplicate unless --force
            if not force:
                skip_reason = self._check_pull_duplicate(
                    patch_name, patch_content_hash, patch_semantic_hash, local_hashes, local_content_hashes
                )
                if skip_reason:
                    display = stash_name or msg or patch_name
                    print(f"  {self._c('gray', '[skip]')} {display}  ({skip_reason})")
                    skipped_count += 1
                    continue

            print(f"\n  {self._c('cyan', '[pull]')} {patch_name}")
            stash_label = stash_name or msg or ''

            with tempfile.NamedTemporaryFile(mode='w', suffix='.patch', delete=False) as f:
                temp_path = f.name

            try:
                try:
                    self._download_patch(repo_name, patch_name, temp_path)
                except RuntimeError:
                    print(f"     -> FAILED to download")
                    continue

                w_commit = self._inject_stash_from_patch(temp_path, stash_label)
                if w_commit:
                    print(f"     -> Restored as: {stash_label or patch_name}")
                    success_count += 1

                    # Attach source content hash as git note for cross-platform dedup
                    if patch_content_hash:
                        self._run_command(
                            f'git notes --ref=sendstash add -m "{patch_content_hash}" {w_commit}',
                            cwd=self._get_cwd(), capture=True
                        )
                        local_content_hashes.add(patch_content_hash)
                else:
                    print(f"     -> FAILED to inject stash")
            finally:
                if os.path.exists(temp_path):
                    os.unlink(temp_path)

        print(f"\n  {self._c('green', 'Done:')} {success_count} pulled, {skipped_count} skipped, {total - success_count - skipped_count} failed  (of {total} total)")

    def pull_global(self, force=False):
        """Pull all patches for all configured projects."""
        configured = self.config.get('projects', {})
        if not configured:
            print(f"{self._c('blue', '[info]')} No projects configured")
            return

        success = 0
        skipped = 0
        failed = 0

        for proj_name, proj_info in configured.items():
            proj_path = proj_info['path']
            if not os.path.isdir(proj_path):
                print(f"\n  {self._c('gray', '[skip]')} {proj_name}: path not found")
                skipped += 1
                continue
            print(f"\n{self._c('bold', '='*60)}")
            print(f" {proj_name}")
            print(f"{self._c('bold', '='*60)}")
            self.project_path = proj_path
            try:
                self.pull_all(force=force)
                success += 1
            except SystemExit:
                print(f"  {self._c('red', '[err]')} Pull failed for {proj_name}")
                failed += 1
            except Exception as e:
                print(f"  {self._c('red', '[err]')} {proj_name}: {e}")
                failed += 1

        print(f"\n{self._c('green', 'Done:')} {success} pulled, {skipped} skipped, {failed} failed")

    def clean(self, all_patches=False, older_than=None, pick=False):
        """Remove old patches from the SMB share for the current repo."""
        repo_name = self._get_repo_name()

        patches = self._list_patches_raw(repo_name)
        if not patches:
            print(f"{self._c('blue', '[info]')} No patches for '{repo_name}'")
            return

        to_delete = []

        if pick:
            messages = self._fetch_messages(repo_name, patches)

            print(f"Available patches for '{repo_name}':")
            for i, (name, size, date) in enumerate(patches, 1):
                print(self._format_patch_item(i, name, size, date, messages))

            try:
                raw = input("\nSelect patch numbers to delete (comma-separated, e.g. 1,3,5): ")
                choices = [int(x.strip()) for x in raw.split(',')]
            except (ValueError, EOFError):
                print("Invalid input.")
                return

            for c in choices:
                if c < 1 or c > len(patches):
                    print(f"Invalid selection: {c} (must be 1-{len(patches)})")
                    return

            to_delete = [patches[c - 1][0] for c in choices]
        elif all_patches:
            to_delete = [p[0] for p in patches]
        elif older_than is not None:
            cutoff = datetime.now() - timedelta(days=older_than)
            for name, size, date in patches:
                # Extract timestamp from filename: branch_YYYY-MM-DD_HH-MM-SS.patch
                ts_match = re.search(r'(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.patch$', name)
                if ts_match:
                    try:
                        patch_time = datetime.strptime(ts_match.group(1), '%Y-%m-%d_%H-%M-%S')
                        if patch_time < cutoff:
                            to_delete.append(name)
                    except ValueError:
                        continue

        if not to_delete:
            print(f"{self._c('blue', '[info]')} No patches to clean")
            return

        try:
            self._delete_patches(repo_name, to_delete)
        except RuntimeError:
            return

        print(f"  {self._c('green', 'Done:')} {len(to_delete)} cleaned from '{repo_name}'")
        for name in to_delete:
            print(f"  - {name}")

    def clean_global(self, older_than=None):
        """Clean patches for all configured projects."""
        configured = self.config.get('projects', {})
        if not configured:
            print(f"{self._c('blue', '[info]')} No projects configured")
            return

        success = 0
        skipped = 0
        failed = 0
        total_cleaned = 0

        for proj_name, proj_info in configured.items():
            proj_path = proj_info['path']
            if not os.path.isdir(proj_path):
                print(f"  {self._c('gray', '[skip]')} {proj_name}: path not found")
                skipped += 1
                continue

            self.project_path = proj_path

            try:
                repo_name = self._get_repo_name()
            except SystemExit:
                print(f"  {self._c('gray', '[skip]')} {proj_name}: not a git repo")
                skipped += 1
                continue

            patches = self._list_patches_raw(repo_name)
            if not patches:
                print(f"  {self._c('gray', '[skip]')} {proj_name}: no patches")
                skipped += 1
                continue

            if older_than is not None:
                cutoff = datetime.now() - timedelta(days=older_than)
                to_delete = []
                for name, size, date in patches:
                    ts_match = re.search(r'(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.patch$', name)
                    if ts_match:
                        try:
                            patch_time = datetime.strptime(ts_match.group(1), '%Y-%m-%d_%H-%M-%S')
                            if patch_time < cutoff:
                                to_delete.append(name)
                        except ValueError:
                            continue
            else:
                to_delete = [p[0] for p in patches]

            if not to_delete:
                print(f"  {self._c('gray', '[skip]')} {proj_name}: nothing to clean")
                skipped += 1
                continue

            print(f"\n{self._c('bold', '='*60)}")
            print(f" {proj_name}")
            print(f"{self._c('bold', '='*60)}")

            try:
                self._delete_patches(repo_name, to_delete)
                for name in to_delete:
                    print(f"  - {name}")
                total_cleaned += len(to_delete)
                success += 1
            except SystemExit:
                print(f"  {self._c('red', '[err]')} Clean failed for {proj_name}")
                failed += 1
            except Exception as e:
                print(f"  {self._c('red', '[err]')} {proj_name}: {e}")
                failed += 1

        print(f"\n{self._c('green', 'Done:')} {total_cleaned} cleaned across {success} project(s), {skipped} skipped, {failed} failed")


def _color(color, text):
    """Colorize text if stdout is a TTY."""
    codes = {'reset': '\033[0m', 'bold': '\033[1m', 'red': '\033[31m', 'green': '\033[32m',
             'yellow': '\033[33m', 'blue': '\033[34m', 'cyan': '\033[36m', 'gray': '\033[90m'}
    if sys.stdout.isatty() and color in codes:
        return f"{codes[color]}{text}{codes['reset']}"
    return str(text)


def check_for_updates(tool_name):
    """Checks if there are updates available on the remote git repository."""
    script_dir = os.path.dirname(os.path.realpath(__file__))

    try:
        # Check if it's a git repo
        result = subprocess.run(
            ['git', 'rev-parse', '--git-dir'],
            cwd=script_dir, capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"{_color('yellow', '[warn]')} Not a git repo, can't check for updates")
            return

        # Get current branch
        result = subprocess.run(
            ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
            cwd=script_dir, capture_output=True, text=True
        )
        branch = result.stdout.strip()

        # Get current local commit
        result = subprocess.run(
            ['git', 'rev-parse', 'HEAD'],
            cwd=script_dir, capture_output=True, text=True
        )
        local_hash = result.stdout.strip()

        # Fetch latest from remote
        print(f"{_color('blue', '[info]')} Checking for updates...")
        result = subprocess.run(
            ['git', 'fetch'],
            cwd=script_dir, capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"{_color('red', '[err]')} Fetch failed: {result.stderr.strip()}")
            return

        # Get remote commit
        result = subprocess.run(
            ['git', 'rev-parse', f'origin/{branch}'],
            cwd=script_dir, capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"{_color('yellow', '[warn]')} Remote branch 'origin/{branch}' not found")
            return
        remote_hash = result.stdout.strip()

        if local_hash == remote_hash:
            print(f"{_color('blue', '[info]')} Up to date ({local_hash[:7]})")
            return

        # Show commits behind
        result = subprocess.run(
            ['git', 'log', '--oneline', f'HEAD..origin/{branch}'],
            cwd=script_dir, capture_output=True, text=True
        )
        commits = result.stdout.strip()
        commit_count = len(commits.splitlines())

        print(f"{_color('blue', '[info]')} {commit_count} commit(s) behind origin/{branch}:")
        print(commits)
        print()

        # Ask user if they want to update
        try:
            answer = input("Do you want to update now? [y/N] ").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print()
            return

        if answer in ('y', 'yes'):
            result = subprocess.run(
                ['git', 'pull'],
                cwd=script_dir, text=True
            )
            if result.returncode == 0:
                print(f"{_color('green', '[info]')} Updated successfully!")
            else:
                print(f"{_color('red', '[err]')} Update failed. Run 'git pull' in {script_dir}")
        else:
            print(f"{_color('blue', '[info]')} Skipped. Run 'git pull' in {script_dir} to update later")

    except FileNotFoundError:
        print(f"{_color('red', '[err]')} git not found in PATH")


def main():
    # Pre-parse --config so we can load projects before building the full parser
    pre_parser = argparse.ArgumentParser(add_help=False)
    pre_parser.add_argument('--config')
    pre_parser.add_argument('--sync-config', action='store_true')
    pre_parser.add_argument('--open', action='store_true')
    pre_parser.add_argument('--check-update', action='store_true')
    pre_args, _ = pre_parser.parse_known_args()

    # Handle --check-update before loading config
    if pre_args.check_update:
        check_for_updates("SendStash")
        return

    stash = SendStash(config_path=pre_args.config)

    if pre_args.open:
        stash.open_folder()
        return

    if pre_args.sync_config:
        stash.sync_config()

    project_choices = stash.get_project_choices() or None

    parser = argparse.ArgumentParser(
        description="Sync git stash patches via SMB share."
    )
    parser.add_argument('--config', help="Path to config.yaml")
    parser.add_argument('--sync-config', action='store_true', help="Sync the configuration from its source before running the command")
    parser.add_argument('--open', action='store_true', help="Open the SendStash directory in file explorer")
    parser.add_argument('--check-update', action='store_true', help="Check if a newer version is available on the remote git repository.")

    subparsers = parser.add_subparsers(dest='command', help="Available commands")

    # Shared parent parser for --project
    project_parser = argparse.ArgumentParser(add_help=False)
    project_parser.add_argument(
        '--project', '-p', choices=project_choices,
        help="Use a configured project instead of the current directory"
    )

    # push
    push_parser = subparsers.add_parser('push', parents=[project_parser], help="Push a stash patch to the SMB share")
    push_parser.add_argument('--message', '-m', help="Optional message/description for the patch")
    push_stash_group = push_parser.add_mutually_exclusive_group()
    push_stash_group.add_argument('--stash', default='stash@{0}', help="Stash reference (default: stash@{0})")
    push_stash_group.add_argument('--stash-all', action='store_true', help="Push all stash entries")
    push_stash_group.add_argument('--pick', action='store_true', help="Interactively choose which stash to push")
    push_stash_group.add_argument('--global', dest='global_flag', action='store_true',
        help="Push stashes from all repos under the configured root")
    push_parser.add_argument('--force', action='store_true',
        help="Push even if the stash hash already exists on the remote")

    # pull
    pull_parser = subparsers.add_parser('pull', parents=[project_parser], help="Pull and apply a stash patch from the SMB share")
    pull_group = pull_parser.add_mutually_exclusive_group()
    pull_group.add_argument('--latest', action='store_true', default=True, help="Pull the most recent patch (default)")
    pull_group.add_argument('--pick', action='store_true', help="Interactively choose which patch to apply")
    pull_group.add_argument('--number', '-n', type=int, help="Pull patch by its list number")
    pull_group.add_argument('--name', help="Pull patch by name substring match")
    pull_group.add_argument('--all', action='store_true', help="Pull all patches as stash entries")
    pull_group.add_argument('--global', dest='global_flag', action='store_true',
        help="Pull all patches for all configured projects")
    pull_parser.add_argument('--apply', action='store_true',
        help="Apply patch to working directory instead of restoring as stash entry")
    pull_parser.add_argument('--force', action='store_true',
        help="Pull even if the patch hash already exists in local stashes")

    # list
    list_parser = subparsers.add_parser('list', parents=[project_parser], help="List available patches on the SMB share")
    list_parser.add_argument('--global', dest='global_flag', action='store_true',
        help="List patches for all configured projects")

    # clean
    clean_parser = subparsers.add_parser('clean', parents=[project_parser], help="Remove old patches from the SMB share")
    clean_parser.add_argument('--global', dest='global_flag', action='store_true',
        help="Clean patches for all configured projects (cleans all by default, combine with --older-than to filter)")
    clean_group = clean_parser.add_mutually_exclusive_group()
    clean_group.add_argument('--all', action='store_true', help="Remove all patches for the current repo")
    clean_group.add_argument('--older-than', type=int, metavar='DAYS', help="Remove patches older than N days")
    clean_group.add_argument('--pick', action='store_true', help="Interactively choose patches to delete")

    # scan
    scan_parser = subparsers.add_parser('scan', help="Scan directories for git repos with stashes")
    scan_parser.add_argument('path', nargs='?', default=None, help="Path to scan (default: root from config)")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        return

    if hasattr(args, 'global_flag') and args.global_flag and args.project:
        parser.error("--global and --project cannot be used together")

    if hasattr(args, 'project') and args.project:
        stash.set_project(args.project)

    if args.command == 'push':
        if hasattr(args, 'global_flag') and args.global_flag:
            stash.push_global(force=args.force, message=args.message)
        elif args.stash_all:
            stash.push_all(message=args.message, force=args.force)
        else:
            stash.push(message=args.message, stash_ref=args.stash, force=args.force, pick=args.pick)
    elif args.command == 'pull':
        if hasattr(args, 'global_flag') and args.global_flag:
            stash.pull_global(force=args.force)
        elif args.all:
            stash.pull_all(force=args.force)
        else:
            stash.pull(latest=not args.pick, pick=args.pick, number=args.number, name=args.name, apply_to_workdir=args.apply, force=args.force)
    elif args.command == 'list':
        if hasattr(args, 'global_flag') and args.global_flag:
            stash.list_global()
        else:
            stash.list_patches()
    elif args.command == 'clean':
        if hasattr(args, 'global_flag') and args.global_flag:
            if args.pick:
                parser.error("--global and --pick cannot be used together")
            stash.clean_global(older_than=args.older_than)
        elif not args.all and args.older_than is None and not args.pick:
            parser.error("clean requires one of: --all, --older-than, --pick, or --global")
        else:
            stash.clean(all_patches=args.all, older_than=args.older_than, pick=args.pick)
    elif args.command == 'scan':
        stash.scan(path=args.path)


if __name__ == '__main__':
    main()