gitlink-cli/cmd/interactive/executor.go

package interactive

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"sort"
	"strings"

	"github.com/gitlink-org/gitlink-cli/shortcuts/common"
)

// Executor runs shortcut commands and captures their stdout output.
type Executor struct{}

// Execute runs the given shortcut with the provided arguments, capturing
// anything written to os.Stdout during execution and returning it as a string.
func (e *Executor) Execute(s *common.Shortcut, args map[string]string) (string, error) {
	// Save original stdout
	oldStdout := os.Stdout

	// Create a pipe: writes go to w, reads come from r
	r, w, err := os.Pipe()
	if err != nil {
		return "", fmt.Errorf("failed to create pipe: %w", err)
	}

	// Redirect stdout to the write end of the pipe
	os.Stdout = w

	// Channel to signal that the goroutine has finished reading
	done := make(chan struct{})
	var buf bytes.Buffer

	// Read from the pipe in a goroutine so that writes don't block
	go func() {
		io.Copy(&buf, r)
		close(done)
	}()

	// Execute the shortcut's Run function
	runErr := s.Run(&common.RuntimeContext{Args: args})

	// Close the writer to signal EOF to the reader goroutine
	w.Close()

	// Wait for the goroutine to finish reading
	<-done

	// Restore original stdout
	os.Stdout = oldStdout

	return buf.String(), runErr
}

// parseDirectCommand parses a direct command string like "issue +list --state open"
// into its components: group, cmd (without +), flagStr, and whether parsing succeeded.
func parseDirectCommand(input string) (group, cmd, flagStr string, ok bool) {
	input = strings.TrimSpace(input)
	if input == "" {
		return "", "", "", false
	}

	parts := strings.Fields(input)
	if len(parts) < 2 {
		return "", "", "", false
	}

	group = parts[0]
	rawCmd := parts[1]

	if !strings.HasPrefix(rawCmd, "+") {
		return "", "", "", false
	}
	cmd = strings.TrimPrefix(rawCmd, "+")

	if len(parts) > 2 {
		flagStr = strings.Join(parts[2:], " ")
	}

	return group, cmd, flagStr, true
}

// parseFlagString parses a flag string like "--title hello -n 42" into a map.
// shortMap is used to expand short flag names to their long equivalents.
func parseFlagString(flagStr string, shortMap map[string]string) map[string]string {
	result := make(map[string]string)

	if flagStr == "" {
		return result
	}

	parts := strings.Fields(flagStr)

	for i := 0; i < len(parts); i++ {
		part := parts[i]

		if strings.HasPrefix(part, "--") {
			// Long flag
			flagPart := strings.TrimPrefix(part, "--")

			if strings.Contains(flagPart, "=") {
				// --flag=value format
				kv := strings.SplitN(flagPart, "=", 2)
				result[kv[0]] = kv[1]
			} else if i+1 < len(parts) && !strings.HasPrefix(parts[i+1], "-") {
				// --flag value format
				result[flagPart] = parts[i+1]
				i++
			} else {
				// --flag without value (boolean-like)
				result[flagPart] = "true"
			}
		} else if strings.HasPrefix(part, "-") && len(part) > 1 {
			// Short flag
			shortName := strings.TrimPrefix(part, "-")

			// Expand short name to long name if mapping exists
			longName := shortName
			if mapped, ok := shortMap[shortName]; ok {
				longName = mapped
			}

			if i+1 < len(parts) && !strings.HasPrefix(parts[i+1], "-") {
				result[longName] = parts[i+1]
				i++
			} else {
				result[longName] = "true"
			}
		}
	}

	return result
}

// findShortcut looks up a shortcut by group and command name in the registry.
func findShortcut(all map[string][]*common.Shortcut, group, cmd string) (*common.Shortcut, bool) {
	shortcuts, ok := all[group]
	if !ok {
		return nil, false
	}

	for _, s := range shortcuts {
		if s.Name == cmd {
			return s, true
		}
	}

	return nil, false
}

// buildShortMap creates a mapping from short flag names to long flag names.
func buildShortMap(s *common.Shortcut) map[string]string {
	m := make(map[string]string)
	for _, f := range s.Flags {
		if f.Short != "" {
			m[f.Short] = f.Name
		}
	}
	return m
}

// missingRequiredFlags returns the names (with -- prefix) of flags that are
// marked as required but not present in args.
func missingRequiredFlags(s *common.Shortcut, args map[string]string) []string {
	var missing []string
	for _, f := range s.Flags {
		if f.Required {
			if _, ok := args[f.Name]; !ok {
				missing = append(missing, "--"+f.Name)
			}
		}
	}
	return missing
}

// formatCommandDisplay formats a command for display, e.g. "issue +create --title hello --body world".
func formatCommandDisplay(group string, s *common.Shortcut, args map[string]string) string {
	var b strings.Builder
	b.WriteString(group)
	b.WriteString(" +")
	b.WriteString(s.Name)

	// Sort flag names for deterministic output
	keys := make([]string, 0, len(args))
	for k := range args {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, k := range keys {
		b.WriteString(" --")
		b.WriteString(k)
		b.WriteString(" ")
		b.WriteString(args[k])
	}

	return b.String()
}