dotfiles/zsh/.config/zsh/functions/dev.zsh

#!/bin/zsh

function _package_manager {
  # Set up completion on first call
  if [[ -z "$_package_manager_completion_setup" ]]; then
    compdef _package_manager_completion _package_manager p 2>/dev/null
    _package_manager_completion_setup=1
  fi

  local pkg_manager=""

  if [[ -f bun.lockb ]]; then
    pkg_manager="bun"
  elif [[ -f pnpm-lock.yaml ]]; then
    pkg_manager="pnpm"
  elif [[ -f yarn.lock ]]; then
    pkg_manager="yarn"
  elif [[ -f package-lock.json ]]; then
    pkg_manager="npm"
  else
    pkg_manager="pnpm"
  fi

  if [[ -f package.json ]] && [[ $1 != "run" ]] && [[ $1 != "install" ]] && [[ $1 != "add" ]] && [[ $1 != "remove" ]] && [[ $1 != "i" ]] && [[ $1 != "rm" ]]; then
    if which jq >/dev/null 2>&1 && jq -e ".scripts[\"$1\"] != null" package.json >/dev/null 2>&1; then
      set -- "run" "$@"
    fi
  fi

  if which corepack >/dev/null 2>&1; then
    corepack ${pkg_manager} "$@"
  else
    command ${pkg_manager} "$@"
  fi
}

function vimrc {
  if [[ -z "$XDG_CONFIG_HOME" ]]; then
    echo "Error: XDG_CONFIG_HOME not set" >&2
    return 1
  fi

  local original_dir=$(pwd)
  cd "$XDG_CONFIG_HOME/nvim" || {
    echo "Error: Cannot access $XDG_CONFIG_HOME/nvim" >&2
    return 1
  }
  nvim
  cd "$original_dir"
}

function nixrc {
  if [[ -z "$XDG_CONFIG_HOME" ]]; then
    echo "Error: XDG_CONFIG_HOME not set" >&2
    return 1
  fi

  local original_dir=$(pwd)
  cd "$XDG_CONFIG_HOME/nixos" || {
    echo "Error: Cannot access $XDG_CONFIG_HOME/nixos" >&2
    return 1
  }
  nvim
  cd "$original_dir"
}

function zshrc {
  if [[ -z "$XDG_CONFIG_HOME" ]]; then
    echo "Error: XDG_CONFIG_HOME not set" >&2
    return 1
  fi

  local original_dir=$(pwd)
  cd "$XDG_CONFIG_HOME/zsh" || {
    echo "Error: Cannot access $XDG_CONFIG_HOME/zsh" >&2
    return 1
  }
  nvim
  cd "$original_dir"
}

function sb {
  if [[ "$1" == "-h" || "$1" == "--help" ]]; then
    echo "Usage: sb"
    echo "Launch SilverBullet for notes and open in browser"
    echo "Notes directory: ~/Documents/Notes"
    echo "Port: 42069"
    return 0
  fi

  local notes_dir="$HOME/Documents/Notes"
  local port=42069

  # Check if silverbullet command exists
  if ! command -v silverbullet >/dev/null 2>&1; then
    echo "Error: silverbullet command not found" >&2
    echo "Please install SilverBullet first" >&2
    return 1
  fi

  # Check if notes directory exists
  if [[ ! -d "$notes_dir" ]]; then
    echo "Error: Notes directory not found at $notes_dir" >&2
    return 1
  fi

  # Check if SilverBullet is already running on port 42069
  if lsof -i ":$port" >/dev/null 2>&1 && pgrep -f "silverbullet.*$notes_dir" >/dev/null 2>&1; then
    echo "SilverBullet is already running for $notes_dir on port $port"
    echo "Opening browser at http://127.0.0.1:$port..."
    xdg-open "http://127.0.0.1:$port" 2>/dev/null || {
      echo "Error: Could not open browser. Please open http://127.0.0.1:$port manually" >&2
      return 1
    }
    return 0
  fi

  echo "Launching SilverBullet on port $port..."
  echo "Notes directory: $notes_dir"

  # Launch SilverBullet in the background
  silverbullet --port "$port" "$notes_dir" >/dev/null 2>&1 &
  local sb_pid=$!

  # Wait a moment for SilverBullet to start
  local wait_count=0
  local max_wait=10
  while [[ $wait_count -lt $max_wait ]]; do
    if lsof -i ":$port" >/dev/null 2>&1; then
      break
    fi
    sleep 0.5
    wait_count=$((wait_count + 1))
  done

  # Check if process is still running
  if ! kill -0 "$sb_pid" 2>/dev/null; then
    echo "Error: SilverBullet failed to start" >&2
    return 1
  fi

  # Open browser
  echo "Opening browser at http://127.0.0.1:$port..."
  xdg-open "http://127.0.0.1:$port" 2>/dev/null || {
    echo "Error: Could not open browser. Please open http://127.0.0.1:$port manually" >&2
    return 1
  }

  echo "SilverBullet is running (PID: $sb_pid) on port $port"
}

