// Package shellparse extracts command steps from shell scripts.

package shellparse

import (

"strings"

"mvdan.cc/sh/v3/syntax"

)

// Parse returns one slice per simple command in src, in source order.

// Each is [program] or [program, arg], where arg is the first non-flag

// positional argument.

//

// Some malformed inputs (e.g. trailing unterminated tokens after valid

// semicolon-separated commands) yield partial results alongside a

// non-nil error. Callers that show parsed output to users should treat

// a non-nil err as a signal to fall back to the raw input rather than

// display the partial.

func Parse(src string) ([][]string, error) {

if src == "" {

return nil, nil

}

f, err := syntax.NewParser().Parse(strings.NewReader(src), "")

if f == nil {

return nil, err

}

var out [][]string

syntax.Walk(f, func(node syntax.Node) bool {

call, ok := node.(*syntax.CallExpr)

if !ok || len(call.Args) == 0 {

return true

}

prog := wordLiteral(call.Args[0])

if prog == "" {

return true

}

step := []string{prog}

if arg := firstNonFlagLiteral(call.Args[1:]); arg != "" {

step = append(step, arg)

}

out = append(out, step)

return true

})

return out, err

}

// wordLiteral returns the literal content of w by concatenating the

// literal pieces of its parts. Bare literals, single-quoted strings,

// and double-quoted strings (when the inner parts are all literals)

// contribute their text. Any part involving variable expansion,

// command substitution, or arithmetic returns "" for the whole word

// because we cannot resolve those without executing the shell.

func wordLiteral(w *syntax.Word) string {

if w == nil {

return ""

}

var sb strings.Builder

for _, part := range w.Parts {

switch p := part.(type) {

case *syntax.Lit:

_, _ = sb.WriteString(p.Value)

case *syntax.SglQuoted:

_, _ = sb.WriteString(p.Value)

case *syntax.DblQuoted:

for _, inner := range p.Parts {

lit, ok := inner.(*syntax.Lit)

if !ok {

return ""

}

_, _ = sb.WriteString(lit.Value)

}

default:

return ""

}

}

return sb.String()

}

// firstNonFlagLiteral returns the literal value of the first word in

// ws that does not start with "-", or "" if none qualifies.

//

// Known limitation: no flag-arity knowledge. For programs whose global

// flags take a separate-word value ("git -C path verb", "kubectl -n ns

// verb", "docker --context X verb"), this returns the flag's value as

// the first positional, not the actual verb. Consumers that need the

// verb in those cases need per-program awareness; this function does

// not provide it.

func firstNonFlagLiteral(ws []*syntax.Word) string {

for _, w := range ws {

lit := wordLiteral(w)

if lit == "" || strings.HasPrefix(lit, "-") {

continue

}

return lit

}

return ""

}