Merge branch 'Kilo-Org:main' into virtual-quota-provider

Author: ivanarifin

.changeset/forty-laws-argue.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/cli": patch
+---
+
+Improved stability of the approval menu, preventing it from showing when you don't expect it

.changeset/tender-news-sin.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/cli": patch
+---
+
+'Added /clear command'

cli/src/commands/__tests__/clear.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Tests for the /clear command
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest"
+import { clearCommand } from "../clear.js"
+import type { CommandContext } from "../core/types.js"
+
+describe("clearCommand", () => {
+	let mockContext: CommandContext
+
+	beforeEach(() => {
+		mockContext = {
+			input: "/clear",
+			args: [],
+			options: {},
+			sendMessage: vi.fn().mockResolvedValue(undefined),
+			addMessage: vi.fn(),
+			clearMessages: vi.fn(),
+			replaceMessages: vi.fn(),
+			setMessageCutoffTimestamp: vi.fn(),
+			clearTask: vi.fn().mockResolvedValue(undefined),
+			setMode: vi.fn(),
+			exit: vi.fn(),
+			routerModels: null,
+			currentProvider: null,
+			kilocodeDefaultModel: "",
+			updateProviderModel: vi.fn().mockResolvedValue(undefined),
+			refreshRouterModels: vi.fn().mockResolvedValue(undefined),
+			updateProvider: vi.fn().mockResolvedValue(undefined),
+			profileData: null,
+			balanceData: null,
+			profileLoading: false,
+			balanceLoading: false,
+		}
+	})
+
+	describe("command metadata", () => {
+		it("should have correct name", () => {
+			expect(clearCommand.name).toBe("clear")
+		})
+
+		it("should have correct aliases", () => {
+			expect(clearCommand.aliases).toEqual(["c", "cls"])
+		})
+
+		it("should have correct category", () => {
+			expect(clearCommand.category).toBe("system")
+		})
+
+		it("should have correct priority", () => {
+			expect(clearCommand.priority).toBe(8)
+		})
+
+		it("should have description", () => {
+			expect(clearCommand.description).toBeTruthy()
+			expect(clearCommand.description).toContain("display")
+		})
+
+		it("should have usage examples", () => {
+			expect(clearCommand.examples).toHaveLength(3)
+			expect(clearCommand.examples).toContain("/clear")
+			expect(clearCommand.examples).toContain("/c")
+			expect(clearCommand.examples).toContain("/cls")
+		})
+	})
+
+	describe("handler", () => {
+		it("should set message cutoff timestamp", async () => {
+			const beforeTime = Date.now()
+			await clearCommand.handler(mockContext)
+			const afterTime = Date.now()
+
+			expect(mockContext.setMessageCutoffTimestamp).toHaveBeenCalledTimes(1)
+			const timestamp = (mockContext.setMessageCutoffTimestamp as any).mock.calls[0][0]
+			expect(timestamp).toBeGreaterThanOrEqual(beforeTime)
+			expect(timestamp).toBeLessThanOrEqual(afterTime)
+		})
+
+		it("should NOT replace messages", async () => {
+			await clearCommand.handler(mockContext)
+
+			expect(mockContext.replaceMessages).not.toHaveBeenCalled()
+		})
+
+		it("should NOT call clearTask (unlike /new command)", async () => {
+			await clearCommand.handler(mockContext)
+
+			expect(mockContext.clearTask).not.toHaveBeenCalled()
+		})
+
+		it("should NOT call clearMessages", async () => {
+			await clearCommand.handler(mockContext)
+
+			expect(mockContext.clearMessages).not.toHaveBeenCalled()
+		})
+
+		it("should execute without errors", async () => {
+			await expect(clearCommand.handler(mockContext)).resolves.not.toThrow()
+		})
+	})
+
+	describe("comparison with /new command", () => {
+		it("should have different behavior than /new", async () => {
+			// /clear should:
+			// 1. Set cutoff timestamp (hide messages)
+			// 2. NOT replace messages
+			// 3. NOT clear extension task state
+			// 4. NOT write escape sequences to stdout (to avoid Ink conflicts)
+
+			await clearCommand.handler(mockContext)
+
+			// Verify /clear behavior
+			expect(mockContext.setMessageCutoffTimestamp).toHaveBeenCalled()
+			expect(mockContext.replaceMessages).not.toHaveBeenCalled()
+			expect(mockContext.clearTask).not.toHaveBeenCalled()
+		})
+
+		it("should not write directly to stdout to avoid Ink conflicts", async () => {
+			// Mock stdout.write to verify it's not called
+			const stdoutWriteSpy = vi.spyOn(process.stdout, "write")
+
+			await clearCommand.handler(mockContext)
+
+			// Verify stdout.write was NOT called
+			// This prevents yoga-layout crashes when Ink is managing the terminal
+			expect(stdoutWriteSpy).not.toHaveBeenCalled()
+
+			stdoutWriteSpy.mockRestore()
+		})
+	})
+})

cli/src/commands/clear.ts

@@ -0,0 +1,27 @@
+/**
+ * /clear command - Clear the display without affecting extension state
+ */
+
+import type { Command } from "./core/types.js"
+
+export const clearCommand: Command = {
+	name: "clear",
+	aliases: ["c", "cls"],
+	description: "Clear the display without affecting the current task",
+	usage: "/clear",
+	examples: ["/clear", "/c", "/cls"],
+	category: "system",
+	priority: 8,
+	handler: async (context) => {
+		const { setMessageCutoffTimestamp, addMessage } = context
+		const now = Date.now()
+		setMessageCutoffTimestamp(now)
+		// Add Spacer message
+		addMessage({
+			id: `empty-${now + 1}`,
+			type: "empty",
+			content: "",
+			ts: now + 1,
+		})
+	},
+}

cli/src/commands/core/types.ts

@@ -36,6 +36,7 @@ export interface CommandContext {
 	addMessage: (message: any) => void
 	clearMessages: () => void
 	replaceMessages: (messages: any[]) => void
+	setMessageCutoffTimestamp: (timestamp: number) => void
 	clearTask: () => Promise<void>
 	setMode: (mode: string) => void
 	exit: () => void

cli/src/commands/index.ts

@@ -9,6 +9,7 @@ import { commandRegistry } from "./core/registry.js"
 
 import { helpCommand } from "./help.js"
 import { newCommand } from "./new.js"
+import { clearCommand } from "./clear.js"
 import { exitCommand } from "./exit.js"
 import { modeCommand } from "./mode.js"
 import { modelCommand } from "./model.js"
@@ -22,6 +23,7 @@ export function initializeCommands(): void {
 	// Register all commands
 	commandRegistry.register(helpCommand)
 	commandRegistry.register(newCommand)
+	commandRegistry.register(clearCommand)
 	commandRegistry.register(exitCommand)
 	commandRegistry.register(modeCommand)
 	commandRegistry.register(modelCommand)