function yay() {
  # Set up completion on first call
  if [[ -z "$_yay_completion_setup" ]]; then
    compdef _yay_completion yay 2>/dev/null
    _yay_completion_setup=1
  fi

  case "$1" in
    update|"-Syu")
      echo "Updating NixOS system..."
      nh os switch ~/.config/nixos --update --ask
      ;;

    search|"-Ss")
      [ -z "$2" ] && { echo "Usage: yay search <package>"; return 1; }
      echo "Searching for '$2'..."
      nix search nixpkgs "$2" 2>/dev/null || nix-env -qaP | grep -i "$2"
      ;;

    install|"-S")
      [ -z "$2" ] && { echo "Usage: yay install <package>"; return 1; }
      echo "Installing $2..."
      nix-env -iA nixpkgs.$2
      ;;

    remove|"-R")
      [ -z "$2" ] && { echo "Usage: yay remove <package>"; return 1; }
      echo "Removing $2..."
      nix-env -e "$2"
      ;;

    list|"-Q")
      echo "Installed packages:"
      nix-env -q
      ;;

    shell|"-p")
      shift
      if [ $# -eq 0 ]; then
        echo "Usage: yay shell <pkg1> [pkg2 ...]"
        return 1
      fi
      echo "Starting nix-shell with: $*"
      nix-shell -p "$@"
      ;;

    clean|"-Sc")
      echo "Cleaning nix store..."
      nix-collect-garbage
      sudo nix-collect-garbage -d
      ;;

    help|"-h")
      bat -Pp << 'EOF'
yay - Simple NixOS package manager wrapper

Commands:
  yay                    Rebuild system
  yay update             Update system
  yay search <pkg>       Search packages
  yay install <pkg>      Install package (user)
  yay remove <pkg>       Remove package
  yay list               List installed packages
  yay shell <pkg...>     Start nix-shell with packages
  yay clean              Clean package cache
  yay help               Show this help

Note: For system packages, edit ~/.config/nixos/configuration.nix
EOF
      ;;

    "")
      echo "Rebuilding NixOS system..."
      nh os switch ~/.config/nixos --ask --no-nom
      ;;

    *)
      if [[ ! "$1" =~ ^- ]]; then
        echo "Installing '$1'..."
        nix-env -iA nixpkgs.$1
      else
        echo "Unknown option: $1"
        echo "Run 'yay help' for available commands"
        return 1
      fi
      ;;
  esac
}

_package_manager_completion() {
  local -a commands
  commands=(
    'run:Run npm script'
    'install:Install dependencies'
    'add:Add dependency'
    'remove:Remove dependency'
    'dev:Start dev server'
    'build:Build project'
    'test:Run tests'
    'lint:Run linter'
  )
  _describe 'package manager commands' commands
}

_yay_completion() {
  local -a opts
  opts=(
    '-Syyu:Update system'
    '-Syu:Update system'
    '-Ss:Search packages'
    '-S:Install system-wide'
    '-R:Remove package'
    '-Q:List installed'
    '-Si:Package info'
    '-Sc:Clean cache'
    '-p:Open nix-shell with packages'
    'help:Show help'
    'install:Install to user env'
    'remove:Remove from user env'
    'list:List installed packages'
    'clean:Clean nix store'
    'shell:Start nix-shell with packages'
  )
  _describe 'yay commands' opts
}

# Completion functions are set up when functions are first called