"strings"
)
-const (
- // stopCommand is the input line that interrupts the running turn.
- stopCommand = "/stop"
+// terminalResultLines is the most lines of a tool result that the client shows.
+const terminalResultLines = 10
- // resultLines is the most lines of a tool result that the client shows.
- resultLines = 10
-)
+// errTerminalDaemonClosed tells that the daemon closed the connection.
+var errTerminalDaemonClosed = errors.New("the daemon closed the connection")
-// chat runs "onechat chat": the terminal client of the daemon. Each line of
+// terminal runs "onechat chat": the terminal client of the daemon. Each line of
// input is a user message, and the line /stop interrupts the running turn. The
// client shows the replies, the tool calls, and their results as they happen.
// It ends at the end of the input or when the daemon closes the connection.
-func chat(ctx context.Context, in io.Reader, out io.Writer) error {
+func terminal(ctx context.Context, in io.Reader, out io.Writer) error {
dir, err := dataDir()
if err != nil {
return err
return fmt.Errorf(`connect to the daemon (start it with "onechat daemon"): %w`, err)
}
- return chatSession(ctx, conn, in, out)
+ return terminalSession(ctx, conn, in, out)
}
-// errDaemonClosed tells that the daemon closed the connection.
-var errDaemonClosed = errors.New("the daemon closed the connection")
-
-// chatSession runs the client on conn until the input ends, the daemon closes
-// the connection, or ctx ends, and closes conn. A read of the input that waits
-// for a line can stay behind when the daemon closes the connection.
-func chatSession(ctx context.Context, conn net.Conn, in io.Reader, out io.Writer) error {
+// terminalSession runs the client on conn until the input ends, the daemon
+// closes the connection, or ctx ends, and closes conn. A read of the input that
+// waits for a line can stay behind when the daemon closes the connection.
+func terminalSession(ctx context.Context, conn net.Conn, in io.Reader, out io.Writer) error {
sent := make(chan error, 1)
go func() {
- sent <- sendLines(ctx, conn, in)
+ sent <- terminalSendLines(ctx, conn, in)
}()
shown := make(chan error, 1)
go func() {
- shown <- showEvents(conn, out)
+ shown <- terminalShowEvents(conn, out)
}()
var err error
err = errors.Join(err, conn.Close())
<-shown
case err = <-shown:
- err = errors.Join(cmpError(err, errDaemonClosed), conn.Close())
+ err = errors.Join(terminalCmpError(err, errTerminalDaemonClosed), conn.Close())
case <-ctx.Done():
err = conn.Close()
<-shown
return err
}
-// cmpError returns err, or fallback when err is nil.
-func cmpError(err, fallback error) error {
- if err == nil {
- return fallback
- }
-
- return err
-}
-
-// sendLines sends each line of in as a request until the input ends.
-func sendLines(ctx context.Context, conn net.Conn, in io.Reader) error {
+// terminalSendLines sends each line of in as a request until the input ends.
+func terminalSendLines(ctx context.Context, conn net.Conn, in io.Reader) error {
encoder := json.NewEncoder(conn)
scanner := bufio.NewScanner(in)
scanner.Buffer(make([]byte, 64*1024), requestBytes)
return scanner.Err()
}
-// showEvents writes each event from the daemon to out until the connection
-// closes.
-func showEvents(conn net.Conn, out io.Writer) error {
+// terminalShowEvents writes each event from the daemon to out until the
+// connection closes.
+func terminalShowEvents(conn net.Conn, out io.Writer) error {
scanner := bufio.NewScanner(conn)
scanner.Buffer(make([]byte, 64*1024), requestBytes)
for scanner.Scan() {
return fmt.Errorf("decode event: %w", err)
}
- text := eventText(event)
+ text := terminalEventText(event)
if text == "" {
continue
}
return scanner.Err()
}
-// eventText returns the text that the client shows for event, or "" for none.
-// The client shows a user message only from another source, such as telegram,
-// because the user typed the others. A tool result shows its first resultLines
-// lines.
-func eventText(event Event) string {
+// terminalCmpError returns err, or fallback when err is nil.
+func terminalCmpError(err, fallback error) error {
+ if err == nil {
+ return fallback
+ }
+
+ return err
+}
+
+// terminalEventText returns the text that the client shows for event, or "" for
+// none. The client shows a user message only from another source, such as
+// telegram, because the user typed the others. A tool result shows its first
+// terminalResultLines lines.
+func terminalEventText(event Event) string {
switch event.Kind {
case "ready":
return "[connected to " + event.Text + "]"
case "tool":
return "[tool] " + event.Text
case "echo":
- return "[result] " + firstLines(event.Text, resultLines)
+ return "[result] " + terminalFirstLines(event.Text, terminalResultLines)
case "busy":
return "[working]"
case "idle":
}
}
-// firstLines returns the first count lines of text, with the number of the
-// lines left out.
-func firstLines(text string, count int) string {
+// terminalFirstLines returns the first count lines of text, with the number of
+// the lines left out.
+func terminalFirstLines(text string, count int) string {
text = strings.TrimRight(text, "\n")
lines := strings.Split(text, "\n")
if len(lines) <= count {
projects / onechat / blobdiff