refactor(printer): precompile templates and drop t() helper

Each Print* method previously re-parsed its template on every call via
template.Must(template.New(...).Funcs(helpers).Parse(...)). Move the six
templates to package-level vars so parsing happens once at init. The t()
helper that selected between successTmpl and errTmpl is no longer
needed; Print and Error reference successTpl / errTpl directly.

Pure refactor — no observable behaviour change.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: takecy

printer/print.go

@@ -44,6 +44,18 @@ const repoErrTmpl = `
   {{ range .Repos }}- {{ . }}
   {{ end }}`
 
+// Templates are parsed once at package init. text/template.Template.Execute is
+// safe for concurrent use, so the same parsed template can be shared across
+// goroutines without re-parsing on every call.
+var (
+	successTpl = template.Must(template.New("success").Funcs(helpers).Parse(successTmpl))
+	errTpl     = template.Must(template.New("err").Funcs(helpers).Parse(errTmpl))
+	cmdTpl     = template.Must(template.New("cmd").Funcs(helpers).Parse(cmdTmpl))
+	msgTpl     = template.Must(template.New("msg").Funcs(helpers).Parse(msgTmpl))
+	msgErrTpl  = template.Must(template.New("msgErr").Funcs(helpers).Parse(msgErrTmpl))
+	repoErrTpl = template.Must(template.New("repoErr").Funcs(helpers).Parse(repoErrTmpl))
+)
+
 // Printer is struct
 type Printer struct {
 	writer    io.Writer
@@ -78,9 +90,7 @@ func (p *Printer) PrintCmd(cmd string, options []string) {
 		Cmd string
 		Ops string
 	}
-	t := template.Must(template.New("item").Funcs(helpers).Parse(cmdTmpl))
-	err := t.Execute(p.writer, cmds{Cmd: cmd, Ops: strings.Join(options, " ")})
-	if err != nil {
+	if err := cmdTpl.Execute(p.writer, cmds{Cmd: cmd, Ops: strings.Join(options, " ")}); err != nil {
 		log.Println(err)
 	}
 }
@@ -90,9 +100,7 @@ func (p *Printer) PrintMsg(msg string) {
 	type message struct {
 		Msg string
 	}
-	t := template.Must(template.New("msg").Funcs(helpers).Parse(msgTmpl))
-	err := t.Execute(p.writer, message{Msg: msg})
-	if err != nil {
+	if err := msgTpl.Execute(p.writer, message{Msg: msg}); err != nil {
 		log.Println(err)
 	}
 }
@@ -102,9 +110,7 @@ func (p *Printer) PrintMsgErr(msg string) {
 	type message struct {
 		Msg string
 	}
-	t := template.Must(template.New("msg").Funcs(helpers).Parse(msgErrTmpl))
-	err := t.Execute(p.writer, message{Msg: msg})
-	if err != nil {
+	if err := msgErrTpl.Execute(p.writer, message{Msg: msg}); err != nil {
 		log.Println(err)
 	}
 }
@@ -115,33 +121,22 @@ func (p *Printer) PrintRepoErr(msg string, repos []string) {
 		Msg   string
 		Repos []string
 	}
-	t := template.Must(template.New("msg").Funcs(helpers).Parse(repoErrTmpl))
-	err := t.Execute(p.writer, message{Msg: msg, Repos: repos})
-	if err != nil {
+	if err := repoErrTpl.Execute(p.writer, message{Msg: msg, Repos: repos}); err != nil {
 		log.Println(err)
 	}
 }
 
 // Print prints result
 func (p *Printer) Print(res Result) {
-	err := t(true).Execute(p.writer, res)
-	if err != nil {
+	if err := successTpl.Execute(p.writer, res); err != nil {
 		log.Println(err)
 	}
 }
 
 // Error prints error
 func (p *Printer) Error(res Result) {
 	res.Msg = res.Err.Error()
-	err := t(false).Execute(p.errWriter, res)
-	if err != nil {
+	if err := errTpl.Execute(p.errWriter, res); err != nil {
 		log.Println(err)
 	}
 }
-
-func t(isSuccess bool) *template.Template {
-	if isSuccess {
-		return template.Must(template.New("item").Funcs(helpers).Parse(successTmpl))
-	}
-	return template.Must(template.New("item").Funcs(helpers).Parse(errTmpl))
-}