@enjoys/context-engine 1.1.1 → 1.1.2

package/data/implementation/toml.json

@@ -1,7 +1,26 @@
-{
-  "language": "toml",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "toml",
+  "implementationPatterns": [
+    {
+      "pattern": "^\\[([^\\]]+)\\]",
+      "captureGroup": 1,
+      "type": "table",
+      "description": "TOML table implementation"
+    },
+    {
+      "pattern": "^\\[\\[([^\\]]+)\\]\\]",
+      "captureGroup": 1,
+      "type": "array_table",
+      "description": "TOML array of tables implementation"
+    },
+    {
+      "pattern": "^(\\w[\\w.-]*)\\s*=",
+      "captureGroup": 1,
+      "type": "property",
+      "description": "TOML key-value implementation"
+    }
+  ],
+  "keywords": {
+    "note": "TOML is a configuration file format with no interface/implementation constructs."
+  }
+}

package/data/implementation/twig.json

@@ -0,0 +1,46 @@
+{
+  "language": "twig",
+  "implementationPatterns": [
+    {
+      "interface": "Extends",
+      "implementationKeyword": "{% extends",
+      "pattern": "\\{%\\s*extends\\s+['\"]([^'\"]+)['\"]",
+      "description": "Template extending base layout"
+    },
+    {
+      "interface": "Block",
+      "implementationKeyword": "{% block",
+      "pattern": "\\{%\\s*block\\s+(\\w+)",
+      "description": "Block override implementation"
+    },
+    {
+      "interface": "Macro",
+      "implementationKeyword": "{% macro",
+      "pattern": "\\{%\\s*macro\\s+(\\w+)\\s*\\(",
+      "description": "Macro definition"
+    },
+    {
+      "interface": "Embed",
+      "implementationKeyword": "{% embed",
+      "pattern": "\\{%\\s*embed\\s+['\"]([^'\"]+)['\"]",
+      "description": "Embed template with block overrides"
+    },
+    {
+      "interface": "Include",
+      "implementationKeyword": "{% include",
+      "pattern": "\\{%\\s*include\\s+['\"]([^'\"]+)['\"]",
+      "description": "Partial template inclusion"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "{% extends %}",
+      "{% block name %}"
+    ],
+    "implementation": [
+      "{% block %}...{% endblock %}",
+      "{% macro %}",
+      "{% embed %}"
+    ]
+  }
+}

package/data/implementation/vb.json

@@ -0,0 +1,24 @@
+{
+  "language": "vb",
+  "implementationPatterns": [
+    {
+      "name": "Class",
+      "pattern": "^\\s*(?:Public|Private|Friend)?\\s*(?:Partial\\s+)?Class\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "class"
+    },
+    {
+      "name": "Module",
+      "pattern": "^\\s*Module\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "module"
+    },
+    {
+      "name": "Sub",
+      "pattern": "^\\s*(?:Public|Private|Protected|Friend)?\\s*(?:Shared\\s+)?Sub\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "method"
+    }
+  ],
+  "keywords": {}
+}

package/data/implementation/wgsl.json

@@ -0,0 +1,24 @@
+{
+  "language": "wgsl",
+  "implementationPatterns": [
+    {
+      "name": "Function",
+      "pattern": "^\\s*(?:@\\w+\\s+)*fn\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "function"
+    },
+    {
+      "name": "Struct",
+      "pattern": "^\\s*struct\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "struct"
+    },
+    {
+      "name": "Global",
+      "pattern": "^\\s*(?:@group\\(\\d+\\)\\s+@binding\\(\\d+\\)\\s+)?var(?:<[^>]+>)?\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "variable"
+    }
+  ],
+  "keywords": {}
+}

package/data/implementation/xml.json

@@ -1,7 +1,32 @@
-{
-  "language": "xml",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "xml",
+  "implementationPatterns": [
+    {
+      "pattern": "<(\\w[\\w:-]*)(?:\\s|>|/)",
+      "captureGroup": 1,
+      "type": "element",
+      "description": "XML element implementation"
+    },
+    {
+      "pattern": "(\\w[\\w:-]*)=[\"']",
+      "captureGroup": 1,
+      "type": "attribute",
+      "description": "XML attribute implementation"
+    },
+    {
+      "pattern": "xmlns(?::(\\w+))?=[\"']([^\"']+)[\"']",
+      "captureGroup": 2,
+      "type": "namespace",
+      "description": "XML namespace implementation"
+    },
+    {
+      "pattern": "<!DOCTYPE\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "doctype",
+      "description": "XML DOCTYPE implementation"
+    }
+  ],
+  "keywords": {
+    "note": "XML is a markup/data format with no interface/implementation constructs."
+  }
+}

package/data/implementation/yaml.json

