Support compact and bgcompact options in chat.save

Author: radare

share/mai/prompts/compact.md

@@ -1,47 +1,10 @@
-I'm going to provide you with a conversation history between a user and an AI assistant. Your task is to analyze the entire conversation and provide a concise, focused response that addresses the core of the user's questions and needs.
+Analyze the conversation history and produce a compact saved-context summary.
 
- This response should:
- 1. Synthesize all the important information from the conversation
- 2. Remove repetitive or redundant elements
- 3. Maintain all key insights and valuable content
- 4. Be presented as a single, coherent response
- 5. Focus on providing the most helpful answer to what the user is ultimately trying to accomplish
+Focus on:
 
-This helps create a cleaner, more efficient conversation that delivers the same value in a more concise format.
+* Core goals, decisions, and outcomes.
+* Important technical facts, filenames, commands, settings, and constraints.
+* Open questions, unresolved problems, and next steps.
+* Relevant annotations that help resume the conversation without rereading the full log.
 
-Okay, here are a few prompt options, varying in detail and tone, suitable for a language mode query focused on compacting a conversation log. I've categorized them by increasing complexity:
-
-**1. Basic Prompt (Good starting point):**
-
-"Summarize the following conversation log. Focus on the key topics, decisions, and outcomes. Keep the summary concise – no more than 5-7 sentences."
-
-**2. Slightly More Detailed Prompt:**
-
-"You are a skilled summarizer of conversation logs.  Please read the following conversation log and generate a short summary (approximately 80-100 words) that captures the essence of the conversation.  Highlight the most important points – decisions made, issues discussed, and ultimately, the result of the interaction. Do not include unnecessary details or personal opinions."
-
-**3.  Prompt with Emphasis on Relevance:**
-
-"Analyze the following conversation log. Identify the core topics discussed and the *most relevant* information.  Craft a summary (around 100-150 words) that answers the question: 'What happened in this conversation, and what's the key takeaway?'  Prioritize the information that directly impacts [mention a specific goal, e.g., the next step, a decision, understanding the issue]."
-
-**4.  Advanced Prompt (Best for complex logs):**
-
-"You are an expert assistant tasked with distilling key information from a conversation log.  Read the following log (provide the log here – consider using a JSON format for better structure if possible).  Your goal is to produce a short, impactful summary (approximately 120-150 words) that focuses on:
-*   **Identifying the central themes/topics.**
-*   **Highlighting the crucial decisions and their implications.**
-*   **Pinpointing the ultimate outcome or resolution.**
-*   **Eliminating irrelevant details and tangents.**
-*   **Maintain a clear and professional tone.**  Do not rewrite the conversation, simply extract the essential elements.  Please respond with the summary."
-
----
-
-**Important Considerations & How to Use This Prompt:**
-
-* **Replace `<INPUT>`:** Replace this placeholder with the actual conversation log text.
-* **Context is Key:** The best prompt will depend *entirely* on the nature of your conversation logs.  A very technical log might benefit from a more detailed prompt. A casual conversation could use a simpler prompt.
-* **Iterate:**  Start with a basic prompt and then refine it based on the output you receive. You might need to tweak the emphasis or length instructions.
-* **Format Output:**  Consider how you want the output formatted.  (e.g., bullet points, a short paragraph).
-
-To help me refine the prompt even further, could you tell me:
-
-*   What *type* of conversation logs are you dealing with (e.g., customer support, internal project discussions, sales calls)?
-*   What is the *purpose* of the summary? (e.g., triage, knowledge base, decision-making)?
+Remove repetition, transient chatter, and irrelevant details. Keep the result concise but complete enough to continue the work later.

src/repl/conf.go

