@enjoys/context-engine 1.1.0 → 1.1.1

package/data/hover/swift.json

@@ -0,0 +1,239 @@
+{
+  "language": "swift",
+  "hovers": {
+    "print": {
+      "contents": [{"value": "```swift\nfunc print(_ items: Any..., separator: String = \" \", terminator: String = \"\\n\")\n```\nWrites textual representations of the given items to standard output."}]
+    },
+    "debugPrint": {
+      "contents": [{"value": "```swift\nfunc debugPrint(_ items: Any..., separator: String = \" \", terminator: String = \"\\n\")\n```\nWrites debug textual representations of the given items to standard output."}]
+    },
+    "dump": {
+      "contents": [{"value": "```swift\nfunc dump<T>(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T\n```\nDumps an object's contents using its mirror to standard output."}]
+    },
+    "min": {
+      "contents": [{"value": "```swift\nfunc min<T: Comparable>(_ x: T, _ y: T) -> T\n```\nReturns the lesser of two comparable values."}]
+    },
+    "max": {
+      "contents": [{"value": "```swift\nfunc max<T: Comparable>(_ x: T, _ y: T) -> T\n```\nReturns the greater of two comparable values."}]
+    },
+    "abs": {
+      "contents": [{"value": "```swift\nfunc abs<T: Comparable & SignedNumeric>(_ x: T) -> T\n```\nReturns the absolute value of the given number."}]
+    },
+    "stride": {
+      "contents": [{"value": "```swift\nfunc stride<T>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T>\n```\nReturns a sequence from start to (but not including) end, stepping by the specified amount."}]
+    },
+    "zip": {
+      "contents": [{"value": "```swift\nfunc zip<Sequence1, Sequence2>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Zip2Sequence<Sequence1, Sequence2>\n```\nCreates a sequence of pairs built out of two underlying sequences."}]
+    },
+    "map": {
+      "contents": [{"value": "```swift\nfunc map<T>(_ transform: (Element) throws -> T) rethrows -> [T]\n```\nReturns an array containing the results of mapping the given closure over the sequence's elements."}]
+    },
+    "filter": {
+      "contents": [{"value": "```swift\nfunc filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]\n```\nReturns an array containing only the elements that satisfy the given predicate."}]
+    },
+    "reduce": {
+      "contents": [{"value": "```swift\nfunc reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result\n```\nReturns the result of combining the sequence's elements using the given closure."}]
+    },
+    "compactMap": {
+      "contents": [{"value": "```swift\nfunc compactMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]\n```\nReturns an array containing the non-nil results of calling the given transformation."}]
+    },
+    "flatMap": {
+      "contents": [{"value": "```swift\nfunc flatMap<SegmentOfResult: Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element]\n```\nReturns an array containing the concatenated results of calling the given transformation."}]
+    },
+    "sorted": {
+      "contents": [{"value": "```swift\nfunc sorted() -> [Element]\n```\nReturns the elements of the sequence, sorted."}]
+    },
+    "forEach": {
+      "contents": [{"value": "```swift\nfunc forEach(_ body: (Element) throws -> Void) rethrows\n```\nCalls the given closure on each element in the sequence in the same order as a for-in loop."}]
+    },
+    "contains": {
+      "contents": [{"value": "```swift\nfunc contains(_ element: Element) -> Bool\n```\nReturns a Boolean value indicating whether the sequence contains the given element."}]
+    },
+    "first": {
+      "contents": [{"value": "```swift\nvar first: Element? { get }\n```\nThe first element of the collection, or nil if the collection is empty."}]
+    },
+    "last": {
+      "contents": [{"value": "```swift\nvar last: Element? { get }\n```\nThe last element of the collection, or nil if the collection is empty."}]
+    },
+    "count": {
+      "contents": [{"value": "```swift\nvar count: Int { get }\n```\nThe number of elements in the collection."}]
+    },
+    "isEmpty": {
+      "contents": [{"value": "```swift\nvar isEmpty: Bool { get }\n```\nA Boolean value indicating whether the collection is empty."}]
+    },
+    "append": {
+      "contents": [{"value": "```swift\nmutating func append(_ newElement: Element)\n```\nAdds a new element at the end of the array."}]
+    },
+    "insert": {
+      "contents": [{"value": "```swift\nmutating func insert(_ newElement: Element, at i: Int)\n```\nInserts a new element at the specified position."}]
+    },
+    "remove": {
+      "contents": [{"value": "```swift\nmutating func remove(at index: Int) -> Element\n```\nRemoves and returns the element at the specified position."}]
+    },
+    "removeAll": {
+      "contents": [{"value": "```swift\nmutating func removeAll(keepingCapacity keepCapacity: Bool = false)\n```\nRemoves all elements from the array."}]
+    },
+    "enumerated": {
+      "contents": [{"value": "```swift\nfunc enumerated() -> EnumeratedSequence<Self>\n```\nReturns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero."}]
+    },
+    "prefix": {
+      "contents": [{"value": "```swift\nfunc prefix(_ maxLength: Int) -> Slice<Self>\n```\nReturns a subsequence, up to the specified maximum length, containing the initial elements."}]
+    },
+    "suffix": {
+      "contents": [{"value": "```swift\nfunc suffix(_ maxLength: Int) -> Slice<Self>\n```\nReturns a subsequence, up to the given maximum length, containing the final elements."}]
+    },
+    "joined": {
+      "contents": [{"value": "```swift\nfunc joined(separator: String = \"\") -> String\n```\nReturns a new string by concatenating the elements of the sequence, adding the given separator."}]
+    },
+    "split": {
+      "contents": [{"value": "```swift\nfunc split(separator: Character, maxSplits: Int = .max, omittingEmptySubsequences: Bool = true) -> [Substring]\n```\nReturns the longest possible subsequences of the collection, around elements equal to the given element."}]
+    },
+    "replacingOccurrences": {
+      "contents": [{"value": "```swift\nfunc replacingOccurrences(of target: String, with replacement: String) -> String\n```\nReturns a new string in which all occurrences of a target string are replaced by another given string."}]
+    },
+    "hasPrefix": {
+      "contents": [{"value": "```swift\nfunc hasPrefix(_ prefix: String) -> Bool\n```\nReturns a Boolean value indicating whether the string begins with the specified prefix."}]
+    },
+    "hasSuffix": {
+      "contents": [{"value": "```swift\nfunc hasSuffix(_ suffix: String) -> Bool\n```\nReturns a Boolean value indicating whether the string ends with the specified suffix."}]
+    },
+    "uppercased": {
+      "contents": [{"value": "```swift\nfunc uppercased() -> String\n```\nReturns an uppercased version of the string."}]
+    },
+    "lowercased": {
+      "contents": [{"value": "```swift\nfunc lowercased() -> String\n```\nReturns a lowercased version of the string."}]
+    },
+    "trimmingCharacters": {
+      "contents": [{"value": "```swift\nfunc trimmingCharacters(in set: CharacterSet) -> String\n```\nReturns a new string made by removing from both ends of the string characters contained in a given character set."}]
+    },
+    "precondition": {
+      "contents": [{"value": "```swift\nfunc precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = \"\")\n```\nChecks a necessary condition for making forward progress."}]
+    },
+    "assert": {
+      "contents": [{"value": "```swift\nfunc assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = \"\")\n```\nPerforms a traditional C-style assert with an optional message."}]
+    },
+    "fatalError": {
+      "contents": [{"value": "```swift\nfunc fatalError(_ message: @autoclosure () -> String = \"\") -> Never\n```\nUnconditionally prints a given message and stops execution."}]
+    },
+    "type(of:)": {
+      "contents": [{"value": "```swift\nfunc type<T>(of value: T) -> T.Type\n```\nReturns the dynamic type of a value."}]
+    },
+    "withAnimation": {
+      "contents": [{"value": "```swift\nfunc withAnimation<Result>(_ animation: Animation? = .default, _ body: () throws -> Result) rethrows -> Result\n```\nReturns the result of recomputing the view's body with the provided animation."}]
+    },
+    "Int": {
+      "contents": [{"value": "```swift\nstruct Int: FixedWidthInteger, SignedInteger\n```\nA signed integer value type."}]
+    },
+    "Double": {
+      "contents": [{"value": "```swift\nstruct Double: FloatingPoint\n```\nA double-precision, floating-point value type."}]
+    },
+    "Float": {
+      "contents": [{"value": "```swift\nstruct Float: FloatingPoint\n```\nA single-precision, floating-point value type."}]
+    },
+    "String": {
+      "contents": [{"value": "```swift\nstruct String: StringProtocol, Hashable, Codable\n```\nA Unicode string value."}]
+    },
+    "Bool": {
+      "contents": [{"value": "```swift\nstruct Bool: Sendable, Hashable, Codable\n```\nA value type whose instances are either true or false."}]
+    },
+    "Array": {
+      "contents": [{"value": "```swift\nstruct Array<Element>: RandomAccessCollection, MutableCollection\n```\nAn ordered, random-access collection."}]
+    },
+    "Dictionary": {
+      "contents": [{"value": "```swift\nstruct Dictionary<Key: Hashable, Value>: Collection\n```\nA collection whose elements are key-value pairs."}]
+    },
+    "Set": {
+      "contents": [{"value": "```swift\nstruct Set<Element: Hashable>: Collection\n```\nAn unordered collection of unique elements."}]
+    },
+    "Optional": {
+      "contents": [{"value": "```swift\nenum Optional<Wrapped>: ExpressibleByNilLiteral\n```\nA type that represents either a wrapped value or the absence of a value."}]
+    },
+    "Result": {
+      "contents": [{"value": "```swift\nenum Result<Success, Failure: Error>\n```\nA value that represents either a success or a failure, including an associated value in each case."}]
+    },
+    "Character": {
+      "contents": [{"value": "```swift\nstruct Character: Hashable, Sendable\n```\nA single extended grapheme cluster."}]
+    },
+    "Data": {
+      "contents": [{"value": "```swift\nstruct Data: Collection, ContiguousBytes, Hashable\n```\nA byte buffer in memory."}]
+    },
+    "URL": {
+      "contents": [{"value": "```swift\nstruct URL: Hashable, Equatable, Sendable\n```\nA value that identifies the location of a resource."}]
+    },
+    "Date": {
+      "contents": [{"value": "```swift\nstruct Date: Comparable, Hashable, Codable, Sendable\n```\nA specific point in time, independent of any calendar or time zone."}]
+    },
+    "Error": {
+      "contents": [{"value": "```swift\nprotocol Error\n```\nA type representing an error value that can be thrown."}]
+    },
+    "Codable": {
+      "contents": [{"value": "```swift\ntypealias Codable = Decodable & Encodable\n```\nA type that can convert itself into and out of an external representation."}]
+    },
+    "Hashable": {
+      "contents": [{"value": "```swift\nprotocol Hashable: Equatable\n```\nA type that can be hashed into a Hasher to produce an integer hash value."}]
+    },
+    "Equatable": {
+      "contents": [{"value": "```swift\nprotocol Equatable\n```\nA type that can be compared for value equality."}]
+    },
+    "Comparable": {
+      "contents": [{"value": "```swift\nprotocol Comparable: Equatable\n```\nA type that can be compared using the relational operators."}]
+    },
+    "Identifiable": {
+      "contents": [{"value": "```swift\nprotocol Identifiable {\n    associatedtype ID: Hashable\n    var id: ID { get }\n}\n```\nA class of types whose instances hold the value of an entity with stable identity."}]
+    },
+    "Sendable": {
+      "contents": [{"value": "```swift\nprotocol Sendable\n```\nA type whose values can safely be passed across concurrency domains by copying."}]
+    },
+    "AsyncSequence": {
+      "contents": [{"value": "```swift\nprotocol AsyncSequence\n```\nA type that provides asynchronous, sequential, iterated access to its elements."}]
+    },
+    "Task": {
+      "contents": [{"value": "```swift\nstruct Task<Success: Sendable, Failure: Error>\n```\nA unit of asynchronous work."}]
+    },
+    "Void": {
+      "contents": [{"value": "```swift\ntypealias Void = ()\n```\nThe return type of functions that don't explicitly specify a return type."}]
+    },
+    "Never": {
+      "contents": [{"value": "```swift\nenum Never\n```\nThe return type of functions that do not return normally; a type with no values."}]
+    },
+    "Any": {
+      "contents": [{"value": "The protocol to which all types implicitly conform."}]
+    },
+    "AnyObject": {
+      "contents": [{"value": "```swift\nprotocol AnyObject\n```\nThe protocol to which all classes implicitly conform."}]
+    },
+    "AnyHashable": {
+      "contents": [{"value": "```swift\nstruct AnyHashable: Hashable\n```\nA type-erased hashable value."}]
+    },
+    "Range": {
+      "contents": [{"value": "```swift\nstruct Range<Bound: Comparable>\n```\nA half-open interval from a lower bound up to, but not including, an upper bound."}]
+    },
+    "ClosedRange": {
+      "contents": [{"value": "```swift\nstruct ClosedRange<Bound: Comparable>\n```\nAn interval from a lower bound up to, and including, an upper bound."}]
+    },
+    "Sequence": {
+      "contents": [{"value": "```swift\nprotocol Sequence\n```\nA type that provides sequential, iterated access to its elements."}]
+    },
+    "Collection": {
+      "contents": [{"value": "```swift\nprotocol Collection: Sequence\n```\nA sequence whose elements can be traversed multiple times and accessed by indexed subscript."}]
+    },
+    "JSONDecoder": {
+      "contents": [{"value": "```swift\nclass JSONDecoder\n```\nAn object that decodes instances of a data type from JSON objects."}]
+    },
+    "JSONEncoder": {
+      "contents": [{"value": "```swift\nclass JSONEncoder\n```\nAn object that encodes instances of a data type as JSON objects."}]
+    },
+    "URLSession": {
+      "contents": [{"value": "```swift\nclass URLSession\n```\nAn object that coordinates a group of related network data transfer tasks."}]
+    },
+    "DispatchQueue": {
+      "contents": [{"value": "```swift\nclass DispatchQueue: DispatchObject\n```\nAn object that manages the execution of work items serially or concurrently."}]
+    },
+    "NotificationCenter": {
+      "contents": [{"value": "```swift\nclass NotificationCenter\n```\nA notification dispatch mechanism that enables the broadcast of information to registered observers."}]
+    },
+    "UserDefaults": {
+      "contents": [{"value": "```swift\nclass UserDefaults\n```\nAn interface to the user's defaults database for persistent key-value storage."}]
+    }
+  }
+}

