test message

Author: Patel230

cmd/iterate/repl.go

@@ -131,19 +131,40 @@ func replHooks() iteragent.AgentHooks {
 	}
 }
 
+// ctrlCExitCh is closed when the user presses Ctrl+C while idle (no active request).
+// The REPL loop listens on this channel to exit cleanly.
+var ctrlCExitCh = make(chan struct{}, 1)
+
 // initREPL loads config, applies theme, sets up signal handling and runtime state.
 func setupSigintHandler() {
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT)
 	go func() {
+		var lastIdle time.Time
 		for range sigCh {
 			if sess.RequestCancel != nil {
+				// Active request — cancel it.
 				sess.RequestCancel()
-				// Snapshot colors under read lock — applyTheme writes these from the main goroutine.
 				colorMu.RLock()
 				y, r := colorYellow, colorReset
 				colorMu.RUnlock()
 				fmt.Printf("\r\033[K%s[cancelled]%s\n", y, r)
+				lastIdle = time.Time{} // reset idle timer after cancel
+			} else {
+				// Idle — double-Ctrl+C to exit.
+				now := time.Now()
+				if !lastIdle.IsZero() && now.Sub(lastIdle) < 2*time.Second {
+					select {
+					case ctrlCExitCh <- struct{}{}:
+					default:
+					}
+				} else {
+					lastIdle = now
+					colorMu.RLock()
+					d, r := colorDim, colorReset
+					colorMu.RUnlock()
+					fmt.Printf("\r\033[K%s(press Ctrl+C again to exit)%s\n", d, r)
+				}
 			}
 		}
 	}()
@@ -221,8 +242,20 @@ func runREPL(ctx context.Context, p iteragent.Provider, repoPath string, thinkin
 	}
 
 	for {
+		// Check for double-Ctrl+C exit signal before blocking on ReadInput.
+		select {
+		case <-ctrlCExitCh:
+			return
+		default:
+		}
+
 		line, ok := selector.ReadInput()
 		if !ok {
+			// Check if this was a double-Ctrl+C exit.
+			select {
+			case <-ctrlCExitCh:
+			default:
+			}
 			break
 		}
 		if line == "" {
@@ -495,6 +528,7 @@ func buildCommandContext(repoPath, line string, parts []string, p iteragent.Prov
 			StreamAndPrint: streamAndPrint,
 			RunShell:       runShell,
 			PromptLine:     selector.PromptLine,
+			ReadMultiLine:  readMultiLine,
 			Undo:           performUndo,
 			BuildRepoMap: func(rp string, refresh bool) string {
 				if refresh {
@@ -596,6 +630,26 @@ func buildAtFileIndex(repoPath string) map[string]string {
 	return idx
 }
 
+// readMultiLine reads multi-line input from the user one line at a time.
+// A blank line submits; Ctrl+C cancels. Returns (text, true) or ("", false).
+func readMultiLine() (string, bool) {
+	fmt.Printf("%s  Multi-line mode — press Enter on a blank line to submit, Ctrl+C to cancel%s\n\n",
+		colorDim, colorReset)
+
+	var lines []string
+	for {
+		line, ok := selector.PromptLine("  ···")
+		if !ok {
+			return "", false
+		}
+		if line == "" && len(lines) > 0 {
+			break
+		}
+		lines = append(lines, line)
+	}
+	return strings.Join(lines, "\n"), true
+}
+
 // suggestAtFiles scans the prompt for words that match repo filenames without
 // an @-prefix already present, and prints a one-line dim hint.
 func suggestAtFiles(prompt, repoPath string) {

internal/commands/session.go

@@ -146,6 +146,14 @@ func registerSessionUtilityA(r *Registry) {
 		Category:    "session",
 		Handler:     cmdPair,
 	})
+
+	r.Register(Command{
+		Name:        "/trim",
+		Aliases:     []string{},
+		Description: "keep last N message pairs in context: /trim [n]",
+		Category:    "session",
+		Handler:     cmdTrim,
+	})
 }
 
 func registerSessionUtilityB(r *Registry) {
@@ -427,11 +435,56 @@ func cmdMulti(ctx Context) Result {
 		return Result{Handled: true}
 	}
 	if ctx.REPL.StreamAndPrint != nil {
-		ctx.REPL.StreamAndPrint(nil, ctx.Agent, text, ctx.RepoPath)
+		ctx.REPL.StreamAndPrint(context.Background(), ctx.Agent, text, ctx.RepoPath)
 	}
 	return Result{Handled: true}
 }
 
+// cmdTrim keeps the last N user+assistant message pairs, dropping older turns.
+// Unlike /compact-hard (which works in raw message count), /trim works in
+// conversation turns: each turn is one user message + one assistant reply.
+func cmdTrim(ctx Context) Result {
+	if ctx.Agent == nil {
+		PrintError("agent not available")
+		return Result{Handled: true}
+	}
+
+	turns := 5 // default: keep last 5 turns
+	if ctx.HasArg(1) {
+		if v, err := strconv.Atoi(ctx.Arg(1)); err == nil && v > 0 {
+			turns = v
+		} else {
+			fmt.Println("Usage: /trim [n]  — keep last n conversation turns (default 5)")
+			return Result{Handled: true}
+		}
+	}
+
+	msgs := ctx.Agent.Messages
+	if len(msgs) == 0 {
+		fmt.Println("No messages in context.")
+		return Result{Handled: true}
+	}
+
+	// Count conversation turns from the end (each user+assistant pair = 1 turn).
+	keep := turns * 2 // approximate: 2 messages per turn
+	if keep >= len(msgs) {
+		fmt.Printf("Context already has ≤%d turns (%d messages).\n", turns, len(msgs))
+		return Result{Handled: true}
+	}
+
+	// Align to a user-message boundary so we always start on a user turn.
+	startIdx := len(msgs) - keep
+	for startIdx > 0 && msgs[startIdx].Role != "user" {
+		startIdx++
+	}
+
+	before := len(msgs)
+	ctx.Agent.Messages = msgs[startIdx:]
+	fmt.Printf("%s✓ trimmed: %d → %d messages (%d turns kept)%s\n\n",
+		ColorLime, before, len(ctx.Agent.Messages), turns, ColorReset)
+	return Result{Handled: true}
+}
+
 func cmdCompactHard(ctx Context) Result {
 	if ctx.Agent == nil {
 		PrintError("agent not available")