alias.go

package alias

import (
	"encoding/json"
	"fmt"
	"log/slog"
	"os"
	"os/exec"
	"sort"
	"strings"

	"github.com/homegrew/grew/pkg/config"
	"github.com/homegrew/grew/pkg/context"
	"github.com/homegrew/grew/pkg/safepath"
	"github.com/spf13/cobra"
)

// Command represents the alias command
var Command = &cobra.Command{
	Use:   "alias [subcommand]",
	Short: "Manage command aliases",
	Long: `Manage command aliases. Aliases let you create shortcuts for
frequently used commands.

Subcommands:
  list, ls             List all aliases (default)
  add <name> <command> Create or overwrite an alias
  rm <name>            Remove an alias
  show <name>          Show what an alias expands to
  edit                 Open the alias file in $EDITOR

Examples:
  grew alias add i install
  grew alias add ri reinstall
  grew alias ls
  grew alias rm i
  grew alias show i
  grew alias edit`,
	RunE: func(cmd *cobra.Command, args []string) error {
		slog.Debug("starting alias command execution")
		if len(args) == 0 {
			return aliasList()
		}

		switch args[0] {
		case "list", "ls":
			return aliasList()
		case "add":
			if len(args) < 3 {
				return fmt.Errorf("usage: grew alias add <name> <command>")
			}
			return aliasAdd(args[1], args[2])
		case "rm", "remove", "delete":
			if len(args) < 2 {
				return fmt.Errorf("usage: grew alias rm <name>")
			}
			return aliasRemove(args[1])
		case "show":
			if len(args) < 2 {
				return fmt.Errorf("usage: grew alias show <name>")
			}
			return aliasShow(args[1])
		case "edit":
			return aliasEdit()
		default:
			return fmt.Errorf("unknown alias subcommand: %s\nRun 'grew help alias' for usage", args[0])
		}
	},
}

func init() {
}

// aliases maps alias names to command strings.
type aliases map[string]string

func aliasFile() (string, error) {
	var root string
	ctx, err := context.New()
	if err != nil {
		root = config.Default().Root
	} else {
		root = ctx.Paths.Root
	}
	if err := safepath.SafeAbsolutePath(root); err != nil {
		slog.Warn("invalid alias root path, using default", "path", root, "error", err)
		return "", fmt.Errorf("alias root path invalid: %w", err)
	}
	p, err := safepath.SafeJoin(root, "aliases.json")
	if err != nil {
		slog.Warn("invalid alias file path", "path", p, "error", err)
		return "", fmt.Errorf("alias file path invalid: %w", err)
	}

	slog.Debug("alias file path resolved", "path", p)
	return p, nil
}

func loadAliases() (aliases, error) {
	a := make(aliases)
	f, err := aliasFile()
	if err != nil {
		return nil, err
	}
	data, err := os.ReadFile(f)
	if err != nil {
		slog.Debug("failed to read alias file", "path", f, "error", err)
		if os.IsNotExist(err) {
			slog.Debug("alias file does not exist, starting with empty aliases", "path", f)
			return a, nil
		}
		return nil, fmt.Errorf("read aliases: %w", err)
	}
	if err := json.Unmarshal(data, &a); err != nil {
		slog.Debug("failed to parse alias file", "path", f, "error", err)
		return nil, fmt.Errorf("parse aliases: %w", err)
	}
	return a, nil
}

func saveAliases(a aliases) error {
	f, err := aliasFile()
	if err != nil {
		slog.Warn("failed to get alias file path for saving", "error", err)
		return err
	}
	data, err := json.MarshalIndent(a, "", "  ")
	if err != nil {
		slog.Warn("failed to marshal aliases for saving", "error", err)
		return fmt.Errorf("marshal aliases: %w", err)
	}
	slog.Debug("saving aliases", "path", f)
	return os.WriteFile(f, data, 0644)
}

func aliasList() error {
	a, err := loadAliases()
	if err != nil {
		return err
	}
	if len(a) == 0 {
		fmt.Println("No aliases defined.")
		return nil
	}
	names := make([]string, 0, len(a))
	for name := range a {
		names = append(names, name)
	}
	sort.Strings(names)
	for _, name := range names {
		fmt.Printf("%-20s %s\n", name, a[name])
	}
	return nil
}

func aliasAdd(name, command string) error {
	a, err := loadAliases()
	if err != nil {
		return err
	}
	if old, exists := a[name]; exists {
		slog.Debug("overwriting alias", "name", name, "old", old)
		fmt.Printf("Overwriting alias %q (was: %s)\n", name, old)
	}
	a[name] = command
	if err := saveAliases(a); err != nil {
		return err
	}
	fmt.Printf("Added alias: %s -> %s\n", name, command)
	return nil
}

func aliasRemove(name string) error {
	a, err := loadAliases()
	if err != nil {
		slog.Debug("loaded aliases for removal", "count", len(a))
		return err
	}
	if _, exists := a[name]; !exists {
		slog.Debug("alias does not exist", "name", name)
		return fmt.Errorf("alias %q does not exist", name)
	}
	delete(a, name)
	if err := saveAliases(a); err != nil {
		slog.Warn("failed to save aliases after removal", "error", err)
		return err
	}
	slog.Debug("alias removed", "name", name)
	fmt.Printf("Removed alias: %s\n", name)
	return nil
}

func aliasShow(name string) error {
	a, err := loadAliases()
	if err != nil {
		return err
	}
	cmd, exists := a[name]
	if !exists {
		return fmt.Errorf("alias %q does not exist", name)
	}
	fmt.Printf("%s: %s\n", name, cmd)
	return nil
}

func aliasEdit() error {
	path, err := aliasFile()
	if err != nil {
		return err
	}
	// Ensure file exists
	if _, err := os.Stat(path); os.IsNotExist(err) {
		if err := saveAliases(make(aliases)); err != nil {
			return err
		}
	}
	editor := os.Getenv("EDITOR")
	if editor == "" {
		editor = os.Getenv("VISUAL")
	}
	if editor == "" {
		fmt.Printf("Alias file: %s\n", path)
		slog.Debug("no EDITOR or VISUAL set", "path", path)
		return fmt.Errorf("no EDITOR or VISUAL set; edit %s manually", path)

	}

	// Validate the editor value: reject shell metacharacters and empty components.
	if strings.ContainsAny(editor, "|;&$`\\'\"\n\t") {
		return fmt.Errorf("EDITOR contains invalid characters: %q", editor)
	}

	// Resolve the editor binary via PATH to ensure it exists.
	editorPath, err := exec.LookPath(editor)
	if err != nil {
		return fmt.Errorf("editor %q not found in PATH: %w", editor, err)
	}

	fmt.Printf("Opening %s with %s...\n", path, editor)
	cmd := exec.Command(editorPath, "--", path)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}