Consider using github.com/peterh/liner

[kortschak]

github.com/peterh/liner is a linenoise-like terminal implementation with features like history, line editing and autocompletion. Adding this to the repl would make it significantly easier to use.

[cosmos72]

It sounds interesting, thanks.

I will have a look as soon as I have a little time

[kortschak]

I have the basics for this that I can donate. I had a look through what you have for reading lines, and I'm not entirely sure how it all works, so it's probably better if I give you the terminal code and you plug that in, unless you want to do it all your self.

[kortschak]

Here is a write up in case you want to pick up what I have (it is derived from code I originally wrote for cayley's REPL, but I am only pasting here what I have free rights to as their author).

Relevant imports:

import (
	"fmt"
	"os"
	"os/signal"

	"github.com/peterh/liner"
)

The initialisation of a terminal is done at the outset of the REPL shell with this snippet that handles history and signals (user warnings can be elided).

term, err := terminal(history)
if os.IsNotExist(err) {
	fmt.Printf("creating new history file: %q\n", history)
}
defer persist(term, history)

This is matched by an appropriate term.Close() when needed, or by the signal handler that is set up in terminal below. Since history is written in the deferred persist call, you can then either return from main or os.Exit and explicitly call persist - the former feels nicer to me.

Then your REPL loop executes the following snippet to get lines. Handle the lines however you want after that. Since you change prompt depending on context, just update prompt variable here for the relevant prompt glyphs for your state.

line, err := term.Prompt(prompt)
if err != nil {
	if err == io.EOF {
		fmt.Println()
		return nil
	}
	return err
}
term.AppendHistory(line)

The machinery:

func terminal(path string) (*liner.State, error) {
	term := liner.NewLiner()

	go func() {
		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt, os.Kill)
		<-c

		err := persist(term, history)
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to properly clean up terminal: %v\n", err)
			os.Exit(1)
		}

		os.Exit(0)
	}()

	f, err := os.Open(path)
	if err != nil {
		return term, err
	}
	defer f.Close()
	_, err = term.ReadHistory(f)
	return term, err
}

func persist(term *liner.State, path string) error {
	f, err := os.OpenFile(path, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
	if err != nil {
		return fmt.Errorf("could not open %q to append history: %v", path, err)
	}
	defer f.Close()
	_, err = term.WriteHistory(f)
	if err != nil {
		return fmt.Errorf("could not write history to %q: %v", path, err)
	}
	return term.Close()
}

[cosmos72]

Sorry for the late answer.
Thanks, I will test it :)

[cosmos72]

Added in commit e224935
Thanks for the patience!