diff --git a/internal/backend/forwarder/compaction.go b/internal/backend/forwarder/compaction.go index c3fd67c..f28220c 100644 --- a/internal/backend/forwarder/compaction.go +++ b/internal/backend/forwarder/compaction.go @@ -77,7 +77,7 @@ func (service *Service) maybeCompactBeforeProvider(stream *ActiveStream, convers if service == nil || stream == nil || conversation == nil { return false, nil } - manualInstruction, manual := parseManualCompactionDirective(stream.LatestUserText) + manualInstruction, manual := streamManualCompactionDirective(stream) plan, err := service.buildCompactionPlan(stream, conversation, compiled, manual, manualInstruction) if err != nil { return false, err @@ -827,7 +827,7 @@ func buildFallbackCompactionSummary(plan *PendingCompaction) string { sections = append(sections, "Compaction note:\n"+truncateCompactionText(plan.HookMessage, 800)) } if strings.TrimSpace(plan.ManualInstruction) != "" { - sections = append(sections, "Manual compact instruction:\n"+truncateCompactionText(plan.ManualInstruction, 800)) + sections = append(sections, "Manual summarize instruction:\n"+truncateCompactionText(plan.ManualInstruction, 800)) } return strings.TrimSpace(truncateCompactionText(strings.Join(sections, "\n\n"), compactionSummaryMaxChars)) } @@ -875,13 +875,62 @@ func (service *Service) resolveCompactionReserveTokens(modelID string) int64 { return compactionAutoReserveTokens } +func parseManualCompactionRequest(userMessage *agentv1.UserMessage) (string, bool) { + if userMessage == nil { + return "", false + } + userText := strings.TrimSpace(userMessage.GetText()) + if instruction, ok := parseManualCompactionDirective(userText); ok { + return instruction, true + } + if userText != "" { + return "", false + } + selectedContext := userMessage.GetSelectedContext() + if selectedContext == nil { + return "", false + } + for _, command := range selectedContext.GetCursorCommands() { + if !isCursorSummarizeCommand(command) { + continue + } + instruction, _ := parseManualCompactionDirective(command.GetContent()) + return instruction, true + } + return "", false +} + +func streamManualCompactionDirective(stream *ActiveStream) (string, bool) { + if stream == nil { + return "", false + } + stream.mu.Lock() + defer stream.mu.Unlock() + if stream.ManualCompaction.Requested { + return strings.TrimSpace(stream.ManualCompaction.Instruction), true + } + return parseManualCompactionDirective(stream.LatestUserText) +} + +func isCursorSummarizeCommand(command *agentv1.SelectedCursorCommand) bool { + if command == nil { + return false + } + if strings.EqualFold(strings.TrimSpace(command.GetName()), "glass-action-summarize") { + return true + } + _, ok := parseManualCompactionDirective(command.GetContent()) + return ok +} + func parseManualCompactionDirective(latestUserText string) (string, bool) { trimmed := strings.TrimSpace(latestUserText) + const directive = "/summarize" switch { - case trimmed == "/compact": + case trimmed == directive: return "", true - case strings.HasPrefix(trimmed, "/compact "): - return strings.TrimSpace(strings.TrimPrefix(trimmed, "/compact")), true + case strings.HasPrefix(trimmed, directive+" "): + return strings.TrimSpace(strings.TrimPrefix(trimmed, directive)), true default: return "", false } diff --git a/internal/backend/forwarder/compaction_test.go b/internal/backend/forwarder/compaction_test.go new file mode 100644 index 0000000..c65131c --- /dev/null +++ b/internal/backend/forwarder/compaction_test.go @@ -0,0 +1,198 @@ +package forwarder + +import ( + "testing" + + "cursor/gen/agentv1" +) + +func TestParseManualCompactionDirectiveSupportsCursorSummarize(t *testing.T) { + tests := []struct { + name string + text string + wantInstruction string + want bool + }{ + {name: "compact removed", text: "/compact", want: false}, + {name: "compact instruction removed", text: "/compact keep deployment details", want: false}, + {name: "summarize", text: "/summarize", want: true}, + {name: "summarize instruction", text: "/summarize keep failing tests", wantInstruction: "keep failing tests", want: true}, + {name: "surrounding whitespace", text: " /summarize ", want: true}, + {name: "similar command", text: "/summarized", want: false}, + {name: "ordinary text", text: "please summarize this file", want: false}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + instruction, ok := parseManualCompactionDirective(test.text) + if ok != test.want || instruction != test.wantInstruction { + t.Fatalf("parseManualCompactionDirective(%q) = (%q, %v), want (%q, %v)", test.text, instruction, ok, test.wantInstruction, test.want) + } + }) + } +} + +func TestParseManualCompactionRequestRecognizesCursorSummarizeCommand(t *testing.T) { + instruction, ok := parseManualCompactionRequest(&agentv1.UserMessage{ + SelectedContext: &agentv1.SelectedContext{ + CursorCommands: []*agentv1.SelectedCursorCommand{ + {Name: "glass-action-summarize", Content: "/summarize"}, + }, + }, + }) + if !ok || instruction != "" { + t.Fatalf("parseManualCompactionRequest() = (%q, %v), want empty instruction and true", instruction, ok) + } +} + +func TestParseManualCompactionRequestIgnoresSummarizeMetadataWhenUserTextIsPresent(t *testing.T) { + instruction, ok := parseManualCompactionRequest(&agentv1.UserMessage{ + Text: "why does /summarize not work?", + SelectedContext: &agentv1.SelectedContext{ + CursorCommands: []*agentv1.SelectedCursorCommand{ + {Name: "glass-action-summarize", Content: "/summarize"}, + }, + }, + }) + if ok || instruction != "" { + t.Fatalf("parseManualCompactionRequest() = (%q, %v), want empty instruction and false", instruction, ok) + } +} + +func TestParseManualCompactionRequestIgnoresOrdinaryCursorCommands(t *testing.T) { + instruction, ok := parseManualCompactionRequest(&agentv1.UserMessage{ + Text: "review this implementation", + SelectedContext: &agentv1.SelectedContext{ + CursorCommands: []*agentv1.SelectedCursorCommand{ + nil, + {Name: "review", Content: "Review the implementation."}, + }, + }, + }) + if ok || instruction != "" { + t.Fatalf("parseManualCompactionRequest() = (%q, %v), want empty instruction and false", instruction, ok) + } +} + +func TestDecodeInboundIntentMapsRunRequestSummarizeActionToManualCompaction(t *testing.T) { + service := &Service{debug: newDebugRecorder("", nil, nil)} + intent, err := service.decodeInboundIntent( + "summarize-request", + newRunRequestMessage(newSummarizeConversationAction()), + "run_request", + ) + if err != nil { + t.Fatalf("decodeInboundIntent() error = %v", err) + } + if intent.Kind != "run" || !intent.StartsRun { + t.Fatalf("decodeInboundIntent() kind = %q, starts_run = %v, want run and true", intent.Kind, intent.StartsRun) + } + if intent.UserMessage != nil { + t.Fatalf("decodeInboundIntent() user_message = %#v, want nil", intent.UserMessage) + } + if !intent.ManualCompaction.Requested || intent.ManualCompaction.Instruction != "" { + t.Fatalf("decodeInboundIntent() manual_compaction = %#v, want requested with empty instruction", intent.ManualCompaction) + } +} + +func TestResolveInboundManualCompactionSupportsStandaloneConversationAction(t *testing.T) { + directive := resolveInboundManualCompaction(&agentv1.AgentClientMessage{ + Message: &agentv1.AgentClientMessage_ConversationAction{ + ConversationAction: newSummarizeConversationAction(), + }, + }, nil) + if !directive.Requested || directive.Instruction != "" { + t.Fatalf("resolveInboundManualCompaction() = %#v, want requested with empty instruction", directive) + } +} + +func TestResolveInboundManualCompactionIgnoresOtherStandaloneActions(t *testing.T) { + directive := resolveInboundManualCompaction(&agentv1.AgentClientMessage{ + Message: &agentv1.AgentClientMessage_ConversationAction{ + ConversationAction: &agentv1.ConversationAction{ + Action: &agentv1.ConversationAction_CancelAction{CancelAction: &agentv1.CancelAction{}}, + }, + }, + }, nil) + if directive.Requested { + t.Fatalf("resolveInboundManualCompaction() = %#v, want not requested", directive) + } +} + +func TestDecodeInboundIntentDoesNotMapOrdinaryRunActionsToManualCompaction(t *testing.T) { + tests := []struct { + name string + text string + }{ + {name: "ordinary message", text: "review this implementation"}, + {name: "compact command removed", text: "/compact"}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + service := &Service{debug: newDebugRecorder("", nil, nil)} + intent, err := service.decodeInboundIntent( + "ordinary-request", + newRunRequestMessage(&agentv1.ConversationAction{ + Action: &agentv1.ConversationAction_UserMessageAction{ + UserMessageAction: &agentv1.UserMessageAction{ + UserMessage: &agentv1.UserMessage{Text: test.text}, + }, + }, + }), + "run_request", + ) + if err != nil { + t.Fatalf("decodeInboundIntent() error = %v", err) + } + if intent.ManualCompaction.Requested { + t.Fatalf("decodeInboundIntent() manual_compaction = %#v, want not requested", intent.ManualCompaction) + } + }) + } +} + +func TestSummarizeConversationActionStartsRun(t *testing.T) { + if !conversationActionStartsRun(newSummarizeConversationAction()) { + t.Fatal("conversationActionStartsRun(summarize) = false, want true") + } + if conversationActionStartsRun(&agentv1.ConversationAction{ + Action: &agentv1.ConversationAction_CancelAction{CancelAction: &agentv1.CancelAction{}}, + }) { + t.Fatal("conversationActionStartsRun(cancel) = true, want false") + } +} + +func TestStreamManualCompactionDirectiveUsesStructuredRequest(t *testing.T) { + stream := &ActiveStream{ + LatestUserText: "visible user text", + ManualCompaction: manualCompactionDirective{ + Requested: true, + Instruction: "keep decisions", + }, + } + instruction, ok := streamManualCompactionDirective(stream) + if !ok || instruction != "keep decisions" { + t.Fatalf("streamManualCompactionDirective() = (%q, %v), want (%q, true)", instruction, ok, "keep decisions") + } +} + +func newRunRequestMessage(action *agentv1.ConversationAction) *agentv1.AgentClientMessage { + conversationID := "test-conversation" + return &agentv1.AgentClientMessage{ + Message: &agentv1.AgentClientMessage_RunRequest{ + RunRequest: &agentv1.AgentRunRequest{ + ConversationId: &conversationID, + Action: action, + }, + }, + } +} + +func newSummarizeConversationAction() *agentv1.ConversationAction { + return &agentv1.ConversationAction{ + Action: &agentv1.ConversationAction_SummarizeAction{ + SummarizeAction: &agentv1.SummarizeAction{}, + }, + } +} diff --git a/internal/backend/forwarder/service.go b/internal/backend/forwarder/service.go index d9c265e..5909c8e 100644 --- a/internal/backend/forwarder/service.go +++ b/internal/backend/forwarder/service.go @@ -672,6 +672,7 @@ func (service *Service) decodeInboundIntent(requestID string, message *agentv1.A default: return InboundIntent{}, fmt.Errorf("unsupported client message kind: %s", clientKind) } + intent.ManualCompaction = resolveInboundManualCompaction(message, intent.UserMessage) return intent, nil } @@ -751,6 +752,7 @@ func (service *Service) handleRunIntent(intent InboundIntent) error { stream.mu.Lock() stream.ThinkingEffort = strings.TrimSpace(intent.ThinkingEffort) stream.SubagentModelOverrides = cloneSubagentModelOverrides(intent.SubagentModelOverrides) + stream.ManualCompaction = intent.ManualCompaction stream.PendingProviderAction = providerActionNone stream.PendingCompaction = nil stream.PendingExecs = make(map[string]runtimecore.PendingExec) @@ -788,6 +790,7 @@ func (service *Service) handleRunIntent(intent InboundIntent) error { "subagent_model_override_count": len(intent.SubagentModelOverrides), "subagent_model_overrides": subagentModelOverrideSummaries(intent.SubagentModelOverrides), "latest_user_text": userMessageText(intent.UserMessage), + "manual_compaction_requested": intent.ManualCompaction.Requested, }) if err := service.publishCheckpoint(intent.RequestID, intent.ConversationID); err != nil { return err @@ -2643,6 +2646,38 @@ func conversationActionIsResume(action *agentv1.ConversationAction) bool { return ok } +func inboundConversationAction(message *agentv1.AgentClientMessage) *agentv1.ConversationAction { + if message == nil { + return nil + } + if action := message.GetConversationAction(); action != nil { + return action + } + if runRequest := message.GetRunRequest(); runRequest != nil { + return runRequest.GetAction() + } + return nil +} + +func conversationActionIsSummarize(action *agentv1.ConversationAction) bool { + if action == nil { + return false + } + _, ok := action.GetAction().(*agentv1.ConversationAction_SummarizeAction) + return ok +} + +func resolveInboundManualCompaction(message *agentv1.AgentClientMessage, userMessage *agentv1.UserMessage) manualCompactionDirective { + instruction, requested := parseManualCompactionRequest(userMessage) + if conversationActionIsSummarize(inboundConversationAction(message)) { + requested = true + } + return manualCompactionDirective{ + Requested: requested, + Instruction: instruction, + } +} + func conversationActionStartsRun(action *agentv1.ConversationAction) bool { if action == nil { return false @@ -2650,6 +2685,7 @@ func conversationActionStartsRun(action *agentv1.ConversationAction) bool { switch action.GetAction().(type) { case *agentv1.ConversationAction_UserMessageAction, *agentv1.ConversationAction_ResumeAction, + *agentv1.ConversationAction_SummarizeAction, *agentv1.ConversationAction_StartPlanAction, *agentv1.ConversationAction_ExecutePlanAction: return true diff --git a/internal/backend/forwarder/types.go b/internal/backend/forwarder/types.go index 4f7111e..c87ef98 100644 --- a/internal/backend/forwarder/types.go +++ b/internal/backend/forwarder/types.go @@ -116,6 +116,11 @@ type StreamSubscriber struct { Signal chan struct{} } +type manualCompactionDirective struct { + Requested bool + Instruction string +} + type ActiveStream struct { mu sync.Mutex @@ -126,6 +131,7 @@ type ActiveStream struct { ModelName string Mode agentv1.AgentMode LatestUserText string + ManualCompaction manualCompactionDirective Status StreamStatus ThinkingEffort string SubagentModelOverrides map[string]runtimecore.SubagentModelOverrideSelection @@ -407,6 +413,7 @@ type InboundIntent struct { HasExplicitMode bool ModeSource ModeSource StartsRun bool + ManualCompaction manualCompactionDirective SubagentTypeName string SubagentModelOverrides map[string]runtimecore.SubagentModelOverrideSelection ConversationState *agentv1.ConversationStateStructure