Merge pull request #3378 from Kilo-Org/kevinvandijk/yolo-mode

Introduce full yolo mode

Author: kevinvandijk

packages/types/src/global-settings.ts

@@ -53,6 +53,7 @@ export const globalSettingsSchema = z.object({
 	customCondensingPrompt: z.string().optional(),
 
 	autoApprovalEnabled: z.boolean().optional(),
+	yoloMode: z.boolean().optional(), // kilocode_change
 	alwaysAllowReadOnly: z.boolean().optional(),
 	alwaysAllowReadOnlyOutsideWorkspace: z.boolean().optional(),
 	alwaysAllowWrite: z.boolean().optional(),

src/core/assistant-message/presentAssistantMessage.ts

@@ -311,6 +311,14 @@ export async function presentAssistantMessage(cline: Task) {
 				progressStatus?: ToolProgressStatus,
 				isProtected?: boolean,
 			) => {
+				// kilocode_change start: yolo mode
+
+				const state = await cline.providerRef.deref()?.getState()
+				if (state?.yoloMode) {
+					return true
+				}
+				// kilocode_change end
+
 				const { response, text, images } = await cline.ask(
 					type,
 					partialMessage,

src/core/task/AutoApprovalHandler.ts

@@ -25,6 +25,15 @@ export class AutoApprovalHandler {
 			data: string,
 		) => Promise<{ response: ClineAskResponse; text?: string; images?: string[] }>,
 	): Promise<AutoApprovalResult> {
+		// kilocode_change start: yolo mode
+		if (state?.yoloMode) {
+			return {
+				shouldProceed: true,
+				requiresApproval: false,
+			}
+		}
+		// kilocode_change end
+
 		// Check request count limit
 		const requestResult = await this.checkRequestLimit(state, messages, askForApproval)
 		if (!requestResult.shouldProceed || requestResult.requiresApproval) {

src/core/task/Task.ts

@@ -841,6 +841,41 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			await this.addToClineMessages({ ts: askTs, type: "ask", ask: type, text, isProtected })
 		}
 
+		// kilocode_change start: YOLO mode auto-answer for follow-up questions
+		// Check if this is a follow-up question with suggestions in YOLO mode
+		if (type === "followup" && text && !partial) {
+			try {
+				const state = await this.providerRef.deref()?.getState()
+				if (state?.yoloMode) {
+					// Parse the follow-up JSON to extract suggestions
+					const followUpData = JSON.parse(text)
+					if (
+						followUpData.suggest &&
+						Array.isArray(followUpData.suggest) &&
+						followUpData.suggest.length > 0
+					) {
+						// Auto-select the first suggestion
+						const firstSuggestion = followUpData.suggest[0]
+						const autoAnswer = firstSuggestion.answer || firstSuggestion
+
+						// Immediately set the response as if the user clicked the first suggestion
+						this.handleWebviewAskResponse("messageResponse", autoAnswer, undefined)
+
+						// Return immediately with the auto-selected answer
+						const result = { response: this.askResponse!, text: autoAnswer, images: undefined }
+						this.askResponse = undefined
+						this.askResponseText = undefined
+						this.askResponseImages = undefined
+						return result
+					}
+				}
+			} catch (error) {
+				// If parsing fails or YOLO check fails, continue with normal flow
+				console.warn("Failed to auto-answer follow-up question in YOLO mode:", error)
+			}
+		}
+		// kilocode_change end
+
 		// The state is mutable if the message is complete and the task will
 		// block (via the `pWaitFor`).
 		const isBlocking = !(this.askResponse !== undefined || this.lastMessageTs !== askTs)

src/core/task/__tests__/AutoApprovalHandler.spec.ts

@@ -35,6 +35,56 @@ describe("AutoApprovalHandler", () => {
 			expect(mockAskForApproval).not.toHaveBeenCalled()
 		})
 
+		// kilocode_change start: yolo mode
+		it("should bypass all checks when YOLO mode is enabled", async () => {
+			mockState.yoloMode = true
+			mockState.allowedMaxRequests = 1
+			mockState.allowedMaxCost = 0.01
+
+			const messages: ClineMessage[] = []
+			// Add messages that would normally exceed limits
+			for (let i = 0; i < 10; i++) {
+				messages.push({ type: "say", say: "api_req_started", text: "{}", ts: 1000 + i })
+			}
+
+			mockGetApiMetrics.mockReturnValue({ totalCost: 100.0 })
+
+			const result = await handler.checkAutoApprovalLimits(mockState, messages, mockAskForApproval)
+
+			expect(result.shouldProceed).toBe(true)
+			expect(result.requiresApproval).toBe(false)
+			expect(mockAskForApproval).not.toHaveBeenCalled()
+			expect(mockGetApiMetrics).not.toHaveBeenCalled()
+		})
+
+		it("should bypass request limits when YOLO mode is enabled", async () => {
+			mockState.yoloMode = true
+			mockState.allowedMaxRequests = 0
+
+			const messages: ClineMessage[] = []
+			const result = await handler.checkAutoApprovalLimits(mockState, messages, mockAskForApproval)
+
+			expect(result.shouldProceed).toBe(true)
+			expect(result.requiresApproval).toBe(false)
+			expect(mockAskForApproval).not.toHaveBeenCalled()
+		})
+
+		it("should bypass cost limits when YOLO mode is enabled", async () => {
+			mockState.yoloMode = true
+			mockState.allowedMaxCost = 0
+
+			const messages: ClineMessage[] = []
+			mockGetApiMetrics.mockReturnValue({ totalCost: 1000.0 })
+
+			const result = await handler.checkAutoApprovalLimits(mockState, messages, mockAskForApproval)
+
+			expect(result.shouldProceed).toBe(true)
+			expect(result.requiresApproval).toBe(false)
+			expect(mockAskForApproval).not.toHaveBeenCalled()
+			expect(mockGetApiMetrics).not.toHaveBeenCalled()
+		})
+		// kilocode_change end
+
 		it("should check request limit before cost limit", async () => {
 			mockState.allowedMaxRequests = 1
 			mockState.allowedMaxCost = 10