@@ -1,7 +1,32 @@
-{
-  "language": "yaml",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "yaml",
+  "implementationPatterns": [
+    {
+      "pattern": "^\\s*(\\w[\\w-]*):",
+      "captureGroup": 1,
+      "type": "key",
+      "description": "YAML key implementation"
+    },
+    {
+      "pattern": "&(\\w[\\w-]*)",
+      "captureGroup": 1,
+      "type": "anchor",
+      "description": "YAML anchor implementation"
+    },
+    {
+      "pattern": "\\*(\\w[\\w-]*)",
+      "captureGroup": 1,
+      "type": "alias",
+      "description": "YAML alias implementation"
+    },
+    {
+      "pattern": "^---",
+      "captureGroup": 0,
+      "type": "document",
+      "description": "YAML document separator"
+    }
+  ],
+  "keywords": {
+    "note": "YAML is a data serialization format with no interface/implementation constructs."
+  }
+}

package/data/implementation/zsh.json

@@ -1,7 +1,41 @@
 {
   "language": "zsh",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Function",
+      "implementationKeyword": "function",
+      "pattern": "(?:function\\s+)?(\\w+)\\s*\\(\\s*\\)\\s*\\{",
+      "description": "Function definition"
+    },
+    {
+      "interface": "Widget",
+      "implementationKeyword": "zle",
+      "pattern": "zle\\s+-N\\s+(\\w+)",
+      "description": "ZLE widget registration"
+    },
+    {
+      "interface": "Completion",
+      "implementationKeyword": "compdef",
+      "pattern": "compdef\\s+(\\w+)",
+      "description": "Completion function binding"
+    },
+    {
+      "interface": "Autoload",
+      "implementationKeyword": "autoload",
+      "pattern": "autoload\\s+(?:-[Uz]+\\s+)*(\\w+)",
+      "description": "Autoloaded function"
+    }
+  ],
   "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
+    "interface": [
+      "autoload",
+      "zle -N",
+      "compdef"
+    ],
+    "implementation": [
+      "function",
+      "() {",
+      "autoload -Uz"
+    ]
   }
 }

package/data/inlayHints/abap.json

@@ -0,0 +1,39 @@
+{
+  "language": "abap",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(CALL\\s+METHOD|CALL\\s+FUNCTION)\\s+(\\w+)",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at ABAP method and function call sites"
+    },
+    {
+      "pattern": "DATA\\s+(\\w+)\\s+TYPE",
+      "kind": 1,
+      "label": ": {type}",
+      "position": "after_variable",
+      "paddingLeft": true,
+      "description": "Show inferred types for DATA declarations"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "'[^']*'",
+      "type": "string"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "number"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(ABAP_TRUE|ABAP_FALSE)\\b",
+      "type": "boolean"
+    },
+    "null_literal": {
+      "pattern": "\\b(INITIAL)\\b",
+      "type": "initial"
+    }
+  }
+}

package/data/inlayHints/apex.json

@@ -0,0 +1,43 @@
+{
+  "language": "apex",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(\\w+)\\s*\\(([^)]+)\\)",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at Apex method call sites"
+    },
+    {
+      "pattern": "var\\s+(\\w+)\\s*=",
+      "kind": 1,
+      "label": ": {type}",
+      "position": "after_variable",
+      "paddingLeft": true,
+      "description": "Show inferred types for var declarations"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "'[^']*'",
+      "type": "String"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "Integer"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "Boolean"
+    },
+    "null_literal": {
+      "pattern": "\\b(null)\\b",
+      "type": "null"
+    },
+    "array_literal": {
+      "pattern": "new\\s+List<",
+      "type": "List"
+    }
+  }
+}

package/data/inlayHints/azcli.json

@@ -0,0 +1,27 @@
+{
+  "language": "azcli",
+  "inlayHintPatterns": [
+    {
+      "pattern": "az\\s+[\\w-]+\\s+[\\w-]+",
+      "kind": 2,
+      "label": "--{param}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names for Azure CLI command arguments"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "\"[^\"]*\"|'[^']*'",
+      "type": "string"
+    },
+    "number_literal": {
+      "pattern": "\\d+",
+      "type": "integer"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "boolean"
+    }
+  }
+}

package/data/inlayHints/bicep.json

@@ -0,0 +1,47 @@
+{
+  "language": "bicep",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(\\w+)\\s*\\(([^)]+)\\)",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at Bicep function call sites"
+    },
+    {
+      "pattern": "var\\s+(\\w+)\\s*=",
+      "kind": 1,
+      "label": ": {type}",
+      "position": "after_variable",
+      "paddingLeft": true,
+      "description": "Show inferred types for var declarations"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "'[^']*'",
+      "type": "string"
+    },
+    "number_literal": {
+      "pattern": "\\d+",
+      "type": "int"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "bool"
+    },
+    "null_literal": {
+      "pattern": "\\b(null)\\b",
+      "type": "null"
+    },
+    "array_literal": {
+      "pattern": "\\[.*\\]",
+      "type": "array"
+    },
+    "object_literal": {
+      "pattern": "\\{.*\\}",
+      "type": "object"
+    }
+  }
+}

package/data/inlayHints/cameligo.json

