feat(actions): add WhenConditionValidator for dynamic actions

Add WhenConditionValidator to validate conditions for dynamic actions.

- Introduce WhenConditionValidator class
- Implement isAvailable method for condition validation
- Update DynamicShireAction to use WhenConditionValidator

shirelang/src/main/kotlin/com/phodal/shirelang/actions/context/ShireContextActionGroup.kt

@@ -8,6 +8,7 @@ import com.phodal.shirelang.ShireIcons
 import com.phodal.shirelang.actions.ShireRunFileAction
 import com.phodal.shirelang.actions.dynamic.DynamicShireActionConfig
 import com.phodal.shirelang.actions.dynamic.DynamicShireActionService
+import com.phodal.shirelang.actions.validator.WhenConditionValidator
 
 class ShireContextActionGroup : ActionGroup() {
     override fun getActionUpdateThread() = ActionUpdateThread.BGT
@@ -27,6 +28,15 @@ class ShireContextActionGroup : ActionGroup() {
 
 class DynamicShireAction(private val config: DynamicShireActionConfig) :
     DumbAwareAction(config.name, config.hole?.description, ShireIcons.DEFAULT) {
+    override fun update(e: AnActionEvent) {
+        val conditions = config.hole?.when_ ?: return
+        val psiFile = e.getData(CommonDataKeys.PSI_FILE) ?: return
+
+        WhenConditionValidator.isAvailable(conditions, psiFile)?.let {
+            e.presentation.isEnabled = it
+        }
+    }
+
     override fun actionPerformed(e: AnActionEvent) {
         val project = e.project ?: return
         val editor = FileEditorManager.getInstance(project).selectedTextEditor

shirelang/src/main/kotlin/com/phodal/shirelang/actions/intention/IntentionHelperUtil.kt

@@ -8,6 +8,7 @@ import com.phodal.shirecore.ShirelangNotifications
 import com.phodal.shirecore.action.ShireActionLocation
 import com.phodal.shirelang.ShireBundle
 import com.phodal.shirelang.actions.dynamic.DynamicShireActionService
+import com.phodal.shirelang.actions.validator.WhenConditionValidator
 import com.phodal.shirelang.compiler.hobbit.HobbitHole
 
 object IntentionHelperUtil {
@@ -25,12 +26,8 @@ class ShireIntentionAction(private val hobbitHole: HobbitHole?, file: PsiFile) :
     override fun getText(): String = ShireBundle.message("shire.intention")
 
     override fun isAvailable(project: Project, editor: Editor, file: PsiFile): Boolean {
-        // if not set when condition, will always available
         val conditions = hobbitHole?.when_ ?: return true
-
-        /// todo: add execute conditions
-
-        return false
+        return WhenConditionValidator.isAvailable(conditions, file)
     }
 
     override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {

shirelang/src/main/kotlin/com/phodal/shirelang/actions/validator/WhenConditionValidator.kt

@@ -0,0 +1,50 @@
+package com.phodal.shirelang.actions.validator
+
+import com.intellij.psi.PsiFile
+import com.phodal.shirelang.compiler.hobbit.FrontMatterType
+import com.phodal.shirelang.compiler.hobbit.Statement
+
+/**
+ * Intention variable for condition include:
+ * - filePath
+ * - fileName
+ * - fileType
+ * - fileExtension
+ * - fileContent
+ */
+class WhenConditionValidator(
+    private val filePath: String,
+    private val fileName: String,
+    private val fileType: String,
+    private val fileExtension: String,
+    private val fileContent: String
+) {
+
+    fun variables(): Map<String, String> {
+        return mapOf(
+            "filePath" to filePath,
+            "fileName" to fileName,
+            "fileType" to fileType,
+            "fileExtension" to fileExtension,
+            "fileContent" to fileContent
+        )
+    }
+
+    companion object {
+        fun build(file: PsiFile): WhenConditionValidator {
+            return WhenConditionValidator(
+                file.virtualFile.path,
+                file.name,
+                file.fileType.name,
+                file.fileType.defaultExtension,
+                file.text
+            )
+        }
+
+        fun isAvailable(conditions: FrontMatterType.Expression, file: PsiFile): Boolean {
+            val variables: Map<String, String> = build(file).variables()
+            return (conditions.value as Statement).evaluate(variables) == true
+        }
+    }
+
+}

shirelang/src/main/kotlin/com/phodal/shirelang/compiler/hobbit/ShireExpression.kt

@@ -7,6 +7,7 @@ import java.util.regex.Pattern
  */
 abstract class Statement {
     abstract fun evaluate(variables: Map<String, String>): Any
+
     fun display(): String {
         return when (this) {
             is Operator -> this.type.display
@@ -124,6 +125,7 @@ data class Comparison(
     override fun evaluate(variables: Map<String, String>): Boolean {
         val variableValue = when(variable.value) {
             is MethodCall -> variable.value.evaluate(variables)
+            is FrontMatterType.STRING -> variable.value.value
             else -> throw IllegalArgumentException("Invalid variable type: ${variable.value}")
         }