Snow CLI v0.7.27

- Compatible with .agents/skills/ directory

- Expose all request scheme configuration to StatusLine

- Optimize ace-file-outline tool

VSCode Extension v0.4.24

- Support code completion and Tab&Tab AI cross-file suggestions

JetBrains Plugin v0.4.22

- Support code completion and Tab&Tab AI cross-file suggestions

Author: MayDay-wpf

.github/workflows/build_jetbrains.yml

@@ -79,7 +79,7 @@ jobs:
 
             ### What's New
 
-            - Add AI-generated git commit message feature
+            - Supports code completion and Tab&Tab AI cross-file suggestions
 
             ### Usage
 

.github/workflows/build_vsix.yml

@@ -65,7 +65,7 @@ jobs:
 
             ### What's New
 
-            - Fix the problem of not being able to trigger the system ringtone and add relevant settings
+            - Supports code completion and Tab&Tab AI cross-file suggestions
 
             ### Installation
 

.github/workflows/publish.yml

@@ -56,8 +56,9 @@ jobs:
 
             ### What's New
 
-            - Add the /simple command to quickly switch to the simple theme
-            - Add search engine plugins to support more custom search engines
+            - Compatible with the .agents/skills/ directory
+            - Expose all request scheme thinking configurations to StatusLine
+            - Optimize the ace-file-outline tool
             
             ### Installation
             ```bash

JetBrains/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "com.snow"
-version = "0.4.21"
+version = "0.4.22"
 
 repositories {
     mavenCentral()

JetBrains/src/main/kotlin/com/snow/plugin/SnowPluginLifecycle.kt

@@ -2,13 +2,16 @@ package com.snow.plugin
 
 import com.intellij.ide.AppLifecycleListener
 import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.fileEditor.FileEditorManager
+import com.intellij.openapi.fileEditor.FileEditorManagerListener
+import com.intellij.openapi.fileEditor.FileEditorManagerEvent
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.project.ProjectManagerListener
+import com.snow.plugin.completion.SnowCompletionService
+import com.snow.plugin.nextEdit.SnowNextEditEngine
 
-/**
- * Plugin lifecycle listener
- */
 class SnowPluginLifecycle : AppLifecycleListener {
     private val wsManager = SnowWebSocketManager.instance
 
@@ -22,6 +25,13 @@ class SnowPluginLifecycle : AppLifecycleListener {
                 }
             })
 
+        // Eagerly initialize completion service so EditorFactoryListener is registered
+        try {
+            SnowCompletionService.getInstance()
+        } catch (e: Exception) {
+            logger.warn("Failed to initialize completion service", e)
+        }
+
         for (project in ProjectManager.getInstance().openProjects) {
             setupProject(project)
         }
@@ -32,6 +42,7 @@ class SnowPluginLifecycle : AppLifecycleListener {
     }
 
     companion object {
+        private val logger = Logger.getInstance(SnowPluginLifecycle::class.java)
         private val trackers = mutableMapOf<Project, SnowEditorContextTracker>()
         private val handlers = mutableMapOf<Project, SnowMessageHandler>()
 
@@ -53,12 +64,44 @@ class SnowPluginLifecycle : AppLifecycleListener {
                     }
                 }
             }
+
+            initNextEditForProject(project)
         }
 
         fun cleanupProject(project: Project) {
             SnowWebSocketManager.instance.cleanupPortInfoForProject(project)
             trackers.remove(project)
             handlers.remove(project)
         }
+
+        private fun initNextEditForProject(project: Project) {
+            try {
+                val engine = SnowNextEditEngine.getInstance(project)
+                val editorManager = FileEditorManager.getInstance(project)
+
+                // Register all currently open editors
+                for (file in editorManager.openFiles) {
+                    val editors = editorManager.getEditors(file)
+                    for (fileEditor in editors) {
+                        val textEditor = fileEditor as? com.intellij.openapi.fileEditor.TextEditor ?: continue
+                        engine.registerDocument(textEditor.editor)
+                    }
+                }
+
+                // Register future editors on selection change
+                project.messageBus.connect().subscribe(
+                    FileEditorManagerListener.FILE_EDITOR_MANAGER,
+                    object : FileEditorManagerListener {
+                        override fun selectionChanged(event: FileEditorManagerEvent) {
+                            val editor = FileEditorManager.getInstance(project).selectedTextEditor
+                            if (editor != null) engine.registerDocument(editor)
+                        }
+                    },
+                )
+            } catch (e: Exception) {
+                logger.warn("Failed to init Next Edit for project", e)
+            }
+        }
+
     }
 }

JetBrains/src/main/kotlin/com/snow/plugin/actions/GenerateCommitMessageAction.kt

@@ -7,6 +7,7 @@ import com.intellij.openapi.project.DumbAwareAction
 import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.vcs.VcsDataKeys
 import com.snow.plugin.commit.SnowCommitMessageGenerationService
+import com.snow.plugin.config.SnowBundle
 import icons.SnowPluginIcons
 import java.awt.event.InputEvent
 
@@ -29,8 +30,8 @@ class GenerateCommitMessageAction : DumbAwareAction() {
         val additionalRequirements = if (shouldAskForRequirements) {
             val input = Messages.showInputDialog(
                 project,
-                "Add optional requirements for the generated commit message.",
-                "Snow CLI: Commit Message Requirements",
+                SnowBundle.message("commitMessage.requirementsPrompt"),
+                SnowBundle.message("commitMessage.requirementsTitle"),
                 Messages.getQuestionIcon(),
             ) ?: return
             input.trim().ifEmpty { null }
@@ -59,14 +60,14 @@ class GenerateCommitMessageAction : DumbAwareAction() {
 
         e.presentation.isEnabledAndVisible = project != null && hasCommitMessageTarget
         e.presentation.text = if (isGenerating) {
-            "Cancel Commit Message Generation"
+            SnowBundle.message("commitMessage.cancel")
         } else {
-            "Generate Commit Message"
+            SnowBundle.message("commitMessage.generate")
         }
         e.presentation.description = if (isGenerating) {
-            "Cancel Snow CLI commit message generation"
+            SnowBundle.message("commitMessage.cancelDescription")
         } else {
-            "Generate a commit message with Snow CLI AI. Alt/Option-click to add requirements."
+            SnowBundle.message("commitMessage.generateDescription")
         }
     }
 

JetBrains/src/main/kotlin/com/snow/plugin/actions/SnowCompletionActions.kt

@@ -0,0 +1,124 @@
+package com.snow.plugin.actions
+
+import com.intellij.notification.NotificationGroupManager
+import com.intellij.notification.NotificationType
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
+import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.openapi.ui.popup.JBPopupFactory
+import com.snow.plugin.completion.SnowCompletionConfig
+import com.snow.plugin.completion.SnowCompletionService
+import com.snow.plugin.completion.SnowModelFetcher
+import com.snow.plugin.config.SnowBundle
+
+class SnowCompletionToggleAction : DumbAwareAction() {
+    override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+    override fun actionPerformed(e: AnActionEvent) {
+        val config = SnowCompletionConfig.getInstance()
+        config.state.enabled = !config.state.enabled
+        val project = e.project
+        if (project != null) {
+            val msg = if (config.enabled)
+                SnowBundle.message("notification.completion.enabled")
+            else
+                SnowBundle.message("notification.completion.disabled")
+            NotificationGroupManager.getInstance()
+                .getNotificationGroup("Snow CLI")
+                .createNotification(msg, NotificationType.INFORMATION)
+                .notify(project)
+        }
+    }
+
+    override fun update(e: AnActionEvent) {
+        val config = SnowCompletionConfig.getInstance()
+        e.presentation.text = if (config.enabled)
+            SnowBundle.message("notification.completion.disabled").removeSuffix(".")
+        else
+            SnowBundle.message("notification.completion.enabled").removeSuffix(".")
+    }
+}
+
+class SnowCompletionTriggerAction : DumbAwareAction() {
+    override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+    override fun actionPerformed(e: AnActionEvent) {
+        val editor = e.getData(CommonDataKeys.EDITOR) ?: return
+        val config = SnowCompletionConfig.getInstance()
+        if (!config.enabled) {
+            e.project?.let {
+                NotificationGroupManager.getInstance()
+                    .getNotificationGroup("Snow CLI")
+                    .createNotification(SnowBundle.message("notification.completion.disabledHint"), NotificationType.INFORMATION)
+                    .notify(it)
+            }
+            return
+        }
+        SnowCompletionService.getInstance().triggerManual(editor)
+    }
+
+    override fun update(e: AnActionEvent) {
+        e.presentation.isEnabled = e.getData(CommonDataKeys.EDITOR) != null
+    }
+}
+
+class SnowCompletionSelectModelAction : DumbAwareAction() {
+    override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+    override fun actionPerformed(e: AnActionEvent) {
+        val project = e.project ?: return
+        val config = SnowCompletionConfig.getInstance()
+
+        if (config.apiKey.isBlank()) {
+            NotificationGroupManager.getInstance()
+                .getNotificationGroup("Snow CLI")
+                .createNotification(SnowBundle.message("notification.completion.apiKeyMissing"), NotificationType.WARNING)
+                .notify(project)
+            return
+        }
+
+        ProgressManager.getInstance().run(object : Task.Backgroundable(project, SnowBundle.message("modelSelect.fetching"), true) {
+            override fun run(indicator: ProgressIndicator) {
+                try {
+                    val models = SnowModelFetcher.fetchModels(config)
+                    ApplicationManager.getApplication().invokeLater {
+                        if (project.isDisposed) return@invokeLater
+                        val items = models.map { it.id }
+                        if (items.isEmpty()) {
+                            NotificationGroupManager.getInstance()
+                                .getNotificationGroup("Snow CLI")
+                                .createNotification(SnowBundle.message("notification.completion.noModels"), NotificationType.WARNING)
+                                .notify(project)
+                            return@invokeLater
+                        }
+
+                        JBPopupFactory.getInstance()
+                            .createPopupChooserBuilder(items)
+                            .setTitle(SnowBundle.message("modelSelect.title", config.provider))
+                            .setItemChosenCallback { chosen ->
+                                config.state.model = chosen
+                                NotificationGroupManager.getInstance()
+                                    .getNotificationGroup("Snow CLI")
+                                    .createNotification(SnowBundle.message("notification.completion.modelSet", chosen), NotificationType.INFORMATION)
+                                    .notify(project)
+                            }
+                            .createPopup()
+                            .showCenteredInCurrentWindow(project)
+                    }
+                } catch (ex: Exception) {
+                    ApplicationManager.getApplication().invokeLater {
+                        NotificationGroupManager.getInstance()
+                            .getNotificationGroup("Snow CLI")
+                            .createNotification(SnowBundle.message("notification.completion.modelFetchFailed", ex.message ?: ""), NotificationType.ERROR)
+                            .notify(project)
+                    }
+                }
+            }
+        })
+    }
+}

JetBrains/src/main/kotlin/com/snow/plugin/actions/SnowInlineActions.kt

@@ -0,0 +1,70 @@
+package com.snow.plugin.actions
+
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.editor.Caret
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.EditorAction
+import com.intellij.openapi.editor.actionSystem.EditorActionHandler
+import com.intellij.openapi.editor.actionSystem.EditorWriteActionHandler
+import com.intellij.openapi.project.DumbAware
+import com.snow.plugin.completion.SnowCompletionService
+import com.snow.plugin.nextEdit.SnowNextEditEngine
+
+/**
+ * Snow CLI: Accept inline suggestion via TAB.
+ *
+ * Uses [EditorAction] + [isEnabledForCaret] so that when there is no inline
+ * completion / next edit session active, this action will report itself as
+ * disabled and IntelliJ will fall back to the default TAB behavior (smart
+ * indent / dedent / live template / lookup) automatically. This avoids the
+ * previous problem where a globally-replaced Tab handler caused the IDE's
+ * auto-indent to overwrite the just-inserted completion text.
+ */
+class SnowAcceptInlineAction : EditorAction(AcceptHandler()), DumbAware {
+
+    private class AcceptHandler : EditorWriteActionHandler() {
+
+        override fun executeWriteAction(editor: Editor, caret: Caret?, dataContext: DataContext?) {
+            // Inline completion has priority over next edit prediction
+            val completion = SnowCompletionService.getInstance()
+            if (completion.tryAccept(editor)) return
+
+            val project = editor.project ?: return
+            SnowNextEditEngine.getInstance(project).tryAccept(editor)
+        }
+
+        override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean {
+            val completion = SnowCompletionService.getInstance()
+            if (completion.hasCompletion(editor)) return true
+            val project = editor.project ?: return false
+            return SnowNextEditEngine.getInstance(project).hasSessionForEditor(editor)
+        }
+    }
+}
+
+/**
+ * Snow CLI: Dismiss inline suggestion via ESCAPE.
+ *
+ * Same rationale as [SnowAcceptInlineAction] — only intercept when we actually
+ * have something to dismiss, otherwise let the IDE handle ESCAPE normally.
+ */
+class SnowDismissInlineAction : EditorAction(DismissHandler()), DumbAware {
+
+    private class DismissHandler : EditorActionHandler() {
+
+        override fun doExecute(editor: Editor, caret: Caret?, dataContext: DataContext) {
+            val completion = SnowCompletionService.getInstance()
+            if (completion.tryDismiss(editor)) return
+
+            val project = editor.project ?: return
+            SnowNextEditEngine.getInstance(project).tryDismiss(editor)
+        }
+
+        override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean {
+            val completion = SnowCompletionService.getInstance()
+            if (completion.hasCompletion(editor)) return true
+            val project = editor.project ?: return false
+            return SnowNextEditEngine.getInstance(project).hasSessionForEditor(editor)
+        }
+    }
+}