package/data/implementation/dart.json

@@ -0,0 +1,14 @@
+{
+  "language": "dart",
+  "implementationPatterns": [
+    {"interface": "Interface", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*(?:extends\\s+\\w+\\s*)?implements\\s+\\w+", "description": "Classes implementing interfaces"},
+    {"interface": "AbstractClass", "implementationKeyword": "extends", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*extends\\s+\\w+", "description": "Classes extending abstract classes"},
+    {"interface": "Mixin", "implementationKeyword": "with", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*(?:extends\\s+\\w+\\s*)?with\\s+\\w+", "description": "Classes applying mixins with 'with' keyword"},
+    {"interface": "SealedClass", "implementationKeyword": "extends", "pattern": "(?:class|sealed\\s+class)\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*extends\\s+\\w+", "description": "Sealed class subtypes"},
+    {"interface": "MixinOn", "implementationKeyword": "on", "pattern": "mixin\\s+(\\w+)\\s+on\\s+\\w+", "description": "Mixin with superclass constraint"}
+  ],
+  "keywords": {
+    "interface": ["abstract class", "sealed class", "interface class", "mixin", "mixin class"],
+    "implementation": ["class", "enum", "extension type", "mixin class"]
+  }
+}

package/data/implementation/docker-compose.json

@@ -0,0 +1,7 @@
+{
+  "language": "docker-compose",
+  "implementationPatterns": [],
+  "keywords": {
+    "note": "Docker Compose (YAML configuration) does not have explicit interface/implementation constructs"
+  }
+}

package/data/implementation/kotlin.json

@@ -0,0 +1,13 @@
+{
+  "language": "kotlin",
+  "implementationPatterns": [
+    {"interface": "Interface", "implementationKeyword": ":", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+", "description": "Classes implementing interfaces"},
+    {"interface": "AbstractClass", "implementationKeyword": ":", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+\\s*\\(", "description": "Classes extending abstract classes"},
+    {"interface": "Sealed", "implementationKeyword": ":", "pattern": "(?:class|object|data\\s+class)\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+", "description": "Sealed class/interface implementations"},
+    {"interface": "FunInterface", "implementationKeyword": "fun interface", "pattern": "fun\\s+interface\\s+(\\w+)", "description": "Functional interface declarations"}
+  ],
+  "keywords": {
+    "interface": ["interface", "abstract class", "sealed class", "sealed interface", "fun interface"],
+    "implementation": ["class", "object", "data class", "enum class", "value class"]
+  }
+}

package/data/implementation/scala.json

@@ -0,0 +1,16 @@
+{
+  "language": "scala",
+  "implementationPatterns": [
+    {"interface": "Trait", "implementationKeyword": "extends", "pattern": "(?:class|object|enum)\\s+(\\w+)\\s*(?:\\([^)]*\\))?\\s*extends\\s+(\\w+)", "description": "Class/object extending a trait or class"},
+    {"interface": "Trait Mixin", "implementationKeyword": "with", "pattern": "(?:class|object|trait)\\s+(\\w+)\\s*(?:\\([^)]*\\))?\\s*(?:extends\\s+\\w+\\s+)?with\\s+(\\w+)", "description": "Mixing in additional traits with 'with' keyword"},
+    {"interface": "Abstract Class", "implementationKeyword": "extends", "pattern": "class\\s+(\\w+)\\s*(?:\\([^)]*\\))?\\s*extends\\s+(?:abstract\\s+)?class\\s+(\\w+)", "description": "Concrete class extending an abstract class"},
+    {"interface": "Sealed Trait", "implementationKeyword": "extends", "pattern": "(?:case\\s+)?(?:class|object)\\s+(\\w+)\\s*(?:\\([^)]*\\))?\\s*extends\\s+(\\w+)", "description": "Case classes/objects extending a sealed trait"},
+    {"interface": "Enum Case", "implementationKeyword": "extends", "pattern": "case\\s+(\\w+)\\s+extends\\s+(\\w+)", "description": "Enum case extending the enum type"},
+    {"interface": "Given Implementation", "implementationKeyword": "given", "pattern": "given\\s+(?:\\w+\\s*:\\s*)?(\\w+)\\s*(?:\\[.*?\\])?\\s+with", "description": "Given instance implementing a type class"},
+    {"interface": "Self Type", "implementationKeyword": "=>", "pattern": "(?:trait|class)\\s+\\w+\\s*\\{\\s*(?:\\w+\\s*:)?\\s*(\\w+)\\s*=>", "description": "Self-type annotation requiring a trait"}
+  ],
+  "keywords": {
+    "interface": ["trait", "abstract class", "sealed trait", "sealed abstract class", "enum"],
+    "implementation": ["class", "case class", "object", "case object", "enum case", "given"]
+  }
+}

package/data/implementation/swift.json

@@ -0,0 +1,14 @@
+{
+  "language": "swift",
+  "implementationPatterns": [
+    {"interface": "Protocol", "implementationKeyword": ":", "pattern": "(?:class|struct|enum|actor)\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+", "description": "Types conforming to protocols"},
+    {"interface": "Class", "implementationKeyword": ":", "pattern": "class\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+", "description": "Classes inheriting from a superclass"},
+    {"interface": "Extension", "implementationKeyword": "extension", "pattern": "extension\\s+(\\w+)\\s*:\\s*\\w+", "description": "Extensions adding protocol conformance"},
+    {"interface": "ProtocolExtension", "implementationKeyword": "extension", "pattern": "extension\\s+(\\w+)\\s*(?:where\\s+[^{]+)?\\s*\\{", "description": "Protocol extensions providing default implementations"},
+    {"interface": "Actor", "implementationKeyword": "actor", "pattern": "actor\\s+(\\w+)\\s*(?:<[^>]*>)?\\s*:\\s*\\w+", "description": "Actors conforming to protocols"}
+  ],
+  "keywords": {
+    "interface": ["protocol", "class", "actor"],
+    "implementation": ["class", "struct", "enum", "actor", "extension"]
+  }
+}

package/data/inlayHints/dart.json

@@ -0,0 +1,29 @@
+{
+  "language": "dart",
+  "inlayHintPatterns": [
+    {"pattern": "(?:var|final)\\s+(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for var/final variable assignments"},
+    {"pattern": "(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "{param_name}:", "position": "before_each_arg", "paddingRight": true, "description": "Show parameter names at call sites"},
+    {"pattern": "(?:var|final)\\s+(\\w+)\\s+in\\s+", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred element type in for-in loops"},
+    {"pattern": "=>\\s+(.+);", "kind": 1, "label": "-> {inferred_type}", "position": "after_arrow", "paddingLeft": true, "description": "Show return type for expression-body functions"},
+    {"pattern": "\\(\\s*(\\w+)\\s*\\)\\s*=>", "kind": 1, "label": ": {inferred_type}", "position": "after_param", "paddingLeft": true, "description": "Show inferred closure parameter types"},
+    {"pattern": "\\.(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "{param_name}:", "position": "before_each_arg", "paddingRight": true, "description": "Show parameter names at method call sites"},
+    {"pattern": "late\\s+(?:final\\s+)?(\\w+)\\s*;", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show type for late variables without explicit type"}
+  ],
+  "typeInferenceRules": {
+    "string_literal": {"pattern": "'[^']*'|\"[^\"]*\"", "type": "String"},
+    "multiline_string": {"pattern": "'''[\\s\\S]*?'''|\"\"\"[\\s\\S]*?\"\"\"", "type": "String"},
+    "int_literal": {"pattern": "\\b\\d+\\b(?!\\.)", "type": "int"},
+    "double_literal": {"pattern": "\\b\\d+\\.\\d+\\b", "type": "double"},
+    "boolean_literal": {"pattern": "\\b(true|false)\\b", "type": "bool"},
+    "null_literal": {"pattern": "\\bnull\\b", "type": "Null"},
+    "list_literal": {"pattern": "\\[", "type": "List<T>"},
+    "const_list": {"pattern": "const\\s*\\[", "type": "List<T>"},
+    "map_literal": {"pattern": "\\{\\s*\\w+\\s*:", "type": "Map<K, V>"},
+    "set_literal": {"pattern": "\\{\\s*[^:]+\\s*\\}", "type": "Set<T>"},
+    "record_literal": {"pattern": "\\(\\s*\\w+\\s*,", "type": "(T1, T2)"},
+    "future_expression": {"pattern": "\\bawait\\s+", "type": "Future<T>"},
+    "stream_expression": {"pattern": "\\byield\\s+", "type": "Stream<T>"},
+    "constructor_call": {"pattern": "\\b[A-Z]\\w*\\s*\\(", "type": "{constructor_class}"},
+    "cascade": {"pattern": "\\.\\.", "type": "{cascade_target}"}
+  }
+}

package/data/inlayHints/docker-compose.json

@@ -0,0 +1,43 @@
+{
+  "language": "docker-compose",
+  "inlayHintPatterns": [
+    {
+      "pattern": "(?:environment):\\s*\\n\\s+(\\w+)\\s*[:=]\\s*(.+)",
+      "kind": 1,
+      "label": ": {inferred_type}",
+      "position": "after_capture_1",
+      "paddingLeft": true,
+      "description": "Show inferred type for environment variable values"
+    }
+  ],
+  "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"
+    },
+    "duration_literal": {
+      "pattern": "\\d+[smh]",
+      "type": "duration"
+    },
+    "bytes_literal": {
+      "pattern": "\\d+[bBkKmMgG]",
+      "type": "bytes"
+    }
+  }
+}

package/data/inlayHints/kotlin.json

@@ -0,0 +1,23 @@
+{
+  "language": "kotlin",
+  "inlayHintPatterns": [
+    {"pattern": "(?:val|var)\\s+(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for variable assignments"},
+    {"pattern": "(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "{param_name}:", "position": "before_each_arg", "paddingRight": true, "description": "Show parameter names at call sites"},
+    {"pattern": "fun\\s+\\w+\\([^)]*\\)\\s*=\\s*", "kind": 1, "label": ": {inferred_type}", "position": "after_equals", "paddingLeft": true, "description": "Show return type for expression functions"},
+    {"pattern": "\\blambda\\b|\\{\\s*\\w+\\s*->", "kind": 1, "label": ": {inferred_type}", "position": "after_param", "paddingLeft": true, "description": "Show lambda parameter types"}
+  ],
+  "typeInferenceRules": {
+    "string_literal": {"pattern": "\".*\"", "type": "String"},
+    "number_literal": {"pattern": "\\d+(\\.\\d+)?", "type": "Int"},
+    "long_literal": {"pattern": "\\d+L", "type": "Long"},
+    "float_literal": {"pattern": "\\d+\\.\\d+[fF]", "type": "Float"},
+    "double_literal": {"pattern": "\\d+\\.\\d+(?!f)", "type": "Double"},
+    "boolean_literal": {"pattern": "\\b(true|false)\\b", "type": "Boolean"},
+    "char_literal": {"pattern": "'.'", "type": "Char"},
+    "null_literal": {"pattern": "\\bnull\\b", "type": "Nothing?"},
+    "list_literal": {"pattern": "listOf\\(", "type": "List<T>"},
+    "map_literal": {"pattern": "mapOf\\(", "type": "Map<K, V>"},
+    "set_literal": {"pattern": "setOf\\(", "type": "Set<T>"},
+    "array_literal": {"pattern": "arrayOf\\(", "type": "Array<T>"}
+  }
+}

package/data/inlayHints/scala.json

@@ -0,0 +1,42 @@
+{
+  "language": "scala",
+  "inlayHintPatterns": [
+    {"pattern": "val\\s+(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for val assignments without explicit type"},
+    {"pattern": "var\\s+(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for var assignments without explicit type"},
+    {"pattern": "def\\s+(\\w+)(?:\\([^)]*\\))*\\s*=\\s*(?!\\{)", "kind": 1, "label": ": {inferred_type}", "position": "after_params", "paddingLeft": true, "description": "Show inferred return type for methods without explicit annotation"},
+    {"pattern": "(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "{param_name}:", "position": "before_each_arg", "paddingRight": true, "description": "Show parameter names at function call sites"},
+    {"pattern": "for\\s*\\{?\\s*(\\w+)\\s*<-", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type of generator variable in for-comprehension"},
+    {"pattern": "case\\s+(\\w+)\\s*=>", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type of pattern match variable"},
+    {"pattern": "\\b(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "(implicit {implicit_name})", "position": "after_args", "paddingLeft": true, "description": "Show implicit parameters being passed at call sites"},
+    {"pattern": "\\.map\\s*\\(\\s*(\\w+)\\s*=>", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type of lambda parameter"},
+    {"pattern": "\\.flatMap\\s*\\(\\s*(\\w+)\\s*=>", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type of flatMap lambda parameter"},
+    {"pattern": "\\.filter\\s*\\(\\s*(\\w+)\\s*=>", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type of filter lambda parameter"},
+    {"pattern": "lazy\\s+val\\s+(\\w+)\\s*=", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for lazy val without explicit type"}
+  ],
+  "typeInferenceRules": {
+    "string_literal": {"pattern": "\"[^\"]*\"", "type": "String"},
+    "multiline_string": {"pattern": "\"\"\"[\\s\\S]*?\"\"\"", "type": "String"},
+    "interpolated_string": {"pattern": "[sf]\"[^\"]*\"", "type": "String"},
+    "int_literal": {"pattern": "\\b\\d+\\b(?![.LlFfDd])", "type": "Int"},
+    "long_literal": {"pattern": "\\b\\d+[Ll]\\b", "type": "Long"},
+    "float_literal": {"pattern": "\\b\\d+\\.\\d+[Ff]\\b", "type": "Float"},
+    "double_literal": {"pattern": "\\b\\d+\\.\\d+\\b(?![Ff])", "type": "Double"},
+    "boolean_literal": {"pattern": "\\b(true|false)\\b", "type": "Boolean"},
+    "char_literal": {"pattern": "'[^']'", "type": "Char"},
+    "null_literal": {"pattern": "\\bnull\\b", "type": "Null"},
+    "list_literal": {"pattern": "List\\s*\\(", "type": "List[T]"},
+    "map_literal": {"pattern": "Map\\s*\\(", "type": "Map[K, V]"},
+    "set_literal": {"pattern": "Set\\s*\\(", "type": "Set[T]"},
+    "vector_literal": {"pattern": "Vector\\s*\\(", "type": "Vector[T]"},
+    "array_literal": {"pattern": "Array\\s*\\(", "type": "Array[T]"},
+    "option_some": {"pattern": "Some\\s*\\(", "type": "Option[T]"},
+    "option_none": {"pattern": "\\bNone\\b", "type": "Option[Nothing]"},
+    "tuple_literal": {"pattern": "\\(\\s*[^)]+\\s*,", "type": "(T1, T2, ...)"},
+    "future_expr": {"pattern": "Future\\s*[{(]", "type": "Future[T]"},
+    "try_expr": {"pattern": "Try\\s*[{(]", "type": "Try[T]"},
+    "right_expr": {"pattern": "Right\\s*\\(", "type": "Either[Nothing, T]"},
+    "left_expr": {"pattern": "Left\\s*\\(", "type": "Either[T, Nothing]"},
+    "constructor_call": {"pattern": "new\\s+[A-Z]\\w*", "type": "{constructor_class}"},
+    "range_expr": {"pattern": "\\d+\\s+(?:to|until)\\s+\\d+", "type": "Range"}
+  }
+}

package/data/inlayHints/swift.json

@@ -0,0 +1,37 @@
+{
+  "language": "swift",
+  "inlayHintPatterns": [
+    {"pattern": "(?:let|var)\\s+(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show inferred type for variable/constant assignments"},
+    {"pattern": "(\\w+)\\s*\\(([^)]+)\\)", "kind": 2, "label": "{param_name}:", "position": "before_each_arg", "paddingRight": true, "description": "Show parameter names at call sites"},
+    {"pattern": "func\\s+\\w+\\([^)]*\\)\\s*->\\s*some\\s+\\w+\\s*\\{", "kind": 1, "label": "// opaque: {inferred_type}", "position": "end_of_line", "paddingLeft": true, "description": "Show concrete type behind opaque return type"},
+    {"pattern": "func\\s+\\w+\\([^)]*\\)\\s*\\{", "kind": 1, "label": "-> Void", "position": "before_brace", "paddingLeft": true, "description": "Show implicit Void return type"},
+    {"pattern": "\\{\\s*(\\w+)\\s*in", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show closure parameter types"},
+    {"pattern": "\\.map\\s*\\{|\\. filter\\s*\\{|\\.compactMap\\s*\\{|\\.flatMap\\s*\\{|\\.reduce\\s*\\(|\\.sorted\\s*\\{|\\.forEach\\s*\\{", "kind": 1, "label": "-> {inferred_type}", "position": "end_of_line", "paddingLeft": true, "description": "Show return type of chained collection operations"},
+    {"pattern": "case\\s+\\.(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show enum case associated value types"}
+  ],
+  "typeInferenceRules": {
+    "string_literal": {"pattern": "\".*\"", "type": "String"},
+    "multiline_string": {"pattern": "\"\"\"[\\s\\S]*?\"\"\"", "type": "String"},
+    "integer_literal": {"pattern": "\\b\\d+\\b", "type": "Int"},
+    "double_literal": {"pattern": "\\b\\d+\\.\\d+\\b", "type": "Double"},
+    "float_literal": {"pattern": "\\b\\d+\\.\\d+[fF]\\b", "type": "Float"},
+    "boolean_literal": {"pattern": "\\b(true|false)\\b", "type": "Bool"},
+    "nil_literal": {"pattern": "\\bnil\\b", "type": "Optional"},
+    "character_literal": {"pattern": "Character\\(\"[^\"]*\"\\)", "type": "Character"},
+    "array_literal": {"pattern": "\\[.*\\]", "type": "[Element]"},
+    "dictionary_literal": {"pattern": "\\[.*:.*\\]", "type": "[Key: Value]"},
+    "empty_array": {"pattern": "\\[\\s*\\]", "type": "[Any]"},
+    "empty_dictionary": {"pattern": "\\[\\s*:\\s*\\]", "type": "[AnyHashable: Any]"},
+    "tuple_literal": {"pattern": "\\(.*,.*\\)", "type": "(T1, T2)"},
+    "optional_chaining": {"pattern": "\\w+\\?\\.", "type": "Optional<T>"},
+    "string_interpolation": {"pattern": "\".*\\\\\\(.*\\).*\"", "type": "String"},
+    "range_literal": {"pattern": "\\d+\\.\\.<\\d+", "type": "Range<Int>"},
+    "closed_range_literal": {"pattern": "\\d+\\.\\.\\.\\d+", "type": "ClosedRange<Int>"},
+    "url_init": {"pattern": "URL\\(string:\\s*\"[^\"]+\"\\)", "type": "URL?"},
+    "data_init": {"pattern": "Data\\(", "type": "Data"},
+    "date_init": {"pattern": "Date\\(", "type": "Date"},
+    "task_init": {"pattern": "Task\\s*\\{", "type": "Task<Void, Never>"},
+    "result_success": {"pattern": "\\.success\\(", "type": "Result<Success, Failure>"},
+    "result_failure": {"pattern": "\\.failure\\(", "type": "Result<Success, Failure>"}
+  }
+}

package/data/inlineCompletions/dart.json

@@ -0,0 +1,27 @@
+{
+  "language": "dart",
+  "inlineCompletions": [
+    {"triggerPattern": "^\\s*void\\s+main\\s*$", "insertText": "void main() {\n  ${1:print('Hello, Dart!');}\n}", "description": "Main function", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*class\\s+\\w+\\s*$", "insertText": "class ${1:Name} {\n  final ${2:String} ${3:field};\n\n  const ${1:Name}({required this.${3:field}});\n\n  $0\n}", "description": "Class with constructor", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*for\\s*$", "insertText": "for (final ${1:item} in ${2:items}) {\n  $0\n}", "description": "For-in loop", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*if\\s*$", "insertText": "if (${1:condition}) {\n  $0\n}", "description": "If statement", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*try\\s*$", "insertText": "try {\n  ${1:// code}\n} on ${2:Exception} catch (e) {\n  ${3:print(e);}\n}", "description": "Try-catch block", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*Future\\s*$", "insertText": "Future<${1:void}> ${2:name}() async {\n  $0\n}", "description": "Async function returning Future", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*Stream\\s*$", "insertText": "Stream<${1:int}> ${2:name}() async* {\n  yield ${3:value};\n}", "description": "Stream generator function", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*switch\\s*\\(", "insertText": "switch (${1:value}) {\n  case ${2:pattern}:\n    $0\n    break;\n  default:\n    break;\n}", "description": "Switch statement", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*final\\s+\\w+\\s*=\\s*switch\\s*$", "insertText": "final ${1:result} = switch (${2:value}) {\n  ${3:pattern} => ${4:expr},\n  _ => ${5:default},\n};", "description": "Switch expression", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*extension\\s+\\w+\\s*$", "insertText": "extension ${1:Name} on ${2:Type} {\n  ${3:ReturnType} ${4:method}() {\n    $0\n  }\n}", "description": "Extension declaration", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*mixin\\s+\\w+\\s*$", "insertText": "mixin ${1:Name} {\n  ${2:void} ${3:method}() {\n    $0\n  }\n}", "description": "Mixin declaration", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*sealed\\s+class\\s*$", "insertText": "sealed class ${1:Name} {}\n\nclass ${2:SubType} extends ${1:Name} {\n  final ${3:String} ${4:value};\n  const ${2:SubType}(this.${4:value});\n}", "description": "Sealed class hierarchy", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*enum\\s+\\w+\\s*$", "insertText": "enum ${1:Name} {\n  ${2:value1}('${3:label1}'),\n  ${4:value2}('${5:label2}');\n\n  final String ${6:label};\n  const ${1:Name}(this.${6:label});\n}", "description": "Enhanced enum with values", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*factory\\s*$", "insertText": "factory ${1:ClassName}.${2:named}(${3:params}) {\n  return ${4:instance};\n}", "description": "Factory constructor", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*class\\s+\\w+\\s+extends\\s+StatelessWidget\\s*$", "insertText": "class ${1:MyWidget} extends StatelessWidget {\n  const ${1:MyWidget}({super.key});\n\n  @override\n  Widget build(BuildContext context) {\n    return ${2:Container()};\n  }\n}", "description": "Stateless widget", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*class\\s+\\w+\\s+extends\\s+StatefulWidget\\s*$", "insertText": "class ${1:MyWidget} extends StatefulWidget {\n  const ${1:MyWidget}({super.key});\n\n  @override\n  State<${1:MyWidget}> createState() => _${1:MyWidget}State();\n}\n\nclass _${1:MyWidget}State extends State<${1:MyWidget}> {\n  @override\n  Widget build(BuildContext context) {\n    return ${2:Container()};\n  }\n}", "description": "Stateful widget with State class", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*test\\s*$", "insertText": "test('${1:description}', () {\n  $0\n});", "description": "Test case", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*group\\s*$", "insertText": "group('${1:description}', () {\n  $0\n});", "description": "Test group", "completeBracketPairs": true},
+    {"triggerPattern": "^\\s*typedef\\s*$", "insertText": "typedef ${1:Name} = ${2:Type};", "description": "Type alias", "completeBracketPairs": true},
+    {"triggerPattern": "\\.then\\s*$", "insertText": ".then((${1:value}) {\n  $0\n})", "description": "Future then callback", "completeBracketPairs": true},
+    {"triggerPattern": "\\.map\\s*$", "insertText": ".map((${1:e}) => ${2:e})", "description": "Map iterable elements", "completeBracketPairs": true},
+    {"triggerPattern": "\\.where\\s*$", "insertText": ".where((${1:e}) => ${2:condition})", "description": "Filter iterable elements", "completeBracketPairs": true}
+  ]
+}