feat(intellij): add command history management

zhanba · zhanba · commit 580dfce7e195 · 2025-04-03T22:04:04.000+08:00
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/CommandHistory.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/CommandHistory.kt
@@ -0,0 +1,45 @@
+package com.tabbyml.intellijtabby.inlineChat
+
+import com.intellij.openapi.components.*
+
+class CommandHistoryState: BaseState() {
+    var history by list<String>()
+}
+
+@Service
+@State(
+    name = "com.tabbyml.intellijtabby.inlineChat.CommandHistory", storages = [Storage("intellij-tabby-command-history.xml")]
+)
+class CommandHistory: SimplePersistentStateComponent<CommandHistoryState>(CommandHistoryState()) {
+    private val maxHistorySize = 30
+
+    fun getHistory(): List<String> {
+        return state.history.toList()
+    }
+
+    fun addCommand(command: String) {
+        // Check if the command already exists
+        val existingIndex = state.history.indexOfFirst { it == command }
+
+        // If it exists, remove it (we'll add it to the top)
+        if (existingIndex != -1) {
+            state.history.removeAt(existingIndex)
+        }
+
+        // Add the new command at the beginning
+        state.history.add(0, command)
+
+        // Trim list if it exceeds the maximum size
+        if (state.history.size > maxHistorySize) {
+            state.history = state.history.take(maxHistorySize).toMutableList()
+        }
+    }
+
+    fun deleteCommand(value: String) {
+        state.history.removeAll { it == value }
+    }
+
+    fun clearHistory() {
+        state.history.clear()
+    }
+}
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/InlineChatIntentionAction.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/InlineChatIntentionAction.kt
@@ -21,18 +21,19 @@ import java.awt.event.*
 import javax.swing.*
 import com.intellij.ui.components.IconLabelButton
 import com.intellij.openapi.ui.popup.JBPopupFactory