@@ -0,0 +1,31 @@
+{
+  "language": "cameligo",
+  "inlayHintPatterns": [
+    {
+      "pattern": "let\\s+(\\w+)\\s*=",
+      "kind": 1,
+      "label": ": {type}",
+      "position": "after_variable",
+      "paddingLeft": true,
+      "description": "Show inferred types for let bindings"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "\"[^\"]*\"",
+      "type": "string"
+    },
+    "number_literal": {
+      "pattern": "\\d+",
+      "type": "int"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "bool"
+    },
+    "null_literal": {
+      "pattern": "\\b(unit)\\b",
+      "type": "unit"
+    }
+  }
+}

package/data/inlayHints/clojure.json

@@ -0,0 +1,51 @@
+{
+  "language": "clojure",
+  "inlayHintPatterns": [
+    {
+      "pattern": "\\((\\w[\\w-]*)\\s+",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at function call sites"
+    },
+    {
+      "pattern": "\\(def\\s+(\\w+)\\s+",
+      "kind": 1,
+      "label": ": {type}",
+      "position": "after_variable",
+      "paddingLeft": true,
+      "description": "Show inferred types for def bindings"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "\"[^\"]*\"",
+      "type": "String"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "Number"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "Boolean"
+    },
+    "null_literal": {
+      "pattern": "\\b(nil)\\b",
+      "type": "nil"
+    },
+    "keyword_literal": {
+      "pattern": ":[\\w-]+",
+      "type": "Keyword"
+    },
+    "vector_literal": {
+      "pattern": "\\[.*\\]",
+      "type": "PersistentVector"
+    },
+    "map_literal": {
+      "pattern": "\\{.*\\}",
+      "type": "PersistentHashMap"
+    }
+  }
+}

package/data/inlayHints/coffee.json

@@ -0,0 +1,39 @@
+{
+  "language": "coffee",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(\\w+)\\s*\\(([^)]+)\\)",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at function call sites"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "['\"].*['\"]",
+      "type": "string"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "number"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false|yes|no|on|off)\\b",
+      "type": "boolean"
+    },
+    "null_literal": {
+      "pattern": "\\b(null|undefined)\\b",
+      "type": "null"
+    },
+    "array_literal": {
+      "pattern": "\\[.*\\]",
+      "type": "Array"
+    },
+    "object_literal": {
+      "pattern": "\\{.*\\}",
+      "type": "Object"
+    }
+  }
+}

package/data/inlayHints/crontab.json

@@ -1,26 +1,27 @@
-{
-  "language": "crontab",
-  "inlayHintPatterns": [],
-  "typeInferenceRules": {
-    "string_literal": {
-      "pattern": "['\"].*['\"]",
-      "type": "string"
-    },
-    "number_literal": {
-      "pattern": "\\\\d+(\\\\.\\\\d+)?",
-      "type": "number"
-    },
-    "boolean_literal": {
-      "pattern": "\\\\b(true|false)\\\\b",
-      "type": "boolean"
-    },
-    "array_literal": {
-      "pattern": "\\\\[.*\\\\]",
-      "type": "array"
-    },
-    "null_literal": {
-      "pattern": "\\\\b(null)\\\\b",
-      "type": "null"
-    }
-  }
-}
+{
+  "language": "crontab",
+  "inlayHintPatterns": [
+    {
+      "pattern": "^(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)",
+      "kind": 2,
+      "label": "min hr dom mon dow",
+      "position": "above_line",
+      "paddingRight": true,
+      "description": "Show field position labels for cron expression fields"
+    }
+  ],
+  "typeInferenceRules": {
+    "number_literal": {
+      "pattern": "\\d+",
+      "type": "integer"
+    },
+    "range_literal": {
+      "pattern": "\\d+-\\d+",
+      "type": "range"
+    },
+    "step_literal": {
+      "pattern": "\\*/\\d+",
+      "type": "step"
+    }
+  }
+}

package/data/inlayHints/cypher.json

@@ -0,0 +1,31 @@
+{
+  "language": "cypher",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(\\w+)\\s*\\(([^)]+)\\)",
+      "kind": 2,
+      "label": "{param_name}:",
+      "position": "before_each_arg",
+      "paddingRight": true,
+      "description": "Show parameter names at Cypher function call sites"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "['\"].*['\"]",
+      "type": "String"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "Number"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(true|false)\\b",
+      "type": "Boolean"
+    },
+    "null_literal": {
+      "pattern": "\\b(null)\\b",
+      "type": "null"
+    }
+  }
+}

package/data/inlayHints/doctest.json

@@ -0,0 +1,31 @@
+{
+  "language": "doctest",
+  "inlayHintPatterns": [
+    {
+      "pattern": ">>>\\s+(.+)",
+      "kind": 1,
+      "label": "-> {type}",
+      "position": "after_expression",
+      "paddingLeft": true,
+      "description": "Show expected return type for doctest expressions"
+    }
+  ],
+  "typeInferenceRules": {
+    "string_literal": {
+      "pattern": "['\"].*['\"]",
+      "type": "str"
+    },
+    "number_literal": {
+      "pattern": "\\d+(\\.\\d+)?",
+      "type": "number"
+    },
+    "boolean_literal": {
+      "pattern": "\\b(True|False)\\b",
+      "type": "bool"
+    },
+    "null_literal": {
+      "pattern": "\\b(None)\\b",
+      "type": "NoneType"
+    }
+  }
+}