cmd

var RootCmd = &cobra.Command{
	Use:   "chat-agent",
	Short: "Chat Agent CLI tool",
	Long:  `A command line interface for llm agent`,
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := logger.Init(); err != nil {
			return err
		}

		cfg, err := config.LoadConfig(configPath)
		if err != nil {
			return err
		}

		availableChats = cfg.Chats

		chatName, _ := cmd.Flags().GetString("chat")
		debug, _ := cmd.Flags().GetBool("debug")

		if chatName == "" {
			for name, item := range cfg.Chats {
				if item.Default {
					chatName = name
					break
				}
			}
		}
		if chatName == "" {
			return fmt.Errorf("Please specify the chat")
		}
		currentChatName = chatName

		cwd, err := os.Getwd()
		if err != nil {
			cwd = "."
		}
		sessionID := filepath.Base(cwd)
		if sessionID == "" || sessionID == "/" {
			sessionID = "cli-root"
		}

		session, err := chatbot.InitChatSession(cmd.Context(), cfg, chatName, sessionID, debug)
		if err != nil {
			return err
		}
		defer func() {
			if session != nil {
				if err := session.Close(); err != nil {
					fmt.Printf("Error closing session: %v\n", err)
				}
			}
		}()

		placeholder := "Send a message (/h for help)"
		homeDir, err := os.UserHomeDir()
		if err != nil {
			return err
		}
		historyPath := filepath.Join(homeDir, ".chat-agent", "history")
		scanner, err := readline.New(readline.Prompt{
			Prompt:         ">>> ",
			AltPrompt:      "... ",
			Placeholder:    placeholder,
			AltPlaceholder: `Use """ to end multi-line input`,
		}, readline.WithHistoryFile(historyPath))
		if err != nil {
			return err
		}
		scanner.UnsetRawMode()
		fmt.Print(readline.StartBracketedPaste)
		defer fmt.Printf(readline.EndBracketedPaste)

		welcome, _ := cmd.Flags().GetString("welcome")
		fmt.Printf("%s\n", welcome)

		msgCount := session.GetMessageCount()
		if msgCount > 0 {
			fmt.Printf("[Context restored from previous session: %d messages]\n", msgCount)
		}

		persistenceStore := session.PersistenceStore()
		cb := chatbot.NewChatBot(context.WithValue(cmd.Context(), "debug", debug), session.Agent, session.Manager, scanner, persistenceStore)

		// ignore ctrl+c and break llm generate
		var chatCancel context.CancelFunc = func() {}
		sigChan := make(chan os.Signal, 1)
		signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
		go func() {
			for {
				<-sigChan
				chatCancel()
			}
		}()

		chatctx, cancel := context.WithCancel(cmd.Context())
		chatCancel = cancel
		if startAt != "" {
			err = cb.StreamChat(chatctx, startAt)
			if err != nil {
				os.Stderr.WriteString("\nerror: " + err.Error() + "\n")
				return nil
			}
		} else if once != "" {

			err = cb.StreamChat(chatctx, once)
			if err != nil {
				os.Stderr.WriteString("\nerror: " + err.Error() + "\n")
			}
			return nil
		}

		// chat loop
		var sb strings.Builder
		var multiline MultilineState
		for {
			if scanner.Prompt.Placeholder != placeholder {
				scanner.Prompt.Placeholder = placeholder
				scanner.HistoryEnable()
			}
			line, err := scanner.Readline()
			switch {
			case errors.Is(err, io.EOF):
				fmt.Println()
				return nil
			case errors.Is(err, readline.ErrInterrupt):
				if line == "" {
					fmt.Println("\nUse Ctrl + d or /q to exit.")
				}

				scanner.Prompt.UseAlt = false
				sb.Reset()

				continue
			case err != nil:
				return err
			}

			switch {
			case multiline != MultilineNone:

				before, ok := strings.CutSuffix(line, `"""`)
				sb.WriteString(before)
				if !ok {
					fmt.Fprintln(&sb)
					continue
				}
				multiline = MultilineNone
				scanner.Prompt.UseAlt = false
			case strings.HasPrefix(line, `"""`):
				line := strings.TrimPrefix(line, `"""`)
				line, ok := strings.CutSuffix(line, `"""`)
				sb.WriteString(line)
				if !ok {

					fmt.Fprintln(&sb)
					multiline = MultilinePrompt
					scanner.Prompt.UseAlt = true
				}
			case scanner.Pasting:
				fmt.Fprintln(&sb, line)
				continue
			default:
				sb.WriteString(line)
			}

			if sb.Len() > 0 && multiline == MultilineNone {
				chatctx, cancel := context.WithCancel(cmd.Context())
				chatCancel = cancel
				input := strings.TrimSpace(sb.String())

				if !disableLocalCommand && strings.HasPrefix(input, "/t ") {
					localcmd := strings.TrimSpace(strings.TrimPrefix(input, "/t"))
					if err := utils.PopenStream(chatctx, localcmd); err != nil {
						os.Stderr.WriteString("exec local cmd error: " + err.Error() + "\n")
					}
					sb.Reset()
					continue
				}

				if strings.HasPrefix(input, "/s ") {
					targetName := strings.TrimSpace(strings.TrimPrefix(input, "/s"))
					if targetName == "" {
						printChats()
					} else if newSession, err := switchChat(cmd.Context(), cfg, targetName, debug, session, sessionID); err != nil {
						fmt.Printf("Error switching chat: %v\n", err)
					} else {
						session = newSession
						currentChatName = targetName
						persistenceStore := session.PersistenceStore()
						cb = chatbot.NewChatBot(context.WithValue(cmd.Context(), "debug", debug), session.Agent, session.Manager, scanner, persistenceStore)
						fmt.Printf("Switched to chat: %s\n", targetName)
					}
					sb.Reset()
					continue
				}

				switch input {
				case "/help", "/h":
					printHelp()
				case "/clear", "/c":
					session.Clear()
					fmt.Println("The conversation context is cleared")
				case "/redo", "/r":
					lastMsg := session.GetLastUserMessage()
					if lastMsg == "" {
						fmt.Println("No previous user message to redo")
					} else {
						session.RemoveLastRound()
						fmt.Printf("Redoing last message: %s\n", lastMsg)
						chatctx, cancel := context.WithCancel(cmd.Context())
						chatCancel = cancel
						err = cb.StreamChat(chatctx, lastMsg)
						session, cb = handleStreamError(err, cmd.Context(), cfg, debug, session, sessionID, scanner, cb)
					}
				case "/keep", "/k":
					if err := session.OnKeep(); err != nil {
						fmt.Printf("Error executing keep hook: %v\n", err)
					} else {
						fmt.Println("Session keep hook executed successfully")
					}
				case "/history", "/i":
					os.Stdout.WriteString(session.Manager.GetSummary())
					fmt.Println()
				case "/debug-context":
					for _, msg := range session.Manager.GetMessages() {
						fmt.Println(msg)
						fmt.Println("===")
					}
				case "/tools", "/l":
					printTools(session.Tools)
				case "/chat":
					printChats()
				case "/quit", "/exit", "/bye", "/q":
					os.Stdout.WriteString("bye!\n")
					return nil
				default:
					err = cb.StreamChat(chatctx, input)
					session, cb = handleStreamError(err, cmd.Context(), cfg, debug, session, sessionID, scanner, cb)
				}
				sb.Reset()
			}
		}
	},
}