@@ -79,7 +79,7 @@ func NewConfigOptions() *ConfigOptions {
 	co.RegisterOption("chat.memory", BooleanOption, "Load memory.txt from ~/.config/mai and include in context", "false")
 	co.RegisterOption("chat.replies", BooleanOption, "Include chat replies when building a single prompt", "true")
 	co.RegisterOption("chat.replythink", BooleanOption, "Include assistant reasoning in stored chat replies", "false")
-	co.RegisterOption("chat.save", StringOption, "Session save behavior on exit: always, never, or prompt", "prompt")
+	co.RegisterOption("chat.save", StringOption, "Session save behavior on exit: always, never, prompt, or compact", "never")
 	co.RegisterOption("chat.system", BooleanOption, "Include chat system messages when building a single prompt", "true")
 	// Number of most recent messages to include when sending to the LLM (0 = all)
 	co.RegisterOption("chat.tail", NumberOption, "Number of most recent messages to include when sending to the LLM (0=all)", "0")
@@ -265,6 +265,12 @@ func (c *ConfigOptions) Set(key, value string) error {
 			}
 			c.values[key] = value
 		default: // StringOption or unknown type
+			if key == "chat.save" {
+				value = strings.ToLower(strings.TrimSpace(value))
+				if !isValidChatSaveMode(value) {
+					return fmt.Errorf("invalid chat.save value: %s (must be one of: always, never, prompt, compact)", value)
+				}
+			}
 			if isReasoningEffortOption(key) {
 				effort, ok := llm.NormalizeReasoningEffort(value)
 				if !ok {
@@ -327,6 +333,20 @@ func (c *ConfigOptions) GetAvailableOptions() []string {
 	return opts
 }
 
+func (c *ConfigOptions) displayValue(key string) string {
+	if c == nil {
+		return "not set"
+	}
+	value := c.Get(key)
+	if value != "" {
+		return value
+	}
+	if info, exists := c.GetOptionInfo(key); exists && info.Default != "" {
+		return fmt.Sprintf("default: %s", info.Default)
+	}
+	return "not set"
+}
+
 // RegisterOptionListener adds a listener function that will be called when an option's value changes
 func (c *ConfigOptions) RegisterOptionListener(key string, callback OptionChangeCallback) {
 	// Create listeners array if it doesn't exist
@@ -375,6 +395,14 @@ func isThinkShowOption(key string) bool {
 	return false
 }
 
+func isValidChatSaveMode(value string) bool {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "always", "never", "prompt", "compact":
+		return true
+	}
+	return false
+}
+
 // GetOptionType returns the type of a given option
 // GetOptionType returns the type of a given option
 func (c *ConfigOptions) GetOptionType(option string) OptionType {
@@ -518,7 +546,8 @@ func (r *REPL) handleSetCommand(args []string) (string, error) {
 		output.WriteString("Available options:\r\n")
 		for _, option := range r.configOptions.GetAvailableOptions() {
 			optType := r.configOptions.GetOptionType(option)
-			fmt.Fprintf(&output, "  %-20s %-15s %s\r\n", option, "("+optType+")", r.configOptions.GetOptionDescription(option))
+			value := r.configOptions.displayValue(option)
+			fmt.Fprintf(&output, "  %-20s = %-15s %-10s %s\r\n", option, value, "("+optType+")", r.configOptions.GetOptionDescription(option))
 		}
 		return output.String(), nil
 	}
@@ -682,6 +711,11 @@ func (r *REPL) handleSetCommand(args []string) (string, error) {
 	case "chat.system":
 		_ = r.configOptions.Set("chat.system", value)
 		return "", nil
+	case "chat.save":
+		if err := r.configOptions.Set("chat.save", value); err != nil {
+			return fmt.Sprintf("Error: %v\r\n", err), nil
+		}
+		return fmt.Sprintf("Set chat.save = %s\r\n", r.configOptions.Get("chat.save")), nil
 	case "chat.format":
 		valLower := strings.ToLower(value)
 		if valLower != "plain" && valLower != "labeled" && valLower != "tokens" {

src/repl/repl.go

@@ -2288,29 +2288,23 @@ func (r *REPL) getCurrentModelForProvider() string {
 	return r.configOptions.Get("ai.model")
 }
 
-// handleCompactCommand processes the /compact command
-// It loads the compact.txt prompt and submits the entire conversation history
-// to the AI, then replaces all messages with the AI's response.
-// The optional extra argument is appended to the compact prompt to let the
-// caller steer the summarization (e.g. "focus on the API changes").
+const compactSaveInstructions = "For saved-session compaction, focus on highlights, decisions, durable facts, open questions, and relevant annotations needed to resume the conversation later."
 
-func (r *REPL) handleCompactCommand(extra ...string) error {
-	// Check if there are enough messages to compact
-	if len(r.messages) < 2 {
-		fmt.Print("Not enough messages to compact. Need at least one exchange.\r\n")
-		return nil
+// compactMessages submits a conversation snapshot to the compact model and
+// returns the compacted replacement history.
+func (r *REPL) compactMessages(ctx context.Context, messages []llm.Message, extra ...string) ([]llm.Message, error) {
+	if len(messages) < 2 {
+		return nil, fmt.Errorf("not enough messages to compact")
 	}
 
-	// Try to find the compact prompt using resolvePromptPath
 	promptPath, err := r.resolvePromptPath("compact")
 	if err != nil {
-		return fmt.Errorf("failed to find compact prompt: %v", err)
+		return nil, fmt.Errorf("failed to find compact prompt: %v", err)
 	}
 
-	// Load the compact prompt from file
 	compactPrompt, err := os.ReadFile(promptPath)
 	if err != nil {
-		return fmt.Errorf("failed to read compact prompt: %v", err)
+		return nil, fmt.Errorf("failed to read compact prompt: %v", err)
 	}
 
 	promptText := string(compactPrompt)
@@ -2322,7 +2316,8 @@ func (r *REPL) handleCompactCommand(extra ...string) error {
 	var conversationText strings.Builder
 	conversationText.WriteString("# Conversation History\n\n")
 
-	for i, msg := range r.messagesForLog() {
+	for i, msg := range messages {
+		msg = r.messageForLog(msg)
 		role := formatRole(msg.Role)
 		fmt.Fprintf(&conversationText, "## %s %d:\n\n%s\n\n", role, i+1, msg.Content)
 	}
@@ -2333,20 +2328,10 @@ func (r *REPL) handleCompactCommand(extra ...string) error {
 		Content: promptText + "\n\n" + conversationText.String(),
 	}
 
-	// Save original messages for recovery if needed
-	originalMessages := r.messages
-
-	// Replace messages with just the compact message
-	r.messages = []llm.Message{compactMessage}
-
-	fmt.Print("Compacting conversation...\r\n")
-
 	// Create client and send message
-	client, err := llm.NewLLMClient(r.buildLLMConfigForTask("compact"), r.ctx)
+	client, err := llm.NewLLMClient(r.buildLLMConfigForTask("compact"), ctx)
 	if err != nil {
-		// Restore original messages on error
-		r.messages = originalMessages
-		return fmt.Errorf("failed to create LLM client: %v", err)
+		return nil, fmt.Errorf("failed to create LLM client: %v", err)
 	}
 
 	// Prepare messages for the API
@@ -2359,20 +2344,36 @@ func (r *REPL) handleCompactCommand(extra ...string) error {
 	// Send the message to the AI (non-streaming mode for this operation)
 	response, err := client.SendMessage(apiMessages, false, nil, nil)
 	if err != nil {
-		// Restore original messages on error
-		r.messages = originalMessages
-		return fmt.Errorf("failed to compact conversation: %v", err)
+		return nil, fmt.Errorf("failed to compact conversation: %v", err)
 	}
 
 	// Create the assistant response message
 	assistantMessage := r.assistantMessageForLog(response)
 
-	// Replace the conversation with just the compact message and response
-	r.messages = []llm.Message{
-		llm.Message{Role: "user", Content: "Please provide a compact response to my questions and needs."},
+	return []llm.Message{
+		{Role: "user", Content: "Please summarize the conversation highlights and relevant annotations."},
 		assistantMessage,
+	}, nil
+}
+
+// handleCompactCommand processes the /chat compact command.
+// It loads the compact prompt and submits the entire conversation history
+// to the AI, then replaces all messages with the compacted response.
+// The optional extra argument is appended to the compact prompt to let the
+// caller steer the summarization.
+func (r *REPL) handleCompactCommand(extra ...string) error {
+	if len(r.messages) < 2 {
+		fmt.Print("Not enough messages to compact. Need at least one exchange.\r\n")
+		return nil
 	}
 
+	snapshot := r.messagesForLog()
+	fmt.Print("Compacting conversation...\r\n")
+	compacted, err := r.compactMessages(r.ctx, snapshot, extra...)
+	if err != nil {
+		return err
+	}
+	r.messages = compacted
 	fmt.Print("Conversation compacted successfully.\r\n")
 
 	return nil

src/repl/repl_chat.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"time"
 
@@ -16,7 +17,7 @@ func registerChatCommands(r *REPL) {
 	// Conversation management commands
 	r.commands["/chat"] = Command{
 		Name:        "/chat",
-		Description: "Manage conversation (save, load, clear, list, log, undo, compact)",
+		Description: "Manage conversation (save, load, clear, list, log, undo, compact, bgcompact)",
 		Handler: func(r *REPL, args []string) (string, error) {
 			return r.handleChatCommand(args)
 		},
@@ -93,6 +94,7 @@ func (r *REPL) handleChatCommand(args []string) (string, error) {
 		output.WriteString("  /chat log         - Display full conversation with preserved formatting\r\n")
 		output.WriteString("  /chat undo [N]    - Remove last or Nth message\r\n")
 		output.WriteString("  /chat compact [text] - Compact conversation; optional text is appended to the compact prompt\r\n")
+		output.WriteString("  /chat bgcompact [text] - Compact conversation in the background\r\n")
 		return output.String(), nil
 	}
 
@@ -142,6 +144,12 @@ func (r *REPL) handleChatCommand(args []string) (string, error) {
 			extra = strings.Join(args[2:], " ")
 		}
 		return "", r.handleCompactCommand(extra)
+	case "bgcompact":
+		extra := ""
+		if len(args) > 2 {
+			extra = strings.Join(args[2:], " ")
+		}
+		return r.startBackgroundCompact(extra)
 	case "memory":
 		// Generate or manage consolidated memory file
 		if len(args) < 3 || args[2] == "generate" {
@@ -170,6 +178,64 @@ func (r *REPL) handleChatCommand(args []string) (string, error) {
 		}
 		return "Usage: /chat memory [generate|show|clear]\r\n", nil
 	default:
-		return fmt.Sprintf("Unknown action: %s\r\nAvailable actions: save, load, sessions, clear, list, log, undo, compact\r\n", action), nil
+		return fmt.Sprintf("Unknown action: %s\r\nAvailable actions: save, load, sessions, clear, list, log, undo, compact, bgcompact\r\n", action), nil
+	}
+}
+
+func (r *REPL) startBackgroundCompact(extra string) (string, error) {
+	r.mu.Lock()
+	if r.bgCompactInProgress {
+		r.mu.Unlock()
+		return "Background compact already running\r\n", nil
+	}
+	r.bgCompactInProgress = true
+	r.mu.Unlock()
+
+	r.requestMu.Lock()
+	rawSnapshot := append([]llm.Message(nil), r.messages...)
+	logSnapshot := r.messagesForLog()
+	r.requestMu.Unlock()
+
+	if len(logSnapshot) < 2 {
+		r.mu.Lock()
+		r.bgCompactInProgress = false
+		r.mu.Unlock()
+		return "Not enough messages to compact. Need at least one exchange.\r\n", nil
+	}
+
+	go r.runBackgroundCompact(rawSnapshot, logSnapshot, extra)
+	return "Background compact started\r\n", nil
+}
+
+func (r *REPL) runBackgroundCompact(rawSnapshot, logSnapshot []llm.Message, extra string) {
+	defer func() {
+		r.mu.Lock()
+		r.bgCompactInProgress = false
+		r.mu.Unlock()
+	}()
+
+	compacted, err := r.compactMessages(context.Background(), logSnapshot, extra)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "\r\nBackground compact failed: %v\r\n", err)
+		return
+	}
+
+	r.requestMu.Lock()
+	defer r.requestMu.Unlock()
+
+	if !messagesHavePrefix(r.messages, rawSnapshot) {
+		fmt.Fprintf(os.Stderr, "\r\nBackground compact skipped: conversation changed before merge\r\n")
+		return
+	}
+
+	suffix := append([]llm.Message(nil), r.messages[len(rawSnapshot):]...)
+	r.messages = append(append([]llm.Message(nil), compacted...), suffix...)
+	fmt.Fprintf(os.Stderr, "\r\nBackground compact completed\r\n")
+}
+
+func messagesHavePrefix(messages, prefix []llm.Message) bool {
+	if len(messages) < len(prefix) {
+		return false
 	}
+	return reflect.DeepEqual(messages[:len(prefix)], prefix)
 }

src/repl/repl_core.go

@@ -398,7 +398,7 @@ func (r *REPL) cleanup() {
 	// Auto-save the chat session if history is enabled and messages exist,
 	// updating the current session or creating a new one if none selected
 	if r.configOptions.GetBool("repl.history") && len(r.messages) > 0 {
-		mode := r.configOptions.Get("chat.save")
+		mode := strings.ToLower(r.configOptions.Get("chat.save"))
 		if mode != "never" {
 			var name string
 			if r.currentSession != "" {
@@ -414,7 +414,13 @@ func (r *REPL) cleanup() {
 				}
 			}
 			fmt.Println("")
-			if err := r.saveSession(name); err != nil {
+			var err error
+			if mode == "compact" {
+				err = r.saveCompactSession(name)
+			} else {
+				err = r.saveSession(name)
+			}
+			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error auto-saving session: %v\n", err)
 			}
 			r.currentSession = name

src/repl/repl_input.go

@@ -580,7 +580,7 @@ func (r *REPL) handleAtFilePathCompletion(line *strings.Builder, prefix, partial
 
 func (r *REPL) handleChatSubcommandCompletion(line *strings.Builder, partialCmd string) {
 	// Available chat subcommands
-	subcommands := []string{"save", "load", "clear", "list", "log", "undo", "compact"}
+	subcommands := []string{"save", "load", "clear", "list", "log", "undo", "compact", "bgcompact"}
 
 	// Filter subcommands by the partial input
 	var filteredCommands []string

src/repl/repl_types.go

@@ -48,7 +48,8 @@ type REPL struct {
 	initialCommand   string             // Command to execute on startup
 	quitAfterActions bool               // Exit after executing initial command
 	// Guard to avoid recursive followup execution
-	followupInProgress bool
+	followupInProgress  bool
+	bgCompactInProgress bool
 	// Callback to stop demo animation when first token is received
 	stopDemoCallback func()
 	wmcpProcess      *exec.Cmd