main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strings"
)

const defaultStorageFile = ".mem.json"

type Store map[string]string

// overridden in tests
var getStorePath = defaultGetStorePath

func defaultGetStorePath() string {
	home, err := os.UserHomeDir()
	if err != nil {
		fmt.Fprintln(os.Stderr, "cannot find home dir:", err)
		os.Exit(1)
	}
	return filepath.Join(home, defaultStorageFile)
}

func load() Store {
	data, err := os.ReadFile(getStorePath())
	if os.IsNotExist(err) {
		return Store{}
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, "read store:", err)
		os.Exit(1)
	}
	var s Store
	if err := json.Unmarshal(data, &s); err != nil {
		fmt.Fprintln(os.Stderr, "parse store:", err)
		os.Exit(1)
	}
	return s
}

func save(s Store) {
	data, err := json.MarshalIndent(s, "", "  ")
	if err != nil {
		fmt.Fprintln(os.Stderr, "marshal store:", err)
		os.Exit(1)
	}
	if err := os.WriteFile(getStorePath(), data, 0600); err != nil {
		fmt.Fprintln(os.Stderr, "write store:", err)
		os.Exit(1)
	}
}

func cmdAdd(name, command string) {
	s := load()
	if _, exists := s[name]; exists {
		fmt.Printf("overwrite %q? (y/N): ", name)
		var ans string
		fmt.Scanln(&ans)
		if strings.ToLower(ans) != "y" {
			fmt.Println("aborted")
			return
		}
	}
	s[name] = command
	save(s)
	fmt.Printf("saved %q\n", name)
}

func cmdRun(name string, extraArgs []string) {
	s := load()
	command, ok := s[name]
	if !ok {
		fmt.Fprintf(os.Stderr, "no command named %q\n", name)
		os.Exit(1)
	}
	if len(extraArgs) > 0 {
		command = command + " " + strings.Join(extraArgs, " ")
	}
	fmt.Printf("$ %s\n", command)
	shell := os.Getenv("SHELL")
	if shell == "" {
		shell = "sh"
	}
	cmd := exec.Command(shell, "-i", "-c", command)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		if exitErr, ok := err.(*exec.ExitError); ok {
			os.Exit(exitErr.ExitCode())
		}
		fmt.Fprintln(os.Stderr, "run error:", err)
		os.Exit(1)
	}
}

func cmdList() {
	s := load()
	if len(s) == 0 {
		fmt.Println("no saved commands")
		return
	}
	names := make([]string, 0, len(s))
	for n := range s {
		names = append(names, n)
	}
	sort.Strings(names)
	maxLen := 0
	for _, n := range names {
		if len(n) > maxLen {
			maxLen = len(n)
		}
	}
	for _, n := range names {
		fmt.Printf("  %-*s  %s\n", maxLen, n, s[n])
	}
}

func cmdDelete(name string) {
	s := load()
	if _, ok := s[name]; !ok {
		fmt.Fprintf(os.Stderr, "no command named %q\n", name)
		os.Exit(1)
	}
	delete(s, name)
	save(s)
	fmt.Printf("deleted %q\n", name)
}

func cmdShow(name string) {
	s := load()
	command, ok := s[name]
	if !ok {
		fmt.Fprintf(os.Stderr, "no command named %q\n", name)
		os.Exit(1)
	}
	fmt.Println(command)
}

func usage() {
	fmt.Print(`mem - save and run terminal commands by name

Usage:
  mem [flags] <subcommand> [args]

Flags:
  -local          use store in current directory instead of home
  -file <name>    store filename (default ".mem.json")

Subcommands:
  add <name> <command>   save a command
  run <name> [args...]   run a saved command (extra args appended)
  list                   list all saved commands
  show <name>            print the raw command
  delete <name>          delete a saved command

Default store: ~/.mem.json
Local store:   ./.mem.json  (with -local)
`)
}

func main() {
	var local bool
	var file string
	flag.BoolVar(&local, "local", false, "use store in current directory")
	flag.StringVar(&file, "file", defaultStorageFile, "store filename")
	flag.Usage = usage
	flag.Parse()

	if local {
		getStorePath = func() string {
			dir, err := os.Getwd()
			if err != nil {
				fmt.Fprintln(os.Stderr, "cannot get working dir:", err)
				os.Exit(1)
			}
			return filepath.Join(dir, file)
		}
	} else if file != defaultStorageFile {
		getStorePath = func() string {
			home, err := os.UserHomeDir()
			if err != nil {
				fmt.Fprintln(os.Stderr, "cannot find home dir:", err)
				os.Exit(1)
			}
			return filepath.Join(home, file)
		}
	}

	args := flag.Args()
	if len(args) < 1 {
		usage()
		os.Exit(0)
	}

	switch args[0] {
	case "add":
		if len(args) < 3 {
			fmt.Fprintln(os.Stderr, "usage: mem add <name> <command>")
			os.Exit(1)
		}
		cmdAdd(args[1], strings.Join(args[2:], " "))
	case "run":
		if len(args) < 2 {
			fmt.Fprintln(os.Stderr, "usage: mem run <name> [args...]")
			os.Exit(1)
		}
		cmdRun(args[1], args[2:])
	case "list", "ls":
		cmdList()
	case "show":
		if len(args) < 2 {
			fmt.Fprintln(os.Stderr, "usage: mem show <name>")
			os.Exit(1)
		}
		cmdShow(args[1])
	case "delete", "rm":
		if len(args) < 2 {
			fmt.Fprintln(os.Stderr, "usage: mem delete <name>")
			os.Exit(1)
		}
		cmdDelete(args[1])
	default:
		fmt.Fprintf(os.Stderr, "unknown subcommand: %s\n", args[0])
		usage()
		os.Exit(1)
	}
}