+import com.intellij.openapi.ui.popup.JBPopupListener
 import com.tabbyml.intellijtabby.lsp.ConnectionService
 import com.tabbyml.intellijtabby.lsp.protocol.ChatEditParams
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.eclipse.lsp4j.Location
+import org.eclipse.lsp4j.Range
 
 class InlineChatIntentionAction : BaseIntentionAction(), DumbAware {
     private var inlay: Inlay<InlineChatInlayRenderer>? = null
     private var inlayRender: InlineChatInlayRenderer? = null
     private var project: Project? = null
-    private var location: Location? = null
     private var editor: Editor? = null
     override fun getFamilyName(): String {
         return "Tabby"
@@ -49,8 +50,8 @@ class InlineChatIntentionAction : BaseIntentionAction(), DumbAware {
         this.project = project
         this.editor = editor
         if (editor != null) {
-            this.location = getCurrentLocation(editor = editor)
-            addInputToEditor(editor = editor, offset = editor.caretModel.offset);
+            inlineChatService.location = getCurrentLocation(editor = editor)
+            addInputToEditor(project, editor, editor.caretModel.offset);
         }
 
         project.messageBus.connect().subscribe(LafManagerListener.TOPIC, LafManagerListener {
@@ -67,9 +68,9 @@ class InlineChatIntentionAction : BaseIntentionAction(), DumbAware {
         return IntentionPreviewInfo.EMPTY
     }
 
-    private fun addInputToEditor(editor: Editor, offset: Int) {
+    private fun addInputToEditor(project: Project, editor: Editor, offset: Int) {
         val inlayModel = editor.inlayModel
-        inlayRender = InlineChatInlayRenderer(editor, this::onClose, this::onInputSubmit)
+        inlayRender = InlineChatInlayRenderer(project, editor, this::onClose, this::onInputSubmit)
         inlay = inlayModel.addBlockElement(offset, true, true, 0, inlayRender!!)
     }
 
@@ -82,18 +83,17 @@ class InlineChatIntentionAction : BaseIntentionAction(), DumbAware {
     private fun onInputSubmit(value: String) {
         chatEdit(command = value)
         editor?.selectionModel?.removeSelection()
+        project?.serviceOrNull<CommandHistory>()?.addCommand(value)
     }
 
     private fun chatEdit(command: String) {
         val scope = CoroutineScope(Dispatchers.IO)
+        val inlineChatService = project?.serviceOrNull<InlineChatService>() ?: return
         scope.launch {
             val server = project?.serviceOrNull<ConnectionService>()?.getServerAsync() ?: return@launch
-            if (location == null) {
-                return@launch
-            }
-            println("chat edit $location")
+            val location = inlineChatService.location ?: return@launch
             val param = ChatEditParams(
-                location = location!!,
+                location = location,
                 command = command
             )
             server.chatFeature.chatEdit(params = param)
@@ -102,12 +102,13 @@ class InlineChatIntentionAction : BaseIntentionAction(), DumbAware {
 }
 
 class InlineChatInlayRenderer(
+    private val project: Project,
     private val editor: Editor,
     private val onClose: () -> Unit,
     private val onSubmit: (value: String) -> Unit
 ) :
     EditorCustomElementRenderer {
-    private val inlineChatComponent = InlineChatComponent(onClose = this::removeComponent, onSubmit = onSubmit)
+    private val inlineChatComponent = InlineChatComponent(project, this::removeComponent, onSubmit)
     private var targetRegion: Rectangle? = null
 
     init {
@@ -169,9 +170,9 @@ class InlineChatInlayRenderer(
     }
 }
 
-class InlineChatComponent(private val onClose: () -> Unit, private val onSubmit: (value: String) -> Unit) : JPanel() {
+class InlineChatComponent(private val project: Project, private val onClose: () -> Unit, private val onSubmit: (value: String) -> Unit) : JPanel() {
     private val closeButton = createCloseButton()
-    private val inlineInput = InlineInputComponent(onSubmit = this::handleSubmit, onCancel = this::handleClose)
+    private val inlineInput = InlineInputComponent(project, this::handleSubmit, this::handleClose)
 
     override fun isOpaque(): Boolean {
         return false;
@@ -223,7 +224,12 @@ class InlineChatComponent(private val onClose: () -> Unit, private val onSubmit:
     }
 }
 
-class InlineInputComponent(private var onSubmit: (value: String) -> Unit, private var onCancel: () -> Unit) : JPanel() {
+data class PickItem(var label: String, var value: String, var icon: Icon, var description: String?, val canDelete: Boolean)
+data class ChatEditFileContext(val referrer: String, val uri: String, val range: Range)
+data class InlineEditCommand(val command: String, val context: List<ChatEditFileContext>?)
+
+class InlineInputComponent(private var project: Project, private var onSubmit: (value: String) -> Unit, private var onCancel: () -> Unit) : JPanel() {
+    private val history: CommandHistory? = project.serviceOrNull<CommandHistory>()
     private val textArea: JTextArea = createTextArea()
     private val submitButton: JLabel = createSubmitButton()
     private val historyButton: JLabel = createHistoryButton()
@@ -320,9 +326,17 @@ class InlineInputComponent(private var onSubmit: (value: String) -> Unit, privat
         return submitButton
     }
 
+    private fun createHistoryButton(): JLabel {
+        val historyButton = IconLabelButton(AllIcons.Actions.SearchWithHistory) { handleOpenHistory() }
+        historyButton.toolTipText = "Select suggested / history Command"
+        historyButton.cursor = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)
+        historyButton.border = BorderFactory.createEmptyBorder(4, 8, 4, 8)
+        return historyButton
+    }
+
     private fun handleOpenHistory() {
-        val historyItems = listOf("History command 1", "History command 2", "/doc")
-        val popup = JBPopupFactory.getInstance().createPopupChooserBuilder(historyItems)
+        val commandItems = getCommandList()
+        val popup = JBPopupFactory.getInstance().createPopupChooserBuilder<PickItem>(commandItems)
             .setRenderer(object : DefaultListCellRenderer() {
                 override fun getListCellRendererComponent(
                     list: JList<*>?,
@@ -331,19 +345,31 @@ class InlineInputComponent(private var onSubmit: (value: String) -> Unit, privat
                     isSelected: Boolean,
                     cellHasFocus: Boolean
                 ): Component {
+                    if (value !is PickItem) {
+                        return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus)
+                    }
                     val panel = JPanel(BorderLayout())
                     panel.preferredSize = Dimension(730, 20)
-
-                    val label = JLabel(value.toString())
+                    val label = JLabel(value.label)
+                    val desc = JLabel(value.description)
                     label.border = BorderFactory.createEmptyBorder(0, 10, 0, 10)
-
-                    val deleteButton = IconLabelButton(AllIcons.Actions.Close) {
-                        // Handle delete action here in a real implementation
+                    panel.add(JLabel(value.icon), BorderLayout.WEST)
+                    val contentPanel = JPanel(BorderLayout())
+                    contentPanel.add(label, BorderLayout.WEST)
+                    desc.foreground = UIUtil.getContextHelpForeground()
+                    contentPanel.add(desc, BorderLayout.CENTER)
+                    contentPanel.isOpaque = false
+                    panel.add(contentPanel, BorderLayout.CENTER)
+                    if (value.canDelete) {
+                        val deleteButton = IconLabelButton(AllIcons.Actions.Close) {
+                            history?.deleteCommand(value.value)
+                            handleOpenHistory()
+                        }
+                        deleteButton.toolTipText = "Delete this command from history"
+//                        deleteButton.cursor =  Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)
+                        deleteButton.border = BorderFactory.createEmptyBorder(0, 5, 0, 5)
+                        panel.add(deleteButton, BorderLayout.EAST)
                     }
-                    deleteButton.border = BorderFactory.createEmptyBorder(0, 5, 0, 5)
-
-                    panel.add(label, BorderLayout.CENTER)
-                    panel.add(deleteButton, BorderLayout.EAST)
 
                     if (isSelected) {
                         panel.background = UIUtil.getListSelectionBackground(true)
@@ -357,18 +383,25 @@ class InlineInputComponent(private var onSubmit: (value: String) -> Unit, privat
                 }
             })
             .setItemChosenCallback { selectedValue ->
-                textArea.text = selectedValue
+                textArea.text = selectedValue.value
             }
             .createPopup()
 
         popup.showUnderneathOf(this)
     }
 
-    private fun createHistoryButton(): JLabel {
-        val historyButton = IconLabelButton(AllIcons.Actions.SearchWithHistory) { handleOpenHistory() }
-        historyButton.toolTipText = "Select predefined / history Command"
-        historyButton.cursor = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)
-        historyButton.border = BorderFactory.createEmptyBorder(4, 8, 4, 8)
-        return historyButton
+    private fun getHistoryCommand(): List<InlineEditCommand> {
+        return history?.getHistory()?.map {
+            InlineEditCommand(it, null)
+        } ?: emptyList()
+    }
+
+    private fun getCommandList(): List<PickItem> {
+        val location = project.serviceOrNull<InlineChatService>()?.location ?: return emptyList()
+        val suggestedItems = getSuggestedCommands(project, location).get()?.map { PickItem(label = it.label, value = it.command, icon = AllIcons.Debugger.ThreadRunning, description = it.command, canDelete = false) } ?: emptyList()
+        val historyItems = getHistoryCommand().filter {historyCommand -> suggestedItems.find { it.value == historyCommand.command.replace("\n", "") } == null }.map {
+            PickItem(label = it.command.replace("\n", ""), value = it.command.replace("\n", ""), icon = AllIcons.Vcs.History, description = null, canDelete = true)
+        }
+        return suggestedItems + historyItems
     }
 }
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/util.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/inlineChat/util.kt
@@ -5,6 +5,8 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.project.Project
 import com.tabbyml.intellijtabby.lsp.ConnectionService
+import com.tabbyml.intellijtabby.lsp.protocol.ChatEditCommand
+import com.tabbyml.intellijtabby.lsp.protocol.ChatEditCommandParams
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -52,4 +54,23 @@ fun getCodeLenses(project: Project, uri: String): CompletableFuture<List<CodeLen
             }
         }
     }
+}
+
+fun getSuggestedCommands(project: Project, location: Location): CompletableFuture<List<ChatEditCommand>?> {
+    val scope = CoroutineScope(Dispatchers.IO)
+    val params = ChatEditCommandParams(location)
+    return CompletableFuture<List<ChatEditCommand>?>().also { future ->
+        scope.launch {
+            try {
+                val server = project.serviceOrNull<ConnectionService>()?.getServerAsync() ?: run {
+                    future.complete(null)
+                    return@launch
+                }
+                val result = server.chatFeature.editCommand(params)
+                future.complete(result.get())
+            } catch (e: Exception) {
+                future.completeExceptionally(e)
+            }
+        }
+    }
 }
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/lsp/protocol/ProtocolData.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/lsp/protocol/ProtocolData.kt
@@ -374,4 +374,8 @@ data class ChatEditFileContext(
 data class ChatEditResolveParams(
   val location: Location,
   var action: String,
-)
+)
+
+data class ChatEditCommandParams(var location: Location)
+
+data class ChatEditCommand(var label: String, var command: String, var source: String = "preset" )
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/lsp/protocol/server/ChatFeature.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/lsp/protocol/server/ChatFeature.kt
@@ -1,10 +1,7 @@
 package com.tabbyml.intellijtabby.lsp.protocol.server
 
 import com.jetbrains.rd.generator.nova.PredefinedType
-import com.tabbyml.intellijtabby.lsp.protocol.ChatEditParams
-import com.tabbyml.intellijtabby.lsp.protocol.ChatEditResolveParams
-import com.tabbyml.intellijtabby.lsp.protocol.GenerateCommitMessageParams
-import com.tabbyml.intellijtabby.lsp.protocol.GenerateCommitMessageResult
+import com.tabbyml.intellijtabby.lsp.protocol.*
 import org.eclipse.lsp4j.jsonrpc.services.JsonRequest
 import org.eclipse.lsp4j.jsonrpc.services.JsonSegment
 import java.util.concurrent.CompletableFuture
@@ -17,6 +14,10 @@ interface ChatFeature {
   @JsonRequest("edit/resolve")
   fun resolveEdit(params: ChatEditResolveParams): CompletableFuture<Boolean>
 
+
+  @JsonRequest("edit/command")
+  fun editCommand(params: ChatEditCommandParams): CompletableFuture<List<ChatEditCommand>?>
+
   @JsonRequest
   fun generateCommitMessage(params: GenerateCommitMessageParams): CompletableFuture<GenerateCommitMessageResult>
 }
diff --git a/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/settings/KeymapSettings.kt b/clients/intellij/src/main/kotlin/com/tabbyml/intellijtabby/settings/KeymapSettings.kt
@@ -82,6 +82,9 @@ class KeymapSettings(private val project: Project) {
       "Tabby.InlineCompletion.AcceptNextWord" to listOf(KeyboardShortcut.fromString("ctrl RIGHT")),
       "Tabby.InlineCompletion.Dismiss" to listOf(KeyboardShortcut.fromString("ESCAPE")),
       "Tabby.Chat.ToggleChatToolWindow" to listOf(KeyboardShortcut.fromString("ctrl L")),
+      "Tabby.InlineChat.Open" to listOf(KeyboardShortcut.fromString("ctrl I")),
+      "Tabby.InlineChat.Resolve.Accept" to listOf(KeyboardShortcut.fromString("ctrl ENTER")),
+      "Tabby.InlineChat.Resolve.Discard" to listOf(KeyboardShortcut.fromString("ESCAPE")),
     )
     private val TABBY_STYLE_KEYMAP_SCHEMA = mapOf(
       "Tabby.InlineCompletion.Trigger" to listOf(
@@ -92,6 +95,9 @@ class KeymapSettings(private val project: Project) {
       "Tabby.InlineCompletion.AcceptNextWord" to listOf(KeyboardShortcut.fromString("ctrl RIGHT")),
       "Tabby.InlineCompletion.Dismiss" to listOf(KeyboardShortcut.fromString("ESCAPE")),
       "Tabby.Chat.ToggleChatToolWindow" to listOf(KeyboardShortcut.fromString("ctrl L")),
+      "Tabby.InlineChat.Open" to listOf(KeyboardShortcut.fromString("ctrl I")),
+      "Tabby.InlineChat.Resolve.Accept" to listOf(KeyboardShortcut.fromString("ctrl ENTER")),
+      "Tabby.InlineChat.Resolve.Discard" to listOf(KeyboardShortcut.fromString("ESCAPE")),
     )
   }
 }
diff --git a/clients/intellij/src/main/resources/META-INF/plugin.xml b/clients/intellij/src/main/resources/META-INF/plugin.xml
@@ -172,7 +172,7 @@
 
         <group id="Tabby.EditorContext" popup="true" text="Tabby">
             <add-to-group group-id="EditorPopupMenu" anchor="last"/>
-            <action id="Tabby.InlineChat" class="com.tabbyml.intellijtabby.inlineChat.InlineChatAction"
+            <action id="Tabby.InlineChat.Open" class="com.tabbyml.intellijtabby.inlineChat.InlineChatAction"
                     text="Open Tabby Inline Chat"
                     description="Open a inline chat widget to chat with Tabby to modify your code.">
                 <keyboard-shortcut first-keystroke="ctrl I" keymap="$default"/>

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,9 @@ class KeymapSettings(private val project: Project) {`
`82`	`82`	`"Tabby.InlineCompletion.AcceptNextWord" to listOf(KeyboardShortcut.fromString("ctrl RIGHT")),`
`83`	`83`	`"Tabby.InlineCompletion.Dismiss" to listOf(KeyboardShortcut.fromString("ESCAPE")),`
`84`	`84`	`"Tabby.Chat.ToggleChatToolWindow" to listOf(KeyboardShortcut.fromString("ctrl L")),`
	`85`	`+ "Tabby.InlineChat.Open" to listOf(KeyboardShortcut.fromString("ctrl I")),`
	`86`	`+ "Tabby.InlineChat.Resolve.Accept" to listOf(KeyboardShortcut.fromString("ctrl ENTER")),`
	`87`	`+ "Tabby.InlineChat.Resolve.Discard" to listOf(KeyboardShortcut.fromString("ESCAPE")),`
`85`	`88`	`)`
`86`	`89`	`private val TABBY_STYLE_KEYMAP_SCHEMA = mapOf(`
`87`	`90`	`"Tabby.InlineCompletion.Trigger" to listOf(`
`@@ -92,6 +95,9 @@ class KeymapSettings(private val project: Project) {`
`92`	`95`	`"Tabby.InlineCompletion.AcceptNextWord" to listOf(KeyboardShortcut.fromString("ctrl RIGHT")),`
`93`	`96`	`"Tabby.InlineCompletion.Dismiss" to listOf(KeyboardShortcut.fromString("ESCAPE")),`
`94`	`97`	`"Tabby.Chat.ToggleChatToolWindow" to listOf(KeyboardShortcut.fromString("ctrl L")),`
	`98`	`+ "Tabby.InlineChat.Open" to listOf(KeyboardShortcut.fromString("ctrl I")),`
	`99`	`+ "Tabby.InlineChat.Resolve.Accept" to listOf(KeyboardShortcut.fromString("ctrl ENTER")),`
	`100`	`+ "Tabby.InlineChat.Resolve.Discard" to listOf(KeyboardShortcut.fromString("ESCAPE")),`
`95`	`101`	`)`
`96`	`102`	`}`
`97`	`103`	`}`